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