Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab...
[linux-2.6] / drivers / media / video / cx18 / cx18-driver.c
1 /*
2  *  cx18 driver initialization and card probing
3  *
4  *  Derived from ivtv-driver.c
5  *
6  *  Copyright (C) 2007  Hans Verkuil <hverkuil@xs4all.nl>
7  *  Copyright (C) 2008  Andy Walls <awalls@radix.net>
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2 of the License, or
12  *  (at your option) any later version.
13  *
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License
20  *  along with this program; if not, write to the Free Software
21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
22  *  02111-1307  USA
23  */
24
25 #include "cx18-driver.h"
26 #include "cx18-io.h"
27 #include "cx18-version.h"
28 #include "cx18-cards.h"
29 #include "cx18-i2c.h"
30 #include "cx18-irq.h"
31 #include "cx18-gpio.h"
32 #include "cx18-firmware.h"
33 #include "cx18-streams.h"
34 #include "cx18-av-core.h"
35 #include "cx18-scb.h"
36 #include "cx18-mailbox.h"
37 #include "cx18-ioctl.h"
38 #include "tuner-xc2028.h"
39
40 #include <media/tveeprom.h>
41
42
43 /* var to keep track of the number of array elements in use */
44 int cx18_cards_active;
45
46 /* If you have already X v4l cards, then set this to X. This way
47    the device numbers stay matched. Example: you have a WinTV card
48    without radio and a Compro H900 with. Normally this would give a
49    video1 device together with a radio0 device for the Compro. By
50    setting this to 1 you ensure that radio0 is now also radio1. */
51 int cx18_first_minor;
52
53 /* Master variable for all cx18 info */
54 struct cx18 *cx18_cards[CX18_MAX_CARDS];
55
56 /* Protects cx18_cards_active */
57 DEFINE_SPINLOCK(cx18_cards_lock);
58
59 /* add your revision and whatnot here */
60 static struct pci_device_id cx18_pci_tbl[] __devinitdata = {
61         {PCI_VENDOR_ID_CX, PCI_DEVICE_ID_CX23418,
62          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
63         {0,}
64 };
65
66 MODULE_DEVICE_TABLE(pci, cx18_pci_tbl);
67
68 /* Parameter declarations */
69 static int cardtype[CX18_MAX_CARDS];
70 static int tuner[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
71                                      -1, -1, -1, -1, -1, -1, -1, -1,
72                                      -1, -1, -1, -1, -1, -1, -1, -1,
73                                      -1, -1, -1, -1, -1, -1, -1, -1 };
74 static int radio[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
75                                      -1, -1, -1, -1, -1, -1, -1, -1,
76                                      -1, -1, -1, -1, -1, -1, -1, -1,
77                                      -1, -1, -1, -1, -1, -1, -1, -1 };
78 static int mmio_ndelay[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
79                                            -1, -1, -1, -1, -1, -1, -1, -1,
80                                            -1, -1, -1, -1, -1, -1, -1, -1,
81                                            -1, -1, -1, -1, -1, -1, -1, -1 };
82 static unsigned cardtype_c = 1;
83 static unsigned tuner_c = 1;
84 static unsigned radio_c = 1;
85 static unsigned mmio_ndelay_c = 1;
86 static char pal[] = "--";
87 static char secam[] = "--";
88 static char ntsc[] = "-";
89
90 /* Buffers */
91 static int enc_mpg_buffers = CX18_DEFAULT_ENC_MPG_BUFFERS;
92 static int enc_ts_buffers = CX18_DEFAULT_ENC_TS_BUFFERS;
93 static int enc_yuv_buffers = CX18_DEFAULT_ENC_YUV_BUFFERS;
94 static int enc_vbi_buffers = CX18_DEFAULT_ENC_VBI_BUFFERS;
95 static int enc_pcm_buffers = CX18_DEFAULT_ENC_PCM_BUFFERS;
96
97 static int cx18_pci_latency = 1;
98
99 int cx18_retry_mmio = 1;
100 int cx18_debug;
101
102 module_param_array(tuner, int, &tuner_c, 0644);
103 module_param_array(radio, bool, &radio_c, 0644);
104 module_param_array(cardtype, int, &cardtype_c, 0644);
105 module_param_array(mmio_ndelay, int, &mmio_ndelay_c, 0644);
106 module_param_string(pal, pal, sizeof(pal), 0644);
107 module_param_string(secam, secam, sizeof(secam), 0644);
108 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
109 module_param_named(debug, cx18_debug, int, 0644);
110 module_param_named(retry_mmio, cx18_retry_mmio, int, 0644);
111 module_param(cx18_pci_latency, int, 0644);
112 module_param(cx18_first_minor, int, 0644);
113
114 module_param(enc_mpg_buffers, int, 0644);
115 module_param(enc_ts_buffers, int, 0644);
116 module_param(enc_yuv_buffers, int, 0644);
117 module_param(enc_vbi_buffers, int, 0644);
118 module_param(enc_pcm_buffers, int, 0644);
119
120 MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
121                         "\t\t\tsee tuner.h for values");
122 MODULE_PARM_DESC(radio,
123                  "Enable or disable the radio. Use only if autodetection\n"
124                  "\t\t\tfails. 0 = disable, 1 = enable");
125 MODULE_PARM_DESC(cardtype,
126                  "Only use this option if your card is not detected properly.\n"
127                  "\t\tSpecify card type:\n"
128                  "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n"
129                  "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n"
130                  "\t\t\t 3 = Compro VideoMate H900\n"
131                  "\t\t\t 4 = Yuan MPC718\n"
132                  "\t\t\t 5 = Conexant Raptor PAL/SECAM\n"
133                  "\t\t\t 6 = Toshiba Qosmio DVB-T/Analog\n"
134                  "\t\t\t 7 = Leadtek WinFast PVR2100\n"
135                  "\t\t\t 0 = Autodetect (default)\n"
136                  "\t\t\t-1 = Ignore this card\n\t\t");
137 MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
138 MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC");
139 MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K");
140 MODULE_PARM_DESC(debug,
141                  "Debug level (bitmask). Default: 0\n"
142                  "\t\t\t  1/0x0001: warning\n"
143                  "\t\t\t  2/0x0002: info\n"
144                  "\t\t\t  4/0x0004: mailbox\n"
145                  "\t\t\t  8/0x0008: dma\n"
146                  "\t\t\t 16/0x0010: ioctl\n"
147                  "\t\t\t 32/0x0020: file\n"
148                  "\t\t\t 64/0x0040: i2c\n"
149                  "\t\t\t128/0x0080: irq\n"
150                  "\t\t\t256/0x0100: high volume\n");
151 MODULE_PARM_DESC(cx18_pci_latency,
152                  "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
153                  "\t\t\tDefault: Yes");
154 MODULE_PARM_DESC(retry_mmio,
155                  "Check and retry memory mapped IO accesses\n"
156                  "\t\t\tDefault: 1 [Yes]");
157 MODULE_PARM_DESC(mmio_ndelay,
158                  "Delay (ns) for each CX23418 memory mapped IO access.\n"
159                  "\t\t\tTry larger values that are close to a multiple of the\n"
160                  "\t\t\tPCI clock period, 30.3 ns, if your card doesn't work.\n"
161                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_MMIO_NDELAY));
162 MODULE_PARM_DESC(enc_mpg_buffers,
163                  "Encoder MPG Buffers (in MB)\n"
164                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS));
165 MODULE_PARM_DESC(enc_ts_buffers,
166                  "Encoder TS Buffers (in MB)\n"
167                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS));
168 MODULE_PARM_DESC(enc_yuv_buffers,
169                  "Encoder YUV Buffers (in MB)\n"
170                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS));
171 MODULE_PARM_DESC(enc_vbi_buffers,
172                  "Encoder VBI Buffers (in MB)\n"
173                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS));
174 MODULE_PARM_DESC(enc_pcm_buffers,
175                  "Encoder PCM buffers (in MB)\n"
176                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS));
177
178 MODULE_PARM_DESC(cx18_first_minor, "Set kernel number assigned to first card");
179
180 MODULE_AUTHOR("Hans Verkuil");
181 MODULE_DESCRIPTION("CX23418 driver");
182 MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
183 MODULE_LICENSE("GPL");
184
185 MODULE_VERSION(CX18_VERSION);
186
187 /* Generic utility functions */
188 int cx18_msleep_timeout(unsigned int msecs, int intr)
189 {
190         int timeout = msecs_to_jiffies(msecs);
191         int sig;
192
193         do {
194                 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
195                 timeout = schedule_timeout(timeout);
196                 sig = intr ? signal_pending(current) : 0;
197         } while (!sig && timeout);
198         return sig;
199 }
200
201 /* Release ioremapped memory */
202 static void cx18_iounmap(struct cx18 *cx)
203 {
204         if (cx == NULL)
205                 return;
206
207         /* Release io memory */
208         if (cx->enc_mem != NULL) {
209                 CX18_DEBUG_INFO("releasing enc_mem\n");
210                 iounmap(cx->enc_mem);
211                 cx->enc_mem = NULL;
212         }
213 }
214
215 /* Hauppauge card? get values from tveeprom */
216 void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
217 {
218         u8 eedata[256];
219
220         cx->i2c_client[0].addr = 0xA0 >> 1;
221         tveeprom_read(&cx->i2c_client[0], eedata, sizeof(eedata));
222         tveeprom_hauppauge_analog(&cx->i2c_client[0], tv, eedata);
223 }
224
225 static void cx18_process_eeprom(struct cx18 *cx)
226 {
227         struct tveeprom tv;
228
229         cx18_read_eeprom(cx, &tv);
230
231         /* Many thanks to Steven Toth from Hauppauge for providing the
232            model numbers */
233         /* Note: the Samsung memory models cannot be reliably determined
234            from the model number. Use the cardtype module option if you
235            have one of these preproduction models. */
236         switch (tv.model) {
237         case 74000 ... 74999:
238                 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
239                 break;
240         case 0:
241                 CX18_ERR("Invalid EEPROM\n");
242                 return;
243         default:
244                 CX18_ERR("Unknown model %d, defaulting to HVR-1600\n", tv.model);
245                 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
246                 break;
247         }
248
249         cx->v4l2_cap = cx->card->v4l2_capabilities;
250         cx->card_name = cx->card->name;
251         cx->card_i2c = cx->card->i2c;
252
253         CX18_INFO("Autodetected %s\n", cx->card_name);
254
255         if (tv.tuner_type == TUNER_ABSENT)
256                 CX18_ERR("tveeprom cannot autodetect tuner!");
257
258         if (cx->options.tuner == -1)
259                 cx->options.tuner = tv.tuner_type;
260         if (cx->options.radio == -1)
261                 cx->options.radio = (tv.has_radio != 0);
262
263         if (cx->std != 0)
264                 /* user specified tuner standard */
265                 return;
266
267         /* autodetect tuner standard */
268         if (tv.tuner_formats & V4L2_STD_PAL) {
269                 CX18_DEBUG_INFO("PAL tuner detected\n");
270                 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
271         } else if (tv.tuner_formats & V4L2_STD_NTSC) {
272                 CX18_DEBUG_INFO("NTSC tuner detected\n");
273                 cx->std |= V4L2_STD_NTSC_M;
274         } else if (tv.tuner_formats & V4L2_STD_SECAM) {
275                 CX18_DEBUG_INFO("SECAM tuner detected\n");
276                 cx->std |= V4L2_STD_SECAM_L;
277         } else {
278                 CX18_INFO("No tuner detected, default to NTSC-M\n");
279                 cx->std |= V4L2_STD_NTSC_M;
280         }
281 }
282
283 static v4l2_std_id cx18_parse_std(struct cx18 *cx)
284 {
285         switch (pal[0]) {
286         case '6':
287                 return V4L2_STD_PAL_60;
288         case 'b':
289         case 'B':
290         case 'g':
291         case 'G':
292                 return V4L2_STD_PAL_BG;
293         case 'h':
294         case 'H':
295                 return V4L2_STD_PAL_H;
296         case 'n':
297         case 'N':
298                 if (pal[1] == 'c' || pal[1] == 'C')
299                         return V4L2_STD_PAL_Nc;
300                 return V4L2_STD_PAL_N;
301         case 'i':
302         case 'I':
303                 return V4L2_STD_PAL_I;
304         case 'd':
305         case 'D':
306         case 'k':
307         case 'K':
308                 return V4L2_STD_PAL_DK;
309         case 'M':
310         case 'm':
311                 return V4L2_STD_PAL_M;
312         case '-':
313                 break;
314         default:
315                 CX18_WARN("pal= argument not recognised\n");
316                 return 0;
317         }
318
319         switch (secam[0]) {
320         case 'b':
321         case 'B':
322         case 'g':
323         case 'G':
324         case 'h':
325         case 'H':
326                 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
327         case 'd':
328         case 'D':
329         case 'k':
330         case 'K':
331                 return V4L2_STD_SECAM_DK;
332         case 'l':
333         case 'L':
334                 if (secam[1] == 'C' || secam[1] == 'c')
335                         return V4L2_STD_SECAM_LC;
336                 return V4L2_STD_SECAM_L;
337         case '-':
338                 break;
339         default:
340                 CX18_WARN("secam= argument not recognised\n");
341                 return 0;
342         }
343
344         switch (ntsc[0]) {
345         case 'm':
346         case 'M':
347                 return V4L2_STD_NTSC_M;
348         case 'j':
349         case 'J':
350                 return V4L2_STD_NTSC_M_JP;
351         case 'k':
352         case 'K':
353                 return V4L2_STD_NTSC_M_KR;
354         case '-':
355                 break;
356         default:
357                 CX18_WARN("ntsc= argument not recognised\n");
358                 return 0;
359         }
360
361         /* no match found */
362         return 0;
363 }
364
365 static void cx18_process_options(struct cx18 *cx)
366 {
367         int i, j;
368
369         cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
370         cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
371         cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;
372         cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;
373         cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
374         cx->options.cardtype = cardtype[cx->num];
375         cx->options.tuner = tuner[cx->num];
376         cx->options.radio = radio[cx->num];
377
378         if (mmio_ndelay[cx->num] < 0)
379                 cx->options.mmio_ndelay = CX18_DEFAULT_MMIO_NDELAY;
380         else
381                 cx->options.mmio_ndelay = mmio_ndelay[cx->num];
382
383         cx->std = cx18_parse_std(cx);
384         if (cx->options.cardtype == -1) {
385                 CX18_INFO("Ignore card\n");
386                 return;
387         }
388         cx->card = cx18_get_card(cx->options.cardtype - 1);
389         if (cx->card)
390                 CX18_INFO("User specified %s card\n", cx->card->name);
391         else if (cx->options.cardtype != 0)
392                 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
393         if (cx->card == NULL) {
394                 if (cx->dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
395                         cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
396                         CX18_INFO("Autodetected Hauppauge card\n");
397                 }
398         }
399         if (cx->card == NULL) {
400                 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
401                         if (cx->card->pci_list == NULL)
402                                 continue;
403                         for (j = 0; cx->card->pci_list[j].device; j++) {
404                                 if (cx->dev->device !=
405                                     cx->card->pci_list[j].device)
406                                         continue;
407                                 if (cx->dev->subsystem_vendor !=
408                                     cx->card->pci_list[j].subsystem_vendor)
409                                         continue;
410                                 if (cx->dev->subsystem_device !=
411                                     cx->card->pci_list[j].subsystem_device)
412                                         continue;
413                                 CX18_INFO("Autodetected %s card\n", cx->card->name);
414                                 goto done;
415                         }
416                 }
417         }
418 done:
419
420         if (cx->card == NULL) {
421                 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
422                 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
423                      cx->dev->vendor, cx->dev->device);
424                 CX18_ERR("              subsystem vendor/device: [%04x:%04x]\n",
425                      cx->dev->subsystem_vendor, cx->dev->subsystem_device);
426                 CX18_ERR("Defaulting to %s card\n", cx->card->name);
427                 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
428                 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
429                 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
430         }
431         cx->v4l2_cap = cx->card->v4l2_capabilities;
432         cx->card_name = cx->card->name;
433         cx->card_i2c = cx->card->i2c;
434 }
435
436 /* Precondition: the cx18 structure has been memset to 0. Only
437    the dev and num fields have been filled in.
438    No assumptions on the card type may be made here (see cx18_init_struct2
439    for that).
440  */
441 static int __devinit cx18_init_struct1(struct cx18 *cx)
442 {
443         cx->base_addr = pci_resource_start(cx->dev, 0);
444
445         mutex_init(&cx->serialize_lock);
446         mutex_init(&cx->i2c_bus_lock[0]);
447         mutex_init(&cx->i2c_bus_lock[1]);
448         mutex_init(&cx->gpio_lock);
449
450         spin_lock_init(&cx->lock);
451
452         cx->work_queue = create_singlethread_workqueue(cx->name);
453         if (cx->work_queue == NULL) {
454                 CX18_ERR("Could not create work queue\n");
455                 return -1;
456         }
457
458         INIT_WORK(&cx->work, cx18_work_handler);
459
460         /* start counting open_id at 1 */
461         cx->open_id = 1;
462
463         /* Initial settings */
464         cx2341x_fill_defaults(&cx->params);
465         cx->temporal_strength = cx->params.video_temporal_filter;
466         cx->spatial_strength = cx->params.video_spatial_filter;
467         cx->filter_mode = cx->params.video_spatial_filter_mode |
468                 (cx->params.video_temporal_filter_mode << 1) |
469                 (cx->params.video_median_filter_type << 2);
470         cx->params.port = CX2341X_PORT_MEMORY;
471         cx->params.capabilities = CX2341X_CAP_HAS_TS;
472         init_waitqueue_head(&cx->cap_w);
473         init_waitqueue_head(&cx->mb_apu_waitq);
474         init_waitqueue_head(&cx->mb_cpu_waitq);
475         init_waitqueue_head(&cx->mb_epu_waitq);
476         init_waitqueue_head(&cx->mb_hpu_waitq);
477         init_waitqueue_head(&cx->dma_waitq);
478
479         /* VBI */
480         cx->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
481         cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
482         cx->vbi.raw_size = 1456;
483         cx->vbi.raw_decoder_line_size = 1456;
484         cx->vbi.raw_decoder_sav_odd_field = 0x20;
485         cx->vbi.raw_decoder_sav_even_field = 0x60;
486         cx->vbi.sliced_decoder_line_size = 272;
487         cx->vbi.sliced_decoder_sav_odd_field = 0xB0;
488         cx->vbi.sliced_decoder_sav_even_field = 0xF0;
489         return 0;
490 }
491
492 /* Second initialization part. Here the card type has been
493    autodetected. */
494 static void __devinit cx18_init_struct2(struct cx18 *cx)
495 {
496         int i;
497
498         for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
499                 if (cx->card->video_inputs[i].video_type == 0)
500                         break;
501         cx->nof_inputs = i;
502         for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
503                 if (cx->card->audio_inputs[i].audio_type == 0)
504                         break;
505         cx->nof_audio_inputs = i;
506
507         /* Find tuner input */
508         for (i = 0; i < cx->nof_inputs; i++) {
509                 if (cx->card->video_inputs[i].video_type ==
510                                 CX18_CARD_INPUT_VID_TUNER)
511                         break;
512         }
513         if (i == cx->nof_inputs)
514                 i = 0;
515         cx->active_input = i;
516         cx->audio_input = cx->card->video_inputs[i].audio_index;
517         cx->av_state.vid_input = CX18_AV_COMPOSITE7;
518         cx->av_state.aud_input = CX18_AV_AUDIO8;
519         cx->av_state.audclk_freq = 48000;
520         cx->av_state.audmode = V4L2_TUNER_MODE_LANG1;
521         cx->av_state.vbi_line_offset = 8;
522 }
523
524 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *dev,
525                           const struct pci_device_id *pci_id)
526 {
527         u16 cmd;
528         unsigned char pci_latency;
529
530         CX18_DEBUG_INFO("Enabling pci device\n");
531
532         if (pci_enable_device(dev)) {
533                 CX18_ERR("Can't enable device %d!\n", cx->num);
534                 return -EIO;
535         }
536         if (pci_set_dma_mask(dev, 0xffffffff)) {
537                 CX18_ERR("No suitable DMA available on card %d.\n", cx->num);
538                 return -EIO;
539         }
540         if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
541                 CX18_ERR("Cannot request encoder memory region on card %d.\n", cx->num);
542                 return -EIO;
543         }
544
545         /* Enable bus mastering and memory mapped IO for the CX23418 */
546         pci_read_config_word(dev, PCI_COMMAND, &cmd);
547         cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
548         pci_write_config_word(dev, PCI_COMMAND, cmd);
549
550         pci_read_config_byte(dev, PCI_CLASS_REVISION, &cx->card_rev);
551         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
552
553         if (pci_latency < 64 && cx18_pci_latency) {
554                 CX18_INFO("Unreasonably low latency timer, "
555                                "setting to 64 (was %d)\n", pci_latency);
556                 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
557                 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
558         }
559
560         CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
561                    "irq: %d, latency: %d, memory: 0x%lx\n",
562                    cx->dev->device, cx->card_rev, dev->bus->number,
563                    PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
564                    cx->dev->irq, pci_latency, (unsigned long)cx->base_addr);
565
566         return 0;
567 }
568
569 #ifdef MODULE
570 static u32 cx18_request_module(struct cx18 *cx, u32 hw,
571                 const char *name, u32 id)
572 {
573         if ((hw & id) == 0)
574                 return hw;
575         if (request_module(name) != 0) {
576                 CX18_ERR("Failed to load module %s\n", name);
577                 return hw & ~id;
578         }
579         CX18_DEBUG_INFO("Loaded module %s\n", name);
580         return hw;
581 }
582 #endif
583
584 static void cx18_load_and_init_modules(struct cx18 *cx)
585 {
586         u32 hw = cx->card->hw_all;
587         int i;
588
589 #ifdef MODULE
590         /* load modules */
591 #ifdef CONFIG_MEDIA_TUNER_MODULE
592         hw = cx18_request_module(cx, hw, "tuner", CX18_HW_TUNER);
593 #endif
594 #ifdef CONFIG_VIDEO_CS5345_MODULE
595         hw = cx18_request_module(cx, hw, "cs5345", CX18_HW_CS5345);
596 #endif
597 #endif
598
599         /* check which i2c devices are actually found */
600         for (i = 0; i < 32; i++) {
601                 u32 device = 1 << i;
602
603                 if (!(device & hw))
604                         continue;
605                 if (device == CX18_HW_GPIO || device == CX18_HW_TVEEPROM ||
606                     device == CX18_HW_CX23418 || device == CX18_HW_DVB) {
607                         /* These 'devices' do not use i2c probing */
608                         cx->hw_flags |= device;
609                         continue;
610                 }
611                 cx18_i2c_register(cx, i);
612                 if (cx18_i2c_hw_addr(cx, device) > 0)
613                         cx->hw_flags |= device;
614         }
615
616         hw = cx->hw_flags;
617 }
618
619 static int __devinit cx18_probe(struct pci_dev *dev,
620                                 const struct pci_device_id *pci_id)
621 {
622         int retval = 0;
623         int i;
624         int vbi_buf_size;
625         u32 devtype;
626         struct cx18 *cx;
627
628         spin_lock(&cx18_cards_lock);
629
630         /* Make sure we've got a place for this card */
631         if (cx18_cards_active == CX18_MAX_CARDS) {
632                 printk(KERN_ERR "cx18:  Maximum number of cards detected (%d).\n",
633                               cx18_cards_active);
634                 spin_unlock(&cx18_cards_lock);
635                 return -ENOMEM;
636         }
637
638         cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
639         if (!cx) {
640                 spin_unlock(&cx18_cards_lock);
641                 return -ENOMEM;
642         }
643         cx18_cards[cx18_cards_active] = cx;
644         cx->dev = dev;
645         cx->num = cx18_cards_active++;
646         snprintf(cx->name, sizeof(cx->name), "cx18-%d", cx->num);
647         CX18_INFO("Initializing card #%d\n", cx->num);
648
649         spin_unlock(&cx18_cards_lock);
650
651         cx18_process_options(cx);
652         if (cx->options.cardtype == -1) {
653                 retval = -ENODEV;
654                 goto err;
655         }
656         if (cx18_init_struct1(cx)) {
657                 retval = -ENOMEM;
658                 goto err;
659         }
660
661         CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
662
663         /* PCI Device Setup */
664         retval = cx18_setup_pci(cx, dev, pci_id);
665         if (retval != 0) {
666                 if (retval == -EIO)
667                         goto free_workqueue;
668                 else if (retval == -ENXIO)
669                         goto free_mem;
670         }
671         /* save cx in the pci struct for later use */
672         pci_set_drvdata(dev, cx);
673
674         /* map io memory */
675         CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
676                    cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
677         cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
678                                        CX18_MEM_SIZE);
679         if (!cx->enc_mem) {
680                 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
681                 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
682                 retval = -ENOMEM;
683                 goto free_mem;
684         }
685         cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
686         devtype = cx18_read_reg(cx, 0xC72028);
687         switch (devtype & 0xff000000) {
688         case 0xff000000:
689                 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
690                 break;
691         case 0x01000000:
692                 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
693                 break;
694         default:
695                 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
696                 break;
697         }
698
699         cx18_init_power(cx, 1);
700         cx18_init_memory(cx);
701
702         cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
703         cx18_init_scb(cx);
704
705         cx18_gpio_init(cx);
706
707         /* active i2c  */
708         CX18_DEBUG_INFO("activating i2c...\n");
709         retval = init_cx18_i2c(cx);
710         if (retval) {
711                 CX18_ERR("Could not initialize i2c\n");
712                 goto free_map;
713         }
714
715         CX18_DEBUG_INFO("Active card count: %d.\n", cx18_cards_active);
716
717         if (cx->card->hw_all & CX18_HW_TVEEPROM) {
718                 /* Based on the model number the cardtype may be changed.
719                    The PCI IDs are not always reliable. */
720                 cx18_process_eeprom(cx);
721         }
722         if (cx->card->comment)
723                 CX18_INFO("%s", cx->card->comment);
724         if (cx->card->v4l2_capabilities == 0) {
725                 retval = -ENODEV;
726                 goto free_i2c;
727         }
728         cx18_init_memory(cx);
729
730         /* Register IRQ */
731         retval = request_irq(cx->dev->irq, cx18_irq_handler,
732                              IRQF_SHARED | IRQF_DISABLED, cx->name, (void *)cx);
733         if (retval) {
734                 CX18_ERR("Failed to register irq %d\n", retval);
735                 goto free_i2c;
736         }
737
738         if (cx->std == 0)
739                 cx->std = V4L2_STD_NTSC_M;
740
741         if (cx->options.tuner == -1) {
742                 int i;
743
744                 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
745                         if ((cx->std & cx->card->tuners[i].std) == 0)
746                                 continue;
747                         cx->options.tuner = cx->card->tuners[i].tuner;
748                         break;
749                 }
750         }
751         /* if no tuner was found, then pick the first tuner in the card list */
752         if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
753                 cx->std = cx->card->tuners[0].std;
754                 if (cx->std & V4L2_STD_PAL)
755                         cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
756                 else if (cx->std & V4L2_STD_NTSC)
757                         cx->std = V4L2_STD_NTSC_M;
758                 else if (cx->std & V4L2_STD_SECAM)
759                         cx->std = V4L2_STD_SECAM_L;
760                 cx->options.tuner = cx->card->tuners[0].tuner;
761         }
762         if (cx->options.radio == -1)
763                 cx->options.radio = (cx->card->radio_input.audio_type != 0);
764
765         /* The card is now fully identified, continue with card-specific
766            initialization. */
767         cx18_init_struct2(cx);
768
769         cx18_load_and_init_modules(cx);
770
771         if (cx->std & V4L2_STD_525_60) {
772                 cx->is_60hz = 1;
773                 cx->is_out_60hz = 1;
774         } else {
775                 cx->is_50hz = 1;
776                 cx->is_out_50hz = 1;
777         }
778         cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
779
780         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = 0x08000;
781         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = 0x08000;
782         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = 0x01200;
783         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = 0x20000;
784         vbi_buf_size = cx->vbi.raw_size * (cx->is_60hz ? 24 : 36) / 2;
785         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
786
787         if (cx->options.radio > 0)
788                 cx->v4l2_cap |= V4L2_CAP_RADIO;
789
790         if (cx->options.tuner > -1) {
791                 struct tuner_setup setup;
792
793                 setup.addr = ADDR_UNSET;
794                 setup.type = cx->options.tuner;
795                 setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
796                 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
797                         cx18_reset_tuner_gpio : NULL;
798                 cx18_call_i2c_clients(cx, TUNER_SET_TYPE_ADDR, &setup);
799                 if (setup.type == TUNER_XC2028) {
800                         static struct xc2028_ctrl ctrl = {
801                                 .fname = XC2028_DEFAULT_FIRMWARE,
802                                 .max_len = 64,
803                         };
804                         struct v4l2_priv_tun_config cfg = {
805                                 .tuner = cx->options.tuner,
806                                 .priv = &ctrl,
807                         };
808                         cx18_call_i2c_clients(cx, TUNER_SET_CONFIG, &cfg);
809                 }
810         }
811
812         /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
813            are not. */
814         cx->tuner_std = cx->std;
815
816         retval = cx18_streams_setup(cx);
817         if (retval) {
818                 CX18_ERR("Error %d setting up streams\n", retval);
819                 goto free_irq;
820         }
821         retval = cx18_streams_register(cx);
822         if (retval) {
823                 CX18_ERR("Error %d registering devices\n", retval);
824                 goto free_streams;
825         }
826
827         CX18_INFO("Initialized card #%d: %s\n", cx->num, cx->card_name);
828
829         return 0;
830
831 free_streams:
832         cx18_streams_cleanup(cx, 1);
833 free_irq:
834         free_irq(cx->dev->irq, (void *)cx);
835 free_i2c:
836         exit_cx18_i2c(cx);
837 free_map:
838         cx18_iounmap(cx);
839 free_mem:
840         release_mem_region(cx->base_addr, CX18_MEM_SIZE);
841 free_workqueue:
842         destroy_workqueue(cx->work_queue);
843 err:
844         if (retval == 0)
845                 retval = -ENODEV;
846         CX18_ERR("Error %d on initialization\n", retval);
847         cx18_log_statistics(cx);
848
849         i = cx->num;
850         spin_lock(&cx18_cards_lock);
851         kfree(cx18_cards[i]);
852         cx18_cards[i] = NULL;
853         spin_unlock(&cx18_cards_lock);
854         return retval;
855 }
856
857 int cx18_init_on_first_open(struct cx18 *cx)
858 {
859         int video_input;
860         int fw_retry_count = 3;
861         struct v4l2_frequency vf;
862         struct cx18_open_id fh;
863
864         fh.cx = cx;
865
866         if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
867                 return -ENXIO;
868
869         if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
870                 return 0;
871
872         while (--fw_retry_count > 0) {
873                 /* load firmware */
874                 if (cx18_firmware_init(cx) == 0)
875                         break;
876                 if (fw_retry_count > 1)
877                         CX18_WARN("Retry loading firmware\n");
878         }
879
880         if (fw_retry_count == 0) {
881                 set_bit(CX18_F_I_FAILED, &cx->i_flags);
882                 return -ENXIO;
883         }
884         set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
885
886         /* Init the firmware twice to work around a silicon bug
887          * transport related. */
888
889         fw_retry_count = 3;
890         while (--fw_retry_count > 0) {
891                 /* load firmware */
892                 if (cx18_firmware_init(cx) == 0)
893                         break;
894                 if (fw_retry_count > 1)
895                         CX18_WARN("Retry loading firmware\n");
896         }
897
898         if (fw_retry_count == 0) {
899                 set_bit(CX18_F_I_FAILED, &cx->i_flags);
900                 return -ENXIO;
901         }
902
903         vf.tuner = 0;
904         vf.type = V4L2_TUNER_ANALOG_TV;
905         vf.frequency = 6400; /* the tuner 'baseline' frequency */
906
907         /* Set initial frequency. For PAL/SECAM broadcasts no
908            'default' channel exists AFAIK. */
909         if (cx->std == V4L2_STD_NTSC_M_JP)
910                 vf.frequency = 1460;    /* ch. 1 91250*16/1000 */
911         else if (cx->std & V4L2_STD_NTSC_M)
912                 vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
913
914         video_input = cx->active_input;
915         cx->active_input++;     /* Force update of input */
916         cx18_s_input(NULL, &fh, video_input);
917
918         /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
919            in one place. */
920         cx->std++;              /* Force full standard initialization */
921         cx18_s_std(NULL, &fh, &cx->tuner_std);
922         cx18_s_frequency(NULL, &fh, &vf);
923         return 0;
924 }
925
926 static void cx18_remove(struct pci_dev *pci_dev)
927 {
928         struct cx18 *cx = pci_get_drvdata(pci_dev);
929
930         CX18_DEBUG_INFO("Removing Card #%d\n", cx->num);
931
932         /* Stop all captures */
933         CX18_DEBUG_INFO("Stopping all streams\n");
934         if (atomic_read(&cx->tot_capturing) > 0)
935                 cx18_stop_all_captures(cx);
936
937         /* Interrupts */
938         cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
939         cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
940
941         cx18_halt_firmware(cx);
942
943         flush_workqueue(cx->work_queue);
944         destroy_workqueue(cx->work_queue);
945
946         cx18_streams_cleanup(cx, 1);
947
948         exit_cx18_i2c(cx);
949
950         free_irq(cx->dev->irq, (void *)cx);
951
952         cx18_iounmap(cx);
953
954         release_mem_region(cx->base_addr, CX18_MEM_SIZE);
955
956         pci_disable_device(cx->dev);
957
958         cx18_log_statistics(cx);
959         CX18_INFO("Removed %s, card #%d\n", cx->card_name, cx->num);
960 }
961
962 /* define a pci_driver for card detection */
963 static struct pci_driver cx18_pci_driver = {
964       .name =     "cx18",
965       .id_table = cx18_pci_tbl,
966       .probe =    cx18_probe,
967       .remove =   cx18_remove,
968 };
969
970 static int module_start(void)
971 {
972         printk(KERN_INFO "cx18:  Start initialization, version %s\n", CX18_VERSION);
973
974         memset(cx18_cards, 0, sizeof(cx18_cards));
975
976         /* Validate parameters */
977         if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
978                 printk(KERN_ERR "cx18:  Exiting, cx18_first_minor must be between 0 and %d\n",
979                      CX18_MAX_CARDS - 1);
980                 return -1;
981         }
982
983         if (cx18_debug < 0 || cx18_debug > 511) {
984                 cx18_debug = 0;
985                 printk(KERN_INFO "cx18:   Debug value must be >= 0 and <= 511!\n");
986         }
987
988         if (pci_register_driver(&cx18_pci_driver)) {
989                 printk(KERN_ERR "cx18:   Error detecting PCI card\n");
990                 return -ENODEV;
991         }
992         printk(KERN_INFO "cx18:  End initialization\n");
993         return 0;
994 }
995
996 static void module_cleanup(void)
997 {
998         int i;
999
1000         pci_unregister_driver(&cx18_pci_driver);
1001
1002         for (i = 0; i < cx18_cards_active; i++) {
1003                 if (cx18_cards[i] == NULL)
1004                         continue;
1005                 kfree(cx18_cards[i]);
1006         }
1007 }
1008
1009 module_init(module_start);
1010 module_exit(module_cleanup);