Commit | Line | Data |
---|---|---|
3aefb79a MCC |
1 | /* |
2 | DVB device driver for em28xx | |
3 | ||
4 | (c) 2008 Mauro Carvalho Chehab <mchehab@infradead.org> | |
5 | ||
bdfbf952 DH |
6 | (c) 2008 Devin Heitmueller <devin.heitmueller@gmail.com> |
7 | - Fixes for the driver to properly work with HVR-950 | |
8 | ||
3421b778 AT |
9 | (c) 2008 Aidan Thornton <makosoft@googlemail.com> |
10 | ||
11 | Based on cx88-dvb, saa7134-dvb and videobuf-dvb originally written by: | |
3aefb79a MCC |
12 | (c) 2004, 2005 Chris Pascoe <c.pascoe@itee.uq.edu.au> |
13 | (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs] | |
14 | ||
15 | This program is free software; you can redistribute it and/or modify | |
16 | it under the terms of the GNU General Public License as published by | |
17 | the Free Software Foundation; either version 2 of the License. | |
18 | */ | |
19 | ||
20 | #include <linux/kernel.h> | |
21 | #include <linux/usb.h> | |
22 | ||
23 | #include "em28xx.h" | |
24 | #include <media/v4l2-common.h> | |
25 | #include <media/videobuf-vmalloc.h> | |
26 | ||
27 | #include "lgdt330x.h" | |
7e6388a1 | 28 | #include "zl10353.h" |
3aefb79a MCC |
29 | |
30 | MODULE_DESCRIPTION("driver for em28xx based DVB cards"); | |
31 | MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>"); | |
32 | MODULE_LICENSE("GPL"); | |
33 | ||
34 | static unsigned int debug; | |
35 | module_param(debug, int, 0644); | |
36 | MODULE_PARM_DESC(debug, "enable debug messages [dvb]"); | |
37 | ||
38 | DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); | |
39 | ||
40 | #define dprintk(level, fmt, arg...) do { \ | |
41 | if (debug >= level) \ | |
3421b778 | 42 | printk(KERN_DEBUG "%s/2-dvb: " fmt, dev->name, ## arg); \ |
3aefb79a MCC |
43 | } while (0) |
44 | ||
3421b778 AT |
45 | #define EM28XX_DVB_NUM_BUFS 5 |
46 | #define EM28XX_DVB_MAX_PACKETSIZE 564 | |
47 | #define EM28XX_DVB_MAX_PACKETS 64 | |
48 | ||
49 | struct em28xx_dvb { | |
50 | struct dvb_frontend *frontend; | |
51 | ||
52 | /* feed count management */ | |
53 | struct mutex lock; | |
54 | int nfeeds; | |
55 | ||
56 | /* general boilerplate stuff */ | |
57 | struct dvb_adapter adapter; | |
58 | struct dvb_demux demux; | |
59 | struct dmxdev dmxdev; | |
60 | struct dmx_frontend fe_hw; | |
61 | struct dmx_frontend fe_mem; | |
62 | struct dvb_net net; | |
63 | }; | |
64 | ||
65 | ||
66 | static inline void print_err_status(struct em28xx *dev, | |
67 | int packet, int status) | |
3aefb79a | 68 | { |
3421b778 | 69 | char *errmsg = "Unknown"; |
3aefb79a | 70 | |
3421b778 AT |
71 | switch (status) { |
72 | case -ENOENT: | |
73 | errmsg = "unlinked synchronuously"; | |
74 | break; | |
75 | case -ECONNRESET: | |
76 | errmsg = "unlinked asynchronuously"; | |
77 | break; | |
78 | case -ENOSR: | |
79 | errmsg = "Buffer error (overrun)"; | |
80 | break; | |
81 | case -EPIPE: | |
82 | errmsg = "Stalled (device not responding)"; | |
83 | break; | |
84 | case -EOVERFLOW: | |
85 | errmsg = "Babble (bad cable?)"; | |
86 | break; | |
87 | case -EPROTO: | |
88 | errmsg = "Bit-stuff error (bad cable?)"; | |
89 | break; | |
90 | case -EILSEQ: | |
91 | errmsg = "CRC/Timeout (could be anything)"; | |
92 | break; | |
93 | case -ETIME: | |
94 | errmsg = "Device does not respond"; | |
95 | break; | |
96 | } | |
97 | if (packet < 0) { | |
98 | dprintk(1, "URB status %d [%s].\n", status, errmsg); | |
99 | } else { | |
6ea54d93 DSL |
100 | dprintk(1, "URB packet %d, status %d [%s].\n", |
101 | packet, status, errmsg); | |
3421b778 AT |
102 | } |
103 | } | |
3aefb79a | 104 | |
3421b778 AT |
105 | static inline int dvb_isoc_copy(struct em28xx *dev, struct urb *urb) |
106 | { | |
107 | int i; | |
3aefb79a | 108 | |
3421b778 AT |
109 | if (!dev) |
110 | return 0; | |
3aefb79a | 111 | |
3421b778 AT |
112 | if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED)) |
113 | return 0; | |
114 | ||
115 | if (urb->status < 0) { | |
116 | print_err_status(dev, -1, urb->status); | |
117 | if (urb->status == -ENOENT) | |
118 | return 0; | |
119 | } | |
120 | ||
121 | for (i = 0; i < urb->number_of_packets; i++) { | |
122 | int status = urb->iso_frame_desc[i].status; | |
123 | ||
124 | if (status < 0) { | |
125 | print_err_status(dev, i, status); | |
126 | if (urb->iso_frame_desc[i].status != -EPROTO) | |
127 | continue; | |
128 | } | |
129 | ||
130 | dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer + | |
131 | urb->iso_frame_desc[i].offset, | |
132 | urb->iso_frame_desc[i].actual_length); | |
133 | } | |
134 | ||
135 | return 0; | |
136 | } | |
137 | ||
6ea54d93 DSL |
138 | static int start_streaming(struct em28xx_dvb *dvb) |
139 | { | |
3421b778 AT |
140 | struct em28xx *dev = dvb->adapter.priv; |
141 | ||
142 | usb_set_interface(dev->udev, 0, 1); | |
6ea54d93 | 143 | dev->em28xx_write_regs_req(dev, 0x00, 0x48, "\x00", 1); |
3421b778 AT |
144 | |
145 | return em28xx_init_isoc(dev, EM28XX_DVB_MAX_PACKETS, | |
146 | EM28XX_DVB_NUM_BUFS, EM28XX_DVB_MAX_PACKETSIZE, | |
147 | dvb_isoc_copy, EM28XX_DIGITAL_CAPTURE); | |
148 | } | |
149 | ||
6ea54d93 DSL |
150 | static int stop_streaming(struct em28xx_dvb *dvb) |
151 | { | |
3421b778 AT |
152 | struct em28xx *dev = dvb->adapter.priv; |
153 | ||
154 | em28xx_uninit_isoc(dev); | |
3aefb79a MCC |
155 | return 0; |
156 | } | |
157 | ||
3421b778 AT |
158 | static int start_feed(struct dvb_demux_feed *feed) |
159 | { | |
160 | struct dvb_demux *demux = feed->demux; | |
161 | struct em28xx_dvb *dvb = demux->priv; | |
162 | int rc, ret; | |
163 | ||
164 | if (!demux->dmx.frontend) | |
165 | return -EINVAL; | |
166 | ||
167 | mutex_lock(&dvb->lock); | |
168 | dvb->nfeeds++; | |
169 | rc = dvb->nfeeds; | |
170 | ||
171 | if (dvb->nfeeds == 1) { | |
172 | ret = start_streaming(dvb); | |
6ea54d93 DSL |
173 | if (ret < 0) |
174 | rc = ret; | |
3421b778 AT |
175 | } |
176 | ||
177 | mutex_unlock(&dvb->lock); | |
178 | return rc; | |
179 | } | |
180 | ||
181 | static int stop_feed(struct dvb_demux_feed *feed) | |
182 | { | |
183 | struct dvb_demux *demux = feed->demux; | |
184 | struct em28xx_dvb *dvb = demux->priv; | |
185 | int err = 0; | |
186 | ||
187 | mutex_lock(&dvb->lock); | |
188 | dvb->nfeeds--; | |
6ea54d93 DSL |
189 | |
190 | if (0 == dvb->nfeeds) | |
3421b778 | 191 | err = stop_streaming(dvb); |
6ea54d93 | 192 | |
3421b778 AT |
193 | mutex_unlock(&dvb->lock); |
194 | return err; | |
195 | } | |
196 | ||
197 | ||
3aefb79a MCC |
198 | /* ------------------------------------------------------------------ */ |
199 | ||
227ad4ab MCC |
200 | static struct lgdt330x_config em2880_lgdt3303_dev = { |
201 | .demod_address = 0x0e, | |
202 | .demod_chip = LGDT3303, | |
203 | }; | |
3aefb79a | 204 | |
7e6388a1 AT |
205 | static struct zl10353_config em28xx_zl10353_with_xc3028 = { |
206 | .demod_address = (0x1e >> 1), | |
207 | .no_tuner = 1, | |
208 | .parallel_ts = 1, | |
209 | .if2 = 45600, | |
210 | }; | |
211 | ||
3aefb79a MCC |
212 | /* ------------------------------------------------------------------ */ |
213 | ||
214 | static int attach_xc3028(u8 addr, struct em28xx *dev) | |
215 | { | |
216 | struct dvb_frontend *fe; | |
3ca9c093 MCC |
217 | struct xc2028_config cfg; |
218 | ||
6ea54d93 | 219 | memset(&cfg, 0, sizeof(cfg)); |
3ca9c093 MCC |
220 | cfg.i2c_adap = &dev->i2c_adap; |
221 | cfg.i2c_addr = addr; | |
3ca9c093 MCC |
222 | cfg.callback = em28xx_tuner_callback; |
223 | ||
3421b778 | 224 | if (!dev->dvb->frontend) { |
3aefb79a MCC |
225 | printk(KERN_ERR "%s/2: dvb frontend not attached. " |
226 | "Can't attach xc3028\n", | |
227 | dev->name); | |
228 | return -EINVAL; | |
229 | } | |
230 | ||
3421b778 | 231 | fe = dvb_attach(xc2028_attach, dev->dvb->frontend, &cfg); |
3aefb79a MCC |
232 | if (!fe) { |
233 | printk(KERN_ERR "%s/2: xc3028 attach failed\n", | |
234 | dev->name); | |
3421b778 AT |
235 | dvb_frontend_detach(dev->dvb->frontend); |
236 | dvb_unregister_frontend(dev->dvb->frontend); | |
237 | dev->dvb->frontend = NULL; | |
3aefb79a MCC |
238 | return -EINVAL; |
239 | } | |
240 | ||
241 | printk(KERN_INFO "%s/2: xc3028 attached\n", dev->name); | |
242 | ||
243 | return 0; | |
244 | } | |
245 | ||
3421b778 AT |
246 | /* ------------------------------------------------------------------ */ |
247 | ||
248 | int register_dvb(struct em28xx_dvb *dvb, | |
249 | struct module *module, | |
250 | struct em28xx *dev, | |
251 | struct device *device) | |
3aefb79a | 252 | { |
3421b778 | 253 | int result; |
3aefb79a | 254 | |
3421b778 | 255 | mutex_init(&dvb->lock); |
3aefb79a | 256 | |
3421b778 AT |
257 | /* register adapter */ |
258 | result = dvb_register_adapter(&dvb->adapter, dev->name, module, device, | |
259 | adapter_nr); | |
260 | if (result < 0) { | |
261 | printk(KERN_WARNING "%s: dvb_register_adapter failed (errno = %d)\n", | |
262 | dev->name, result); | |
263 | goto fail_adapter; | |
264 | } | |
265 | dvb->adapter.priv = dev; | |
266 | ||
267 | /* register frontend */ | |
268 | result = dvb_register_frontend(&dvb->adapter, dvb->frontend); | |
269 | if (result < 0) { | |
270 | printk(KERN_WARNING "%s: dvb_register_frontend failed (errno = %d)\n", | |
271 | dev->name, result); | |
272 | goto fail_frontend; | |
273 | } | |
274 | ||
275 | /* register demux stuff */ | |
276 | dvb->demux.dmx.capabilities = | |
277 | DMX_TS_FILTERING | DMX_SECTION_FILTERING | | |
278 | DMX_MEMORY_BASED_FILTERING; | |
279 | dvb->demux.priv = dvb; | |
280 | dvb->demux.filternum = 256; | |
281 | dvb->demux.feednum = 256; | |
282 | dvb->demux.start_feed = start_feed; | |
283 | dvb->demux.stop_feed = stop_feed; | |
284 | result = dvb_dmx_init(&dvb->demux); | |
285 | if (result < 0) { | |
286 | printk(KERN_WARNING "%s: dvb_dmx_init failed (errno = %d)\n", | |
287 | dev->name, result); | |
288 | goto fail_dmx; | |
289 | } | |
290 | ||
291 | dvb->dmxdev.filternum = 256; | |
292 | dvb->dmxdev.demux = &dvb->demux.dmx; | |
293 | dvb->dmxdev.capabilities = 0; | |
294 | result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter); | |
295 | if (result < 0) { | |
296 | printk(KERN_WARNING "%s: dvb_dmxdev_init failed (errno = %d)\n", | |
297 | dev->name, result); | |
298 | goto fail_dmxdev; | |
299 | } | |
52284c3e | 300 | |
3421b778 AT |
301 | dvb->fe_hw.source = DMX_FRONTEND_0; |
302 | result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw); | |
303 | if (result < 0) { | |
304 | printk(KERN_WARNING "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n", | |
305 | dev->name, result); | |
306 | goto fail_fe_hw; | |
307 | } | |
308 | ||
309 | dvb->fe_mem.source = DMX_MEMORY_FE; | |
310 | result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem); | |
311 | if (result < 0) { | |
312 | printk(KERN_WARNING "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n", | |
313 | dev->name, result); | |
314 | goto fail_fe_mem; | |
315 | } | |
316 | ||
317 | result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw); | |
318 | if (result < 0) { | |
319 | printk(KERN_WARNING "%s: connect_frontend failed (errno = %d)\n", | |
320 | dev->name, result); | |
321 | goto fail_fe_conn; | |
322 | } | |
323 | ||
324 | /* register network adapter */ | |
325 | dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx); | |
326 | return 0; | |
327 | ||
328 | fail_fe_conn: | |
329 | dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem); | |
330 | fail_fe_mem: | |
331 | dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw); | |
332 | fail_fe_hw: | |
333 | dvb_dmxdev_release(&dvb->dmxdev); | |
334 | fail_dmxdev: | |
335 | dvb_dmx_release(&dvb->demux); | |
336 | fail_dmx: | |
337 | dvb_unregister_frontend(dvb->frontend); | |
338 | fail_frontend: | |
339 | dvb_frontend_detach(dvb->frontend); | |
340 | dvb_unregister_adapter(&dvb->adapter); | |
341 | fail_adapter: | |
342 | return result; | |
343 | } | |
344 | ||
345 | static void unregister_dvb(struct em28xx_dvb *dvb) | |
346 | { | |
347 | dvb_net_release(&dvb->net); | |
348 | dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem); | |
349 | dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw); | |
350 | dvb_dmxdev_release(&dvb->dmxdev); | |
351 | dvb_dmx_release(&dvb->demux); | |
352 | dvb_unregister_frontend(dvb->frontend); | |
353 | dvb_frontend_detach(dvb->frontend); | |
354 | dvb_unregister_adapter(&dvb->adapter); | |
355 | } | |
356 | ||
357 | ||
358 | static int dvb_init(struct em28xx *dev) | |
359 | { | |
360 | int result = 0; | |
361 | struct em28xx_dvb *dvb; | |
362 | ||
363 | dvb = kzalloc(sizeof(struct em28xx_dvb), GFP_KERNEL); | |
6ea54d93 DSL |
364 | |
365 | if (dvb == NULL) { | |
366 | printk(KERN_INFO "em28xx_dvb: memory allocation failed\n"); | |
3421b778 AT |
367 | return -ENOMEM; |
368 | } | |
369 | dev->dvb = dvb; | |
3aefb79a MCC |
370 | |
371 | /* init frontend */ | |
372 | switch (dev->model) { | |
227ad4ab MCC |
373 | case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_950: |
374 | /* Enable lgdt330x */ | |
bdfbf952 | 375 | dev->mode = EM28XX_DIGITAL_MODE; |
227ad4ab MCC |
376 | em28xx_tuner_callback(dev, XC2028_TUNER_RESET, 0); |
377 | ||
3421b778 AT |
378 | dvb->frontend = dvb_attach(lgdt330x_attach, |
379 | &em2880_lgdt3303_dev, | |
380 | &dev->i2c_adap); | |
381 | if (attach_xc3028(0x61, dev) < 0) { | |
382 | result = -EINVAL; | |
383 | goto out_free; | |
384 | } | |
227ad4ab | 385 | break; |
7e6388a1 AT |
386 | case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900: |
387 | /* Enable zl10353 */ | |
388 | dev->mode = EM28XX_DIGITAL_MODE; | |
389 | em28xx_tuner_callback(dev, XC2028_TUNER_RESET, 0); | |
3421b778 AT |
390 | dvb->frontend = dvb_attach(zl10353_attach, |
391 | &em28xx_zl10353_with_xc3028, | |
392 | &dev->i2c_adap); | |
393 | if (attach_xc3028(0x61, dev) < 0) { | |
394 | result = -EINVAL; | |
395 | goto out_free; | |
396 | } | |
7e6388a1 | 397 | break; |
3aefb79a MCC |
398 | default: |
399 | printk(KERN_ERR "%s/2: The frontend of your DVB/ATSC card" | |
400 | " isn't supported yet\n", | |
401 | dev->name); | |
402 | break; | |
403 | } | |
3421b778 | 404 | if (NULL == dvb->frontend) { |
3aefb79a MCC |
405 | printk(KERN_ERR |
406 | "%s/2: frontend initialization failed\n", | |
407 | dev->name); | |
3421b778 AT |
408 | result = -EINVAL; |
409 | goto out_free; | |
3aefb79a MCC |
410 | } |
411 | ||
412 | /* register everything */ | |
3421b778 AT |
413 | result = register_dvb(dvb, THIS_MODULE, dev, &dev->udev->dev); |
414 | ||
6ea54d93 | 415 | if (result < 0) |
3421b778 | 416 | goto out_free; |
3421b778 | 417 | |
102a0b08 | 418 | printk(KERN_INFO "Successfully loaded em28xx-dvb\n"); |
3421b778 AT |
419 | return 0; |
420 | ||
421 | out_free: | |
422 | kfree(dvb); | |
423 | dev->dvb = NULL; | |
424 | return result; | |
3aefb79a MCC |
425 | } |
426 | ||
427 | static int dvb_fini(struct em28xx *dev) | |
428 | { | |
3421b778 AT |
429 | if (dev->dvb) { |
430 | unregister_dvb(dev->dvb); | |
431 | dev->dvb = NULL; | |
432 | } | |
3aefb79a MCC |
433 | |
434 | return 0; | |
435 | } | |
436 | ||
437 | static struct em28xx_ops dvb_ops = { | |
438 | .id = EM28XX_DVB, | |
439 | .name = "Em28xx dvb Extension", | |
440 | .init = dvb_init, | |
441 | .fini = dvb_fini, | |
442 | }; | |
443 | ||
444 | static int __init em28xx_dvb_register(void) | |
445 | { | |
446 | return em28xx_register_extension(&dvb_ops); | |
447 | } | |
448 | ||
449 | static void __exit em28xx_dvb_unregister(void) | |
450 | { | |
451 | em28xx_unregister_extension(&dvb_ops); | |
452 | } | |
453 | ||
454 | module_init(em28xx_dvb_register); | |
455 | module_exit(em28xx_dvb_unregister); |