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