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