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