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