Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ivtv-driver.c
Go to the documentation of this file.
1 /*
2  ivtv driver initialization and card probing
3  Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com>
4  Copyright (C) 2004 Chris Kennedy <[email protected]>
5  Copyright (C) 2005-2007 Hans Verkuil <[email protected]>
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 2 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program; if not, write to the Free Software
19  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20  */
21 
22 /* Main Driver file for the ivtv project:
23  * Driver for the Conexant CX23415/CX23416 chip.
24  * Author: Kevin Thayer (nufan_wfk at yahoo.com)
25  * License: GPL
26  * http://www.ivtvdriver.org
27  *
28  * -----
29  * MPG600/MPG160 support by T.Adachi <[email protected]>
30  * and Takeru KOMORIYA<[email protected]>
31  *
32  * AVerMedia M179 GPIO info by Chris Pinkham <[email protected]>
33  * using information provided by Jiun-Kuei Jung @ AVerMedia.
34  *
35  * Kurouto Sikou CX23416GYC-STVLP tested by K.Ohta <[email protected]>
36  * using information from T.Adachi,Takeru KOMORIYA and others :-)
37  *
38  * Nagase TRANSGEAR 5000TV, Aopen VA2000MAX-STN6 and I/O data GV-MVP/RX
39  * version by T.Adachi. Special thanks Mr.Suzuki
40  */
41 
42 #include "ivtv-driver.h"
43 #include "ivtv-version.h"
44 #include "ivtv-fileops.h"
45 #include "ivtv-i2c.h"
46 #include "ivtv-firmware.h"
47 #include "ivtv-queue.h"
48 #include "ivtv-udma.h"
49 #include "ivtv-irq.h"
50 #include "ivtv-mailbox.h"
51 #include "ivtv-streams.h"
52 #include "ivtv-ioctl.h"
53 #include "ivtv-cards.h"
54 #include "ivtv-vbi.h"
55 #include "ivtv-routing.h"
56 #include "ivtv-controls.h"
57 #include "ivtv-gpio.h"
58 #include <linux/dma-mapping.h>
59 #include <media/tveeprom.h>
60 #include <media/saa7115.h>
61 #include <media/v4l2-chip-ident.h>
62 #include "tuner-xc2028.h"
63 
64 /* If you have already X v4l cards, then set this to X. This way
65  the device numbers stay matched. Example: you have a WinTV card
66  without radio and a PVR-350 with. Normally this would give a
67  video1 device together with a radio0 device for the PVR. By
68  setting this to 1 you ensure that radio0 is now also radio1. */
69 int ivtv_first_minor;
70 
71 /* Callback for registering extensions */
72 int (*ivtv_ext_init)(struct ivtv *);
73 EXPORT_SYMBOL(ivtv_ext_init);
74 
75 /* add your revision and whatnot here */
76 static struct pci_device_id ivtv_pci_tbl[] __devinitdata = {
77  {PCI_VENDOR_ID_ICOMP, PCI_DEVICE_ID_IVTV15,
78  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
79  {PCI_VENDOR_ID_ICOMP, PCI_DEVICE_ID_IVTV16,
80  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
81  {0,}
82 };
83 
84 MODULE_DEVICE_TABLE(pci,ivtv_pci_tbl);
85 
86 /* ivtv instance counter */
87 static atomic_t ivtv_instance = ATOMIC_INIT(0);
88 
89 /* Parameter declarations */
90 static int cardtype[IVTV_MAX_CARDS];
91 static int tuner[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
92  -1, -1, -1, -1, -1, -1, -1, -1,
93  -1, -1, -1, -1, -1, -1, -1, -1,
94  -1, -1, -1, -1, -1, -1, -1, -1 };
95 static int radio[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
96  -1, -1, -1, -1, -1, -1, -1, -1,
97  -1, -1, -1, -1, -1, -1, -1, -1,
98  -1, -1, -1, -1, -1, -1, -1, -1 };
99 static int i2c_clock_period[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
100  -1, -1, -1, -1, -1, -1, -1, -1,
101  -1, -1, -1, -1, -1, -1, -1, -1,
102  -1, -1, -1, -1, -1, -1, -1, -1 };
103 
104 static unsigned int cardtype_c = 1;
105 static unsigned int tuner_c = 1;
106 static int radio_c = 1;
107 static unsigned int i2c_clock_period_c = 1;
108 static char pal[] = "---";
109 static char secam[] = "--";
110 static char ntsc[] = "-";
111 
112 /* Buffers */
113 
114 /* DMA Buffers, Default size in MB allocated */
115 #define IVTV_DEFAULT_ENC_MPG_BUFFERS 4
116 #define IVTV_DEFAULT_ENC_YUV_BUFFERS 2
117 #define IVTV_DEFAULT_ENC_VBI_BUFFERS 1
118 /* Exception: size in kB for this stream (MB is overkill) */
119 #define IVTV_DEFAULT_ENC_PCM_BUFFERS 320
120 #define IVTV_DEFAULT_DEC_MPG_BUFFERS 1
121 #define IVTV_DEFAULT_DEC_YUV_BUFFERS 1
122 /* Exception: size in kB for this stream (MB is way overkill) */
123 #define IVTV_DEFAULT_DEC_VBI_BUFFERS 64
124 
125 static int enc_mpg_buffers = IVTV_DEFAULT_ENC_MPG_BUFFERS;
126 static int enc_yuv_buffers = IVTV_DEFAULT_ENC_YUV_BUFFERS;
127 static int enc_vbi_buffers = IVTV_DEFAULT_ENC_VBI_BUFFERS;
128 static int enc_pcm_buffers = IVTV_DEFAULT_ENC_PCM_BUFFERS;
129 static int dec_mpg_buffers = IVTV_DEFAULT_DEC_MPG_BUFFERS;
130 static int dec_yuv_buffers = IVTV_DEFAULT_DEC_YUV_BUFFERS;
131 static int dec_vbi_buffers = IVTV_DEFAULT_DEC_VBI_BUFFERS;
132 
133 static int ivtv_yuv_mode;
134 static int ivtv_yuv_threshold = -1;
135 static int ivtv_pci_latency = 1;
136 
137 int ivtv_debug;
138 #ifdef CONFIG_VIDEO_ADV_DEBUG
139 int ivtv_fw_debug;
140 #endif
141 
142 static int tunertype = -1;
143 static int newi2c = -1;
144 
145 module_param_array(tuner, int, &tuner_c, 0644);
146 module_param_array(radio, int, &radio_c, 0644);
147 module_param_array(cardtype, int, &cardtype_c, 0644);
148 module_param_string(pal, pal, sizeof(pal), 0644);
149 module_param_string(secam, secam, sizeof(secam), 0644);
150 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
151 module_param_named(debug,ivtv_debug, int, 0644);
152 #ifdef CONFIG_VIDEO_ADV_DEBUG
153 module_param_named(fw_debug, ivtv_fw_debug, int, 0644);
154 #endif
155 module_param(ivtv_pci_latency, int, 0644);
156 module_param(ivtv_yuv_mode, int, 0644);
157 module_param(ivtv_yuv_threshold, int, 0644);
158 module_param(ivtv_first_minor, int, 0644);
159 
160 module_param(enc_mpg_buffers, int, 0644);
161 module_param(enc_yuv_buffers, int, 0644);
162 module_param(enc_vbi_buffers, int, 0644);
163 module_param(enc_pcm_buffers, int, 0644);
164 module_param(dec_mpg_buffers, int, 0644);
165 module_param(dec_yuv_buffers, int, 0644);
166 module_param(dec_vbi_buffers, int, 0644);
167 
168 module_param(tunertype, int, 0644);
169 module_param(newi2c, int, 0644);
170 module_param_array(i2c_clock_period, int, &i2c_clock_period_c, 0644);
171 
172 MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
173  "\t\t\tsee tuner.h for values");
174 MODULE_PARM_DESC(radio,
175  "Enable or disable the radio. Use only if autodetection\n"
176  "\t\t\tfails. 0 = disable, 1 = enable");
177 MODULE_PARM_DESC(cardtype,
178  "Only use this option if your card is not detected properly.\n"
179  "\t\tSpecify card type:\n"
180  "\t\t\t 1 = WinTV PVR 250\n"
181  "\t\t\t 2 = WinTV PVR 350\n"
182  "\t\t\t 3 = WinTV PVR-150 or PVR-500\n"
183  "\t\t\t 4 = AVerMedia M179\n"
184  "\t\t\t 5 = YUAN MPG600/Kuroutoshikou iTVC16-STVLP\n"
185  "\t\t\t 6 = YUAN MPG160/Kuroutoshikou iTVC15-STVLP\n"
186  "\t\t\t 7 = YUAN PG600/DIAMONDMM PVR-550 (CX Falcon 2)\n"
187  "\t\t\t 8 = Adaptec AVC-2410\n"
188  "\t\t\t 9 = Adaptec AVC-2010\n"
189  "\t\t\t10 = NAGASE TRANSGEAR 5000TV\n"
190  "\t\t\t11 = AOpen VA2000MAX-STN6\n"
191  "\t\t\t12 = YUAN MPG600GR/Kuroutoshikou CX23416GYC-STVLP\n"
192  "\t\t\t13 = I/O Data GV-MVP/RX\n"
193  "\t\t\t14 = I/O Data GV-MVP/RX2E\n"
194  "\t\t\t15 = GOTVIEW PCI DVD\n"
195  "\t\t\t16 = GOTVIEW PCI DVD2 Deluxe\n"
196  "\t\t\t17 = Yuan MPC622\n"
197  "\t\t\t18 = Digital Cowboy DCT-MTVP1\n"
198  "\t\t\t19 = Yuan PG600V2/GotView PCI DVD Lite\n"
199  "\t\t\t20 = Club3D ZAP-TV1x01\n"
200  "\t\t\t21 = AverTV MCE 116 Plus\n"
201  "\t\t\t22 = ASUS Falcon2\n"
202  "\t\t\t23 = AverMedia PVR-150 Plus\n"
203  "\t\t\t24 = AverMedia EZMaker PCI Deluxe\n"
204  "\t\t\t25 = AverMedia M104 (not yet working)\n"
205  "\t\t\t26 = Buffalo PC-MV5L/PCI\n"
206  "\t\t\t27 = AVerMedia UltraTV 1500 MCE\n"
207  "\t\t\t28 = Sony VAIO Giga Pocket (ENX Kikyou)\n"
208  "\t\t\t 0 = Autodetect (default)\n"
209  "\t\t\t-1 = Ignore this card\n\t\t");
210 MODULE_PARM_DESC(pal, "Set PAL standard: BGH, DK, I, M, N, Nc, 60");
211 MODULE_PARM_DESC(secam, "Set SECAM standard: BGH, DK, L, LC");
212 MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J (Japan), K (South Korea)");
213 MODULE_PARM_DESC(tunertype,
214  "Specify tuner type:\n"
215  "\t\t\t 0 = tuner for PAL-B/G/H/D/K/I, SECAM-B/G/H/D/K/L/Lc\n"
216  "\t\t\t 1 = tuner for NTSC-M/J/K, PAL-M/N/Nc\n"
217  "\t\t\t-1 = Autodetect (default)\n");
218 MODULE_PARM_DESC(debug,
219  "Debug level (bitmask). Default: 0\n"
220  "\t\t\t 1/0x0001: warning\n"
221  "\t\t\t 2/0x0002: info\n"
222  "\t\t\t 4/0x0004: mailbox\n"
223  "\t\t\t 8/0x0008: ioctl\n"
224  "\t\t\t 16/0x0010: file\n"
225  "\t\t\t 32/0x0020: dma\n"
226  "\t\t\t 64/0x0040: irq\n"
227  "\t\t\t 128/0x0080: decoder\n"
228  "\t\t\t 256/0x0100: yuv\n"
229  "\t\t\t 512/0x0200: i2c\n"
230  "\t\t\t1024/0x0400: high volume\n");
231 #ifdef CONFIG_VIDEO_ADV_DEBUG
232 MODULE_PARM_DESC(fw_debug,
233  "Enable code for debugging firmware problems. Default: 0\n");
234 #endif
235 MODULE_PARM_DESC(ivtv_pci_latency,
236  "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
237  "\t\t\tDefault: Yes");
238 MODULE_PARM_DESC(ivtv_yuv_mode,
239  "Specify the yuv playback mode:\n"
240  "\t\t\t0 = interlaced\n\t\t\t1 = progressive\n\t\t\t2 = auto\n"
241  "\t\t\tDefault: 0 (interlaced)");
242 MODULE_PARM_DESC(ivtv_yuv_threshold,
243  "If ivtv_yuv_mode is 2 (auto) then playback content as\n\t\tprogressive if src height <= ivtv_yuvthreshold\n"
244  "\t\t\tDefault: 480");
245 MODULE_PARM_DESC(enc_mpg_buffers,
246  "Encoder MPG Buffers (in MB)\n"
247  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_MPG_BUFFERS));
248 MODULE_PARM_DESC(enc_yuv_buffers,
249  "Encoder YUV Buffers (in MB)\n"
250  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_YUV_BUFFERS));
251 MODULE_PARM_DESC(enc_vbi_buffers,
252  "Encoder VBI Buffers (in MB)\n"
253  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_VBI_BUFFERS));
254 MODULE_PARM_DESC(enc_pcm_buffers,
255  "Encoder PCM buffers (in kB)\n"
256  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_PCM_BUFFERS));
257 MODULE_PARM_DESC(dec_mpg_buffers,
258  "Decoder MPG buffers (in MB)\n"
259  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_MPG_BUFFERS));
260 MODULE_PARM_DESC(dec_yuv_buffers,
261  "Decoder YUV buffers (in MB)\n"
262  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_YUV_BUFFERS));
263 MODULE_PARM_DESC(dec_vbi_buffers,
264  "Decoder VBI buffers (in kB)\n"
265  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_VBI_BUFFERS));
266 MODULE_PARM_DESC(newi2c,
267  "Use new I2C implementation\n"
268  "\t\t\t-1 is autodetect, 0 is off, 1 is on\n"
269  "\t\t\tDefault is autodetect");
270 MODULE_PARM_DESC(i2c_clock_period,
271  "Period of SCL for the I2C bus controlled by the CX23415/6\n"
272  "\t\t\tMin: 10 usec (100 kHz), Max: 4500 usec (222 Hz)\n"
273  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_I2C_CLOCK_PERIOD));
274 
275 MODULE_PARM_DESC(ivtv_first_minor, "Set device node number assigned to first card");
276 
277 MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
278 MODULE_DESCRIPTION("CX23415/CX23416 driver");
279 MODULE_SUPPORTED_DEVICE
280  ("CX23415/CX23416 MPEG2 encoder (WinTV PVR-150/250/350/500,\n"
281  "\t\t\tYuan MPG series and similar)");
282 MODULE_LICENSE("GPL");
283 
284 MODULE_VERSION(IVTV_VERSION);
285 
286 #if defined(CONFIG_MODULES) && defined(MODULE)
287 static void request_module_async(struct work_struct *work)
288 {
289  struct ivtv *dev = container_of(work, struct ivtv, request_module_wk);
290 
291  /* Make sure ivtv-alsa module is loaded */
292  request_module("ivtv-alsa");
293 
294  /* Initialize ivtv-alsa for this instance of the cx18 device */
295  if (ivtv_ext_init != NULL)
296  ivtv_ext_init(dev);
297 }
298 
299 static void request_modules(struct ivtv *dev)
300 {
301  INIT_WORK(&dev->request_module_wk, request_module_async);
302  schedule_work(&dev->request_module_wk);
303 }
304 
305 static void flush_request_modules(struct ivtv *dev)
306 {
307  flush_work_sync(&dev->request_module_wk);
308 }
309 #else
310 #define request_modules(dev)
311 #define flush_request_modules(dev)
312 #endif /* CONFIG_MODULES */
313 
314 void ivtv_clear_irq_mask(struct ivtv *itv, u32 mask)
315 {
316  itv->irqmask &= ~mask;
317  write_reg_sync(itv->irqmask, IVTV_REG_IRQMASK);
318 }
319 
320 void ivtv_set_irq_mask(struct ivtv *itv, u32 mask)
321 {
322  itv->irqmask |= mask;
323  write_reg_sync(itv->irqmask, IVTV_REG_IRQMASK);
324 }
325 
326 int ivtv_set_output_mode(struct ivtv *itv, int mode)
327 {
328  int old_mode;
329 
330  spin_lock(&itv->lock);
331  old_mode = itv->output_mode;
332  if (old_mode == 0)
333  itv->output_mode = old_mode = mode;
334  spin_unlock(&itv->lock);
335  return old_mode;
336 }
337 
338 struct ivtv_stream *ivtv_get_output_stream(struct ivtv *itv)
339 {
340  switch (itv->output_mode) {
341  case OUT_MPG:
342  return &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
343  case OUT_YUV:
344  return &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
345  default:
346  return NULL;
347  }
348 }
349 
350 int ivtv_waitq(wait_queue_head_t *waitq)
351 {
352  DEFINE_WAIT(wait);
353 
354  prepare_to_wait(waitq, &wait, TASK_INTERRUPTIBLE);
355  schedule();
356  finish_wait(waitq, &wait);
357  return signal_pending(current) ? -EINTR : 0;
358 }
359 
360 /* Generic utility functions */
361 int ivtv_msleep_timeout(unsigned int msecs, int intr)
362 {
363  int timeout = msecs_to_jiffies(msecs);
364 
365  do {
366  set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
367  timeout = schedule_timeout(timeout);
368  if (intr) {
369  int ret = signal_pending(current);
370 
371  if (ret)
372  return ret;
373  }
374  } while (timeout);
375  return 0;
376 }
377 
378 /* Release ioremapped memory */
379 static void ivtv_iounmap(struct ivtv *itv)
380 {
381  if (itv == NULL)
382  return;
383 
384  /* Release registers memory */
385  if (itv->reg_mem != NULL) {
386  IVTV_DEBUG_INFO("releasing reg_mem\n");
387  iounmap(itv->reg_mem);
388  itv->reg_mem = NULL;
389  }
390  /* Release io memory */
391  if (itv->has_cx23415 && itv->dec_mem != NULL) {
392  IVTV_DEBUG_INFO("releasing dec_mem\n");
393  iounmap(itv->dec_mem);
394  }
395  itv->dec_mem = NULL;
396 
397  /* Release io memory */
398  if (itv->enc_mem != NULL) {
399  IVTV_DEBUG_INFO("releasing enc_mem\n");
400  iounmap(itv->enc_mem);
401  itv->enc_mem = NULL;
402  }
403 }
404 
405 /* Hauppauge card? get values from tveeprom */
406 void ivtv_read_eeprom(struct ivtv *itv, struct tveeprom *tv)
407 {
408  u8 eedata[256];
409 
410  itv->i2c_client.addr = 0xA0 >> 1;
411  tveeprom_read(&itv->i2c_client, eedata, sizeof(eedata));
412  tveeprom_hauppauge_analog(&itv->i2c_client, tv, eedata);
413 }
414 
415 static void ivtv_process_eeprom(struct ivtv *itv)
416 {
417  struct tveeprom tv;
418  int pci_slot = PCI_SLOT(itv->pdev->devfn);
419 
420  ivtv_read_eeprom(itv, &tv);
421 
422  /* Many thanks to Steven Toth from Hauppauge for providing the
423  model numbers */
424  switch (tv.model) {
425  /* In a few cases the PCI subsystem IDs do not correctly
426  identify the card. A better method is to check the
427  model number from the eeprom instead. */
428  case 30012 ... 30039: /* Low profile PVR250 */
429  case 32000 ... 32999:
430  case 48000 ... 48099: /* 48??? range are PVR250s with a cx23415 */
431  case 48400 ... 48599:
432  itv->card = ivtv_get_card(IVTV_CARD_PVR_250);
433  break;
434  case 48100 ... 48399:
435  case 48600 ... 48999:
436  itv->card = ivtv_get_card(IVTV_CARD_PVR_350);
437  break;
438  case 23000 ... 23999: /* PVR500 */
439  case 25000 ... 25999: /* Low profile PVR150 */
440  case 26000 ... 26999: /* Regular PVR150 */
441  itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
442  break;
443  case 0:
444  IVTV_ERR("Invalid EEPROM\n");
445  return;
446  default:
447  IVTV_ERR("Unknown model %d, defaulting to PVR-150\n", tv.model);
448  itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
449  break;
450  }
451 
452  switch (tv.model) {
453  /* Old style PVR350 (with an saa7114) uses this input for
454  the tuner. */
455  case 48254:
456  itv->card = ivtv_get_card(IVTV_CARD_PVR_350_V1);
457  break;
458  default:
459  break;
460  }
461 
462  itv->v4l2_cap = itv->card->v4l2_capabilities;
463  itv->card_name = itv->card->name;
464  itv->card_i2c = itv->card->i2c;
465 
466  /* If this is a PVR500 then it should be possible to detect whether it is the
467  first or second unit by looking at the subsystem device ID: is bit 4 is
468  set, then it is the second unit (according to info from Hauppauge).
469 
470  However, while this works for most cards, I have seen a few PVR500 cards
471  where both units have the same subsystem ID.
472 
473  So instead I look at the reported 'PCI slot' (which is the slot on the PVR500
474  PCI bridge) and if it is 8, then it is assumed to be the first unit, otherwise
475  it is the second unit. It is possible that it is a different slot when ivtv is
476  used in Xen, in that case I ignore this card here. The worst that can happen
477  is that the card presents itself with a non-working radio device.
478 
479  This detection is needed since the eeprom reports incorrectly that a radio is
480  present on the second unit. */
481  if (tv.model / 1000 == 23) {
482  static const struct ivtv_card_tuner_i2c ivtv_i2c_radio = {
483  .radio = { 0x60, I2C_CLIENT_END },
484  .demod = { 0x43, I2C_CLIENT_END },
485  .tv = { 0x61, I2C_CLIENT_END },
486  };
487 
488  itv->card_name = "WinTV PVR 500";
489  itv->card_i2c = &ivtv_i2c_radio;
490  if (pci_slot == 8 || pci_slot == 9) {
491  int is_first = (pci_slot & 1) == 0;
492 
493  itv->card_name = is_first ? "WinTV PVR 500 (unit #1)" :
494  "WinTV PVR 500 (unit #2)";
495  if (!is_first) {
496  IVTV_INFO("Correcting tveeprom data: no radio present on second unit\n");
497  tv.has_radio = 0;
498  }
499  }
500  }
501  IVTV_INFO("Autodetected %s\n", itv->card_name);
502 
503  switch (tv.tuner_hauppauge_model) {
504  case 85:
505  case 99:
506  case 112:
507  itv->pvr150_workaround = 1;
508  break;
509  default:
510  break;
511  }
512  if (tv.tuner_type == TUNER_ABSENT)
513  IVTV_ERR("tveeprom cannot autodetect tuner!\n");
514 
515  if (itv->options.tuner == -1)
516  itv->options.tuner = tv.tuner_type;
517  if (itv->options.radio == -1)
518  itv->options.radio = (tv.has_radio != 0);
519  /* only enable newi2c if an IR blaster is present */
520  if (itv->options.newi2c == -1 && tv.has_ir) {
521  itv->options.newi2c = (tv.has_ir & 4) ? 1 : 0;
522  if (itv->options.newi2c) {
523  IVTV_INFO("Reopen i2c bus for IR-blaster support\n");
524  exit_ivtv_i2c(itv);
525  init_ivtv_i2c(itv);
526  }
527  }
528 
529  if (itv->std != 0)
530  /* user specified tuner standard */
531  return;
532 
533  /* autodetect tuner standard */
534  if (tv.tuner_formats & V4L2_STD_PAL) {
535  IVTV_DEBUG_INFO("PAL tuner detected\n");
536  itv->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
537  } else if (tv.tuner_formats & V4L2_STD_NTSC) {
538  IVTV_DEBUG_INFO("NTSC tuner detected\n");
539  itv->std |= V4L2_STD_NTSC_M;
540  } else if (tv.tuner_formats & V4L2_STD_SECAM) {
541  IVTV_DEBUG_INFO("SECAM tuner detected\n");
542  itv->std |= V4L2_STD_SECAM_L;
543  } else {
544  IVTV_INFO("No tuner detected, default to NTSC-M\n");
545  itv->std |= V4L2_STD_NTSC_M;
546  }
547 }
548 
549 static v4l2_std_id ivtv_parse_std(struct ivtv *itv)
550 {
551  switch (pal[0]) {
552  case '6':
553  tunertype = 0;
554  return V4L2_STD_PAL_60;
555  case 'b':
556  case 'B':
557  case 'g':
558  case 'G':
559  case 'h':
560  case 'H':
561  tunertype = 0;
562  return V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
563  case 'n':
564  case 'N':
565  tunertype = 1;
566  if (pal[1] == 'c' || pal[1] == 'C')
567  return V4L2_STD_PAL_Nc;
568  return V4L2_STD_PAL_N;
569  case 'i':
570  case 'I':
571  tunertype = 0;
572  return V4L2_STD_PAL_I;
573  case 'd':
574  case 'D':
575  case 'k':
576  case 'K':
577  tunertype = 0;
578  return V4L2_STD_PAL_DK;
579  case 'M':
580  case 'm':
581  tunertype = 1;
582  return V4L2_STD_PAL_M;
583  case '-':
584  break;
585  default:
586  IVTV_WARN("pal= argument not recognised\n");
587  return 0;
588  }
589 
590  switch (secam[0]) {
591  case 'b':
592  case 'B':
593  case 'g':
594  case 'G':
595  case 'h':
596  case 'H':
597  tunertype = 0;
598  return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
599  case 'd':
600  case 'D':
601  case 'k':
602  case 'K':
603  tunertype = 0;
604  return V4L2_STD_SECAM_DK;
605  case 'l':
606  case 'L':
607  tunertype = 0;
608  if (secam[1] == 'C' || secam[1] == 'c')
609  return V4L2_STD_SECAM_LC;
610  return V4L2_STD_SECAM_L;
611  case '-':
612  break;
613  default:
614  IVTV_WARN("secam= argument not recognised\n");
615  return 0;
616  }
617 
618  switch (ntsc[0]) {
619  case 'm':
620  case 'M':
621  tunertype = 1;
622  return V4L2_STD_NTSC_M;
623  case 'j':
624  case 'J':
625  tunertype = 1;
626  return V4L2_STD_NTSC_M_JP;
627  case 'k':
628  case 'K':
629  tunertype = 1;
630  return V4L2_STD_NTSC_M_KR;
631  case '-':
632  break;
633  default:
634  IVTV_WARN("ntsc= argument not recognised\n");
635  return 0;
636  }
637 
638  /* no match found */
639  return 0;
640 }
641 
642 static void ivtv_process_options(struct ivtv *itv)
643 {
644  const char *chipname;
645  int i, j;
646 
647  itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers * 1024;
648  itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers * 1024;
649  itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers * 1024;
650  itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
651  itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_MPG] = dec_mpg_buffers * 1024;
652  itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_YUV] = dec_yuv_buffers * 1024;
653  itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_VBI] = dec_vbi_buffers;
654  itv->options.cardtype = cardtype[itv->instance];
655  itv->options.tuner = tuner[itv->instance];
656  itv->options.radio = radio[itv->instance];
657 
658  itv->options.i2c_clock_period = i2c_clock_period[itv->instance];
659  if (itv->options.i2c_clock_period == -1)
660  itv->options.i2c_clock_period = IVTV_DEFAULT_I2C_CLOCK_PERIOD;
661  else if (itv->options.i2c_clock_period < 10)
662  itv->options.i2c_clock_period = 10;
663  else if (itv->options.i2c_clock_period > 4500)
664  itv->options.i2c_clock_period = 4500;
665 
666  itv->options.newi2c = newi2c;
667  if (tunertype < -1 || tunertype > 1) {
668  IVTV_WARN("Invalid tunertype argument, will autodetect instead\n");
669  tunertype = -1;
670  }
671  itv->std = ivtv_parse_std(itv);
672  if (itv->std == 0 && tunertype >= 0)
673  itv->std = tunertype ? V4L2_STD_MN : (V4L2_STD_ALL & ~V4L2_STD_MN);
674  itv->has_cx23415 = (itv->pdev->device == PCI_DEVICE_ID_IVTV15);
675  chipname = itv->has_cx23415 ? "cx23415" : "cx23416";
676  if (itv->options.cardtype == -1) {
677  IVTV_INFO("Ignore card (detected %s based chip)\n", chipname);
678  return;
679  }
680  if ((itv->card = ivtv_get_card(itv->options.cardtype - 1))) {
681  IVTV_INFO("User specified %s card (detected %s based chip)\n",
682  itv->card->name, chipname);
683  } else if (itv->options.cardtype != 0) {
684  IVTV_ERR("Unknown user specified type, trying to autodetect card\n");
685  }
686  if (itv->card == NULL) {
687  if (itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE ||
688  itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT1 ||
689  itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT2) {
690  itv->card = ivtv_get_card(itv->has_cx23415 ? IVTV_CARD_PVR_350 : IVTV_CARD_PVR_150);
691  IVTV_INFO("Autodetected Hauppauge card (%s based)\n",
692  chipname);
693  }
694  }
695  if (itv->card == NULL) {
696  for (i = 0; (itv->card = ivtv_get_card(i)); i++) {
697  if (itv->card->pci_list == NULL)
698  continue;
699  for (j = 0; itv->card->pci_list[j].device; j++) {
700  if (itv->pdev->device !=
701  itv->card->pci_list[j].device)
702  continue;
703  if (itv->pdev->subsystem_vendor !=
704  itv->card->pci_list[j].subsystem_vendor)
705  continue;
706  if (itv->pdev->subsystem_device !=
707  itv->card->pci_list[j].subsystem_device)
708  continue;
709  IVTV_INFO("Autodetected %s card (%s based)\n",
710  itv->card->name, chipname);
711  goto done;
712  }
713  }
714  }
715 done:
716 
717  if (itv->card == NULL) {
718  itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
719  IVTV_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
720  itv->pdev->vendor, itv->pdev->device);
721  IVTV_ERR(" subsystem vendor/device: [%04x:%04x]\n",
722  itv->pdev->subsystem_vendor, itv->pdev->subsystem_device);
723  IVTV_ERR(" %s based\n", chipname);
724  IVTV_ERR("Defaulting to %s card\n", itv->card->name);
725  IVTV_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
726  IVTV_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
727  IVTV_ERR("Prefix your subject line with [UNKNOWN IVTV CARD].\n");
728  }
729  itv->v4l2_cap = itv->card->v4l2_capabilities;
730  itv->card_name = itv->card->name;
731  itv->card_i2c = itv->card->i2c;
732 }
733 
734 /* Precondition: the ivtv structure has been memset to 0. Only
735  the dev and num fields have been filled in.
736  No assumptions on the card type may be made here (see ivtv_init_struct2
737  for that).
738  */
739 static int __devinit ivtv_init_struct1(struct ivtv *itv)
740 {
741  struct sched_param param = { .sched_priority = 99 };
742 
743  itv->base_addr = pci_resource_start(itv->pdev, 0);
744  itv->enc_mbox.max_mbox = 2; /* the encoder has 3 mailboxes (0-2) */
745  itv->dec_mbox.max_mbox = 1; /* the decoder has 2 mailboxes (0-1) */
746 
747  mutex_init(&itv->serialize_lock);
748  mutex_init(&itv->i2c_bus_lock);
749  mutex_init(&itv->udma.lock);
750 
751  spin_lock_init(&itv->lock);
752  spin_lock_init(&itv->dma_reg_lock);
753 
754  init_kthread_worker(&itv->irq_worker);
755  itv->irq_worker_task = kthread_run(kthread_worker_fn, &itv->irq_worker,
756  itv->v4l2_dev.name);
757  if (IS_ERR(itv->irq_worker_task)) {
758  IVTV_ERR("Could not create ivtv task\n");
759  return -1;
760  }
761  /* must use the FIFO scheduler as it is realtime sensitive */
762  sched_setscheduler(itv->irq_worker_task, SCHED_FIFO, &param);
763 
764  init_kthread_work(&itv->irq_work, ivtv_irq_work_handler);
765 
766  /* Initial settings */
767  itv->cxhdl.port = CX2341X_PORT_MEMORY;
768  itv->cxhdl.capabilities = CX2341X_CAP_HAS_SLICED_VBI;
769  init_waitqueue_head(&itv->eos_waitq);
770  init_waitqueue_head(&itv->event_waitq);
771  init_waitqueue_head(&itv->vsync_waitq);
772  init_waitqueue_head(&itv->dma_waitq);
773  init_timer(&itv->dma_timer);
774  itv->dma_timer.function = ivtv_unfinished_dma;
775  itv->dma_timer.data = (unsigned long)itv;
776 
777  itv->cur_dma_stream = -1;
778  itv->cur_pio_stream = -1;
779 
780  /* Ctrls */
781  itv->speed = 1000;
782 
783  /* VBI */
784  itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
785  itv->vbi.sliced_in = &itv->vbi.in.fmt.sliced;
786 
787  /* Init the sg table for osd/yuv output */
788  sg_init_table(itv->udma.SGlist, IVTV_DMA_SG_OSD_ENT);
789 
790  /* OSD */
791  itv->osd_global_alpha_state = 1;
792  itv->osd_global_alpha = 255;
793 
794  /* YUV */
795  atomic_set(&itv->yuv_info.next_dma_frame, -1);
796  itv->yuv_info.lace_mode = ivtv_yuv_mode;
797  itv->yuv_info.lace_threshold = ivtv_yuv_threshold;
798  itv->yuv_info.max_frames_buffered = 3;
799  itv->yuv_info.track_osd = 1;
800  return 0;
801 }
802 
803 /* Second initialization part. Here the card type has been
804  autodetected. */
805 static void __devinit ivtv_init_struct2(struct ivtv *itv)
806 {
807  int i;
808 
809  for (i = 0; i < IVTV_CARD_MAX_VIDEO_INPUTS; i++)
810  if (itv->card->video_inputs[i].video_type == 0)
811  break;
812  itv->nof_inputs = i;
813  for (i = 0; i < IVTV_CARD_MAX_AUDIO_INPUTS; i++)
814  if (itv->card->audio_inputs[i].audio_type == 0)
815  break;
816  itv->nof_audio_inputs = i;
817 
818  if (itv->card->hw_all & IVTV_HW_CX25840) {
819  itv->vbi.sliced_size = 288; /* multiple of 16, real size = 284 */
820  } else {
821  itv->vbi.sliced_size = 64; /* multiple of 16, real size = 52 */
822  }
823 
824  /* Find tuner input */
825  for (i = 0; i < itv->nof_inputs; i++) {
826  if (itv->card->video_inputs[i].video_type ==
827  IVTV_CARD_INPUT_VID_TUNER)
828  break;
829  }
830  if (i == itv->nof_inputs)
831  i = 0;
832  itv->active_input = i;
833  itv->audio_input = itv->card->video_inputs[i].audio_index;
834 }
835 
836 static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *pdev,
837  const struct pci_device_id *pci_id)
838 {
839  u16 cmd;
840  unsigned char pci_latency;
841 
842  IVTV_DEBUG_INFO("Enabling pci device\n");
843 
844  if (pci_enable_device(pdev)) {
845  IVTV_ERR("Can't enable device!\n");
846  return -EIO;
847  }
848  if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
849  IVTV_ERR("No suitable DMA available.\n");
850  return -EIO;
851  }
852  if (!request_mem_region(itv->base_addr, IVTV_ENCODER_SIZE, "ivtv encoder")) {
853  IVTV_ERR("Cannot request encoder memory region.\n");
854  return -EIO;
855  }
856 
857  if (!request_mem_region(itv->base_addr + IVTV_REG_OFFSET,
858  IVTV_REG_SIZE, "ivtv registers")) {
859  IVTV_ERR("Cannot request register memory region.\n");
860  release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
861  return -EIO;
862  }
863 
864  if (itv->has_cx23415 &&
865  !request_mem_region(itv->base_addr + IVTV_DECODER_OFFSET,
866  IVTV_DECODER_SIZE, "ivtv decoder")) {
867  IVTV_ERR("Cannot request decoder memory region.\n");
868  release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
869  release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
870  return -EIO;
871  }
872 
873  /* Check for bus mastering */
874  pci_read_config_word(pdev, PCI_COMMAND, &cmd);
875  if (!(cmd & PCI_COMMAND_MASTER)) {
876  IVTV_DEBUG_INFO("Attempting to enable Bus Mastering\n");
877  pci_set_master(pdev);
878  pci_read_config_word(pdev, PCI_COMMAND, &cmd);
879  if (!(cmd & PCI_COMMAND_MASTER)) {
880  IVTV_ERR("Bus Mastering is not enabled\n");
881  return -ENXIO;
882  }
883  }
884  IVTV_DEBUG_INFO("Bus Mastering Enabled.\n");
885 
886  pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
887 
888  if (pci_latency < 64 && ivtv_pci_latency) {
889  IVTV_INFO("Unreasonably low latency timer, "
890  "setting to 64 (was %d)\n", pci_latency);
891  pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 64);
892  pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
893  }
894  /* This config space value relates to DMA latencies. The
895  default value 0x8080 is too low however and will lead
896  to DMA errors. 0xffff is the max value which solves
897  these problems. */
898  pci_write_config_dword(pdev, 0x40, 0xffff);
899 
900  IVTV_DEBUG_INFO("%d (rev %d) at %02x:%02x.%x, "
901  "irq: %d, latency: %d, memory: 0x%llx\n",
902  pdev->device, pdev->revision, pdev->bus->number,
903  PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
904  pdev->irq, pci_latency, (u64)itv->base_addr);
905 
906  return 0;
907 }
908 
909 static void ivtv_load_and_init_modules(struct ivtv *itv)
910 {
911  u32 hw = itv->card->hw_all;
912  unsigned i;
913 
914  /* check which i2c devices are actually found */
915  for (i = 0; i < 32; i++) {
916  u32 device = 1 << i;
917 
918  if (!(device & hw))
919  continue;
920  if (device == IVTV_HW_GPIO || device == IVTV_HW_TVEEPROM) {
921  /* GPIO and TVEEPROM do not use i2c probing */
922  itv->hw_flags |= device;
923  continue;
924  }
925  if (ivtv_i2c_register(itv, i) == 0)
926  itv->hw_flags |= device;
927  }
928 
929  /* probe for legacy IR controllers that aren't in card definitions */
930  if ((itv->hw_flags & IVTV_HW_IR_ANY) == 0)
931  ivtv_i2c_new_ir_legacy(itv);
932 
933  if (itv->card->hw_all & IVTV_HW_CX25840)
934  itv->sd_video = ivtv_find_hw(itv, IVTV_HW_CX25840);
935  else if (itv->card->hw_all & IVTV_HW_SAA717X)
936  itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA717X);
937  else if (itv->card->hw_all & IVTV_HW_SAA7114)
938  itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA7114);
939  else
940  itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA7115);
941  itv->sd_audio = ivtv_find_hw(itv, itv->card->hw_audio_ctrl);
942  itv->sd_muxer = ivtv_find_hw(itv, itv->card->hw_muxer);
943 
944  hw = itv->hw_flags;
945 
946  if (itv->card->type == IVTV_CARD_CX23416GYC) {
947  /* Several variations of this card exist, detect which card
948  type should be used. */
949  if ((hw & (IVTV_HW_UPD64031A | IVTV_HW_UPD6408X)) == 0)
950  itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGRYCS);
951  else if ((hw & IVTV_HW_UPD64031A) == 0)
952  itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGR);
953  }
954  else if (itv->card->type == IVTV_CARD_GV_MVPRX ||
955  itv->card->type == IVTV_CARD_GV_MVPRX2E) {
956  /* The crystal frequency of GVMVPRX is 24.576MHz */
957  v4l2_subdev_call(itv->sd_video, video, s_crystal_freq,
958  SAA7115_FREQ_24_576_MHZ, SAA7115_FREQ_FL_UCGC);
959  }
960 
961  if (hw & IVTV_HW_CX25840) {
962  itv->vbi.raw_decoder_line_size = 1444;
963  itv->vbi.raw_decoder_sav_odd_field = 0x20;
964  itv->vbi.raw_decoder_sav_even_field = 0x60;
965  itv->vbi.sliced_decoder_line_size = 272;
966  itv->vbi.sliced_decoder_sav_odd_field = 0xB0;
967  itv->vbi.sliced_decoder_sav_even_field = 0xF0;
968  }
969 
970  if (hw & IVTV_HW_SAA711X) {
971  struct v4l2_dbg_chip_ident v;
972 
973  /* determine the exact saa711x model */
974  itv->hw_flags &= ~IVTV_HW_SAA711X;
975 
976  v.match.type = V4L2_CHIP_MATCH_I2C_DRIVER;
977  strlcpy(v.match.name, "saa7115", sizeof(v.match.name));
978  ivtv_call_hw(itv, IVTV_HW_SAA711X, core, g_chip_ident, &v);
979  if (v.ident == V4L2_IDENT_SAA7114) {
980  itv->hw_flags |= IVTV_HW_SAA7114;
981  /* VBI is not yet supported by the saa7114 driver. */
982  itv->v4l2_cap &= ~(V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_VBI_CAPTURE);
983  } else {
984  itv->hw_flags |= IVTV_HW_SAA7115;
985  }
986  itv->vbi.raw_decoder_line_size = 1443;
987  itv->vbi.raw_decoder_sav_odd_field = 0x25;
988  itv->vbi.raw_decoder_sav_even_field = 0x62;
989  itv->vbi.sliced_decoder_line_size = 51;
990  itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
991  itv->vbi.sliced_decoder_sav_even_field = 0xEC;
992  }
993 
994  if (hw & IVTV_HW_SAA717X) {
995  itv->vbi.raw_decoder_line_size = 1443;
996  itv->vbi.raw_decoder_sav_odd_field = 0x25;
997  itv->vbi.raw_decoder_sav_even_field = 0x62;
998  itv->vbi.sliced_decoder_line_size = 51;
999  itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
1000  itv->vbi.sliced_decoder_sav_even_field = 0xEC;
1001  }
1002 }
1003 
1004 static int __devinit ivtv_probe(struct pci_dev *pdev,
1005  const struct pci_device_id *pci_id)
1006 {
1007  int retval = 0;
1008  int vbi_buf_size;
1009  struct ivtv *itv;
1010 
1011  itv = kzalloc(sizeof(struct ivtv), GFP_ATOMIC);
1012  if (itv == NULL)
1013  return -ENOMEM;
1014  itv->pdev = pdev;
1015  itv->instance = v4l2_device_set_name(&itv->v4l2_dev, "ivtv",
1016  &ivtv_instance);
1017 
1018  retval = v4l2_device_register(&pdev->dev, &itv->v4l2_dev);
1019  if (retval) {
1020  kfree(itv);
1021  return retval;
1022  }
1023  IVTV_INFO("Initializing card %d\n", itv->instance);
1024 
1025  ivtv_process_options(itv);
1026  if (itv->options.cardtype == -1) {
1027  retval = -ENODEV;
1028  goto err;
1029  }
1030  if (ivtv_init_struct1(itv)) {
1031  retval = -ENOMEM;
1032  goto err;
1033  }
1034  retval = cx2341x_handler_init(&itv->cxhdl, 50);
1035  if (retval)
1036  goto err;
1037  itv->v4l2_dev.ctrl_handler = &itv->cxhdl.hdl;
1038  itv->cxhdl.ops = &ivtv_cxhdl_ops;
1039  itv->cxhdl.priv = itv;
1040  itv->cxhdl.func = ivtv_api_func;
1041 
1042  IVTV_DEBUG_INFO("base addr: 0x%llx\n", (u64)itv->base_addr);
1043 
1044  /* PCI Device Setup */
1045  retval = ivtv_setup_pci(itv, pdev, pci_id);
1046  if (retval == -EIO)
1047  goto free_worker;
1048  if (retval == -ENXIO)
1049  goto free_mem;
1050 
1051  /* map io memory */
1052  IVTV_DEBUG_INFO("attempting ioremap at 0x%llx len 0x%08x\n",
1053  (u64)itv->base_addr + IVTV_ENCODER_OFFSET, IVTV_ENCODER_SIZE);
1054  itv->enc_mem = ioremap_nocache(itv->base_addr + IVTV_ENCODER_OFFSET,
1055  IVTV_ENCODER_SIZE);
1056  if (!itv->enc_mem) {
1057  IVTV_ERR("ioremap failed. Can't get a window into CX23415/6 "
1058  "encoder memory\n");
1059  IVTV_ERR("Each capture card with a CX23415/6 needs 8 MB of "
1060  "vmalloc address space for this window\n");
1061  IVTV_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
1062  IVTV_ERR("Use the vmalloc= kernel command line option to set "
1063  "VmallocTotal to a larger value\n");
1064  retval = -ENOMEM;
1065  goto free_mem;
1066  }
1067 
1068  if (itv->has_cx23415) {
1069  IVTV_DEBUG_INFO("attempting ioremap at 0x%llx len 0x%08x\n",
1070  (u64)itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1071  itv->dec_mem = ioremap_nocache(itv->base_addr + IVTV_DECODER_OFFSET,
1072  IVTV_DECODER_SIZE);
1073  if (!itv->dec_mem) {
1074  IVTV_ERR("ioremap failed. Can't get a window into "
1075  "CX23415 decoder memory\n");
1076  IVTV_ERR("Each capture card with a CX23415 needs 8 MB "
1077  "of vmalloc address space for this window\n");
1078  IVTV_ERR("Check the output of 'grep Vmalloc "
1079  "/proc/meminfo'\n");
1080  IVTV_ERR("Use the vmalloc= kernel command line option "
1081  "to set VmallocTotal to a larger value\n");
1082  retval = -ENOMEM;
1083  goto free_mem;
1084  }
1085  }
1086  else {
1087  itv->dec_mem = itv->enc_mem;
1088  }
1089 
1090  /* map registers memory */
1091  IVTV_DEBUG_INFO("attempting ioremap at 0x%llx len 0x%08x\n",
1092  (u64)itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1093  itv->reg_mem =
1094  ioremap_nocache(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1095  if (!itv->reg_mem) {
1096  IVTV_ERR("ioremap failed. Can't get a window into CX23415/6 "
1097  "register space\n");
1098  IVTV_ERR("Each capture card with a CX23415/6 needs 64 kB of "
1099  "vmalloc address space for this window\n");
1100  IVTV_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
1101  IVTV_ERR("Use the vmalloc= kernel command line option to set "
1102  "VmallocTotal to a larger value\n");
1103  retval = -ENOMEM;
1104  goto free_io;
1105  }
1106 
1107  retval = ivtv_gpio_init(itv);
1108  if (retval)
1109  goto free_io;
1110 
1111  /* active i2c */
1112  IVTV_DEBUG_INFO("activating i2c...\n");
1113  if (init_ivtv_i2c(itv)) {
1114  IVTV_ERR("Could not initialize i2c\n");
1115  goto free_io;
1116  }
1117 
1118  if (itv->card->hw_all & IVTV_HW_TVEEPROM) {
1119  /* Based on the model number the cardtype may be changed.
1120  The PCI IDs are not always reliable. */
1121  ivtv_process_eeprom(itv);
1122  }
1123  if (itv->card->comment)
1124  IVTV_INFO("%s", itv->card->comment);
1125  if (itv->card->v4l2_capabilities == 0) {
1126  /* card was detected but is not supported */
1127  retval = -ENODEV;
1128  goto free_i2c;
1129  }
1130 
1131  if (itv->std == 0) {
1132  itv->std = V4L2_STD_NTSC_M;
1133  }
1134 
1135  if (itv->options.tuner == -1) {
1136  int i;
1137 
1138  for (i = 0; i < IVTV_CARD_MAX_TUNERS; i++) {
1139  if ((itv->std & itv->card->tuners[i].std) == 0)
1140  continue;
1141  itv->options.tuner = itv->card->tuners[i].tuner;
1142  break;
1143  }
1144  }
1145  /* if no tuner was found, then pick the first tuner in the card list */
1146  if (itv->options.tuner == -1 && itv->card->tuners[0].std) {
1147  itv->std = itv->card->tuners[0].std;
1148  if (itv->std & V4L2_STD_PAL)
1149  itv->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
1150  else if (itv->std & V4L2_STD_NTSC)
1151  itv->std = V4L2_STD_NTSC_M;
1152  else if (itv->std & V4L2_STD_SECAM)
1153  itv->std = V4L2_STD_SECAM_L;
1154  itv->options.tuner = itv->card->tuners[0].tuner;
1155  }
1156  if (itv->options.radio == -1)
1157  itv->options.radio = (itv->card->radio_input.audio_type != 0);
1158 
1159  /* The card is now fully identified, continue with card-specific
1160  initialization. */
1161  ivtv_init_struct2(itv);
1162 
1163  ivtv_load_and_init_modules(itv);
1164 
1165  if (itv->std & V4L2_STD_525_60) {
1166  itv->is_60hz = 1;
1167  itv->is_out_60hz = 1;
1168  } else {
1169  itv->is_50hz = 1;
1170  itv->is_out_50hz = 1;
1171  }
1172 
1173  itv->yuv_info.osd_full_w = 720;
1174  itv->yuv_info.osd_full_h = itv->is_out_50hz ? 576 : 480;
1175  itv->yuv_info.v4l2_src_w = itv->yuv_info.osd_full_w;
1176  itv->yuv_info.v4l2_src_h = itv->yuv_info.osd_full_h;
1177 
1178  cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1179 
1180  itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_MPG] = 0x08000;
1181  itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_PCM] = 0x01200;
1182  itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_MPG] = 0x10000;
1183  itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_YUV] = 0x10000;
1184  itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_YUV] = 0x08000;
1185 
1186  /* Setup VBI Raw Size. Should be big enough to hold PAL.
1187  It is possible to switch between PAL and NTSC, so we need to
1188  take the largest size here. */
1189  /* 1456 is multiple of 16, real size = 1444 */
1190  itv->vbi.raw_size = 1456;
1191  /* We use a buffer size of 1/2 of the total size needed for a
1192  frame. This is actually very useful, since we now receive
1193  a field at a time and that makes 'compressing' the raw data
1194  down to size by stripping off the SAV codes a lot easier.
1195  Note: having two different buffer sizes prevents standard
1196  switching on the fly. We need to find a better solution... */
1197  vbi_buf_size = itv->vbi.raw_size * (itv->is_60hz ? 24 : 36) / 2;
1198  itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
1199  itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_VBI] = sizeof(struct v4l2_sliced_vbi_data) * 36;
1200 
1201  if (itv->options.radio > 0)
1202  itv->v4l2_cap |= V4L2_CAP_RADIO;
1203 
1204  if (itv->options.tuner > -1) {
1205  struct tuner_setup setup;
1206 
1207  setup.addr = ADDR_UNSET;
1208  setup.type = itv->options.tuner;
1209  setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
1210  if (itv->options.radio > 0)
1211  setup.mode_mask |= T_RADIO;
1212  setup.tuner_callback = (setup.type == TUNER_XC2028) ?
1213  ivtv_reset_tuner_gpio : NULL;
1214  ivtv_call_all(itv, tuner, s_type_addr, &setup);
1215  if (setup.type == TUNER_XC2028) {
1216  static struct xc2028_ctrl ctrl = {
1217  .fname = XC2028_DEFAULT_FIRMWARE,
1218  .max_len = 64,
1219  };
1220  struct v4l2_priv_tun_config cfg = {
1221  .tuner = itv->options.tuner,
1222  .priv = &ctrl,
1223  };
1224  ivtv_call_all(itv, tuner, s_config, &cfg);
1225  }
1226  }
1227 
1228  /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1229  are not. */
1230  itv->tuner_std = itv->std;
1231 
1232  if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1233  struct v4l2_ctrl_handler *hdl = itv->v4l2_dev.ctrl_handler;
1234 
1235  itv->ctrl_pts = v4l2_ctrl_new_std(hdl, &ivtv_hdl_out_ops,
1236  V4L2_CID_MPEG_VIDEO_DEC_PTS, 0, 0, 0, 0);
1237  itv->ctrl_frame = v4l2_ctrl_new_std(hdl, &ivtv_hdl_out_ops,
1238  V4L2_CID_MPEG_VIDEO_DEC_FRAME, 0, 0, 0, 0);
1239  /* Note: V4L2_MPEG_AUDIO_DEC_PLAYBACK_AUTO is not supported,
1240  mask that menu item. */
1241  itv->ctrl_audio_playback =
1242  v4l2_ctrl_new_std_menu(hdl, &ivtv_hdl_out_ops,
1243  V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK,
1244  V4L2_MPEG_AUDIO_DEC_PLAYBACK_SWAPPED_STEREO,
1245  1 << V4L2_MPEG_AUDIO_DEC_PLAYBACK_AUTO,
1246  V4L2_MPEG_AUDIO_DEC_PLAYBACK_STEREO);
1247  itv->ctrl_audio_multilingual_playback =
1248  v4l2_ctrl_new_std_menu(hdl, &ivtv_hdl_out_ops,
1249  V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK,
1250  V4L2_MPEG_AUDIO_DEC_PLAYBACK_SWAPPED_STEREO,
1251  1 << V4L2_MPEG_AUDIO_DEC_PLAYBACK_AUTO,
1252  V4L2_MPEG_AUDIO_DEC_PLAYBACK_LEFT);
1253  if (hdl->error) {
1254  retval = hdl->error;
1255  goto free_i2c;
1256  }
1257  v4l2_ctrl_cluster(2, &itv->ctrl_pts);
1258  v4l2_ctrl_cluster(2, &itv->ctrl_audio_playback);
1259  ivtv_call_all(itv, video, s_std_output, itv->std);
1260  /* Turn off the output signal. The mpeg decoder is not yet
1261  active so without this you would get a green image until the
1262  mpeg decoder becomes active. */
1263  ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 0);
1264  }
1265 
1266  /* clear interrupt mask, effectively disabling interrupts */
1267  ivtv_set_irq_mask(itv, 0xffffffff);
1268 
1269  /* Register IRQ */
1270  retval = request_irq(itv->pdev->irq, ivtv_irq_handler,
1271  IRQF_SHARED | IRQF_DISABLED, itv->v4l2_dev.name, (void *)itv);
1272  if (retval) {
1273  IVTV_ERR("Failed to register irq %d\n", retval);
1274  goto free_i2c;
1275  }
1276 
1277  retval = ivtv_streams_setup(itv);
1278  if (retval) {
1279  IVTV_ERR("Error %d setting up streams\n", retval);
1280  goto free_irq;
1281  }
1282  retval = ivtv_streams_register(itv);
1283  if (retval) {
1284  IVTV_ERR("Error %d registering devices\n", retval);
1285  goto free_streams;
1286  }
1287  IVTV_INFO("Initialized card: %s\n", itv->card_name);
1288 
1289  /* Load ivtv submodules (ivtv-alsa) */
1290  request_modules(itv);
1291  return 0;
1292 
1293 free_streams:
1294  ivtv_streams_cleanup(itv, 1);
1295 free_irq:
1296  free_irq(itv->pdev->irq, (void *)itv);
1297 free_i2c:
1298  v4l2_ctrl_handler_free(&itv->cxhdl.hdl);
1299  exit_ivtv_i2c(itv);
1300 free_io:
1301  ivtv_iounmap(itv);
1302 free_mem:
1303  release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1304  release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1305  if (itv->has_cx23415)
1306  release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1307 free_worker:
1308  kthread_stop(itv->irq_worker_task);
1309 err:
1310  if (retval == 0)
1311  retval = -ENODEV;
1312  IVTV_ERR("Error %d on initialization\n", retval);
1313 
1314  v4l2_device_unregister(&itv->v4l2_dev);
1315  kfree(itv);
1316  return retval;
1317 }
1318 
1319 int ivtv_init_on_first_open(struct ivtv *itv)
1320 {
1321  struct v4l2_frequency vf;
1322  /* Needed to call ioctls later */
1323  struct ivtv_open_id fh;
1324  int fw_retry_count = 3;
1325  int video_input;
1326 
1327  fh.itv = itv;
1328  fh.type = IVTV_ENC_STREAM_TYPE_MPG;
1329 
1330  if (test_bit(IVTV_F_I_FAILED, &itv->i_flags))
1331  return -ENXIO;
1332 
1333  if (test_and_set_bit(IVTV_F_I_INITED, &itv->i_flags))
1334  return 0;
1335 
1336  while (--fw_retry_count > 0) {
1337  /* load firmware */
1338  if (ivtv_firmware_init(itv) == 0)
1339  break;
1340  if (fw_retry_count > 1)
1341  IVTV_WARN("Retry loading firmware\n");
1342  }
1343 
1344  if (fw_retry_count == 0) {
1345  set_bit(IVTV_F_I_FAILED, &itv->i_flags);
1346  return -ENXIO;
1347  }
1348 
1349  /* Try and get firmware versions */
1350  IVTV_DEBUG_INFO("Getting firmware version..\n");
1351  ivtv_firmware_versions(itv);
1352 
1353  if (itv->card->hw_all & IVTV_HW_CX25840)
1354  v4l2_subdev_call(itv->sd_video, core, load_fw);
1355 
1356  vf.tuner = 0;
1357  vf.type = V4L2_TUNER_ANALOG_TV;
1358  vf.frequency = 6400; /* the tuner 'baseline' frequency */
1359 
1360  /* Set initial frequency. For PAL/SECAM broadcasts no
1361  'default' channel exists AFAIK. */
1362  if (itv->std == V4L2_STD_NTSC_M_JP) {
1363  vf.frequency = 1460; /* ch. 1 91250*16/1000 */
1364  }
1365  else if (itv->std & V4L2_STD_NTSC_M) {
1366  vf.frequency = 1076; /* ch. 4 67250*16/1000 */
1367  }
1368 
1369  video_input = itv->active_input;
1370  itv->active_input++; /* Force update of input */
1371  ivtv_s_input(NULL, &fh, video_input);
1372 
1373  /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1374  in one place. */
1375  itv->std++; /* Force full standard initialization */
1376  itv->std_out = itv->std;
1377  ivtv_s_frequency(NULL, &fh, &vf);
1378 
1379  if (itv->card->v4l2_capabilities & V4L2_CAP_VIDEO_OUTPUT) {
1380  /* Turn on the TV-out: ivtv_init_mpeg_decoder() initializes
1381  the mpeg decoder so now the saa7127 receives a proper
1382  signal. */
1383  ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 1);
1384  ivtv_init_mpeg_decoder(itv);
1385  }
1386 
1387  /* On a cx23416 this seems to be able to enable DMA to the chip? */
1388  if (!itv->has_cx23415)
1389  write_reg_sync(0x03, IVTV_REG_DMACONTROL);
1390 
1391  ivtv_s_std_enc(itv, &itv->tuner_std);
1392 
1393  /* Default interrupts enabled. For the PVR350 this includes the
1394  decoder VSYNC interrupt, which is always on. It is not only used
1395  during decoding but also by the OSD.
1396  Some old PVR250 cards had a cx23415, so testing for that is too
1397  general. Instead test if the card has video output capability. */
1398  if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1399  ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT | IVTV_IRQ_DEC_VSYNC);
1400  ivtv_set_osd_alpha(itv);
1401  ivtv_s_std_dec(itv, &itv->tuner_std);
1402  } else {
1403  ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT);
1404  }
1405 
1406  /* Setup initial controls */
1407  cx2341x_handler_setup(&itv->cxhdl);
1408  return 0;
1409 }
1410 
1411 static void ivtv_remove(struct pci_dev *pdev)
1412 {
1413  struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
1414  struct ivtv *itv = to_ivtv(v4l2_dev);
1415  int i;
1416 
1417  IVTV_DEBUG_INFO("Removing card\n");
1418 
1419  flush_request_modules(itv);
1420 
1421  if (test_bit(IVTV_F_I_INITED, &itv->i_flags)) {
1422  /* Stop all captures */
1423  IVTV_DEBUG_INFO("Stopping all streams\n");
1424  if (atomic_read(&itv->capturing) > 0)
1425  ivtv_stop_all_captures(itv);
1426 
1427  /* Stop all decoding */
1428  IVTV_DEBUG_INFO("Stopping decoding\n");
1429 
1430  /* Turn off the TV-out */
1431  if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1432  ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 0);
1433  if (atomic_read(&itv->decoding) > 0) {
1434  int type;
1435 
1436  if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
1437  type = IVTV_DEC_STREAM_TYPE_YUV;
1438  else
1439  type = IVTV_DEC_STREAM_TYPE_MPG;
1440  ivtv_stop_v4l2_decode_stream(&itv->streams[type],
1441  V4L2_DEC_CMD_STOP_TO_BLACK | V4L2_DEC_CMD_STOP_IMMEDIATELY, 0);
1442  }
1443  ivtv_halt_firmware(itv);
1444  }
1445 
1446  /* Interrupts */
1447  ivtv_set_irq_mask(itv, 0xffffffff);
1448  del_timer_sync(&itv->dma_timer);
1449 
1450  /* Kill irq worker */
1451  flush_kthread_worker(&itv->irq_worker);
1452  kthread_stop(itv->irq_worker_task);
1453 
1454  ivtv_streams_cleanup(itv, 1);
1455  ivtv_udma_free(itv);
1456 
1457  v4l2_ctrl_handler_free(&itv->cxhdl.hdl);
1458 
1459  exit_ivtv_i2c(itv);
1460 
1461  free_irq(itv->pdev->irq, (void *)itv);
1462  ivtv_iounmap(itv);
1463 
1464  release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1465  release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1466  if (itv->has_cx23415)
1467  release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1468 
1469  pci_disable_device(itv->pdev);
1470  for (i = 0; i < IVTV_VBI_FRAMES; i++)
1471  kfree(itv->vbi.sliced_mpeg_data[i]);
1472 
1473  printk(KERN_INFO "ivtv: Removed %s\n", itv->card_name);
1474 
1475  v4l2_device_unregister(&itv->v4l2_dev);
1476  kfree(itv);
1477 }
1478 
1479 /* define a pci_driver for card detection */
1480 static struct pci_driver ivtv_pci_driver = {
1481  .name = "ivtv",
1482  .id_table = ivtv_pci_tbl,
1483  .probe = ivtv_probe,
1484  .remove = ivtv_remove,
1485 };
1486 
1487 static int __init module_start(void)
1488 {
1489  printk(KERN_INFO "ivtv: Start initialization, version %s\n", IVTV_VERSION);
1490 
1491  /* Validate parameters */
1492  if (ivtv_first_minor < 0 || ivtv_first_minor >= IVTV_MAX_CARDS) {
1493  printk(KERN_ERR "ivtv: Exiting, ivtv_first_minor must be between 0 and %d\n",
1494  IVTV_MAX_CARDS - 1);
1495  return -1;
1496  }
1497 
1498  if (ivtv_debug < 0 || ivtv_debug > 2047) {
1499  ivtv_debug = 0;
1500  printk(KERN_INFO "ivtv: Debug value must be >= 0 and <= 2047\n");
1501  }
1502 
1503  if (pci_register_driver(&ivtv_pci_driver)) {
1504  printk(KERN_ERR "ivtv: Error detecting PCI card\n");
1505  return -ENODEV;
1506  }
1507  printk(KERN_INFO "ivtv: End initialization\n");
1508  return 0;
1509 }
1510 
1511 static void __exit module_cleanup(void)
1512 {
1513  pci_unregister_driver(&ivtv_pci_driver);
1514 }
1515 
1516 /* Note: These symbols are exported because they are used by the ivtvfb
1517  framebuffer module and an infrared module for the IR-blaster. */
1518 EXPORT_SYMBOL(ivtv_set_irq_mask);
1519 EXPORT_SYMBOL(ivtv_api);
1520 EXPORT_SYMBOL(ivtv_vapi);
1521 EXPORT_SYMBOL(ivtv_vapi_result);
1522 EXPORT_SYMBOL(ivtv_clear_irq_mask);
1523 EXPORT_SYMBOL(ivtv_debug);
1524 #ifdef CONFIG_VIDEO_ADV_DEBUG
1525 EXPORT_SYMBOL(ivtv_fw_debug);
1526 #endif
1527 EXPORT_SYMBOL(ivtv_reset_ir_gpio);
1528 EXPORT_SYMBOL(ivtv_udma_setup);
1529 EXPORT_SYMBOL(ivtv_udma_unmap);
1530 EXPORT_SYMBOL(ivtv_udma_alloc);
1531 EXPORT_SYMBOL(ivtv_udma_prepare);
1532 EXPORT_SYMBOL(ivtv_init_on_first_open);
1533 EXPORT_SYMBOL(ivtv_firmware_check);
1534 
1535 module_init(module_start);
1536 module_exit(module_cleanup);
Generated on Thu Jan 10 2013 13:48:11 for Linux Kernel by   doxygen 1.8.2