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/i2c/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 *zr->video_dev = zoran_template; 1053 zr->video_dev->v4l2_dev = &zr->v4l2_dev; 1054 zr->video_dev->lock = &zr->lock; 1055 strcpy(zr->video_dev->name, ZR_DEVNAME(zr)); 1056 /* It's not a mem2mem device, but you can both capture and output from 1057 one and the same device. This should really be split up into two 1058 device nodes, but that's a job for another day. */ 1059 zr->video_dev->vfl_dir = VFL_DIR_M2M; 1060 err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr[zr->id]); 1061 if (err < 0) 1062 goto exit_free; 1063 video_set_drvdata(zr->video_dev, zr); 1064 1065 zoran_init_hardware(zr); 1066 if (zr36067_debug > 2) 1067 detect_guest_activity(zr); 1068 test_interrupts(zr); 1069 if (!pass_through) { 1070 decoder_call(zr, video, s_stream, 0); 1071 encoder_call(zr, video, s_routing, 2, 0, 0); 1072 } 1073 1074 zr->zoran_proc = NULL; 1075 zr->initialized = 1; 1076 return 0; 1077 1078 exit_free: 1079 kfree(zr->stat_com); 1080 kfree(zr->video_dev); 1081 return err; 1082 } 1083 1084 static void zoran_remove(struct pci_dev *pdev) 1085 { 1086 struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev); 1087 struct zoran *zr = to_zoran(v4l2_dev); 1088 1089 if (!zr->initialized) 1090 goto exit_free; 1091 1092 /* unregister videocodec bus */ 1093 if (zr->codec) { 1094 struct videocodec_master *master = zr->codec->master_data; 1095 1096 videocodec_detach(zr->codec); 1097 kfree(master); 1098 } 1099 if (zr->vfe) { 1100 struct videocodec_master *master = zr->vfe->master_data; 1101 1102 videocodec_detach(zr->vfe); 1103 kfree(master); 1104 } 1105 1106 /* unregister i2c bus */ 1107 zoran_unregister_i2c(zr); 1108 /* disable PCI bus-mastering */ 1109 zoran_set_pci_master(zr, 0); 1110 /* put chip into reset */ 1111 btwrite(0, ZR36057_SPGPPCR); 1112 free_irq(zr->pci_dev->irq, zr); 1113 /* unmap and free memory */ 1114 kfree(zr->stat_com); 1115 zoran_proc_cleanup(zr); 1116 iounmap(zr->zr36057_mem); 1117 pci_disable_device(zr->pci_dev); 1118 video_unregister_device(zr->video_dev); 1119 exit_free: 1120 v4l2_ctrl_handler_free(&zr->hdl); 1121 v4l2_device_unregister(&zr->v4l2_dev); 1122 kfree(zr); 1123 } 1124 1125 void 1126 zoran_vdev_release (struct video_device *vdev) 1127 { 1128 kfree(vdev); 1129 } 1130 1131 static struct videocodec_master *zoran_setup_videocodec(struct zoran *zr, 1132 int type) 1133 { 1134 struct videocodec_master *m = NULL; 1135 1136 m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL); 1137 if (!m) { 1138 dprintk(1, KERN_ERR "%s: %s - no memory\n", 1139 ZR_DEVNAME(zr), __func__); 1140 return m; 1141 } 1142 1143 /* magic and type are unused for master struct. Makes sense only at 1144 codec structs. 1145 In the past, .type were initialized to the old V4L1 .hardware 1146 value, as VID_HARDWARE_ZR36067 1147 */ 1148 m->magic = 0L; 1149 m->type = 0; 1150 1151 m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER; 1152 strlcpy(m->name, ZR_DEVNAME(zr), sizeof(m->name)); 1153 m->data = zr; 1154 1155 switch (type) 1156 { 1157 case CODEC_TYPE_ZR36060: 1158 m->readreg = zr36060_read; 1159 m->writereg = zr36060_write; 1160 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE; 1161 break; 1162 case CODEC_TYPE_ZR36050: 1163 m->readreg = zr36050_read; 1164 m->writereg = zr36050_write; 1165 m->flags |= CODEC_FLAG_JPEG; 1166 break; 1167 case CODEC_TYPE_ZR36016: 1168 m->readreg = zr36016_read; 1169 m->writereg = zr36016_write; 1170 m->flags |= CODEC_FLAG_VFE; 1171 break; 1172 } 1173 1174 return m; 1175 } 1176 1177 static void zoran_subdev_notify(struct v4l2_subdev *sd, unsigned int cmd, void *arg) 1178 { 1179 struct zoran *zr = to_zoran(sd->v4l2_dev); 1180 1181 /* Bt819 needs to reset its FIFO buffer using #FRST pin and 1182 LML33 card uses GPIO(7) for that. */ 1183 if (cmd == BT819_FIFO_RESET_LOW) 1184 GPIO(zr, 7, 0); 1185 else if (cmd == BT819_FIFO_RESET_HIGH) 1186 GPIO(zr, 7, 1); 1187 } 1188 1189 /* 1190 * Scan for a Buz card (actually for the PCI controller ZR36057), 1191 * request the irq and map the io memory 1192 */ 1193 static int zoran_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 1194 { 1195 unsigned char latency, need_latency; 1196 struct zoran *zr; 1197 int result; 1198 struct videocodec_master *master_vfe = NULL; 1199 struct videocodec_master *master_codec = NULL; 1200 int card_num; 1201 char *codec_name, *vfe_name; 1202 unsigned int nr; 1203 1204 1205 nr = zoran_num++; 1206 if (nr >= BUZ_MAX) { 1207 dprintk(1, KERN_ERR "%s: driver limited to %d card(s) maximum\n", 1208 ZORAN_NAME, BUZ_MAX); 1209 return -ENOENT; 1210 } 1211 1212 zr = kzalloc(sizeof(struct zoran), GFP_KERNEL); 1213 if (!zr) { 1214 dprintk(1, KERN_ERR "%s: %s - kzalloc failed\n", 1215 ZORAN_NAME, __func__); 1216 return -ENOMEM; 1217 } 1218 zr->v4l2_dev.notify = zoran_subdev_notify; 1219 if (v4l2_device_register(&pdev->dev, &zr->v4l2_dev)) 1220 goto zr_free_mem; 1221 zr->pci_dev = pdev; 1222 zr->id = nr; 1223 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id); 1224 if (v4l2_ctrl_handler_init(&zr->hdl, 10)) 1225 goto zr_unreg; 1226 zr->v4l2_dev.ctrl_handler = &zr->hdl; 1227 spin_lock_init(&zr->spinlock); 1228 mutex_init(&zr->lock); 1229 if (pci_enable_device(pdev)) 1230 goto zr_unreg; 1231 zr->revision = zr->pci_dev->revision; 1232 1233 dprintk(1, 1234 KERN_INFO 1235 "%s: Zoran ZR360%c7 (rev %d), irq: %d, memory: 0x%08llx\n", 1236 ZR_DEVNAME(zr), zr->revision < 2 ? '5' : '6', zr->revision, 1237 zr->pci_dev->irq, (uint64_t)pci_resource_start(zr->pci_dev, 0)); 1238 if (zr->revision >= 2) { 1239 dprintk(1, 1240 KERN_INFO 1241 "%s: Subsystem vendor=0x%04x id=0x%04x\n", 1242 ZR_DEVNAME(zr), zr->pci_dev->subsystem_vendor, 1243 zr->pci_dev->subsystem_device); 1244 } 1245 1246 /* Use auto-detected card type? */ 1247 if (card[nr] == -1) { 1248 if (zr->revision < 2) { 1249 dprintk(1, 1250 KERN_ERR 1251 "%s: No card type specified, please use the card=X module parameter\n", 1252 ZR_DEVNAME(zr)); 1253 dprintk(1, 1254 KERN_ERR 1255 "%s: It is not possible to auto-detect ZR36057 based cards\n", 1256 ZR_DEVNAME(zr)); 1257 goto zr_unreg; 1258 } 1259 1260 card_num = ent->driver_data; 1261 if (card_num >= NUM_CARDS) { 1262 dprintk(1, 1263 KERN_ERR 1264 "%s: Unknown card, try specifying card=X module parameter\n", 1265 ZR_DEVNAME(zr)); 1266 goto zr_unreg; 1267 } 1268 dprintk(3, 1269 KERN_DEBUG 1270 "%s: %s() - card %s detected\n", 1271 ZR_DEVNAME(zr), __func__, zoran_cards[card_num].name); 1272 } else { 1273 card_num = card[nr]; 1274 if (card_num >= NUM_CARDS || card_num < 0) { 1275 dprintk(1, 1276 KERN_ERR 1277 "%s: User specified card type %d out of range (0 .. %d)\n", 1278 ZR_DEVNAME(zr), card_num, NUM_CARDS - 1); 1279 goto zr_unreg; 1280 } 1281 } 1282 1283 /* even though we make this a non pointer and thus 1284 * theoretically allow for making changes to this struct 1285 * on a per-individual card basis at runtime, this is 1286 * strongly discouraged. This structure is intended to 1287 * keep general card information, no settings or anything */ 1288 zr->card = zoran_cards[card_num]; 1289 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), 1290 "%s[%u]", zr->card.name, zr->id); 1291 1292 zr->zr36057_mem = pci_ioremap_bar(zr->pci_dev, 0); 1293 if (!zr->zr36057_mem) { 1294 dprintk(1, KERN_ERR "%s: %s() - ioremap failed\n", 1295 ZR_DEVNAME(zr), __func__); 1296 goto zr_unreg; 1297 } 1298 1299 result = request_irq(zr->pci_dev->irq, zoran_irq, 1300 IRQF_SHARED, ZR_DEVNAME(zr), zr); 1301 if (result < 0) { 1302 if (result == -EINVAL) { 1303 dprintk(1, 1304 KERN_ERR 1305 "%s: %s - bad irq number or handler\n", 1306 ZR_DEVNAME(zr), __func__); 1307 } else if (result == -EBUSY) { 1308 dprintk(1, 1309 KERN_ERR 1310 "%s: %s - IRQ %d busy, change your PnP config in BIOS\n", 1311 ZR_DEVNAME(zr), __func__, zr->pci_dev->irq); 1312 } else { 1313 dprintk(1, 1314 KERN_ERR 1315 "%s: %s - can't assign irq, error code %d\n", 1316 ZR_DEVNAME(zr), __func__, result); 1317 } 1318 goto zr_unmap; 1319 } 1320 1321 /* set PCI latency timer */ 1322 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER, 1323 &latency); 1324 need_latency = zr->revision > 1 ? 32 : 48; 1325 if (latency != need_latency) { 1326 dprintk(2, KERN_INFO "%s: Changing PCI latency from %d to %d\n", 1327 ZR_DEVNAME(zr), latency, need_latency); 1328 pci_write_config_byte(zr->pci_dev, PCI_LATENCY_TIMER, 1329 need_latency); 1330 } 1331 1332 zr36057_restart(zr); 1333 /* i2c */ 1334 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n", 1335 ZR_DEVNAME(zr)); 1336 1337 if (zoran_register_i2c(zr) < 0) { 1338 dprintk(1, KERN_ERR "%s: %s - can't initialize i2c bus\n", 1339 ZR_DEVNAME(zr), __func__); 1340 goto zr_free_irq; 1341 } 1342 1343 zr->decoder = v4l2_i2c_new_subdev(&zr->v4l2_dev, 1344 &zr->i2c_adapter, zr->card.i2c_decoder, 1345 0, zr->card.addrs_decoder); 1346 1347 if (zr->card.i2c_encoder) 1348 zr->encoder = v4l2_i2c_new_subdev(&zr->v4l2_dev, 1349 &zr->i2c_adapter, zr->card.i2c_encoder, 1350 0, zr->card.addrs_encoder); 1351 1352 dprintk(2, 1353 KERN_INFO "%s: Initializing videocodec bus...\n", 1354 ZR_DEVNAME(zr)); 1355 1356 if (zr->card.video_codec) { 1357 codec_name = codecid_to_modulename(zr->card.video_codec); 1358 if (codec_name) { 1359 result = request_module(codec_name); 1360 if (result) { 1361 dprintk(1, 1362 KERN_ERR 1363 "%s: failed to load modules %s: %d\n", 1364 ZR_DEVNAME(zr), codec_name, result); 1365 } 1366 } 1367 } 1368 if (zr->card.video_vfe) { 1369 vfe_name = codecid_to_modulename(zr->card.video_vfe); 1370 if (vfe_name) { 1371 result = request_module(vfe_name); 1372 if (result < 0) { 1373 dprintk(1, 1374 KERN_ERR 1375 "%s: failed to load modules %s: %d\n", 1376 ZR_DEVNAME(zr), vfe_name, result); 1377 } 1378 } 1379 } 1380 1381 /* reset JPEG codec */ 1382 jpeg_codec_sleep(zr, 1); 1383 jpeg_codec_reset(zr); 1384 /* video bus enabled */ 1385 /* display codec revision */ 1386 if (zr->card.video_codec != 0) { 1387 master_codec = zoran_setup_videocodec(zr, zr->card.video_codec); 1388 if (!master_codec) 1389 goto zr_unreg_i2c; 1390 zr->codec = videocodec_attach(master_codec); 1391 if (!zr->codec) { 1392 dprintk(1, KERN_ERR "%s: %s - no codec found\n", 1393 ZR_DEVNAME(zr), __func__); 1394 goto zr_free_codec; 1395 } 1396 if (zr->codec->type != zr->card.video_codec) { 1397 dprintk(1, KERN_ERR "%s: %s - wrong codec\n", 1398 ZR_DEVNAME(zr), __func__); 1399 goto zr_detach_codec; 1400 } 1401 } 1402 if (zr->card.video_vfe != 0) { 1403 master_vfe = zoran_setup_videocodec(zr, zr->card.video_vfe); 1404 if (!master_vfe) 1405 goto zr_detach_codec; 1406 zr->vfe = videocodec_attach(master_vfe); 1407 if (!zr->vfe) { 1408 dprintk(1, KERN_ERR "%s: %s - no VFE found\n", 1409 ZR_DEVNAME(zr), __func__); 1410 goto zr_free_vfe; 1411 } 1412 if (zr->vfe->type != zr->card.video_vfe) { 1413 dprintk(1, KERN_ERR "%s: %s = wrong VFE\n", 1414 ZR_DEVNAME(zr), __func__); 1415 goto zr_detach_vfe; 1416 } 1417 } 1418 1419 /* take care of Natoma chipset and a revision 1 zr36057 */ 1420 if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) { 1421 zr->jpg_buffers.need_contiguous = 1; 1422 dprintk(1, KERN_INFO 1423 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n", 1424 ZR_DEVNAME(zr)); 1425 } 1426 1427 if (zr36057_init(zr) < 0) 1428 goto zr_detach_vfe; 1429 1430 zoran_proc_init(zr); 1431 1432 return 0; 1433 1434 zr_detach_vfe: 1435 videocodec_detach(zr->vfe); 1436 zr_free_vfe: 1437 kfree(master_vfe); 1438 zr_detach_codec: 1439 videocodec_detach(zr->codec); 1440 zr_free_codec: 1441 kfree(master_codec); 1442 zr_unreg_i2c: 1443 zoran_unregister_i2c(zr); 1444 zr_free_irq: 1445 btwrite(0, ZR36057_SPGPPCR); 1446 free_irq(zr->pci_dev->irq, zr); 1447 zr_unmap: 1448 iounmap(zr->zr36057_mem); 1449 zr_unreg: 1450 v4l2_ctrl_handler_free(&zr->hdl); 1451 v4l2_device_unregister(&zr->v4l2_dev); 1452 zr_free_mem: 1453 kfree(zr); 1454 1455 return -ENODEV; 1456 } 1457 1458 static struct pci_driver zoran_driver = { 1459 .name = "zr36067", 1460 .id_table = zr36067_pci_tbl, 1461 .probe = zoran_probe, 1462 .remove = zoran_remove, 1463 }; 1464 1465 static int __init zoran_init(void) 1466 { 1467 int res; 1468 1469 printk(KERN_INFO "Zoran MJPEG board driver version %s\n", 1470 ZORAN_VERSION); 1471 1472 /* check the parameters we have been given, adjust if necessary */ 1473 if (v4l_nbufs < 2) 1474 v4l_nbufs = 2; 1475 if (v4l_nbufs > VIDEO_MAX_FRAME) 1476 v4l_nbufs = VIDEO_MAX_FRAME; 1477 /* The user specfies the in KB, we want them in byte 1478 * (and page aligned) */ 1479 v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024); 1480 if (v4l_bufsize < 32768) 1481 v4l_bufsize = 32768; 1482 /* 2 MB is arbitrary but sufficient for the maximum possible images */ 1483 if (v4l_bufsize > 2048 * 1024) 1484 v4l_bufsize = 2048 * 1024; 1485 if (jpg_nbufs < 4) 1486 jpg_nbufs = 4; 1487 if (jpg_nbufs > BUZ_MAX_FRAME) 1488 jpg_nbufs = BUZ_MAX_FRAME; 1489 jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024); 1490 if (jpg_bufsize < 8192) 1491 jpg_bufsize = 8192; 1492 if (jpg_bufsize > (512 * 1024)) 1493 jpg_bufsize = 512 * 1024; 1494 /* Use parameter for vidmem or try to find a video card */ 1495 if (vidmem) { 1496 dprintk(1, 1497 KERN_INFO 1498 "%s: Using supplied video memory base address @ 0x%lx\n", 1499 ZORAN_NAME, vidmem); 1500 } 1501 1502 /* some mainboards might not do PCI-PCI data transfer well */ 1503 if (pci_pci_problems & (PCIPCI_FAIL|PCIAGP_FAIL|PCIPCI_ALIMAGIK)) { 1504 dprintk(1, 1505 KERN_WARNING 1506 "%s: chipset does not support reliable PCI-PCI DMA\n", 1507 ZORAN_NAME); 1508 } 1509 1510 res = pci_register_driver(&zoran_driver); 1511 if (res) { 1512 dprintk(1, 1513 KERN_ERR 1514 "%s: Unable to register ZR36057 driver\n", 1515 ZORAN_NAME); 1516 return res; 1517 } 1518 1519 return 0; 1520 } 1521 1522 static void __exit zoran_exit(void) 1523 { 1524 pci_unregister_driver(&zoran_driver); 1525 } 1526 1527 module_init(zoran_init); 1528 module_exit(zoran_exit); 1529