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