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