1 /* 2 * Zoran zr36057/zr36067 PCI controller driver, for the 3 * Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux 4 * Media Labs LML33/LML33R10. 5 * 6 * This part handles card-specific data and detection 7 * 8 * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx> 9 * 10 * Currently maintained by: 11 * Ronald Bultje <rbultje@ronald.bitfreak.net> 12 * Laurent Pinchart <laurent.pinchart@skynet.be> 13 * Mailinglist <mjpeg-users@lists.sf.net> 14 * 15 * This program is free software; you can redistribute it and/or modify 16 * it under the terms of the GNU General Public License as published by 17 * the Free Software Foundation; either version 2 of the License, or 18 * (at your option) any later version. 19 * 20 * This program is distributed in the hope that it will be useful, 21 * but WITHOUT ANY WARRANTY; without even the implied warranty of 22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 23 * GNU General Public License for more details. 24 */ 25 26 #include <linux/delay.h> 27 28 #include <linux/types.h> 29 #include <linux/kernel.h> 30 #include <linux/module.h> 31 #include <linux/init.h> 32 #include <linux/vmalloc.h> 33 #include <linux/slab.h> 34 35 #include <linux/proc_fs.h> 36 #include <linux/i2c.h> 37 #include <linux/i2c-algo-bit.h> 38 #include <linux/videodev2.h> 39 #include <linux/spinlock.h> 40 #include <linux/sem.h> 41 #include <linux/kmod.h> 42 #include <linux/wait.h> 43 44 #include <linux/pci.h> 45 #include <linux/interrupt.h> 46 #include <linux/mutex.h> 47 #include <linux/io.h> 48 #include <media/v4l2-common.h> 49 #include <media/i2c/bt819.h> 50 51 #include "videocodec.h" 52 #include "zoran.h" 53 #include "zoran_card.h" 54 #include "zoran_device.h" 55 #include "zoran_procfs.h" 56 57 extern const struct zoran_format zoran_formats[]; 58 59 static int card[BUZ_MAX] = { [0 ... (BUZ_MAX-1)] = -1 }; 60 module_param_array(card, int, NULL, 0444); 61 MODULE_PARM_DESC(card, "Card type"); 62 63 /* 64 The video mem address of the video card. 65 The driver has a little database for some videocards 66 to determine it from there. If your video card is not in there 67 you have either to give it to the driver as a parameter 68 or set in in a VIDIOCSFBUF ioctl 69 */ 70 71 static unsigned long vidmem; /* default = 0 - Video memory base address */ 72 module_param_hw(vidmem, ulong, iomem, 0444); 73 MODULE_PARM_DESC(vidmem, "Default video memory base address"); 74 75 /* 76 Default input and video norm at startup of the driver. 77 */ 78 79 static unsigned int default_input; /* default 0 = Composite, 1 = S-Video */ 80 module_param(default_input, uint, 0444); 81 MODULE_PARM_DESC(default_input, 82 "Default input (0=Composite, 1=S-Video, 2=Internal)"); 83 84 static int default_mux = 1; /* 6 Eyes input selection */ 85 module_param(default_mux, int, 0644); 86 MODULE_PARM_DESC(default_mux, 87 "Default 6 Eyes mux setting (Input selection)"); 88 89 static int default_norm; /* default 0 = PAL, 1 = NTSC 2 = SECAM */ 90 module_param(default_norm, int, 0444); 91 MODULE_PARM_DESC(default_norm, "Default norm (0=PAL, 1=NTSC, 2=SECAM)"); 92 93 /* /dev/videoN, -1 for autodetect */ 94 static int video_nr[BUZ_MAX] = { [0 ... (BUZ_MAX-1)] = -1 }; 95 module_param_array(video_nr, int, NULL, 0444); 96 MODULE_PARM_DESC(video_nr, "Video device number (-1=Auto)"); 97 98 int v4l_nbufs = 4; 99 int v4l_bufsize = 864; /* Everybody should be able to work with this setting */ 100 module_param(v4l_nbufs, int, 0644); 101 MODULE_PARM_DESC(v4l_nbufs, "Maximum number of V4L buffers to use"); 102 module_param(v4l_bufsize, int, 0644); 103 MODULE_PARM_DESC(v4l_bufsize, "Maximum size per V4L buffer (in kB)"); 104 105 int jpg_nbufs = 32; 106 int jpg_bufsize = 512; /* max size for 100% quality full-PAL frame */ 107 module_param(jpg_nbufs, int, 0644); 108 MODULE_PARM_DESC(jpg_nbufs, "Maximum number of JPG buffers to use"); 109 module_param(jpg_bufsize, int, 0644); 110 MODULE_PARM_DESC(jpg_bufsize, "Maximum size per JPG buffer (in kB)"); 111 112 int pass_through = 0; /* 1=Pass through TV signal when device is not used */ 113 /* 0=Show color bar when device is not used (LML33: only if lml33dpath=1) */ 114 module_param(pass_through, int, 0644); 115 MODULE_PARM_DESC(pass_through, 116 "Pass TV signal through to TV-out when idling"); 117 118 int zr36067_debug = 1; 119 module_param_named(debug, zr36067_debug, int, 0644); 120 MODULE_PARM_DESC(debug, "Debug level (0-5)"); 121 122 #define ZORAN_VERSION "0.10.1" 123 124 MODULE_DESCRIPTION("Zoran-36057/36067 JPEG codec driver"); 125 MODULE_AUTHOR("Serguei Miridonov"); 126 MODULE_LICENSE("GPL"); 127 MODULE_VERSION(ZORAN_VERSION); 128 129 #define ZR_DEVICE(subven, subdev, data) { \ 130 .vendor = PCI_VENDOR_ID_ZORAN, .device = PCI_DEVICE_ID_ZORAN_36057, \ 131 .subvendor = (subven), .subdevice = (subdev), .driver_data = (data) } 132 133 static struct pci_device_id zr36067_pci_tbl[] = { 134 ZR_DEVICE(PCI_VENDOR_ID_MIRO, PCI_DEVICE_ID_MIRO_DC10PLUS, DC10plus), 135 ZR_DEVICE(PCI_VENDOR_ID_MIRO, PCI_DEVICE_ID_MIRO_DC30PLUS, DC30plus), 136 ZR_DEVICE(PCI_VENDOR_ID_ELECTRONICDESIGNGMBH, PCI_DEVICE_ID_LML_33R10, LML33R10), 137 ZR_DEVICE(PCI_VENDOR_ID_IOMEGA, PCI_DEVICE_ID_IOMEGA_BUZ, BUZ), 138 ZR_DEVICE(PCI_ANY_ID, PCI_ANY_ID, NUM_CARDS), 139 {0} 140 }; 141 MODULE_DEVICE_TABLE(pci, zr36067_pci_tbl); 142 143 static unsigned int zoran_num; /* number of cards found */ 144 145 /* videocodec bus functions ZR36060 */ 146 static u32 147 zr36060_read (struct videocodec *codec, 148 u16 reg) 149 { 150 struct zoran *zr = (struct zoran *) codec->master_data->data; 151 __u32 data; 152 153 if (post_office_wait(zr) 154 || post_office_write(zr, 0, 1, reg >> 8) 155 || post_office_write(zr, 0, 2, reg & 0xff)) { 156 return -1; 157 } 158 159 data = post_office_read(zr, 0, 3) & 0xff; 160 return data; 161 } 162 163 static void 164 zr36060_write (struct videocodec *codec, 165 u16 reg, 166 u32 val) 167 { 168 struct zoran *zr = (struct zoran *) codec->master_data->data; 169 170 if (post_office_wait(zr) 171 || post_office_write(zr, 0, 1, reg >> 8) 172 || post_office_write(zr, 0, 2, reg & 0xff)) { 173 return; 174 } 175 176 post_office_write(zr, 0, 3, val & 0xff); 177 } 178 179 /* videocodec bus functions ZR36050 */ 180 static u32 181 zr36050_read (struct videocodec *codec, 182 u16 reg) 183 { 184 struct zoran *zr = (struct zoran *) codec->master_data->data; 185 __u32 data; 186 187 if (post_office_wait(zr) 188 || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES 189 return -1; 190 } 191 192 data = post_office_read(zr, 0, reg & 0x03) & 0xff; // reg. LOWBYTES + read 193 return data; 194 } 195 196 static void 197 zr36050_write (struct videocodec *codec, 198 u16 reg, 199 u32 val) 200 { 201 struct zoran *zr = (struct zoran *) codec->master_data->data; 202 203 if (post_office_wait(zr) 204 || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES 205 return; 206 } 207 208 post_office_write(zr, 0, reg & 0x03, val & 0xff); // reg. LOWBYTES + wr. data 209 } 210 211 /* videocodec bus functions ZR36016 */ 212 static u32 213 zr36016_read (struct videocodec *codec, 214 u16 reg) 215 { 216 struct zoran *zr = (struct zoran *) codec->master_data->data; 217 __u32 data; 218 219 if (post_office_wait(zr)) { 220 return -1; 221 } 222 223 data = post_office_read(zr, 2, reg & 0x03) & 0xff; // read 224 return data; 225 } 226 227 /* hack for in zoran_device.c */ 228 void 229 zr36016_write (struct videocodec *codec, 230 u16 reg, 231 u32 val) 232 { 233 struct zoran *zr = (struct zoran *) codec->master_data->data; 234 235 if (post_office_wait(zr)) { 236 return; 237 } 238 239 post_office_write(zr, 2, reg & 0x03, val & 0x0ff); // wr. data 240 } 241 242 /* 243 * Board specific information 244 */ 245 246 static void 247 dc10_init (struct zoran *zr) 248 { 249 dprintk(3, KERN_DEBUG "%s: %s\n", ZR_DEVNAME(zr), __func__); 250 251 /* Pixel clock selection */ 252 GPIO(zr, 4, 0); 253 GPIO(zr, 5, 1); 254 /* Enable the video bus sync signals */ 255 GPIO(zr, 7, 0); 256 } 257 258 static void 259 dc10plus_init (struct zoran *zr) 260 { 261 dprintk(3, KERN_DEBUG "%s: %s\n", ZR_DEVNAME(zr), __func__); 262 } 263 264 static void 265 buz_init (struct zoran *zr) 266 { 267 dprintk(3, KERN_DEBUG "%s: %s\n", ZR_DEVNAME(zr), __func__); 268 269 /* some stuff from Iomega */ 270 pci_write_config_dword(zr->pci_dev, 0xfc, 0x90680f15); 271 pci_write_config_dword(zr->pci_dev, 0x0c, 0x00012020); 272 pci_write_config_dword(zr->pci_dev, 0xe8, 0xc0200000); 273 } 274 275 static void 276 lml33_init (struct zoran *zr) 277 { 278 dprintk(3, KERN_DEBUG "%s: %s\n", ZR_DEVNAME(zr), __func__); 279 280 GPIO(zr, 2, 1); // Set Composite input/output 281 } 282 283 static void 284 avs6eyes_init (struct zoran *zr) 285 { 286 // AverMedia 6-Eyes original driver by Christer Weinigel 287 288 // Lifted straight from Christer's old driver and 289 // modified slightly by Martin Samuelsson. 290 291 int mux = default_mux; /* 1 = BT866, 7 = VID1 */ 292 293 GPIO(zr, 4, 1); /* Bt866 SLEEP on */ 294 udelay(2); 295 296 GPIO(zr, 0, 1); /* ZR36060 /RESET on */ 297 GPIO(zr, 1, 0); /* ZR36060 /SLEEP on */ 298 GPIO(zr, 2, mux & 1); /* MUX S0 */ 299 GPIO(zr, 3, 0); /* /FRAME on */ 300 GPIO(zr, 4, 0); /* Bt866 SLEEP off */ 301 GPIO(zr, 5, mux & 2); /* MUX S1 */ 302 GPIO(zr, 6, 0); /* ? */ 303 GPIO(zr, 7, mux & 4); /* MUX S2 */ 304 305 } 306 307 static char * 308 codecid_to_modulename (u16 codecid) 309 { 310 char *name = NULL; 311 312 switch (codecid) { 313 case CODEC_TYPE_ZR36060: 314 name = "zr36060"; 315 break; 316 case CODEC_TYPE_ZR36050: 317 name = "zr36050"; 318 break; 319 case CODEC_TYPE_ZR36016: 320 name = "zr36016"; 321 break; 322 } 323 324 return name; 325 } 326 327 // struct tvnorm { 328 // u16 Wt, Wa, HStart, HSyncStart, Ht, Ha, VStart; 329 // }; 330 331 static struct tvnorm f50sqpixel = { 944, 768, 83, 880, 625, 576, 16 }; 332 static struct tvnorm f60sqpixel = { 780, 640, 51, 716, 525, 480, 12 }; 333 static struct tvnorm f50ccir601 = { 864, 720, 75, 804, 625, 576, 18 }; 334 static struct tvnorm f60ccir601 = { 858, 720, 57, 788, 525, 480, 16 }; 335 336 static struct tvnorm f50ccir601_lml33 = { 864, 720, 75+34, 804, 625, 576, 18 }; 337 static struct tvnorm f60ccir601_lml33 = { 858, 720, 57+34, 788, 525, 480, 16 }; 338 339 /* The DC10 (57/16/50) uses VActive as HSync, so HStart must be 0 */ 340 static struct tvnorm f50sqpixel_dc10 = { 944, 768, 0, 880, 625, 576, 0 }; 341 static struct tvnorm f60sqpixel_dc10 = { 780, 640, 0, 716, 525, 480, 12 }; 342 343 /* FIXME: I cannot swap U and V in saa7114, so i do one 344 * pixel left shift in zoran (75 -> 74) 345 * (Maxim Yevtyushkin <max@linuxmedialabs.com>) */ 346 static struct tvnorm f50ccir601_lm33r10 = { 864, 720, 74+54, 804, 625, 576, 18 }; 347 static struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56+54, 788, 525, 480, 16 }; 348 349 /* FIXME: The ks0127 seem incapable of swapping U and V, too, which is why I 350 * copy Maxim's left shift hack for the 6 Eyes. 351 * 352 * Christer's driver used the unshifted norms, though... 353 * /Sam */ 354 static struct tvnorm f50ccir601_avs6eyes = { 864, 720, 74, 804, 625, 576, 18 }; 355 static struct tvnorm f60ccir601_avs6eyes = { 858, 720, 56, 788, 525, 480, 16 }; 356 357 static const unsigned short vpx3220_addrs[] = { 0x43, 0x47, I2C_CLIENT_END }; 358 static const unsigned short saa7110_addrs[] = { 0x4e, 0x4f, I2C_CLIENT_END }; 359 static const unsigned short saa7111_addrs[] = { 0x25, 0x24, I2C_CLIENT_END }; 360 static const unsigned short saa7114_addrs[] = { 0x21, 0x20, I2C_CLIENT_END }; 361 static const unsigned short adv717x_addrs[] = { 0x6a, 0x6b, 0x2a, 0x2b, I2C_CLIENT_END }; 362 static const unsigned short ks0127_addrs[] = { 0x6c, 0x6d, I2C_CLIENT_END }; 363 static const unsigned short saa7185_addrs[] = { 0x44, I2C_CLIENT_END }; 364 static const unsigned short bt819_addrs[] = { 0x45, I2C_CLIENT_END }; 365 static const unsigned short bt856_addrs[] = { 0x44, I2C_CLIENT_END }; 366 static const unsigned short bt866_addrs[] = { 0x44, I2C_CLIENT_END }; 367 368 static struct card_info zoran_cards[NUM_CARDS] = { 369 { 370 .type = DC10_old, 371 .name = "DC10(old)", 372 .i2c_decoder = "vpx3220a", 373 .addrs_decoder = vpx3220_addrs, 374 .video_codec = CODEC_TYPE_ZR36050, 375 .video_vfe = CODEC_TYPE_ZR36016, 376 377 .inputs = 3, 378 .input = { 379 { 1, "Composite" }, 380 { 2, "S-Video" }, 381 { 0, "Internal/comp" } 382 }, 383 .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM, 384 .tvn = { 385 &f50sqpixel_dc10, 386 &f60sqpixel_dc10, 387 &f50sqpixel_dc10 388 }, 389 .jpeg_int = 0, 390 .vsync_int = ZR36057_ISR_GIRQ1, 391 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 }, 392 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 }, 393 .gpcs = { -1, 0 }, 394 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, 395 .gws_not_connected = 0, 396 .input_mux = 0, 397 .init = &dc10_init, 398 }, { 399 .type = DC10_new, 400 .name = "DC10(new)", 401 .i2c_decoder = "saa7110", 402 .addrs_decoder = saa7110_addrs, 403 .i2c_encoder = "adv7175", 404 .addrs_encoder = adv717x_addrs, 405 .video_codec = CODEC_TYPE_ZR36060, 406 407 .inputs = 3, 408 .input = { 409 { 0, "Composite" }, 410 { 7, "S-Video" }, 411 { 5, "Internal/comp" } 412 }, 413 .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM, 414 .tvn = { 415 &f50sqpixel, 416 &f60sqpixel, 417 &f50sqpixel}, 418 .jpeg_int = ZR36057_ISR_GIRQ0, 419 .vsync_int = ZR36057_ISR_GIRQ1, 420 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 }, 421 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, 422 .gpcs = { -1, 1}, 423 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 }, 424 .gws_not_connected = 0, 425 .input_mux = 0, 426 .init = &dc10plus_init, 427 }, { 428 .type = DC10plus, 429 .name = "DC10plus", 430 .i2c_decoder = "saa7110", 431 .addrs_decoder = saa7110_addrs, 432 .i2c_encoder = "adv7175", 433 .addrs_encoder = adv717x_addrs, 434 .video_codec = CODEC_TYPE_ZR36060, 435 436 .inputs = 3, 437 .input = { 438 { 0, "Composite" }, 439 { 7, "S-Video" }, 440 { 5, "Internal/comp" } 441 }, 442 .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM, 443 .tvn = { 444 &f50sqpixel, 445 &f60sqpixel, 446 &f50sqpixel 447 }, 448 .jpeg_int = ZR36057_ISR_GIRQ0, 449 .vsync_int = ZR36057_ISR_GIRQ1, 450 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 }, 451 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, 452 .gpcs = { -1, 1 }, 453 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 }, 454 .gws_not_connected = 0, 455 .input_mux = 0, 456 .init = &dc10plus_init, 457 }, { 458 .type = DC30, 459 .name = "DC30", 460 .i2c_decoder = "vpx3220a", 461 .addrs_decoder = vpx3220_addrs, 462 .i2c_encoder = "adv7175", 463 .addrs_encoder = adv717x_addrs, 464 .video_codec = CODEC_TYPE_ZR36050, 465 .video_vfe = CODEC_TYPE_ZR36016, 466 467 .inputs = 3, 468 .input = { 469 { 1, "Composite" }, 470 { 2, "S-Video" }, 471 { 0, "Internal/comp" } 472 }, 473 .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM, 474 .tvn = { 475 &f50sqpixel_dc10, 476 &f60sqpixel_dc10, 477 &f50sqpixel_dc10 478 }, 479 .jpeg_int = 0, 480 .vsync_int = ZR36057_ISR_GIRQ1, 481 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 }, 482 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 }, 483 .gpcs = { -1, 0 }, 484 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, 485 .gws_not_connected = 0, 486 .input_mux = 0, 487 .init = &dc10_init, 488 }, { 489 .type = DC30plus, 490 .name = "DC30plus", 491 .i2c_decoder = "vpx3220a", 492 .addrs_decoder = vpx3220_addrs, 493 .i2c_encoder = "adv7175", 494 .addrs_encoder = adv717x_addrs, 495 .video_codec = CODEC_TYPE_ZR36050, 496 .video_vfe = CODEC_TYPE_ZR36016, 497 498 .inputs = 3, 499 .input = { 500 { 1, "Composite" }, 501 { 2, "S-Video" }, 502 { 0, "Internal/comp" } 503 }, 504 .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM, 505 .tvn = { 506 &f50sqpixel_dc10, 507 &f60sqpixel_dc10, 508 &f50sqpixel_dc10 509 }, 510 .jpeg_int = 0, 511 .vsync_int = ZR36057_ISR_GIRQ1, 512 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 }, 513 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 }, 514 .gpcs = { -1, 0 }, 515 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, 516 .gws_not_connected = 0, 517 .input_mux = 0, 518 .init = &dc10_init, 519 }, { 520 .type = LML33, 521 .name = "LML33", 522 .i2c_decoder = "bt819a", 523 .addrs_decoder = bt819_addrs, 524 .i2c_encoder = "bt856", 525 .addrs_encoder = bt856_addrs, 526 .video_codec = CODEC_TYPE_ZR36060, 527 528 .inputs = 2, 529 .input = { 530 { 0, "Composite" }, 531 { 7, "S-Video" } 532 }, 533 .norms = V4L2_STD_NTSC|V4L2_STD_PAL, 534 .tvn = { 535 &f50ccir601_lml33, 536 &f60ccir601_lml33, 537 NULL 538 }, 539 .jpeg_int = ZR36057_ISR_GIRQ1, 540 .vsync_int = ZR36057_ISR_GIRQ0, 541 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 }, 542 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 }, 543 .gpcs = { 3, 1 }, 544 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 }, 545 .gws_not_connected = 1, 546 .input_mux = 0, 547 .init = &lml33_init, 548 }, { 549 .type = LML33R10, 550 .name = "LML33R10", 551 .i2c_decoder = "saa7114", 552 .addrs_decoder = saa7114_addrs, 553 .i2c_encoder = "adv7170", 554 .addrs_encoder = adv717x_addrs, 555 .video_codec = CODEC_TYPE_ZR36060, 556 557 .inputs = 2, 558 .input = { 559 { 0, "Composite" }, 560 { 7, "S-Video" } 561 }, 562 .norms = V4L2_STD_NTSC|V4L2_STD_PAL, 563 .tvn = { 564 &f50ccir601_lm33r10, 565 &f60ccir601_lm33r10, 566 NULL 567 }, 568 .jpeg_int = ZR36057_ISR_GIRQ1, 569 .vsync_int = ZR36057_ISR_GIRQ0, 570 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 }, 571 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 }, 572 .gpcs = { 3, 1 }, 573 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 }, 574 .gws_not_connected = 1, 575 .input_mux = 0, 576 .init = &lml33_init, 577 }, { 578 .type = BUZ, 579 .name = "Buz", 580 .i2c_decoder = "saa7111", 581 .addrs_decoder = saa7111_addrs, 582 .i2c_encoder = "saa7185", 583 .addrs_encoder = saa7185_addrs, 584 .video_codec = CODEC_TYPE_ZR36060, 585 586 .inputs = 2, 587 .input = { 588 { 3, "Composite" }, 589 { 7, "S-Video" } 590 }, 591 .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM, 592 .tvn = { 593 &f50ccir601, 594 &f60ccir601, 595 &f50ccir601 596 }, 597 .jpeg_int = ZR36057_ISR_GIRQ1, 598 .vsync_int = ZR36057_ISR_GIRQ0, 599 .gpio = { 1, -1, 3, -1, -1, -1, -1, -1 }, 600 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, 601 .gpcs = { 3, 1 }, 602 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 }, 603 .gws_not_connected = 1, 604 .input_mux = 0, 605 .init = &buz_init, 606 }, { 607 .type = AVS6EYES, 608 .name = "6-Eyes", 609 /* AverMedia chose not to brand the 6-Eyes. Thus it 610 can't be autodetected, and requires card=x. */ 611 .i2c_decoder = "ks0127", 612 .addrs_decoder = ks0127_addrs, 613 .i2c_encoder = "bt866", 614 .addrs_encoder = bt866_addrs, 615 .video_codec = CODEC_TYPE_ZR36060, 616 617 .inputs = 10, 618 .input = { 619 { 0, "Composite 1" }, 620 { 1, "Composite 2" }, 621 { 2, "Composite 3" }, 622 { 4, "Composite 4" }, 623 { 5, "Composite 5" }, 624 { 6, "Composite 6" }, 625 { 8, "S-Video 1" }, 626 { 9, "S-Video 2" }, 627 {10, "S-Video 3" }, 628 {15, "YCbCr" } 629 }, 630 .norms = V4L2_STD_NTSC|V4L2_STD_PAL, 631 .tvn = { 632 &f50ccir601_avs6eyes, 633 &f60ccir601_avs6eyes, 634 NULL 635 }, 636 .jpeg_int = ZR36057_ISR_GIRQ1, 637 .vsync_int = ZR36057_ISR_GIRQ0, 638 .gpio = { 1, 0, 3, -1, -1, -1, -1, -1 },// Validity unknown /Sam 639 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, // Validity unknown /Sam 640 .gpcs = { 3, 1 }, // Validity unknown /Sam 641 .vfe_pol = { 1, 0, 0, 0, 0, 1, 0, 0 }, // Validity unknown /Sam 642 .gws_not_connected = 1, 643 .input_mux = 1, 644 .init = &avs6eyes_init, 645 } 646 647 }; 648 649 /* 650 * I2C functions 651 */ 652 /* software I2C functions */ 653 static int 654 zoran_i2c_getsda (void *data) 655 { 656 struct zoran *zr = (struct zoran *) data; 657 658 return (btread(ZR36057_I2CBR) >> 1) & 1; 659 } 660 661 static int 662 zoran_i2c_getscl (void *data) 663 { 664 struct zoran *zr = (struct zoran *) data; 665 666 return btread(ZR36057_I2CBR) & 1; 667 } 668 669 static void 670 zoran_i2c_setsda (void *data, 671 int state) 672 { 673 struct zoran *zr = (struct zoran *) data; 674 675 if (state) 676 zr->i2cbr |= 2; 677 else 678 zr->i2cbr &= ~2; 679 btwrite(zr->i2cbr, ZR36057_I2CBR); 680 } 681 682 static void 683 zoran_i2c_setscl (void *data, 684 int state) 685 { 686 struct zoran *zr = (struct zoran *) data; 687 688 if (state) 689 zr->i2cbr |= 1; 690 else 691 zr->i2cbr &= ~1; 692 btwrite(zr->i2cbr, ZR36057_I2CBR); 693 } 694 695 static const struct i2c_algo_bit_data zoran_i2c_bit_data_template = { 696 .setsda = zoran_i2c_setsda, 697 .setscl = zoran_i2c_setscl, 698 .getsda = zoran_i2c_getsda, 699 .getscl = zoran_i2c_getscl, 700 .udelay = 10, 701 .timeout = 100, 702 }; 703 704 static int 705 zoran_register_i2c (struct zoran *zr) 706 { 707 zr->i2c_algo = zoran_i2c_bit_data_template; 708 zr->i2c_algo.data = zr; 709 strlcpy(zr->i2c_adapter.name, ZR_DEVNAME(zr), 710 sizeof(zr->i2c_adapter.name)); 711 i2c_set_adapdata(&zr->i2c_adapter, &zr->v4l2_dev); 712 zr->i2c_adapter.algo_data = &zr->i2c_algo; 713 zr->i2c_adapter.dev.parent = &zr->pci_dev->dev; 714 return i2c_bit_add_bus(&zr->i2c_adapter); 715 } 716 717 static void 718 zoran_unregister_i2c (struct zoran *zr) 719 { 720 i2c_del_adapter(&zr->i2c_adapter); 721 } 722 723 /* Check a zoran_params struct for correctness, insert default params */ 724 725 int 726 zoran_check_jpg_settings (struct zoran *zr, 727 struct zoran_jpg_settings *settings, 728 int try) 729 { 730 int err = 0, err0 = 0; 731 732 dprintk(4, 733 KERN_DEBUG 734 "%s: %s - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n", 735 ZR_DEVNAME(zr), __func__, settings->decimation, settings->HorDcm, 736 settings->VerDcm, settings->TmpDcm); 737 dprintk(4, 738 KERN_DEBUG 739 "%s: %s - x: %d, y: %d, w: %d, y: %d\n", 740 ZR_DEVNAME(zr), __func__, settings->img_x, settings->img_y, 741 settings->img_width, settings->img_height); 742 /* Check decimation, set default values for decimation = 1, 2, 4 */ 743 switch (settings->decimation) { 744 case 1: 745 746 settings->HorDcm = 1; 747 settings->VerDcm = 1; 748 settings->TmpDcm = 1; 749 settings->field_per_buff = 2; 750 settings->img_x = 0; 751 settings->img_y = 0; 752 settings->img_width = BUZ_MAX_WIDTH; 753 settings->img_height = BUZ_MAX_HEIGHT / 2; 754 break; 755 case 2: 756 757 settings->HorDcm = 2; 758 settings->VerDcm = 1; 759 settings->TmpDcm = 2; 760 settings->field_per_buff = 1; 761 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0; 762 settings->img_y = 0; 763 settings->img_width = 764 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH; 765 settings->img_height = BUZ_MAX_HEIGHT / 2; 766 break; 767 case 4: 768 769 if (zr->card.type == DC10_new) { 770 dprintk(1, 771 KERN_DEBUG 772 "%s: %s - HDec by 4 is not supported on the DC10\n", 773 ZR_DEVNAME(zr), __func__); 774 err0++; 775 break; 776 } 777 778 settings->HorDcm = 4; 779 settings->VerDcm = 2; 780 settings->TmpDcm = 2; 781 settings->field_per_buff = 1; 782 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0; 783 settings->img_y = 0; 784 settings->img_width = 785 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH; 786 settings->img_height = BUZ_MAX_HEIGHT / 2; 787 break; 788 case 0: 789 790 /* We have to check the data the user has set */ 791 792 if (settings->HorDcm != 1 && settings->HorDcm != 2 && 793 (zr->card.type == DC10_new || settings->HorDcm != 4)) { 794 settings->HorDcm = clamp(settings->HorDcm, 1, 2); 795 err0++; 796 } 797 if (settings->VerDcm != 1 && settings->VerDcm != 2) { 798 settings->VerDcm = clamp(settings->VerDcm, 1, 2); 799 err0++; 800 } 801 if (settings->TmpDcm != 1 && settings->TmpDcm != 2) { 802 settings->TmpDcm = clamp(settings->TmpDcm, 1, 2); 803 err0++; 804 } 805 if (settings->field_per_buff != 1 && 806 settings->field_per_buff != 2) { 807 settings->field_per_buff = clamp(settings->field_per_buff, 1, 2); 808 err0++; 809 } 810 if (settings->img_x < 0) { 811 settings->img_x = 0; 812 err0++; 813 } 814 if (settings->img_y < 0) { 815 settings->img_y = 0; 816 err0++; 817 } 818 if (settings->img_width < 0 || settings->img_width > BUZ_MAX_WIDTH) { 819 settings->img_width = clamp(settings->img_width, 0, (int)BUZ_MAX_WIDTH); 820 err0++; 821 } 822 if (settings->img_height < 0 || settings->img_height > BUZ_MAX_HEIGHT / 2) { 823 settings->img_height = clamp(settings->img_height, 0, BUZ_MAX_HEIGHT / 2); 824 err0++; 825 } 826 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH) { 827 settings->img_x = BUZ_MAX_WIDTH - settings->img_width; 828 err0++; 829 } 830 if (settings->img_y + settings->img_height > BUZ_MAX_HEIGHT / 2) { 831 settings->img_y = BUZ_MAX_HEIGHT / 2 - settings->img_height; 832 err0++; 833 } 834 if (settings->img_width % (16 * settings->HorDcm) != 0) { 835 settings->img_width -= settings->img_width % (16 * settings->HorDcm); 836 if (settings->img_width == 0) 837 settings->img_width = 16 * settings->HorDcm; 838 err0++; 839 } 840 if (settings->img_height % (8 * settings->VerDcm) != 0) { 841 settings->img_height -= settings->img_height % (8 * settings->VerDcm); 842 if (settings->img_height == 0) 843 settings->img_height = 8 * settings->VerDcm; 844 err0++; 845 } 846 847 if (!try && err0) { 848 dprintk(1, 849 KERN_ERR 850 "%s: %s - error in params for decimation = 0\n", 851 ZR_DEVNAME(zr), __func__); 852 err++; 853 } 854 break; 855 default: 856 dprintk(1, 857 KERN_ERR 858 "%s: %s - decimation = %d, must be 0, 1, 2 or 4\n", 859 ZR_DEVNAME(zr), __func__, settings->decimation); 860 err++; 861 break; 862 } 863 864 if (settings->jpg_comp.quality > 100) 865 settings->jpg_comp.quality = 100; 866 if (settings->jpg_comp.quality < 5) 867 settings->jpg_comp.quality = 5; 868 if (settings->jpg_comp.APPn < 0) 869 settings->jpg_comp.APPn = 0; 870 if (settings->jpg_comp.APPn > 15) 871 settings->jpg_comp.APPn = 15; 872 if (settings->jpg_comp.APP_len < 0) 873 settings->jpg_comp.APP_len = 0; 874 if (settings->jpg_comp.APP_len > 60) 875 settings->jpg_comp.APP_len = 60; 876 if (settings->jpg_comp.COM_len < 0) 877 settings->jpg_comp.COM_len = 0; 878 if (settings->jpg_comp.COM_len > 60) 879 settings->jpg_comp.COM_len = 60; 880 if (err) 881 return -EINVAL; 882 return 0; 883 } 884 885 void 886 zoran_open_init_params (struct zoran *zr) 887 { 888 int i; 889 890 /* User must explicitly set a window */ 891 zr->overlay_settings.is_set = 0; 892 zr->overlay_mask = NULL; 893 zr->overlay_active = ZORAN_FREE; 894 895 zr->v4l_memgrab_active = 0; 896 zr->v4l_overlay_active = 0; 897 zr->v4l_grab_frame = NO_GRAB_ACTIVE; 898 zr->v4l_grab_seq = 0; 899 zr->v4l_settings.width = 192; 900 zr->v4l_settings.height = 144; 901 zr->v4l_settings.format = &zoran_formats[7]; /* YUY2 - YUV-4:2:2 packed */ 902 zr->v4l_settings.bytesperline = 903 zr->v4l_settings.width * 904 ((zr->v4l_settings.format->depth + 7) / 8); 905 906 /* DMA ring stuff for V4L */ 907 zr->v4l_pend_tail = 0; 908 zr->v4l_pend_head = 0; 909 zr->v4l_sync_tail = 0; 910 zr->v4l_buffers.active = ZORAN_FREE; 911 for (i = 0; i < VIDEO_MAX_FRAME; i++) { 912 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */ 913 } 914 zr->v4l_buffers.allocated = 0; 915 916 for (i = 0; i < BUZ_MAX_FRAME; i++) { 917 zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */ 918 } 919 zr->jpg_buffers.active = ZORAN_FREE; 920 zr->jpg_buffers.allocated = 0; 921 /* Set necessary params and call zoran_check_jpg_settings to set the defaults */ 922 zr->jpg_settings.decimation = 1; 923 zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */ 924 if (zr->card.type != BUZ) 925 zr->jpg_settings.odd_even = 1; 926 else 927 zr->jpg_settings.odd_even = 0; 928 zr->jpg_settings.jpg_comp.APPn = 0; 929 zr->jpg_settings.jpg_comp.APP_len = 0; /* No APPn marker */ 930 memset(zr->jpg_settings.jpg_comp.APP_data, 0, 931 sizeof(zr->jpg_settings.jpg_comp.APP_data)); 932 zr->jpg_settings.jpg_comp.COM_len = 0; /* No COM marker */ 933 memset(zr->jpg_settings.jpg_comp.COM_data, 0, 934 sizeof(zr->jpg_settings.jpg_comp.COM_data)); 935 zr->jpg_settings.jpg_comp.jpeg_markers = 936 V4L2_JPEG_MARKER_DHT | V4L2_JPEG_MARKER_DQT; 937 i = zoran_check_jpg_settings(zr, &zr->jpg_settings, 0); 938 if (i) 939 dprintk(1, KERN_ERR "%s: %s internal error\n", 940 ZR_DEVNAME(zr), __func__); 941 942 clear_interrupt_counters(zr); 943 zr->testing = 0; 944 } 945 946 static void test_interrupts (struct zoran *zr) 947 { 948 DEFINE_WAIT(wait); 949 int timeout, icr; 950 951 clear_interrupt_counters(zr); 952 953 zr->testing = 1; 954 icr = btread(ZR36057_ICR); 955 btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR); 956 prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE); 957 timeout = schedule_timeout(HZ); 958 finish_wait(&zr->test_q, &wait); 959 btwrite(0, ZR36057_ICR); 960 btwrite(0x78000000, ZR36057_ISR); 961 zr->testing = 0; 962 dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr)); 963 if (timeout) { 964 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout); 965 } 966 if (zr36067_debug > 1) 967 print_interrupts(zr); 968 btwrite(icr, ZR36057_ICR); 969 } 970 971 static int zr36057_init (struct zoran *zr) 972 { 973 int j, err; 974 975 dprintk(1, 976 KERN_INFO 977 "%s: %s - initializing card[%d], zr=%p\n", 978 ZR_DEVNAME(zr), __func__, zr->id, zr); 979 980 /* default setup of all parameters which will persist between opens */ 981 zr->user = 0; 982 983 init_waitqueue_head(&zr->v4l_capq); 984 init_waitqueue_head(&zr->jpg_capq); 985 init_waitqueue_head(&zr->test_q); 986 zr->jpg_buffers.allocated = 0; 987 zr->v4l_buffers.allocated = 0; 988 989 zr->vbuf_base = (void *) vidmem; 990 zr->vbuf_width = 0; 991 zr->vbuf_height = 0; 992 zr->vbuf_depth = 0; 993 zr->vbuf_bytesperline = 0; 994 995 /* Avoid nonsense settings from user for default input/norm */ 996 if (default_norm < 0 || default_norm > 2) 997 default_norm = 0; 998 if (default_norm == 0) { 999 zr->norm = V4L2_STD_PAL; 1000 zr->timing = zr->card.tvn[0]; 1001 } else if (default_norm == 1) { 1002 zr->norm = V4L2_STD_NTSC; 1003 zr->timing = zr->card.tvn[1]; 1004 } else { 1005 zr->norm = V4L2_STD_SECAM; 1006 zr->timing = zr->card.tvn[2]; 1007 } 1008 if (zr->timing == NULL) { 1009 dprintk(1, 1010 KERN_WARNING 1011 "%s: %s - default TV standard not supported by hardware. PAL will be used.\n", 1012 ZR_DEVNAME(zr), __func__); 1013 zr->norm = V4L2_STD_PAL; 1014 zr->timing = zr->card.tvn[0]; 1015 } 1016 1017 if (default_input > zr->card.inputs-1) { 1018 dprintk(1, 1019 KERN_WARNING 1020 "%s: default_input value %d out of range (0-%d)\n", 1021 ZR_DEVNAME(zr), default_input, zr->card.inputs-1); 1022 default_input = 0; 1023 } 1024 zr->input = default_input; 1025 1026 /* default setup (will be repeated at every open) */ 1027 zoran_open_init_params(zr); 1028 1029 /* allocate memory *before* doing anything to the hardware 1030 * in case allocation fails */ 1031 zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL); 1032 zr->video_dev = video_device_alloc(); 1033 if (!zr->stat_com || !zr->video_dev) { 1034 dprintk(1, 1035 KERN_ERR 1036 "%s: %s - kmalloc (STAT_COM) failed\n", 1037 ZR_DEVNAME(zr), __func__); 1038 err = -ENOMEM; 1039 goto exit_free; 1040 } 1041 for (j = 0; j < BUZ_NUM_STAT_COM; j++) { 1042 zr->stat_com[j] = cpu_to_le32(1); /* mark as unavailable to zr36057 */ 1043 } 1044 1045 /* 1046 * Now add the template and register the device unit. 1047 */ 1048 *zr->video_dev = zoran_template; 1049 zr->video_dev->v4l2_dev = &zr->v4l2_dev; 1050 zr->video_dev->lock = &zr->lock; 1051 strcpy(zr->video_dev->name, ZR_DEVNAME(zr)); 1052 /* It's not a mem2mem device, but you can both capture and output from 1053 one and the same device. This should really be split up into two 1054 device nodes, but that's a job for another day. */ 1055 zr->video_dev->vfl_dir = VFL_DIR_M2M; 1056 err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr[zr->id]); 1057 if (err < 0) 1058 goto exit_free; 1059 video_set_drvdata(zr->video_dev, zr); 1060 1061 zoran_init_hardware(zr); 1062 if (zr36067_debug > 2) 1063 detect_guest_activity(zr); 1064 test_interrupts(zr); 1065 if (!pass_through) { 1066 decoder_call(zr, video, s_stream, 0); 1067 encoder_call(zr, video, s_routing, 2, 0, 0); 1068 } 1069 1070 zr->zoran_proc = NULL; 1071 zr->initialized = 1; 1072 return 0; 1073 1074 exit_free: 1075 kfree(zr->stat_com); 1076 kfree(zr->video_dev); 1077 return err; 1078 } 1079 1080 static void zoran_remove(struct pci_dev *pdev) 1081 { 1082 struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev); 1083 struct zoran *zr = to_zoran(v4l2_dev); 1084 1085 if (!zr->initialized) 1086 goto exit_free; 1087 1088 /* unregister videocodec bus */ 1089 if (zr->codec) { 1090 struct videocodec_master *master = zr->codec->master_data; 1091 1092 videocodec_detach(zr->codec); 1093 kfree(master); 1094 } 1095 if (zr->vfe) { 1096 struct videocodec_master *master = zr->vfe->master_data; 1097 1098 videocodec_detach(zr->vfe); 1099 kfree(master); 1100 } 1101 1102 /* unregister i2c bus */ 1103 zoran_unregister_i2c(zr); 1104 /* disable PCI bus-mastering */ 1105 zoran_set_pci_master(zr, 0); 1106 /* put chip into reset */ 1107 btwrite(0, ZR36057_SPGPPCR); 1108 free_irq(zr->pci_dev->irq, zr); 1109 /* unmap and free memory */ 1110 kfree(zr->stat_com); 1111 zoran_proc_cleanup(zr); 1112 iounmap(zr->zr36057_mem); 1113 pci_disable_device(zr->pci_dev); 1114 video_unregister_device(zr->video_dev); 1115 exit_free: 1116 v4l2_ctrl_handler_free(&zr->hdl); 1117 v4l2_device_unregister(&zr->v4l2_dev); 1118 kfree(zr); 1119 } 1120 1121 void 1122 zoran_vdev_release (struct video_device *vdev) 1123 { 1124 kfree(vdev); 1125 } 1126 1127 static struct videocodec_master *zoran_setup_videocodec(struct zoran *zr, 1128 int type) 1129 { 1130 struct videocodec_master *m = NULL; 1131 1132 m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL); 1133 if (!m) { 1134 dprintk(1, KERN_ERR "%s: %s - no memory\n", 1135 ZR_DEVNAME(zr), __func__); 1136 return m; 1137 } 1138 1139 /* magic and type are unused for master struct. Makes sense only at 1140 codec structs. 1141 In the past, .type were initialized to the old V4L1 .hardware 1142 value, as VID_HARDWARE_ZR36067 1143 */ 1144 m->magic = 0L; 1145 m->type = 0; 1146 1147 m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER; 1148 strlcpy(m->name, ZR_DEVNAME(zr), sizeof(m->name)); 1149 m->data = zr; 1150 1151 switch (type) 1152 { 1153 case CODEC_TYPE_ZR36060: 1154 m->readreg = zr36060_read; 1155 m->writereg = zr36060_write; 1156 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE; 1157 break; 1158 case CODEC_TYPE_ZR36050: 1159 m->readreg = zr36050_read; 1160 m->writereg = zr36050_write; 1161 m->flags |= CODEC_FLAG_JPEG; 1162 break; 1163 case CODEC_TYPE_ZR36016: 1164 m->readreg = zr36016_read; 1165 m->writereg = zr36016_write; 1166 m->flags |= CODEC_FLAG_VFE; 1167 break; 1168 } 1169 1170 return m; 1171 } 1172 1173 static void zoran_subdev_notify(struct v4l2_subdev *sd, unsigned int cmd, void *arg) 1174 { 1175 struct zoran *zr = to_zoran(sd->v4l2_dev); 1176 1177 /* Bt819 needs to reset its FIFO buffer using #FRST pin and 1178 LML33 card uses GPIO(7) for that. */ 1179 if (cmd == BT819_FIFO_RESET_LOW) 1180 GPIO(zr, 7, 0); 1181 else if (cmd == BT819_FIFO_RESET_HIGH) 1182 GPIO(zr, 7, 1); 1183 } 1184 1185 /* 1186 * Scan for a Buz card (actually for the PCI controller ZR36057), 1187 * request the irq and map the io memory 1188 */ 1189 static int zoran_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 1190 { 1191 unsigned char latency, need_latency; 1192 struct zoran *zr; 1193 int result; 1194 struct videocodec_master *master_vfe = NULL; 1195 struct videocodec_master *master_codec = NULL; 1196 int card_num; 1197 char *codec_name, *vfe_name; 1198 unsigned int nr; 1199 1200 1201 nr = zoran_num++; 1202 if (nr >= BUZ_MAX) { 1203 dprintk(1, KERN_ERR "%s: driver limited to %d card(s) maximum\n", 1204 ZORAN_NAME, BUZ_MAX); 1205 return -ENOENT; 1206 } 1207 1208 zr = kzalloc(sizeof(struct zoran), GFP_KERNEL); 1209 if (!zr) { 1210 dprintk(1, KERN_ERR "%s: %s - kzalloc failed\n", 1211 ZORAN_NAME, __func__); 1212 return -ENOMEM; 1213 } 1214 zr->v4l2_dev.notify = zoran_subdev_notify; 1215 if (v4l2_device_register(&pdev->dev, &zr->v4l2_dev)) 1216 goto zr_free_mem; 1217 zr->pci_dev = pdev; 1218 zr->id = nr; 1219 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id); 1220 if (v4l2_ctrl_handler_init(&zr->hdl, 10)) 1221 goto zr_unreg; 1222 zr->v4l2_dev.ctrl_handler = &zr->hdl; 1223 spin_lock_init(&zr->spinlock); 1224 mutex_init(&zr->lock); 1225 if (pci_enable_device(pdev)) 1226 goto zr_unreg; 1227 zr->revision = zr->pci_dev->revision; 1228 1229 dprintk(1, 1230 KERN_INFO 1231 "%s: Zoran ZR360%c7 (rev %d), irq: %d, memory: 0x%08llx\n", 1232 ZR_DEVNAME(zr), zr->revision < 2 ? '5' : '6', zr->revision, 1233 zr->pci_dev->irq, (uint64_t)pci_resource_start(zr->pci_dev, 0)); 1234 if (zr->revision >= 2) { 1235 dprintk(1, 1236 KERN_INFO 1237 "%s: Subsystem vendor=0x%04x id=0x%04x\n", 1238 ZR_DEVNAME(zr), zr->pci_dev->subsystem_vendor, 1239 zr->pci_dev->subsystem_device); 1240 } 1241 1242 /* Use auto-detected card type? */ 1243 if (card[nr] == -1) { 1244 if (zr->revision < 2) { 1245 dprintk(1, 1246 KERN_ERR 1247 "%s: No card type specified, please use the card=X module parameter\n", 1248 ZR_DEVNAME(zr)); 1249 dprintk(1, 1250 KERN_ERR 1251 "%s: It is not possible to auto-detect ZR36057 based cards\n", 1252 ZR_DEVNAME(zr)); 1253 goto zr_unreg; 1254 } 1255 1256 card_num = ent->driver_data; 1257 if (card_num >= NUM_CARDS) { 1258 dprintk(1, 1259 KERN_ERR 1260 "%s: Unknown card, try specifying card=X module parameter\n", 1261 ZR_DEVNAME(zr)); 1262 goto zr_unreg; 1263 } 1264 dprintk(3, 1265 KERN_DEBUG 1266 "%s: %s() - card %s detected\n", 1267 ZR_DEVNAME(zr), __func__, zoran_cards[card_num].name); 1268 } else { 1269 card_num = card[nr]; 1270 if (card_num >= NUM_CARDS || card_num < 0) { 1271 dprintk(1, 1272 KERN_ERR 1273 "%s: User specified card type %d out of range (0 .. %d)\n", 1274 ZR_DEVNAME(zr), card_num, NUM_CARDS - 1); 1275 goto zr_unreg; 1276 } 1277 } 1278 1279 /* even though we make this a non pointer and thus 1280 * theoretically allow for making changes to this struct 1281 * on a per-individual card basis at runtime, this is 1282 * strongly discouraged. This structure is intended to 1283 * keep general card information, no settings or anything */ 1284 zr->card = zoran_cards[card_num]; 1285 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), 1286 "%s[%u]", zr->card.name, zr->id); 1287 1288 zr->zr36057_mem = pci_ioremap_bar(zr->pci_dev, 0); 1289 if (!zr->zr36057_mem) { 1290 dprintk(1, KERN_ERR "%s: %s() - ioremap failed\n", 1291 ZR_DEVNAME(zr), __func__); 1292 goto zr_unreg; 1293 } 1294 1295 result = request_irq(zr->pci_dev->irq, zoran_irq, 1296 IRQF_SHARED, ZR_DEVNAME(zr), zr); 1297 if (result < 0) { 1298 if (result == -EINVAL) { 1299 dprintk(1, 1300 KERN_ERR 1301 "%s: %s - bad irq number or handler\n", 1302 ZR_DEVNAME(zr), __func__); 1303 } else if (result == -EBUSY) { 1304 dprintk(1, 1305 KERN_ERR 1306 "%s: %s - IRQ %d busy, change your PnP config in BIOS\n", 1307 ZR_DEVNAME(zr), __func__, zr->pci_dev->irq); 1308 } else { 1309 dprintk(1, 1310 KERN_ERR 1311 "%s: %s - can't assign irq, error code %d\n", 1312 ZR_DEVNAME(zr), __func__, result); 1313 } 1314 goto zr_unmap; 1315 } 1316 1317 /* set PCI latency timer */ 1318 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER, 1319 &latency); 1320 need_latency = zr->revision > 1 ? 32 : 48; 1321 if (latency != need_latency) { 1322 dprintk(2, KERN_INFO "%s: Changing PCI latency from %d to %d\n", 1323 ZR_DEVNAME(zr), latency, need_latency); 1324 pci_write_config_byte(zr->pci_dev, PCI_LATENCY_TIMER, 1325 need_latency); 1326 } 1327 1328 zr36057_restart(zr); 1329 /* i2c */ 1330 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n", 1331 ZR_DEVNAME(zr)); 1332 1333 if (zoran_register_i2c(zr) < 0) { 1334 dprintk(1, KERN_ERR "%s: %s - can't initialize i2c bus\n", 1335 ZR_DEVNAME(zr), __func__); 1336 goto zr_free_irq; 1337 } 1338 1339 zr->decoder = v4l2_i2c_new_subdev(&zr->v4l2_dev, 1340 &zr->i2c_adapter, zr->card.i2c_decoder, 1341 0, zr->card.addrs_decoder); 1342 1343 if (zr->card.i2c_encoder) 1344 zr->encoder = v4l2_i2c_new_subdev(&zr->v4l2_dev, 1345 &zr->i2c_adapter, zr->card.i2c_encoder, 1346 0, zr->card.addrs_encoder); 1347 1348 dprintk(2, 1349 KERN_INFO "%s: Initializing videocodec bus...\n", 1350 ZR_DEVNAME(zr)); 1351 1352 if (zr->card.video_codec) { 1353 codec_name = codecid_to_modulename(zr->card.video_codec); 1354 if (codec_name) { 1355 result = request_module(codec_name); 1356 if (result) { 1357 dprintk(1, 1358 KERN_ERR 1359 "%s: failed to load modules %s: %d\n", 1360 ZR_DEVNAME(zr), codec_name, result); 1361 } 1362 } 1363 } 1364 if (zr->card.video_vfe) { 1365 vfe_name = codecid_to_modulename(zr->card.video_vfe); 1366 if (vfe_name) { 1367 result = request_module(vfe_name); 1368 if (result < 0) { 1369 dprintk(1, 1370 KERN_ERR 1371 "%s: failed to load modules %s: %d\n", 1372 ZR_DEVNAME(zr), vfe_name, result); 1373 } 1374 } 1375 } 1376 1377 /* reset JPEG codec */ 1378 jpeg_codec_sleep(zr, 1); 1379 jpeg_codec_reset(zr); 1380 /* video bus enabled */ 1381 /* display codec revision */ 1382 if (zr->card.video_codec != 0) { 1383 master_codec = zoran_setup_videocodec(zr, zr->card.video_codec); 1384 if (!master_codec) 1385 goto zr_unreg_i2c; 1386 zr->codec = videocodec_attach(master_codec); 1387 if (!zr->codec) { 1388 dprintk(1, KERN_ERR "%s: %s - no codec found\n", 1389 ZR_DEVNAME(zr), __func__); 1390 goto zr_free_codec; 1391 } 1392 if (zr->codec->type != zr->card.video_codec) { 1393 dprintk(1, KERN_ERR "%s: %s - wrong codec\n", 1394 ZR_DEVNAME(zr), __func__); 1395 goto zr_detach_codec; 1396 } 1397 } 1398 if (zr->card.video_vfe != 0) { 1399 master_vfe = zoran_setup_videocodec(zr, zr->card.video_vfe); 1400 if (!master_vfe) 1401 goto zr_detach_codec; 1402 zr->vfe = videocodec_attach(master_vfe); 1403 if (!zr->vfe) { 1404 dprintk(1, KERN_ERR "%s: %s - no VFE found\n", 1405 ZR_DEVNAME(zr), __func__); 1406 goto zr_free_vfe; 1407 } 1408 if (zr->vfe->type != zr->card.video_vfe) { 1409 dprintk(1, KERN_ERR "%s: %s = wrong VFE\n", 1410 ZR_DEVNAME(zr), __func__); 1411 goto zr_detach_vfe; 1412 } 1413 } 1414 1415 /* take care of Natoma chipset and a revision 1 zr36057 */ 1416 if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) { 1417 zr->jpg_buffers.need_contiguous = 1; 1418 dprintk(1, KERN_INFO 1419 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n", 1420 ZR_DEVNAME(zr)); 1421 } 1422 1423 if (zr36057_init(zr) < 0) 1424 goto zr_detach_vfe; 1425 1426 zoran_proc_init(zr); 1427 1428 return 0; 1429 1430 zr_detach_vfe: 1431 videocodec_detach(zr->vfe); 1432 zr_free_vfe: 1433 kfree(master_vfe); 1434 zr_detach_codec: 1435 videocodec_detach(zr->codec); 1436 zr_free_codec: 1437 kfree(master_codec); 1438 zr_unreg_i2c: 1439 zoran_unregister_i2c(zr); 1440 zr_free_irq: 1441 btwrite(0, ZR36057_SPGPPCR); 1442 free_irq(zr->pci_dev->irq, zr); 1443 zr_unmap: 1444 iounmap(zr->zr36057_mem); 1445 zr_unreg: 1446 v4l2_ctrl_handler_free(&zr->hdl); 1447 v4l2_device_unregister(&zr->v4l2_dev); 1448 zr_free_mem: 1449 kfree(zr); 1450 1451 return -ENODEV; 1452 } 1453 1454 static struct pci_driver zoran_driver = { 1455 .name = "zr36067", 1456 .id_table = zr36067_pci_tbl, 1457 .probe = zoran_probe, 1458 .remove = zoran_remove, 1459 }; 1460 1461 static int __init zoran_init(void) 1462 { 1463 int res; 1464 1465 printk(KERN_INFO "Zoran MJPEG board driver version %s\n", 1466 ZORAN_VERSION); 1467 1468 /* check the parameters we have been given, adjust if necessary */ 1469 if (v4l_nbufs < 2) 1470 v4l_nbufs = 2; 1471 if (v4l_nbufs > VIDEO_MAX_FRAME) 1472 v4l_nbufs = VIDEO_MAX_FRAME; 1473 /* The user specfies the in KB, we want them in byte 1474 * (and page aligned) */ 1475 v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024); 1476 if (v4l_bufsize < 32768) 1477 v4l_bufsize = 32768; 1478 /* 2 MB is arbitrary but sufficient for the maximum possible images */ 1479 if (v4l_bufsize > 2048 * 1024) 1480 v4l_bufsize = 2048 * 1024; 1481 if (jpg_nbufs < 4) 1482 jpg_nbufs = 4; 1483 if (jpg_nbufs > BUZ_MAX_FRAME) 1484 jpg_nbufs = BUZ_MAX_FRAME; 1485 jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024); 1486 if (jpg_bufsize < 8192) 1487 jpg_bufsize = 8192; 1488 if (jpg_bufsize > (512 * 1024)) 1489 jpg_bufsize = 512 * 1024; 1490 /* Use parameter for vidmem or try to find a video card */ 1491 if (vidmem) { 1492 dprintk(1, 1493 KERN_INFO 1494 "%s: Using supplied video memory base address @ 0x%lx\n", 1495 ZORAN_NAME, vidmem); 1496 } 1497 1498 /* some mainboards might not do PCI-PCI data transfer well */ 1499 if (pci_pci_problems & (PCIPCI_FAIL|PCIAGP_FAIL|PCIPCI_ALIMAGIK)) { 1500 dprintk(1, 1501 KERN_WARNING 1502 "%s: chipset does not support reliable PCI-PCI DMA\n", 1503 ZORAN_NAME); 1504 } 1505 1506 res = pci_register_driver(&zoran_driver); 1507 if (res) { 1508 dprintk(1, 1509 KERN_ERR 1510 "%s: Unable to register ZR36057 driver\n", 1511 ZORAN_NAME); 1512 return res; 1513 } 1514 1515 return 0; 1516 } 1517 1518 static void __exit zoran_exit(void) 1519 { 1520 pci_unregister_driver(&zoran_driver); 1521 } 1522 1523 module_init(zoran_init); 1524 module_exit(zoran_exit); 1525