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 = CX2341X_CAP_HAS_TS;
 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                 if (cx->std & V4L2_STD_PAL)
 726                         cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
 727                 else if (cx->std & V4L2_STD_NTSC)
 728                         cx->std = V4L2_STD_NTSC_M;
 729                 else if (cx->std & V4L2_STD_SECAM)
 730                         cx->std = V4L2_STD_SECAM_L;
 731                 cx->options.tuner = cx->card->tuners[0].tuner;
 732         }
 733         if (cx->options.radio == -1)
 734                 cx->options.radio = (cx->card->radio_input.audio_type != 0);
 735
 736         /* The card is now fully identified, continue with card-specific
 737            initialization. */
 738         cx18_init_struct2(cx);
 739
 740         cx18_load_and_init_modules(cx);
 741
 742         if (cx->std & V4L2_STD_525_60) {
 743                 cx->is_60hz = 1;
 744                 cx->is_out_60hz = 1;
 745         } else {
 746                 cx->is_50hz = 1;
 747                 cx->is_out_50hz = 1;
 748         }
 749         cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
 750
 751         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = 0x08000;
 752         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = 0x08000;
 753         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = 0x01200;
 754         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = 0x20000;
 755         vbi_buf_size = cx->vbi.raw_size * (cx->is_60hz ? 24 : 36) / 2;
 756         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
 757
 758         if (cx->options.radio > 0)
 759                 cx->v4l2_cap |= V4L2_CAP_RADIO;
 760
 761         if (cx->options.tuner > -1) {
 762                 struct tuner_setup setup;
 763
 764                 setup.addr = ADDR_UNSET;
 765                 setup.type = cx->options.tuner;
 766                 setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
 767                 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
 768                         cx18_reset_tuner_gpio : NULL;
 769                 cx18_call_i2c_clients(cx, TUNER_SET_TYPE_ADDR, &setup);
 770                 if (setup.type == TUNER_XC2028) {
 771                         static struct xc2028_ctrl ctrl = {
 772                                 .fname = XC2028_DEFAULT_FIRMWARE,
 773                                 .max_len = 64,
 774                         };
 775                         struct v4l2_priv_tun_config cfg = {
 776                                 .tuner = cx->options.tuner,
 777                                 .priv = &ctrl,
 778                         };
 779                         cx18_call_i2c_clients(cx, TUNER_SET_CONFIG, &cfg);
 780                 }
 781         }
 782
 783         /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
 784            are not. */
 785         cx->tuner_std = cx->std;
 786
 787         retval = cx18_streams_setup(cx);
 788         if (retval) {
 789                 CX18_ERR("Error %d setting up streams\n", retval);
 790                 goto free_irq;
 791         }
 792         retval = cx18_streams_register(cx);
 793         if (retval) {
 794                 CX18_ERR("Error %d registering devices\n", retval);
 795                 goto free_streams;
 796         }
 797
 798         CX18_INFO("Initialized card #%d: %s\n", cx->num, cx->card_name);
 799
 800         return 0;
 801
 802 free_streams:
 803         cx18_streams_cleanup(cx, 1);
 804 free_irq:
 805         free_irq(cx->dev->irq, (void *)cx);
 806 free_i2c:
 807         exit_cx18_i2c(cx);
 808 free_map:
 809         cx18_iounmap(cx);
 810 free_mem:
 811         release_mem_region(cx->base_addr, CX18_MEM_SIZE);
 812 free_workqueue:
 813 err:
 814         if (retval == 0)
 815                 retval = -ENODEV;
 816         CX18_ERR("Error %d on initialization\n", retval);
 817
 818         kfree(cx18_cards[cx18_cards_active]);
 819         cx18_cards[cx18_cards_active] = NULL;
 820         return retval;
 821 }
 822
 823 int cx18_init_on_first_open(struct cx18 *cx)
 824 {
 825         int video_input;
 826         int fw_retry_count = 3;
 827         struct v4l2_frequency vf;
 828         struct cx18_open_id fh;
 829
 830         fh.cx = cx;
 831
 832         if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
 833                 return -ENXIO;
 834
 835         if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
 836                 return 0;
 837
 838         while (--fw_retry_count > 0) {
 839                 /* load firmware */
 840                 if (cx18_firmware_init(cx) == 0)
 841                         break;
 842                 if (fw_retry_count > 1)
 843                         CX18_WARN("Retry loading firmware\n");
 844         }
 845
 846         if (fw_retry_count == 0) {
 847                 set_bit(CX18_F_I_FAILED, &cx->i_flags);
 848                 return -ENXIO;
 849         }
 850         set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
 851
 852         /* Init the firmware twice to work around a silicon bug
 853          * transport related. */
 854
 855         fw_retry_count = 3;
 856         while (--fw_retry_count > 0) {
 857                 /* load firmware */
 858                 if (cx18_firmware_init(cx) == 0)
 859                         break;
 860                 if (fw_retry_count > 1)
 861                         CX18_WARN("Retry loading firmware\n");
 862         }
 863
 864         if (fw_retry_count == 0) {
 865                 set_bit(CX18_F_I_FAILED, &cx->i_flags);
 866                 return -ENXIO;
 867         }
 868
 869         vf.tuner = 0;
 870         vf.type = V4L2_TUNER_ANALOG_TV;
 871         vf.frequency = 6400; /* the tuner 'baseline' frequency */
 872
 873         /* Set initial frequency. For PAL/SECAM broadcasts no
 874            'default' channel exists AFAIK. */
 875         if (cx->std == V4L2_STD_NTSC_M_JP)
 876                 vf.frequency = 1460;    /* ch. 1 91250*16/1000 */
 877         else if (cx->std & V4L2_STD_NTSC_M)
 878                 vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
 879
 880         video_input = cx->active_input;
 881         cx->active_input++;     /* Force update of input */
 882         cx18_s_input(NULL, &fh, video_input);
 883
 884         /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
 885            in one place. */
 886         cx->std++;              /* Force full standard initialization */
 887         cx18_s_std(NULL, &fh, &cx->tuner_std);
 888         cx18_s_frequency(NULL, &fh, &vf);
 889         return 0;
 890 }
 891
 892 static void cx18_remove(struct pci_dev *pci_dev)
 893 {
 894         struct cx18 *cx = pci_get_drvdata(pci_dev);
 895
 896         CX18_DEBUG_INFO("Removing Card #%d\n", cx->num);
 897
 898         /* Stop all captures */
 899         CX18_DEBUG_INFO("Stopping all streams\n");
 900         if (atomic_read(&cx->tot_capturing) > 0)
 901                 cx18_stop_all_captures(cx);
 902
 903         /* Interrupts */
 904         sw1_irq_disable(IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
 905         sw2_irq_disable(IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
 906
 907         cx18_halt_firmware(cx);
 908
 909         cx18_streams_cleanup(cx, 1);
 910
 911         exit_cx18_i2c(cx);
 912
 913         free_irq(cx->dev->irq, (void *)cx);
 914
 915         cx18_iounmap(cx);
 916
 917         release_mem_region(cx->base_addr, CX18_MEM_SIZE);
 918
 919         pci_disable_device(cx->dev);
 920
 921         CX18_INFO("Removed %s, card #%d\n", cx->card_name, cx->num);
 922 }
 923
 924 /* define a pci_driver for card detection */
 925 static struct pci_driver cx18_pci_driver = {
 926       .name =     "cx18",
 927       .id_table = cx18_pci_tbl,
 928       .probe =    cx18_probe,
 929       .remove =   cx18_remove,
 930 };
 931
 932 static int module_start(void)
 933 {
 934         printk(KERN_INFO "cx18:  Start initialization, version %s\n", CX18_VERSION);
 935
 936         memset(cx18_cards, 0, sizeof(cx18_cards));
 937
 938         /* Validate parameters */
 939         if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
 940                 printk(KERN_ERR "cx18:  Exiting, ivtv_first_minor must be between 0 and %d\n",
 941                      CX18_MAX_CARDS - 1);
 942                 return -1;
 943         }
 944
 945         if (cx18_debug < 0 || cx18_debug > 511) {
 946                 cx18_debug = 0;
 947                 printk(KERN_INFO "cx18:   Debug value must be >= 0 and <= 511!\n");
 948         }
 949
 950         if (pci_register_driver(&cx18_pci_driver)) {
 951                 printk(KERN_ERR "cx18:   Error detecting PCI card\n");
 952                 return -ENODEV;
 953         }
 954         printk(KERN_INFO "cx18:  End initialization\n");
 955         return 0;
 956 }
 957
 958 static void module_cleanup(void)
 959 {
 960         int i;
 961
 962         pci_unregister_driver(&cx18_pci_driver);
 963
 964         for (i = 0; i < cx18_cards_active; i++) {
 965                 if (cx18_cards[i] == NULL)
 966                         continue;
 967                 kfree(cx18_cards[i]);
 968         }
 969 }
 970
 971 module_init(module_start);
 972 module_exit(module_cleanup);