Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 1 | /* |
| 2 | * flexcop.c - driver for digital TV devices equipped with B2C2 FlexcopII(b)/III |
| 3 | * |
| 4 | * Copyright (C) 2004-5 Patrick Boettcher <patrick.boettcher@desy.de> |
| 5 | * |
| 6 | * based on the skystar2-driver |
| 7 | * Copyright (C) 2003 Vadim Catana, skystar@moldova.cc |
| 8 | * |
| 9 | * Acknowledgements: |
| 10 | * John Jurrius from BBTI, Inc. for extensive support with |
| 11 | * code examples and data books |
| 12 | * |
| 13 | * Bjarne Steinsbo, bjarne at steinsbo.com (some ideas for rewriting) |
| 14 | * |
| 15 | * Contributions to the skystar2-driver have been done by |
| 16 | * Vincenzo Di Massa, hawk.it at tiscalinet.it (several DiSEqC fixes) |
| 17 | * Roberto Ragusa, r.ragusa at libero.it (polishing, restyling the code) |
| 18 | * Niklas Peinecke, peinecke at gdv.uni-hannover.de (hardware pid/mac filtering) |
| 19 | * |
| 20 | * |
| 21 | * This program is free software; you can redistribute it and/or |
| 22 | * modify it under the terms of the GNU Lesser General Public License |
| 23 | * as published by the Free Software Foundation; either version 2.1 |
| 24 | * of the License, or (at your option) any later version. |
| 25 | * |
| 26 | * This program is distributed in the hope that it will be useful, |
| 27 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 28 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 29 | * GNU General Public License for more details. |
| 30 | * |
| 31 | * You should have received a copy of the GNU Lesser General Public License |
| 32 | * along with this program; if not, write to the Free Software |
| 33 | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| 34 | */ |
| 35 | |
| 36 | #include "flexcop.h" |
| 37 | |
| 38 | #define DRIVER_NAME "B2C2 FlexcopII/II(b)/III digital TV receiver chip" |
| 39 | #define DRIVER_AUTHOR "Patrick Boettcher <patrick.boettcher@desy.de" |
| 40 | |
| 41 | #ifdef CONFIG_DVB_B2C2_FLEXCOP_DEBUG |
| 42 | #define DEBSTATUS "" |
| 43 | #else |
| 44 | #define DEBSTATUS " (debugging is not enabled)" |
| 45 | #endif |
| 46 | |
| 47 | int b2c2_flexcop_debug; |
| 48 | module_param_named(debug, b2c2_flexcop_debug, int, 0644); |
Patrick Boettcher | 64221be | 2005-07-07 17:57:49 -0700 | [diff] [blame] | 49 | MODULE_PARM_DESC(debug, "set debug level (1=info,2=tuner,4=i2c,8=ts,16=sram,32=reg (|-able))." DEBSTATUS); |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 50 | #undef DEBSTATUS |
| 51 | |
| 52 | /* global zero for ibi values */ |
| 53 | flexcop_ibi_value ibi_zero; |
| 54 | |
| 55 | static int flexcop_dvb_start_feed(struct dvb_demux_feed *dvbdmxfeed) |
| 56 | { |
| 57 | struct flexcop_device *fc = dvbdmxfeed->demux->priv; |
| 58 | return flexcop_pid_feed_control(fc,dvbdmxfeed,1); |
| 59 | } |
| 60 | |
| 61 | static int flexcop_dvb_stop_feed(struct dvb_demux_feed *dvbdmxfeed) |
| 62 | { |
| 63 | struct flexcop_device *fc = dvbdmxfeed->demux->priv; |
| 64 | return flexcop_pid_feed_control(fc,dvbdmxfeed,0); |
| 65 | } |
| 66 | |
| 67 | static int flexcop_dvb_init(struct flexcop_device *fc) |
| 68 | { |
| 69 | int ret; |
Johannes Stezenbach | 59a7ad6 | 2005-05-16 21:54:16 -0700 | [diff] [blame] | 70 | if ((ret = dvb_register_adapter(&fc->dvb_adapter,"FlexCop Digital TV device",fc->owner)) < 0) { |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 71 | err("error registering DVB adapter"); |
| 72 | return ret; |
| 73 | } |
| 74 | fc->dvb_adapter.priv = fc; |
| 75 | |
| 76 | fc->demux.dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING); |
| 77 | fc->demux.priv = fc; |
| 78 | |
| 79 | fc->demux.filternum = fc->demux.feednum = FC_MAX_FEED; |
| 80 | |
| 81 | fc->demux.start_feed = flexcop_dvb_start_feed; |
| 82 | fc->demux.stop_feed = flexcop_dvb_stop_feed; |
| 83 | fc->demux.write_to_decoder = NULL; |
| 84 | |
| 85 | if ((ret = dvb_dmx_init(&fc->demux)) < 0) { |
| 86 | err("dvb_dmx failed: error %d",ret); |
| 87 | goto err_dmx; |
| 88 | } |
| 89 | |
| 90 | fc->hw_frontend.source = DMX_FRONTEND_0; |
| 91 | |
| 92 | fc->dmxdev.filternum = fc->demux.feednum; |
| 93 | fc->dmxdev.demux = &fc->demux.dmx; |
| 94 | fc->dmxdev.capabilities = 0; |
| 95 | if ((ret = dvb_dmxdev_init(&fc->dmxdev, &fc->dvb_adapter)) < 0) { |
| 96 | err("dvb_dmxdev_init failed: error %d",ret); |
| 97 | goto err_dmx_dev; |
| 98 | } |
| 99 | |
| 100 | if ((ret = fc->demux.dmx.add_frontend(&fc->demux.dmx, &fc->hw_frontend)) < 0) { |
| 101 | err("adding hw_frontend to dmx failed: error %d",ret); |
| 102 | goto err_dmx_add_hw_frontend; |
| 103 | } |
| 104 | |
| 105 | fc->mem_frontend.source = DMX_MEMORY_FE; |
| 106 | if ((ret = fc->demux.dmx.add_frontend(&fc->demux.dmx, &fc->mem_frontend)) < 0) { |
| 107 | err("adding mem_frontend to dmx failed: error %d",ret); |
| 108 | goto err_dmx_add_mem_frontend; |
| 109 | } |
| 110 | |
| 111 | if ((ret = fc->demux.dmx.connect_frontend(&fc->demux.dmx, &fc->hw_frontend)) < 0) { |
| 112 | err("connect frontend failed: error %d",ret); |
| 113 | goto err_connect_frontend; |
| 114 | } |
| 115 | |
| 116 | dvb_net_init(&fc->dvb_adapter, &fc->dvbnet, &fc->demux.dmx); |
| 117 | |
| 118 | fc->init_state |= FC_STATE_DVB_INIT; |
| 119 | goto success; |
| 120 | |
| 121 | err_connect_frontend: |
| 122 | fc->demux.dmx.remove_frontend(&fc->demux.dmx,&fc->mem_frontend); |
| 123 | err_dmx_add_mem_frontend: |
| 124 | fc->demux.dmx.remove_frontend(&fc->demux.dmx,&fc->hw_frontend); |
| 125 | err_dmx_add_hw_frontend: |
| 126 | dvb_dmxdev_release(&fc->dmxdev); |
| 127 | err_dmx_dev: |
| 128 | dvb_dmx_release(&fc->demux); |
| 129 | err_dmx: |
| 130 | dvb_unregister_adapter(&fc->dvb_adapter); |
| 131 | return ret; |
| 132 | |
| 133 | success: |
| 134 | return 0; |
| 135 | } |
| 136 | |
| 137 | static void flexcop_dvb_exit(struct flexcop_device *fc) |
| 138 | { |
| 139 | if (fc->init_state & FC_STATE_DVB_INIT) { |
| 140 | dvb_net_release(&fc->dvbnet); |
| 141 | |
| 142 | fc->demux.dmx.close(&fc->demux.dmx); |
| 143 | fc->demux.dmx.remove_frontend(&fc->demux.dmx,&fc->mem_frontend); |
| 144 | fc->demux.dmx.remove_frontend(&fc->demux.dmx,&fc->hw_frontend); |
| 145 | dvb_dmxdev_release(&fc->dmxdev); |
| 146 | dvb_dmx_release(&fc->demux); |
| 147 | dvb_unregister_adapter(&fc->dvb_adapter); |
| 148 | |
| 149 | deb_info("deinitialized dvb stuff\n"); |
| 150 | } |
| 151 | fc->init_state &= ~FC_STATE_DVB_INIT; |
| 152 | } |
| 153 | |
| 154 | /* these methods are necessary to achieve the long-term-goal of hiding the |
| 155 | * struct flexcop_device from the bus-parts */ |
| 156 | void flexcop_pass_dmx_data(struct flexcop_device *fc, u8 *buf, u32 len) |
| 157 | { |
| 158 | dvb_dmx_swfilter(&fc->demux, buf, len); |
| 159 | } |
| 160 | EXPORT_SYMBOL(flexcop_pass_dmx_data); |
| 161 | |
| 162 | void flexcop_pass_dmx_packets(struct flexcop_device *fc, u8 *buf, u32 no) |
| 163 | { |
| 164 | dvb_dmx_swfilter_packets(&fc->demux, buf, no); |
| 165 | } |
| 166 | EXPORT_SYMBOL(flexcop_pass_dmx_packets); |
| 167 | |
| 168 | static void flexcop_reset(struct flexcop_device *fc) |
| 169 | { |
| 170 | flexcop_ibi_value v210,v204; |
| 171 | |
| 172 | /* reset the flexcop itself */ |
| 173 | fc->write_ibi_reg(fc,ctrl_208,ibi_zero); |
| 174 | |
| 175 | v210.raw = 0; |
Patrick Boettcher | 64221be | 2005-07-07 17:57:49 -0700 | [diff] [blame] | 176 | v210.sw_reset_210.reset_block_000 = 1; |
| 177 | v210.sw_reset_210.reset_block_100 = 1; |
| 178 | v210.sw_reset_210.reset_block_200 = 1; |
| 179 | v210.sw_reset_210.reset_block_300 = 1; |
| 180 | v210.sw_reset_210.reset_block_400 = 1; |
| 181 | v210.sw_reset_210.reset_block_500 = 1; |
| 182 | v210.sw_reset_210.reset_block_600 = 1; |
| 183 | v210.sw_reset_210.reset_block_700 = 1; |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 184 | v210.sw_reset_210.Block_reset_enable = 0xb2; |
Patrick Boettcher | 64221be | 2005-07-07 17:57:49 -0700 | [diff] [blame] | 185 | |
| 186 | v210.sw_reset_210.Special_controls = 0xc259; |
| 187 | |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 188 | fc->write_ibi_reg(fc,sw_reset_210,v210); |
Patrick Boettcher | 64221be | 2005-07-07 17:57:49 -0700 | [diff] [blame] | 189 | msleep(1); |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 190 | |
| 191 | /* reset the periphical devices */ |
| 192 | |
| 193 | v204 = fc->read_ibi_reg(fc,misc_204); |
| 194 | v204.misc_204.Per_reset_sig = 0; |
| 195 | fc->write_ibi_reg(fc,misc_204,v204); |
Michael Krufky | c0b11b9 | 2005-11-08 21:35:32 -0800 | [diff] [blame] | 196 | msleep(1); |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 197 | v204.misc_204.Per_reset_sig = 1; |
| 198 | fc->write_ibi_reg(fc,misc_204,v204); |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 199 | } |
| 200 | |
Patrick Boettcher | 64221be | 2005-07-07 17:57:49 -0700 | [diff] [blame] | 201 | void flexcop_reset_block_300(struct flexcop_device *fc) |
| 202 | { |
| 203 | flexcop_ibi_value v208_save = fc->read_ibi_reg(fc,ctrl_208), |
| 204 | v210 = fc->read_ibi_reg(fc,sw_reset_210); |
| 205 | |
| 206 | deb_rdump("208: %08x, 210: %08x\n",v208_save.raw,v210.raw); |
| 207 | |
| 208 | fc->write_ibi_reg(fc,ctrl_208,ibi_zero); |
| 209 | |
| 210 | v210.sw_reset_210.reset_block_300 = 1; |
| 211 | v210.sw_reset_210.Block_reset_enable = 0xb2; |
| 212 | |
| 213 | fc->write_ibi_reg(fc,sw_reset_210,v210); |
| 214 | msleep(1); |
| 215 | |
| 216 | fc->write_ibi_reg(fc,ctrl_208,v208_save); |
| 217 | } |
| 218 | EXPORT_SYMBOL(flexcop_reset_block_300); |
| 219 | |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 220 | struct flexcop_device *flexcop_device_kmalloc(size_t bus_specific_len) |
| 221 | { |
| 222 | void *bus; |
Panagiotis Issaris | 7408187 | 2006-01-11 19:40:56 -0200 | [diff] [blame] | 223 | struct flexcop_device *fc = kzalloc(sizeof(struct flexcop_device), GFP_KERNEL); |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 224 | if (!fc) { |
| 225 | err("no memory"); |
| 226 | return NULL; |
| 227 | } |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 228 | |
Panagiotis Issaris | 7408187 | 2006-01-11 19:40:56 -0200 | [diff] [blame] | 229 | bus = kzalloc(bus_specific_len, GFP_KERNEL); |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 230 | if (!bus) { |
| 231 | err("no memory"); |
| 232 | kfree(fc); |
| 233 | return NULL; |
| 234 | } |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 235 | |
| 236 | fc->bus_specific = bus; |
| 237 | |
| 238 | return fc; |
| 239 | } |
| 240 | EXPORT_SYMBOL(flexcop_device_kmalloc); |
| 241 | |
| 242 | void flexcop_device_kfree(struct flexcop_device *fc) |
| 243 | { |
| 244 | kfree(fc->bus_specific); |
| 245 | kfree(fc); |
| 246 | } |
| 247 | EXPORT_SYMBOL(flexcop_device_kfree); |
| 248 | |
| 249 | int flexcop_device_initialize(struct flexcop_device *fc) |
| 250 | { |
| 251 | int ret; |
| 252 | ibi_zero.raw = 0; |
| 253 | |
| 254 | flexcop_reset(fc); |
| 255 | flexcop_determine_revision(fc); |
| 256 | flexcop_sram_init(fc); |
| 257 | flexcop_hw_filter_init(fc); |
| 258 | |
| 259 | flexcop_smc_ctrl(fc, 0); |
| 260 | |
Johannes Stezenbach | 7782413 | 2005-05-16 21:54:14 -0700 | [diff] [blame] | 261 | if ((ret = flexcop_dvb_init(fc))) |
| 262 | goto error; |
| 263 | |
| 264 | /* do the MAC address reading after initializing the dvb_adapter */ |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 265 | if (fc->get_mac_addr(fc, 0) == 0) { |
Johannes Stezenbach | 7782413 | 2005-05-16 21:54:14 -0700 | [diff] [blame] | 266 | u8 *b = fc->dvb_adapter.proposed_mac; |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 267 | info("MAC address = %02x:%02x:%02x:%02x:%02x:%02x", b[0],b[1],b[2],b[3],b[4],b[5]); |
Johannes Stezenbach | 7782413 | 2005-05-16 21:54:14 -0700 | [diff] [blame] | 268 | flexcop_set_mac_filter(fc,b); |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 269 | flexcop_mac_filter_ctrl(fc,1); |
| 270 | } else |
| 271 | warn("reading of MAC address failed.\n"); |
| 272 | |
Johannes Stezenbach | 2add87a | 2005-05-16 21:54:10 -0700 | [diff] [blame] | 273 | |
| 274 | if ((ret = flexcop_i2c_init(fc))) |
| 275 | goto error; |
| 276 | |
| 277 | if ((ret = flexcop_frontend_init(fc))) |
| 278 | goto error; |
| 279 | |
| 280 | flexcop_device_name(fc,"initialization of","complete"); |
| 281 | |
| 282 | ret = 0; |
| 283 | goto success; |
| 284 | error: |
| 285 | flexcop_device_exit(fc); |
| 286 | success: |
| 287 | return ret; |
| 288 | } |
| 289 | EXPORT_SYMBOL(flexcop_device_initialize); |
| 290 | |
| 291 | void flexcop_device_exit(struct flexcop_device *fc) |
| 292 | { |
| 293 | flexcop_frontend_exit(fc); |
| 294 | flexcop_i2c_exit(fc); |
| 295 | flexcop_dvb_exit(fc); |
| 296 | } |
| 297 | EXPORT_SYMBOL(flexcop_device_exit); |
| 298 | |
| 299 | static int flexcop_module_init(void) |
| 300 | { |
| 301 | info(DRIVER_NAME " loaded successfully"); |
| 302 | return 0; |
| 303 | } |
| 304 | |
| 305 | static void flexcop_module_cleanup(void) |
| 306 | { |
| 307 | info(DRIVER_NAME " unloaded successfully"); |
| 308 | } |
| 309 | |
| 310 | module_init(flexcop_module_init); |
| 311 | module_exit(flexcop_module_cleanup); |
| 312 | |
| 313 | MODULE_AUTHOR(DRIVER_AUTHOR); |
| 314 | MODULE_DESCRIPTION(DRIVER_NAME); |
| 315 | MODULE_LICENSE("GPL"); |