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

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

Linux/Unix编程

开发平台：

Unix_Linux

zr36120.c：源码内容
  1. /*
  2.     zr36120.c - Zoran 36120/36125 based framegrabbers
  4.     Copyright (C) 1998-1999 Pauline Middelink <middelin@polyware.nl>
  6.     This program is free software; you can redistribute it and/or modify
  7.     it under the terms of the GNU General Public License as published by
  8.     the Free Software Foundation; either version 2 of the License, or
  9.     (at your option) any later version.
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  16.     You should have received a copy of the GNU General Public License
  17.     along with this program; if not, write to the Free Software
  18.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19. */
  21. #include <linux/module.h>
  22. #include <linux/delay.h>
  23. #include <linux/init.h>
  24. #include <linux/errno.h>
  25. #include <linux/fs.h>
  26. #include <linux/kernel.h>
  27. #include <linux/major.h>
  28. #include <linux/slab.h>
  29. #include <linux/vmalloc.h>
  30. #include <linux/mm.h>
  31. #include <linux/pci.h>
  32. #include <linux/signal.h>
  33. #include <asm/io.h>
  34. #include <asm/pgtable.h>
  35. #include <asm/page.h>
  36. #include <linux/sched.h>
  37. #include <linux/video_decoder.h>
  38. #include <asm/segment.h>
  40. #include <linux/version.h>
  41. #include <asm/uaccess.h>
  43. #include "tuner.h"
  44. #include "zr36120.h"
  45. #include "zr36120_mem.h"
  47. /* mark an required function argument unused - lintism */
  48. #define UNUSED(x) (void)(x)
  50. /* sensible default */
  51. #ifndef CARDTYPE
  52. #define CARDTYPE 0
  53. #endif
  55. /* Anybody who uses more than four? */
  56. #define ZORAN_MAX 4
  58. static unsigned int triton1=0; /* triton1 chipset? */
  59. static unsigned int cardtype[ZORAN_MAX]={ [ 0 ... ZORAN_MAX-1 ] = CARDTYPE };
  60. static int video_nr = -1;
  61. static int vbi_nr = -1;
  63. static struct pci_device_id zr36120_pci_tbl[] = {
  64. { PCI_VENDOR_ID_ZORAN,PCI_DEVICE_ID_ZORAN_36120,
  65.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
  66. { 0 }
  67. };
  68. MODULE_DEVICE_TABLE(pci, zr36120_pci_tbl);
  70. MODULE_AUTHOR("Pauline Middelink <middelin@polyware.nl>");
  71. MODULE_DESCRIPTION("Zoran ZR36120 based framegrabber");
  72. MODULE_LICENSE("GPL");
  74. MODULE_PARM(triton1,"i");
  75. MODULE_PARM(cardtype,"1-" __MODULE_STRING(ZORAN_MAX) "i");
  76. MODULE_PARM(video_nr,"i");
  77. MODULE_PARM(vbi_nr,"i");
  79. static int zoran_cards;
  80. static struct zoran zorans[ZORAN_MAX];
  82. /*
  83.  * the meaning of each element can be found in zr36120.h
  84.  * Determining the value of gpdir/gpval can be tricky. The
  85.  * best way is to run the card under the original software
  86.  * and read the values from the general purpose registers
  87.  * 0x28 and 0x2C. How you do that is left as an exercise
  88.  * to the impatient reader :)
  89.  */
  90. #define T 1 /* to seperate the bools from the ints */
  91. #define F 0
  92. static struct tvcard tvcards[] = {
  93. /* reported working by <middelin@polyware.nl> */
  94. /*0*/ { "Trust Victor II",
  95.   2, 0, T, T, T, T, 0x7F, 0x80, { 1, SVHS(6) }, { 0 } },
  96. /* reported working by <Michael.Paxton@aihw.gov.au>  */
  97. /*1*/   { "Aitech WaveWatcher TV-PCI",
  98.   3, 0, T, F, T, T, 0x7F, 0x80, { 1, TUNER(3), SVHS(6) }, { 0 } },
  99. /* reported working by ? */
  100. /*2*/ { "Genius Video Wonder PCI Video Capture Card",
  101.   2, 0, T, T, T, T, 0x7F, 0x80, { 1, SVHS(6) }, { 0 } },
  102. /* reported working by <Pascal.Gabriel@wanadoo.fr> */
  103. /*3*/ { "Guillemot Maxi-TV PCI",
  104.   2, 0, T, T, T, T, 0x7F, 0x80, { 1, SVHS(6) }, { 0 } },
  105. /* reported working by "Craig Whitmore <lennon@igrin.co.nz> */
  106. /*4*/ { "Quadrant Buster",
  107.   3, 3, T, F, T, T, 0x7F, 0x80, { SVHS(1), TUNER(2), 3 }, { 1, 2, 3 } },
  108. /* a debug entry which has all inputs mapped */
  109. /*5*/ { "ZR36120 based framegrabber (all inputs enabled)",
  110.   6, 0, T, T, T, T, 0x7F, 0x80, { 1, 2, 3, 4, 5, 6 }, { 0 } }
  111. };
  112. #undef T
  113. #undef F
  114. #define NRTVCARDS (sizeof(tvcards)/sizeof(tvcards[0]))
  116. #ifdef __sparc__
  117. #define ENDIANESS 0
  118. #else
  119. #define ENDIANESS ZORAN_VFEC_LE
  120. #endif
  122. static struct { const char name[8]; uint mode; uint bpp; } palette2fmt[] = {
  123. /* n/a     */ { "n/a",     0, 0 },
  124. /* GREY    */ { "GRAY",    0, 0 },
  125. /* HI240   */ { "HI240",   0, 0 },
  126. /* RGB565  */ { "RGB565",  ZORAN_VFEC_RGB_RGB565|ENDIANESS, 2 },
  127. /* RGB24   */ { "RGB24",   ZORAN_VFEC_RGB_RGB888|ENDIANESS|ZORAN_VFEC_PACK24, 3 },
  128. /* RGB32   */ { "RGB32",   ZORAN_VFEC_RGB_RGB888|ENDIANESS, 4 },
  129. /* RGB555  */ { "RGB555",  ZORAN_VFEC_RGB_RGB555|ENDIANESS, 2 },
  130. /* YUV422  */ { "YUV422",  ZORAN_VFEC_RGB_YUV422|ENDIANESS, 2 },
  131. /* YUYV    */ { "YUYV",    0, 0 },
  132. /* UYVY    */ { "UYVY",    0, 0 },
  133. /* YUV420  */ { "YUV420",  0, 0 },
  134. /* YUV411  */ { "YUV411",  0, 0 },
  135. /* RAW     */ { "RAW",     0, 0 },
  136. /* YUV422P */ { "YUV422P", 0, 0 },
  137. /* YUV411P */ { "YUV411P", 0, 0 }};
  138. #define NRPALETTES (sizeof(palette2fmt)/sizeof(palette2fmt[0]))
  139. #undef ENDIANESS
  141. /* ----------------------------------------------------------------------- */
  142. /* ZORAN chipset detector                                                 */
  143. /* shamelessly stolen from bttv.c                                         */
  144. /* Reason for beeing here: we need to detect if we are running on a        */
  145. /* Triton based chipset, and if so, enable a certain bit                   */
  146. /* ----------------------------------------------------------------------- */
  147. static
  148. void __init handle_chipset(void)
  149. {
  150. struct pci_dev *dev = NULL;
  152. /* Just in case some nut set this to something dangerous */
  153. if (triton1)
  154. triton1 = ZORAN_VDC_TRICOM;
  156. while ((dev = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82437, dev)))
  157. {
  158. printk(KERN_INFO "zoran: Host bridge 82437FX Triton PIIXn");
  159. triton1 = ZORAN_VDC_TRICOM;
  160. }
  161. }
  163. /* ----------------------------------------------------------------------- */
  164. /* ZORAN functions    */
  165. /* ----------------------------------------------------------------------- */
  167. static void zoran_set_geo(struct zoran* ztv, struct vidinfo* i);
  169. #if 0 /* unused */
  170. static
  171. void zoran_dump(struct zoran *ztv)
  172. {
  173. char str[256];
  174. char *p=str; /* shut up, gcc! */
  175. int i;
  177. for (i=0; i<0x60; i+=4) {
  178. if ((i % 16) == 0) {
  179. if (i) printk("%sn",str);
  180. p = str;
  181. p+= sprintf(str, KERN_DEBUG "       %04x: ",i);
  182. }
  183. p += sprintf(p, "%08x ",zrread(i));
  184. }
  185. }
  186. #endif /* unused */
  188. static
  189. void reap_states(struct zoran* ztv)
  190. {
  191. /* count frames */
  192. ztv->fieldnr++;
  194. /*
  195.  * Are we busy at all?
  196.  * This depends on if there is a workqueue AND the
  197.  * videotransfer is enabled on the chip...
  198.  */
  199. if (ztv->workqueue && (zrread(ZORAN_VDC) & ZORAN_VDC_VIDEN))
  200. {
  201. struct vidinfo* newitem;
  203. /* did we get a complete frame? */
  204. if (zrread(ZORAN_VSTR) & ZORAN_VSTR_GRAB)
  205. return;
  207. DEBUG(printk(CARD_DEBUG "completed %s at %pn",CARD,ztv->workqueue->kindof==FBUFFER_GRAB?"grab":"read",ztv->workqueue));
  209. /* we are done with this buffer, tell everyone */
  210. ztv->workqueue->status = FBUFFER_DONE;
  211. ztv->workqueue->fieldnr = ztv->fieldnr;
  212. /* not good, here for BTTV_FIELDNR reasons */
  213. ztv->lastfieldnr = ztv->fieldnr;
  215. switch (ztv->workqueue->kindof) {
  216.  case FBUFFER_GRAB:
  217. wake_up_interruptible(&ztv->grabq);
  218. break;
  219.  case FBUFFER_VBI:
  220. wake_up_interruptible(&ztv->vbiq);
  221. break;
  222.  default:
  223. printk(CARD_INFO "somebody killed the workqueue (kindof=%d)!n",CARD,ztv->workqueue->kindof);
  224. }
  226. /* item completed, skip to next item in queue */
  227. write_lock(&ztv->lock);
  228. newitem = ztv->workqueue->next;
  229. ztv->workqueue->next = 0; /* mark completed */
  230. ztv->workqueue = newitem;
  231. write_unlock(&ztv->lock);
  232. }
  234. /*
  235.  * ok, so it seems we have nothing in progress right now.
  236.  * Lets see if we can find some work.
  237.  */
  238. if (ztv->workqueue)
  239. {
  240. struct vidinfo* newitem;
  241. again:
  243. DEBUG(printk(CARD_DEBUG "starting %s at %pn",CARD,ztv->workqueue->kindof==FBUFFER_GRAB?"grab":"read",ztv->workqueue));
  245. /* loadup the frame settings */
  246. read_lock(&ztv->lock);
  247. zoran_set_geo(ztv,ztv->workqueue);
  248. read_unlock(&ztv->lock);
  250. switch (ztv->workqueue->kindof) {
  251.  case FBUFFER_GRAB:
  252.  case FBUFFER_VBI:
  253. zrand(~ZORAN_OCR_OVLEN, ZORAN_OCR);
  254. zror(ZORAN_VSTR_SNAPSHOT,ZORAN_VSTR);
  255. zror(ZORAN_VDC_VIDEN,ZORAN_VDC);
  257. /* start single-shot grab */
  258. zror(ZORAN_VSTR_GRAB, ZORAN_VSTR);
  259. break;
  260.  default:
  261. printk(CARD_INFO "what is this doing on the queue? (kindof=%d)n",CARD,ztv->workqueue->kindof);
  262. write_lock(&ztv->lock);
  263. newitem = ztv->workqueue->next;
  264. ztv->workqueue->next = 0;
  265. ztv->workqueue = newitem;
  266. write_unlock(&ztv->lock);
  267. if (newitem)
  268. goto again; /* yeah, sure.. */
  269. }
  270. /* bye for now */
  271. return;
  272. }
  273. DEBUG(printk(CARD_DEBUG "nothing in queuen",CARD));
  275. /*
  276.  * What? Even the workqueue is empty? Am i really here
  277.  * for nothing? Did i come all that way to... do nothing?
  278.  */
  280. /* do we need to overlay? */
  281. if (test_bit(STATE_OVERLAY, &ztv->state))
  282. {
  283. /* are we already overlaying? */
  284. if (!(zrread(ZORAN_OCR) & ZORAN_OCR_OVLEN) ||
  285.     !(zrread(ZORAN_VDC) & ZORAN_VDC_VIDEN))
  286. {
  287. DEBUG(printk(CARD_DEBUG "starting overlayn",CARD));
  289. read_lock(&ztv->lock);
  290. zoran_set_geo(ztv,&ztv->overinfo);
  291. read_unlock(&ztv->lock);
  293. zror(ZORAN_OCR_OVLEN, ZORAN_OCR);
  294. zrand(~ZORAN_VSTR_SNAPSHOT,ZORAN_VSTR);
  295. zror(ZORAN_VDC_VIDEN,ZORAN_VDC);
  296. }
  298. /*
  299.  * leave overlaying on, but turn interrupts off.
  300.  */
  301. zrand(~ZORAN_ICR_EN,ZORAN_ICR);
  302. return;
  303. }
  305. /* do we have any VBI idle time processing? */
  306. if (test_bit(STATE_VBI, &ztv->state))
  307. {
  308. struct vidinfo* item;
  309. struct vidinfo* lastitem;
  311. /* protect the workqueue */
  312. write_lock(&ztv->lock);
  313. lastitem = ztv->workqueue;
  314. if (lastitem)
  315. while (lastitem->next) lastitem = lastitem->next;
  316. for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++)
  317. if (item->next == 0 && item->status == FBUFFER_FREE)
  318. {
  319. DEBUG(printk(CARD_DEBUG "%p added to queuen",CARD,item));
  320. item->status = FBUFFER_BUSY;
  321. if (!lastitem)
  322. ztv->workqueue = item;
  323. else 
  324. lastitem->next = item;
  325. lastitem = item;
  326. }
  327. write_unlock(&ztv->lock);
  328. if (ztv->workqueue)
  329. goto again; /* hey, _i_ graduated :) */
  330. }
  332. /*
  333.  * Then we must be realy IDLE
  334.  */
  335. DEBUG(printk(CARD_DEBUG "turning offn",CARD));
  336. /* nothing further to do, disable DMA and further IRQs */
  337. zrand(~ZORAN_VDC_VIDEN,ZORAN_VDC);
  338. zrand(~ZORAN_ICR_EN,ZORAN_ICR);
  339. }
  341. static
  342. void zoran_irq(int irq, void *dev_id, struct pt_regs * regs)
  343. {
  344. u32 stat,estat;
  345. int count = 0;
  346. struct zoran *ztv = (struct zoran *)dev_id;
  348. UNUSED(irq); UNUSED(regs);
  349. for (;;) {
  350. /* get/clear interrupt status bits */
  351. stat=zrread(ZORAN_ISR);
  352. estat=stat & zrread(ZORAN_ICR);
  353. if (!estat)
  354. return;
  355. zrwrite(estat,ZORAN_ISR);
  356. IDEBUG(printk(CARD_DEBUG "estat %08xn",CARD,estat));
  357. IDEBUG(printk(CARD_DEBUG " stat %08xn",CARD,stat));
  359. if (estat & ZORAN_ISR_CODE)
  360. {
  361. IDEBUG(printk(CARD_DEBUG "CodReplIRQn",CARD));
  362. }
  363. if (estat & ZORAN_ISR_GIRQ0)
  364. {
  365. IDEBUG(printk(CARD_DEBUG "GIRQ0n",CARD));
  366. if (!ztv->card->usegirq1)
  367. reap_states(ztv);
  368. }
  369. if (estat & ZORAN_ISR_GIRQ1)
  370. {
  371. IDEBUG(printk(CARD_DEBUG "GIRQ1n",CARD));
  372. if (ztv->card->usegirq1)
  373. reap_states(ztv);
  374. }
  376. count++;
  377. if (count > 10)
  378. printk(CARD_ERR "irq loop %d (%x)n",CARD,count,estat);
  379. if (count > 20)
  380. {
  381. zrwrite(0, ZORAN_ICR);
  382. printk(CARD_ERR "IRQ lockup, cleared int maskn",CARD);
  383. }
  384. }
  385. }
  387. static
  388. int zoran_muxsel(struct zoran* ztv, int channel, int norm)
  389. {
  390. int rv;
  392. /* set the new video norm */
  393. rv = i2c_control_device(&(ztv->i2c), I2C_DRIVERID_VIDEODECODER, DECODER_SET_NORM, &norm);
  394. if (rv)
  395. return rv;
  396. ztv->norm = norm;
  398. /* map the given channel to the cards decoder's channel */
  399. channel = ztv->card->video_mux[channel] & CHANNEL_MASK;
  401. /* set the new channel */
  402. rv = i2c_control_device(&(ztv->i2c), I2C_DRIVERID_VIDEODECODER, DECODER_SET_INPUT, &channel);
  403. return rv;
  404. }
  406. /* Tell the interrupt handler what to to.  */
  407. static
  408. void zoran_cap(struct zoran* ztv, int on)
  409. {
  410. DEBUG(printk(CARD_DEBUG "zoran_cap(%d) state=%xn",CARD,on,ztv->state));
  412. if (on) {
  413. ztv->running = 1;
  415. /*
  416.  * turn interrupts (back) on. The DMA will be enabled
  417.  * inside the irq handler when it detects a restart.
  418.  */
  419. zror(ZORAN_ICR_EN,ZORAN_ICR);
  420. }
  421. else {
  422. /*
  423.  * turn both interrupts and DMA off
  424.  */
  425. zrand(~ZORAN_VDC_VIDEN,ZORAN_VDC);
  426. zrand(~ZORAN_ICR_EN,ZORAN_ICR);
  428. ztv->running = 0;
  429. }
  430. }
  432. static ulong dmask[] = {
  433. 0xFFFFFFFF, 0xFFFFFFFE, 0xFFFFFFFC, 0xFFFFFFF8,
  434. 0xFFFFFFF0, 0xFFFFFFE0, 0xFFFFFFC0, 0xFFFFFF80,
  435. 0xFFFFFF00, 0xFFFFFE00, 0xFFFFFC00, 0xFFFFF800,
  436. 0xFFFFF000, 0xFFFFE000, 0xFFFFC000, 0xFFFF8000,
  437. 0xFFFF0000, 0xFFFE0000, 0xFFFC0000, 0xFFF80000,
  438. 0xFFF00000, 0xFFE00000, 0xFFC00000, 0xFF800000,
  439. 0xFF000000, 0xFE000000, 0xFC000000, 0xF8000000,
  440. 0xF0000000, 0xE0000000, 0xC0000000, 0x80000000
  441. };
  443. static
  444. void zoran_built_overlay(struct zoran* ztv, int count, struct video_clip *vcp)
  445. {
  446. ulong* mtop;
  447. int ystep = (ztv->vidXshift + ztv->vidWidth+31)/32; /* next DWORD */
  448. int i;
  450. DEBUG(printk(KERN_DEBUG "       overlay at %p, ystep=%d, clips=%dn",ztv->overinfo.overlay,ystep,count));
  452. for (i=0; i<count; i++) {
  453. struct video_clip *vp = vcp+i;
  454. UNUSED(vp);
  455. DEBUG(printk(KERN_DEBUG "       %d: clip(%d,%d,%d,%d)n", i,vp->x,vp->y,vp->width,vp->height));
  456. }
  458. /*
  459.  * activate the visible portion of the screen
  460.  * Note we take some shortcuts here, because we
  461.  * know the width can never be < 32. (I.e. a DWORD)
  462.  * We also assume the overlay starts somewhere in
  463.  * the FIRST dword.
  464.  */
  465. {
  466. int start = ztv->vidXshift;
  467. ulong firstd = dmask[start];
  468. ulong lastd = ~dmask[(start + ztv->overinfo.w) & 31];
  469. mtop = ztv->overinfo.overlay;
  470. for (i=0; i<ztv->overinfo.h; i++) {
  471. int w = ztv->vidWidth;
  472. ulong* line = mtop;
  473. if (start & 31) {
  474. *line++ = firstd;
  475. w -= 32-(start&31);
  476. }
  477. memset(line, ~0, w/8);
  478. if (w & 31)
  479. line[w/32] = lastd;
  480. mtop += ystep;
  481. }
  482. }
  484. /* process clipping regions */
  485. for (i=0; i<count; i++) {
  486. int h;
  487. if (vcp->x < 0 || (uint)vcp->x > ztv->overinfo.w ||
  488.     vcp->y < 0 || vcp->y > ztv->overinfo.h ||
  489.     vcp->width < 0 || (uint)(vcp->x+vcp->width) > ztv->overinfo.w ||
  490.     vcp->height < 0 || (vcp->y+vcp->height) > ztv->overinfo.h)
  491. {
  492. DEBUG(printk(CARD_DEBUG "illegal clipzone (%d,%d,%d,%d) not in (0,0,%d,%d), adaptingn",CARD,vcp->x,vcp->y,vcp->width,vcp->height,ztv->overinfo.w,ztv->overinfo.h));
  493. if (vcp->x < 0) vcp->x = 0;
  494. if ((uint)vcp->x > ztv->overinfo.w) vcp->x = ztv->overinfo.w;
  495. if (vcp->y < 0) vcp->y = 0;
  496. if (vcp->y > ztv->overinfo.h) vcp->y = ztv->overinfo.h;
  497. if (vcp->width < 0) vcp->width = 0;
  498. if ((uint)(vcp->x+vcp->width) > ztv->overinfo.w) vcp->width = ztv->overinfo.w - vcp->x;
  499. if (vcp->height < 0) vcp->height = 0;
  500. if (vcp->y+vcp->height > ztv->overinfo.h) vcp->height = ztv->overinfo.h - vcp->y;
  501. // continue;
  502. }
  504. mtop = &ztv->overinfo.overlay[vcp->y*ystep];
  505. for (h=0; h<=vcp->height; h++) {
  506. int w;
  507. int x = ztv->vidXshift + vcp->x;
  508. for (w=0; w<=vcp->width; w++) {
  509. clear_bit(x&31, &mtop[x/32]);
  510. x++;
  511. }
  512. mtop += ystep;
  513. }
  514. ++vcp;
  515. }
  517. mtop = ztv->overinfo.overlay;
  518. zrwrite(virt_to_bus(mtop), ZORAN_MTOP);
  519. zrwrite(virt_to_bus(mtop+ystep), ZORAN_MBOT);
  520. zraor((ztv->vidInterlace*ystep)<<0,~ZORAN_OCR_MASKSTRIDE,ZORAN_OCR);
  521. }
  523. struct tvnorm 
  524. {
  525. u16 Wt, Wa, Ht, Ha, HStart, VStart;
  526. };
  528. static struct tvnorm tvnorms[] = {
  529. /* PAL-BDGHI */
  530. /* { 864, 720, 625, 576, 131, 21 },*/
  531. /*00*/ { 864, 768, 625, 576, 81, 17 },
  532. /* NTSC */
  533. /*01*/ { 858, 720, 525, 480, 121, 10 },
  534. /* SECAM */
  535. /*02*/ { 864, 720, 625, 576, 131, 21 },
  536. /* BW50 */
  537. /*03*/ { 864, 720, 625, 576, 131, 21 },
  538. /* BW60 */
  539. /*04*/ { 858, 720, 525, 480, 121, 10 }
  540. };
  541. #define TVNORMS (sizeof(tvnorms)/sizeof(tvnorm))
  543. /*
  544.  * Program the chip for a setup as described in the vidinfo struct.
  545.  *
  546.  * Side-effects: calculates vidXshift, vidInterlace,
  547.  * vidHeight, vidWidth which are used in a later stage
  548.  * to calculate the overlay mask
  549.  *
  550.  * This is an internal function, as such it does not check the
  551.  * validity of the struct members... Spectaculair crashes will
  552.  * follow /very/ quick when you're wrong and the chip right :)
  553.  */
  554. static
  555. void zoran_set_geo(struct zoran* ztv, struct vidinfo* i)
  556. {
  557. ulong top, bot;
  558. int stride;
  559. int winWidth, winHeight;
  560. int maxWidth, maxHeight, maxXOffset, maxYOffset;
  561. long vfec;
  563. DEBUG(printk(CARD_DEBUG "set_geo(rect=(%d,%d,%d,%d), norm=%d, format=%d, bpp=%d, bpl=%d, busadr=%lx, overlay=%p)n",CARD,i->x,i->y,i->w,i->h,ztv->norm,i->format,i->bpp,i->bpl,i->busadr,i->overlay));
  565. /*
  566.  * make sure the DMA transfers are inhibited during our
  567.  * reprogramming of the chip
  568.  */
  569. zrand(~ZORAN_VDC_VIDEN,ZORAN_VDC);
  571. maxWidth = tvnorms[ztv->norm].Wa;
  572. maxHeight = tvnorms[ztv->norm].Ha/2;
  573. maxXOffset = tvnorms[ztv->norm].HStart;
  574. maxYOffset = tvnorms[ztv->norm].VStart;
  576. /* setup vfec register (keep ExtFl,TopField and VCLKPol settings) */
  577. vfec = (zrread(ZORAN_VFEC) & (ZORAN_VFEC_EXTFL|ZORAN_VFEC_TOPFIELD|ZORAN_VFEC_VCLKPOL)) |
  578.        (palette2fmt[i->format].mode & (ZORAN_VFEC_RGB|ZORAN_VFEC_ERRDIF|ZORAN_VFEC_LE|ZORAN_VFEC_PACK24));
  580. /*
  581.  * Set top, bottom ptrs. Since these must be DWORD aligned,
  582.  * possible adjust the x and the width of the window.
  583.  * so the endposition stay the same. The vidXshift will make
  584.  * sure we are not writing pixels before the requested x.
  585.  */
  586. ztv->vidXshift = 0;
  587. winWidth = i->w;
  588. if (winWidth < 0)
  589. winWidth = -winWidth;
  590. top = i->busadr + i->x*i->bpp + i->y*i->bpl;
  591. if (top & 3) {
  592. ztv->vidXshift = (top & 3) / i->bpp;
  593. winWidth += ztv->vidXshift;
  594. DEBUG(printk(KERN_DEBUG "       window-x shifted %d pixels leftn",ztv->vidXshift));
  595. top &= ~3;
  596. }
  598. /*
  599.  * bottom points to next frame but in interleaved mode we want
  600.  * to 'mix' the 2 frames to one capture, so 'bot' points to one
  601.  * (physical) line below the top line.
  602.  */
  603. bot = top + i->bpl;
  604. zrwrite(top,ZORAN_VTOP);
  605. zrwrite(bot,ZORAN_VBOT);
  607. /*
  608.  * Make sure the winWidth is DWORD aligned too,
  609.  * thereby automaticly making sure the stride to the
  610.  * next line is DWORD aligned too (as required by spec).
  611.  */
  612. if ((winWidth*i->bpp) & 3) {
  613. DEBUG(printk(KERN_DEBUG "       window-width enlarged by %d pixelsn",(winWidth*i->bpp) & 3));
  614. winWidth += (winWidth*i->bpp) & 3;
  615. }
  617. /* determine the DispMode and stride */
  618. if (i->h >= 0 && i->h <= maxHeight) {
  619. /* single frame grab suffices for this height. */
  620. vfec |= ZORAN_VFEC_DISPMOD;
  621. ztv->vidInterlace = 0;
  622. stride = i->bpl - (winWidth*i->bpp);
  623. winHeight = i->h;
  624. }
  625. else {
  626. /* interleaving needed for this height */
  627. ztv->vidInterlace = 1;
  628. stride = i->bpl*2 - (winWidth*i->bpp);
  629. winHeight = i->h/2;
  630. }
  631. if (winHeight < 0) /* can happen for VBI! */
  632. winHeight = -winHeight;
  634. /* safety net, sometimes bpl is too short??? */
  635. if (stride<0) {
  636. DEBUG(printk(CARD_DEBUG "WARNING stride = %dn",CARD,stride));
  637. stride = 0;
  638. }
  640. zraor((winHeight<<12)|(winWidth<<0),~(ZORAN_VDC_VIDWINHT|ZORAN_VDC_VIDWINWID), ZORAN_VDC);
  641. zraor(stride<<16,~ZORAN_VSTR_DISPSTRIDE,ZORAN_VSTR);
  643. /* remember vidWidth, vidHeight for overlay calculations */
  644. ztv->vidWidth = winWidth;
  645. ztv->vidHeight = winHeight;
  646. DEBUG(printk(KERN_DEBUG "       top=%08lx, bottom=%08lxn",top,bot));
  647. DEBUG(printk(KERN_DEBUG "       winWidth=%d, winHeight=%dn",winWidth,winHeight));
  648. DEBUG(printk(KERN_DEBUG "       maxWidth=%d, maxHeight=%dn",maxWidth,maxHeight));
  649. DEBUG(printk(KERN_DEBUG "       stride=%dn",stride));
  651. /*
  652.  * determine horizontal scales and crops
  653.  */
  654. if (i->w < 0) {
  655. int Hstart = 1;
  656. int Hend = Hstart + winWidth;
  657. DEBUG(printk(KERN_DEBUG "       Y: scale=0, start=%d, end=%dn", Hstart, Hend));
  658. zraor((Hstart<<10)|(Hend<<0),~(ZORAN_VFEH_HSTART|ZORAN_VFEH_HEND),ZORAN_VFEH);
  659. }
  660. else {
  661. int Wa = maxWidth;
  662. int X = (winWidth*64+Wa-1)/Wa;
  663. int We = winWidth*64/X;
  664. int HorDcm = 64-X;
  665. int hcrop1 = 2*(Wa-We)/4;
  666. /*
  667.  * BUGFIX: Juha Nurmela <junki@qn-lpr2-165.quicknet.inet.fi> 
  668.  * found the solution to the color phase shift.
  669.  * See ChangeLog for the full explanation)
  670.  */
  671. int Hstart = (maxXOffset + hcrop1) | 1;
  672. int Hend = Hstart + We - 1;
  674. DEBUG(printk(KERN_DEBUG "       X: scale=%d, start=%d, end=%dn", HorDcm, Hstart, Hend));
  676. zraor((Hstart<<10)|(Hend<<0),~(ZORAN_VFEH_HSTART|ZORAN_VFEH_HEND),ZORAN_VFEH);
  677. vfec |= HorDcm<<14;
  679. if (HorDcm<16)
  680. vfec |= ZORAN_VFEC_HFILTER_1; /* no filter */
  681. else if (HorDcm<32)
  682. vfec |= ZORAN_VFEC_HFILTER_3; /* 3 tap filter */
  683. else if (HorDcm<48)
  684. vfec |= ZORAN_VFEC_HFILTER_4; /* 4 tap filter */
  685. else vfec |= ZORAN_VFEC_HFILTER_5; /* 5 tap filter */
  686. }
  688. /*
  689.  * Determine vertical scales and crops
  690.  *
  691.  * when height is negative, we want to read starting at line 0
  692.  * One day someone might need access to these lines...
  693.  */
  694. if (i->h < 0) {
  695. int Vstart = 0;
  696. int Vend = Vstart + winHeight;
  697. DEBUG(printk(KERN_DEBUG "       Y: scale=0, start=%d, end=%dn", Vstart, Vend));
  698. zraor((Vstart<<10)|(Vend<<0),~(ZORAN_VFEV_VSTART|ZORAN_VFEV_VEND),ZORAN_VFEV);
  699. }
  700. else {
  701. int Ha = maxHeight;
  702. int Y = (winHeight*64+Ha-1)/Ha;
  703. int He = winHeight*64/Y;
  704. int VerDcm = 64-Y;
  705. int vcrop1 = 2*(Ha-He)/4;
  706. int Vstart = maxYOffset + vcrop1;
  707. int Vend = Vstart + He - 1;
  709. DEBUG(printk(KERN_DEBUG "       Y: scale=%d, start=%d, end=%dn", VerDcm, Vstart, Vend));
  710. zraor((Vstart<<10)|(Vend<<0),~(ZORAN_VFEV_VSTART|ZORAN_VFEV_VEND),ZORAN_VFEV);
  711. vfec |= VerDcm<<8;
  712. }
  714. DEBUG(printk(KERN_DEBUG "       F: format=%d(=%s)n",i->format,palette2fmt[i->format].name));
  716. /* setup the requested format */
  717. zrwrite(vfec, ZORAN_VFEC);
  718. }
  720. static
  721. void zoran_common_open(struct zoran* ztv, int flags)
  722. {
  723. UNUSED(flags);
  725. /* already opened? */
  726. if (ztv->users++ != 0)
  727. return;
  729. /* unmute audio */
  730. /* /what/ audio? */
  732. ztv->state = 0;
  734. /* setup the encoder to the initial values */
  735. ztv->picture.colour=254<<7;
  736. ztv->picture.brightness=128<<8;
  737. ztv->picture.hue=128<<8;
  738. ztv->picture.contrast=216<<7;
  739. i2c_control_device(&ztv->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_PICTURE, &ztv->picture);
  741. /* default to the composite input since my camera is there */
  742. zoran_muxsel(ztv, 0, VIDEO_MODE_PAL);
  743. }
  745. static
  746. void zoran_common_close(struct zoran* ztv)
  747. {
  748. if (--ztv->users != 0)
  749. return;
  751. /* mute audio */
  752. /* /what/ audio? */
  754. /* stop the chip */
  755. zoran_cap(ztv, 0);
  756. }
  758. /*
  759.  * Open a zoran card. Right now the flags are just a hack
  760.  */
  761. static int zoran_open(struct video_device *dev, int flags)
  762. {
  763. struct zoran *ztv = (struct zoran*)dev;
  764. struct vidinfo* item;
  765. char* pos;
  767. DEBUG(printk(CARD_DEBUG "open(dev,%d)n",CARD,flags));
  769. /*********************************************
  770.  * We really should be doing lazy allocing...
  771.  *********************************************/
  772. /* allocate a frame buffer */
  773. if (!ztv->fbuffer)
  774. ztv->fbuffer = bmalloc(ZORAN_MAX_FBUFSIZE);
  775. if (!ztv->fbuffer) {
  776. /* could not get a buffer, bail out */
  777. return -ENOBUFS;
  778. }
  779. /* at this time we _always_ have a framebuffer */
  780. memset(ztv->fbuffer,0,ZORAN_MAX_FBUFSIZE);
  782. if (!ztv->overinfo.overlay)
  783. ztv->overinfo.overlay = (void*)kmalloc(1024*1024/8, GFP_KERNEL);
  784. if (!ztv->overinfo.overlay) {
  785. /* could not get an overlay buffer, bail out */
  786. bfree(ztv->fbuffer, ZORAN_MAX_FBUFSIZE);
  787. return -ENOBUFS;
  788. }
  789. /* at this time we _always_ have a overlay */
  791. /* clear buffer status, and give them a DMAable address */
  792. pos = ztv->fbuffer;
  793. for (item=ztv->grabinfo; item!=ztv->grabinfo+ZORAN_MAX_FBUFFERS; item++)
  794. {
  795. item->status = FBUFFER_FREE;
  796. item->memadr = pos;
  797. item->busadr = virt_to_bus(pos);
  798. pos += ZORAN_MAX_FBUFFER;
  799. }
  801. /* do the common part of all open's */
  802. zoran_common_open(ztv, flags);
  804. return 0;
  805. }
  807. static
  808. void zoran_close(struct video_device* dev)
  809. {
  810. struct zoran *ztv = (struct zoran*)dev;
  812. DEBUG(printk(CARD_DEBUG "close(dev)n",CARD));
  814. /* driver specific closure */
  815. clear_bit(STATE_OVERLAY, &ztv->state);
  817. zoran_common_close(ztv);
  819.         /*
  820.          *      This is sucky but right now I can't find a good way to
  821.          *      be sure its safe to free the buffer. We wait 5-6 fields
  822.          *      which is more than sufficient to be sure.
  823.          */
  824.         current->state = TASK_UNINTERRUPTIBLE;
  825.         schedule_timeout(HZ/10);        /* Wait 1/10th of a second */
  827. /* free the allocated framebuffer */
  828. if (ztv->fbuffer)
  829. bfree( ztv->fbuffer, ZORAN_MAX_FBUFSIZE );
  830. ztv->fbuffer = 0;
  831. if (ztv->overinfo.overlay)
  832. kfree( ztv->overinfo.overlay );
  833. ztv->overinfo.overlay = 0;
  835. }
  837. /*
  838.  * This read function could be used reentrant in a SMP situation.
  839.  *
  840.  * This is made possible by the spinlock which is kept till we
  841.  * found and marked a buffer for our own use. The lock must
  842.  * be released as soon as possible to prevent lock contention.
  843.  */
  844. static
  845. long zoran_read(struct video_device* dev, char* buf, unsigned long count, int nonblock)
  846. {
  847. struct zoran *ztv = (struct zoran*)dev;
  848. unsigned long max;
  849. struct vidinfo* unused = 0;
  850. struct vidinfo* done = 0;
  852. DEBUG(printk(CARD_DEBUG "zoran_read(%p,%ld,%d)n",CARD,buf,count,nonblock));
  854. /* find ourself a free or completed buffer */
  855. for (;;) {
  856. struct vidinfo* item;
  858. write_lock_irq(&ztv->lock);
  859. for (item=ztv->grabinfo; item!=ztv->grabinfo+ZORAN_MAX_FBUFFERS; item++)
  860. {
  861. if (!unused && item->status == FBUFFER_FREE)
  862. unused = item;
  863. if (!done && item->status == FBUFFER_DONE)
  864. done = item;
  865. }
  866. if (done || unused)
  867. break;
  869. /* no more free buffers, wait for them. */
  870. write_unlock_irq(&ztv->lock);
  871. if (nonblock)
  872. return -EWOULDBLOCK;
  873. interruptible_sleep_on(&ztv->grabq);
  874. if (signal_pending(current))
  875. return -EINTR;
  876. }
  878. /* Do we have 'ready' data? */
  879. if (!done) {
  880. /* no? than this will take a while... */
  881. if (nonblock) {
  882. write_unlock_irq(&ztv->lock);
  883. return -EWOULDBLOCK;
  884. }
  886. /* mark the unused buffer as wanted */
  887. unused->status = FBUFFER_BUSY;
  888. unused->w = 320;
  889. unused->h = 240;
  890. unused->format = VIDEO_PALETTE_RGB24;
  891. unused->bpp = palette2fmt[unused->format].bpp;
  892. unused->bpl = unused->w * unused->bpp;
  893. unused->next = 0;
  894. { /* add to tail of queue */
  895.   struct vidinfo* oldframe = ztv->workqueue;
  896.   if (!oldframe) ztv->workqueue = unused;
  897.   else {
  898.     while (oldframe->next) oldframe = oldframe->next;
  899.     oldframe->next = unused;
  900.   }
  901. }
  902. write_unlock_irq(&ztv->lock);
  904. /* tell the state machine we want it filled /NOW/ */
  905. zoran_cap(ztv, 1);
  907. /* wait till this buffer gets grabbed */
  908. while (unused->status == FBUFFER_BUSY) {
  909. interruptible_sleep_on(&ztv->grabq);
  910. /* see if a signal did it */
  911. if (signal_pending(current))
  912. return -EINTR;
  913. }
  914. done = unused;
  915. }
  916. else
  917. write_unlock_irq(&ztv->lock);
  919. /* Yes! we got data! */
  920. max = done->bpl * done->h;
  921. if (count > max)
  922. count = max;
  923. if (copy_to_user((void*)buf, done->memadr, count))
  924. count = -EFAULT;
  926. /* keep the engine running */
  927. done->status = FBUFFER_FREE;
  928. // zoran_cap(ztv,1);
  930. /* tell listeners this buffer became free */
  931. wake_up_interruptible(&ztv->grabq);
  933. /* goodbye */
  934. DEBUG(printk(CARD_DEBUG "zoran_read() returns %lun",CARD,count));
  935. return count;
  936. }
  938. static
  939. long zoran_write(struct video_device* dev, const char* buf, unsigned long count, int nonblock)
  940. {
  941. struct zoran *ztv = (struct zoran *)dev;
  942. UNUSED(ztv); UNUSED(dev); UNUSED(buf); UNUSED(count); UNUSED(nonblock);
  943. DEBUG(printk(CARD_DEBUG "zoran_writen",CARD));
  944. return -EINVAL;
  945. }
  947. #if LINUX_VERSION_CODE >= 0x020100
  948. static
  949. unsigned int zoran_poll(struct video_device *dev, struct file *file, poll_table *wait)
  950. {
  951. struct zoran *ztv = (struct zoran *)dev;
  952. struct vidinfo* item;
  953. unsigned int mask = 0;
  955. poll_wait(file, &ztv->grabq, wait);
  957. for (item=ztv->grabinfo; item!=ztv->grabinfo+ZORAN_MAX_FBUFFERS; item++)
  958. if (item->status == FBUFFER_DONE)
  959. {
  960. mask |= (POLLIN | POLLRDNORM);
  961. break;
  962. }
  964. DEBUG(printk(CARD_DEBUG "zoran_poll()=%xn",CARD,mask));
  966. return mask;
  967. }
  968. #endif
  970. /* append a new clipregion to the vector of video_clips */
  971. static
  972. void new_clip(struct video_window* vw, struct video_clip* vcp, int x, int y, int w, int h)
  973. {
  974. vcp[vw->clipcount].x = x;
  975. vcp[vw->clipcount].y = y;
  976. vcp[vw->clipcount].width = w;
  977. vcp[vw->clipcount].height = h;
  978. vw->clipcount++;
  979. }
  981. static
  982. int zoran_ioctl(struct video_device* dev, unsigned int cmd, void *arg)
  983. {
  984. struct zoran* ztv = (struct zoran*)dev;
  986. switch (cmd) {
  987.  case VIDIOCGCAP:
  988.  {
  989. struct video_capability c;
  990. DEBUG(printk(CARD_DEBUG "VIDIOCGCAPn",CARD));
  992. strcpy(c.name,ztv->video_dev.name);
  993. c.type = VID_TYPE_CAPTURE|
  994.  VID_TYPE_OVERLAY|
  995.  VID_TYPE_CLIPPING|
  996.  VID_TYPE_FRAMERAM|
  997.  VID_TYPE_SCALES;
  998. if (ztv->have_tuner)
  999. c.type |= VID_TYPE_TUNER;
  1000. if (ztv->have_decoder) {
  1001. c.channels = ztv->card->video_inputs;
  1002. c.audios = ztv->card->audio_inputs;
  1003. } else
  1004. /* no decoder -> no channels */
  1005. c.channels = c.audios = 0;
  1006. c.maxwidth = 768;
  1007. c.maxheight = 576;
  1008. c.minwidth = 32;
  1009. c.minheight = 32;
  1010. if (copy_to_user(arg,&c,sizeof(c)))
  1011. return -EFAULT;
  1012. break;
  1013.  }
  1015.  case VIDIOCGCHAN:
  1016.  {
  1017. struct video_channel v;
  1018. int mux;
  1019. if (copy_from_user(&v, arg,sizeof(v)))
  1020. return -EFAULT;
  1021. DEBUG(printk(CARD_DEBUG "VIDIOCGCHAN(%d)n",CARD,v.channel));
  1022. v.flags=VIDEO_VC_AUDIO
  1023. #ifdef VIDEO_VC_NORM
  1024. |VIDEO_VC_NORM
  1025. #endif
  1026. ;
  1027. v.tuners=0;
  1028. v.type=VIDEO_TYPE_CAMERA;
  1029. #ifdef I_EXPECT_POSSIBLE_NORMS_IN_THE_API
  1030. v.norm=VIDEO_MODE_PAL|
  1031.        VIDEO_MODE_NTSC|
  1032.        VIDEO_MODE_SECAM;
  1033. #else
  1034. v.norm=VIDEO_MODE_PAL;
  1035. #endif
  1036. /* too many inputs? no decoder -> no channels */
  1037. if (!ztv->have_decoder || v.channel < 0 ||  v.channel >= ztv->card->video_inputs)
  1038. return -EINVAL;
  1040. /* now determine the name of the channel */
  1041. mux = ztv->card->video_mux[v.channel];
  1042. if (mux & IS_TUNER) {
  1043. /* lets assume only one tuner, yes? */
  1044. strcpy(v.name,"Television");
  1045. v.type = VIDEO_TYPE_TV;
  1046. if (ztv->have_tuner) {
  1047. v.flags |= VIDEO_VC_TUNER;
  1048. v.tuners = 1;
  1049. }
  1050. }
  1051. else if (mux & IS_SVHS)
  1052. sprintf(v.name,"S-Video-%d",v.channel);
  1053. else
  1054. sprintf(v.name,"CVBS-%d",v.channel);
  1056. if (copy_to_user(arg,&v,sizeof(v)))
  1057. return -EFAULT;
  1058. break;
  1059.  }
  1060.  case VIDIOCSCHAN:
  1061.  { /* set video channel */
  1062. struct video_channel v;
  1063. if (copy_from_user(&v, arg,sizeof(v)))
  1064. return -EFAULT;
  1065. DEBUG(printk(CARD_DEBUG "VIDIOCSCHAN(%d,%d)n",CARD,v.channel,v.norm));
  1067. /* too many inputs? no decoder -> no channels */
  1068. if (!ztv->have_decoder || v.channel >= ztv->card->video_inputs || v.channel < 0)
  1069. return -EINVAL;
  1071. if (v.norm != VIDEO_MODE_PAL &&
  1072.     v.norm != VIDEO_MODE_NTSC &&
  1073.     v.norm != VIDEO_MODE_SECAM &&
  1074.     v.norm != VIDEO_MODE_AUTO)
  1075. return -EOPNOTSUPP;
  1077. /* make it happen, nr1! */
  1078. return zoran_muxsel(ztv,v.channel,v.norm);
  1079.  }
  1081.  case VIDIOCGTUNER:
  1082.  {
  1083. struct video_tuner v;
  1084. if (copy_from_user(&v, arg,sizeof(v)))
  1085. return -EFAULT;
  1086. DEBUG(printk(CARD_DEBUG "VIDIOCGTUNER(%d)n",CARD,v.tuner));
  1088. /* Only no or one tuner for now */
  1089. if (!ztv->have_tuner || v.tuner)
  1090. return -EINVAL;
  1092. strcpy(v.name,"Television");
  1093. v.rangelow  = 0;
  1094. v.rangehigh = ~0;
  1095. v.flags     = VIDEO_TUNER_PAL|VIDEO_TUNER_NTSC|VIDEO_TUNER_SECAM;
  1096. v.mode      = ztv->norm;
  1097. v.signal    = 0xFFFF; /* unknown */
  1099. if (copy_to_user(arg,&v,sizeof(v)))
  1100. return -EFAULT;
  1101. break;
  1102.  }
  1103.  case VIDIOCSTUNER:
  1104.  {
  1105. struct video_tuner v;
  1106. if (copy_from_user(&v, arg, sizeof(v)))
  1107. return -EFAULT;
  1108. DEBUG(printk(CARD_DEBUG "VIDIOCSTUNER(%d,%d)n",CARD,v.tuner,v.mode));
  1110. /* Only no or one tuner for now */
  1111. if (!ztv->have_tuner || v.tuner)
  1112. return -EINVAL;
  1114. /* and it only has certain valid modes */
  1115. if( v.mode != VIDEO_MODE_PAL &&
  1116.     v.mode != VIDEO_MODE_NTSC &&
  1117.     v.mode != VIDEO_MODE_SECAM)
  1118. return -EOPNOTSUPP;
  1120. /* engage! */
  1121. return zoran_muxsel(ztv,v.tuner,v.mode);
  1122.  }
  1124.  case VIDIOCGPICT:
  1125.  {
  1126. struct video_picture p = ztv->picture;
  1127. DEBUG(printk(CARD_DEBUG "VIDIOCGPICTn",CARD));
  1128. p.depth = ztv->depth;
  1129. switch (p.depth) {
  1130.  case  8: p.palette=VIDEO_PALETTE_YUV422;
  1131.   break;
  1132.  case 15: p.palette=VIDEO_PALETTE_RGB555;
  1133.   break;
  1134.  case 16: p.palette=VIDEO_PALETTE_RGB565;
  1135.   break;
  1136.  case 24: p.palette=VIDEO_PALETTE_RGB24;
  1137.   break;
  1138.  case 32: p.palette=VIDEO_PALETTE_RGB32;
  1139.   break;
  1140. }
  1141. if (copy_to_user(arg, &p, sizeof(p)))
  1142. return -EFAULT;
  1143. break;
  1144.  }
  1145.  case VIDIOCSPICT:
  1146.  {
  1147. struct video_picture p;
  1148. if (copy_from_user(&p, arg,sizeof(p)))
  1149. return -EFAULT;
  1150. DEBUG(printk(CARD_DEBUG "VIDIOCSPICT(%d,%d,%d,%d,%d,%d,%d)n",CARD,p.brightness,p.hue,p.colour,p.contrast,p.whiteness,p.depth,p.palette));
  1152. /* depth must match with framebuffer */
  1153. if (p.depth != ztv->depth)
  1154. return -EINVAL;
  1156. /* check if palette matches this bpp */
  1157. if (p.palette>NRPALETTES ||
  1158.     palette2fmt[p.palette].bpp != ztv->overinfo.bpp)
  1159. return -EINVAL;
  1161. write_lock_irq(&ztv->lock);
  1162. ztv->overinfo.format = p.palette;
  1163. ztv->picture = p;
  1164. write_unlock_irq(&ztv->lock);
  1166. /* tell the decoder */
  1167. i2c_control_device(&ztv->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_PICTURE, &p);
  1168. break;
  1169.  }
  1171.  case VIDIOCGWIN:
  1172.  {
  1173. struct video_window vw;
  1174. DEBUG(printk(CARD_DEBUG "VIDIOCGWINn",CARD));
  1175. read_lock(&ztv->lock);
  1176. vw.x      = ztv->overinfo.x;
  1177. vw.y      = ztv->overinfo.y;
  1178. vw.width  = ztv->overinfo.w;
  1179. vw.height = ztv->overinfo.h;
  1180. vw.chromakey= 0;
  1181. vw.flags  = 0;
  1182. if (ztv->vidInterlace)
  1183. vw.flags|=VIDEO_WINDOW_INTERLACE;
  1184. read_unlock(&ztv->lock);
  1185. if (copy_to_user(arg,&vw,sizeof(vw)))
  1186. return -EFAULT;
  1187. break;
  1188.  }
  1189.  case VIDIOCSWIN:
  1190.  {
  1191. struct video_window vw;
  1192. struct video_clip *vcp;
  1193. int on;
  1194. if (copy_from_user(&vw,arg,sizeof(vw)))
  1195. return -EFAULT;
  1196. DEBUG(printk(CARD_DEBUG "VIDIOCSWIN(%d,%d,%d,%d,%x,%d)n",CARD,vw.x,vw.y,vw.width,vw.height,vw.flags,vw.clipcount));
  1198. if (vw.flags)
  1199. return -EINVAL;
  1201. if (vw.clipcount <0 || vw.clipcount>256)
  1202. return -EDOM;   /* Too many! */
  1204. /*
  1205.  *      Do any clips.
  1206.  */
  1207. vcp = vmalloc(sizeof(struct video_clip)*(vw.clipcount+4));
  1208. if (vcp==NULL)
  1209. return -ENOMEM;
  1210. if (vw.clipcount && copy_from_user(vcp,vw.clips,sizeof(struct video_clip)*vw.clipcount)) {
  1211. vfree(vcp);
  1212. return -EFAULT;
  1213. }
  1215. on = ztv->running;
  1216. if (on)
  1217. zoran_cap(ztv, 0);
  1219. /*
  1220.  * strange, it seems xawtv sometimes calls us with 0
  1221.  * width and/or height. Ignore these values
  1222.  */
  1223. if (vw.x == 0)
  1224. vw.x = ztv->overinfo.x;
  1225. if (vw.y == 0)
  1226. vw.y = ztv->overinfo.y;
  1228. /* by now we are committed to the new data... */
  1229. write_lock_irq(&ztv->lock);
  1230. ztv->overinfo.x = vw.x;
  1231. ztv->overinfo.y = vw.y;
  1232. ztv->overinfo.w = vw.width;
  1233. ztv->overinfo.h = vw.height;
  1234. write_unlock_irq(&ztv->lock);
  1236. /*
  1237.  *      Impose display clips
  1238.  */
  1239. if (vw.x+vw.width > ztv->swidth)
  1240. new_clip(&vw, vcp, ztv->swidth-vw.x, 0, vw.width-1, vw.height-1);
  1241. if (vw.y+vw.height > ztv->sheight)
  1242. new_clip(&vw, vcp, 0, ztv->sheight-vw.y, vw.width-1, vw.height-1);
  1244. /* built the requested clipping zones */
  1245. zoran_set_geo(ztv, &ztv->overinfo);
  1246. zoran_built_overlay(ztv, vw.clipcount, vcp);
  1247. vfree(vcp);
  1249. /* if we were on, restart the video engine */
  1250. if (on)
  1251. zoran_cap(ztv, 1);
  1252. break;
  1253.  }
  1255.  case VIDIOCCAPTURE:
  1256.  {
  1257. int v;
  1258. if (get_user(v, (int *)arg))
  1259. return -EFAULT;
  1260. DEBUG(printk(CARD_DEBUG "VIDIOCCAPTURE(%d)n",CARD,v));
  1262. if (v==0) {
  1263. clear_bit(STATE_OVERLAY, &ztv->state);
  1264. zoran_cap(ztv, 1);
  1265. }
  1266. else {
  1267. /* is VIDIOCSFBUF, VIDIOCSWIN done? */
  1268. if (ztv->overinfo.busadr==0 || ztv->overinfo.w==0 || ztv->overinfo.h==0)
  1269. return -EINVAL;
  1271. set_bit(STATE_OVERLAY, &ztv->state);
  1272. zoran_cap(ztv, 1);
  1273. }
  1274. break;
  1275.  }
  1277.  case VIDIOCGFBUF:
  1278.  {
  1279. struct video_buffer v;
  1280. DEBUG(printk(CARD_DEBUG "VIDIOCGFBUFn",CARD));
  1281. read_lock(&ztv->lock);
  1282. v.base   = (void *)ztv->overinfo.busadr;
  1283. v.height = ztv->sheight;
  1284. v.width  = ztv->swidth;
  1285. v.depth  = ztv->depth;
  1286. v.bytesperline = ztv->overinfo.bpl;
  1287. read_unlock(&ztv->lock);
  1288. if(copy_to_user(arg, &v,sizeof(v)))
  1289. return -EFAULT;
  1290. break;
  1291.  }
  1292.  case VIDIOCSFBUF:
  1293.  {
  1294. struct video_buffer v;
  1295. #if LINUX_VERSION_CODE >= 0x020100
  1296. if(!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_ADMIN))
  1297. #else
  1298. if(!suser())
  1299. #endif
  1300. return -EPERM;
  1301. if (copy_from_user(&v, arg,sizeof(v)))
  1302. return -EFAULT;
  1303. DEBUG(printk(CARD_DEBUG "VIDIOCSFBUF(%p,%d,%d,%d,%d)n",CARD,v.base, v.width,v.height,v.depth,v.bytesperline));
  1305. if (v.depth!=15 && v.depth!=16 && v.depth!=24 && v.depth!=32)
  1306. return -EINVAL;
  1307. if (v.bytesperline<1)
  1308. return -EINVAL;
  1309. if (ztv->running)
  1310. return -EBUSY;
  1311. write_lock_irq(&ztv->lock);
  1312. ztv->overinfo.busadr  = (ulong)v.base;
  1313. ztv->sheight      = v.height;
  1314. ztv->swidth       = v.width;
  1315. ztv->depth        = v.depth; /* bits per pixel */
  1316. ztv->overinfo.bpp = ((v.depth+1)&0x38)/8;/* bytes per pixel */
  1317. ztv->overinfo.bpl = v.bytesperline; /* bytes per line */
  1318. write_unlock_irq(&ztv->lock);
  1319. break;
  1320.  }
  1322.  case VIDIOCKEY:
  1323.  {
  1324. /* Will be handled higher up .. */
  1325. break;
  1326.  }
  1328.  case VIDIOCSYNC:
  1329.  {
  1330. int i;
  1331. if (get_user(i, (int *) arg))
  1332. return -EFAULT;
  1333. DEBUG(printk(CARD_DEBUG "VIDEOCSYNC(%d)n",CARD,i));
  1334. if (i<0 || i>ZORAN_MAX_FBUFFERS)
  1335. return -EINVAL;
  1336. switch (ztv->grabinfo[i].status) {
  1337.  case FBUFFER_FREE:
  1338. return -EINVAL;
  1339.  case FBUFFER_BUSY:
  1340. /* wait till this buffer gets grabbed */
  1341. while (ztv->grabinfo[i].status == FBUFFER_BUSY) {
  1342. interruptible_sleep_on(&ztv->grabq);
  1343. /* see if a signal did it */
  1344. if (signal_pending(current))
  1345. return -EINTR;
  1346. }
  1347. /* don't fall through; a DONE buffer is not UNUSED */
  1348. break;
  1349.  case FBUFFER_DONE:
  1350. ztv->grabinfo[i].status = FBUFFER_FREE;
  1351. /* tell ppl we have a spare buffer */
  1352. wake_up_interruptible(&ztv->grabq);
  1353. break;
  1354. }
  1355. DEBUG(printk(CARD_DEBUG "VIDEOCSYNC(%d) returnsn",CARD,i));
  1356. break;
  1357.  }
  1359.  case VIDIOCMCAPTURE:
  1360.  {
  1361. struct video_mmap vm;
  1362. struct vidinfo* frame;
  1363. if (copy_from_user(&vm,arg,sizeof(vm)))
  1364. return -EFAULT;
  1365. DEBUG(printk(CARD_DEBUG "VIDIOCMCAPTURE(%d,(%d,%d),%d)n",CARD,vm.frame,vm.width,vm.height,vm.format));
  1366. if (vm.frame<0 || vm.frame>ZORAN_MAX_FBUFFERS ||
  1367.     vm.width<32 || vm.width>768 ||
  1368.     vm.height<32 || vm.height>576 ||
  1369.     vm.format>NRPALETTES ||
  1370.     palette2fmt[vm.format].mode == 0)
  1371. return -EINVAL;
  1373. /* we are allowed to take over UNUSED and DONE buffers */
  1374. frame = &ztv->grabinfo[vm.frame];
  1375. if (frame->status == FBUFFER_BUSY)
  1376. return -EBUSY;
  1378. /* setup the other parameters if they are given */
  1379. write_lock_irq(&ztv->lock);
  1380. frame->w = vm.width;
  1381. frame->h = vm.height;
  1382. frame->format = vm.format;
  1383. frame->bpp = palette2fmt[frame->format].bpp;
  1384. frame->bpl = frame->w*frame->bpp;
  1385. frame->status = FBUFFER_BUSY;
  1386. frame->next = 0;
  1387. { /* add to tail of queue */
  1388.   struct vidinfo* oldframe = ztv->workqueue;
  1389.   if (!oldframe) ztv->workqueue = frame;
  1390.   else {
  1391.     while (oldframe->next) oldframe = oldframe->next;
  1392.     oldframe->next = frame;
  1393.   }
  1394. }
  1395. write_unlock_irq(&ztv->lock);
  1396. zoran_cap(ztv, 1);
  1397. break;
  1398.  }
  1400.  case VIDIOCGMBUF:
  1401.  {
  1402. struct video_mbuf mb;
  1403. int i;
  1404. DEBUG(printk(CARD_DEBUG "VIDIOCGMBUFn",CARD));
  1405. mb.size = ZORAN_MAX_FBUFSIZE;
  1406. mb.frames = ZORAN_MAX_FBUFFERS;
  1407. for (i=0; i<ZORAN_MAX_FBUFFERS; i++)
  1408. mb.offsets[i] = i*ZORAN_MAX_FBUFFER;
  1409. if(copy_to_user(arg, &mb,sizeof(mb)))
  1410. return -EFAULT;
  1411. break;
  1412.  }
  1414.  case VIDIOCGUNIT:
  1415.  {
  1416. struct video_unit vu;
  1417. DEBUG(printk(CARD_DEBUG "VIDIOCGUNITn",CARD));
  1418. vu.video = ztv->video_dev.minor;
  1419. vu.vbi = ztv->vbi_dev.minor;
  1420. vu.radio = VIDEO_NO_UNIT;
  1421. vu.audio = VIDEO_NO_UNIT;
  1422. vu.teletext = VIDEO_NO_UNIT;
  1423. if(copy_to_user(arg, &vu,sizeof(vu)))
  1424. return -EFAULT;
  1425. break;
  1426.  }
  1428.  case VIDIOCGFREQ:
  1429.  {
  1430. unsigned long v = ztv->tuner_freq;
  1431. if (copy_to_user(arg,&v,sizeof(v)))
  1432. return -EFAULT;
  1433. DEBUG(printk(CARD_DEBUG "VIDIOCGFREQn",CARD));
  1434. break;
  1435.  }
  1436.  case VIDIOCSFREQ:
  1437.  {
  1438. unsigned long v;
  1439. if (copy_from_user(&v, arg, sizeof(v)))
  1440. return -EFAULT;
  1441. DEBUG(printk(CARD_DEBUG "VIDIOCSFREQn",CARD));
  1443. if (ztv->have_tuner) {
  1444. int fixme = v;
  1445. if (i2c_control_device(&(ztv->i2c), I2C_DRIVERID_TUNER, TUNER_SET_TVFREQ, &fixme) < 0)
  1446. return -EAGAIN;
  1447. }
  1448. ztv->tuner_freq = v;
  1449. break;
  1450.  }
  1452.  /* Why isn't this in the API?
  1453.   * And why doesn't it take a buffer number?
  1454.  case BTTV_FIELDNR: 
  1455.  {
  1456. unsigned long v = ztv->lastfieldnr;
  1457. if (copy_to_user(arg,&v,sizeof(v)))
  1458. return -EFAULT;
  1459. DEBUG(printk(CARD_DEBUG "BTTV_FIELDNRn",CARD));
  1460. break;
  1461.  }
  1462.  */
  1464.  default:
  1465. return -ENOIOCTLCMD;
  1466. }
  1467. return 0;
  1468. }
  1470. static
  1471. int zoran_mmap(struct video_device* dev, const char* adr, unsigned long size)
  1472. {
  1473. struct zoran* ztv = (struct zoran*)dev;
  1474. unsigned long start = (unsigned long)adr;
  1475. unsigned long pos;
  1477. DEBUG(printk(CARD_DEBUG "zoran_mmap(0x%p,%ld)n",CARD,adr,size));
  1479. /* sanity checks */
  1480. if (size > ZORAN_MAX_FBUFSIZE || !ztv->fbuffer)
  1481. return -EINVAL;
  1483. /* start mapping the whole shabang to user memory */
  1484. pos = (unsigned long)ztv->fbuffer;
  1485. while (size>0) {
  1486. unsigned long page = virt_to_phys((void*)pos);
  1487. if (remap_page_range(start, page, PAGE_SIZE, PAGE_SHARED))
  1488. return -EAGAIN;
  1489. start += PAGE_SIZE;
  1490. pos += PAGE_SIZE;
  1491. size -= PAGE_SIZE;
  1492. }
  1493. return 0;
  1494. }
  1496. static struct video_device zr36120_template=
  1497. {
  1498. owner: THIS_MODULE,
  1499. name: "UNSET",
  1500. type: VID_TYPE_TUNER|VID_TYPE_CAPTURE|VID_TYPE_OVERLAY,
  1501. hardware: VID_HARDWARE_ZR36120,
  1502. open: zoran_open,
  1503. close: zoran_close,
  1504. read: zoran_read,
  1505. write: zoran_write,
  1506. poll: zoran_poll,
  1507. ioctl: zoran_ioctl,
  1508. mmap: zoran_mmap,
  1509. minor: -1,
  1510. };
  1512. static
  1513. int vbi_open(struct video_device *dev, int flags)
  1514. {
  1515. struct zoran *ztv = (struct zoran*)dev->priv;
  1516. struct vidinfo* item;
  1518. DEBUG(printk(CARD_DEBUG "vbi_open(dev,%d)n",CARD,flags));
  1520. /*
  1521.  * During VBI device open, we continiously grab VBI-like
  1522.  * data in the vbi buffer when we have nothing to do.
  1523.  * Only when there is an explicit request for VBI data
  1524.  * (read call) we /force/ a read.
  1525.  */
  1527. /* allocate buffers */
  1528. for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++)
  1529. {
  1530. item->status = FBUFFER_FREE;
  1532. /* alloc */
  1533. if (!item->memadr) {
  1534. item->memadr = bmalloc(ZORAN_VBI_BUFSIZE);
  1535. if (!item->memadr) {
  1536. /* could not get a buffer, bail out */
  1537. while (item != ztv->readinfo) {
  1538. item--;
  1539. bfree(item->memadr, ZORAN_VBI_BUFSIZE);
  1540. item->memadr = 0;
  1541. item->busadr = 0;
  1542. }
  1543. return -ENOBUFS;
  1544. }
  1545. }
  1547. /* determine the DMAable address */
  1548. item->busadr = virt_to_bus(item->memadr);
  1549. }
  1551. /* do the common part of all open's */
  1552. zoran_common_open(ztv, flags);
  1554. set_bit(STATE_VBI, &ztv->state);
  1555. /* start read-ahead */
  1556. zoran_cap(ztv, 1);
  1558. return 0;
  1559. }
  1561. static
  1562. void vbi_close(struct video_device *dev)
  1563. {
  1564. struct zoran *ztv = (struct zoran*)dev->priv;
  1565. struct vidinfo* item;
  1567. DEBUG(printk(CARD_DEBUG "vbi_close(dev)n",CARD));
  1569. /* driver specific closure */
  1570. clear_bit(STATE_VBI, &ztv->state);
  1572. zoran_common_close(ztv);
  1574.         /*
  1575.          *      This is sucky but right now I can't find a good way to
  1576.          *      be sure its safe to free the buffer. We wait 5-6 fields
  1577.          *      which is more than sufficient to be sure.
  1578.          */
  1579.         current->state = TASK_UNINTERRUPTIBLE;
  1580.         schedule_timeout(HZ/10);        /* Wait 1/10th of a second */
  1582. for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++)
  1583. {
  1584. if (item->memadr)
  1585. bfree(item->memadr, ZORAN_VBI_BUFSIZE);
  1586. item->memadr = 0;
  1587. }
  1589. }
  1591. /*
  1592.  * This read function could be used reentrant in a SMP situation.
  1593.  *
  1594.  * This is made possible by the spinlock which is kept till we
  1595.  * found and marked a buffer for our own use. The lock must
  1596.  * be released as soon as possible to prevent lock contention.
  1597.  */
  1598. static
  1599. long vbi_read(struct video_device* dev, char* buf, unsigned long count, int nonblock)
  1600. {
  1601. struct zoran *ztv = (struct zoran*)dev->priv;
  1602. unsigned long max;
  1603. struct vidinfo* unused = 0;
  1604. struct vidinfo* done = 0;
  1606. DEBUG(printk(CARD_DEBUG "vbi_read(0x%p,%ld,%d)n",CARD,buf,count,nonblock));
  1608. /* find ourself a free or completed buffer */
  1609. for (;;) {
  1610. struct vidinfo* item;
  1612. write_lock_irq(&ztv->lock);
  1613. for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++) {
  1614. if (!unused && item->status == FBUFFER_FREE)
  1615. unused = item;
  1616. if (!done && item->status == FBUFFER_DONE)
  1617. done = item;
  1618. }
  1619. if (done || unused)
  1620. break;
  1622. /* no more free buffers, wait for them. */
  1623. write_unlock_irq(&ztv->lock);
  1624. if (nonblock)
  1625. return -EWOULDBLOCK;
  1626. interruptible_sleep_on(&ztv->vbiq);
  1627. if (signal_pending(current))
  1628. return -EINTR;
  1629. }
  1631. /* Do we have 'ready' data? */
  1632. if (!done) {
  1633. /* no? than this will take a while... */
  1634. if (nonblock) {
  1635. write_unlock_irq(&ztv->lock);
  1636. return -EWOULDBLOCK;
  1637. }
  1639. /* mark the unused buffer as wanted */
  1640. unused->status = FBUFFER_BUSY;
  1641. unused->next = 0;
  1642. { /* add to tail of queue */
  1643.   struct vidinfo* oldframe = ztv->workqueue;
  1644.   if (!oldframe) ztv->workqueue = unused;
  1645.   else {
  1646.     while (oldframe->next) oldframe = oldframe->next;
  1647.     oldframe->next = unused;
  1648.   }
  1649. }
  1650. write_unlock_irq(&ztv->lock);
  1652. /* tell the state machine we want it filled /NOW/ */
  1653. zoran_cap(ztv, 1);
  1655. /* wait till this buffer gets grabbed */
  1656. while (unused->status == FBUFFER_BUSY) {
  1657. interruptible_sleep_on(&ztv->vbiq);
  1658. /* see if a signal did it */
  1659. if (signal_pending(current))
  1660. return -EINTR;
  1661. }
  1662. done = unused;
  1663. }
  1664. else
  1665. write_unlock_irq(&ztv->lock);
  1667. /* Yes! we got data! */
  1668. max = done->bpl * -done->h;
  1669. if (count > max)
  1670. count = max;
  1672. /* check if the user gave us enough room to write the data */
  1673. if (!access_ok(VERIFY_WRITE, buf, count)) {
  1674. count = -EFAULT;
  1675. goto out;
  1676. }
  1678. /*
  1679.  * Now transform/strip the data from YUV to Y-only
  1680.  * NB. Assume the Y is in the LSB of the YUV data.
  1681.  */
  1682. {
  1683. unsigned char* optr = buf;
  1684. unsigned char* eptr = buf+count;
  1686. /* are we beeing accessed from an old driver? */
  1687. if (count == 2*19*2048) {
  1688. /*
  1689.  * Extreme HACK, old VBI programs expect 2048 points
  1690.  * of data, and we only got 864 orso. Double each 
  1691.  * datapoint and clear the rest of the line.
  1692.  * This way we have appear to have a
  1693.  * sample_frequency of 29.5 Mc.
  1694.  */
  1695. int x,y;
  1696. unsigned char* iptr = done->memadr+1;
  1697. for (y=done->h; optr<eptr && y<0; y++)
  1698. {
  1699. /* copy to doubled data to userland */
  1700. for (x=0; optr+1<eptr && x<-done->w; x++)
  1701. {
  1702. unsigned char a = iptr[x*2];
  1703. *optr++ = a;
  1704. *optr++ = a;
  1705. }
  1706. /* and clear the rest of the line */
  1707. for (x*=2; optr<eptr && x<done->bpl; x++)
  1708. *optr++ = 0;
  1709. /* next line */
  1710. iptr += done->bpl;
  1711. }
  1712. }
  1713. else {
  1714. /*
  1715.  * Other (probably newer) programs asked
  1716.  * us what geometry we are using, and are
  1717.  * reading the correct size.
  1718.  */
  1719. int x,y;
  1720. unsigned char* iptr = done->memadr+1;
  1721. for (y=done->h; optr<eptr && y<0; y++)
  1722. {
  1723. /* copy to doubled data to userland */
  1724. for (x=0; optr<eptr && x<-done->w; x++)
  1725. *optr++ = iptr[x*2];
  1726. /* and clear the rest of the line */
  1727. for (;optr<eptr && x<done->bpl; x++)
  1728. *optr++ = 0;
  1729. /* next line */
  1730. iptr += done->bpl;
  1731. }
  1732. }
  1734. /* API compliance:
  1735.  * place the framenumber (half fieldnr) in the last long
  1736.  */
  1737. ((ulong*)eptr)[-1] = done->fieldnr/2;
  1738. }
  1740. /* keep the engine running */
  1741. done->status = FBUFFER_FREE;
  1742. zoran_cap(ztv, 1);
  1744. /* tell listeners this buffer just became free */
  1745. wake_up_interruptible(&ztv->vbiq);
  1747. /* goodbye */
  1748. out:
  1749. DEBUG(printk(CARD_DEBUG "vbi_read() returns %lun",CARD,count));
  1750. return count;
  1751. }
  1753. #if LINUX_VERSION_CODE >= 0x020100
  1754. static
  1755. unsigned int vbi_poll(struct video_device *dev, struct file *file, poll_table *wait)
  1756. {
  1757. struct zoran *ztv = (struct zoran*)dev->priv;
  1758. struct vidinfo* item;
  1759. unsigned int mask = 0;
  1761. poll_wait(file, &ztv->vbiq, wait);
  1763. for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++)
  1764. if (item->status == FBUFFER_DONE)
  1765. {
  1766. mask |= (POLLIN | POLLRDNORM);
  1767. break;
  1768. }
  1770. DEBUG(printk(CARD_DEBUG "vbi_poll()=%xn",CARD,mask));
  1772. return mask;
  1773. }
  1774. #endif
  1776. static
  1777. int vbi_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
  1778. {
  1779. struct zoran* ztv = (struct zoran*)dev->priv;
  1781. switch (cmd) {
  1782.  case VIDIOCGVBIFMT:
  1783.  {
  1784. struct vbi_format f;
  1785. DEBUG(printk(CARD_DEBUG "VIDIOCGVBIINFOn",CARD));
  1786. f.sampling_rate = 14750000UL;
  1787. f.samples_per_line = -ztv->readinfo[0].w;
  1788. f.sample_format = VIDEO_PALETTE_RAW;
  1789. f.start[0] = f.start[1] = ztv->readinfo[0].y;
  1790. f.start[1] += 312;
  1791. f.count[0] = f.count[1] = -ztv->readinfo[0].h;
  1792. f.flags = VBI_INTERLACED;
  1793. if (copy_to_user(arg,&f,sizeof(f)))
  1794. return -EFAULT;
  1795. break;
  1796.  }
  1797.  case VIDIOCSVBIFMT:
  1798.  {
  1799. struct vbi_format f;
  1800. int i;
  1801. if (copy_from_user(&f, arg,sizeof(f)))
  1802. return -EFAULT;
  1803. DEBUG(printk(CARD_DEBUG "VIDIOCSVBIINFO(%d,%d,%d,%d,%d,%d,%d,%x)n",CARD,f.sampling_rate,f.samples_per_line,f.sample_format,f.start[0],f.start[1],f.count[0],f.count[1],f.flags));
  1805. /* lots of parameters are fixed... (PAL) */
  1806. if (f.sampling_rate != 14750000UL ||
  1807.     f.samples_per_line > 864 ||
  1808.     f.sample_format != VIDEO_PALETTE_RAW ||
  1809.     f.start[0] < 0 ||
  1810.     f.start[0] != f.start[1]-312 ||
  1811.     f.count[0] != f.count[1] ||
  1812.     f.start[0]+f.count[0] >= 288 ||
  1813.     f.flags != VBI_INTERLACED)
  1814. return -EINVAL;
  1816. write_lock_irq(&ztv->lock);
  1817. ztv->readinfo[0].y = f.start[0];
  1818. ztv->readinfo[0].w = -f.samples_per_line;
  1819. ztv->readinfo[0].h = -f.count[0];
  1820. ztv->readinfo[0].bpl = f.samples_per_line*ztv->readinfo[0].bpp;
  1821. for (i=1; i<ZORAN_VBI_BUFFERS; i++)
  1822. ztv->readinfo[i] = ztv->readinfo[i];
  1823. write_unlock_irq(&ztv->lock);
  1824. break;
  1825.  }
  1826.  default:
  1827. return -ENOIOCTLCMD;
  1828. }
  1829. return 0;
  1830. }
  1832. static struct video_device vbi_template=
  1833. {
  1834. owner: THIS_MODULE,
  1835. name: "UNSET",
  1836. type: VID_TYPE_CAPTURE|VID_TYPE_TELETEXT,
  1837. hardware: VID_HARDWARE_ZR36120,
  1838. open: vbi_open,
  1839. close: vbi_close,
  1840. read: vbi_read,
  1841. write: zoran_write,
  1842. poll: vbi_poll,
  1843. ioctl: vbi_ioctl,
  1844. minor: -1,
  1845. };
  1847. /*
  1848.  *      Scan for a Zoran chip, request the irq and map the io memory
  1849.  */
  1850. static
  1851. int __init find_zoran(void)
  1852. {
  1853. int result;
  1854. struct zoran *ztv;
  1855. struct pci_dev *dev = NULL;
  1856. unsigned char revision;
  1857. int zoran_num=0;
  1859. while ((dev = pci_find_device(PCI_VENDOR_ID_ZORAN,PCI_DEVICE_ID_ZORAN_36120, dev)))
  1860. {
  1861. /* Ok, a ZR36120/ZR36125 found! */
  1862. ztv = &zorans[zoran_num];
  1863. ztv->dev = dev;
  1865. if (pci_enable_device(dev))
  1866. return -EIO;
  1868. pci_read_config_byte(dev, PCI_CLASS_REVISION, &revision);
  1869. printk(KERN_INFO "zoran: Zoran %x (rev %d) ",
  1870. dev->device, revision);
  1871. printk("bus: %d, devfn: %d, irq: %d, ",
  1872. dev->bus->number, dev->devfn, dev->irq);
  1873. printk("memory: 0x%08lx.n", ztv->zoran_adr);
  1875. ztv->zoran_mem = ioremap(ztv->zoran_adr, 0x1000);
  1876. DEBUG(printk(KERN_DEBUG "zoran: mapped-memory at 0x%pn",ztv->zoran_mem));
  1878. result = request_irq(dev->irq, zoran_irq,
  1879. SA_SHIRQ|SA_INTERRUPT,"zoran",(void *)ztv);
  1880. if (result==-EINVAL)
  1881. {
  1882. iounmap(ztv->zoran_mem);
  1883. printk(KERN_ERR "zoran: Bad irq number or handlern");
  1884. return -EINVAL;
  1885. }
  1886. if (result==-EBUSY)
  1887. printk(KERN_ERR "zoran: IRQ %d busy, change your PnP config in BIOSn",dev->irq);
  1888. if (result < 0) {
  1889. iounmap(ztv->zoran_mem);
  1890. return result;
  1891. }
  1892. /* Enable bus-mastering */
  1893. pci_set_master(dev);
  1895. zoran_num++;
  1896. }
  1897. if(zoran_num)
  1898. printk(KERN_INFO "zoran: %d Zoran card(s) found.n",zoran_num);
  1899. return zoran_num;
  1900. }
  1902. static
  1903. int __init init_zoran(int card)
  1904. {
  1905. struct zoran *ztv = &zorans[card];
  1906. int i;
  1908. /* if the given cardtype valid? */
  1909. if (cardtype[card]>=NRTVCARDS) {
  1910. printk(KERN_INFO "invalid cardtype(%d) detectedn",cardtype[card]);
  1911. return -1;
  1912. }
  1914. /* reset the zoran */
  1915. zrand(~ZORAN_PCI_SOFTRESET,ZORAN_PCI);
  1916. udelay(10);
  1917. zror(ZORAN_PCI_SOFTRESET,ZORAN_PCI);
  1918. udelay(10);
  1920. /* zoran chip specific details */
  1921. ztv->card = tvcards+cardtype[card]; /* point to the selected card */
  1922. ztv->norm = 0; /* PAL */
  1923. ztv->tuner_freq = 0;
  1925. /* videocard details */
  1926. ztv->swidth = 800;
  1927. ztv->sheight = 600;
  1928. ztv->depth = 16;
  1930. /* State details */
  1931. ztv->fbuffer = 0;
  1932. ztv->overinfo.kindof = FBUFFER_OVERLAY;
  1933. ztv->overinfo.status = FBUFFER_FREE;
  1934. ztv->overinfo.x = 0;
  1935. ztv->overinfo.y = 0;
  1936. ztv->overinfo.w = 768; /* 640 */
  1937. ztv->overinfo.h = 576; /* 480 */
  1938. ztv->overinfo.format = VIDEO_PALETTE_RGB565;
  1939. ztv->overinfo.bpp = palette2fmt[ztv->overinfo.format].bpp;
  1940. ztv->overinfo.bpl = ztv->overinfo.bpp*ztv->swidth;
  1941. ztv->overinfo.busadr = 0;
  1942. ztv->overinfo.memadr = 0;
  1943. ztv->overinfo.overlay = 0;
  1944. for (i=0; i<ZORAN_MAX_FBUFFERS; i++) {
  1945. ztv->grabinfo[i] = ztv->overinfo;
  1946. ztv->grabinfo[i].kindof = FBUFFER_GRAB;
  1947. }
  1948. init_waitqueue_head(&ztv->grabq);
  1950. /* VBI details */
  1951. ztv->readinfo[0] = ztv->overinfo;
  1952. ztv->readinfo[0].kindof = FBUFFER_VBI;
  1953. ztv->readinfo[0].w = -864;
  1954. ztv->readinfo[0].h = -38;
  1955. ztv->readinfo[0].format = VIDEO_PALETTE_YUV422;
  1956. ztv->readinfo[0].bpp = palette2fmt[ztv->readinfo[0].format].bpp;
  1957. ztv->readinfo[0].bpl = 1024*ztv->readinfo[0].bpp;
  1958. for (i=1; i<ZORAN_VBI_BUFFERS; i++)
  1959. ztv->readinfo[i] = ztv->readinfo[0];
  1960. init_waitqueue_head(&ztv->vbiq);
  1962. /* maintenance data */
  1963. ztv->have_decoder = 0;
  1964. ztv->have_tuner = 0;
  1965. ztv->tuner_type = 0;
  1966. ztv->running = 0;
  1967. ztv->users = 0;
  1968. ztv->lock = RW_LOCK_UNLOCKED;
  1969. ztv->workqueue = 0;
  1970. ztv->fieldnr = 0;
  1971. ztv->lastfieldnr = 0;
  1973. if (triton1)
  1974. zrand(~ZORAN_VDC_TRICOM, ZORAN_VDC);
  1976. /* external FL determines TOP frame */
  1977. zror(ZORAN_VFEC_EXTFL, ZORAN_VFEC); 
  1979. /* set HSpol */
  1980. if (ztv->card->hsync_pos)
  1981. zrwrite(ZORAN_VFEH_HSPOL, ZORAN_VFEH);
  1982. /* set VSpol */
  1983. if (ztv->card->vsync_pos)
  1984. zrwrite(ZORAN_VFEV_VSPOL, ZORAN_VFEV);
  1986. /* Set the proper General Purpuse register bits */
  1987. /* implicit: no softreset, 0 waitstates */
  1988. zrwrite(ZORAN_PCI_SOFTRESET|(ztv->card->gpdir<<0),ZORAN_PCI);
  1989. /* implicit: 3 duration and recovery PCI clocks on guest 0-3 */
  1990. zrwrite(ztv->card->gpval<<24,ZORAN_GUEST);
  1992. /* clear interrupt status */
  1993. zrwrite(~0, ZORAN_ISR);
  1995. /*
  1996.  * i2c template
  1997.  */
  1998. ztv->i2c = zoran_i2c_bus_template;
  1999. sprintf(ztv->i2c.name,"zoran-%d",card);
  2000. ztv->i2c.data = ztv;
  2002. /*
  2003.  * Now add the template and register the device unit
  2004.  */
  2005. ztv->video_dev = zr36120_template;
  2006. strcpy(ztv->video_dev.name, ztv->i2c.name);
  2007. ztv->video_dev.priv = ztv;
  2008. if (video_register_device(&ztv->video_dev, VFL_TYPE_GRABBER, video_nr) < 0)
  2009. return -1;
  2011. ztv->vbi_dev = vbi_template;
  2012. strcpy(ztv->vbi_dev.name, ztv->i2c.name);
  2013. ztv->vbi_dev.priv = ztv;
  2014. if (video_register_device(&ztv->vbi_dev, VFL_TYPE_VBI, vbi_nr) < 0) {
  2015. video_unregister_device(&ztv->video_dev);
  2016. return -1;
  2017. }
  2018. i2c_register_bus(&ztv->i2c);
  2020. /* set interrupt mask - the PIN enable will be set later */
  2021. zrwrite(ZORAN_ICR_GIRQ0|ZORAN_ICR_GIRQ1|ZORAN_ICR_CODE, ZORAN_ICR);
  2023. printk(KERN_INFO "%s: installed %sn",ztv->i2c.name,ztv->card->name);
  2024. return 0;
  2025. }
  2027. static
  2028. void release_zoran(int max)
  2029. {
  2030. struct zoran *ztv;
  2031. int i;
  2033. for (i=0;i<max; i++) 
  2034. {
  2035. ztv = &zorans[i];
  2037. /* turn off all capturing, DMA and IRQs */
  2038. /* reset the zoran */
  2039. zrand(~ZORAN_PCI_SOFTRESET,ZORAN_PCI);
  2040. udelay(10);
  2041. zror(ZORAN_PCI_SOFTRESET,ZORAN_PCI);
  2042. udelay(10);
  2044. /* first disable interrupts before unmapping the memory! */
  2045. zrwrite(0, ZORAN_ICR);
  2046. zrwrite(0xffffffffUL,ZORAN_ISR);
  2048. /* free it */
  2049. free_irq(ztv->dev->irq,ztv);
  2050.  
  2051.      /* unregister i2c_bus */
  2052. i2c_unregister_bus((&ztv->i2c));
  2054. /* unmap and free memory */
  2055. if (ztv->zoran_mem)
  2056. iounmap(ztv->zoran_mem);
  2058. video_unregister_device(&ztv->video_dev);
  2059. video_unregister_device(&ztv->vbi_dev);
  2060. }
  2061. }
  2063. void __exit zr36120_exit(void)
  2064. {
  2065. release_zoran(zoran_cards);
  2066. }
  2068. int __init zr36120_init(void)
  2069. {
  2070. int card;
  2071.  
  2072. handle_chipset();
  2073. zoran_cards = find_zoran();
  2074. if (zoran_cards<0)
  2075. /* no cards found, no need for a driver */
  2076. return -EIO;
  2078. /* initialize Zorans */
  2079. for (card=0; card<zoran_cards; card++) {
  2080. if (init_zoran(card)<0) {
  2081. /* only release the zorans we have registered */
  2082. release_zoran(card);
  2083. return -EIO;
  2084. } 
  2085. }
  2086. return 0;
  2087. }
  2089. module_init(zr36120_init);
  2090. module_exit(zr36120_exit);