git.oblomov.eu Git - linux-2.6/blob - 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 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
 425         spin_lock_init(&cx->lock);
 426         spin_lock_init(&cx->dma_reg_lock);
 427
 428         /* start counting open_id at 1 */
 429         cx->open_id = 1;
 430
 431         /* Initial settings */
 432         cx2341x_fill_defaults(&cx->params);
 433         cx->temporal_strength = cx->params.video_temporal_filter;
 434         cx->spatial_strength = cx->params.video_spatial_filter;
 435         cx->filter_mode = cx->params.video_spatial_filter_mode |
 436                 (cx->params.video_temporal_filter_mode << 1) |
 437                 (cx->params.video_median_filter_type << 2);
 438         cx->params.port = CX2341X_PORT_MEMORY;
 439         cx->params.capabilities = 0;
 440         init_waitqueue_head(&cx->cap_w);
 441         init_waitqueue_head(&cx->mb_apu_waitq);
 442         init_waitqueue_head(&cx->mb_cpu_waitq);
 443         init_waitqueue_head(&cx->mb_epu_waitq);
 444         init_waitqueue_head(&cx->mb_hpu_waitq);
 445         init_waitqueue_head(&cx->dma_waitq);
 446
 447         /* VBI */
 448         cx->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
 449         cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
 450         cx->vbi.raw_size = 1456;
 451         cx->vbi.raw_decoder_line_size = 1456;
 452         cx->vbi.raw_decoder_sav_odd_field = 0x20;
 453         cx->vbi.raw_decoder_sav_even_field = 0x60;
 454         cx->vbi.sliced_decoder_line_size = 272;
 455         cx->vbi.sliced_decoder_sav_odd_field = 0xB0;
 456         cx->vbi.sliced_decoder_sav_even_field = 0xF0;
 457         return 0;
 458 }
 459
 460 /* Second initialization part. Here the card type has been
 461    autodetected. */
 462 static void __devinit cx18_init_struct2(struct cx18 *cx)
 463 {
 464         int i;
 465
 466         for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
 467                 if (cx->card->video_inputs[i].video_type == 0)
 468                         break;
 469         cx->nof_inputs = i;
 470         for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
 471                 if (cx->card->audio_inputs[i].audio_type == 0)
 472                         break;
 473         cx->nof_audio_inputs = i;
 474
 475         /* Find tuner input */
 476         for (i = 0; i < cx->nof_inputs; i++) {
 477                 if (cx->card->video_inputs[i].video_type ==
 478                                 CX18_CARD_INPUT_VID_TUNER)
 479                         break;
 480         }
 481         if (i == cx->nof_inputs)
 482                 i = 0;
 483         cx->active_input = i;
 484         cx->audio_input = cx->card->video_inputs[i].audio_index;
 485         cx->av_state.vid_input = CX18_AV_COMPOSITE7;
 486         cx->av_state.aud_input = CX18_AV_AUDIO8;
 487         cx->av_state.audclk_freq = 48000;
 488         cx->av_state.audmode = V4L2_TUNER_MODE_LANG1;
 489         cx->av_state.vbi_line_offset = 8;
 490 }
 491
 492 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *dev,
 493                           const struct pci_device_id *pci_id)
 494 {
 495         u16 cmd;
 496         unsigned char pci_latency;
 497
 498         CX18_DEBUG_INFO("Enabling pci device\n");
 499
 500         if (pci_enable_device(dev)) {
 501                 CX18_ERR("Can't enable device %d!\n", cx->num);
 502                 return -EIO;
 503         }
 504         if (pci_set_dma_mask(dev, 0xffffffff)) {
 505                 CX18_ERR("No suitable DMA available on card %d.\n", cx->num);
 506                 return -EIO;
 507         }
 508         if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
 509                 CX18_ERR("Cannot request encoder memory region on card %d.\n", cx->num);
 510                 return -EIO;
 511         }
 512
 513         /* Check for bus mastering */
 514         pci_read_config_word(dev, PCI_COMMAND, &cmd);
 515         cmd |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
 516         pci_write_config_word(dev, PCI_COMMAND, cmd);
 517
 518         pci_read_config_byte(dev, PCI_CLASS_REVISION, &cx->card_rev);
 519         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
 520
 521         if (pci_latency < 64 && cx18_pci_latency) {
 522                 CX18_INFO("Unreasonably low latency timer, "
 523                                "setting to 64 (was %d)\n", pci_latency);
 524                 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
 525                 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
 526         }
 527         /* This config space value relates to DMA latencies. The
 528            default value 0x8080 is too low however and will lead
 529            to DMA errors. 0xffff is the max value which solves
 530            these problems. */
 531         pci_write_config_dword(dev, 0x40, 0xffff);
 532
 533         CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
 534                    "irq: %d, latency: %d, memory: 0x%lx\n",
 535                    cx->dev->device, cx->card_rev, dev->bus->number,
 536                    PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
 537                    cx->dev->irq, pci_latency, (unsigned long)cx->base_addr);
 538
 539         return 0;
 540 }
 541
 542 #ifdef MODULE
 543 static u32 cx18_request_module(struct cx18 *cx, u32 hw,
 544                 const char *name, u32 id)
 545 {
 546         if ((hw & id) == 0)
 547                 return hw;
 548         if (request_module(name) != 0) {
 549                 CX18_ERR("Failed to load module %s\n", name);
 550                 return hw & ~id;
 551         }
 552         CX18_DEBUG_INFO("Loaded module %s\n", name);
 553         return hw;
 554 }
 555 #endif
 556
 557 static void cx18_load_and_init_modules(struct cx18 *cx)
 558 {
 559         u32 hw = cx->card->hw_all;
 560         int i;
 561
 562 #ifdef MODULE
 563         /* load modules */
 564 #ifndef CONFIG_MEDIA_TUNER
 565         hw = cx18_request_module(cx, hw, "tuner", CX18_HW_TUNER);
 566 #endif
 567 #ifndef CONFIG_VIDEO_CS5345
 568         hw = cx18_request_module(cx, hw, "cs5345", CX18_HW_CS5345);
 569 #endif
 570 #endif
 571
 572         /* check which i2c devices are actually found */
 573         for (i = 0; i < 32; i++) {
 574                 u32 device = 1 << i;
 575
 576                 if (!(device & hw))
 577                         continue;
 578                 if (device == CX18_HW_GPIO || device == CX18_HW_TVEEPROM ||
 579                     device == CX18_HW_CX23418 || device == CX18_HW_DVB) {
 580                         /* These 'devices' do not use i2c probing */
 581                         cx->hw_flags |= device;
 582                         continue;
 583                 }
 584                 cx18_i2c_register(cx, i);
 585                 if (cx18_i2c_hw_addr(cx, device) > 0)
 586                         cx->hw_flags |= device;
 587         }
 588
 589         hw = cx->hw_flags;
 590 }
 591
 592 static int __devinit cx18_probe(struct pci_dev *dev,
 593                                 const struct pci_device_id *pci_id)
 594 {
 595         int retval = 0;
 596         int vbi_buf_size;
 597         u32 devtype;
 598         struct cx18 *cx;
 599
 600         spin_lock(&cx18_cards_lock);
 601
 602         /* Make sure we've got a place for this card */
 603         if (cx18_cards_active == CX18_MAX_CARDS) {
 604                 printk(KERN_ERR "cx18:  Maximum number of cards detected (%d).\n",
 605                               cx18_cards_active);
 606                 spin_unlock(&cx18_cards_lock);
 607                 return -ENOMEM;
 608         }
 609
 610         cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
 611         if (!cx) {
 612                 spin_unlock(&cx18_cards_lock);
 613                 return -ENOMEM;
 614         }
 615         cx18_cards[cx18_cards_active] = cx;
 616         cx->dev = dev;
 617         cx->num = cx18_cards_active++;
 618         snprintf(cx->name, sizeof(cx->name), "cx18-%d", cx->num);
 619         CX18_INFO("Initializing card #%d\n", cx->num);
 620
 621         spin_unlock(&cx18_cards_lock);
 622
 623         cx18_process_options(cx);
 624         if (cx->options.cardtype == -1) {
 625                 retval = -ENODEV;
 626                 goto err;
 627         }
 628         if (cx18_init_struct1(cx)) {
 629                 retval = -ENOMEM;
 630                 goto err;
 631         }
 632
 633         CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
 634
 635         /* PCI Device Setup */
 636         retval = cx18_setup_pci(cx, dev, pci_id);
 637         if (retval != 0) {
 638                 if (retval == -EIO)
 639                         goto free_workqueue;
 640                 else if (retval == -ENXIO)
 641                         goto free_mem;
 642         }
 643         /* save cx in the pci struct for later use */
 644         pci_set_drvdata(dev, cx);
 645
 646         /* map io memory */
 647         CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
 648                    cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
 649         cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
 650                                        CX18_MEM_SIZE);
 651         if (!cx->enc_mem) {
 652                 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
 653                 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
 654                 retval = -ENOMEM;
 655                 goto free_mem;
 656         }
 657         cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
 658         devtype = read_reg(0xC72028);
 659         switch (devtype & 0xff000000) {
 660         case 0xff000000:
 661                 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
 662                 break;
 663         case 0x01000000:
 664                 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
 665                 break;
 666         default:
 667                 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
 668                 break;
 669         }
 670
 671         cx18_init_power(cx, 1);
 672         cx18_init_memory(cx);
 673
 674         cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
 675         cx18_init_scb(cx);
 676
 677         cx18_gpio_init(cx);
 678
 679         /* active i2c  */
 680         CX18_DEBUG_INFO("activating i2c...\n");
 681         if (init_cx18_i2c(cx)) {
 682                 CX18_ERR("Could not initialize i2c\n");
 683                 goto free_map;
 684         }
 685
 686         CX18_DEBUG_INFO("Active card count: %d.\n", cx18_cards_active);
 687
 688         if (cx->card->hw_all & CX18_HW_TVEEPROM) {
 689                 /* Based on the model number the cardtype may be changed.
 690                    The PCI IDs are not always reliable. */
 691                 cx18_process_eeprom(cx);
 692         }
 693         if (cx->card->comment)
 694                 CX18_INFO("%s", cx->card->comment);
 695         if (cx->card->v4l2_capabilities == 0) {
 696                 retval = -ENODEV;
 697                 goto free_i2c;
 698         }
 699         cx18_init_memory(cx);
 700
 701         /* Register IRQ */
 702         retval = request_irq(cx->dev->irq, cx18_irq_handler,
 703                              IRQF_SHARED | IRQF_DISABLED, cx->name, (void *)cx);
 704         if (retval) {
 705                 CX18_ERR("Failed to register irq %d\n", retval);
 706                 goto free_i2c;
 707         }
 708
 709         if (cx->std == 0)
 710                 cx->std = V4L2_STD_NTSC_M;
 711
 712         if (cx->options.tuner == -1) {
 713                 int i;
 714
 715                 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
 716                         if ((cx->std & cx->card->tuners[i].std) == 0)
 717                                 continue;
 718                         cx->options.tuner = cx->card->tuners[i].tuner;
 719                         break;
 720                 }
 721         }
 722         /* if no tuner was found, then pick the first tuner in the card list */
 723         if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
 724                 cx->std = cx->card->tuners[0].std;
 725                 cx->options.tuner = cx->card->tuners[0].tuner;
 726         }
 727         if (cx->options.radio == -1)
 728                 cx->options.radio = (cx->card->radio_input.audio_type != 0);
 729
 730         /* The card is now fully identified, continue with card-specific
 731            initialization. */
 732         cx18_init_struct2(cx);
 733
 734         cx18_load_and_init_modules(cx);
 735
 736         if (cx->std & V4L2_STD_525_60) {
 737                 cx->is_60hz = 1;
 738                 cx->is_out_60hz = 1;
 739         } else {
 740                 cx->is_50hz = 1;
 741                 cx->is_out_50hz = 1;
 742         }
 743         cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
 744
 745         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = 0x08000;
 746         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = 0x08000;
 747         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = 0x01200;
 748         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = 0x20000;
 749         vbi_buf_size = cx->vbi.raw_size * (cx->is_60hz ? 24 : 36) / 2;
 750         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
 751
 752         if (cx->options.radio > 0)
 753                 cx->v4l2_cap |= V4L2_CAP_RADIO;
 754
 755         if (cx->options.tuner > -1) {
 756                 struct tuner_setup setup;
 757
 758                 setup.addr = ADDR_UNSET;
 759                 setup.type = cx->options.tuner;
 760                 setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
 761                 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
 762                         cx18_reset_tuner_gpio : NULL;
 763                 cx18_call_i2c_clients(cx, TUNER_SET_TYPE_ADDR, &setup);
 764                 if (setup.type == TUNER_XC2028) {
 765                         static struct xc2028_ctrl ctrl = {
 766                                 .fname = XC2028_DEFAULT_FIRMWARE,
 767                                 .max_len = 64,
 768                         };
 769                         struct v4l2_priv_tun_config cfg = {
 770                                 .tuner = cx->options.tuner,
 771                                 .priv = &ctrl,
 772                         };
 773                         cx18_call_i2c_clients(cx, TUNER_SET_CONFIG, &cfg);
 774                 }
 775         }
 776
 777         /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
 778            are not. */
 779         cx->tuner_std = cx->std;
 780
 781         retval = cx18_streams_setup(cx);
 782         if (retval) {
 783                 CX18_ERR("Error %d setting up streams\n", retval);
 784                 goto free_irq;
 785         }
 786         retval = cx18_streams_register(cx);
 787         if (retval) {
 788                 CX18_ERR("Error %d registering devices\n", retval);
 789                 goto free_streams;
 790         }
 791
 792         CX18_INFO("Initialized card #%d: %s\n", cx->num, cx->card_name);
 793
 794         return 0;
 795
 796 free_streams:
 797         cx18_streams_cleanup(cx, 1);
 798 free_irq:
 799         free_irq(cx->dev->irq, (void *)cx);
 800 free_i2c:
 801         exit_cx18_i2c(cx);
 802 free_map:
 803         cx18_iounmap(cx);
 804 free_mem:
 805         release_mem_region(cx->base_addr, CX18_MEM_SIZE);
 806 free_workqueue:
 807 err:
 808         if (retval == 0)
 809                 retval = -ENODEV;
 810         CX18_ERR("Error %d on initialization\n", retval);
 811
 812         kfree(cx18_cards[cx18_cards_active]);
 813         cx18_cards[cx18_cards_active] = NULL;
 814         return retval;
 815 }
 816
 817 int cx18_init_on_first_open(struct cx18 *cx)
 818 {
 819         int video_input;
 820         int fw_retry_count = 3;
 821         struct v4l2_frequency vf;
 822         struct cx18_open_id fh;
 823
 824         fh.cx = cx;
 825
 826         if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
 827                 return -ENXIO;
 828
 829         if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
 830                 return 0;
 831
 832         while (--fw_retry_count > 0) {
 833                 /* load firmware */
 834                 if (cx18_firmware_init(cx) == 0)
 835                         break;
 836                 if (fw_retry_count > 1)
 837                         CX18_WARN("Retry loading firmware\n");
 838         }
 839
 840         if (fw_retry_count == 0) {
 841                 set_bit(CX18_F_I_FAILED, &cx->i_flags);
 842                 return -ENXIO;
 843         }
 844         set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
 845
 846         /* Init the firmware twice to work around a silicon bug
 847          * transport related. */
 848
 849         fw_retry_count = 3;
 850         while (--fw_retry_count > 0) {
 851                 /* load firmware */
 852                 if (cx18_firmware_init(cx) == 0)
 853                         break;
 854                 if (fw_retry_count > 1)
 855                         CX18_WARN("Retry loading firmware\n");
 856         }
 857
 858         if (fw_retry_count == 0) {
 859                 set_bit(CX18_F_I_FAILED, &cx->i_flags);
 860                 return -ENXIO;
 861         }
 862
 863         vf.tuner = 0;
 864         vf.type = V4L2_TUNER_ANALOG_TV;
 865         vf.frequency = 6400; /* the tuner 'baseline' frequency */
 866
 867         /* Set initial frequency. For PAL/SECAM broadcasts no
 868            'default' channel exists AFAIK. */
 869         if (cx->std == V4L2_STD_NTSC_M_JP)
 870                 vf.frequency = 1460;    /* ch. 1 91250*16/1000 */
 871         else if (cx->std & V4L2_STD_NTSC_M)
 872                 vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
 873
 874         video_input = cx->active_input;
 875         cx->active_input++;     /* Force update of input */
 876         cx18_s_input(NULL, &fh, video_input);
 877
 878         /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
 879            in one place. */
 880         cx->std++;              /* Force full standard initialization */
 881         cx18_s_std(NULL, &fh, &cx->tuner_std);
 882         cx18_s_frequency(NULL, &fh, &vf);
 883         return 0;
 884 }
 885
 886 static void cx18_remove(struct pci_dev *pci_dev)
 887 {
 888         struct cx18 *cx = pci_get_drvdata(pci_dev);
 889
 890         CX18_DEBUG_INFO("Removing Card #%d\n", cx->num);
 891
 892         /* Stop all captures */
 893         CX18_DEBUG_INFO("Stopping all streams\n");
 894         if (atomic_read(&cx->tot_capturing) > 0)
 895                 cx18_stop_all_captures(cx);
 896
 897         /* Interrupts */
 898         sw1_irq_disable(IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
 899         sw2_irq_disable(IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
 900
 901         cx18_halt_firmware(cx);
 902
 903         cx18_streams_cleanup(cx, 1);
 904
 905         exit_cx18_i2c(cx);
 906
 907         free_irq(cx->dev->irq, (void *)cx);
 908
 909         cx18_iounmap(cx);
 910
 911         release_mem_region(cx->base_addr, CX18_MEM_SIZE);
 912
 913         pci_disable_device(cx->dev);
 914
 915         CX18_INFO("Removed %s, card #%d\n", cx->card_name, cx->num);
 916 }
 917
 918 /* define a pci_driver for card detection */
 919 static struct pci_driver cx18_pci_driver = {
 920       .name =     "cx18",
 921       .id_table = cx18_pci_tbl,
 922       .probe =    cx18_probe,
 923       .remove =   cx18_remove,
 924 };
 925
 926 static int module_start(void)
 927 {
 928         printk(KERN_INFO "cx18:  Start initialization, version %s\n", CX18_VERSION);
 929
 930         memset(cx18_cards, 0, sizeof(cx18_cards));
 931
 932         /* Validate parameters */
 933         if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
 934                 printk(KERN_ERR "cx18:  Exiting, ivtv_first_minor must be between 0 and %d\n",
 935                      CX18_MAX_CARDS - 1);
 936                 return -1;
 937         }
 938
 939         if (cx18_debug < 0 || cx18_debug > 511) {
 940                 cx18_debug = 0;
 941                 printk(KERN_INFO "cx18:   Debug value must be >= 0 and <= 511!\n");
 942         }
 943
 944         if (pci_register_driver(&cx18_pci_driver)) {
 945                 printk(KERN_ERR "cx18:   Error detecting PCI card\n");
 946                 return -ENODEV;
 947         }
 948         printk(KERN_INFO "cx18:  End initialization\n");
 949         return 0;
 950 }
 951
 952 static void module_cleanup(void)
 953 {
 954         int i;
 955
 956         pci_unregister_driver(&cx18_pci_driver);
 957
 958         for (i = 0; i < cx18_cards_active; i++) {
 959                 if (cx18_cards[i] == NULL)
 960                         continue;
 961                 kfree(cx18_cards[i]);
 962         }
 963 }
 964
 965 module_init(module_start);
 966 module_exit(module_cleanup);