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