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