开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
bttv-driver.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：79k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

bttv-driver.c：源码内容
  1. /*
  2.     bttv - Bt848 frame grabber driver
  4.     Copyright (C) 1996,97,98 Ralph  Metzler (rjkm@thp.uni-koeln.de)
  5.                            & Marcus Metzler (mocm@thp.uni-koeln.de)
  6.     (c) 1999,2000 Gerd Knorr <kraxel@goldbach.in-berlin.de>
  8.     This program is free software; you can redistribute it and/or modify
  9.     it under the terms of the GNU General Public License as published by
  10.     the Free Software Foundation; either version 2 of the License, or
  11.     (at your option) any later version.
  13.     This program is distributed in the hope that it will be useful,
  14.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.     GNU General Public License for more details.
  18.     You should have received a copy of the GNU General Public License
  19.     along with this program; if not, write to the Free Software
  20.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21. */
  23. #include <linux/version.h>
  24. #include <linux/module.h>
  25. #include <linux/delay.h>
  26. #include <linux/errno.h>
  27. #include <linux/fs.h>
  28. #include <linux/kernel.h>
  29. #include <linux/major.h>
  30. #include <linux/slab.h>
  31. #include <linux/mm.h>
  32. #include <linux/poll.h>
  33. #include <linux/pci.h>
  34. #include <linux/signal.h>
  35. #include <asm/io.h>
  36. #include <linux/ioport.h>
  37. #include <asm/pgtable.h>
  38. #include <asm/page.h>
  39. #include <linux/sched.h>
  40. #include <linux/types.h>
  41. #include <linux/wrapper.h>
  42. #include <linux/interrupt.h>
  43. #include <linux/kmod.h>
  44. #include <linux/vmalloc.h>
  45. #include <linux/init.h>
  46. #include <linux/pagemap.h>
  48. #include "bttvp.h"
  49. #include "tuner.h"
  51. #define DEBUG(x) /* Debug driver */
  52. #define MIN(a,b) (((a)>(b))?(b):(a))
  53. #define MAX(a,b) (((a)>(b))?(a):(b))
  55. static void bt848_set_risc_jmps(struct bttv *btv, int state);
  57. int bttv_num; /* number of Bt848s in use */
  58. struct bttv bttvs[BTTV_MAX];
  60. /* configuration variables */
  61. #if defined(__sparc__) || defined(__powerpc__) || defined(__hppa__)
  62. static unsigned int bigendian=1;
  63. #else
  64. static unsigned int bigendian=0;
  65. #endif
  66. static unsigned int radio[BTTV_MAX];
  67. static unsigned int fieldnr = 0;
  68. static unsigned int irq_debug = 0;
  69. static unsigned int gbuffers = 4;
  70. static unsigned int gbufsize = BTTV_MAX_FBUF;
  71. static int latency = -1;
  73. static unsigned int combfilter = 0;
  74. static unsigned int lumafilter = 0;
  75. static unsigned int automute = 1;
  76. static unsigned int chroma_agc = 0;
  77. static unsigned int adc_crush = 1;
  78. static int video_nr = -1;
  79. static int radio_nr = -1;
  80. static int vbi_nr = -1;
  81. unsigned int bttv_debug = 0;
  82. unsigned int bttv_verbose = 1;
  83. unsigned int bttv_gpio = 0;
  85. /* insmod options */
  86. MODULE_PARM(radio,"1-" __stringify(BTTV_MAX) "i");
  87. MODULE_PARM_DESC(radio,"The TV card supports radio, default is 0 (no)");
  88. MODULE_PARM(bigendian,"i");
  89. MODULE_PARM_DESC(bigendian,"byte order of the framebuffer, default is native endian");
  90. MODULE_PARM(fieldnr,"i");
  91. MODULE_PARM_DESC(fieldnr,"count fields, default is 0 (no)");
  92. MODULE_PARM(bttv_verbose,"i");
  93. MODULE_PARM_DESC(bttv_verbose,"verbose startup messages, default is 1 (yes)");
  94. MODULE_PARM(bttv_gpio,"i");
  95. MODULE_PARM_DESC(bttv_gpio,"log gpio changes, default is 0 (no)");
  96. MODULE_PARM(bttv_debug,"i");
  97. MODULE_PARM_DESC(bttv_debug,"debug messages, default is 0 (no)");
  98. MODULE_PARM(irq_debug,"i");
  99. MODULE_PARM_DESC(irq_debug,"irq handler debug messages, default is 0 (no)");
  100. MODULE_PARM(gbuffers,"i");
  101. MODULE_PARM_DESC(gbuffers,"number of capture buffers, default is 2 (64 max)");
  102. MODULE_PARM(gbufsize,"i");
  103. MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 0x208000");
  104. MODULE_PARM(latency,"i");
  105. MODULE_PARM_DESC(latency,"pci latency timer");
  107. MODULE_PARM(combfilter,"i");
  108. MODULE_PARM(lumafilter,"i");
  109. MODULE_PARM(automute,"i");
  110. MODULE_PARM_DESC(automute,"mute audio on bad/missing video signal, default is 1 (yes)");
  111. MODULE_PARM(chroma_agc,"i");
  112. MODULE_PARM_DESC(chroma_agc,"enables the AGC of chroma signal, default is 0 (no)");
  113. MODULE_PARM(adc_crush,"i");
  114. MODULE_PARM_DESC(adc_crush,"enables the luminance ADC crush, default is 1 (yes)");
  116. MODULE_PARM(video_nr,"i");
  117. MODULE_PARM(radio_nr,"i");
  118. MODULE_PARM(vbi_nr,"i");
  120. MODULE_DESCRIPTION("bttv - v4l driver module for bt848/878 based cards");
  121. MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
  122. MODULE_LICENSE("GPL");
  124. /* kernel args */
  125. #ifndef MODULE
  126. static int __init p_radio(char *str) { return bttv_parse(str,BTTV_MAX,radio); }
  127. __setup("bttv.radio=", p_radio);
  128. #endif
  130. #define I2C_TIMING (0x7<<4)
  131. #define I2C_DELAY   10
  133. #define I2C_SET(CTRL,DATA) 
  134.     { btwrite((CTRL<<1)|(DATA), BT848_I2C); udelay(I2C_DELAY); }
  135. #define I2C_GET()   (btread(BT848_I2C)&1)
  137. #define BURSTOFFSET 76
  138. #define BTTV_ERRORS 5
  141. /*******************************/
  142. /* Memory management functions */
  143. /*******************************/
  146. static inline unsigned long kvirt_to_bus(unsigned long adr) 
  147. {
  148.         unsigned long kva;
  150. kva = (unsigned long)page_address(vmalloc_to_page((void *)adr));
  151. kva |= adr & (PAGE_SIZE-1); /* restore the offset */   
  152. return virt_to_bus((void *)kva);
  153. }
  155. /* Here we want the physical address of the memory.
  156.  * This is used when initializing the contents of the
  157.  * area and marking the pages as reserved.
  158.  */
  159. static inline unsigned long kvirt_to_pa(unsigned long adr) 
  160. {
  161.         unsigned long kva;
  163. kva = (unsigned long)page_address(vmalloc_to_page((void *)adr));
  164. kva |= adr & (PAGE_SIZE-1); /* restore the offset */
  165. return __pa(kva);
  166. }
  168. static void * rvmalloc(signed long size)
  169. {
  170. struct page *page;
  171. void * mem;
  172. unsigned long adr;
  174. mem=vmalloc_32(size);
  175. if (NULL == mem)
  176. printk(KERN_INFO "bttv: vmalloc_32(%ld) failedn",size);
  177. else {
  178. /* Clear the ram out, no junk to the user */
  179. memset(mem, 0, size);
  180.         adr=(unsigned long) mem;
  181. while (size > 0) {
  182. page = vmalloc_to_page((void *)adr);
  183. mem_map_reserve(page);
  184. adr+=PAGE_SIZE;
  185. size-=PAGE_SIZE;
  186. }
  187. }
  188. return mem;
  189. }
  191. static void rvfree(void * mem, signed long size)
  192. {
  193. struct page *page;
  194.         unsigned long adr;
  195.         
  196. if (mem) {
  197.         adr=(unsigned long) mem;
  198. while (size > 0) {
  199. page = vmalloc_to_page((void *)adr);
  200. mem_map_unreserve(page);
  201. adr+=PAGE_SIZE;
  202. size-=PAGE_SIZE;
  203. }
  204. vfree(mem);
  205. }
  206. }
  210. /*
  211.  * Create the giant waste of buffer space we need for now
  212.  * until we get DMA to user space sorted out (probably 2.3.x)
  213.  *
  214.  * We only create this as and when someone uses mmap
  215.  */
  216.  
  217. static int fbuffer_alloc(struct bttv *btv)
  218. {
  219. if(!btv->fbuffer)
  220. btv->fbuffer=(unsigned char *) rvmalloc(gbuffers*gbufsize);
  221. else
  222. printk(KERN_ERR "bttv%d: Double alloc of fbuffer!n",
  223. btv->nr);
  224. if(!btv->fbuffer)
  225. return -ENOBUFS;
  226. return 0;
  227. }
  229. /* ----------------------------------------------------------------------- */
  231. void bttv_gpio_tracking(struct bttv *btv, char *comment)
  232. {
  233. unsigned int outbits, data;
  234. outbits = btread(BT848_GPIO_OUT_EN);
  235. data    = btread(BT848_GPIO_DATA);
  236. printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]n",
  237.        btv->nr,outbits,data & outbits, data & ~outbits, comment);
  238. }
  240. static char *audio_modes[] = { "audio: tuner", "audio: radio", "audio: extern",
  241.        "audio: intern", "audio: off" };
  243. static void audio(struct bttv *btv, int mode)
  244. {
  245. if (bttv_tvcards[btv->type].gpiomask)
  246. btaor(bttv_tvcards[btv->type].gpiomask,
  247.       ~bttv_tvcards[btv->type].gpiomask,
  248.       BT848_GPIO_OUT_EN);
  250. switch (mode)
  251. {
  252.         case AUDIO_MUTE:
  253.                         btv->audio|=AUDIO_MUTE;
  254. break;
  255.   case AUDIO_UNMUTE:
  256. btv->audio&=~AUDIO_MUTE;
  257. mode=btv->audio;
  258. break;
  259. case AUDIO_OFF:
  260. mode=AUDIO_OFF;
  261. break;
  262. case AUDIO_ON:
  263. mode=btv->audio;
  264. break;
  265. default:
  266. btv->audio&=AUDIO_MUTE;
  267. btv->audio|=mode;
  268. break;
  269. }
  270.         /* if audio mute or not in H-lock, turn audio off */
  271. if ((btv->audio&AUDIO_MUTE))
  272.         mode=AUDIO_OFF;
  273.         if ((mode == AUDIO_TUNER) && (btv->radio))
  274. mode = AUDIO_RADIO;
  275. if (bttv_tvcards[btv->type].gpiomask)
  276. btaor(bttv_tvcards[btv->type].audiomux[mode],
  277.       ~bttv_tvcards[btv->type].gpiomask,
  278.       BT848_GPIO_DATA);
  279. if (bttv_gpio)
  280. bttv_gpio_tracking(btv,audio_modes[mode]);
  281. if (!in_interrupt())
  282. bttv_call_i2c_clients(btv,AUDC_SET_INPUT,&(mode));
  283. }
  286. static inline void bt848_dma(struct bttv *btv, uint state)
  287. {
  288. if (state)
  289. btor(3, BT848_GPIO_DMA_CTL);
  290. else
  291. btand(~3, BT848_GPIO_DMA_CTL);
  292. }
  295. /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC*/
  297. /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C 
  298.    PLL_X = Reference pre-divider (0=1, 1=2) 
  299.    PLL_C = Post divider (0=6, 1=4)
  300.    PLL_I = Integer input 
  301.    PLL_F = Fractional input 
  302.    
  303.    F_input = 28.636363 MHz: 
  304.    PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
  305. */
  307. static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
  308. {
  309.         unsigned char fl, fh, fi;
  310.         
  311.         /* prevent overflows */
  312.         fin/=4;
  313.         fout/=4;
  315.         fout*=12;
  316.         fi=fout/fin;
  318.         fout=(fout%fin)*256;
  319.         fh=fout/fin;
  321.         fout=(fout%fin)*256;
  322.         fl=fout/fin;
  324.         /*printk("0x%02x 0x%02x 0x%02xn", fi, fh, fl);*/
  325.         btwrite(fl, BT848_PLL_F_LO);
  326.         btwrite(fh, BT848_PLL_F_HI);
  327.         btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
  328. }
  330. static int set_pll(struct bttv *btv)
  331. {
  332.         int i;
  333. unsigned long tv;
  335.         if (!btv->pll.pll_crystal)
  336.                 return 0;
  338.         if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
  339.                 /* no PLL needed */
  340.                 if (btv->pll.pll_current == 0) {
  341.                         /* printk ("bttv%d: PLL: is offn",btv->nr); */
  342.                         return 0;
  343.                 }
  344. if (bttv_verbose)
  345. printk ("bttv%d: PLL: switching offn",btv->nr);
  346.                 btwrite(0x00,BT848_TGCTRL);
  347.                 btwrite(0x00,BT848_PLL_XCI);
  348.                 btv->pll.pll_current = 0;
  349.                 return 0;
  350.         }
  352.         if (btv->pll.pll_ofreq == btv->pll.pll_current) {
  353.                 /* printk("bttv%d: PLL: no change requiredn",btv->nr); */
  354.                 return 1;
  355.         }
  357.         if (bttv_verbose)
  358. printk("bttv%d: PLL: %d => %d ... ",btv->nr,
  359.        btv->pll.pll_ifreq, btv->pll.pll_ofreq);
  361. set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
  363. /*  Let other people run while the PLL stabilizes */
  364. tv=jiffies+HZ/10;       /* .1 seconds */
  365. do
  366. {
  367. schedule();
  368. }
  369. while(time_before(jiffies,tv));
  371.         for (i=0; i<100; i++) 
  372.         {
  373.                 if ((btread(BT848_DSTATUS)&BT848_DSTATUS_PLOCK))
  374.                         btwrite(0,BT848_DSTATUS);
  375.                 else
  376.                 {
  377.                         btwrite(0x08,BT848_TGCTRL);
  378.                         btv->pll.pll_current = btv->pll.pll_ofreq;
  379. if (bttv_verbose)
  380. printk("okn");
  381.                         return 1;
  382.                 }
  383.                 mdelay(10);
  384.         }
  385.         btv->pll.pll_current = 0;
  386. if (bttv_verbose)
  387. printk("oopsn");
  388.         return -1;
  389. }
  391. static void bt848_muxsel(struct bttv *btv, unsigned int input)
  392. {
  393.         /* needed by RemoteVideo MX */
  394. if (bttv_tvcards[btv->type].gpiomask2)
  395. btaor(bttv_tvcards[btv->type].gpiomask2,
  396.       ~bttv_tvcards[btv->type].gpiomask2,
  397.       BT848_GPIO_OUT_EN);
  399. /* This seems to get rid of some synchronization problems */
  400. btand(~(3<<5), BT848_IFORM);
  401. mdelay(10);
  403. input %= bttv_tvcards[btv->type].video_inputs;
  404. if (input==bttv_tvcards[btv->type].svhs)
  405. {
  406. btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
  407. btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
  408. }
  409. else
  410. {
  411. btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
  412. btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
  413. }
  415. btaor((bttv_tvcards[btv->type].muxsel[input]&3)<<5, ~(3<<5), BT848_IFORM);
  416. audio(btv, (input!=bttv_tvcards[btv->type].tuner) ?
  417.               AUDIO_EXTERN : AUDIO_TUNER);
  419. if (bttv_tvcards[btv->type].gpiomask2)
  420. btaor(bttv_tvcards[btv->type].muxsel[input]>>4,
  421.       ~bttv_tvcards[btv->type].gpiomask2,
  422.       BT848_GPIO_DATA);
  424. /* card specific hook */
  425. if (bttv_tvcards[btv->type].muxsel_hook)
  426. bttv_tvcards[btv->type].muxsel_hook(btv, input);
  428. if (bttv_gpio)
  429. bttv_gpio_tracking(btv,"muxsel");
  431. }
  434. struct tvnorm
  435. {
  436.         u32 Fsc;
  437.         u16 swidth, sheight; /* scaled standard width, height */
  438. u16 totalwidth;
  439. u8 adelay, bdelay, iform;
  440. u32 scaledtwidth;
  441. u16 hdelayx1, hactivex1;
  442. u16 vdelay;
  443.         u8 vbipack;
  444. };
  446. static struct tvnorm tvnorms[] = {
  447. /* PAL-BDGHI */
  448.         /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
  449.   /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
  450.         { 35468950,
  451.           924, 576, 1135, 0x7f, 0x72, (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
  452.           1135, 186, 924,
  453. #ifdef VIDEODAT_HACK
  454.   VBI_MAXLINES*2,
  455. #else
  456.   0x20,
  457. #endif
  458.   255},
  460. /* NTSC */
  461. { 28636363,
  462.           768, 480,  910, 0x68, 0x5d, (BT848_IFORM_NTSC|BT848_IFORM_XT0),
  463.           910, 128, 910, 0x1a, 144},
  464. #if 0
  465. /* SECAM EAST */
  466. { 35468950, 
  467.           768, 576, 1135, 0x7f, 0xb0, (BT848_IFORM_SECAM|BT848_IFORM_XT1),
  468.   944, 186, 922, 0x20, 255},
  469. #else
  470. /* SECAM L */
  471.         { 35468950,
  472.           924, 576, 1135, 0x7f, 0xb0, (BT848_IFORM_SECAM|BT848_IFORM_XT1),
  473.           1135, 186, 922, 0x20, 255},
  474. #endif
  475.         /* PAL-NC */
  476.         { 28636363,
  477.           640, 576,  910, 0x68, 0x5d, (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
  478.           780, 130, 734, 0x1a, 144},
  479. /* PAL-M */
  480. { 28636363, 
  481.           640, 480, 910, 0x68, 0x5d, (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
  482.   780, 135, 754, 0x1a, 144},
  483. /* PAL-N */
  484. { 35468950, 
  485.           768, 576, 1135, 0x7f, 0x72, (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
  486.   944, 186, 922, 0x20, 144},
  487. /* NTSC-Japan */
  488. { 28636363,
  489.           640, 480,  910, 0x68, 0x5d, (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
  490.   780, 135, 754, 0x16, 144},
  491. };
  492. #define TVNORMS (sizeof(tvnorms)/sizeof(tvnorm))
  493. #define VBI_SPL 2044
  495. /* RISC command to write one VBI data line */
  496. #define VBI_RISC BT848_RISC_WRITE|VBI_SPL|BT848_RISC_EOL|BT848_RISC_SOL
  498. static void make_vbitab(struct bttv *btv)
  499. {
  500. int i;
  501. unsigned int *po=(unsigned int *) btv->vbi_odd;
  502. unsigned int *pe=(unsigned int *) btv->vbi_even;
  503.   
  504. if (bttv_debug > 1)
  505. printk("bttv%d: vbi1: po=%08lx pe=%08lxn",
  506.        btv->nr,virt_to_bus(po), virt_to_bus(pe));
  507.         
  508. *(po++)=cpu_to_le32(BT848_RISC_SYNC|BT848_FIFO_STATUS_FM1); *(po++)=0;
  509. for (i=0; i<VBI_MAXLINES; i++) 
  510. {
  511. *(po++)=cpu_to_le32(VBI_RISC);
  512. *(po++)=cpu_to_le32(kvirt_to_bus((unsigned long)btv->vbibuf+i*2048));
  513. }
  514. *(po++)=cpu_to_le32(BT848_RISC_JUMP);
  515. *(po++)=cpu_to_le32(virt_to_bus(btv->risc_jmp+4));
  517. *(pe++)=cpu_to_le32(BT848_RISC_SYNC|BT848_FIFO_STATUS_FM1); *(pe++)=0;
  518. for (i=VBI_MAXLINES; i<VBI_MAXLINES*2; i++) 
  519. {
  520. *(pe++)=cpu_to_le32(VBI_RISC);
  521. *(pe++)=cpu_to_le32(kvirt_to_bus((unsigned long)btv->vbibuf+i*2048));
  522. }
  523. *(pe++)=cpu_to_le32(BT848_RISC_JUMP|BT848_RISC_IRQ|(0x01<<16));
  524. *(pe++)=cpu_to_le32(virt_to_bus(btv->risc_jmp+10));
  526. if (bttv_debug > 1)
  527. printk("bttv%d: vbi2: po=%08lx pe=%08lxn",
  528.        btv->nr,virt_to_bus(po), virt_to_bus(pe));
  529. }
  531. static int fmtbppx2[16] = {
  532.         8, 6, 4, 4, 4, 3, 2, 2, 4, 3, 0, 0, 0, 0, 2, 0 
  533. };
  535. static int palette2fmt[] = {
  536. 0,
  537. BT848_COLOR_FMT_Y8,
  538. BT848_COLOR_FMT_RGB8,
  539. BT848_COLOR_FMT_RGB16,
  540. BT848_COLOR_FMT_RGB24,
  541. BT848_COLOR_FMT_RGB32,
  542. BT848_COLOR_FMT_RGB15,
  543. BT848_COLOR_FMT_YUY2,
  544. BT848_COLOR_FMT_YUY2,
  545. -1,
  546. -1,
  547. -1,
  548. BT848_COLOR_FMT_RAW,
  549. BT848_COLOR_FMT_YCrCb422,
  550. BT848_COLOR_FMT_YCrCb411,
  551. BT848_COLOR_FMT_YCrCb422,
  552. BT848_COLOR_FMT_YCrCb411,
  553. };
  554. #define PALETTEFMT_MAX (sizeof(palette2fmt)/sizeof(int))
  556. static int make_rawrisctab(struct bttv *btv, unsigned int *ro,
  557.    unsigned int *re, unsigned int *vbuf)
  558. {
  559.         unsigned long line;
  560. unsigned long bpl=1024; /* bytes per line */
  561. unsigned long vadr=(unsigned long) vbuf;
  563. *(ro++)=cpu_to_le32(BT848_RISC_SYNC|BT848_FIFO_STATUS_FM1); 
  564.         *(ro++)=cpu_to_le32(0);
  565. *(re++)=cpu_to_le32(BT848_RISC_SYNC|BT848_FIFO_STATUS_FM1);
  566.         *(re++)=cpu_to_le32(0);
  567.   
  568.         /* In PAL 650 blocks of 256 DWORDs are sampled, but only if VDELAY
  569.            is 2 and without separate VBI grabbing.
  570.            We'll have to handle this inside the IRQ handler ... */
  572. for (line=0; line < 640; line++)
  573. {
  574.                 *(ro++)=cpu_to_le32(BT848_RISC_WRITE|bpl|BT848_RISC_SOL|BT848_RISC_EOL);
  575.                 *(ro++)=cpu_to_le32(kvirt_to_bus(vadr));
  576.                 *(re++)=cpu_to_le32(BT848_RISC_WRITE|bpl|BT848_RISC_SOL|BT848_RISC_EOL);
  577.                 *(re++)=cpu_to_le32(kvirt_to_bus(vadr+gbufsize/2));
  578.                 vadr+=bpl;
  579. }
  581. *(ro++)=cpu_to_le32(BT848_RISC_JUMP);
  582. *(ro++)=cpu_to_le32(btv->bus_vbi_even);
  583. *(re++)=cpu_to_le32(BT848_RISC_JUMP|BT848_RISC_IRQ|(2<<16));
  584. *(re++)=cpu_to_le32(btv->bus_vbi_odd);
  586. return 0;
  587. }
  589. static int  make_prisctab(struct bttv *btv, unsigned int *ro,
  590.                           unsigned int *re, 
  591.                           unsigned int *vbuf, unsigned short width,
  592.                           unsigned short height, unsigned short fmt)
  593. {
  594.         unsigned long line, lmask;
  595. unsigned long bl, blcr, blcb, rcmd;
  596. unsigned long todo;
  597. unsigned int **rp;
  598. int inter;
  599. unsigned long cbadr, cradr;
  600. unsigned long vadr=(unsigned long) vbuf;
  601. int shift, csize;
  603. if (bttv_debug > 1)
  604. printk("bttv%d: prisc1: ro=%08lx re=%08lxn",
  605.        btv->nr,virt_to_bus(ro), virt_to_bus(re));
  607. switch(fmt)
  608. {
  609.         case VIDEO_PALETTE_YUV422P:
  610.                 csize=(width*height)>>1;
  611.                 shift=1;
  612.                 lmask=0;
  613.                 break;
  614.                 
  615.         case VIDEO_PALETTE_YUV411P:
  616.                 csize=(width*height)>>2;
  617.                 shift=2;
  618.                 lmask=0;
  619.                 break;
  620.  
  621.  case VIDEO_PALETTE_YUV420P:
  622.                 csize=(width*height)>>2;
  623.                 shift=1;
  624.                 lmask=1;
  625.                 break;
  626.                 
  627.  case VIDEO_PALETTE_YUV410P:
  628.                 csize=(width*height)>>4;
  629.                 shift=2;
  630.                 lmask=3;
  631.                 break;
  632.                 
  633.         default:
  634.                 return -1;
  635. }
  636. cbadr=vadr+(width*height);
  637. cradr=cbadr+csize;
  638. inter = (height>tvnorms[btv->win.norm].sheight/2) ? 1 : 0;
  640. *(ro++)=cpu_to_le32(BT848_RISC_SYNC|BT848_FIFO_STATUS_FM3);
  641.         *(ro++)=0;
  642. *(re++)=cpu_to_le32(BT848_RISC_SYNC|BT848_FIFO_STATUS_FM3);
  643.         *(re++)=0;
  644.   
  645. for (line=0; line < (height<<(1^inter)); line++)
  646. {
  647. if(line==height)
  648. {
  649. vadr+=csize<<1;
  650. cbadr=vadr+(width*height);
  651. cradr=cbadr+csize;
  652. }
  653.         if (inter) 
  654.         rp= (line&1) ? &re : &ro;
  655. else 
  656.                 rp= (line>=height) ? &ro : &re; 
  657.                 
  659.         if(line&lmask)
  660.          rcmd=BT848_RISC_WRITE1S23|BT848_RISC_SOL;
  661.         else
  662.          rcmd=BT848_RISC_WRITE123|BT848_RISC_SOL;
  664.         todo=width;
  665. while(todo)
  666. {
  667.                  bl=PAGE_SIZE-((PAGE_SIZE-1)&vadr);
  668.                  blcr=(PAGE_SIZE-((PAGE_SIZE-1)&cradr))<<shift;
  669.  blcb=(PAGE_SIZE-((PAGE_SIZE-1)&cbadr))<<shift;
  670.  bl=(blcr<bl) ? blcr : bl;
  671.  bl=(blcb<bl) ? blcb : bl;
  672.  bl=(bl>todo) ? todo : bl;
  673.  blcr=bl>>shift;
  674.  blcb=blcr;
  675.  /* bl now containts the longest row that can be written */
  676.  todo-=bl;
  677.  if(!todo) rcmd|=BT848_RISC_EOL; /* if this is the last EOL */
  678.  
  679.  *((*rp)++)=cpu_to_le32(rcmd|bl);
  680.  *((*rp)++)=cpu_to_le32(blcb|(blcr<<16));
  681.  *((*rp)++)=cpu_to_le32(kvirt_to_bus(vadr));
  682.  vadr+=bl;
  683.  if((rcmd&(15<<28))==BT848_RISC_WRITE123)
  684.  {
  685.   *((*rp)++)=cpu_to_le32(kvirt_to_bus(cbadr));
  686.   cbadr+=blcb;
  687.   *((*rp)++)=cpu_to_le32(kvirt_to_bus(cradr));
  688.   cradr+=blcr;
  689.  }
  690.  
  691.  rcmd&=~BT848_RISC_SOL; /* only the first has SOL */
  692. }
  693. }
  695. *(ro++)=cpu_to_le32(BT848_RISC_JUMP);
  696. *(ro++)=cpu_to_le32(btv->bus_vbi_even);
  697. *(re++)=cpu_to_le32(BT848_RISC_JUMP|BT848_RISC_IRQ|(2<<16));
  698. *(re++)=cpu_to_le32(btv->bus_vbi_odd);
  700. if (bttv_debug > 1)
  701. printk("bttv%d: prisc2: ro=%08lx re=%08lxn",
  702.        btv->nr,virt_to_bus(ro), virt_to_bus(re));
  704. return 0;
  705. }
  706.  
  707. static int  make_vrisctab(struct bttv *btv, unsigned int *ro,
  708.                           unsigned int *re, 
  709.                           unsigned int *vbuf, unsigned short width,
  710.                           unsigned short height, unsigned short palette)
  711. {
  712.         unsigned long line;
  713. unsigned long bpl;  /* bytes per line */
  714. unsigned long bl;
  715. unsigned long todo;
  716. unsigned int **rp;
  717. int inter;
  718. unsigned long vadr=(unsigned long) vbuf;
  720.         if (palette==VIDEO_PALETTE_RAW) 
  721.                 return make_rawrisctab(btv, ro, re, vbuf);
  722.         if (palette>=VIDEO_PALETTE_PLANAR)
  723.                 return make_prisctab(btv, ro, re, vbuf, width, height, palette);
  725. if (bttv_debug > 1)
  726. printk("bttv%d: vrisc1: ro=%08lx re=%08lxn",
  727.        btv->nr,virt_to_bus(ro), virt_to_bus(re));
  729. inter = (height>tvnorms[btv->win.norm].sheight/2) ? 1 : 0;
  730. bpl=width*fmtbppx2[palette2fmt[palette]&0xf]/2;
  732. *(ro++)=cpu_to_le32(BT848_RISC_SYNC|BT848_FIFO_STATUS_FM1); 
  733.         *(ro++)=cpu_to_le32(0);
  734. *(re++)=cpu_to_le32(BT848_RISC_SYNC|BT848_FIFO_STATUS_FM1);
  735.         *(re++)=cpu_to_le32(0);
  736.   
  737. for (line=0; line < (height<<(1^inter)); line++)
  738. {
  739.         if (inter) 
  740.         rp= (line&1) ? &re : &ro;
  741. else 
  742.                 rp= (line>=height) ? &ro : &re; 
  744. bl=PAGE_SIZE-((PAGE_SIZE-1)&vadr);
  745. if (bpl<=bl)
  746.                 {
  747.         *((*rp)++)=cpu_to_le32(BT848_RISC_WRITE|BT848_RISC_SOL|
  748.         BT848_RISC_EOL|bpl); 
  749. *((*rp)++)=cpu_to_le32(kvirt_to_bus(vadr));
  750. vadr+=bpl;
  751. }
  752. else
  753. {
  754.         todo=bpl;
  755.         *((*rp)++)=cpu_to_le32(BT848_RISC_WRITE|BT848_RISC_SOL|bl);
  756. *((*rp)++)=cpu_to_le32(kvirt_to_bus(vadr));
  757. vadr+=bl;
  758. todo-=bl;
  759. while (todo>PAGE_SIZE)
  760. {
  761.         *((*rp)++)=cpu_to_le32(BT848_RISC_WRITE|PAGE_SIZE);
  762. *((*rp)++)=cpu_to_le32(kvirt_to_bus(vadr));
  763. vadr+=PAGE_SIZE;
  764. todo-=PAGE_SIZE;
  765. }
  766. *((*rp)++)=cpu_to_le32(BT848_RISC_WRITE|BT848_RISC_EOL|todo);
  767. *((*rp)++)=cpu_to_le32(kvirt_to_bus(vadr));
  768. vadr+=todo;
  769. }
  770. }
  772. *(ro++)=cpu_to_le32(BT848_RISC_JUMP);
  773. *(ro++)=cpu_to_le32(btv->bus_vbi_even);
  774. *(re++)=cpu_to_le32(BT848_RISC_JUMP|BT848_RISC_IRQ|(2<<16));
  775. *(re++)=cpu_to_le32(btv->bus_vbi_odd);
  777. if (bttv_debug > 1)
  778. printk("bttv%d: vrisc2: ro=%08lx re=%08lxn",
  779.        btv->nr,virt_to_bus(ro), virt_to_bus(re));
  781. return 0;
  782. }
  784. static unsigned char lmaskt[8] = 
  785. { 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80};
  786. static unsigned char rmaskt[8] = 
  787. { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
  789. static void clip_draw_rectangle(unsigned char *clipmap, int x, int y, int w, int h)
  790. {
  791.         unsigned char lmask, rmask, *p;
  792.         int W, l, r;
  793. int i;
  795. if (bttv_debug > 1)
  796. printk("bttv clip: %dx%d+%d+%dn",w,h,x,y);
  798. /* bitmap is fixed width, 128 bytes (1024 pixels represented) */
  799.         if (x<0)
  800.         {
  801.                 w+=x;
  802.                 x=0;
  803.         }
  804.         if (y<0)
  805.         {
  806.                 h+=y;
  807.                 y=0;
  808.         }
  809. if (w < 0 || h < 0) /* catch bad clips */
  810. return;
  811. /* out of range data should just fall through */
  812.         if (y+h>=625)
  813.                 h=625-y;
  814.         if (x+w>=1024)
  815.                 w=1024-x;
  817.         l=x>>3;
  818.         r=(x+w-1)>>3;
  819.         W=r-l-1;
  820.         lmask=lmaskt[x&7];
  821.         rmask=rmaskt[(x+w-1)&7];
  822.         p=clipmap+128*y+l;
  823.         
  824.         if (W>0) 
  825.         {
  826.                 for (i=0; i<h; i++, p+=128) 
  827.                 {
  828.                         *p|=lmask;
  829.                         memset(p+1, 0xff, W);
  830.                         p[W+1]|=rmask;
  831.                 }
  832.         } else if (!W) {
  833.                 for (i=0; i<h; i++, p+=128) 
  834.                 {
  835.                         p[0]|=lmask;
  836.                         p[1]|=rmask;
  837.                 }
  838.         } else {
  839.                 for (i=0; i<h; i++, p+=128) 
  840.                         p[0]|=lmask&rmask;
  841.         }
  842.                
  844. }
  846. static void make_clip_tab(struct bttv *btv, struct video_clip *cr, int ncr)
  847. {
  848. int i, line, x, y, bpl, width, height, inter, maxw;
  849. unsigned int bpp, dx, sx, **rp, *ro, *re, flags, len;
  850. unsigned long adr;
  851. unsigned char *clipmap, *clipline, cbit, lastbit, outofmem;
  853. /* take care: bpp != btv->win.bpp is allowed here */
  854. bpp = fmtbppx2[btv->win.color_fmt&0xf]/2;
  855. bpl=btv->win.bpl;
  856. adr=btv->win.vidadr + btv->win.x * btv->win.bpp + btv->win.y * bpl;
  857. inter=(btv->win.interlace&1)^1;
  858. width=btv->win.width;
  859. height=btv->win.height;
  860. if (bttv_debug > 1)
  861. printk("bttv%d: clip1: pal=%d size=%dx%d, bpl=%d bpp=%dn",
  862.        btv->nr,btv->picture.palette,width,height,bpl,bpp);
  863. if(width > 1023)
  864. width = 1023; /* sanity check */
  865. if(height > 625)
  866. height = 625; /* sanity check */
  867. ro=btv->risc_scr_odd;
  868. re=btv->risc_scr_even;
  870. if (bttv_debug)
  871. printk("bttv%d: clip: ro=%08lx re=%08lxn",
  872.        btv->nr,virt_to_bus(ro), virt_to_bus(re));
  874. if ((clipmap=vmalloc(VIDEO_CLIPMAP_SIZE))==NULL) {
  875. /* can't clip, don't generate any risc code */
  876. *(ro++)=cpu_to_le32(BT848_RISC_JUMP);
  877. *(ro++)=cpu_to_le32(btv->bus_vbi_even);
  878. *(re++)=cpu_to_le32(BT848_RISC_JUMP);
  879. *(re++)=cpu_to_le32(btv->bus_vbi_odd);
  880. }
  881. if (ncr < 0) { /* bitmap was pased */
  882. memcpy(clipmap, (unsigned char *)cr, VIDEO_CLIPMAP_SIZE);
  883. } else { /* convert rectangular clips to a bitmap */
  884. memset(clipmap, 0, VIDEO_CLIPMAP_SIZE); /* clear map */
  885. for (i=0; i<ncr; i++)
  886. clip_draw_rectangle(clipmap, cr[i].x, cr[i].y,
  887. cr[i].width, cr[i].height);
  888. }
  889. /* clip against viewing window AND screen 
  890.    so we do not have to rely on the user program
  891.  */
  892. maxw = (bpl - btv->win.x * btv->win.bpp) / bpp;
  893. clip_draw_rectangle(clipmap, (width > maxw) ? maxw : width,
  894.     0, 1024, 768);
  895. clip_draw_rectangle(clipmap,0,(btv->win.y+height>btv->win.sheight) ?
  896.     (btv->win.sheight-btv->win.y) : height,1024,768);
  897. if (btv->win.x<0)
  898. clip_draw_rectangle(clipmap, 0, 0, -(btv->win.x), 768);
  899. if (btv->win.y<0)
  900. clip_draw_rectangle(clipmap, 0, 0, 1024, -(btv->win.y));
  902. *(ro++)=cpu_to_le32(BT848_RISC_SYNC|BT848_FIFO_STATUS_FM1);
  903.         *(ro++)=cpu_to_le32(0);
  904. *(re++)=cpu_to_le32(BT848_RISC_SYNC|BT848_FIFO_STATUS_FM1);
  905.         *(re++)=cpu_to_le32(0);
  907. /* translate bitmap to risc code */
  908.         for (line=outofmem=0; line < (height<<inter) && !outofmem; line++)
  909.         {
  910. y = line>>inter;
  911. rp= (line&1) ? &re : &ro;
  912. clipline = clipmap + (y<<7); /* running pointers ... */
  913. lastbit = *clipline & 1;
  914. for(x=dx=0,sx=0; x<=width && !outofmem;) {
  915. if (0 == (x&7)) {
  916. /* check bytes not bits if we can ... */
  917. if (lastbit) {
  918. while (0xff==*clipline && x<width-8) {
  919. x  += 8;
  920. dx += 8;
  921. clipline++;
  922. }
  923. } else {
  924. while (0x00==*clipline && x<width-8) {
  925. x  += 8;
  926. dx += 8;
  927. clipline++;
  928. }
  929. }
  930. }
  931. cbit = *clipline & (1<<(x&7));
  932. if (x < width && !lastbit == !cbit) {
  933. dx++;
  934. } else {
  935. /* generate the dma controller code */
  936. len = dx * bpp;
  937. flags = ((bpp==4) ? BT848_RISC_BYTE3 : 0);
  938. flags |= ((!sx) ? BT848_RISC_SOL : 0);
  939. flags |= ((sx + dx == width) ? BT848_RISC_EOL : 0);
  940. if (!lastbit) {
  941. *((*rp)++)=cpu_to_le32(BT848_RISC_WRITE|flags|len);
  942. *((*rp)++)=cpu_to_le32(adr + bpp * sx);
  943. } else {
  944. *((*rp)++)=cpu_to_le32(BT848_RISC_SKIP|flags|len);
  945. }
  946. lastbit=cbit;
  947. sx += dx;
  948. dx = 1;
  949. if (ro - btv->risc_scr_odd>(RISCMEM_LEN>>3) - 16)
  950. outofmem++;
  951. if (re - btv->risc_scr_even>(RISCMEM_LEN>>3) - 16)
  952. outofmem++;
  953. }
  954. x++;
  955. if (0 == (x&7))
  956. clipline++;
  957. }
  958. if ((!inter)||(line&1))
  959.                         adr+=bpl;
  960. }
  962. vfree(clipmap);
  963. /* outofmem flag relies on the following code to discard extra data */
  964. *(ro++)=cpu_to_le32(BT848_RISC_JUMP);
  965. *(ro++)=cpu_to_le32(btv->bus_vbi_even);
  966. *(re++)=cpu_to_le32(BT848_RISC_JUMP);
  967. *(re++)=cpu_to_le32(btv->bus_vbi_odd);
  969. if (bttv_debug > 1)
  970. printk("bttv%d: clip2: pal=%d size=%dx%d, bpl=%d bpp=%dn",
  971.        btv->nr,btv->picture.palette,width,height,bpl,bpp);
  972. }
  974. /*
  975.  * Set the registers for the size we have specified. Don't bother
  976.  * trying to understand this without the BT848 manual in front of
  977.  * you [AC]. 
  978.  *
  979.  * PS: The manual is free for download in .pdf format from 
  980.  * www.brooktree.com - nicely done those folks.
  981.  */
  982.  
  983. static inline void bt848_set_eogeo(struct bttv *btv, struct tvnorm *tvn,
  984.    int odd, int width, int height)
  985. {
  986.         u16 vscale, hscale;
  987. u32 xsf, sr;
  988. u16 hdelay;
  989. u8 crop, vtc;
  990. int inter = (height>tvn->sheight/2) ? 0 : 1;
  991.         int off = odd ? 0x80 : 0x00;
  993. xsf = (width*tvn->scaledtwidth)/tvn->swidth;
  994. hscale = ((tvn->totalwidth*4096UL)/xsf-4096);
  995. hdelay =  tvn->hdelayx1;
  996. hdelay =  (hdelay*width)/tvn->swidth;
  997. hdelay &= 0x3fe;
  998. sr=((tvn->sheight>>inter)*512)/height-512;
  999. vscale=(0x10000UL-sr)&0x1fff;
  1000. crop=((width>>8)&0x03)|((hdelay>>6)&0x0c)|
  1001. ((tvn->sheight>>4)&0x30)|((tvn->vdelay>>2)&0xc0);
  1002. vscale |= inter ? (BT848_VSCALE_INT<<8) : 0;
  1004. if (combfilter) {
  1005. /* Some people say interpolation looks bad ... */
  1006. vtc = (width < 193) ? 2 : ((width < 385) ? 1 : 0);
  1007. if (width < 769)
  1008. btor(BT848_VSCALE_COMB, BT848_E_VSCALE_HI+off);
  1009. else
  1010. btand(~BT848_VSCALE_COMB, BT848_E_VSCALE_HI+off);
  1011. } else {
  1012. vtc = 0;
  1013. btand(~BT848_VSCALE_COMB, BT848_E_VSCALE_HI+off);
  1014. }
  1016. btwrite(vtc, BT848_E_VTC+off);
  1017. btwrite(hscale>>8, BT848_E_HSCALE_HI+off);
  1018. btwrite(hscale&0xff, BT848_E_HSCALE_LO+off);
  1019. btaor((vscale>>8), 0xe0, BT848_E_VSCALE_HI+off);
  1020. btwrite(vscale&0xff, BT848_E_VSCALE_LO+off);
  1021. btwrite(width&0xff, BT848_E_HACTIVE_LO+off);
  1022. btwrite(hdelay&0xff, BT848_E_HDELAY_LO+off);
  1023. btwrite(tvn->sheight&0xff, BT848_E_VACTIVE_LO+off);
  1024. btwrite(tvn->vdelay&0xff, BT848_E_VDELAY_LO+off);
  1025. btwrite(crop, BT848_E_CROP+off);
  1026. }
  1029. static void bt848_set_geo(struct bttv *btv)
  1030. {
  1031. u16 ewidth, eheight, owidth, oheight;
  1032. u16 format, bswap;
  1033. struct tvnorm *tvn;
  1035. tvn=&tvnorms[btv->win.norm];
  1037. btwrite(tvn->adelay, BT848_ADELAY);
  1038. btwrite(tvn->bdelay, BT848_BDELAY);
  1039. btaor(tvn->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH), BT848_IFORM);
  1040. btwrite(tvn->vbipack, BT848_VBI_PACK_SIZE);
  1041. btwrite(1, BT848_VBI_PACK_DEL);
  1043.         btv->pll.pll_ofreq = tvn->Fsc;
  1044. if (!in_interrupt())
  1045. set_pll(btv);
  1047. btv->win.interlace = (btv->win.height>tvn->sheight/2) ? 1 : 0;
  1049. if (0 == btv->risc_cap_odd &&
  1050.     0 == btv->risc_cap_even) {
  1051. /* overlay only */
  1052. owidth  = btv->win.width;
  1053. oheight = btv->win.height;
  1054. ewidth  = btv->win.width;
  1055. eheight = btv->win.height;
  1056. format  = btv->win.color_fmt;
  1057. bswap   = btv->fb_color_ctl;
  1058. } else if (-1 != btv->gq_grab      &&
  1059.    0  == btv->risc_cap_odd &&
  1060.    !btv->win.interlace     &&
  1061.    btv->scr_on) {
  1062. /* odd field -> overlay, even field -> capture */
  1063. owidth  = btv->win.width;
  1064. oheight = btv->win.height;
  1065. ewidth  = btv->gbuf[btv->gq_grab].width;
  1066. eheight = btv->gbuf[btv->gq_grab].height;
  1067. format  = (btv->win.color_fmt & 0xf0) |
  1068. (btv->gbuf[btv->gq_grab].fmt & 0x0f);
  1069. bswap   = btv->fb_color_ctl & 0x0a;
  1070. } else {
  1071. /* capture only */
  1072. owidth  = btv->gbuf[btv->gq_grab].width;
  1073. oheight = btv->gbuf[btv->gq_grab].height;
  1074. ewidth  = btv->gbuf[btv->gq_grab].width;
  1075. eheight = btv->gbuf[btv->gq_grab].height;
  1076. format  = btv->gbuf[btv->gq_grab].fmt;
  1077. bswap   = 0;
  1078. }
  1080. /* program odd + even fields */
  1081. bt848_set_eogeo(btv, tvn, 1, owidth, oheight);
  1082. bt848_set_eogeo(btv, tvn, 0, ewidth, eheight);
  1084. btwrite(format, BT848_COLOR_FMT);
  1085. btwrite(bswap | BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
  1086. }
  1089. static int bpp2fmt[4] = {
  1090.         BT848_COLOR_FMT_RGB8, BT848_COLOR_FMT_RGB16,
  1091.         BT848_COLOR_FMT_RGB24, BT848_COLOR_FMT_RGB32 
  1092. };
  1094. static void bt848_set_winsize(struct bttv *btv)
  1095. {
  1096.         unsigned short format;
  1098. if (btv->picture.palette > 0 && btv->picture.palette <= VIDEO_PALETTE_YUV422) {
  1099. /* format set by VIDIOCSPICT */
  1100. format = palette2fmt[btv->picture.palette];
  1101. } else {
  1102. /* use default for the given color depth */
  1103. format = (btv->win.depth==15) ? BT848_COLOR_FMT_RGB15 :
  1104. bpp2fmt[(btv->win.bpp-1)&3];
  1105. }
  1106. btv->win.color_fmt = format;
  1107. if (bigendian &&
  1108.     format == BT848_COLOR_FMT_RGB32) {
  1109. btv->fb_color_ctl =
  1110. BT848_COLOR_CTL_WSWAP_ODD |
  1111. BT848_COLOR_CTL_WSWAP_EVEN |
  1112. BT848_COLOR_CTL_BSWAP_ODD |
  1113. BT848_COLOR_CTL_BSWAP_EVEN;
  1114.         } else if (bigendian &&
  1115.    (format == BT848_COLOR_FMT_RGB16 ||
  1116.                     format == BT848_COLOR_FMT_RGB15)) {
  1117. btv->fb_color_ctl =
  1118. BT848_COLOR_CTL_BSWAP_ODD |
  1119. BT848_COLOR_CTL_BSWAP_EVEN;
  1120.         } else {
  1121. btv->fb_color_ctl = 0;
  1122. }
  1124. /* RGB8 seems to be a 9x5x5 GRB color cube starting at
  1125.  * color 16. Why the h... can't they even mention this in the
  1126.  * data sheet?  [AC - because it's a standard format so I guess
  1127.  * it never occurred to them]
  1128.  * Enable dithering in this mode.
  1129.  */
  1131. if (format==BT848_COLOR_FMT_RGB8)
  1132.                 btand(~BT848_CAP_CTL_DITH_FRAME, BT848_CAP_CTL); 
  1133. else
  1134.         btor(BT848_CAP_CTL_DITH_FRAME, BT848_CAP_CTL);
  1136.         bt848_set_geo(btv);
  1137. }
  1139. /*
  1140.  * Grab into virtual memory.
  1141.  */
  1143. static int vgrab(struct bttv *btv, struct video_mmap *mp)
  1144. {
  1145. unsigned int *ro, *re;
  1146. unsigned int *vbuf;
  1147. unsigned long flags;
  1149. if(btv->fbuffer==NULL)
  1150. {
  1151. if(fbuffer_alloc(btv))
  1152. return -ENOBUFS;
  1153. }
  1155. if(mp->frame >= gbuffers || mp->frame < 0)
  1156. return -EINVAL;
  1157. if(btv->gbuf[mp->frame].stat != GBUFFER_UNUSED)
  1158. return -EBUSY;
  1160. if(mp->height < 32 || mp->width < 48)
  1161. return -EINVAL;
  1162. if (mp->format >= PALETTEFMT_MAX)
  1163. return -EINVAL;
  1165. if (mp->height*mp->width*fmtbppx2[palette2fmt[mp->format]&0x0f]/2
  1166.     > gbufsize)
  1167. return -EINVAL;
  1168. if (-1 == palette2fmt[mp->format])
  1169. return -EINVAL;
  1171. /*
  1172.  * Ok load up the BT848
  1173.  */
  1174.  
  1175. vbuf=(unsigned int *)(btv->fbuffer+gbufsize*mp->frame);
  1176. ro=btv->gbuf[mp->frame].risc;
  1177. re=ro+2048;
  1178.         make_vrisctab(btv, ro, re, vbuf, mp->width, mp->height, mp->format);
  1180. if (bttv_debug)
  1181. printk("bttv%d: cap vgrab: queue %d (%d:%dx%d)n",
  1182.        btv->nr,mp->frame,mp->format,mp->width,mp->height);
  1183.         spin_lock_irqsave(&btv->s_lock, flags); 
  1184.         btv->gbuf[mp->frame].stat    = GBUFFER_GRABBING;
  1185. btv->gbuf[mp->frame].fmt     = palette2fmt[mp->format];
  1186. btv->gbuf[mp->frame].width   = mp->width;
  1187. btv->gbuf[mp->frame].height  = mp->height;
  1188. btv->gbuf[mp->frame].ro      = virt_to_bus(ro);
  1189. btv->gbuf[mp->frame].re      = virt_to_bus(re);
  1191. #if 1
  1192. if (mp->height <= tvnorms[btv->win.norm].sheight/2 &&
  1193.     mp->format != VIDEO_PALETTE_RAW)
  1194. btv->gbuf[mp->frame].ro = 0;
  1195. #endif
  1197. if (-1 == btv->gq_grab && btv->gq_in == btv->gq_out) {
  1198. btv->gq_start = 1;
  1199. btv->risc_jmp[12]=cpu_to_le32(BT848_RISC_JUMP|(0x8<<16)|BT848_RISC_IRQ);
  1200.         }
  1201. btv->gqueue[btv->gq_in++] = mp->frame;
  1202. btv->gq_in = btv->gq_in % MAX_GBUFFERS;
  1204. btor(3, BT848_CAP_CTL);
  1205. btor(3, BT848_GPIO_DMA_CTL);
  1206. spin_unlock_irqrestore(&btv->s_lock, flags);
  1207. return 0;
  1208. }
  1210. static long bttv_write(struct video_device *v, const char *buf, unsigned long count, int nonblock)
  1211. {
  1212. return -EINVAL;
  1213. }
  1215. static long bttv_read(struct video_device *v, char *buf, unsigned long count, int nonblock)
  1216. {
  1217. struct bttv *btv= (struct bttv *)v;
  1218. int q;
  1219. unsigned long todo;
  1220. DECLARE_WAITQUEUE(wait, current);
  1222. /* BROKEN: RETURNS VBI WHEN IT SHOULD RETURN GRABBED VIDEO FRAME */
  1223. todo=count;
  1224. while (todo && todo>(q=VBIBUF_SIZE-btv->vbip)) 
  1225. {
  1226. if(copy_to_user((void *) buf, (void *) btv->vbibuf+btv->vbip, q))
  1227. return -EFAULT;
  1228. todo-=q;
  1229. buf+=q;
  1231. add_wait_queue(&btv->vbiq, &wait);
  1232. current->state = TASK_INTERRUPTIBLE;
  1233. if (todo && q==VBIBUF_SIZE-btv->vbip) 
  1234. {
  1235. if(nonblock)
  1236. {
  1237. remove_wait_queue(&btv->vbiq, &wait);
  1238.                                 current->state = TASK_RUNNING;
  1239. if(count==todo)
  1240. return -EWOULDBLOCK;
  1241. return count-todo;
  1242. }
  1243. schedule();
  1244. if(signal_pending(current))
  1245. {
  1246. remove_wait_queue(&btv->vbiq, &wait);
  1247.                                 current->state = TASK_RUNNING;
  1249. if(todo==count)
  1250. return -EINTR;
  1251. else
  1252. return count-todo;
  1253. }
  1254. }
  1255. remove_wait_queue(&btv->vbiq, &wait);
  1256.                 current->state = TASK_RUNNING;
  1257. }
  1258. if (todo) 
  1259. {
  1260. if(copy_to_user((void *) buf, (void *) btv->vbibuf+btv->vbip, todo))
  1261. return -EFAULT;
  1262. btv->vbip+=todo;
  1263. }
  1264. return count;
  1265. }
  1267. static inline void burst(int on)
  1268. {
  1269. tvnorms[0].scaledtwidth = 1135 - (on?BURSTOFFSET-2:0);
  1270. tvnorms[0].hdelayx1     = 186  - (on?BURSTOFFSET  :0);
  1271. tvnorms[2].scaledtwidth = 1135 - (on?BURSTOFFSET-2:0);
  1272. tvnorms[2].hdelayx1     = 186  - (on?BURSTOFFSET  :0);
  1273. }
  1275. /*
  1276.  * called from irq handler on fatal errors.  Takes the grabber chip
  1277.  * offline, flag it needs a reinitialization (which can't be done
  1278.  * from irq context) and wake up all sleeping proccesses.  They would
  1279.  * block forever else.  We also need someone who actually does the
  1280.  * reinitialization from process context...
  1281.  */
  1282. static void bt848_offline(struct bttv *btv)
  1283. {
  1284. int i;
  1285. spin_lock(&btv->s_lock);
  1287. /* cancel all outstanding grab requests */
  1288. btv->gq_in = 0;
  1289. btv->gq_out = 0;
  1290. btv->gq_grab = -1;
  1291. for (i = 0; i < gbuffers; i++)
  1292. if (btv->gbuf[i].stat == GBUFFER_GRABBING)
  1293. btv->gbuf[i].stat = GBUFFER_ERROR;
  1295. /* disable screen overlay and DMA */
  1296. btv->risc_cap_odd  = 0;
  1297. btv->risc_cap_even = 0;
  1298. bt848_set_risc_jmps(btv,0);
  1300. /* flag the chip needs a restart */
  1301. btv->needs_restart = 1;
  1302. spin_unlock(&btv->s_lock);
  1304. wake_up_interruptible(&btv->vbiq);
  1305. wake_up_interruptible(&btv->capq);
  1306. }
  1308. static void bt848_restart(struct bttv *btv)
  1309. {
  1310.   unsigned long irq_flags;
  1312. if (bttv_verbose)
  1313. printk("bttv%d: resetting chipn",btv->nr);
  1314. btwrite(0xfffffUL, BT848_INT_STAT);
  1315. btand(~15, BT848_GPIO_DMA_CTL);
  1316. btwrite(0, BT848_SRESET);
  1317. btwrite(virt_to_bus(btv->risc_jmp+2),
  1318. BT848_RISC_STRT_ADD);
  1320. /* enforce pll reprogramming */
  1321. btv->pll.pll_current = 0;
  1322. set_pll(btv);
  1324. spin_lock_irqsave(&btv->s_lock, irq_flags);
  1325. btv->errors = 0;
  1326. btv->needs_restart = 0;
  1327. bt848_set_geo(btv);
  1328. bt848_set_risc_jmps(btv,-1);
  1329. spin_unlock_irqrestore(&btv->s_lock, irq_flags);
  1330. }
  1332. /*
  1333.  * Open a bttv card. Right now the flags stuff is just playing
  1334.  */
  1336. static int bttv_open(struct video_device *dev, int flags)
  1337. {
  1338. struct bttv *btv = (struct bttv *)dev;
  1339.         int i,ret;
  1341. ret = -EBUSY;
  1342. if (bttv_debug)
  1343. printk("bttv%d: open calledn",btv->nr);
  1345. down(&btv->lock);
  1346. if (btv->user)
  1347. goto out_unlock;
  1349. btv->fbuffer=(unsigned char *) rvmalloc(gbuffers*gbufsize);
  1350. ret = -ENOMEM;
  1351. if (!btv->fbuffer)
  1352. goto out_unlock;
  1354.         btv->gq_in = 0;
  1355.         btv->gq_out = 0;
  1356. btv->gq_grab = -1;
  1357.         for (i = 0; i < gbuffers; i++)
  1358.                 btv->gbuf[i].stat = GBUFFER_UNUSED;
  1360. if (btv->needs_restart)
  1361. bt848_restart(btv);
  1362.         burst(0);
  1363. set_pll(btv);
  1364.         btv->user++;
  1365. up(&btv->lock);
  1366.         return 0;
  1368.  out_unlock:
  1369. up(&btv->lock);
  1370. return ret;
  1371. }
  1373. static void bttv_close(struct video_device *dev)
  1374. {
  1375. struct bttv *btv=(struct bttv *)dev;
  1376.   unsigned long irq_flags;
  1377. int need_wait;
  1379. down(&btv->lock);
  1380. btv->user--;
  1381. spin_lock_irqsave(&btv->s_lock, irq_flags);
  1382. need_wait = (-1 != btv->gq_grab);
  1383. btv->gq_start = 0;
  1384. btv->gq_in = 0;
  1385. btv->gq_out = 0;
  1386. btv->gq_grab = -1;
  1387. btv->scr_on = 0;
  1388. btv->risc_cap_odd = 0;
  1389. btv->risc_cap_even = 0;
  1390. bt848_set_risc_jmps(btv,-1);
  1391. spin_unlock_irqrestore(&btv->s_lock, irq_flags);
  1393. /*
  1394.  * A word of warning. At this point the chip
  1395.  * is still capturing because its FIFO hasn't emptied
  1396.  * and the DMA control operations are posted PCI 
  1397.  * operations.
  1398.  */
  1400. btread(BT848_I2C);  /* This fixes the PCI posting delay */
  1402. if (need_wait) {
  1403. /*
  1404.  * This is sucky but right now I can't find a good way to
  1405.  * be sure its safe to free the buffer. We wait 5-6 fields
  1406.  * which is more than sufficient to be sure.
  1407.  */
  1408. current->state = TASK_UNINTERRUPTIBLE;
  1409. schedule_timeout(HZ/10); /* Wait 1/10th of a second */
  1410. }
  1412. /*
  1413.  * We have allowed it to drain.
  1414.  */
  1416. if(btv->fbuffer)
  1417. rvfree((void *) btv->fbuffer, gbuffers*gbufsize);
  1418. btv->fbuffer=0;
  1419. up(&btv->lock);
  1420. }
  1423. /***********************************/
  1424. /* ioctls and supporting functions */
  1425. /***********************************/
  1427. static inline void bt848_bright(struct bttv *btv, uint bright)
  1428. {
  1429. btwrite(bright&0xff, BT848_BRIGHT);
  1430. }
  1432. static inline void bt848_hue(struct bttv *btv, uint hue)
  1433. {
  1434. btwrite(hue&0xff, BT848_HUE);
  1435. }
  1437. static inline void bt848_contrast(struct bttv *btv, uint cont)
  1438. {
  1439. unsigned int conthi;
  1441. conthi=(cont>>6)&4;
  1442. btwrite(cont&0xff, BT848_CONTRAST_LO);
  1443. btaor(conthi, ~4, BT848_E_CONTROL);
  1444. btaor(conthi, ~4, BT848_O_CONTROL);
  1445. }
  1447. static inline void bt848_sat_u(struct bttv *btv, unsigned long data)
  1448. {
  1449. u32 datahi;
  1451. datahi=(data>>7)&2;
  1452. btwrite(data&0xff, BT848_SAT_U_LO);
  1453. btaor(datahi, ~2, BT848_E_CONTROL);
  1454. btaor(datahi, ~2, BT848_O_CONTROL);
  1455. }
  1457. static inline void bt848_sat_v(struct bttv *btv, unsigned long data)
  1458. {
  1459. u32 datahi;
  1461. datahi=(data>>8)&1;
  1462. btwrite(data&0xff, BT848_SAT_V_LO);
  1463. btaor(datahi, ~1, BT848_E_CONTROL);
  1464. btaor(datahi, ~1, BT848_O_CONTROL);
  1465. }
  1467. /*
  1468.  * ioctl routine
  1469.  */
  1471. static int bttv_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
  1472. {
  1473. struct bttv *btv=(struct bttv *)dev;
  1474.   unsigned long irq_flags;
  1475.   int i,ret = 0;
  1477. if (bttv_debug > 1)
  1478. printk("bttv%d: ioctl 0x%xn",btv->nr,cmd);
  1480. switch (cmd) {
  1481. case VIDIOCGCAP:
  1482. {
  1483. struct video_capability b;
  1484. strcpy(b.name,btv->video_dev.name);
  1485. b.type = VID_TYPE_CAPTURE|
  1486. ((bttv_tvcards[btv->type].tuner != -1) ? VID_TYPE_TUNER : 0) |
  1487. VID_TYPE_OVERLAY|
  1488. VID_TYPE_CLIPPING|
  1489. VID_TYPE_FRAMERAM|
  1490. VID_TYPE_SCALES;
  1491. b.channels = bttv_tvcards[btv->type].video_inputs;
  1492. b.audios = bttv_tvcards[btv->type].audio_inputs;
  1493. b.maxwidth = tvnorms[btv->win.norm].swidth;
  1494. b.maxheight = tvnorms[btv->win.norm].sheight;
  1495. b.minwidth = 48;
  1496. b.minheight = 32;
  1497. if(copy_to_user(arg,&b,sizeof(b)))
  1498. return -EFAULT;
  1499. return 0;
  1500. }
  1501. case VIDIOCGCHAN:
  1502. {
  1503. struct video_channel v;
  1504. if(copy_from_user(&v, arg,sizeof(v)))
  1505. return -EFAULT;
  1506. v.flags=VIDEO_VC_AUDIO;
  1507. v.tuners=0;
  1508. v.type=VIDEO_TYPE_CAMERA;
  1509. v.norm = btv->win.norm;
  1510. if (v.channel>=bttv_tvcards[btv->type].video_inputs)
  1511. return -EINVAL;
  1512. if(v.channel==bttv_tvcards[btv->type].tuner) 
  1513. {
  1514. strcpy(v.name,"Television");
  1515. v.flags|=VIDEO_VC_TUNER;
  1516. v.type=VIDEO_TYPE_TV;
  1517. v.tuners=1;
  1518. } 
  1519. else if(v.channel==bttv_tvcards[btv->type].svhs) 
  1520. strcpy(v.name,"S-Video");
  1521. else
  1522. sprintf(v.name,"Composite%d",v.channel);
  1524. if(copy_to_user(arg,&v,sizeof(v)))
  1525. return -EFAULT;
  1526. return 0;
  1527. }
  1528. /*
  1529.  * Each channel has 1 tuner
  1530.  */
  1531. case VIDIOCSCHAN:
  1532. {
  1533. struct video_channel v;
  1534. if(copy_from_user(&v, arg,sizeof(v)))
  1535. return -EFAULT;
  1537. if (v.channel>bttv_tvcards[btv->type].video_inputs)
  1538. return -EINVAL;
  1539. if (v.norm > (sizeof(tvnorms)/sizeof(*tvnorms)))
  1540. return -EOPNOTSUPP;
  1542. bttv_call_i2c_clients(btv,cmd,&v);
  1543. down(&btv->lock);
  1544. bt848_muxsel(btv, v.channel);
  1545. btv->channel=v.channel;
  1546. if (btv->win.norm != v.norm) {
  1547. if (btv->type == BTTV_VOODOOTV_FM)
  1548. bttv_tda9880_setnorm(btv,v.norm);
  1549. btv->win.norm = v.norm;
  1550. make_vbitab(btv);
  1551. spin_lock_irqsave(&btv->s_lock, irq_flags);
  1552. bt848_set_winsize(btv);
  1553. spin_unlock_irqrestore(&btv->s_lock, irq_flags);
  1554. }
  1555. up(&btv->lock);
  1556. return 0;
  1557. }
  1558. case VIDIOCGTUNER:
  1559. {
  1560. struct video_tuner v;
  1561. if(copy_from_user(&v,arg,sizeof(v))!=0)
  1562. return -EFAULT;
  1563. #if 0 /* tuner.signal might be of intrest for non-tuner sources too ... */
  1564. if(v.tuner||btv->channel) /* Only tuner 0 */
  1565. return -EINVAL;
  1566. #endif
  1567. strcpy(v.name, "Television");
  1568. v.rangelow=0;
  1569. v.rangehigh=0xFFFFFFFF;
  1570. v.flags=VIDEO_TUNER_PAL|VIDEO_TUNER_NTSC|VIDEO_TUNER_SECAM;
  1571. v.mode = btv->win.norm;
  1572. v.signal = (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC) ? 0xFFFF : 0;
  1573. bttv_call_i2c_clients(btv,cmd,&v);
  1574. if(copy_to_user(arg,&v,sizeof(v)))
  1575. return -EFAULT;
  1576. return 0;
  1577. }
  1578. /* We have but one tuner */
  1579. case VIDIOCSTUNER:
  1580. {
  1581. struct video_tuner v;
  1582. if(copy_from_user(&v, arg, sizeof(v)))
  1583. return -EFAULT;
  1584. /* Only one channel has a tuner */
  1585. if(v.tuner!=bttv_tvcards[btv->type].tuner)
  1586. return -EINVAL;
  1587.  
  1588. if(v.mode!=VIDEO_MODE_PAL&&v.mode!=VIDEO_MODE_NTSC
  1589.    &&v.mode!=VIDEO_MODE_SECAM)
  1590. return -EOPNOTSUPP;
  1591. bttv_call_i2c_clients(btv,cmd,&v);
  1592. if (btv->win.norm != v.mode) {
  1593. btv->win.norm = v.mode;
  1594.                         down(&btv->lock);
  1595. set_pll(btv);
  1596. make_vbitab(btv);
  1597. spin_lock_irqsave(&btv->s_lock, irq_flags);
  1598. bt848_set_winsize(btv);
  1599. spin_unlock_irqrestore(&btv->s_lock, irq_flags);
  1600. up(&btv->lock);
  1601. }
  1602. return 0;
  1603. }
  1604. case VIDIOCGPICT:
  1605. {
  1606. struct video_picture p=btv->picture;
  1607. if(copy_to_user(arg, &p, sizeof(p)))
  1608. return -EFAULT;
  1609. return 0;
  1610. }
  1611. case VIDIOCSPICT:
  1612. {
  1613. struct video_picture p;
  1614. if (copy_from_user(&p, arg,sizeof(p)))
  1615. return -EFAULT;
  1616. if (p.palette > PALETTEFMT_MAX)
  1617. return -EINVAL;
  1618. if (-1 == palette2fmt[p.palette])
  1619. return -EINVAL;
  1620. down(&btv->lock);
  1621. /* We want -128 to 127 we get 0-65535 */
  1622. bt848_bright(btv, (p.brightness>>8)-128);
  1623. /* 0-511 for the colour */
  1624. bt848_sat_u(btv, p.colour>>7);
  1625. bt848_sat_v(btv, ((p.colour>>7)*201L)/237);
  1626. /* -128 to 127 */
  1627. bt848_hue(btv, (p.hue>>8)-128);
  1628. /* 0-511 */
  1629. bt848_contrast(btv, p.contrast>>7);
  1630. btv->picture = p;
  1631. up(&btv->lock);
  1632. return 0;
  1633. }
  1634. case VIDIOCSWIN:
  1635. {
  1636. struct video_window vw;
  1637. struct video_clip *vcp = NULL;
  1639. if(copy_from_user(&vw,arg,sizeof(vw)))
  1640. return -EFAULT;
  1642. down(&btv->lock);
  1643. if(vw.flags || vw.width < 16 || vw.height < 16) 
  1644. {
  1645. spin_lock_irqsave(&btv->s_lock, irq_flags);
  1646. btv->scr_on = 0;
  1647. bt848_set_risc_jmps(btv,-1);
  1648. spin_unlock_irqrestore(&btv->s_lock, irq_flags);
  1649. up(&btv->lock);
  1650. return -EINVAL;
  1651. }
  1652. if (btv->win.bpp < 4) 
  1653. { /* adjust and align writes */
  1654. vw.x = (vw.x + 3) & ~3;
  1655. vw.width &= ~3;
  1656. }
  1657. if (btv->needs_restart)
  1658. bt848_restart(btv);
  1659. btv->win.x=vw.x;
  1660. btv->win.y=vw.y;
  1661. btv->win.width=vw.width;
  1662. btv->win.height=vw.height;
  1664. spin_lock_irqsave(&btv->s_lock, irq_flags);
  1665. bt848_set_risc_jmps(btv,0);
  1666. bt848_set_winsize(btv);
  1667. spin_unlock_irqrestore(&btv->s_lock, irq_flags);
  1669. /*
  1670.  * Do any clips.
  1671.  */
  1672. if(vw.clipcount<0) {
  1673. if((vcp=vmalloc(VIDEO_CLIPMAP_SIZE))==NULL) {
  1674. up(&btv->lock);
  1675. return -ENOMEM;
  1676. }
  1677. if(copy_from_user(vcp, vw.clips,
  1678.   VIDEO_CLIPMAP_SIZE)) {
  1679. up(&btv->lock);
  1680. vfree(vcp);
  1681. return -EFAULT;
  1682. }
  1683. } else if (vw.clipcount > 2048) {
  1684. up(&btv->lock);
  1685. return -EINVAL;
  1686. } else if (vw.clipcount) {
  1687. if((vcp=vmalloc(sizeof(struct video_clip)*
  1688. (vw.clipcount))) == NULL) {
  1689. up(&btv->lock);
  1690. return -ENOMEM;
  1691. }
  1692. if(copy_from_user(vcp,vw.clips,
  1693.   sizeof(struct video_clip)*
  1694.   vw.clipcount)) {
  1695. up(&btv->lock);
  1696. vfree(vcp);
  1697. return -EFAULT;
  1698. }
  1699. }
  1700. make_clip_tab(btv, vcp, vw.clipcount);
  1701. if (vw.clipcount != 0)
  1702. vfree(vcp);
  1703. spin_lock_irqsave(&btv->s_lock, irq_flags);
  1704. bt848_set_risc_jmps(btv,-1);
  1705. spin_unlock_irqrestore(&btv->s_lock, irq_flags);
  1706. up(&btv->lock);
  1707. return 0;
  1708. }
  1709. case VIDIOCGWIN:
  1710. {
  1711. struct video_window vw;
  1712. memset(&vw,0,sizeof(vw));
  1713. vw.x=btv->win.x;
  1714. vw.y=btv->win.y;
  1715. vw.width=btv->win.width;
  1716. vw.height=btv->win.height;
  1717. if(btv->win.interlace)
  1718. vw.flags|=VIDEO_WINDOW_INTERLACE;
  1719. if(copy_to_user(arg,&vw,sizeof(vw)))
  1720. return -EFAULT;
  1721. return 0;
  1722. }
  1723. case VIDIOCCAPTURE:
  1724. {
  1725. int v;
  1726. if(copy_from_user(&v, arg,sizeof(v)))
  1727. return -EFAULT;
  1728. if(btv->win.vidadr == 0)
  1729. return -EINVAL;
  1730. if (btv->win.width==0 || btv->win.height==0)
  1731. return -EINVAL;
  1732. if (1 == no_overlay)
  1733. return -EIO;
  1734. spin_lock_irqsave(&btv->s_lock, irq_flags);
  1735. if (v == 1 && btv->win.vidadr != 0)
  1736. btv->scr_on = 1;
  1737. if (v == 0)
  1738. btv->scr_on = 0;
  1739. bt848_set_risc_jmps(btv,-1);
  1740. spin_unlock_irqrestore(&btv->s_lock, irq_flags);
  1741. return 0;
  1742. }
  1743. case VIDIOCGFBUF:
  1744. {
  1745. struct video_buffer v;
  1746. v.base=(void *)btv->win.vidadr;
  1747. v.height=btv->win.sheight;
  1748. v.width=btv->win.swidth;
  1749. v.depth=btv->win.depth;
  1750. v.bytesperline=btv->win.bpl;
  1751. if(copy_to_user(arg, &v,sizeof(v)))
  1752. return -EFAULT;
  1753. return 0;
  1755. }
  1756. case VIDIOCSFBUF:
  1757. {
  1758. struct video_buffer v;
  1759. if(!capable(CAP_SYS_ADMIN) &&
  1760.    !capable(CAP_SYS_RAWIO))
  1761. return -EPERM;
  1762. if(copy_from_user(&v, arg,sizeof(v)))
  1763. return -EFAULT;
  1764. if(v.depth!=8 && v.depth!=15 && v.depth!=16 && 
  1765.    v.depth!=24 && v.depth!=32 && v.width > 16 &&
  1766.    v.height > 16 && v.bytesperline > 16)
  1767. return -EINVAL;
  1768. down(&btv->lock);
  1769. if (v.base)
  1770. btv->win.vidadr=(unsigned long)v.base;
  1771. btv->win.sheight=v.height;
  1772. btv->win.swidth=v.width;
  1773. btv->win.bpp=((v.depth+7)&0x38)/8;
  1774. btv->win.depth=v.depth;
  1775. btv->win.bpl=v.bytesperline;
  1777. #if 0 /* was broken for ages and nobody noticed.  Looks like we don't need
  1778.  it any more as everybody explicitly sets the palette using VIDIOCSPICT
  1779.  these days */
  1780. /* set sefault color format */
  1781. switch (v.depth) {
  1782. case  8: btv->picture.palette = VIDEO_PALETTE_HI240;  break;
  1783. case 15: btv->picture.palette = VIDEO_PALETTE_RGB555; break;
  1784. case 16: btv->picture.palette = VIDEO_PALETTE_RGB565; break;
  1785. case 24: btv->picture.palette = VIDEO_PALETTE_RGB24;  break;
  1786. case 32: btv->picture.palette = VIDEO_PALETTE_RGB32;  break;
  1787. }
  1788. #endif
  1790. if (bttv_debug)
  1791. printk("Display at %p is %d by %d, bytedepth %d, bpl %dn",
  1792.        v.base, v.width,v.height, btv->win.bpp, btv->win.bpl);
  1793. spin_lock_irqsave(&btv->s_lock, irq_flags);
  1794. bt848_set_winsize(btv);
  1795. spin_unlock_irqrestore(&btv->s_lock, irq_flags);
  1796. up(&btv->lock);
  1797. return 0;
  1798. }
  1799. case VIDIOCKEY:
  1800. {
  1801. /* Will be handled higher up .. */
  1802. return 0;
  1803. }
  1804. case VIDIOCGFREQ:
  1805. {
  1806. unsigned long v=btv->win.freq;
  1807. if(copy_to_user(arg,&v,sizeof(v)))
  1808. return -EFAULT;
  1809. return 0;
  1810. }
  1811. case VIDIOCSFREQ:
  1812. {
  1813. unsigned long v;
  1814. if(copy_from_user(&v, arg, sizeof(v)))
  1815. return -EFAULT;
  1816. btv->win.freq=v;
  1817. bttv_call_i2c_clients(btv,cmd,&v);
  1818. #if 1
  1819. if (btv->radio && btv->has_matchbox)
  1820. tea5757_set_freq(btv,v);
  1821. #endif
  1822. return 0;
  1823. }
  1825. case VIDIOCGAUDIO:
  1826. {
  1827. struct video_audio v;
  1829. v=btv->audio_dev;
  1830. v.flags&=~(VIDEO_AUDIO_MUTE|VIDEO_AUDIO_MUTABLE);
  1831. v.flags|=VIDEO_AUDIO_MUTABLE;
  1832. strcpy(v.name,"TV");
  1834. v.mode = VIDEO_SOUND_MONO;
  1835. bttv_call_i2c_clients(btv,cmd,&v);
  1837. /* card specific hooks */
  1838. if (btv->audio_hook)
  1839. btv->audio_hook(btv,&v,0);
  1841. if(copy_to_user(arg,&v,sizeof(v)))
  1842. return -EFAULT;
  1843. return 0;
  1844. }
  1845. case VIDIOCSAUDIO:
  1846. {
  1847. struct video_audio v;
  1849. if(copy_from_user(&v,arg, sizeof(v)))
  1850. return -EFAULT;
  1851. down(&btv->lock);
  1852. if(v.flags&VIDEO_AUDIO_MUTE)
  1853. audio(btv, AUDIO_MUTE);
  1854. /* One audio source per tuner -- huh? <GA> */
  1855. if(v.audio<0 || v.audio >= bttv_tvcards[btv->type].audio_inputs) {
  1856. up(&btv->lock);
  1857. return -EINVAL;
  1858. }
  1859. /* bt848_muxsel(btv,v.audio); */
  1860. if(!(v.flags&VIDEO_AUDIO_MUTE))
  1861. audio(btv, AUDIO_UNMUTE);
  1863. bttv_call_i2c_clients(btv,cmd,&v);
  1865. /* card specific hooks */
  1866. if (btv->audio_hook)
  1867. btv->audio_hook(btv,&v,1);
  1869. btv->audio_dev=v;
  1870. up(&btv->lock);
  1871. return 0;
  1872. }
  1874. case VIDIOCSYNC:
  1875. {
  1876. DECLARE_WAITQUEUE(wait, current);
  1878. if(copy_from_user((void *)&i,arg,sizeof(int)))
  1879. return -EFAULT;
  1880. if (i < 0 || i >= gbuffers)
  1881. return -EINVAL;
  1882. switch (btv->gbuf[i].stat) {
  1883. case GBUFFER_UNUSED:
  1884. ret = -EINVAL;
  1885. break;
  1886. case GBUFFER_GRABBING:
  1887. add_wait_queue(&btv->capq, &wait);
  1888. current->state = TASK_INTERRUPTIBLE;
  1889. while(btv->gbuf[i].stat==GBUFFER_GRABBING) {
  1890. if (bttv_debug)
  1891. printk("bttv%d: cap sync: sleep on %dn",btv->nr,i);
  1892. schedule();
  1893. if(signal_pending(current)) {
  1894. remove_wait_queue(&btv->capq, &wait);
  1895. current->state = TASK_RUNNING;
  1896. return -EINTR;
  1897. }
  1898. }
  1899. remove_wait_queue(&btv->capq, &wait);
  1900. current->state = TASK_RUNNING;
  1901. /* fall throuth */
  1902. case GBUFFER_DONE:
  1903. case GBUFFER_ERROR:
  1904. ret = (btv->gbuf[i].stat == GBUFFER_ERROR) ? -EIO : 0;
  1905. if (bttv_debug)
  1906. printk("bttv%d: cap sync: buffer %d, retval %dn",btv->nr,i,ret);
  1907. btv->gbuf[i].stat = GBUFFER_UNUSED;
  1908. }
  1909. if (btv->needs_restart) {
  1910. down(&btv->lock);
  1911. bt848_restart(btv);
  1912. up(&btv->lock);
  1913. }
  1914. return ret;
  1915. }
  1917. case BTTV_FIELDNR: 
  1918. if(copy_to_user((void *) arg, (void *) &btv->last_field, 
  1919. sizeof(btv->last_field)))
  1920. return -EFAULT;
  1921. break;
  1922.       
  1923. case BTTV_PLLSET: {
  1924. struct bttv_pll_info p;
  1925. if(!capable(CAP_SYS_ADMIN))
  1926. return -EPERM;
  1927. if(copy_from_user(&p , (void *) arg, sizeof(btv->pll)))
  1928. return -EFAULT;
  1929. down(&btv->lock);
  1930. btv->pll.pll_ifreq = p.pll_ifreq;
  1931. btv->pll.pll_ofreq = p.pll_ofreq;
  1932. btv->pll.pll_crystal = p.pll_crystal;
  1933. up(&btv->lock);
  1934. break;
  1935. }
  1937. case VIDIOCMCAPTURE:
  1938. {
  1939. struct video_mmap vm;
  1940. int ret;
  1941. if(copy_from_user((void *) &vm, (void *) arg, sizeof(vm)))
  1942. return -EFAULT;
  1943. down(&btv->lock);
  1944. ret = vgrab(btv, &vm);
  1945. up(&btv->lock);
  1946. return ret;
  1947. }
  1949. case VIDIOCGMBUF:
  1950. {
  1951. struct video_mbuf vm;
  1952. memset(&vm, 0 , sizeof(vm));
  1953. vm.size=gbufsize*gbuffers;
  1954. vm.frames=gbuffers;
  1955. for (i = 0; i < gbuffers; i++)
  1956. vm.offsets[i]=i*gbufsize;
  1957. if(copy_to_user((void *)arg, (void *)&vm, sizeof(vm)))
  1958. return -EFAULT;
  1959. return 0;
  1960. }
  1962. case VIDIOCGUNIT:
  1963. {
  1964. struct video_unit vu;
  1965. vu.video=btv->video_dev.minor;
  1966. vu.vbi=btv->vbi_dev.minor;
  1967. if(btv->radio_dev.minor!=-1)
  1968. vu.radio=btv->radio_dev.minor;
  1969. else
  1970. vu.radio=VIDEO_NO_UNIT;
  1971. vu.audio=VIDEO_NO_UNIT;
  1972. vu.teletext=VIDEO_NO_UNIT;
  1973. if(copy_to_user((void *)arg, (void *)&vu, sizeof(vu)))
  1974. return -EFAULT;
  1975. return 0;
  1976. }
  1978. case BTTV_BURST_ON:
  1979. {
  1980. burst(1);
  1981. return 0;
  1982. }
  1984. case BTTV_BURST_OFF:
  1985. {
  1986. burst(0);
  1987. return 0;
  1988. }
  1990. case BTTV_VERSION:
  1991. {
  1992. return BTTV_VERSION_CODE;
  1993. }
  1994.                         
  1995. case BTTV_PICNR:
  1996. {
  1997. /* return picture;*/
  1998. return  0;
  1999. }
  2001. default:
  2002. return -ENOIOCTLCMD;
  2003. }
  2004. return 0;
  2005. }
  2007. /*
  2008.  * This maps the vmalloced and reserved fbuffer to user space.
  2009.  *
  2010.  *  FIXME: 
  2011.  *  - PAGE_READONLY should suffice!?
  2012.  *  - remap_page_range is kind of inefficient for page by page remapping.
  2013.  *    But e.g. pte_alloc() does not work in modules ... :-(
  2014.  */
  2016. static int do_bttv_mmap(struct bttv *btv, const char *adr, unsigned long size)
  2017. {
  2018.         unsigned long start=(unsigned long) adr;
  2019.         unsigned long page,pos;
  2021.         if (size>gbuffers*gbufsize)
  2022.                 return -EINVAL;
  2023.         if (!btv->fbuffer) {
  2024.                 if(fbuffer_alloc(btv))
  2025.                         return -EINVAL;
  2026.         }
  2027.         pos=(unsigned long) btv->fbuffer;
  2028.         while (size > 0) {
  2029.                 page = kvirt_to_pa(pos);
  2030.                 if (remap_page_range(start, page, PAGE_SIZE, PAGE_SHARED))
  2031.                         return -EAGAIN;
  2032.                 start+=PAGE_SIZE;
  2033.                 pos+=PAGE_SIZE;
  2034.                 size-=PAGE_SIZE;
  2035.         }
  2036.         return 0;
  2037. }
  2039. static int bttv_mmap(struct video_device *dev, const char *adr, unsigned long size)
  2040. {
  2041.         struct bttv *btv=(struct bttv *)dev;
  2042.         int r;
  2044.         down(&btv->lock);
  2045.         r=do_bttv_mmap(btv, adr, size);
  2046.         up(&btv->lock);
  2047.         return r;
  2048. }
  2051. static struct video_device bttv_template=
  2052. {
  2053. owner: THIS_MODULE,
  2054. name: "UNSET",
  2055. type: VID_TYPE_TUNER|VID_TYPE_CAPTURE|VID_TYPE_OVERLAY|VID_TYPE_TELETEXT,
  2056. hardware: VID_HARDWARE_BT848,
  2057. open: bttv_open,
  2058. close: bttv_close,
  2059. read: bttv_read,
  2060. write: bttv_write,
  2061. ioctl: bttv_ioctl,
  2062. mmap: bttv_mmap,
  2063. minor: -1,
  2064. };
  2067. static long vbi_read(struct video_device *v, char *buf, unsigned long count,
  2068.      int nonblock)
  2069. {
  2070. struct bttv *btv=(struct bttv *)(v-2);
  2071. int q,todo;
  2072. DECLARE_WAITQUEUE(wait, current);
  2074. todo=count;
  2075. while (todo && todo>(q=VBIBUF_SIZE-btv->vbip)) 
  2076. {
  2077. if (btv->needs_restart) {
  2078. down(&btv->lock);
  2079. bt848_restart(btv);
  2080. up(&btv->lock);
  2081. }
  2082. if(copy_to_user((void *) buf, (void *) btv->vbibuf+btv->vbip, q))
  2083. return -EFAULT;
  2084. todo-=q;
  2085. buf+=q;
  2087. add_wait_queue(&btv->vbiq, &wait);
  2088. current->state = TASK_INTERRUPTIBLE;
  2089. if (todo && q==VBIBUF_SIZE-btv->vbip) 
  2090. {
  2091. if(nonblock)
  2092. {
  2093. remove_wait_queue(&btv->vbiq, &wait);
  2094. current->state = TASK_RUNNING;
  2095. if(count==todo)
  2096. return -EWOULDBLOCK;
  2097. return count-todo;
  2098. }
  2099. schedule();
  2100. if(signal_pending(current))
  2101. {
  2102. remove_wait_queue(&btv->vbiq, &wait);
  2103.                                 current->state = TASK_RUNNING;
  2104. if(todo==count)
  2105. return -EINTR;
  2106. else
  2107. return count-todo;
  2108. }
  2109. }
  2110. remove_wait_queue(&btv->vbiq, &wait);
  2111. current->state = TASK_RUNNING;
  2112. }
  2113. if (todo) 
  2114. {
  2115. if(copy_to_user((void *) buf, (void *) btv->vbibuf+btv->vbip, todo))
  2116. return -EFAULT;
  2117. btv->vbip+=todo;
  2118. }
  2119. return count;
  2120. }
  2122. static unsigned int vbi_poll(struct video_device *dev, struct file *file,
  2123. poll_table *wait)
  2124. {
  2125. struct bttv *btv=(struct bttv *)(dev-2);
  2126. unsigned int mask = 0;
  2128. poll_wait(file, &btv->vbiq, wait);
  2130. if (btv->vbip < VBIBUF_SIZE)
  2131. mask |= (POLLIN | POLLRDNORM);
  2133. return mask;
  2134. }
  2136. static int vbi_open(struct video_device *dev, int flags)
  2137. {
  2138. struct bttv *btv=(struct bttv *)(dev-2);
  2139.   unsigned long irq_flags;
  2141.         down(&btv->lock);
  2142. if (btv->needs_restart)
  2143. bt848_restart(btv);
  2144. set_pll(btv);
  2145. btv->vbip=VBIBUF_SIZE;
  2146. spin_lock_irqsave(&btv->s_lock, irq_flags);
  2147. btv->vbi_on = 1;
  2148. bt848_set_risc_jmps(btv,-1);
  2149. spin_unlock_irqrestore(&btv->s_lock, irq_flags);
  2150. up(&btv->lock);
  2152. return 0;   
  2153. }
  2155. static void vbi_close(struct video_device *dev)
  2156. {
  2157. struct bttv *btv=(struct bttv *)(dev-2);
  2158.   unsigned long irq_flags;
  2160. spin_lock_irqsave(&btv->s_lock, irq_flags);
  2161. btv->vbi_on = 0;
  2162. bt848_set_risc_jmps(btv,-1);
  2163. spin_unlock_irqrestore(&btv->s_lock, irq_flags);
  2164. }
  2166. static int vbi_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
  2167. {
  2168. struct bttv *btv=(struct bttv *)(dev-2);
  2170. switch (cmd) {
  2171. case VIDIOCGCAP:
  2172. {
  2173. struct video_capability b;
  2174. strcpy(b.name,btv->vbi_dev.name);
  2175. b.type = ((bttv_tvcards[btv->type].tuner != -1) ? VID_TYPE_TUNER : 0) |
  2176. VID_TYPE_TELETEXT;
  2177. b.channels = 0;
  2178. b.audios = 0;
  2179. b.maxwidth = 0;
  2180. b.maxheight = 0;
  2181. b.minwidth = 0;
  2182. b.minheight = 0;
  2183. if(copy_to_user(arg,&b,sizeof(b)))
  2184. return -EFAULT;
  2185. return 0;
  2186. }
  2187. case VIDIOCGFREQ:
  2188. case VIDIOCSFREQ:
  2189. case VIDIOCGTUNER:
  2190. case VIDIOCSTUNER:
  2191. case VIDIOCGCHAN:
  2192. case VIDIOCSCHAN:
  2193. case BTTV_VERSION:
  2194. return bttv_ioctl(dev-2,cmd,arg);
  2195. case BTTV_VBISIZE:
  2196. /* make alevt happy :-) */
  2197. return VBIBUF_SIZE;
  2198. default:
  2199. return -EINVAL;
  2200. }
  2201. }
  2203. static struct video_device vbi_template=
  2204. {
  2205. owner: THIS_MODULE,
  2206. name: "bttv vbi",
  2207. type: VID_TYPE_CAPTURE|VID_TYPE_TELETEXT,
  2208. hardware: VID_HARDWARE_BT848,
  2209. open: vbi_open,
  2210. close: vbi_close,
  2211. read: vbi_read,
  2212. write: bttv_write,
  2213. poll: vbi_poll,
  2214. ioctl: vbi_ioctl,
  2215. minor: -1,
  2216. };
  2219. static int radio_open(struct video_device *dev, int flags)
  2220. {
  2221. struct bttv *btv = (struct bttv *)(dev-1);
  2222. unsigned long v;
  2224.         down(&btv->lock);
  2225. if (btv->user)
  2226. goto busy_unlock;
  2227. btv->user++;
  2229. btv->radio = 1;
  2230. v = 400*16;
  2231. bttv_call_i2c_clients(btv,VIDIOCSFREQ,&v);
  2232. bttv_call_i2c_clients(btv,AUDC_SET_RADIO,&btv->tuner_type);
  2233. bt848_muxsel(btv,0);
  2234. up(&btv->lock);
  2236. return 0;   
  2238.  busy_unlock:
  2239. up(&btv->lock);
  2240. return -EBUSY;
  2241. }
  2243. static void radio_close(struct video_device *dev)
  2244. {
  2245. struct bttv *btv=(struct bttv *)(dev-1);
  2247. down(&btv->lock);
  2248. btv->user--;
  2249. btv->radio = 0;
  2250. up(&btv->lock);
  2251. }
  2253. static long radio_read(struct video_device *v, char *buf, unsigned long count, int nonblock)
  2254. {
  2255. return -EINVAL;
  2256. }
  2258. static int radio_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
  2259. {
  2260.         struct bttv *btv=(struct bttv *)(dev-1);
  2261. switch (cmd) {
  2262. case VIDIOCGCAP:
  2263. {
  2264. struct video_capability v;
  2265. strcpy(v.name,btv->video_dev.name);
  2266. v.type = VID_TYPE_TUNER;
  2267. v.channels = 1;
  2268. v.audios = 1;
  2269. /* No we don't do pictures */
  2270. v.maxwidth = 0;
  2271. v.maxheight = 0;
  2272. v.minwidth = 0;
  2273. v.minheight = 0;
  2274. if (copy_to_user(arg, &v, sizeof(v)))
  2275. return -EFAULT;
  2276. return 0;
  2277. break;
  2278. }
  2279. case VIDIOCGTUNER:
  2280. {
  2281. struct video_tuner v;
  2282. if(copy_from_user(&v,arg,sizeof(v))!=0)
  2283. return -EFAULT;
  2284. if(v.tuner||btv->channel) /* Only tuner 0 */
  2285. return -EINVAL;
  2286. strcpy(v.name, "Radio");
  2287. /* japan:          76.0 MHz -  89.9 MHz
  2288.    western europe: 87.5 MHz - 108.0 MHz
  2289.    russia:         65.0 MHz - 108.0 MHz */
  2290. v.rangelow=(int)(65*16);
  2291. v.rangehigh=(int)(108*16);
  2292. v.flags= 0; /* XXX */
  2293. v.mode = 0; /* XXX */
  2294. bttv_call_i2c_clients(btv,cmd,&v);
  2295. if(copy_to_user(arg,&v,sizeof(v)))
  2296. return -EFAULT;
  2297. return 0;
  2298. }
  2299. case VIDIOCSTUNER:
  2300. {
  2301. struct video_tuner v;
  2302. if(copy_from_user(&v, arg, sizeof(v)))
  2303. return -EFAULT;
  2304. /* Only channel 0 has a tuner */
  2305. if(v.tuner!=0 || btv->channel)
  2306. return -EINVAL;
  2307. /* XXX anything to do ??? */
  2308. return 0;
  2309. }
  2310. case VIDIOCGFREQ:
  2311. case VIDIOCSFREQ:
  2312. case VIDIOCGAUDIO:
  2313. case VIDIOCSAUDIO:
  2314. bttv_ioctl((struct video_device *)btv,cmd,arg);
  2315. break;
  2316. default:
  2317. return -ENOIOCTLCMD;
  2318. }
  2319. return 0;
  2320. }
  2322. static struct video_device radio_template=
  2323. {
  2324. owner: THIS_MODULE,
  2325. name: "bttv radio",
  2326. type: VID_TYPE_TUNER,
  2327. hardware: VID_HARDWARE_BT848,
  2328. open: radio_open,
  2329. close: radio_close,
  2330. read: radio_read,          /* just returns -EINVAL */
  2331. write: bttv_write,          /* just returns -EINVAL */
  2332. ioctl: radio_ioctl,
  2333. minor: -1,
  2334. };
  2337. static void bt848_set_risc_jmps(struct bttv *btv, int flags)
  2338. {
  2339. if (-1 == flags) {
  2340. /* defaults */
  2341. flags = 0;
  2342. if (btv->scr_on)
  2343. flags |= 0x03;
  2344. if (btv->vbi_on)
  2345. flags |= 0x0c;
  2346. #if 0
  2347. /* Hmm ... */
  2348. if ((0 != btv->risc_cap_even) ||
  2349.     (0 != btv->risc_cap_odd))
  2350. flags |= 0x0c;
  2351. #endif
  2352. }
  2354. if (bttv_debug > 1)
  2355. printk("bttv%d: set_risc_jmp %08lx:",
  2356.        btv->nr,virt_to_bus(btv->risc_jmp));
  2358. /* Sync to start of odd field */
  2359. btv->risc_jmp[0]=cpu_to_le32(BT848_RISC_SYNC|BT848_RISC_RESYNC
  2360.                                 |BT848_FIFO_STATUS_VRE);
  2361. btv->risc_jmp[1]=cpu_to_le32(0);
  2363. /* Jump to odd vbi sub */
  2364. btv->risc_jmp[2]=cpu_to_le32(BT848_RISC_JUMP|(0xd<<20));
  2365. if (flags&8) {
  2366. if (bttv_debug > 1)
  2367. printk(" ev=%08lx",virt_to_bus(btv->vbi_odd));
  2368. btv->risc_jmp[3]=cpu_to_le32(virt_to_bus(btv->vbi_odd));
  2369. } else {
  2370. if (bttv_debug > 1)
  2371. printk(" -----------");
  2372. btv->risc_jmp[3]=cpu_to_le32(virt_to_bus(btv->risc_jmp+4));
  2373. }
  2375.         /* Jump to odd sub */
  2376. btv->risc_jmp[4]=cpu_to_le32(BT848_RISC_JUMP|(0xe<<20));
  2377. if (0 != btv->risc_cap_odd) {
  2378. if (bttv_debug > 1)
  2379. printk(" e%d=%08x",btv->gq_grab,btv->risc_cap_odd);
  2380. flags |= 3;
  2381. btv->risc_jmp[5]=cpu_to_le32(btv->risc_cap_odd);
  2382. } else if ((flags&2) &&
  2383.    (!btv->win.interlace || 0 == btv->risc_cap_even)) {
  2384. if (bttv_debug > 1)
  2385. printk(" eo=%08lx",virt_to_bus(btv->risc_scr_odd));
  2386. btv->risc_jmp[5]=cpu_to_le32(virt_to_bus(btv->risc_scr_odd));
  2387. } else {
  2388. if (bttv_debug > 1)
  2389. printk(" -----------");
  2390. btv->risc_jmp[5]=cpu_to_le32(virt_to_bus(btv->risc_jmp+6));
  2391. }
  2394. /* Sync to start of even field */
  2395. btv->risc_jmp[6]=cpu_to_le32(BT848_RISC_SYNC|BT848_RISC_RESYNC
  2396.                                 |BT848_FIFO_STATUS_VRO);
  2397. btv->risc_jmp[7]=cpu_to_le32(0);
  2399. /* Jump to even vbi sub */
  2400. btv->risc_jmp[8]=cpu_to_le32(BT848_RISC_JUMP);
  2401. if (flags&4) {
  2402. if (bttv_debug > 1)
  2403. printk(" ov=%08lx",virt_to_bus(btv->vbi_even));
  2404. btv->risc_jmp[9]=cpu_to_le32(virt_to_bus(btv->vbi_even));
  2405. } else {
  2406. if (bttv_debug > 1)
  2407. printk(" -----------");
  2408. btv->risc_jmp[9]=cpu_to_le32(virt_to_bus(btv->risc_jmp+10));
  2409. }
  2411. /* Jump to even sub */
  2412. btv->risc_jmp[10]=cpu_to_le32(BT848_RISC_JUMP|(8<<20));
  2413. if (0 != btv->risc_cap_even) {
  2414. if (bttv_debug > 1)
  2415. printk(" o%d=%08x",btv->gq_grab,btv->risc_cap_even);
  2416. flags |= 3;
  2417. btv->risc_jmp[11]=cpu_to_le32(btv->risc_cap_even);
  2418. } else if ((flags&1) &&
  2419.    btv->win.interlace) {
  2420. if (bttv_debug > 1)
  2421. printk(" oo=%08lx",virt_to_bus(btv->risc_scr_even));
  2422. btv->risc_jmp[11]=cpu_to_le32(virt_to_bus(btv->risc_scr_even));
  2423. } else {
  2424. if (bttv_debug > 1)
  2425. printk(" -----------");
  2426. btv->risc_jmp[11]=cpu_to_le32(virt_to_bus(btv->risc_jmp+12));
  2427. }
  2429. if (btv->gq_start) {
  2430. btv->risc_jmp[12]=cpu_to_le32(BT848_RISC_JUMP|(0x8<<16)|BT848_RISC_IRQ);
  2431. } else {
  2432. btv->risc_jmp[12]=cpu_to_le32(BT848_RISC_JUMP);
  2433. }
  2434. btv->risc_jmp[13]=cpu_to_le32(virt_to_bus(btv->risc_jmp));
  2436. /* enable cpaturing and DMA */
  2437. if (bttv_debug > 1)
  2438. printk(" flags=0x%x dma=%sn",
  2439.        flags,(flags&0x0f) ? "on" : "off");
  2440. btaor(flags, ~0x0f, BT848_CAP_CTL);
  2441. if (flags&0x0f)
  2442. bt848_dma(btv, 3);
  2443. else
  2444. bt848_dma(btv, 0);
  2445. }
  2447. static int __devinit init_video_dev(struct bttv *btv)
  2448. {
  2449. audio(btv, AUDIO_MUTE);
  2450.         
  2451. if (video_register_device(&btv->video_dev,VFL_TYPE_GRABBER,video_nr)<0)
  2452. return -1;
  2453. printk(KERN_INFO "bttv%d: registered device video%dn",
  2454.        btv->nr,btv->video_dev.minor & 0x1f);
  2455. if (video_register_device(&btv->vbi_dev,VFL_TYPE_VBI,vbi_nr)<0) {
  2456.         video_unregister_device(&btv->video_dev);
  2457. return -1;
  2458. }
  2459. printk(KERN_INFO "bttv%d: registered device vbi%dn",
  2460.        btv->nr,btv->vbi_dev.minor & 0x1f);
  2461. if (btv->has_radio) {
  2462. if(video_register_device(&btv->radio_dev, VFL_TYPE_RADIO, radio_nr)<0) {
  2463.         video_unregister_device(&btv->vbi_dev);
  2464.         video_unregister_device(&btv->video_dev);
  2465. return -1;
  2466. }
  2467. printk(KERN_INFO "bttv%d: registered device radio%dn",
  2468.        btv->nr,btv->radio_dev.minor & 0x1f);
  2469. }
  2470.         return 1;
  2471. }
  2473. static int __devinit init_bt848(struct bttv *btv)
  2474. {
  2475. int j,val;
  2476.   unsigned long irq_flags;
  2478. btv->user=0; 
  2479.         init_MUTEX(&btv->lock);
  2481. /* dump current state of the gpio registers before changing them,
  2482.  * might help to make a new card work */
  2483. if (bttv_gpio) {
  2484. bttv_gpio_tracking(btv,"init #1");
  2485. bttv_gpio_tracking(btv,"init #1");
  2486. }
  2488. /* reset the bt848 */
  2489. btwrite(0, BT848_SRESET);
  2491. /* not registered yet */
  2492. btv->video_dev.minor = -1;
  2493. btv->radio_dev.minor = -1;
  2494. btv->vbi_dev.minor = -1;
  2496. /* default setup for max. PAL size in a 1024xXXX hicolor framebuffer */
  2497. btv->win.norm=0; /* change this to 1 for NTSC, 2 for SECAM */
  2498. btv->win.interlace=1;
  2499. btv->win.x=0;
  2500. btv->win.y=0;
  2501. btv->win.width=320;
  2502. btv->win.height=240;
  2503. btv->win.bpp=2;
  2504. btv->win.depth=16;
  2505. btv->win.color_fmt=BT848_COLOR_FMT_RGB16;
  2506. btv->win.bpl=1024*btv->win.bpp;
  2507. btv->win.swidth=1024;
  2508. btv->win.sheight=768;
  2509. btv->win.vidadr=0;
  2510. btv->vbi_on=0;
  2511. btv->scr_on=0;
  2513. btv->risc_scr_odd=0;
  2514. btv->risc_scr_even=0;
  2515. btv->risc_cap_odd=0;
  2516. btv->risc_cap_even=0;
  2517. btv->risc_jmp=0;
  2518. btv->vbibuf=0;
  2519.         btv->field=btv->last_field=0;
  2521. btv->errors=0;
  2522. btv->needs_restart=0;
  2523. btv->has_radio=radio[btv->nr];
  2525. if (!(btv->risc_scr_odd=(unsigned int *) kmalloc(RISCMEM_LEN/2, GFP_KERNEL)))
  2526. return -1;
  2527. if (!(btv->risc_scr_even=(unsigned int *) kmalloc(RISCMEM_LEN/2, GFP_KERNEL)))
  2528. return -1;
  2529. if (!(btv->risc_jmp =(unsigned int *) kmalloc(2048, GFP_KERNEL)))
  2530. return -1;
  2531. btv->vbi_odd=btv->risc_jmp+16;
  2532. btv->vbi_even=btv->vbi_odd+256;
  2533. btv->bus_vbi_odd=virt_to_bus(btv->risc_jmp+12);
  2534. btv->bus_vbi_even=virt_to_bus(btv->risc_jmp+6);
  2536. btwrite(virt_to_bus(btv->risc_jmp+2), BT848_RISC_STRT_ADD);
  2537. btv->vbibuf=(unsigned char *) vmalloc_32(VBIBUF_SIZE);
  2538. if (!btv->vbibuf) 
  2539. return -1;
  2540. if (!(btv->gbuf = kmalloc(sizeof(struct bttv_gbuf)*gbuffers,GFP_KERNEL)))
  2541. return -1;
  2542. for (j = 0; j < gbuffers; j++) {
  2543. if (!(btv->gbuf[j].risc = kmalloc(16384,GFP_KERNEL)))
  2544. return -1;
  2545. }
  2547. memset(btv->vbibuf, 0, VBIBUF_SIZE); /* We don't want to return random
  2548.                                         memory to the user */
  2550. btv->fbuffer=NULL;
  2552. /* btwrite(0, BT848_TDEC); */
  2553.         btwrite(0x10, BT848_COLOR_CTL);
  2554. btwrite(0x00, BT848_CAP_CTL);
  2555. /* set planar and packed mode trigger points and         */
  2556. /* set rising edge of inverted GPINTR pin as irq trigger */
  2557. btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
  2558. BT848_GPIO_DMA_CTL_PLTP1_16|
  2559. BT848_GPIO_DMA_CTL_PLTP23_16|
  2560. BT848_GPIO_DMA_CTL_GPINTC|
  2561. BT848_GPIO_DMA_CTL_GPINTI, 
  2562. BT848_GPIO_DMA_CTL);
  2564.         /* select direct input */
  2565. btwrite(0x00, BT848_GPIO_REG_INP);
  2566. btwrite(0x00, BT848_GPIO_OUT_EN);
  2567. if (bttv_gpio)
  2568. bttv_gpio_tracking(btv,"init #2");
  2570. btwrite(BT848_IFORM_MUX1 | BT848_IFORM_XTAUTO | BT848_IFORM_AUTO,
  2571. BT848_IFORM);
  2573. btwrite(0xd8, BT848_CONTRAST_LO);
  2574. bt848_bright(btv, 0x10);
  2576. btwrite(0x20, BT848_E_VSCALE_HI);
  2577. btwrite(0x20, BT848_O_VSCALE_HI);
  2578. btwrite(BT848_ADC_RESERVED | (adc_crush ? BT848_ADC_CRUSH : 0),
  2579. BT848_ADC);
  2581. if (lumafilter) {
  2582. btwrite(0, BT848_E_CONTROL);
  2583. btwrite(0, BT848_O_CONTROL);
  2584. } else {
  2585. btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
  2586. btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
  2587. }
  2589. btv->picture.colour=254<<7;
  2590. btv->picture.brightness=128<<8;
  2591. btv->picture.hue=128<<8;
  2592. btv->picture.contrast=0xd8<<7;
  2594. val = chroma_agc ? BT848_SCLOOP_CAGC : 0;
  2595.         btwrite(val, BT848_E_SCLOOP);
  2596.         btwrite(val, BT848_O_SCLOOP);
  2598. /* clear interrupt status */
  2599. btwrite(0xfffffUL, BT848_INT_STAT);
  2600.         
  2601. /* set interrupt mask */
  2602. btwrite(btv->triton1|
  2603.                 /*BT848_INT_PABORT|BT848_INT_RIPERR|BT848_INT_PPERR|
  2604.                   BT848_INT_FDSR|BT848_INT_FTRGT|BT848_INT_FBUS|*/
  2605.                 (fieldnr ? BT848_INT_VSYNC : 0)|
  2606. BT848_INT_GPINT|
  2607. BT848_INT_SCERR|
  2608. BT848_INT_RISCI|BT848_INT_OCERR|BT848_INT_VPRES|
  2609. BT848_INT_FMTCHG|BT848_INT_HLOCK,
  2610. BT848_INT_MASK);
  2612. bt848_muxsel(btv, 1);
  2613. bt848_set_winsize(btv);
  2614. make_vbitab(btv);
  2615. spin_lock_irqsave(&btv->s_lock, irq_flags);
  2616. bt848_set_risc_jmps(btv,-1);
  2617. spin_unlock_irqrestore(&btv->s_lock, irq_flags);
  2619. /* needs to be done before i2c is registered */
  2620. bttv_init_card1(btv);
  2622. /* register i2c */
  2623.         btv->tuner_type=-1;
  2624.         init_bttv_i2c(btv);
  2626. /* some card-specific stuff (needs working i2c) */
  2627. bttv_init_card2(btv);
  2629. /*
  2630.  * Now add the template and register the device unit.
  2631.  */
  2632.         init_video_dev(btv);
  2634. return 0;
  2635. }
  2637. /* ----------------------------------------------------------------------- */
  2639. static char *irq_name[] = { "FMTCHG", "VSYNC", "HSYNC", "OFLOW", "HLOCK",
  2640.     "VPRES", "6", "7", "I2CDONE", "GPINT", "10",
  2641.     "RISCI", "FBUS", "FTRGT", "FDSR", "PPERR",
  2642.     "RIPERR", "PABORT", "OCERR", "SCERR" };
  2644. static void bttv_irq(int irq, void *dev_id, struct pt_regs * regs)
  2645. {
  2646. u32 stat,astat;
  2647. u32 dstat;
  2648. int count;
  2649. struct bttv *btv;
  2651. btv=(struct bttv *)dev_id;
  2652. count=0;
  2653. while (1) 
  2654. {
  2655. /* get/clear interrupt status bits */
  2656. stat=btread(BT848_INT_STAT);
  2657. astat=stat&btread(BT848_INT_MASK);
  2658. if (!astat)
  2659. return;
  2660. btwrite(stat,BT848_INT_STAT);
  2662. /* get device status bits */
  2663. dstat=btread(BT848_DSTATUS);
  2665. if (irq_debug) {
  2666. int i;
  2667. printk(KERN_DEBUG "bttv%d: irq loop=%d risc=%x, bits:",
  2668.        btv->nr, count, stat>>28);
  2669. for (i = 0; i < (sizeof(irq_name)/sizeof(char*)); i++) {
  2670. if (stat & (1 << i))
  2671. printk(" %s",irq_name[i]);
  2672. if (astat & (1 << i))
  2673. printk("*");
  2674. }
  2675. if (stat & BT848_INT_HLOCK)
  2676. printk("   HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
  2677.        ? "yes" : "no");
  2678. if (stat & BT848_INT_VPRES)
  2679. printk("   PRES => %s", (dstat & BT848_DSTATUS_PRES)
  2680.        ? "yes" : "no");
  2681. if (stat & BT848_INT_FMTCHG)
  2682. printk("   NUML => %s", (dstat & BT848_DSTATUS_PRES)
  2683.        ? "625" : "525");
  2684. printk("n");
  2685. }
  2687. if (astat&BT848_INT_GPINT)
  2688. wake_up_interruptible(&btv->gpioq);
  2690. if (astat&BT848_INT_VSYNC) 
  2691.                         btv->field++;
  2693. if (astat&(BT848_INT_SCERR|BT848_INT_OCERR)) {
  2694. if (bttv_verbose)
  2695. printk("bttv%d: irq:%s%s risc_count=%08xn",
  2696.        btv->nr,
  2697.        (astat&BT848_INT_SCERR) ? " SCERR" : "",
  2698.        (astat&BT848_INT_OCERR) ? " OCERR" : "",
  2699.        btread(BT848_RISC_COUNT));
  2700. btv->errors++;
  2701. if (btv->errors < BTTV_ERRORS) {
  2702. spin_lock(&btv->s_lock);
  2703. btand(~15, BT848_GPIO_DMA_CTL);
  2704. btwrite(virt_to_bus(btv->risc_jmp+2),
  2705. BT848_RISC_STRT_ADD);
  2706. bt848_set_geo(btv);
  2707. bt848_set_risc_jmps(btv,-1);
  2708. spin_unlock(&btv->s_lock);
  2709. } else {
  2710. if (bttv_verbose)
  2711. printk("bttv%d: aiee: error loopsn",btv->nr);
  2712. bt848_offline(btv);
  2713. }
  2714. }
  2715. if (astat&BT848_INT_RISCI) 
  2716. {
  2717. if (bttv_debug > 1)
  2718. printk("bttv%d: IRQ_RISCIn",btv->nr);
  2720. /* captured VBI frame */
  2721. if (stat&(1<<28)) 
  2722. {
  2723. btv->vbip=0;
  2724. /* inc vbi frame count for detecting drops */
  2725. (*(u32 *)&(btv->vbibuf[VBIBUF_SIZE - 4]))++;
  2726. wake_up_interruptible(&btv->vbiq);
  2727. }
  2729. /* captured full frame */
  2730. if (stat&(2<<28) && btv->gq_grab != -1) 
  2731. {
  2732.                                 btv->last_field=btv->field;
  2733. if (bttv_debug)
  2734. printk("bttv%d: cap irq: done %dn",btv->nr,btv->gq_grab);
  2735. do_gettimeofday(&btv->gbuf[btv->gq_grab].tv);
  2736. spin_lock(&btv->s_lock);
  2737. btv->gbuf[btv->gq_grab].stat = GBUFFER_DONE;
  2738. btv->gq_grab = -1;
  2739.         if (btv->gq_in != btv->gq_out)
  2740. {
  2741. btv->gq_grab = btv->gqueue[btv->gq_out++];
  2742. btv->gq_out  = btv->gq_out % MAX_GBUFFERS;
  2743. if (bttv_debug)
  2744. printk("bttv%d: cap irq: capture %dn",btv->nr,btv->gq_grab);
  2745.                                         btv->risc_cap_odd  = btv->gbuf[btv->gq_grab].ro;
  2746. btv->risc_cap_even = btv->gbuf[btv->gq_grab].re;
  2747. bt848_set_risc_jmps(btv,-1);
  2748. bt848_set_geo(btv);
  2749. btwrite(BT848_COLOR_CTL_GAMMA,
  2750. BT848_COLOR_CTL);
  2751. } else {
  2752.                                         btv->risc_cap_odd  = 0;
  2753. btv->risc_cap_even = 0;
  2754. bt848_set_risc_jmps(btv,-1);
  2755.                                         bt848_set_geo(btv);
  2756. btwrite(btv->fb_color_ctl | BT848_COLOR_CTL_GAMMA,
  2757. BT848_COLOR_CTL);
  2758. }
  2759. spin_unlock(&btv->s_lock);
  2760. wake_up_interruptible(&btv->capq);
  2761. break;
  2762. }
  2763. if (stat&(8<<28) && btv->gq_start) 
  2764. {
  2765. spin_lock(&btv->s_lock);
  2766. btv->gq_start = 0;
  2767. btv->gq_grab = btv->gqueue[btv->gq_out++];
  2768. btv->gq_out  = btv->gq_out % MAX_GBUFFERS;
  2769. if (bttv_debug)
  2770. printk("bttv%d: cap irq: capture %d [start]n",btv->nr,btv->gq_grab);
  2771. btv->risc_cap_odd  = btv->gbuf[btv->gq_grab].ro;
  2772. btv->risc_cap_even = btv->gbuf[btv->gq_grab].re;
  2773. bt848_set_risc_jmps(btv,-1);
  2774. bt848_set_geo(btv);
  2775. btwrite(BT848_COLOR_CTL_GAMMA,
  2776. BT848_COLOR_CTL);
  2777. spin_unlock(&btv->s_lock);
  2778. }
  2779. }
  2781. if (automute && (astat&BT848_INT_HLOCK)) {
  2782. if ((dstat&BT848_DSTATUS_HLOC) || (btv->radio))
  2783. audio(btv, AUDIO_ON);
  2784. else
  2785. audio(btv, AUDIO_OFF);
  2786. }
  2787.     
  2788. count++;
  2789. if (count > 20) {
  2790. btwrite(0, BT848_INT_MASK);
  2791. printk(KERN_ERR 
  2792.        "bttv%d: IRQ lockup, cleared int maskn", btv->nr);
  2793. bt848_offline(btv);
  2794. }
  2795. }
  2796. }
  2800. /*
  2801.  * Scan for a Bt848 card, request the irq and map the io memory 
  2802.  */
  2804. static void bttv_remove(struct pci_dev *pci_dev)
  2805. {
  2806.         u8 command;
  2807.         int j;
  2808.         struct bttv *btv = pci_get_drvdata(pci_dev);
  2810. if (bttv_verbose)
  2811. printk("bttv%d: unloadingn",btv->nr);
  2813.         /* unregister i2c_bus */
  2814. if (0 == btv->i2c_rc)
  2815. i2c_bit_del_bus(&btv->i2c_adap);
  2817.         /* turn off all capturing, DMA and IRQs */
  2818.         btand(~15, BT848_GPIO_DMA_CTL);
  2820.         /* first disable interrupts before unmapping the memory! */
  2821.         btwrite(0, BT848_INT_MASK);
  2822.         btwrite(~0x0UL,BT848_INT_STAT);
  2823.         btwrite(0x0, BT848_GPIO_OUT_EN);
  2824. if (bttv_gpio)
  2825. bttv_gpio_tracking(btv,"cleanup");
  2827.         /* disable PCI bus-mastering */
  2828.         pci_read_config_byte(btv->dev, PCI_COMMAND, &command);
  2829.         command &= ~PCI_COMMAND_MASTER;
  2830.         pci_write_config_byte(btv->dev, PCI_COMMAND, command);
  2832.         /* unmap and free memory */
  2833.         for (j = 0; j < gbuffers; j++)
  2834.                 if (btv->gbuf[j].risc)
  2835.                         kfree(btv->gbuf[j].risc);
  2836.         if (btv->gbuf)
  2837.                 kfree((void *) btv->gbuf);
  2839.         if (btv->risc_scr_odd)
  2840.                 kfree((void *) btv->risc_scr_odd);
  2842.         if (btv->risc_scr_even)
  2843.                 kfree((void *) btv->risc_scr_even);
  2845.         DEBUG(printk(KERN_DEBUG "free: risc_jmp: 0x%p.n", btv->risc_jmp));
  2846.         if (btv->risc_jmp)
  2847.                 kfree((void *) btv->risc_jmp);
  2849.         DEBUG(printk(KERN_DEBUG "bt848_vbibuf: 0x%p.n", btv->vbibuf));
  2850.         if (btv->vbibuf)
  2851.                 vfree((void *) btv->vbibuf);
  2853.         free_irq(btv->dev->irq,btv);
  2854.         DEBUG(printk(KERN_DEBUG "bt848_mem: 0x%p.n", btv->bt848_mem));
  2855.         if (btv->bt848_mem)
  2856.                 iounmap(btv->bt848_mem);
  2858.         if (btv->video_dev.minor!=-1)
  2859.                 video_unregister_device(&btv->video_dev);
  2860.         if (btv->vbi_dev.minor!=-1)
  2861.                 video_unregister_device(&btv->vbi_dev);
  2862.         if (btv->radio_dev.minor != -1)
  2863.                 video_unregister_device(&btv->radio_dev);
  2865.         release_mem_region(pci_resource_start(btv->dev,0),
  2866.                            pci_resource_len(btv->dev,0));
  2867.         /* wake up any waiting processes
  2868.            because shutdown flag is set, no new processes (in this queue)
  2869.            are expected
  2870.         */
  2871.         btv->shutdown=1;
  2872.         wake_up(&btv->gpioq);
  2874. pci_set_drvdata(pci_dev, NULL);
  2875.         return;
  2876. }
  2879. static int __devinit bttv_probe(struct pci_dev *dev, const struct pci_device_id *pci_id)
  2880. {
  2881. int result;
  2882. unsigned char lat;
  2883. struct bttv *btv;
  2884. #if defined(__powerpc__)
  2885.         unsigned int cmd;
  2886. #endif
  2888. if (bttv_num == BTTV_MAX)
  2889. return -ENOMEM;
  2890. printk(KERN_INFO "bttv: Bt8xx card found (%d).n", bttv_num);
  2892.         btv=&bttvs[bttv_num];
  2893.         btv->dev=dev;
  2894.         btv->nr = bttv_num;
  2895.         btv->bt848_mem=NULL;
  2896.         btv->vbibuf=NULL;
  2897.         btv->risc_jmp=NULL;
  2898.         btv->vbi_odd=NULL;
  2899.         btv->vbi_even=NULL;
  2900.         init_waitqueue_head(&btv->vbiq);
  2901.         init_waitqueue_head(&btv->capq);
  2902.         btv->vbip=VBIBUF_SIZE;
  2903. btv->s_lock = SPIN_LOCK_UNLOCKED;
  2904. init_waitqueue_head(&btv->gpioq);
  2905. btv->shutdown=0;
  2907. memcpy(&btv->video_dev,&bttv_template, sizeof(bttv_template));
  2908. memcpy(&btv->vbi_dev,&vbi_template, sizeof(vbi_template));
  2909. memcpy(&btv->radio_dev,&radio_template,sizeof(radio_template));
  2911.         btv->id=dev->device;
  2912. btv->bt848_adr=pci_resource_start(dev,0);
  2913. if (pci_enable_device(dev)) {
  2914.                 printk(KERN_WARNING "bttv%d: Can't enable device.n",
  2915.        btv->nr);
  2916. return -EIO;
  2917. }
  2918.         if (pci_set_dma_mask(dev, 0xffffffff)) {
  2919.                 printk(KERN_WARNING "bttv%d: No suitable DMA available.n",
  2920.        btv->nr);
  2921. return -EIO;
  2922.         }
  2923. if (!request_mem_region(pci_resource_start(dev,0),
  2924. pci_resource_len(dev,0),
  2925. "bttv")) {
  2926. return -EBUSY;
  2927. }
  2928.         if (btv->id >= 878)
  2929.                 btv->i2c_command = 0x83;                   
  2930.         else
  2931.                 btv->i2c_command=(I2C_TIMING | BT848_I2C_SCL | BT848_I2C_SDA);
  2933. if (-1 != latency) {
  2934. printk(KERN_INFO "bttv%d: setting pci latency timer to %dn",
  2935.        bttv_num,latency);
  2936. pci_write_config_byte(dev, PCI_LATENCY_TIMER, latency);
  2937. }
  2938.         pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
  2939.         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
  2940.         printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %02x:%02x.%x, ",
  2941.                bttv_num,btv->id, btv->revision, dev->bus->number,
  2942.        PCI_SLOT(dev->devfn),PCI_FUNC(dev->devfn));
  2943.         printk("irq: %d, latency: %d, mmio: 0x%lxn",
  2944.        btv->dev->irq, lat, btv->bt848_adr);
  2946. bttv_idcard(btv);
  2948. #if defined(__powerpc__)
  2949.         /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
  2950.         /* response on cards with no firmware is not enabled by OF */
  2951.         pci_read_config_dword(dev, PCI_COMMAND, &cmd);
  2952.         cmd = (cmd | PCI_COMMAND_MEMORY ); 
  2953.         pci_write_config_dword(dev, PCI_COMMAND, cmd);
  2954. #endif
  2956. #ifdef __sparc__
  2957. btv->bt848_mem=(unsigned char *)btv->bt848_adr;
  2958. #else
  2959. btv->bt848_mem=ioremap(btv->bt848_adr, 0x1000);
  2960. #endif
  2961.         
  2962.         /* clear interrupt mask */
  2963. btwrite(0, BT848_INT_MASK);
  2965.         result = request_irq(btv->dev->irq, bttv_irq,
  2966.                              SA_SHIRQ | SA_INTERRUPT,"bttv",(void *)btv);
  2967.         if (result==-EINVAL) 
  2968.         {
  2969.                 printk(KERN_ERR "bttv%d: Bad irq number or handlern",
  2970.                        bttv_num);
  2971. goto fail1;
  2972.         }
  2973.         if (result==-EBUSY)
  2974.         {
  2975.                 printk(KERN_ERR "bttv%d: IRQ %d busy, change your PnP config in BIOSn",bttv_num,btv->dev->irq);
  2976. goto fail1;
  2977.         }
  2978.         if (result < 0) 
  2979. goto fail1;
  2980.         
  2981. if (0 != bttv_handle_chipset(btv)) {
  2982. result = -1;
  2983. goto fail2;
  2984. }
  2986.         pci_set_master(dev);
  2987. pci_set_drvdata(dev,btv);
  2989. if(init_bt848(btv) < 0) {
  2990. bttv_remove(dev);
  2991. return -EIO;
  2992. }
  2993. bttv_num++;
  2995.         return 0;
  2997.  fail2:
  2998.         free_irq(btv->dev->irq,btv);
  2999.  fail1:
  3000. release_mem_region(pci_resource_start(btv->dev,0),
  3001.    pci_resource_len(btv->dev,0));
  3002. return result;
  3003. }
  3005. static struct pci_device_id bttv_pci_tbl[] __devinitdata = {
  3006.         {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
  3007.          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  3008. {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
  3009.          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  3010. {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
  3011.          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  3012. {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
  3013.          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  3014.         {0,}
  3015. };
  3017. MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
  3019. static struct pci_driver bttv_pci_driver = {
  3020.         name:     "bttv",
  3021.         id_table: bttv_pci_tbl,
  3022.         probe:    bttv_probe,
  3023.         remove:   bttv_remove,
  3024. };
  3026. static int bttv_init_module(void)
  3027. {
  3028. bttv_num = 0;
  3030. printk(KERN_INFO "bttv: driver version %d.%d.%d loadedn",
  3031.        (BTTV_VERSION_CODE >> 16) & 0xff,
  3032.        (BTTV_VERSION_CODE >> 8) & 0xff,
  3033.        BTTV_VERSION_CODE & 0xff);
  3034. if (gbuffers < 2 || gbuffers > MAX_GBUFFERS)
  3035. gbuffers = 2;
  3036. if (gbufsize < 0 || gbufsize > BTTV_MAX_FBUF)
  3037. gbufsize = BTTV_MAX_FBUF;
  3038. if (bttv_verbose)
  3039. printk(KERN_INFO "bttv: using %d buffers with %dk (%dk total) for capturen",
  3040.        gbuffers,gbufsize/1024,gbuffers*gbufsize/1024);
  3042. bttv_check_chipset();
  3044. return pci_module_init(&bttv_pci_driver);
  3045. }
  3047. static void bttv_cleanup_module(void)
  3048. {
  3049. pci_unregister_driver(&bttv_pci_driver);
  3050. return;
  3051. }
  3053. module_init(bttv_init_module);
  3054. module_exit(bttv_cleanup_module);
  3056. /*
  3057.  * Local variables:
  3058.  * c-basic-offset: 8
  3059.  * End:
  3060.  */