1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/init.h>
24#include <linux/list.h>
25#include <linux/module.h>
26#include <linux/slab.h>
27#include <linux/usb.h>
28#include <linux/vmalloc.h>
29#include <media/v4l2-common.h>
30#include <media/tuner.h>
31
32#include "cx231xx.h"
33#include "cx231xx-reg.h"
34
35
36
37static unsigned int core_debug;
38module_param(core_debug, int, 0644);
39MODULE_PARM_DESC(core_debug, "enable debug messages [core]");
40
41#define cx231xx_coredbg(fmt, arg...) do {\
42 if (core_debug) \
43 printk(KERN_INFO "%s %s :"fmt, \
44 dev->name, __func__ , ##arg); } while (0)
45
46static unsigned int reg_debug;
47module_param(reg_debug, int, 0644);
48MODULE_PARM_DESC(reg_debug, "enable debug messages [URB reg]");
49
50static int alt = CX231XX_PINOUT;
51module_param(alt, int, 0644);
52MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
53
54#define cx231xx_isocdbg(fmt, arg...) do {\
55 if (core_debug) \
56 printk(KERN_INFO "%s %s :"fmt, \
57 dev->name, __func__ , ##arg); } while (0)
58
59
60
61
62
63LIST_HEAD(cx231xx_devlist);
64static DEFINE_MUTEX(cx231xx_devlist_mutex);
65
66
67
68
69
70
71void cx231xx_remove_from_devlist(struct cx231xx *dev)
72{
73 if (dev == NULL)
74 return;
75 if (dev->udev == NULL)
76 return;
77
78 if (atomic_read(&dev->devlist_count) > 0) {
79 mutex_lock(&cx231xx_devlist_mutex);
80 list_del(&dev->devlist);
81 atomic_dec(&dev->devlist_count);
82 mutex_unlock(&cx231xx_devlist_mutex);
83 }
84};
85
86void cx231xx_add_into_devlist(struct cx231xx *dev)
87{
88 mutex_lock(&cx231xx_devlist_mutex);
89 list_add_tail(&dev->devlist, &cx231xx_devlist);
90 atomic_inc(&dev->devlist_count);
91 mutex_unlock(&cx231xx_devlist_mutex);
92};
93
94static LIST_HEAD(cx231xx_extension_devlist);
95
96int cx231xx_register_extension(struct cx231xx_ops *ops)
97{
98 struct cx231xx *dev = NULL;
99
100 mutex_lock(&cx231xx_devlist_mutex);
101 list_add_tail(&ops->next, &cx231xx_extension_devlist);
102 list_for_each_entry(dev, &cx231xx_devlist, devlist)
103 ops->init(dev);
104
105 printk(KERN_INFO DRIVER_NAME ": %s initialized\n", ops->name);
106 mutex_unlock(&cx231xx_devlist_mutex);
107 return 0;
108}
109EXPORT_SYMBOL(cx231xx_register_extension);
110
111void cx231xx_unregister_extension(struct cx231xx_ops *ops)
112{
113 struct cx231xx *dev = NULL;
114
115 mutex_lock(&cx231xx_devlist_mutex);
116 list_for_each_entry(dev, &cx231xx_devlist, devlist)
117 ops->fini(dev);
118
119
120 printk(KERN_INFO DRIVER_NAME ": %s removed\n", ops->name);
121 list_del(&ops->next);
122 mutex_unlock(&cx231xx_devlist_mutex);
123}
124EXPORT_SYMBOL(cx231xx_unregister_extension);
125
126void cx231xx_init_extension(struct cx231xx *dev)
127{
128 struct cx231xx_ops *ops = NULL;
129
130 mutex_lock(&cx231xx_devlist_mutex);
131 if (!list_empty(&cx231xx_extension_devlist)) {
132 list_for_each_entry(ops, &cx231xx_extension_devlist, next) {
133 if (ops->init)
134 ops->init(dev);
135 }
136 }
137 mutex_unlock(&cx231xx_devlist_mutex);
138}
139
140void cx231xx_close_extension(struct cx231xx *dev)
141{
142 struct cx231xx_ops *ops = NULL;
143
144 mutex_lock(&cx231xx_devlist_mutex);
145 if (!list_empty(&cx231xx_extension_devlist)) {
146 list_for_each_entry(ops, &cx231xx_extension_devlist, next) {
147 if (ops->fini)
148 ops->fini(dev);
149 }
150 }
151 mutex_unlock(&cx231xx_devlist_mutex);
152}
153
154
155
156
157int cx231xx_send_usb_command(struct cx231xx_i2c *i2c_bus,
158 struct cx231xx_i2c_xfer_data *req_data)
159{
160 int status = 0;
161 struct cx231xx *dev = i2c_bus->dev;
162 struct VENDOR_REQUEST_IN ven_req;
163
164 u8 saddr_len = 0;
165 u8 _i2c_period = 0;
166 u8 _i2c_nostop = 0;
167 u8 _i2c_reserve = 0;
168
169
170 _i2c_period = i2c_bus->i2c_period;
171 _i2c_nostop = i2c_bus->i2c_nostop;
172 _i2c_reserve = i2c_bus->i2c_reserve;
173
174 saddr_len = req_data->saddr_len;
175
176
177 if (saddr_len == 1)
178 ven_req.wValue =
179 req_data->
180 dev_addr << 9 | _i2c_period << 4 | saddr_len << 2 |
181 _i2c_nostop << 1 | I2C_SYNC | _i2c_reserve << 6;
182 else
183 ven_req.wValue =
184 req_data->
185 dev_addr << 9 | _i2c_period << 4 | saddr_len << 2 |
186 _i2c_nostop << 1 | I2C_SYNC | _i2c_reserve << 6;
187
188
189 if (req_data->direction & I2C_M_RD) {
190
191 ven_req.bRequest = i2c_bus->nr + 4;
192 } else
193 ven_req.bRequest = i2c_bus->nr;
194
195
196 switch (saddr_len) {
197 case 0:
198 ven_req.wIndex = 0;
199 break;
200 case 1:
201 ven_req.wIndex = (req_data->saddr_dat & 0xff);
202 break;
203 case 2:
204 ven_req.wIndex = req_data->saddr_dat;
205 break;
206 }
207
208
209 ven_req.wLength = req_data->buf_size;
210
211
212 ven_req.bData = 0;
213
214
215 if (req_data->direction) {
216 ven_req.direction = USB_DIR_IN;
217 memset(req_data->p_buffer, 0x00, ven_req.wLength);
218 } else
219 ven_req.direction = USB_DIR_OUT;
220
221
222 ven_req.pBuff = req_data->p_buffer;
223
224
225
226 status = cx231xx_send_vendor_cmd(dev, &ven_req);
227 if (status < 0) {
228 cx231xx_info
229 ("UsbInterface::sendCommand, failed with status -%d\n",
230 status);
231 }
232
233 return status;
234}
235EXPORT_SYMBOL_GPL(cx231xx_send_usb_command);
236
237
238
239
240
241
242
243static int __usb_control_msg(struct cx231xx *dev, unsigned int pipe,
244 __u8 request, __u8 requesttype, __u16 value, __u16 index,
245 void *data, __u16 size, int timeout)
246{
247 int rc, i;
248
249 if (reg_debug) {
250 printk(KERN_DEBUG "%s: (pipe 0x%08x): "
251 "%s: %02x %02x %02x %02x %02x %02x %02x %02x ",
252 dev->name,
253 pipe,
254 (requesttype & USB_DIR_IN) ? "IN" : "OUT",
255 requesttype,
256 request,
257 value & 0xff, value >> 8,
258 index & 0xff, index >> 8,
259 size & 0xff, size >> 8);
260 if (!(requesttype & USB_DIR_IN)) {
261 printk(KERN_CONT ">>>");
262 for (i = 0; i < size; i++)
263 printk(KERN_CONT " %02x",
264 ((unsigned char *)data)[i]);
265 }
266 }
267
268
269 mutex_lock(&dev->ctrl_urb_lock);
270 if (!(requesttype & USB_DIR_IN) && size)
271 memcpy(dev->urb_buf, data, size);
272 rc = usb_control_msg(dev->udev, pipe, request, requesttype, value,
273 index, dev->urb_buf, size, timeout);
274 if ((requesttype & USB_DIR_IN) && size)
275 memcpy(data, dev->urb_buf, size);
276 mutex_unlock(&dev->ctrl_urb_lock);
277
278 if (reg_debug) {
279 if (unlikely(rc < 0)) {
280 printk(KERN_CONT "FAILED!\n");
281 return rc;
282 }
283
284 if ((requesttype & USB_DIR_IN)) {
285 printk(KERN_CONT "<<<");
286 for (i = 0; i < size; i++)
287 printk(KERN_CONT " %02x",
288 ((unsigned char *)data)[i]);
289 }
290 printk(KERN_CONT "\n");
291 }
292
293 return rc;
294}
295
296
297
298
299
300
301int cx231xx_read_ctrl_reg(struct cx231xx *dev, u8 req, u16 reg,
302 char *buf, int len)
303{
304 u8 val = 0;
305 int ret;
306 int pipe = usb_rcvctrlpipe(dev->udev, 0);
307
308 if (dev->state & DEV_DISCONNECTED)
309 return -ENODEV;
310
311 if (len > URB_MAX_CTRL_SIZE)
312 return -EINVAL;
313
314 switch (len) {
315 case 1:
316 val = ENABLE_ONE_BYTE;
317 break;
318 case 2:
319 val = ENABLE_TWE_BYTE;
320 break;
321 case 3:
322 val = ENABLE_THREE_BYTE;
323 break;
324 case 4:
325 val = ENABLE_FOUR_BYTE;
326 break;
327 default:
328 val = 0xFF;
329 }
330
331 if (val == 0xFF)
332 return -EINVAL;
333
334 ret = __usb_control_msg(dev, pipe, req,
335 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
336 val, reg, buf, len, HZ);
337 return ret;
338}
339
340int cx231xx_send_vendor_cmd(struct cx231xx *dev,
341 struct VENDOR_REQUEST_IN *ven_req)
342{
343 int ret;
344 int pipe = 0;
345 int unsend_size = 0;
346 u8 *pdata;
347
348 if (dev->state & DEV_DISCONNECTED)
349 return -ENODEV;
350
351 if ((ven_req->wLength > URB_MAX_CTRL_SIZE))
352 return -EINVAL;
353
354 if (ven_req->direction)
355 pipe = usb_rcvctrlpipe(dev->udev, 0);
356 else
357 pipe = usb_sndctrlpipe(dev->udev, 0);
358
359
360
361
362
363 if ((ven_req->wLength > 4) && ((ven_req->bRequest == 0x4) ||
364 (ven_req->bRequest == 0x5) ||
365 (ven_req->bRequest == 0x6))) {
366 unsend_size = 0;
367 pdata = ven_req->pBuff;
368
369
370 unsend_size = ven_req->wLength;
371
372
373 ven_req->wValue = ven_req->wValue & 0xFFFB;
374 ven_req->wValue = (ven_req->wValue & 0xFFBD) | 0x2;
375 ret = __usb_control_msg(dev, pipe, ven_req->bRequest,
376 ven_req->direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
377 ven_req->wValue, ven_req->wIndex, pdata,
378 0x0004, HZ);
379 unsend_size = unsend_size - 4;
380
381
382 ven_req->wValue = (ven_req->wValue & 0xFFBD) | 0x42;
383 while (unsend_size - 4 > 0) {
384 pdata = pdata + 4;
385 ret = __usb_control_msg(dev, pipe,
386 ven_req->bRequest,
387 ven_req->direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
388 ven_req->wValue, ven_req->wIndex, pdata,
389 0x0004, HZ);
390 unsend_size = unsend_size - 4;
391 }
392
393
394 ven_req->wValue = (ven_req->wValue & 0xFFBD) | 0x40;
395 pdata = pdata + 4;
396 ret = __usb_control_msg(dev, pipe, ven_req->bRequest,
397 ven_req->direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
398 ven_req->wValue, ven_req->wIndex, pdata,
399 unsend_size, HZ);
400 } else {
401 ret = __usb_control_msg(dev, pipe, ven_req->bRequest,
402 ven_req->direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
403 ven_req->wValue, ven_req->wIndex,
404 ven_req->pBuff, ven_req->wLength, HZ);
405 }
406
407 return ret;
408}
409
410
411
412
413
414int cx231xx_write_ctrl_reg(struct cx231xx *dev, u8 req, u16 reg, char *buf,
415 int len)
416{
417 u8 val = 0;
418 int ret;
419 int pipe = usb_sndctrlpipe(dev->udev, 0);
420
421 if (dev->state & DEV_DISCONNECTED)
422 return -ENODEV;
423
424 if ((len < 1) || (len > URB_MAX_CTRL_SIZE))
425 return -EINVAL;
426
427 switch (len) {
428 case 1:
429 val = ENABLE_ONE_BYTE;
430 break;
431 case 2:
432 val = ENABLE_TWE_BYTE;
433 break;
434 case 3:
435 val = ENABLE_THREE_BYTE;
436 break;
437 case 4:
438 val = ENABLE_FOUR_BYTE;
439 break;
440 default:
441 val = 0xFF;
442 }
443
444 if (val == 0xFF)
445 return -EINVAL;
446
447 if (reg_debug) {
448 int byte;
449
450 cx231xx_isocdbg("(pipe 0x%08x): "
451 "OUT: %02x %02x %02x %02x %02x %02x %02x %02x >>>",
452 pipe,
453 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
454 req, 0, val, reg & 0xff,
455 reg >> 8, len & 0xff, len >> 8);
456
457 for (byte = 0; byte < len; byte++)
458 cx231xx_isocdbg(" %02x", (unsigned char)buf[byte]);
459 cx231xx_isocdbg("\n");
460 }
461
462 ret = __usb_control_msg(dev, pipe, req,
463 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
464 val, reg, buf, len, HZ);
465
466 return ret;
467}
468
469
470
471
472
473int cx231xx_set_video_alternate(struct cx231xx *dev)
474{
475 int errCode, prev_alt = dev->video_mode.alt;
476 unsigned int min_pkt_size = dev->width * 2 + 4;
477 u32 usb_interface_index = 0;
478
479
480
481
482
483 if (dev->width * 2 * dev->height > 720 * 240 * 2)
484 min_pkt_size *= 2;
485
486 if (dev->width > 360) {
487
488 dev->video_mode.alt = 3;
489 } else if (dev->width > 180) {
490
491 dev->video_mode.alt = 2;
492 } else if (dev->width > 0) {
493
494 dev->video_mode.alt = 1;
495 } else {
496
497 dev->video_mode.alt = 0;
498 }
499
500 if (dev->USE_ISO == 0)
501 dev->video_mode.alt = 0;
502
503 cx231xx_coredbg("dev->video_mode.alt= %d\n", dev->video_mode.alt);
504
505
506 usb_interface_index =
507 dev->current_pcb_config.hs_config_info[0].interface_info.
508 video_index + 1;
509
510 if (dev->video_mode.alt != prev_alt) {
511 cx231xx_coredbg("minimum isoc packet size: %u (alt=%d)\n",
512 min_pkt_size, dev->video_mode.alt);
513
514 if (dev->video_mode.alt_max_pkt_size != NULL)
515 dev->video_mode.max_pkt_size =
516 dev->video_mode.alt_max_pkt_size[dev->video_mode.alt];
517 cx231xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n",
518 dev->video_mode.alt,
519 dev->video_mode.max_pkt_size);
520 errCode =
521 usb_set_interface(dev->udev, usb_interface_index,
522 dev->video_mode.alt);
523 if (errCode < 0) {
524 cx231xx_errdev
525 ("cannot change alt number to %d (error=%i)\n",
526 dev->video_mode.alt, errCode);
527 return errCode;
528 }
529 }
530 return 0;
531}
532
533int cx231xx_set_alt_setting(struct cx231xx *dev, u8 index, u8 alt)
534{
535 int status = 0;
536 u32 usb_interface_index = 0;
537 u32 max_pkt_size = 0;
538
539 switch (index) {
540 case INDEX_TS1:
541 usb_interface_index =
542 dev->current_pcb_config.hs_config_info[0].interface_info.
543 ts1_index + 1;
544 dev->ts1_mode.alt = alt;
545 if (dev->ts1_mode.alt_max_pkt_size != NULL)
546 max_pkt_size = dev->ts1_mode.max_pkt_size =
547 dev->ts1_mode.alt_max_pkt_size[dev->ts1_mode.alt];
548 break;
549 case INDEX_TS2:
550 usb_interface_index =
551 dev->current_pcb_config.hs_config_info[0].interface_info.
552 ts2_index + 1;
553 break;
554 case INDEX_AUDIO:
555 usb_interface_index =
556 dev->current_pcb_config.hs_config_info[0].interface_info.
557 audio_index + 1;
558 dev->adev.alt = alt;
559 if (dev->adev.alt_max_pkt_size != NULL)
560 max_pkt_size = dev->adev.max_pkt_size =
561 dev->adev.alt_max_pkt_size[dev->adev.alt];
562 break;
563 case INDEX_VIDEO:
564 usb_interface_index =
565 dev->current_pcb_config.hs_config_info[0].interface_info.
566 video_index + 1;
567 dev->video_mode.alt = alt;
568 if (dev->video_mode.alt_max_pkt_size != NULL)
569 max_pkt_size = dev->video_mode.max_pkt_size =
570 dev->video_mode.alt_max_pkt_size[dev->video_mode.
571 alt];
572 break;
573 case INDEX_VANC:
574 if (dev->board.no_alt_vanc)
575 return 0;
576 usb_interface_index =
577 dev->current_pcb_config.hs_config_info[0].interface_info.
578 vanc_index + 1;
579 dev->vbi_mode.alt = alt;
580 if (dev->vbi_mode.alt_max_pkt_size != NULL)
581 max_pkt_size = dev->vbi_mode.max_pkt_size =
582 dev->vbi_mode.alt_max_pkt_size[dev->vbi_mode.alt];
583 break;
584 case INDEX_HANC:
585 usb_interface_index =
586 dev->current_pcb_config.hs_config_info[0].interface_info.
587 hanc_index + 1;
588 dev->sliced_cc_mode.alt = alt;
589 if (dev->sliced_cc_mode.alt_max_pkt_size != NULL)
590 max_pkt_size = dev->sliced_cc_mode.max_pkt_size =
591 dev->sliced_cc_mode.alt_max_pkt_size[dev->
592 sliced_cc_mode.
593 alt];
594 break;
595 default:
596 break;
597 }
598
599 if (alt > 0 && max_pkt_size == 0) {
600 cx231xx_errdev
601 ("can't change interface %d alt no. to %d: Max. Pkt size = 0\n",
602 usb_interface_index, alt);
603
604
605 if (dev->board.no_alt_vanc)
606 return -1;
607 }
608
609 cx231xx_coredbg("setting alternate %d with wMaxPacketSize=%u,"
610 "Interface = %d\n", alt, max_pkt_size,
611 usb_interface_index);
612
613 if (usb_interface_index > 0) {
614 status = usb_set_interface(dev->udev, usb_interface_index, alt);
615 if (status < 0) {
616 cx231xx_errdev
617 ("can't change interface %d alt no. to %d (err=%i)\n",
618 usb_interface_index, alt, status);
619 return status;
620 }
621 }
622
623 return status;
624}
625EXPORT_SYMBOL_GPL(cx231xx_set_alt_setting);
626
627int cx231xx_gpio_set(struct cx231xx *dev, struct cx231xx_reg_seq *gpio)
628{
629 int rc = 0;
630
631 if (!gpio)
632 return rc;
633
634
635 while (gpio->sleep >= 0) {
636 rc = cx231xx_set_gpio_value(dev, gpio->bit, gpio->val);
637 if (rc < 0)
638 return rc;
639
640 if (gpio->sleep > 0)
641 msleep(gpio->sleep);
642
643 gpio++;
644 }
645 return rc;
646}
647
648int cx231xx_demod_reset(struct cx231xx *dev)
649{
650
651 u8 status = 0;
652 u8 value[4] = { 0, 0, 0, 0 };
653
654 status = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, PWR_CTL_EN,
655 value, 4);
656
657 cx231xx_coredbg("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", PWR_CTL_EN,
658 value[0], value[1], value[2], value[3]);
659
660 cx231xx_coredbg("Enter cx231xx_demod_reset()\n");
661
662 value[1] = (u8) 0x3;
663 status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
664 PWR_CTL_EN, value, 4);
665 msleep(10);
666
667 value[1] = (u8) 0x0;
668 status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
669 PWR_CTL_EN, value, 4);
670 msleep(10);
671
672 value[1] = (u8) 0x3;
673 status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
674 PWR_CTL_EN, value, 4);
675 msleep(10);
676
677
678
679 status = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, PWR_CTL_EN,
680 value, 4);
681
682 cx231xx_coredbg("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", PWR_CTL_EN,
683 value[0], value[1], value[2], value[3]);
684
685 return status;
686}
687EXPORT_SYMBOL_GPL(cx231xx_demod_reset);
688int is_fw_load(struct cx231xx *dev)
689{
690 return cx231xx_check_fw(dev);
691}
692EXPORT_SYMBOL_GPL(is_fw_load);
693
694int cx231xx_set_mode(struct cx231xx *dev, enum cx231xx_mode set_mode)
695{
696 int errCode = 0;
697
698 if (dev->mode == set_mode)
699 return 0;
700
701 if (set_mode == CX231XX_SUSPEND) {
702
703 dev->mode = set_mode;
704 }
705
706
707 if (dev->mode != CX231XX_SUSPEND)
708 return -EINVAL;
709
710 dev->mode = set_mode;
711
712 if (dev->mode == CX231XX_DIGITAL_MODE) {
713
714 switch (dev->model) {
715 case CX231XX_BOARD_CNXT_CARRAERA:
716 case CX231XX_BOARD_CNXT_RDE_250:
717 case CX231XX_BOARD_CNXT_SHELBY:
718 case CX231XX_BOARD_CNXT_RDU_250:
719 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 0);
720 break;
721 case CX231XX_BOARD_CNXT_RDE_253S:
722 case CX231XX_BOARD_CNXT_RDU_253S:
723 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 1);
724 break;
725 case CX231XX_BOARD_HAUPPAUGE_EXETER:
726 errCode = cx231xx_set_power_mode(dev,
727 POLARIS_AVMODE_DIGITAL);
728 break;
729 default:
730 break;
731 }
732 } else {
733
734 switch (dev->model) {
735 case CX231XX_BOARD_CNXT_CARRAERA:
736 case CX231XX_BOARD_CNXT_RDE_250:
737 case CX231XX_BOARD_CNXT_SHELBY:
738 case CX231XX_BOARD_CNXT_RDU_250:
739 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 1);
740 break;
741 case CX231XX_BOARD_CNXT_RDE_253S:
742 case CX231XX_BOARD_CNXT_RDU_253S:
743 case CX231XX_BOARD_HAUPPAUGE_EXETER:
744 case CX231XX_BOARD_PV_PLAYTV_USB_HYBRID:
745 case CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL:
746 case CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC:
747 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 0);
748 break;
749 default:
750 break;
751 }
752 }
753
754 return 0;
755}
756EXPORT_SYMBOL_GPL(cx231xx_set_mode);
757
758int cx231xx_ep5_bulkout(struct cx231xx *dev, u8 *firmware, u16 size)
759{
760 int errCode = 0;
761 int actlen, ret = -ENOMEM;
762 u32 *buffer;
763
764buffer = kzalloc(4096, GFP_KERNEL);
765 if (buffer == NULL) {
766 cx231xx_info("out of mem\n");
767 return -ENOMEM;
768 }
769 memcpy(&buffer[0], firmware, 4096);
770
771 ret = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 5),
772 buffer, 4096, &actlen, 2000);
773
774 if (ret)
775 cx231xx_info("bulk message failed: %d (%d/%d)", ret,
776 size, actlen);
777 else {
778 errCode = actlen != size ? -1 : 0;
779 }
780kfree(buffer);
781 return 0;
782}
783
784
785
786
787
788
789
790
791static void cx231xx_isoc_irq_callback(struct urb *urb)
792{
793 struct cx231xx_dmaqueue *dma_q = urb->context;
794 struct cx231xx_video_mode *vmode =
795 container_of(dma_q, struct cx231xx_video_mode, vidq);
796 struct cx231xx *dev = container_of(vmode, struct cx231xx, video_mode);
797 int rc, i;
798
799 switch (urb->status) {
800 case 0:
801 case -ETIMEDOUT:
802 break;
803 case -ECONNRESET:
804 case -ENOENT:
805 case -ESHUTDOWN:
806 return;
807 default:
808 cx231xx_isocdbg("urb completition error %d.\n", urb->status);
809 break;
810 }
811
812
813 spin_lock(&dev->video_mode.slock);
814 rc = dev->video_mode.isoc_ctl.isoc_copy(dev, urb);
815 spin_unlock(&dev->video_mode.slock);
816
817
818 for (i = 0; i < urb->number_of_packets; i++) {
819 urb->iso_frame_desc[i].status = 0;
820 urb->iso_frame_desc[i].actual_length = 0;
821 }
822 urb->status = 0;
823
824 urb->status = usb_submit_urb(urb, GFP_ATOMIC);
825 if (urb->status) {
826 cx231xx_isocdbg("urb resubmit failed (error=%i)\n",
827 urb->status);
828 }
829}
830
831
832
833
834
835
836
837static void cx231xx_bulk_irq_callback(struct urb *urb)
838{
839 struct cx231xx_dmaqueue *dma_q = urb->context;
840 struct cx231xx_video_mode *vmode =
841 container_of(dma_q, struct cx231xx_video_mode, vidq);
842 struct cx231xx *dev = container_of(vmode, struct cx231xx, video_mode);
843 int rc;
844
845 switch (urb->status) {
846 case 0:
847 case -ETIMEDOUT:
848 break;
849 case -ECONNRESET:
850 case -ENOENT:
851 case -ESHUTDOWN:
852 return;
853 default:
854 cx231xx_isocdbg("urb completition error %d.\n", urb->status);
855 break;
856 }
857
858
859 spin_lock(&dev->video_mode.slock);
860 rc = dev->video_mode.bulk_ctl.bulk_copy(dev, urb);
861 spin_unlock(&dev->video_mode.slock);
862
863
864 urb->status = 0;
865
866 urb->status = usb_submit_urb(urb, GFP_ATOMIC);
867 if (urb->status) {
868 cx231xx_isocdbg("urb resubmit failed (error=%i)\n",
869 urb->status);
870 }
871}
872
873
874
875void cx231xx_uninit_isoc(struct cx231xx *dev)
876{
877 struct cx231xx_dmaqueue *dma_q = &dev->video_mode.vidq;
878 struct urb *urb;
879 int i;
880
881 cx231xx_isocdbg("cx231xx: called cx231xx_uninit_isoc\n");
882
883 dev->video_mode.isoc_ctl.nfields = -1;
884 for (i = 0; i < dev->video_mode.isoc_ctl.num_bufs; i++) {
885 urb = dev->video_mode.isoc_ctl.urb[i];
886 if (urb) {
887 if (!irqs_disabled())
888 usb_kill_urb(urb);
889 else
890 usb_unlink_urb(urb);
891
892 if (dev->video_mode.isoc_ctl.transfer_buffer[i]) {
893 usb_free_coherent(dev->udev,
894 urb->transfer_buffer_length,
895 dev->video_mode.isoc_ctl.
896 transfer_buffer[i],
897 urb->transfer_dma);
898 }
899 usb_free_urb(urb);
900 dev->video_mode.isoc_ctl.urb[i] = NULL;
901 }
902 dev->video_mode.isoc_ctl.transfer_buffer[i] = NULL;
903 }
904
905 kfree(dev->video_mode.isoc_ctl.urb);
906 kfree(dev->video_mode.isoc_ctl.transfer_buffer);
907 kfree(dma_q->p_left_data);
908
909 dev->video_mode.isoc_ctl.urb = NULL;
910 dev->video_mode.isoc_ctl.transfer_buffer = NULL;
911 dev->video_mode.isoc_ctl.num_bufs = 0;
912 dma_q->p_left_data = NULL;
913
914 if (dev->mode_tv == 0)
915 cx231xx_capture_start(dev, 0, Raw_Video);
916 else
917 cx231xx_capture_start(dev, 0, TS1_serial_mode);
918
919
920}
921EXPORT_SYMBOL_GPL(cx231xx_uninit_isoc);
922
923
924
925
926void cx231xx_uninit_bulk(struct cx231xx *dev)
927{
928 struct urb *urb;
929 int i;
930
931 cx231xx_isocdbg("cx231xx: called cx231xx_uninit_bulk\n");
932
933 dev->video_mode.bulk_ctl.nfields = -1;
934 for (i = 0; i < dev->video_mode.bulk_ctl.num_bufs; i++) {
935 urb = dev->video_mode.bulk_ctl.urb[i];
936 if (urb) {
937 if (!irqs_disabled())
938 usb_kill_urb(urb);
939 else
940 usb_unlink_urb(urb);
941
942 if (dev->video_mode.bulk_ctl.transfer_buffer[i]) {
943 usb_free_coherent(dev->udev,
944 urb->transfer_buffer_length,
945 dev->video_mode.isoc_ctl.
946 transfer_buffer[i],
947 urb->transfer_dma);
948 }
949 usb_free_urb(urb);
950 dev->video_mode.bulk_ctl.urb[i] = NULL;
951 }
952 dev->video_mode.bulk_ctl.transfer_buffer[i] = NULL;
953 }
954
955 kfree(dev->video_mode.bulk_ctl.urb);
956 kfree(dev->video_mode.bulk_ctl.transfer_buffer);
957
958 dev->video_mode.bulk_ctl.urb = NULL;
959 dev->video_mode.bulk_ctl.transfer_buffer = NULL;
960 dev->video_mode.bulk_ctl.num_bufs = 0;
961
962 if (dev->mode_tv == 0)
963 cx231xx_capture_start(dev, 0, Raw_Video);
964 else
965 cx231xx_capture_start(dev, 0, TS1_serial_mode);
966
967
968}
969EXPORT_SYMBOL_GPL(cx231xx_uninit_bulk);
970
971
972
973
974int cx231xx_init_isoc(struct cx231xx *dev, int max_packets,
975 int num_bufs, int max_pkt_size,
976 int (*isoc_copy) (struct cx231xx *dev, struct urb *urb))
977{
978 struct cx231xx_dmaqueue *dma_q = &dev->video_mode.vidq;
979 int i;
980 int sb_size, pipe;
981 struct urb *urb;
982 int j, k;
983 int rc;
984
985
986 cx231xx_uninit_isoc(dev);
987
988 dma_q->p_left_data = kzalloc(4096, GFP_KERNEL);
989 if (dma_q->p_left_data == NULL) {
990 cx231xx_info("out of mem\n");
991 return -ENOMEM;
992 }
993
994
995
996 dev->video_mode.isoc_ctl.isoc_copy = isoc_copy;
997 dev->video_mode.isoc_ctl.num_bufs = num_bufs;
998 dma_q->pos = 0;
999 dma_q->is_partial_line = 0;
1000 dma_q->last_sav = 0;
1001 dma_q->current_field = -1;
1002 dma_q->field1_done = 0;
1003 dma_q->lines_per_field = dev->height / 2;
1004 dma_q->bytes_left_in_line = dev->width << 1;
1005 dma_q->lines_completed = 0;
1006 dma_q->mpeg_buffer_done = 0;
1007 dma_q->left_data_count = 0;
1008 dma_q->mpeg_buffer_completed = 0;
1009 dma_q->add_ps_package_head = CX231XX_NEED_ADD_PS_PACKAGE_HEAD;
1010 dma_q->ps_head[0] = 0x00;
1011 dma_q->ps_head[1] = 0x00;
1012 dma_q->ps_head[2] = 0x01;
1013 dma_q->ps_head[3] = 0xBA;
1014 for (i = 0; i < 8; i++)
1015 dma_q->partial_buf[i] = 0;
1016
1017 dev->video_mode.isoc_ctl.urb =
1018 kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL);
1019 if (!dev->video_mode.isoc_ctl.urb) {
1020 cx231xx_errdev("cannot alloc memory for usb buffers\n");
1021 return -ENOMEM;
1022 }
1023
1024 dev->video_mode.isoc_ctl.transfer_buffer =
1025 kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL);
1026 if (!dev->video_mode.isoc_ctl.transfer_buffer) {
1027 cx231xx_errdev("cannot allocate memory for usbtransfer\n");
1028 kfree(dev->video_mode.isoc_ctl.urb);
1029 return -ENOMEM;
1030 }
1031
1032 dev->video_mode.isoc_ctl.max_pkt_size = max_pkt_size;
1033 dev->video_mode.isoc_ctl.buf = NULL;
1034
1035 sb_size = max_packets * dev->video_mode.isoc_ctl.max_pkt_size;
1036
1037 if (dev->mode_tv == 1)
1038 dev->video_mode.end_point_addr = 0x81;
1039 else
1040 dev->video_mode.end_point_addr = 0x84;
1041
1042
1043
1044 for (i = 0; i < dev->video_mode.isoc_ctl.num_bufs; i++) {
1045 urb = usb_alloc_urb(max_packets, GFP_KERNEL);
1046 if (!urb) {
1047 cx231xx_err("cannot alloc isoc_ctl.urb %i\n", i);
1048 cx231xx_uninit_isoc(dev);
1049 return -ENOMEM;
1050 }
1051 dev->video_mode.isoc_ctl.urb[i] = urb;
1052
1053 dev->video_mode.isoc_ctl.transfer_buffer[i] =
1054 usb_alloc_coherent(dev->udev, sb_size, GFP_KERNEL,
1055 &urb->transfer_dma);
1056 if (!dev->video_mode.isoc_ctl.transfer_buffer[i]) {
1057 cx231xx_err("unable to allocate %i bytes for transfer"
1058 " buffer %i%s\n",
1059 sb_size, i,
1060 in_interrupt() ? " while in int" : "");
1061 cx231xx_uninit_isoc(dev);
1062 return -ENOMEM;
1063 }
1064 memset(dev->video_mode.isoc_ctl.transfer_buffer[i], 0, sb_size);
1065
1066 pipe =
1067 usb_rcvisocpipe(dev->udev, dev->video_mode.end_point_addr);
1068
1069 usb_fill_int_urb(urb, dev->udev, pipe,
1070 dev->video_mode.isoc_ctl.transfer_buffer[i],
1071 sb_size, cx231xx_isoc_irq_callback, dma_q, 1);
1072
1073 urb->number_of_packets = max_packets;
1074 urb->transfer_flags = URB_ISO_ASAP;
1075
1076 k = 0;
1077 for (j = 0; j < max_packets; j++) {
1078 urb->iso_frame_desc[j].offset = k;
1079 urb->iso_frame_desc[j].length =
1080 dev->video_mode.isoc_ctl.max_pkt_size;
1081 k += dev->video_mode.isoc_ctl.max_pkt_size;
1082 }
1083 }
1084
1085 init_waitqueue_head(&dma_q->wq);
1086
1087
1088 for (i = 0; i < dev->video_mode.isoc_ctl.num_bufs; i++) {
1089 rc = usb_submit_urb(dev->video_mode.isoc_ctl.urb[i],
1090 GFP_ATOMIC);
1091 if (rc) {
1092 cx231xx_err("submit of urb %i failed (error=%i)\n", i,
1093 rc);
1094 cx231xx_uninit_isoc(dev);
1095 return rc;
1096 }
1097 }
1098
1099 if (dev->mode_tv == 0)
1100 cx231xx_capture_start(dev, 1, Raw_Video);
1101 else
1102 cx231xx_capture_start(dev, 1, TS1_serial_mode);
1103
1104 return 0;
1105}
1106EXPORT_SYMBOL_GPL(cx231xx_init_isoc);
1107
1108
1109
1110
1111int cx231xx_init_bulk(struct cx231xx *dev, int max_packets,
1112 int num_bufs, int max_pkt_size,
1113 int (*bulk_copy) (struct cx231xx *dev, struct urb *urb))
1114{
1115 struct cx231xx_dmaqueue *dma_q = &dev->video_mode.vidq;
1116 int i;
1117 int sb_size, pipe;
1118 struct urb *urb;
1119 int rc;
1120
1121 dev->video_input = dev->video_input > 2 ? 2 : dev->video_input;
1122
1123 cx231xx_coredbg("Setting Video mux to %d\n", dev->video_input);
1124
1125 video_mux(dev, dev->video_input);
1126
1127
1128 cx231xx_uninit_bulk(dev);
1129
1130 dev->video_mode.bulk_ctl.bulk_copy = bulk_copy;
1131 dev->video_mode.bulk_ctl.num_bufs = num_bufs;
1132 dma_q->pos = 0;
1133 dma_q->is_partial_line = 0;
1134 dma_q->last_sav = 0;
1135 dma_q->current_field = -1;
1136 dma_q->field1_done = 0;
1137 dma_q->lines_per_field = dev->height / 2;
1138 dma_q->bytes_left_in_line = dev->width << 1;
1139 dma_q->lines_completed = 0;
1140 dma_q->mpeg_buffer_done = 0;
1141 dma_q->left_data_count = 0;
1142 dma_q->mpeg_buffer_completed = 0;
1143 dma_q->ps_head[0] = 0x00;
1144 dma_q->ps_head[1] = 0x00;
1145 dma_q->ps_head[2] = 0x01;
1146 dma_q->ps_head[3] = 0xBA;
1147 for (i = 0; i < 8; i++)
1148 dma_q->partial_buf[i] = 0;
1149
1150 dev->video_mode.bulk_ctl.urb =
1151 kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL);
1152 if (!dev->video_mode.bulk_ctl.urb) {
1153 cx231xx_errdev("cannot alloc memory for usb buffers\n");
1154 return -ENOMEM;
1155 }
1156
1157 dev->video_mode.bulk_ctl.transfer_buffer =
1158 kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL);
1159 if (!dev->video_mode.bulk_ctl.transfer_buffer) {
1160 cx231xx_errdev("cannot allocate memory for usbtransfer\n");
1161 kfree(dev->video_mode.bulk_ctl.urb);
1162 return -ENOMEM;
1163 }
1164
1165 dev->video_mode.bulk_ctl.max_pkt_size = max_pkt_size;
1166 dev->video_mode.bulk_ctl.buf = NULL;
1167
1168 sb_size = max_packets * dev->video_mode.bulk_ctl.max_pkt_size;
1169
1170 if (dev->mode_tv == 1)
1171 dev->video_mode.end_point_addr = 0x81;
1172 else
1173 dev->video_mode.end_point_addr = 0x84;
1174
1175
1176
1177 for (i = 0; i < dev->video_mode.bulk_ctl.num_bufs; i++) {
1178 urb = usb_alloc_urb(0, GFP_KERNEL);
1179 if (!urb) {
1180 cx231xx_err("cannot alloc bulk_ctl.urb %i\n", i);
1181 cx231xx_uninit_bulk(dev);
1182 return -ENOMEM;
1183 }
1184 dev->video_mode.bulk_ctl.urb[i] = urb;
1185 urb->transfer_flags = 0;
1186
1187 dev->video_mode.bulk_ctl.transfer_buffer[i] =
1188 usb_alloc_coherent(dev->udev, sb_size, GFP_KERNEL,
1189 &urb->transfer_dma);
1190 if (!dev->video_mode.bulk_ctl.transfer_buffer[i]) {
1191 cx231xx_err("unable to allocate %i bytes for transfer"
1192 " buffer %i%s\n",
1193 sb_size, i,
1194 in_interrupt() ? " while in int" : "");
1195 cx231xx_uninit_bulk(dev);
1196 return -ENOMEM;
1197 }
1198 memset(dev->video_mode.bulk_ctl.transfer_buffer[i], 0, sb_size);
1199
1200 pipe = usb_rcvbulkpipe(dev->udev,
1201 dev->video_mode.end_point_addr);
1202 usb_fill_bulk_urb(urb, dev->udev, pipe,
1203 dev->video_mode.bulk_ctl.transfer_buffer[i],
1204 sb_size, cx231xx_bulk_irq_callback, dma_q);
1205 }
1206
1207 init_waitqueue_head(&dma_q->wq);
1208
1209
1210 for (i = 0; i < dev->video_mode.bulk_ctl.num_bufs; i++) {
1211 rc = usb_submit_urb(dev->video_mode.bulk_ctl.urb[i],
1212 GFP_ATOMIC);
1213 if (rc) {
1214 cx231xx_err("submit of urb %i failed (error=%i)\n", i,
1215 rc);
1216 cx231xx_uninit_bulk(dev);
1217 return rc;
1218 }
1219 }
1220
1221 if (dev->mode_tv == 0)
1222 cx231xx_capture_start(dev, 1, Raw_Video);
1223 else
1224 cx231xx_capture_start(dev, 1, TS1_serial_mode);
1225
1226 return 0;
1227}
1228EXPORT_SYMBOL_GPL(cx231xx_init_bulk);
1229void cx231xx_stop_TS1(struct cx231xx *dev)
1230{
1231 int status = 0;
1232 u8 val[4] = { 0, 0, 0, 0 };
1233
1234 val[0] = 0x00;
1235 val[1] = 0x03;
1236 val[2] = 0x00;
1237 val[3] = 0x00;
1238 status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
1239 TS_MODE_REG, val, 4);
1240
1241 val[0] = 0x00;
1242 val[1] = 0x70;
1243 val[2] = 0x04;
1244 val[3] = 0x00;
1245 status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
1246 TS1_CFG_REG, val, 4);
1247}
1248
1249void cx231xx_start_TS1(struct cx231xx *dev)
1250{
1251 int status = 0;
1252 u8 val[4] = { 0, 0, 0, 0 };
1253
1254 val[0] = 0x03;
1255 val[1] = 0x03;
1256 val[2] = 0x00;
1257 val[3] = 0x00;
1258 status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
1259 TS_MODE_REG, val, 4);
1260
1261 val[0] = 0x04;
1262 val[1] = 0xA3;
1263 val[2] = 0x3B;
1264 val[3] = 0x00;
1265 status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
1266 TS1_CFG_REG, val, 4);
1267}
1268
1269
1270
1271
1272int cx231xx_dev_init(struct cx231xx *dev)
1273{
1274 int errCode = 0;
1275
1276
1277
1278
1279 dev->i2c_bus[0].nr = 0;
1280 dev->i2c_bus[0].dev = dev;
1281 dev->i2c_bus[0].i2c_period = I2C_SPEED_100K;
1282 dev->i2c_bus[0].i2c_nostop = 0;
1283 dev->i2c_bus[0].i2c_reserve = 0;
1284
1285
1286 dev->i2c_bus[1].nr = 1;
1287 dev->i2c_bus[1].dev = dev;
1288 dev->i2c_bus[1].i2c_period = I2C_SPEED_100K;
1289 dev->i2c_bus[1].i2c_nostop = 0;
1290 dev->i2c_bus[1].i2c_reserve = 0;
1291
1292
1293 dev->i2c_bus[2].nr = 2;
1294 dev->i2c_bus[2].dev = dev;
1295 dev->i2c_bus[2].i2c_period = I2C_SPEED_100K;
1296 dev->i2c_bus[2].i2c_nostop = 0;
1297 dev->i2c_bus[2].i2c_reserve = 0;
1298
1299
1300 cx231xx_i2c_register(&dev->i2c_bus[0]);
1301 cx231xx_i2c_register(&dev->i2c_bus[1]);
1302 cx231xx_i2c_register(&dev->i2c_bus[2]);
1303
1304
1305
1306
1307 if (dev->board.external_av) {
1308 errCode = cx231xx_set_power_mode(dev,
1309 POLARIS_AVMODE_ENXTERNAL_AV);
1310 if (errCode < 0) {
1311 cx231xx_errdev
1312 ("%s: Failed to set Power - errCode [%d]!\n",
1313 __func__, errCode);
1314 return errCode;
1315 }
1316 } else {
1317 errCode = cx231xx_set_power_mode(dev,
1318 POLARIS_AVMODE_ANALOGT_TV);
1319 if (errCode < 0) {
1320 cx231xx_errdev
1321 ("%s: Failed to set Power - errCode [%d]!\n",
1322 __func__, errCode);
1323 return errCode;
1324 }
1325 }
1326
1327
1328 if ((dev->board.tuner_type == TUNER_XC5000) ||
1329 (dev->board.tuner_type == TUNER_XC2028))
1330 cx231xx_gpio_set(dev, dev->board.tuner_gpio);
1331
1332
1333 errCode = cx231xx_afe_init_super_block(dev, 0x23c);
1334 if (errCode < 0) {
1335 cx231xx_errdev
1336 ("%s: cx231xx_afe init super block - errCode [%d]!\n",
1337 __func__, errCode);
1338 return errCode;
1339 }
1340 errCode = cx231xx_afe_init_channels(dev);
1341 if (errCode < 0) {
1342 cx231xx_errdev
1343 ("%s: cx231xx_afe init channels - errCode [%d]!\n",
1344 __func__, errCode);
1345 return errCode;
1346 }
1347
1348
1349 errCode = cx231xx_dif_set_standard(dev, DIF_USE_BASEBAND);
1350 if (errCode < 0) {
1351 cx231xx_errdev
1352 ("%s: cx231xx_dif set to By pass mode - errCode [%d]!\n",
1353 __func__, errCode);
1354 return errCode;
1355 }
1356
1357
1358 errCode = cx231xx_i2s_blk_initialize(dev);
1359 if (errCode < 0) {
1360 cx231xx_errdev
1361 ("%s: cx231xx_i2s block initialize - errCode [%d]!\n",
1362 __func__, errCode);
1363 return errCode;
1364 }
1365
1366
1367 errCode = cx231xx_init_ctrl_pin_status(dev);
1368 if (errCode < 0) {
1369 cx231xx_errdev("%s: cx231xx_init ctrl pins - errCode [%d]!\n",
1370 __func__, errCode);
1371 return errCode;
1372 }
1373
1374
1375 switch (dev->model) {
1376 case CX231XX_BOARD_CNXT_CARRAERA:
1377 case CX231XX_BOARD_CNXT_RDE_250:
1378 case CX231XX_BOARD_CNXT_SHELBY:
1379 case CX231XX_BOARD_CNXT_RDU_250:
1380 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 1);
1381 break;
1382 case CX231XX_BOARD_CNXT_RDE_253S:
1383 case CX231XX_BOARD_CNXT_RDU_253S:
1384 case CX231XX_BOARD_HAUPPAUGE_EXETER:
1385 case CX231XX_BOARD_PV_PLAYTV_USB_HYBRID:
1386 case CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL:
1387 case CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC:
1388 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 0);
1389 break;
1390 default:
1391 break;
1392 }
1393 if (errCode < 0) {
1394 cx231xx_errdev
1395 ("%s: cx231xx_AGC mode to Analog - errCode [%d]!\n",
1396 __func__, errCode);
1397 return errCode;
1398 }
1399
1400
1401 cx231xx_set_alt_setting(dev, INDEX_VIDEO, 0);
1402 cx231xx_set_alt_setting(dev, INDEX_VANC, 0);
1403 cx231xx_set_alt_setting(dev, INDEX_HANC, 0);
1404 if (dev->board.has_dvb)
1405 cx231xx_set_alt_setting(dev, INDEX_TS1, 0);
1406
1407
1408 errCode = cx231xx_enable_i2c_port_3(dev, true);
1409
1410 return errCode;
1411}
1412EXPORT_SYMBOL_GPL(cx231xx_dev_init);
1413
1414void cx231xx_dev_uninit(struct cx231xx *dev)
1415{
1416
1417 cx231xx_i2c_unregister(&dev->i2c_bus[2]);
1418 cx231xx_i2c_unregister(&dev->i2c_bus[1]);
1419 cx231xx_i2c_unregister(&dev->i2c_bus[0]);
1420}
1421EXPORT_SYMBOL_GPL(cx231xx_dev_uninit);
1422
1423
1424
1425
1426int cx231xx_send_gpio_cmd(struct cx231xx *dev, u32 gpio_bit, u8 *gpio_val,
1427 u8 len, u8 request, u8 direction)
1428{
1429 int status = 0;
1430 struct VENDOR_REQUEST_IN ven_req;
1431
1432
1433 ven_req.wValue = (u16) (gpio_bit >> 16 & 0xffff);
1434
1435
1436 if (!request) {
1437 if (direction)
1438 ven_req.bRequest = VRT_GET_GPIO;
1439 else
1440 ven_req.bRequest = VRT_SET_GPIO;
1441 } else {
1442 if (direction)
1443 ven_req.bRequest = VRT_GET_GPIE;
1444 else
1445 ven_req.bRequest = VRT_SET_GPIE;
1446 }
1447
1448
1449 ven_req.wIndex = (u16) (gpio_bit & 0xffff);
1450
1451
1452 ven_req.wLength = len;
1453
1454
1455 ven_req.bData = 0;
1456
1457
1458 ven_req.pBuff = gpio_val;
1459
1460
1461 if (direction) {
1462 ven_req.direction = USB_DIR_IN;
1463 memset(ven_req.pBuff, 0x00, ven_req.wLength);
1464 } else
1465 ven_req.direction = USB_DIR_OUT;
1466
1467
1468
1469 status = cx231xx_send_vendor_cmd(dev, &ven_req);
1470 if (status < 0) {
1471 cx231xx_info
1472 ("UsbInterface::sendCommand, failed with status -%d\n",
1473 status);
1474 }
1475
1476 return status;
1477}
1478EXPORT_SYMBOL_GPL(cx231xx_send_gpio_cmd);
1479
1480
1481
1482
1483int cx231xx_mode_register(struct cx231xx *dev, u16 address, u32 mode)
1484{
1485 u8 value[4] = { 0x0, 0x0, 0x0, 0x0 };
1486 u32 tmp = 0;
1487 int status = 0;
1488
1489 status =
1490 cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, address, value, 4);
1491 if (status < 0)
1492 return status;
1493
1494 tmp = *((u32 *) value);
1495 tmp |= mode;
1496
1497 value[0] = (u8) tmp;
1498 value[1] = (u8) (tmp >> 8);
1499 value[2] = (u8) (tmp >> 16);
1500 value[3] = (u8) (tmp >> 24);
1501
1502 status =
1503 cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, address, value, 4);
1504
1505 return status;
1506}
1507
1508
1509
1510
1511int cx231xx_read_i2c_master(struct cx231xx *dev, u8 dev_addr, u16 saddr,
1512 u8 saddr_len, u32 *data, u8 data_len, int master)
1513{
1514 int status = 0;
1515 struct cx231xx_i2c_xfer_data req_data;
1516 u8 value[64] = "0";
1517
1518 if (saddr_len == 0)
1519 saddr = 0;
1520 else if (saddr_len == 1)
1521 saddr &= 0xff;
1522
1523
1524 req_data.dev_addr = dev_addr >> 1;
1525 req_data.direction = I2C_M_RD;
1526 req_data.saddr_len = saddr_len;
1527 req_data.saddr_dat = saddr;
1528 req_data.buf_size = data_len;
1529 req_data.p_buffer = (u8 *) value;
1530
1531
1532 if (master == 0)
1533 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[0],
1534 &req_data);
1535 else if (master == 1)
1536 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[1],
1537 &req_data);
1538 else if (master == 2)
1539 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[2],
1540 &req_data);
1541
1542 if (status >= 0) {
1543
1544 if (data_len == 1)
1545 *data = value[0];
1546 else if (data_len == 4)
1547 *data =
1548 value[0] | value[1] << 8 | value[2] << 16 | value[3]
1549 << 24;
1550 else if (data_len > 4)
1551 *data = value[saddr];
1552 }
1553
1554 return status;
1555}
1556
1557int cx231xx_write_i2c_master(struct cx231xx *dev, u8 dev_addr, u16 saddr,
1558 u8 saddr_len, u32 data, u8 data_len, int master)
1559{
1560 int status = 0;
1561 u8 value[4] = { 0, 0, 0, 0 };
1562 struct cx231xx_i2c_xfer_data req_data;
1563
1564 value[0] = (u8) data;
1565 value[1] = (u8) (data >> 8);
1566 value[2] = (u8) (data >> 16);
1567 value[3] = (u8) (data >> 24);
1568
1569 if (saddr_len == 0)
1570 saddr = 0;
1571 else if (saddr_len == 1)
1572 saddr &= 0xff;
1573
1574
1575 req_data.dev_addr = dev_addr >> 1;
1576 req_data.direction = 0;
1577 req_data.saddr_len = saddr_len;
1578 req_data.saddr_dat = saddr;
1579 req_data.buf_size = data_len;
1580 req_data.p_buffer = value;
1581
1582
1583 if (master == 0)
1584 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[0],
1585 &req_data);
1586 else if (master == 1)
1587 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[1],
1588 &req_data);
1589 else if (master == 2)
1590 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[2],
1591 &req_data);
1592
1593 return status;
1594}
1595
1596int cx231xx_read_i2c_data(struct cx231xx *dev, u8 dev_addr, u16 saddr,
1597 u8 saddr_len, u32 *data, u8 data_len)
1598{
1599 int status = 0;
1600 struct cx231xx_i2c_xfer_data req_data;
1601 u8 value[4] = { 0, 0, 0, 0 };
1602
1603 if (saddr_len == 0)
1604 saddr = 0;
1605 else if (saddr_len == 1)
1606 saddr &= 0xff;
1607
1608
1609 req_data.dev_addr = dev_addr >> 1;
1610 req_data.direction = I2C_M_RD;
1611 req_data.saddr_len = saddr_len;
1612 req_data.saddr_dat = saddr;
1613 req_data.buf_size = data_len;
1614 req_data.p_buffer = (u8 *) value;
1615
1616
1617 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[0], &req_data);
1618
1619 if (status >= 0) {
1620
1621 if (data_len == 1)
1622 *data = value[0];
1623 else
1624 *data =
1625 value[0] | value[1] << 8 | value[2] << 16 | value[3]
1626 << 24;
1627 }
1628
1629 return status;
1630}
1631
1632int cx231xx_write_i2c_data(struct cx231xx *dev, u8 dev_addr, u16 saddr,
1633 u8 saddr_len, u32 data, u8 data_len)
1634{
1635 int status = 0;
1636 u8 value[4] = { 0, 0, 0, 0 };
1637 struct cx231xx_i2c_xfer_data req_data;
1638
1639 value[0] = (u8) data;
1640 value[1] = (u8) (data >> 8);
1641 value[2] = (u8) (data >> 16);
1642 value[3] = (u8) (data >> 24);
1643
1644 if (saddr_len == 0)
1645 saddr = 0;
1646 else if (saddr_len == 1)
1647 saddr &= 0xff;
1648
1649
1650 req_data.dev_addr = dev_addr >> 1;
1651 req_data.direction = 0;
1652 req_data.saddr_len = saddr_len;
1653 req_data.saddr_dat = saddr;
1654 req_data.buf_size = data_len;
1655 req_data.p_buffer = value;
1656
1657
1658 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[0], &req_data);
1659
1660 return status;
1661}
1662
1663int cx231xx_reg_mask_write(struct cx231xx *dev, u8 dev_addr, u8 size,
1664 u16 register_address, u8 bit_start, u8 bit_end,
1665 u32 value)
1666{
1667 int status = 0;
1668 u32 tmp;
1669 u32 mask = 0;
1670 int i;
1671
1672 if (bit_start > (size - 1) || bit_end > (size - 1))
1673 return -1;
1674
1675 if (size == 8) {
1676 status =
1677 cx231xx_read_i2c_data(dev, dev_addr, register_address, 2,
1678 &tmp, 1);
1679 } else {
1680 status =
1681 cx231xx_read_i2c_data(dev, dev_addr, register_address, 2,
1682 &tmp, 4);
1683 }
1684
1685 if (status < 0)
1686 return status;
1687
1688 mask = 1 << bit_end;
1689 for (i = bit_end; i > bit_start && i > 0; i--)
1690 mask = mask + (1 << (i - 1));
1691
1692 value <<= bit_start;
1693
1694 if (size == 8) {
1695 tmp &= ~mask;
1696 tmp |= value;
1697 tmp &= 0xff;
1698 status =
1699 cx231xx_write_i2c_data(dev, dev_addr, register_address, 2,
1700 tmp, 1);
1701 } else {
1702 tmp &= ~mask;
1703 tmp |= value;
1704 status =
1705 cx231xx_write_i2c_data(dev, dev_addr, register_address, 2,
1706 tmp, 4);
1707 }
1708
1709 return status;
1710}
1711
1712int cx231xx_read_modify_write_i2c_dword(struct cx231xx *dev, u8 dev_addr,
1713 u16 saddr, u32 mask, u32 value)
1714{
1715 u32 temp;
1716 int status = 0;
1717
1718 status = cx231xx_read_i2c_data(dev, dev_addr, saddr, 2, &temp, 4);
1719
1720 if (status < 0)
1721 return status;
1722
1723 temp &= ~mask;
1724 temp |= value;
1725
1726 status = cx231xx_write_i2c_data(dev, dev_addr, saddr, 2, temp, 4);
1727
1728 return status;
1729}
1730
1731u32 cx231xx_set_field(u32 field_mask, u32 data)
1732{
1733 u32 temp;
1734
1735 for (temp = field_mask; (temp & 1) == 0; temp >>= 1)
1736 data <<= 1;
1737
1738 return data;
1739}
1740
