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