tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

V4L/DVB (3344e): Stradis Lindent


Stradis Lindent + some handwork

Signed-off-by: Jiri Slaby <jirislaby@gmail.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>

authored by Jiri Slaby and committed by Mauro Carvalho Chehab f823f679 91fb8357

+391 -416
unified split
+391 -416
drivers/media/video/stradis.c
··· 49 49 #include "saa7121.h" 50 50 #include "cs8420.h" 51 51 52 - #define DEBUG(x) /* debug driver */ 53 - #undef IDEBUG /* debug irq handler */ 54 - #undef MDEBUG /* debug memory management */ 52 + #define DEBUG(x) /* debug driver */ 53 + #undef IDEBUG /* debug irq handler */ 54 + #undef MDEBUG /* debug memory management */ 55 55 56 56 #define SAA7146_MAX 6 57 57 ··· 62 62 static int video_nr = -1; 63 63 module_param(video_nr, int, 0); 64 64 MODULE_LICENSE("GPL"); 65 - 66 65 67 66 #define nDebNormal 0x00480000 68 67 #define nDebNoInc 0x00480000 ··· 98 99 99 100 #ifdef USE_RESCUE_EEPROM_SDM275 100 101 static unsigned char rescue_eeprom[64] = { 101 - 0x00,0x01,0x04,0x13,0x26,0x0f,0x10,0x00,0x00,0x00,0x43,0x63,0x22,0x01,0x29,0x15,0x73,0x00,0x1f, 'd', 'e', 'c', 'x', 'l', 'd', 'v', 'a',0x02,0x00,0x01,0x00,0xcc,0xa4,0x63,0x09,0xe2,0x10,0x00,0x0a,0x00,0x02,0x02, 'd', 'e', 'c', 'x', 'l', 'a',0x00,0x00,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 102 + 0x00, 0x01, 0x04, 0x13, 0x26, 0x0f, 0x10, 0x00, 0x00, 0x00, 0x43, 0x63, 103 + 0x22, 0x01, 0x29, 0x15, 0x73, 0x00, 0x1f, 'd', 'e', 'c', 'x', 'l', 104 + 'd', 'v', 'a', 0x02, 0x00, 0x01, 0x00, 0xcc, 0xa4, 0x63, 0x09, 0xe2, 105 + 0x10, 0x00, 0x0a, 0x00, 0x02, 0x02, 'd', 'e', 'c', 'x', 'l', 'a', 106 + 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 107 + 0x00, 0x00, 0x00, 0x00, 102 108 }; 103 109 #endif 104 110 ··· 144 140 145 141 if (saaread(SAA7146_I2C_STATUS) & 0x3c) 146 142 I2CWipe(saa); 147 - for (i = 0; i < 1000 && 148 - (saaread(SAA7146_I2C_STATUS) & SAA7146_I2C_BUSY); i++) 143 + for (i = 0; 144 + i < 1000 && (saaread(SAA7146_I2C_STATUS) & SAA7146_I2C_BUSY); 145 + i++) 149 146 schedule(); 150 147 if (i == 1000) 151 148 I2CWipe(saa); 152 149 if (dosub) 153 150 saawrite(((addr & 0xfe) << 24) | (((addr | 1) & 0xff) << 8) | 154 - ((subaddr & 0xff) << 16) | 0xed, SAA7146_I2C_TRANSFER); 151 + ((subaddr & 0xff) << 16) | 0xed, SAA7146_I2C_TRANSFER); 155 152 else 156 153 saawrite(((addr & 0xfe) << 24) | (((addr | 1) & 0xff) << 16) | 157 - 0xf1, SAA7146_I2C_TRANSFER); 154 + 0xf1, SAA7146_I2C_TRANSFER); 158 155 saawrite((SAA7146_MC2_UPLD_I2C << 16) | 159 156 SAA7146_MC2_UPLD_I2C, SAA7146_MC2); 160 157 /* wait for i2c registers to be programmed */ ··· 168 163 schedule(); 169 164 if (saaread(SAA7146_I2C_STATUS) & SAA7146_I2C_ERR) 170 165 return -1; 171 - if (i == 1000) 166 + if (i == 1000) 172 167 printk("i2c setup read timeout\n"); 173 168 saawrite(0x41, SAA7146_I2C_TRANSFER); 174 169 saawrite((SAA7146_MC2_UPLD_I2C << 16) | ··· 183 178 schedule(); 184 179 if (saaread(SAA7146_I2C_TRANSFER) & SAA7146_I2C_ERR) 185 180 return -1; 186 - if (i == 1000) 181 + if (i == 1000) 187 182 printk("i2c read timeout\n"); 188 183 return ((saaread(SAA7146_I2C_TRANSFER) >> 24) & 0xff); 189 184 } ··· 218 213 { 219 214 int i; 220 215 221 - DEBUG(printk(KERN_DEBUG "stradis%d: i2c: device found=%02x\n", saa->nr, id)); 222 - if (id == 0xa0) { /* we have rev2 or later board, fill in info */ 216 + DEBUG(printk(KERN_DEBUG "stradis%d: i2c: device found=%02x\n", saa->nr, 217 + id)); 218 + if (id == 0xa0) { /* we have rev2 or later board, fill in info */ 223 219 for (i = 0; i < 64; i++) 224 220 saa->boardcfg[i] = I2CRead(saa, 0xa0, i, 1); 225 221 #ifdef USE_RESCUE_EEPROM_SDM275 226 222 if (saa->boardcfg[0] != 0) { 227 - printk("stradis%d: WARNING: EEPROM STORED VALUES HAVE BEEN IGNORED\n", saa->nr); 223 + printk("stradis%d: WARNING: EEPROM STORED VALUES HAVE " 224 + "BEEN IGNORED\n", saa->nr); 228 225 for (i = 0; i < 64; i++) 229 226 saa->boardcfg[i] = rescue_eeprom[i]; 230 227 } 231 228 #endif 232 229 printk("stradis%d: config =", saa->nr); 233 230 for (i = 0; i < 51; i++) { 234 - printk(" %02x",saa->boardcfg[i]); 231 + printk(" %02x", saa->boardcfg[i]); 235 232 } 236 233 printk("\n"); 237 234 } ··· 261 254 for (i = 0; i < 500000 && 262 255 (saaread(SAA7146_PSR) & SAA7146_PSR_DEBI_S); i++) 263 256 saaread(SAA7146_MC2); 257 + 264 258 if (i > debiwait_maxwait) 265 259 printk("wait-for-debi-done maxwait: %d\n", 266 260 debiwait_maxwait = i); 267 - 261 + 268 262 if (i == 500000) 269 263 return -1; 264 + 270 265 return 0; 271 266 } 272 267 273 268 static int debiwrite(struct saa7146 *saa, u32 config, int addr, 274 - u32 val, int count) 269 + u32 val, int count) 275 270 { 276 271 u32 cmd; 277 272 if (count <= 0 || count > 32764) ··· 339 330 return; 340 331 } 341 332 /* if at least 1 block audio waiting and audio fifo isn't full */ 342 - if (audbytes >= 2048 && (debiread(saa, debNormal, 343 - IBM_MP2_AUD_FIFO, 2) & 0xff) < 60) { 333 + if (audbytes >= 2048 && (debiread(saa, debNormal, IBM_MP2_AUD_FIFO, 2) 334 + & 0xff) < 60) { 344 335 if (saa->audhead > saa->audtail) 345 336 split = 65536 - saa->audhead; 346 337 else 347 338 split = 0; 348 339 audbytes = 2048; 349 340 if (split > 0 && split < 2048) { 350 - memcpy(saa->dmadebi, saa->audbuf + saa->audhead, 351 - split); 341 + memcpy(saa->dmadebi, saa->audbuf + saa->audhead, split); 352 342 saa->audhead = 0; 353 343 audbytes -= split; 354 344 } else ··· 356 348 audbytes); 357 349 saa->audhead += audbytes; 358 350 saa->audhead &= 0xffff; 359 - debiwrite(saa, debAudio, (NewCard? IBM_MP2_AUD_FIFO : 360 - IBM_MP2_AUD_FIFOW), 0, 2048); 351 + debiwrite(saa, debAudio, (NewCard ? IBM_MP2_AUD_FIFO : 352 + IBM_MP2_AUD_FIFOW), 0, 2048); 361 353 wake_up_interruptible(&saa->audq); 362 - /* if at least 1 block video waiting and video fifo isn't full */ 354 + /* if at least 1 block video waiting and video fifo isn't full */ 363 355 } else if (vidbytes >= 30720 && (debiread(saa, debNormal, 364 - IBM_MP2_FIFO, 2)) < 16384) { 356 + IBM_MP2_FIFO, 2)) < 16384) { 365 357 if (saa->vidhead > saa->vidtail) 366 358 split = 524288 - saa->vidhead; 367 359 else 368 360 split = 0; 369 361 vidbytes = 30720; 370 362 if (split > 0 && split < 30720) { 371 - memcpy(saa->dmadebi, saa->vidbuf + saa->vidhead, 372 - split); 363 + memcpy(saa->dmadebi, saa->vidbuf + saa->vidhead, split); 373 364 saa->vidhead = 0; 374 365 vidbytes -= split; 375 366 } else ··· 378 371 saa->vidhead += vidbytes; 379 372 saa->vidhead &= 0x7ffff; 380 373 debiwrite(saa, debVideo, (NewCard ? IBM_MP2_FIFO : 381 - IBM_MP2_FIFOW), 0, 30720); 374 + IBM_MP2_FIFOW), 0, 30720); 382 375 wake_up_interruptible(&saa->vidq); 383 376 } 384 377 saawrite(SAA7146_PSR_DEBI_S | SAA7146_PSR_PIN1, SAA7146_IER); ··· 390 383 if (size > 30720) 391 384 size = 30720; 392 385 /* ensure some multiple of 8 bytes is transferred */ 393 - size = 8 * ((size + 8)>>3); 386 + size = 8 * ((size + 8) >> 3); 394 387 if (size) { 395 388 debiwrite(saa, debNormal, IBM_MP2_OSD_ADDR, 396 - (saa->osdhead>>3), 2); 389 + (saa->osdhead >> 3), 2); 397 390 memcpy(saa->dmadebi, &saa->osdbuf[saa->osdhead], size); 398 391 saa->osdhead += size; 399 392 /* block transfer of next 8 bytes to ~32k bytes */ ··· 407 400 408 401 static irqreturn_t saa7146_irq(int irq, void *dev_id, struct pt_regs *regs) 409 402 { 410 - struct saa7146 *saa = (struct saa7146 *) dev_id; 403 + struct saa7146 *saa = dev_id; 411 404 u32 stat, astat; 412 405 int count; 413 406 int handled = 0; ··· 456 449 saa->vidinfo.v_size = 480; 457 450 #if 0 458 451 if (saa->endmarkhead != saa->endmarktail) { 459 - saa->audhead = 452 + saa->audhead = 460 453 saa->endmark[saa->endmarkhead]; 461 454 saa->endmarkhead++; 462 455 if (saa->endmarkhead >= MAX_MARKS) ··· 466 459 } 467 460 if (istat & 0x4000) { /* Sequence Error Code */ 468 461 if (saa->endmarkhead != saa->endmarktail) { 469 - saa->audhead = 462 + saa->audhead = 470 463 saa->endmark[saa->endmarkhead]; 471 464 saa->endmarkhead++; 472 465 if (saa->endmarkhead >= MAX_MARKS) ··· 585 578 int i; 586 579 587 580 if (chain) 588 - debiwrite(saa, debNormal, IBM_MP2_COMMAND, (command << 1) | 1, 2); 581 + debiwrite(saa, debNormal, IBM_MP2_COMMAND, (command << 1)| 1,2); 589 582 else 590 583 debiwrite(saa, debNormal, IBM_MP2_COMMAND, command << 1, 2); 591 584 debiwrite(saa, debNormal, IBM_MP2_CMD_DATA, data, 2); ··· 635 628 else 636 629 sequence = mode8420con; 637 630 for (i = 0; i < INIT8420LEN; i++) 638 - I2CWrite(saa, 0x20, init8420[i * 2], 639 - init8420[i * 2 + 1], 2); 631 + I2CWrite(saa, 0x20, init8420[i * 2], init8420[i * 2 + 1], 2); 640 632 for (i = 0; i < MODE8420LEN; i++) 641 - I2CWrite(saa, 0x20, sequence[i * 2], 642 - sequence[i * 2 + 1], 2); 633 + I2CWrite(saa, 0x20, sequence[i * 2], sequence[i * 2 + 1], 2); 643 634 printk("stradis%d: CS8420 initialized\n", saa->nr); 644 635 } 645 636 ··· 653 648 /* initialize PAL/NTSC video encoder */ 654 649 for (i = 0; i < INIT7121LEN; i++) { 655 650 if (NewCard) { /* handle new card encoder differences */ 656 - if (sequence[i*2] == 0x3a) 651 + if (sequence[i * 2] == 0x3a) 657 652 I2CWrite(saa, 0x88, 0x3a, 0x13, 2); 658 - else if (sequence[i*2] == 0x6b) 653 + else if (sequence[i * 2] == 0x6b) 659 654 I2CWrite(saa, 0x88, 0x6b, 0x20, 2); 660 - else if (sequence[i*2] == 0x6c) 655 + else if (sequence[i * 2] == 0x6c) 661 656 I2CWrite(saa, 0x88, 0x6c, 662 657 dopal ? 0x09 : 0xf5, 2); 663 - else if (sequence[i*2] == 0x6d) 658 + else if (sequence[i * 2] == 0x6d) 664 659 I2CWrite(saa, 0x88, 0x6d, 665 660 dopal ? 0x20 : 0x00, 2); 666 - else if (sequence[i*2] == 0x7a) 661 + else if (sequence[i * 2] == 0x7a) 667 662 I2CWrite(saa, 0x88, 0x7a, 668 663 dopal ? (PALFirstActive - 1) : 669 664 (NTSCFirstActive - 4), 2); 670 - else if (sequence[i*2] == 0x7b) 665 + else if (sequence[i * 2] == 0x7b) 671 666 I2CWrite(saa, 0x88, 0x7b, 672 667 dopal ? PALLastActive : 673 668 NTSCLastActive, 2); 674 - else I2CWrite(saa, 0x88, sequence[i * 2], 675 - sequence[i * 2 + 1], 2); 669 + else 670 + I2CWrite(saa, 0x88, sequence[i * 2], 671 + sequence[i * 2 + 1], 2); 676 672 } else { 677 - if (sequence[i*2] == 0x6b && mod) 678 - I2CWrite(saa, 0x88, 0x6b, 679 - (sequence[i * 2 + 1] ^ 0x09), 2); 680 - else if (sequence[i*2] == 0x7a) 673 + if (sequence[i * 2] == 0x6b && mod) 674 + I2CWrite(saa, 0x88, 0x6b, 675 + (sequence[i * 2 + 1] ^ 0x09), 2); 676 + else if (sequence[i * 2] == 0x7a) 681 677 I2CWrite(saa, 0x88, 0x7a, 682 678 dopal ? (PALFirstActive - 1) : 683 679 (NTSCFirstActive - 4), 2); 684 - else if (sequence[i*2] == 0x7b) 680 + else if (sequence[i * 2] == 0x7b) 685 681 I2CWrite(saa, 0x88, 0x7b, 686 682 dopal ? PALLastActive : 687 683 NTSCLastActive, 2); ··· 706 700 nCode = noffset + 0x100; 707 701 if (nCode == 1) 708 702 nCode = 0x401; 709 - else if (nCode < 1) nCode = 0x400 + PixelsPerLine + nCode; 703 + else if (nCode < 1) 704 + nCode = 0x400 + PixelsPerLine + nCode; 710 705 debiwrite(saa, debNormal, XILINX_GLDELAY, nCode, 2); 711 706 } 712 707 ··· 717 710 saa->boardcfg[2] = mode; 718 711 /* do not adjust analog video parameters here, use saa7121 init */ 719 712 /* you will affect the SDI output on the new card */ 720 - if (mode == VIDEO_MODE_PAL) { /* PAL */ 713 + if (mode == VIDEO_MODE_PAL) { /* PAL */ 721 714 debiwrite(saa, debNormal, XILINX_CTL0, 0x0808, 2); 722 715 mdelay(50); 723 716 saawrite(0x012002c0, SAA7146_NUM_LINE_BYTE1); 724 717 if (NewCard) { 725 - debiwrite(saa, debNormal, IBM_MP2_DISP_MODE, 726 - 0xe100, 2); 718 + debiwrite(saa, debNormal, IBM_MP2_DISP_MODE, 0xe100, 2); 727 719 mdelay(50); 728 720 } 729 721 debiwrite(saa, debNormal, IBM_MP2_DISP_MODE, 730 - NewCard ? 0xe500: 0x6500, 2); 722 + NewCard ? 0xe500 : 0x6500, 2); 731 723 debiwrite(saa, debNormal, IBM_MP2_DISP_DLY, 732 724 (1 << 8) | 733 - (NewCard ? PALFirstActive : PALFirstActive-6), 2); 725 + (NewCard ? PALFirstActive : PALFirstActive - 6), 2); 734 726 } else { /* NTSC */ 735 727 debiwrite(saa, debNormal, XILINX_CTL0, 0x0800, 2); 736 728 mdelay(50); 737 729 saawrite(0x00f002c0, SAA7146_NUM_LINE_BYTE1); 738 730 debiwrite(saa, debNormal, IBM_MP2_DISP_MODE, 739 - NewCard ? 0xe100: 0x6100, 2); 731 + NewCard ? 0xe100 : 0x6100, 2); 740 732 debiwrite(saa, debNormal, IBM_MP2_DISP_DLY, 741 733 (1 << 8) | 742 - (NewCard ? NTSCFirstActive : NTSCFirstActive-6), 2); 734 + (NewCard ? NTSCFirstActive : NTSCFirstActive - 6), 2); 743 735 } 744 736 } 745 - 746 737 747 738 /* Intialize bitmangler to map from a byte value to the mangled word that 748 739 * must be output to program the Xilinx part through the DEBI port. ··· 769 764 for (num = 0; num < saa_num; num++) { 770 765 saa = &saa7146s[num]; 771 766 if (saa->boardcfg[0] > 20) 772 - continue; /* card was programmed */ 767 + continue; /* card was programmed */ 773 768 loadtwo = (saa->boardcfg[18] & 0x10); 774 769 if (!NewCard) /* we have an old board */ 775 770 for (i = 0; i < 256; i++) 776 - bitmangler[i] = ((i & 0x01) << 15) | 777 - ((i & 0x02) << 6) | ((i & 0x04) << 4) | 778 - ((i & 0x08) << 9) | ((i & 0x10) << 7) | 779 - ((i & 0x20) >> 3) | ((i & 0x40) >> 5) | 780 - ((i & 0x80) >> 7); 781 - else /* else we have a new board */ 771 + bitmangler[i] = ((i & 0x01) << 15) | 772 + ((i & 0x02) << 6) | ((i & 0x04) << 4) | 773 + ((i & 0x08) << 9) | ((i & 0x10) << 7) | 774 + ((i & 0x20) >> 3) | ((i & 0x40) >> 5) | 775 + ((i & 0x80) >> 7); 776 + else /* else we have a new board */ 782 777 for (i = 0; i < 256; i++) 783 - bitmangler[i] = ((i & 0x01) << 7) | 784 - ((i & 0x02) << 5) | ((i & 0x04) << 3) | 785 - ((i & 0x08) << 1) | ((i & 0x10) >> 1) | 786 - ((i & 0x20) >> 3) | ((i & 0x40) >> 5) | 787 - ((i & 0x80) >> 7); 778 + bitmangler[i] = ((i & 0x01) << 7) | 779 + ((i & 0x02) << 5) | ((i & 0x04) << 3) | 780 + ((i & 0x08) << 1) | ((i & 0x10) >> 1) | 781 + ((i & 0x20) >> 3) | ((i & 0x40) >> 5) | 782 + ((i & 0x80) >> 7); 788 783 789 784 dmabuf = (u16 *) saa->dmadebi; 790 785 newdma = (u8 *) saa->dmadebi; 791 786 if (NewCard) { /* SDM2xxx */ 792 787 if (!strncmp(bitdata->loadwhat, "decoder2", 8)) 793 788 continue; /* fpga not for this card */ 794 - if (!strncmp(&saa->boardcfg[42], 795 - bitdata->loadwhat, 8)) { 789 + if (!strncmp(&saa->boardcfg[42], bitdata->loadwhat, 8)) 796 790 loadfile = 1; 797 - } else if (loadtwo && !strncmp(&saa->boardcfg[19], 798 - bitdata->loadwhat, 8)) { 791 + else if (loadtwo && !strncmp(&saa->boardcfg[19], 792 + bitdata->loadwhat, 8)) 799 793 loadfile = 2; 800 - } else if (!saa->boardcfg[42] && /* special */ 801 - !strncmp("decxl", bitdata->loadwhat, 8)) { 802 - loadfile = 1; 803 - } else 794 + else if (!saa->boardcfg[42] && !strncmp("decxl", 795 + bitdata->loadwhat, 8)) 796 + loadfile = 1; /* special */ 797 + else 804 798 continue; /* fpga not for this card */ 805 - if (loadfile != 1 && loadfile != 2) { 799 + if (loadfile != 1 && loadfile != 2) 806 800 continue; /* skip to next card */ 807 - } 808 - if (saa->boardcfg[0] && loadfile == 1 ) 801 + if (saa->boardcfg[0] && loadfile == 1) 809 802 continue; /* skip to next card */ 810 803 if (saa->boardcfg[0] != 1 && loadfile == 2) 811 804 continue; /* skip to next card */ ··· 838 835 /* Release Xilinx INIT signal (WS2) */ 839 836 saawrite(0x00000000, SAA7146_GPIO_CTRL); 840 837 /* Wait for the INIT to go High */ 841 - for (i = 0; i < 10000 && 842 - !(saaread(SAA7146_PSR) & SAA7146_PSR_PIN2); i++) 838 + for (i = 0; 839 + i < 10000 && !(saaread(SAA7146_PSR) & SAA7146_PSR_PIN2); 840 + i++) 843 841 schedule(); 844 842 if (i == 1000) { 845 843 printk(KERN_INFO "stradis%d: no fpga INIT\n", saa->nr); ··· 850 846 if (NewCard) { 851 847 for (i = startindex; i < bitdata->datasize; i++) 852 848 newdma[i - startindex] = 853 - bitmangler[bitdata->data[i]]; 849 + bitmangler[bitdata->data[i]]; 854 850 debiwrite(saa, 0x01420000, 0, 0, 855 851 ((bitdata->datasize - startindex) + 5)); 856 - if (loadtwo) { 857 - if (loadfile == 1) { 858 - printk("stradis%d: " 859 - "awaiting 2nd FPGA bitfile\n", 860 - saa->nr); 861 - continue; /* skip to next card */ 862 - } 863 - 852 + if (loadtwo && loadfile == 1) { 853 + printk("stradis%d: awaiting 2nd FPGA bitfile\n", 854 + saa->nr); 855 + continue; /* skip to next card */ 864 856 } 865 857 } else { 866 858 for (i = startindex; i < bitdata->datasize; i++) ··· 865 865 debiwrite(saa, 0x014a0000, 0, 0, 866 866 ((bitdata->datasize - startindex) + 5) * 2); 867 867 } 868 - for (i = 0; i < 1000 && 869 - !(saaread(SAA7146_PSR) & SAA7146_PSR_PIN2); i++) 868 + for (i = 0; 869 + i < 1000 && !(saaread(SAA7146_PSR) & SAA7146_PSR_PIN2); 870 + i++) 870 871 schedule(); 871 872 if (i == 1000) { 872 873 printk(KERN_INFO "stradis%d: FPGA load failed\n", ··· 891 890 /* mute CS3310 */ 892 891 if (HaveCS3310) 893 892 debiwrite(saa, debNormal, XILINX_CS3310_CMPLT, 894 - 0, 2); 893 + 0, 2); 895 894 /* set VXCO to PWM mode, release reset, blank on */ 896 895 debiwrite(saa, debNormal, XILINX_CTL0, 0xffc4, 2); 897 896 mdelay(10); 898 897 /* unmute CS3310 */ 899 898 if (HaveCS3310) 900 899 debiwrite(saa, debNormal, XILINX_CTL0, 901 - 0x2020, 2); 900 + 0x2020, 2); 902 901 } 903 902 /* set source Black */ 904 903 debiwrite(saa, debNormal, XILINX_CTL0, 0x1707, 2); ··· 924 923 /* we must init CS8420 first since rev b pulls i2s */ 925 924 /* master clock low and CS4341 needs i2s master to */ 926 925 /* run the i2c port. */ 927 - if (HaveCS8420) { 926 + if (HaveCS8420) 928 927 /* 0=consumer, 1=pro */ 929 928 initialize_cs8420(saa, 0); 930 - } 929 + 931 930 mdelay(5); 932 931 if (HaveCS4341) 933 932 initialize_cs4341(saa); ··· 947 946 debiwrite(saa, debNormal, XILINX_CTL0, 0x8080, 2); 948 947 #endif 949 948 } 949 + 950 950 return failure; 951 951 } 952 952 ··· 988 986 /* we must init CS8420 first since rev b pulls i2s */ 989 987 /* master clock low and CS4341 needs i2s master to */ 990 988 /* run the i2c port. */ 991 - if (HaveCS8420) { 989 + if (HaveCS8420) 992 990 /* 0=consumer, 1=pro */ 993 991 initialize_cs8420(saa, 1); 994 - } 992 + 995 993 mdelay(5); 996 994 if (HaveCS4341) 997 995 initialize_cs4341(saa); ··· 1006 1004 debiwrite(saa, debNormal, IBM_MP2_OSD_SIZE, 0x2000, 2); 1007 1005 debiwrite(saa, debNormal, IBM_MP2_AUD_CTL, 0x4552, 2); 1008 1006 if (ibm_send_command(saa, IBM_MP2_CONFIG_DECODER, 1009 - (ChipControl == 0x43 ? 0xe800 : 0xe000), 1)) { 1007 + (ChipControl == 0x43 ? 0xe800 : 0xe000), 1)) { 1010 1008 printk(KERN_ERR "stradis%d: IBM config failed\n", saa->nr); 1011 1009 } 1012 1010 if (HaveCS3310) { 1013 1011 int i = CS3310MaxLvl; 1014 - debiwrite(saa, debNormal, XILINX_CS3310_CMPLT, ((i<<8)|i), 2); 1012 + debiwrite(saa, debNormal, XILINX_CS3310_CMPLT, ((i << 8)| i),2); 1015 1013 } 1016 1014 /* start video decoder */ 1017 1015 debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL, ChipControl, 2); ··· 1024 1022 /* clear pending interrupts */ 1025 1023 debiread(saa, debNormal, IBM_MP2_HOST_INT, 2); 1026 1024 debiwrite(saa, debNormal, XILINX_CTL0, 0x1711, 2); 1025 + 1027 1026 return 0; 1028 1027 } 1029 1028 ··· 1038 1035 saa = &saa7146s[num]; 1039 1036 /* check that FPGA is loaded */ 1040 1037 debiwrite(saa, debNormal, IBM_MP2_OSD_SIZE, 0xa55a, 2); 1041 - if ((i = debiread(saa, debNormal, IBM_MP2_OSD_SIZE, 2)) != 1042 - 0xa55a) { 1038 + i = debiread(saa, debNormal, IBM_MP2_OSD_SIZE, 2); 1039 + if (i != 0xa55a) { 1043 1040 printk(KERN_INFO "stradis%d: %04x != 0xa55a\n", 1044 1041 saa->nr, i); 1045 1042 #if 0 ··· 1050 1047 if (saa->boardcfg[0] > 27) 1051 1048 continue; /* skip to next card */ 1052 1049 /* load video control store */ 1053 - saa->boardcfg[1] = 0x13; /* no-sync default */ 1050 + saa->boardcfg[1] = 0x13; /* no-sync default */ 1054 1051 debiwrite(saa, debNormal, IBM_MP2_WR_PROT, 1, 2); 1055 1052 debiwrite(saa, debNormal, IBM_MP2_PROC_IADDR, 0, 2); 1056 1053 for (i = 0; i < microcode->datasize / 2; i++) 1057 1054 debiwrite(saa, debNormal, IBM_MP2_PROC_IDATA, 1058 1055 (microcode->data[i * 2] << 8) | 1059 - microcode->data[i * 2 + 1], 2); 1056 + microcode->data[i * 2 + 1], 2); 1060 1057 debiwrite(saa, debNormal, IBM_MP2_PROC_IADDR, 0, 2); 1061 1058 debiwrite(saa, debNormal, IBM_MP2_WR_PROT, 0, 2); 1062 1059 debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL, 1063 - ChipControl, 2); 1060 + ChipControl, 2); 1064 1061 saa->boardcfg[0] = 28; 1065 1062 } 1066 1063 if (!strncmp(microcode->loadwhat, "decoder.aud", 11)) { ··· 1077 1074 debiwrite(saa, debNormal, IBM_MP2_OSD_SIZE, 0x2000, 2); 1078 1075 debiwrite(saa, debNormal, IBM_MP2_AUD_CTL, 0x4552, 2); 1079 1076 if (ibm_send_command(saa, IBM_MP2_CONFIG_DECODER, 1080 - 0xe000, 1)) { 1081 - printk(KERN_ERR 1082 - "stradis%d: IBM config failed\n", 1083 - saa->nr); 1077 + 0xe000, 1)) { 1078 + printk(KERN_ERR "stradis%d: IBM config " 1079 + "failed\n", saa->nr); 1084 1080 return -1; 1085 1081 } 1086 1082 /* set PWM to center value */ 1087 1083 if (NewCard) { 1088 1084 debiwrite(saa, debNormal, XILINX_PWM, 1089 - saa->boardcfg[14] + 1090 - (saa->boardcfg[13]<<8), 2); 1085 + saa->boardcfg[14] + 1086 + (saa->boardcfg[13] << 8), 2); 1091 1087 } else 1092 - debiwrite(saa, debNormal, XILINX_PWM, 1093 - 0x46, 2); 1088 + debiwrite(saa, debNormal, XILINX_PWM, 0x46, 2); 1089 + 1094 1090 if (HaveCS3310) { 1095 1091 i = CS3310MaxLvl; 1096 - debiwrite(saa, debNormal, 1097 - XILINX_CS3310_CMPLT, ((i<<8)|i), 2); 1092 + debiwrite(saa, debNormal, XILINX_CS3310_CMPLT, 1093 + (i << 8) | i, 2); 1098 1094 } 1099 - printk(KERN_INFO 1100 - "stradis%d: IBM MPEGCD%d Initialized\n", 1101 - saa->nr, 18 + (debiread(saa, debNormal, 1102 - IBM_MP2_CHIP_CONTROL, 2) >> 12)); 1095 + printk(KERN_INFO "stradis%d: IBM MPEGCD%d Inited\n", 1096 + saa->nr, 18 + (debiread(saa, debNormal, 1097 + IBM_MP2_CHIP_CONTROL, 2) >> 12)); 1103 1098 /* start video decoder */ 1104 1099 debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL, 1105 1100 ChipControl, 2); 1106 - debiwrite(saa, debNormal, IBM_MP2_RB_THRESHOLD, 1107 - 0x4037, 2); /* 256k vid, 3520 bytes aud */ 1101 + debiwrite(saa, debNormal, IBM_MP2_RB_THRESHOLD, 0x4037, 1102 + 2); /* 256k vid, 3520 bytes aud */ 1108 1103 debiwrite(saa, debNormal, IBM_MP2_AUD_CTL, 0x4573, 2); 1109 1104 ibm_send_command(saa, IBM_MP2_PLAY, 0, 0); 1110 1105 /* enable buffer threshold irq */ ··· 1115 1114 saa->boardcfg[0] = 37; 1116 1115 } 1117 1116 } 1117 + 1118 1118 return 0; 1119 1119 } 1120 1120 1121 - static u32 palette2fmt[] = 1122 - { /* some of these YUV translations are wrong */ 1123 - 0xffffffff, 0x86000000, 0x87000000, 0x80000000, 0x8100000, 0x82000000, 1124 - 0x83000000, 0x00000000, 0x03000000, 0x03000000, 0x0a00000, 0x03000000, 1125 - 0x06000000, 0x00000000, 0x03000000, 0x0a000000, 0x0300000 1121 + static u32 palette2fmt[] = { /* some of these YUV translations are wrong */ 1122 + 0xffffffff, 0x86000000, 0x87000000, 0x80000000, 0x8100000, 0x82000000, 1123 + 0x83000000, 0x00000000, 0x03000000, 0x03000000, 0x0a00000, 0x03000000, 1124 + 0x06000000, 0x00000000, 0x03000000, 0x0a000000, 0x0300000 1126 1125 }; 1127 - static int bpp2fmt[4] = 1128 - { 1126 + static int bpp2fmt[4] = { 1129 1127 VIDEO_PALETTE_HI240, VIDEO_PALETTE_RGB565, VIDEO_PALETTE_RGB24, 1130 1128 VIDEO_PALETTE_RGB32 1131 1129 }; 1132 1130 1133 1131 /* I wish I could find a formula to calculate these... */ 1134 - static u32 h_prescale[64] = 1135 - { 1136 - 0x10000000, 0x18040202, 0x18080000, 0x380c0606, 0x38100204, 0x38140808, 1137 - 0x38180000, 0x381c0000, 0x3820161c, 0x38242a3b, 0x38281230, 0x382c4460, 1138 - 0x38301040, 0x38340080, 0x38380000, 0x383c0000, 0x3840fefe, 0x3844ee9f, 1139 - 0x3848ee9f, 0x384cee9f, 0x3850ee9f, 0x38542a3b, 0x38581230, 0x385c0000, 1140 - 0x38600000, 0x38640000, 0x38680000, 0x386c0000, 0x38700000, 0x38740000, 1141 - 0x38780000, 0x387c0000, 0x30800000, 0x38840000, 0x38880000, 0x388c0000, 1142 - 0x38900000, 0x38940000, 0x38980000, 0x389c0000, 0x38a00000, 0x38a40000, 1143 - 0x38a80000, 0x38ac0000, 0x38b00000, 0x38b40000, 0x38b80000, 0x38bc0000, 1144 - 0x38c00000, 0x38c40000, 0x38c80000, 0x38cc0000, 0x38d00000, 0x38d40000, 1145 - 0x38d80000, 0x38dc0000, 0x38e00000, 0x38e40000, 0x38e80000, 0x38ec0000, 1146 - 0x38f00000, 0x38f40000, 0x38f80000, 0x38fc0000, 1132 + static u32 h_prescale[64] = { 1133 + 0x10000000, 0x18040202, 0x18080000, 0x380c0606, 0x38100204, 0x38140808, 1134 + 0x38180000, 0x381c0000, 0x3820161c, 0x38242a3b, 0x38281230, 0x382c4460, 1135 + 0x38301040, 0x38340080, 0x38380000, 0x383c0000, 0x3840fefe, 0x3844ee9f, 1136 + 0x3848ee9f, 0x384cee9f, 0x3850ee9f, 0x38542a3b, 0x38581230, 0x385c0000, 1137 + 0x38600000, 0x38640000, 0x38680000, 0x386c0000, 0x38700000, 0x38740000, 1138 + 0x38780000, 0x387c0000, 0x30800000, 0x38840000, 0x38880000, 0x388c0000, 1139 + 0x38900000, 0x38940000, 0x38980000, 0x389c0000, 0x38a00000, 0x38a40000, 1140 + 0x38a80000, 0x38ac0000, 0x38b00000, 0x38b40000, 0x38b80000, 0x38bc0000, 1141 + 0x38c00000, 0x38c40000, 0x38c80000, 0x38cc0000, 0x38d00000, 0x38d40000, 1142 + 0x38d80000, 0x38dc0000, 0x38e00000, 0x38e40000, 0x38e80000, 0x38ec0000, 1143 + 0x38f00000, 0x38f40000, 0x38f80000, 0x38fc0000, 1147 1144 }; 1148 - static u32 v_gain[64] = 1149 - { 1150 - 0x016000ff, 0x016100ff, 0x016100ff, 0x016200ff, 0x016200ff, 0x016200ff, 1151 - 0x016200ff, 0x016300ff, 0x016300ff, 0x016300ff, 0x016300ff, 0x016300ff, 1152 - 0x016300ff, 0x016300ff, 0x016300ff, 0x016400ff, 0x016400ff, 0x016400ff, 1153 - 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1154 - 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1155 - 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1156 - 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1157 - 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1158 - 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1159 - 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1160 - 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1145 + static u32 v_gain[64] = { 1146 + 0x016000ff, 0x016100ff, 0x016100ff, 0x016200ff, 0x016200ff, 0x016200ff, 1147 + 0x016200ff, 0x016300ff, 0x016300ff, 0x016300ff, 0x016300ff, 0x016300ff, 1148 + 0x016300ff, 0x016300ff, 0x016300ff, 0x016400ff, 0x016400ff, 0x016400ff, 1149 + 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1150 + 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1151 + 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1152 + 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1153 + 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1154 + 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1155 + 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1156 + 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 1161 1157 }; 1162 - 1163 1158 1164 1159 static void saa7146_set_winsize(struct saa7146 *saa) 1165 1160 { ··· 1171 1174 saawrite(saa->win.vidadr + saa->win.bpl * saa->win.sheight, 1172 1175 SAA7146_PROT_ADDR1); 1173 1176 saawrite(0, SAA7146_PAGE1); 1174 - saawrite(format|0x60, SAA7146_CLIP_FORMAT_CTRL); 1177 + saawrite(format | 0x60, SAA7146_CLIP_FORMAT_CTRL); 1175 1178 offset = (704 / (saa->win.width - 1)) & 0x3f; 1176 1179 saawrite(h_prescale[offset], SAA7146_HPS_H_PRESCALE); 1177 1180 offset = (720896 / saa->win.width) / (offset + 1); 1178 - saawrite((offset<<12)|0x0c, SAA7146_HPS_H_SCALE); 1181 + saawrite((offset << 12) | 0x0c, SAA7146_HPS_H_SCALE); 1179 1182 if (CurrentMode == VIDEO_MODE_NTSC) { 1180 - yacl = /*(480 / saa->win.height - 1) & 0x3f*/ 0; 1183 + yacl = /*(480 / saa->win.height - 1) & 0x3f */ 0; 1181 1184 ysci = 1024 - (saa->win.height * 1024 / 480); 1182 1185 } else { 1183 - yacl = /*(576 / saa->win.height - 1) & 0x3f*/ 0; 1186 + yacl = /*(576 / saa->win.height - 1) & 0x3f */ 0; 1184 1187 ysci = 1024 - (saa->win.height * 1024 / 576); 1185 1188 } 1186 - saawrite((1<<31)|(ysci<<21)|(yacl<<15), SAA7146_HPS_V_SCALE); 1189 + saawrite((1 << 31) | (ysci << 21) | (yacl << 15), SAA7146_HPS_V_SCALE); 1187 1190 saawrite(v_gain[yacl], SAA7146_HPS_V_GAIN); 1188 1191 saawrite(((SAA7146_MC2_UPLD_DMA1 | SAA7146_MC2_UPLD_HPS_V | 1189 - SAA7146_MC2_UPLD_HPS_H) << 16) | (SAA7146_MC2_UPLD_DMA1 | 1190 - SAA7146_MC2_UPLD_HPS_V | SAA7146_MC2_UPLD_HPS_H), 1191 - SAA7146_MC2); 1192 + SAA7146_MC2_UPLD_HPS_H) << 16) | (SAA7146_MC2_UPLD_DMA1 | 1193 + SAA7146_MC2_UPLD_HPS_V | SAA7146_MC2_UPLD_HPS_H), SAA7146_MC2); 1192 1194 } 1193 1195 1194 1196 /* clip_draw_rectangle(cm,x,y,w,h) -- handle clipping an area ··· 1222 1226 startword = (x >> 5); 1223 1227 endword = ((x + w) >> 5); 1224 1228 bitsleft = (0xffffffff >> (x & 31)); 1225 - bitsright = (0xffffffff << (~((x + w) - (endword<<5)))); 1226 - temp = &clipmap[(y<<5) + startword]; 1229 + bitsright = (0xffffffff << (~((x + w) - (endword << 5)))); 1230 + temp = &clipmap[(y << 5) + startword]; 1227 1231 w = endword - startword; 1228 1232 if (!w) { 1229 1233 bitsleft |= bitsright; ··· 1248 1252 u32 *clipmap; 1249 1253 1250 1254 clipmap = saa->dmavid2; 1251 - if((width=saa->win.width)>1023) 1252 - width = 1023; /* sanity check */ 1253 - if((height=saa->win.height)>640) 1254 - height = 639; /* sanity check */ 1255 - if (ncr > 0) { /* rectangles pased */ 1255 + if ((width = saa->win.width) > 1023) 1256 + width = 1023; /* sanity check */ 1257 + if ((height = saa->win.height) > 640) 1258 + height = 639; /* sanity check */ 1259 + if (ncr > 0) { /* rectangles pased */ 1256 1260 /* convert rectangular clips to a bitmap */ 1257 - memset(clipmap, 0, VIDEO_CLIPMAP_SIZE); /* clear map */ 1261 + memset(clipmap, 0, VIDEO_CLIPMAP_SIZE); /* clear map */ 1258 1262 for (i = 0; i < ncr; i++) 1259 1263 clip_draw_rectangle(clipmap, cr[i].x, cr[i].y, 1260 1264 cr[i].width, cr[i].height); ··· 1262 1266 /* clip against viewing window AND screen 1263 1267 so we do not have to rely on the user program 1264 1268 */ 1265 - clip_draw_rectangle(clipmap,(saa->win.x+width>saa->win.swidth) ? 1266 - (saa->win.swidth-saa->win.x) : width, 0, 1024, 768); 1267 - clip_draw_rectangle(clipmap,0,(saa->win.y+height>saa->win.sheight) ? 1268 - (saa->win.sheight-saa->win.y) : height,1024,768); 1269 - if (saa->win.x<0) 1270 - clip_draw_rectangle(clipmap, 0, 0, -(saa->win.x), 768); 1271 - if (saa->win.y<0) 1272 - clip_draw_rectangle(clipmap, 0, 0, 1024, -(saa->win.y)); 1269 + clip_draw_rectangle(clipmap, (saa->win.x + width > saa->win.swidth) ? 1270 + (saa->win.swidth - saa->win.x) : width, 0, 1024, 768); 1271 + clip_draw_rectangle(clipmap, 0, 1272 + (saa->win.y + height > saa->win.sheight) ? 1273 + (saa->win.sheight - saa->win.y) : height, 1024, 768); 1274 + if (saa->win.x < 0) 1275 + clip_draw_rectangle(clipmap, 0, 0, -saa->win.x, 768); 1276 + if (saa->win.y < 0) 1277 + clip_draw_rectangle(clipmap, 0, 0, 1024, -saa->win.y); 1273 1278 } 1274 1279 1275 1280 static int saa_ioctl(struct inode *inode, struct file *file, ··· 1284 1287 { 1285 1288 struct video_capability b; 1286 1289 strcpy(b.name, saa->video_dev.name); 1287 - b.type = VID_TYPE_CAPTURE | 1288 - VID_TYPE_OVERLAY | 1289 - VID_TYPE_CLIPPING | 1290 - VID_TYPE_FRAMERAM | 1291 - VID_TYPE_SCALES; 1290 + b.type = VID_TYPE_CAPTURE | VID_TYPE_OVERLAY | 1291 + VID_TYPE_CLIPPING | VID_TYPE_FRAMERAM | 1292 + VID_TYPE_SCALES; 1292 1293 b.channels = 1; 1293 1294 b.audios = 1; 1294 1295 b.maxwidth = 768; ··· 1323 1328 if (p.palette < sizeof(palette2fmt) / sizeof(u32)) { 1324 1329 format = palette2fmt[p.palette]; 1325 1330 saa->win.color_fmt = format; 1326 - saawrite(format|0x60, SAA7146_CLIP_FORMAT_CTRL); 1331 + saawrite(format | 0x60, 1332 + SAA7146_CLIP_FORMAT_CTRL); 1327 1333 } 1328 1334 saawrite(((p.brightness & 0xff00) << 16) | 1329 - ((p.contrast & 0xfe00) << 7) | 1330 - ((p.colour & 0xfe00) >> 9), SAA7146_BCS_CTRL); 1335 + ((p.contrast & 0xfe00) << 7) | 1336 + ((p.colour & 0xfe00) >> 9), SAA7146_BCS_CTRL); 1331 1337 saa->picture = p; 1332 1338 /* upload changed registers */ 1333 1339 saawrite(((SAA7146_MC2_UPLD_HPS_H | 1334 - SAA7146_MC2_UPLD_HPS_V) << 16) | 1335 - SAA7146_MC2_UPLD_HPS_H | SAA7146_MC2_UPLD_HPS_V, 1336 - SAA7146_MC2); 1340 + SAA7146_MC2_UPLD_HPS_V) << 16) | 1341 + SAA7146_MC2_UPLD_HPS_H | 1342 + SAA7146_MC2_UPLD_HPS_V, SAA7146_MC2); 1337 1343 return 0; 1338 1344 } 1339 1345 case VIDIOCSWIN: ··· 1345 1349 if (copy_from_user(&vw, arg, sizeof(vw))) 1346 1350 return -EFAULT; 1347 1351 1348 - if (vw.flags || vw.width < 16 || vw.height < 16) { /* stop capture */ 1349 - saawrite((SAA7146_MC1_TR_E_1 << 16), SAA7146_MC1); 1352 + /* stop capture */ 1353 + if (vw.flags || vw.width < 16 || vw.height < 16) { 1354 + saawrite((SAA7146_MC1_TR_E_1 << 16), 1355 + SAA7146_MC1); 1350 1356 return -EINVAL; 1351 1357 } 1352 - if (saa->win.bpp < 4) { /* 32-bit align start and adjust width */ 1358 + /* 32-bit align start and adjust width */ 1359 + if (saa->win.bpp < 4) { 1353 1360 int i = vw.x; 1354 1361 vw.x = (vw.x + 3) & ~3; 1355 1362 i = vw.x - i; ··· 1381 1382 */ 1382 1383 if (vw.clipcount < 0) { 1383 1384 if (copy_from_user(saa->dmavid2, vw.clips, 1384 - VIDEO_CLIPMAP_SIZE)) 1385 + VIDEO_CLIPMAP_SIZE)) 1385 1386 return -EFAULT; 1386 - } 1387 - else if (vw.clipcount > 16384) { 1387 + } else if (vw.clipcount > 16384) { 1388 1388 return -EINVAL; 1389 1389 } else if (vw.clipcount > 0) { 1390 - if ((vcp = vmalloc(sizeof(struct video_clip) * 1391 - (vw.clipcount))) == NULL) 1392 - return -ENOMEM; 1390 + vcp = vmalloc(sizeof(struct video_clip) * 1391 + vw.clipcount); 1392 + if (vcp == NULL) 1393 + return -ENOMEM; 1393 1394 if (copy_from_user(vcp, vw.clips, 1394 - sizeof(struct video_clip) * 1395 - vw.clipcount)) { 1395 + sizeof(struct video_clip) * 1396 + vw.clipcount)) { 1396 1397 vfree(vcp); 1397 1398 return -EFAULT; 1398 1399 } 1399 1400 } else /* nothing clipped */ 1400 1401 memset(saa->dmavid2, 0, VIDEO_CLIPMAP_SIZE); 1402 + 1401 1403 make_clip_tab(saa, vcp, vw.clipcount); 1402 1404 if (vw.clipcount > 0) 1403 1405 vfree(vcp); ··· 1431 1431 if (v == 0) { 1432 1432 saa->cap &= ~1; 1433 1433 saawrite((SAA7146_MC1_TR_E_1 << 16), 1434 - SAA7146_MC1); 1434 + SAA7146_MC1); 1435 1435 } else { 1436 1436 if (saa->win.vidadr == 0 || saa->win.width == 0 1437 - || saa->win.height == 0) 1437 + || saa->win.height == 0) 1438 1438 return -EINVAL; 1439 1439 saa->cap |= 1; 1440 1440 saawrite((SAA7146_MC1_TR_E_1 << 16) | 0xffff, 1441 - SAA7146_MC1); 1441 + SAA7146_MC1); 1442 1442 } 1443 1443 return 0; 1444 1444 } 1445 1445 case VIDIOCGFBUF: 1446 1446 { 1447 1447 struct video_buffer v; 1448 - v.base = (void *) saa->win.vidadr; 1448 + v.base = (void *)saa->win.vidadr; 1449 1449 v.height = saa->win.sheight; 1450 1450 v.width = saa->win.swidth; 1451 1451 v.depth = saa->win.depth; ··· 1463 1463 if (copy_from_user(&v, arg, sizeof(v))) 1464 1464 return -EFAULT; 1465 1465 if (v.depth != 8 && v.depth != 15 && v.depth != 16 && 1466 - v.depth != 24 && v.depth != 32 && v.width > 16 && 1466 + v.depth != 24 && v.depth != 32 && v.width > 16 && 1467 1467 v.height > 16 && v.bytesperline > 16) 1468 1468 return -EINVAL; 1469 1469 if (v.base) 1470 - saa->win.vidadr = (unsigned long) v.base; 1470 + saa->win.vidadr = (unsigned long)v.base; 1471 1471 saa->win.sheight = v.height; 1472 1472 saa->win.swidth = v.width; 1473 1473 saa->win.bpp = ((v.depth + 7) & 0x38) / 8; 1474 1474 saa->win.depth = v.depth; 1475 1475 saa->win.bpl = v.bytesperline; 1476 1476 1477 - DEBUG(printk("Display at %p is %d by %d, bytedepth %d, bpl %d\n", 1478 - v.base, v.width, v.height, saa->win.bpp, saa->win.bpl)); 1477 + DEBUG(printk("Display at %p is %d by %d, bytedepth %d, " 1478 + "bpl %d\n", v.base, v.width, v.height, 1479 + saa->win.bpp, saa->win.bpl)); 1479 1480 saa7146_set_winsize(saa); 1480 1481 return 0; 1481 1482 } ··· 1504 1503 int i; 1505 1504 if (copy_from_user(&v, arg, sizeof(v))) 1506 1505 return -EFAULT; 1507 - i = (~(v.volume>>8))&0xff; 1506 + i = (~(v.volume >> 8)) & 0xff; 1508 1507 if (!HaveCS4341) { 1509 - if (v.flags & VIDEO_AUDIO_MUTE) { 1508 + if (v.flags & VIDEO_AUDIO_MUTE) 1510 1509 debiwrite(saa, debNormal, 1511 - IBM_MP2_FRNT_ATTEN, 1512 - 0xffff, 2); 1513 - } 1510 + IBM_MP2_FRNT_ATTEN, 0xffff, 2); 1514 1511 if (!(v.flags & VIDEO_AUDIO_MUTE)) 1515 1512 debiwrite(saa, debNormal, 1516 - IBM_MP2_FRNT_ATTEN, 1517 - 0x0000, 2); 1513 + IBM_MP2_FRNT_ATTEN, 0x0000, 2); 1518 1514 if (v.flags & VIDEO_AUDIO_VOLUME) 1519 1515 debiwrite(saa, debNormal, 1520 1516 IBM_MP2_FRNT_ATTEN, 1521 - (i<<8)|i, 2); 1517 + (i << 8) | i, 2); 1522 1518 } else { 1523 1519 if (v.flags & VIDEO_AUDIO_MUTE) 1524 1520 cs4341_setlevel(saa, 0xff, 0xff); ··· 1543 1545 case VIDIOCSPLAYMODE: 1544 1546 { 1545 1547 struct video_play_mode pmode; 1546 - if (copy_from_user((void *) &pmode, arg, 1547 - sizeof(struct video_play_mode))) 1548 + if (copy_from_user((void *)&pmode, arg, 1549 + sizeof(struct video_play_mode))) 1548 1550 return -EFAULT; 1549 1551 switch (pmode.mode) { 1550 - case VID_PLAY_VID_OUT_MODE: 1551 - if (pmode.p1 != VIDEO_MODE_NTSC && 1552 + case VID_PLAY_VID_OUT_MODE: 1553 + if (pmode.p1 != VIDEO_MODE_NTSC && 1552 1554 pmode.p1 != VIDEO_MODE_PAL) 1555 + return -EINVAL; 1556 + set_out_format(saa, pmode.p1); 1557 + return 0; 1558 + case VID_PLAY_GENLOCK: 1559 + debiwrite(saa, debNormal, XILINX_CTL0, 1560 + pmode.p1 ? 0x8000 : 0x8080, 2); 1561 + if (NewCard) 1562 + set_genlock_offset(saa, pmode.p2); 1563 + return 0; 1564 + case VID_PLAY_NORMAL: 1565 + debiwrite(saa, debNormal, 1566 + IBM_MP2_CHIP_CONTROL, ChipControl, 2); 1567 + ibm_send_command(saa, IBM_MP2_PLAY, 0, 0); 1568 + saa->playmode = pmode.mode; 1569 + return 0; 1570 + case VID_PLAY_PAUSE: 1571 + /* IBM removed the PAUSE command */ 1572 + /* they say use SINGLE_FRAME now */ 1573 + case VID_PLAY_SINGLE_FRAME: 1574 + ibm_send_command(saa, IBM_MP2_SINGLE_FRAME,0,0); 1575 + if (saa->playmode == pmode.mode) { 1576 + debiwrite(saa, debNormal, 1577 + IBM_MP2_CHIP_CONTROL, 1578 + ChipControl, 2); 1579 + } 1580 + saa->playmode = pmode.mode; 1581 + return 0; 1582 + case VID_PLAY_FAST_FORWARD: 1583 + ibm_send_command(saa, IBM_MP2_FAST_FORWARD,0,0); 1584 + saa->playmode = pmode.mode; 1585 + return 0; 1586 + case VID_PLAY_SLOW_MOTION: 1587 + ibm_send_command(saa, IBM_MP2_SLOW_MOTION, 1588 + pmode.p1, 0); 1589 + saa->playmode = pmode.mode; 1590 + return 0; 1591 + case VID_PLAY_IMMEDIATE_NORMAL: 1592 + /* ensure transfers resume */ 1593 + debiwrite(saa, debNormal, 1594 + IBM_MP2_CHIP_CONTROL, ChipControl, 2); 1595 + ibm_send_command(saa, IBM_MP2_IMED_NORM_PLAY, 1596 + 0, 0); 1597 + saa->playmode = VID_PLAY_NORMAL; 1598 + return 0; 1599 + case VID_PLAY_SWITCH_CHANNELS: 1600 + saa->audhead = saa->audtail = 0; 1601 + saa->vidhead = saa->vidtail = 0; 1602 + ibm_send_command(saa, IBM_MP2_FREEZE_FRAME,0,1); 1603 + ibm_send_command(saa, IBM_MP2_RESET_AUD_RATE, 1604 + 0, 1); 1605 + debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL, 1606 + 0, 2); 1607 + ibm_send_command(saa, IBM_MP2_CHANNEL_SWITCH, 1608 + 0, 1); 1609 + debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL, 1610 + ChipControl, 2); 1611 + ibm_send_command(saa, IBM_MP2_PLAY, 0, 0); 1612 + saa->playmode = VID_PLAY_NORMAL; 1613 + return 0; 1614 + case VID_PLAY_FREEZE_FRAME: 1615 + ibm_send_command(saa, IBM_MP2_FREEZE_FRAME,0,0); 1616 + saa->playmode = pmode.mode; 1617 + return 0; 1618 + case VID_PLAY_STILL_MODE: 1619 + ibm_send_command(saa, IBM_MP2_SET_STILL_MODE, 1620 + 0, 0); 1621 + saa->playmode = pmode.mode; 1622 + return 0; 1623 + case VID_PLAY_MASTER_MODE: 1624 + if (pmode.p1 == VID_PLAY_MASTER_NONE) 1625 + saa->boardcfg[1] = 0x13; 1626 + else if (pmode.p1 == VID_PLAY_MASTER_VIDEO) 1627 + saa->boardcfg[1] = 0x23; 1628 + else if (pmode.p1 == VID_PLAY_MASTER_AUDIO) 1629 + saa->boardcfg[1] = 0x43; 1630 + else 1631 + return -EINVAL; 1632 + debiwrite(saa, debNormal, 1633 + IBM_MP2_CHIP_CONTROL, ChipControl, 2); 1634 + return 0; 1635 + case VID_PLAY_ACTIVE_SCANLINES: 1636 + if (CurrentMode == VIDEO_MODE_PAL) { 1637 + if (pmode.p1 < 1 || pmode.p2 > 625) 1553 1638 return -EINVAL; 1554 - set_out_format(saa, pmode.p1); 1555 - return 0; 1556 - case VID_PLAY_GENLOCK: 1557 - debiwrite(saa, debNormal, 1558 - XILINX_CTL0, 1559 - (pmode.p1 ? 0x8000 : 0x8080), 1560 - 2); 1561 - if (NewCard) 1562 - set_genlock_offset(saa, 1563 - pmode.p2); 1564 - return 0; 1565 - case VID_PLAY_NORMAL: 1566 - debiwrite(saa, debNormal, 1567 - IBM_MP2_CHIP_CONTROL, 1568 - ChipControl, 2); 1569 - ibm_send_command(saa, 1570 - IBM_MP2_PLAY, 0, 0); 1571 - saa->playmode = pmode.mode; 1572 - return 0; 1573 - case VID_PLAY_PAUSE: 1574 - /* IBM removed the PAUSE command */ 1575 - /* they say use SINGLE_FRAME now */ 1576 - case VID_PLAY_SINGLE_FRAME: 1577 - ibm_send_command(saa, 1578 - IBM_MP2_SINGLE_FRAME, 1579 - 0, 0); 1580 - if (saa->playmode == pmode.mode) { 1581 - debiwrite(saa, debNormal, 1582 - IBM_MP2_CHIP_CONTROL, 1583 - ChipControl, 2); 1584 - } 1585 - saa->playmode = pmode.mode; 1586 - return 0; 1587 - case VID_PLAY_FAST_FORWARD: 1588 - ibm_send_command(saa, 1589 - IBM_MP2_FAST_FORWARD, 0, 0); 1590 - saa->playmode = pmode.mode; 1591 - return 0; 1592 - case VID_PLAY_SLOW_MOTION: 1593 - ibm_send_command(saa, 1594 - IBM_MP2_SLOW_MOTION, 1595 - pmode.p1, 0); 1596 - saa->playmode = pmode.mode; 1597 - return 0; 1598 - case VID_PLAY_IMMEDIATE_NORMAL: 1599 - /* ensure transfers resume */ 1600 - debiwrite(saa, debNormal, 1601 - IBM_MP2_CHIP_CONTROL, 1602 - ChipControl, 2); 1603 - ibm_send_command(saa, 1604 - IBM_MP2_IMED_NORM_PLAY, 0, 0); 1605 - saa->playmode = VID_PLAY_NORMAL; 1606 - return 0; 1607 - case VID_PLAY_SWITCH_CHANNELS: 1608 - saa->audhead = saa->audtail = 0; 1609 - saa->vidhead = saa->vidtail = 0; 1610 - ibm_send_command(saa, 1611 - IBM_MP2_FREEZE_FRAME, 0, 1); 1612 - ibm_send_command(saa, 1613 - IBM_MP2_RESET_AUD_RATE, 0, 1); 1614 - debiwrite(saa, debNormal, 1615 - IBM_MP2_CHIP_CONTROL, 0, 2); 1616 - ibm_send_command(saa, 1617 - IBM_MP2_CHANNEL_SWITCH, 0, 1); 1618 - debiwrite(saa, debNormal, 1619 - IBM_MP2_CHIP_CONTROL, 1620 - ChipControl, 2); 1621 - ibm_send_command(saa, 1622 - IBM_MP2_PLAY, 0, 0); 1623 - saa->playmode = VID_PLAY_NORMAL; 1624 - return 0; 1625 - case VID_PLAY_FREEZE_FRAME: 1626 - ibm_send_command(saa, 1627 - IBM_MP2_FREEZE_FRAME, 0, 0); 1628 - saa->playmode = pmode.mode; 1629 - return 0; 1630 - case VID_PLAY_STILL_MODE: 1631 - ibm_send_command(saa, 1632 - IBM_MP2_SET_STILL_MODE, 0, 0); 1633 - saa->playmode = pmode.mode; 1634 - return 0; 1635 - case VID_PLAY_MASTER_MODE: 1636 - if (pmode.p1 == VID_PLAY_MASTER_NONE) 1637 - saa->boardcfg[1] = 0x13; 1638 - else if (pmode.p1 == 1639 - VID_PLAY_MASTER_VIDEO) 1640 - saa->boardcfg[1] = 0x23; 1641 - else if (pmode.p1 == 1642 - VID_PLAY_MASTER_AUDIO) 1643 - saa->boardcfg[1] = 0x43; 1644 - else 1639 + saa->boardcfg[5] = pmode.p1; 1640 + saa->boardcfg[55] = (pmode.p1 + 1641 + (pmode.p2 / 2) - 1) & 0xff; 1642 + } else { 1643 + if (pmode.p1 < 4 || pmode.p2 > 525) 1645 1644 return -EINVAL; 1646 - debiwrite(saa, debNormal, 1647 - IBM_MP2_CHIP_CONTROL, 1648 - ChipControl, 2); 1649 - return 0; 1650 - case VID_PLAY_ACTIVE_SCANLINES: 1651 - if (CurrentMode == VIDEO_MODE_PAL) { 1652 - if (pmode.p1 < 1 || 1653 - pmode.p2 > 625) 1654 - return -EINVAL; 1655 - saa->boardcfg[5] = pmode.p1; 1656 - saa->boardcfg[55] = (pmode.p1 + 1657 - (pmode.p2/2) - 1) & 1658 - 0xff; 1659 - } else { 1660 - if (pmode.p1 < 4 || 1661 - pmode.p2 > 525) 1662 - return -EINVAL; 1663 - saa->boardcfg[4] = pmode.p1; 1664 - saa->boardcfg[54] = (pmode.p1 + 1665 - (pmode.p2/2) - 4) & 1666 - 0xff; 1667 - } 1668 - set_out_format(saa, CurrentMode); 1669 - case VID_PLAY_RESET: 1670 - return do_ibm_reset(saa); 1671 - case VID_PLAY_END_MARK: 1672 - if (saa->endmarktail < 1673 - saa->endmarkhead) { 1674 - if (saa->endmarkhead - 1645 + saa->boardcfg[4] = pmode.p1; 1646 + saa->boardcfg[54] = (pmode.p1 + 1647 + (pmode.p2 / 2) - 4) & 0xff; 1648 + } 1649 + set_out_format(saa, CurrentMode); 1650 + case VID_PLAY_RESET: 1651 + return do_ibm_reset(saa); 1652 + case VID_PLAY_END_MARK: 1653 + if (saa->endmarktail < saa->endmarkhead) { 1654 + if (saa->endmarkhead - 1675 1655 saa->endmarktail < 2) 1676 - return -ENOSPC; 1677 - } else if (saa->endmarkhead <= 1678 - saa->endmarktail) { 1679 - if (saa->endmarktail - 1680 - saa->endmarkhead > 1681 - (MAX_MARKS - 2)) 1682 - return -ENOSPC; 1683 - } else 1684 1656 return -ENOSPC; 1685 - saa->endmark[saa->endmarktail] = 1686 - saa->audtail; 1687 - saa->endmarktail++; 1688 - if (saa->endmarktail >= MAX_MARKS) 1689 - saa->endmarktail = 0; 1657 + } else if (saa->endmarkhead <=saa->endmarktail){ 1658 + if (saa->endmarktail - saa->endmarkhead 1659 + > (MAX_MARKS - 2)) 1660 + return -ENOSPC; 1661 + } else 1662 + return -ENOSPC; 1663 + saa->endmark[saa->endmarktail] = saa->audtail; 1664 + saa->endmarktail++; 1665 + if (saa->endmarktail >= MAX_MARKS) 1666 + saa->endmarktail = 0; 1690 1667 } 1691 1668 return -EINVAL; 1692 1669 } 1693 1670 case VIDIOCSWRITEMODE: 1694 1671 { 1695 1672 int mode; 1696 - if (copy_from_user((void *) &mode, arg, sizeof(int))) 1697 - return -EFAULT; 1673 + if (copy_from_user((void *)&mode, arg, sizeof(int))) 1674 + return -EFAULT; 1698 1675 if (mode == VID_WRITE_MPEG_AUD || 1699 - mode == VID_WRITE_MPEG_VID || 1700 - mode == VID_WRITE_CC || 1701 - mode == VID_WRITE_TTX || 1702 - mode == VID_WRITE_OSD) { 1676 + mode == VID_WRITE_MPEG_VID || 1677 + mode == VID_WRITE_CC || 1678 + mode == VID_WRITE_TTX || 1679 + mode == VID_WRITE_OSD) { 1703 1680 saa->writemode = mode; 1704 1681 return 0; 1705 1682 } ··· 1688 1715 if (copy_from_user(&ucode, arg, sizeof(ucode))) 1689 1716 return -EFAULT; 1690 1717 if (ucode.datasize > 65536 || ucode.datasize < 1024 || 1691 - strncmp(ucode.loadwhat, "dec", 3)) 1718 + strncmp(ucode.loadwhat, "dec", 3)) 1692 1719 return -EINVAL; 1693 1720 if ((udata = vmalloc(ucode.datasize)) == NULL) 1694 1721 return -ENOMEM; ··· 1697 1724 return -EFAULT; 1698 1725 } 1699 1726 ucode.data = udata; 1700 - if (!strncmp(ucode.loadwhat, "decoder.aud", 11) 1701 - || !strncmp(ucode.loadwhat, "decoder.vid", 11)) 1727 + if (!strncmp(ucode.loadwhat, "decoder.aud", 11) || 1728 + !strncmp(ucode.loadwhat, "decoder.vid", 11)) 1702 1729 i = initialize_ibmmpeg2(&ucode); 1703 1730 else 1704 1731 i = initialize_fpga(&ucode); ··· 1743 1770 return -EINVAL; 1744 1771 } 1745 1772 1746 - static ssize_t saa_read(struct file *file, char __user *buf, 1747 - size_t count, loff_t *ppos) 1773 + static ssize_t saa_read(struct file *file, char __user * buf, 1774 + size_t count, loff_t * ppos) 1748 1775 { 1749 1776 return -EINVAL; 1750 1777 } 1751 1778 1752 - static ssize_t saa_write(struct file *file, const char __user *buf, 1753 - size_t count, loff_t *ppos) 1779 + static ssize_t saa_write(struct file *file, const char __user * buf, 1780 + size_t count, loff_t * ppos) 1754 1781 { 1755 1782 struct saa7146 *saa = file->private_data; 1756 1783 unsigned long todo = count; ··· 1761 1788 if (saa->writemode == VID_WRITE_MPEG_AUD) { 1762 1789 spin_lock_irqsave(&saa->lock, flags); 1763 1790 if (saa->audhead <= saa->audtail) 1764 - blocksize = 65536-(saa->audtail - saa->audhead); 1791 + blocksize = 65536 - 1792 + (saa->audtail - saa->audhead); 1765 1793 else 1766 1794 blocksize = saa->audhead - saa->audtail; 1767 1795 spin_unlock_irqrestore(&saa->lock, flags); 1768 1796 if (blocksize < 16384) { 1769 1797 saawrite(SAA7146_PSR_DEBI_S | 1770 - SAA7146_PSR_PIN1, SAA7146_IER); 1798 + SAA7146_PSR_PIN1, SAA7146_IER); 1771 1799 saawrite(SAA7146_PSR_PIN1, SAA7146_PSR); 1772 1800 /* wait for buffer space to open */ 1773 1801 interruptible_sleep_on(&saa->audq); 1774 1802 } 1775 1803 spin_lock_irqsave(&saa->lock, flags); 1776 1804 if (saa->audhead <= saa->audtail) { 1777 - blocksize = 65536-(saa->audtail - saa->audhead); 1805 + blocksize = 65536 - 1806 + (saa->audtail - saa->audhead); 1778 1807 split = 65536 - saa->audtail; 1779 1808 } else { 1780 1809 blocksize = saa->audhead - saa->audtail; ··· 1791 1816 return -ENOSPC; 1792 1817 if (split < blocksize) { 1793 1818 if (copy_from_user(saa->audbuf + 1794 - saa->audtail, buf, split)) 1819 + saa->audtail, buf, split)) 1795 1820 return -EFAULT; 1796 1821 buf += split; 1797 1822 todo -= split; ··· 1799 1824 saa->audtail = 0; 1800 1825 } 1801 1826 if (copy_from_user(saa->audbuf + saa->audtail, buf, 1802 - blocksize)) 1827 + blocksize)) 1803 1828 return -EFAULT; 1804 1829 saa->audtail += blocksize; 1805 1830 todo -= blocksize; ··· 1808 1833 } else if (saa->writemode == VID_WRITE_MPEG_VID) { 1809 1834 spin_lock_irqsave(&saa->lock, flags); 1810 1835 if (saa->vidhead <= saa->vidtail) 1811 - blocksize=524288-(saa->vidtail - saa->vidhead); 1836 + blocksize = 524288 - 1837 + (saa->vidtail - saa->vidhead); 1812 1838 else 1813 1839 blocksize = saa->vidhead - saa->vidtail; 1814 1840 spin_unlock_irqrestore(&saa->lock, flags); 1815 1841 if (blocksize < 65536) { 1816 1842 saawrite(SAA7146_PSR_DEBI_S | 1817 - SAA7146_PSR_PIN1, SAA7146_IER); 1843 + SAA7146_PSR_PIN1, SAA7146_IER); 1818 1844 saawrite(SAA7146_PSR_PIN1, SAA7146_PSR); 1819 1845 /* wait for buffer space to open */ 1820 1846 interruptible_sleep_on(&saa->vidq); 1821 1847 } 1822 1848 spin_lock_irqsave(&saa->lock, flags); 1823 1849 if (saa->vidhead <= saa->vidtail) { 1824 - blocksize=524288-(saa->vidtail - saa->vidhead); 1850 + blocksize = 524288 - 1851 + (saa->vidtail - saa->vidhead); 1825 1852 split = 524288 - saa->vidtail; 1826 1853 } else { 1827 1854 blocksize = saa->vidhead - saa->vidtail; ··· 1838 1861 return -ENOSPC; 1839 1862 if (split < blocksize) { 1840 1863 if (copy_from_user(saa->vidbuf + 1841 - saa->vidtail, buf, split)) 1864 + saa->vidtail, buf, split)) 1842 1865 return -EFAULT; 1843 1866 buf += split; 1844 1867 todo -= split; ··· 1846 1869 saa->vidtail = 0; 1847 1870 } 1848 1871 if (copy_from_user(saa->vidbuf + saa->vidtail, buf, 1849 - blocksize)) 1872 + blocksize)) 1850 1873 return -EFAULT; 1851 1874 saa->vidtail += blocksize; 1852 1875 todo -= blocksize; ··· 1864 1887 debiwrite(saa, debNormal, IBM_MP2_OSD_LINK_ADDR, 0, 2); 1865 1888 debiwrite(saa, debNormal, IBM_MP2_MASK0, 0xc00d, 2); 1866 1889 debiwrite(saa, debNormal, IBM_MP2_DISP_MODE, 1867 - debiread(saa, debNormal, 1868 - IBM_MP2_DISP_MODE, 2) | 1, 2); 1890 + debiread(saa, debNormal, 1891 + IBM_MP2_DISP_MODE, 2) | 1, 2); 1869 1892 /* trigger osd data transfer */ 1870 1893 saawrite(SAA7146_PSR_DEBI_S | 1871 1894 SAA7146_PSR_PIN1, SAA7146_IER); ··· 1900 1923 return 0; 1901 1924 } 1902 1925 1903 - static struct file_operations saa_fops = 1904 - { 1905 - .owner = THIS_MODULE, 1906 - .open = saa_open, 1907 - .release = saa_release, 1908 - .ioctl = saa_ioctl, 1909 - .compat_ioctl = v4l_compat_ioctl32, 1910 - .read = saa_read, 1911 - .llseek = no_llseek, 1912 - .write = saa_write, 1913 - .mmap = saa_mmap, 1926 + static struct file_operations saa_fops = { 1927 + .owner = THIS_MODULE, 1928 + .open = saa_open, 1929 + .release = saa_release, 1930 + .ioctl = saa_ioctl, 1931 + .compat_ioctl = v4l_compat_ioctl32, 1932 + .read = saa_read, 1933 + .llseek = no_llseek, 1934 + .write = saa_write, 1935 + .mmap = saa_mmap, 1914 1936 }; 1915 1937 1916 1938 /* template for video_device-structure */ 1917 - static struct video_device saa_template = 1918 - { 1919 - .name = "SAA7146A", 1920 - .type = VID_TYPE_CAPTURE | VID_TYPE_OVERLAY, 1921 - .hardware = VID_HARDWARE_SAA7146, 1922 - .fops = &saa_fops, 1923 - .minor = -1, 1939 + static struct video_device saa_template = { 1940 + .name = "SAA7146A", 1941 + .type = VID_TYPE_CAPTURE | VID_TYPE_OVERLAY, 1942 + .hardware = VID_HARDWARE_SAA7146, 1943 + .fops = &saa_fops, 1944 + .minor = -1, 1924 1945 }; 1925 1946 1926 1947 static int __devinit configure_saa7146(struct pci_dev *pdev, int num) 1927 1948 { 1928 1949 int retval; 1929 1950 struct saa7146 *saa = pci_get_drvdata(pdev); 1930 - 1951 + 1931 1952 saa->endmarkhead = saa->endmarktail = 0; 1932 1953 saa->win.x = saa->win.y = 0; 1933 1954 saa->win.width = saa->win.cropwidth = 720; ··· 1965 1990 dev_err(&pdev->dev, "%d: pci_enable_device failed!\n", num); 1966 1991 goto err; 1967 1992 } 1968 - 1993 + 1969 1994 saa->id = pdev->device; 1970 1995 saa->irq = pdev->irq; 1971 1996 saa->video_dev.minor = -1; ··· 1995 2020 pci_set_master(pdev); 1996 2021 retval = video_register_device(&saa->video_dev, VFL_TYPE_GRABBER, 1997 2022 video_nr); 1998 - if (retval < 0) { 2023 + if (retval < 0) { 1999 2024 dev_err(&pdev->dev, "%d: error in registering video device!\n", 2000 2025 num); 2001 2026 goto errio; ··· 2030 2055 saawrite(0x00000000, SAA7146_DD1_STREAM_A); 2031 2056 saawrite(0x00000000, SAA7146_BRS_CTRL); 2032 2057 saawrite(0x80400040, SAA7146_BCS_CTRL); 2033 - saawrite(0x0000e000 /*| (1<<29)*/, SAA7146_HPS_CTRL); 2058 + saawrite(0x0000e000 /*| (1<<29) */ , SAA7146_HPS_CTRL); 2034 2059 saawrite(0x00000060, SAA7146_CLIP_FORMAT_CTRL); 2035 2060 saawrite(0x00000000, SAA7146_ACON1); 2036 2061 saawrite(0x00000000, SAA7146_ACON2); 2037 2062 saawrite(0x00000600, SAA7146_I2C_STATUS); 2038 2063 saawrite(((SAA7146_MC2_UPLD_D1_B | SAA7146_MC2_UPLD_D1_A | 2039 - SAA7146_MC2_UPLD_BRS | SAA7146_MC2_UPLD_HPS_H | 2040 - SAA7146_MC2_UPLD_HPS_V | SAA7146_MC2_UPLD_DMA2 | 2041 - SAA7146_MC2_UPLD_DMA1 | SAA7146_MC2_UPLD_I2C) << 16) | 0xffff, 2042 - SAA7146_MC2); 2064 + SAA7146_MC2_UPLD_BRS | SAA7146_MC2_UPLD_HPS_H | 2065 + SAA7146_MC2_UPLD_HPS_V | SAA7146_MC2_UPLD_DMA2 | 2066 + SAA7146_MC2_UPLD_DMA1 | SAA7146_MC2_UPLD_I2C) << 16) | 0xffff, 2067 + SAA7146_MC2); 2043 2068 /* setup arbitration control registers */ 2044 2069 saawrite(0x1412121a, SAA7146_PCI_BT_V1); 2045 2070 ··· 2077 2102 saawrite(virt_to_bus(saa->dmavid2), SAA7146_BASE_EVEN2); 2078 2103 saawrite(virt_to_bus(saa->dmavid2) + 128, SAA7146_BASE_ODD2); 2079 2104 saawrite(virt_to_bus(saa->dmavid2) + VIDEO_CLIPMAP_SIZE, 2080 - SAA7146_PROT_ADDR2); 2105 + SAA7146_PROT_ADDR2); 2081 2106 saawrite(256, SAA7146_PITCH2); 2082 - saawrite(4, SAA7146_PAGE2); /* dma direction: read, no byteswap */ 2107 + saawrite(4, SAA7146_PAGE2); /* dma direction: read, no byteswap */ 2083 2108 saawrite(((SAA7146_MC2_UPLD_DMA2) << 16) | SAA7146_MC2_UPLD_DMA2, 2084 2109 SAA7146_MC2); 2085 2110 I2CBusScan(saa); ··· 2184 2209 { PCI_DEVICE(PCI_VENDOR_ID_PHILIPS, PCI_DEVICE_ID_PHILIPS_SAA7146) }, 2185 2210 { 0 } 2186 2211 }; 2212 + 2187 2213 MODULE_DEVICE_TABLE(pci, stradis_pci_tbl); 2188 2214 2189 2215 static struct pci_driver stradis_driver = { 2190 - .name = "stradis", 2191 - .id_table = stradis_pci_tbl, 2192 - .probe = stradis_probe, 2193 - .remove = __devexit_p(stradis_remove) 2216 + .name = "stradis", 2217 + .id_table = stradis_pci_tbl, 2218 + .probe = stradis_probe, 2219 + .remove = __devexit_p(stradis_remove) 2194 2220 }; 2195 2221 2196 2222 int __init stradis_init(void) ··· 2206 2230 2207 2231 return retval; 2208 2232 } 2209 - 2210 2233 2211 2234 void __exit stradis_exit(void) 2212 2235 {