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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
planb.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：62k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

planb.c：源码内容
  1. /* 
  2.     planb - PlanB frame grabber driver
  4.     PlanB is used in the 7x00/8x00 series of PowerMacintosh
  5.     Computers as video input DMA controller.
  7.     Copyright (C) 1998 Michel Lanners (mlan@cpu.lu)
  9.     Based largely on the bttv driver by Ralph Metzler (rjkm@thp.uni-koeln.de)
  11.     Additional debugging and coding by Takashi Oe (toe@unlserve.unl.edu)
  13.     This program is free software; you can redistribute it and/or modify
  14.     it under the terms of the GNU General Public License as published by
  15.     the Free Software Foundation; either version 2 of the License, or
  16.     (at your option) any later version.
  18.     This program is distributed in the hope that it will be useful,
  19.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.     GNU General Public License for more details.
  23.     You should have received a copy of the GNU General Public License
  24.     along with this program; if not, write to the Free Software
  25.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26. */
  28. /* $Id: planb.c,v 1.18 1999/05/02 17:36:34 mlan Exp $ */
  30. #include <linux/version.h>
  31. #include <linux/init.h>
  32. #include <linux/errno.h>
  33. #include <linux/module.h>
  34. #include <linux/kernel.h>
  35. #include <linux/major.h>
  36. #include <linux/slab.h>
  37. #include <linux/types.h>
  38. #include <linux/pci.h>
  39. #include <linux/delay.h>
  40. #include <linux/vmalloc.h>
  41. #include <linux/mm.h>
  42. #include <linux/sched.h>
  43. #include <linux/wrapper.h>
  44. #include <linux/tqueue.h>
  45. #include <linux/videodev.h>
  46. #include <asm/uaccess.h>
  47. #include <asm/io.h>
  48. #include <asm/prom.h>
  49. #include <asm/dbdma.h>
  50. #include <asm/pgtable.h>
  51. #include <asm/page.h>
  52. #include <asm/irq.h>
  53. #include <asm/semaphore.h>
  55. #include "planb.h"
  56. #include "saa7196.h"
  58. /* Would you mind for some ugly debugging? */
  59. #if 0
  60. #define DEBUG(x...) printk(KERN_DEBUG ## x) /* Debug driver */
  61. #else
  62. #define DEBUG(x...)  /* Don't debug driver */
  63. #endif
  65. #if 0
  66. #define IDEBUG(x...) printk(KERN_DEBUG ## x) /* Debug interrupt part */
  67. #else
  68. #define IDEBUG(x...)  /* Don't debug interrupt part */
  69. #endif
  71. /* Ever seen a Mac with more than 1 of these? */
  72. #define PLANB_MAX 1
  74. static int planb_num;
  75. static struct planb planbs[PLANB_MAX];
  76. static volatile struct planb_registers *planb_regs;
  78. static int def_norm = PLANB_DEF_NORM; /* default norm */
  79. static int video_nr = -1;
  81. MODULE_PARM(def_norm, "i");
  82. MODULE_PARM_DESC(def_norm, "Default startup norm (0=PAL, 1=NTSC, 2=SECAM)");
  83. MODULE_PARM(video_nr,"i");
  84. MODULE_LICENSE("GPL");
  87. /* ------------------ PlanB Exported Functions ------------------ */
  88. static long planb_write(struct video_device *, const char *, unsigned long, int);
  89. static long planb_read(struct video_device *, char *, unsigned long, int);
  90. static int planb_open(struct video_device *, int);
  91. static void planb_close(struct video_device *);
  92. static int planb_ioctl(struct video_device *, unsigned int, void *);
  93. static int planb_mmap(struct video_device *, const char *, unsigned long);
  94. static void planb_irq(int, void *, struct pt_regs *);
  95. static void release_planb(void);
  96. static int init_planbs(void);
  98. /* ------------------ PlanB Internal Functions ------------------ */
  99. static int planb_prepare_open(struct planb *);
  100. static void planb_prepare_close(struct planb *);
  101. static void saa_write_reg(unsigned char, unsigned char);
  102. static unsigned char saa_status(int, struct planb *);
  103. static void saa_set(unsigned char, unsigned char, struct planb *);
  104. static void saa_init_regs(struct planb *);
  105. static int grabbuf_alloc(struct planb *);
  106. static int vgrab(struct planb *, struct video_mmap *);
  107. static void add_clip(struct planb *, struct video_clip *);
  108. static void fill_cmd_buff(struct planb *);
  109. static void cmd_buff(struct planb *);
  110. static volatile struct dbdma_cmd *setup_grab_cmd(int, struct planb *);
  111. static void overlay_start(struct planb *);
  112. static void overlay_stop(struct planb *);
  113. static inline void tab_cmd_dbdma(volatile struct dbdma_cmd *, unsigned short,
  114. unsigned int);
  115. static inline void tab_cmd_store(volatile struct dbdma_cmd *, unsigned int,
  116. unsigned int);
  117. static inline void tab_cmd_gen(volatile struct dbdma_cmd *, unsigned short,
  118. unsigned short, unsigned int, unsigned int);
  119. static int init_planb(struct planb *);
  120. static int find_planb(void);
  121. static void planb_pre_capture(int, int, struct planb *);
  122. static volatile struct dbdma_cmd *cmd_geo_setup(volatile struct dbdma_cmd *,
  123. int, int, int, int, int, struct planb *);
  124. static inline void planb_dbdma_stop(volatile struct dbdma_regs *);
  125. static unsigned int saa_geo_setup(int, int, int, int, struct planb *);
  126. static inline int overlay_is_active(struct planb *);
  128. /*******************************/
  129. /* Memory management functions */
  130. /*******************************/
  132. static int grabbuf_alloc(struct planb *pb)
  133. {
  134. int i, npage;
  136. npage = MAX_GBUFFERS * ((PLANB_MAX_FBUF / PAGE_SIZE + 1)
  137. #ifndef PLANB_GSCANLINE
  138. + MAX_LNUM
  139. #endif /* PLANB_GSCANLINE */
  140. );
  141. if ((pb->rawbuf = (unsigned char**) kmalloc (npage
  142. * sizeof(unsigned long), GFP_KERNEL)) == 0)
  143. return -ENOMEM;
  144. for (i = 0; i < npage; i++) {
  145. pb->rawbuf[i] = (unsigned char *)__get_free_pages(GFP_KERNEL
  146. |GFP_DMA, 0);
  147. if (!pb->rawbuf[i])
  148. break;
  149. mem_map_reserve(virt_to_page(pb->rawbuf[i]));
  150. }
  151. if (i-- < npage) {
  152. printk(KERN_DEBUG "PlanB: init_grab: grab buffer not allocatedn");
  153. for (; i > 0; i--) {
  154. mem_map_unreserve(virt_to_page(pb->rawbuf[i]));
  155. free_pages((unsigned long)pb->rawbuf[i], 0);
  156. }
  157. kfree(pb->rawbuf);
  158. return -ENOBUFS;
  159. }
  160. pb->rawbuf_size = npage;
  161. return 0;
  162. }
  164. /*****************************/
  165. /* Hardware access functions */
  166. /*****************************/
  168. static void saa_write_reg(unsigned char addr, unsigned char val)
  169. {
  170. planb_regs->saa_addr = addr; eieio();
  171. planb_regs->saa_regval = val; eieio();
  172. return;
  173. }
  175. /* return  status byte 0 or 1: */
  176. static unsigned char saa_status(int byte, struct planb *pb)
  177. {
  178. saa_regs[pb->win.norm][SAA7196_STDC] =
  179. (saa_regs[pb->win.norm][SAA7196_STDC] & ~2) | ((byte & 1) << 1);
  180. saa_write_reg (SAA7196_STDC, saa_regs[pb->win.norm][SAA7196_STDC]);
  182. /* Let's wait 30msec for this one */
  183. current->state = TASK_INTERRUPTIBLE;
  184. #if LINUX_VERSION_CODE >= 0x02017F
  185. schedule_timeout(30 * HZ / 1000);
  186. #else
  187. current->timeout = jiffies + 30 * HZ / 1000; /* 30 ms */;
  188. schedule();
  189. #endif
  191. return (unsigned char)in_8 (&planb_regs->saa_status);
  192. }
  194. static void saa_set(unsigned char addr, unsigned char val, struct planb *pb)
  195. {
  196. if(saa_regs[pb->win.norm][addr] != val) {
  197. saa_regs[pb->win.norm][addr] = val;
  198. saa_write_reg (addr, val);
  199. }
  200. return;
  201. }
  203. static void saa_init_regs(struct planb *pb)
  204. {
  205. int i;
  207. for (i = 0; i < SAA7196_NUMREGS; i++)
  208. saa_write_reg (i, saa_regs[pb->win.norm][i]);
  209. }
  211. static unsigned int saa_geo_setup(int width, int height, int interlace, int bpp,
  212. struct planb *pb)
  213. {
  214. int ht, norm = pb->win.norm;
  216. switch(bpp) {
  217. case 2:
  218. /* RGB555+a 1x16-bit + 16-bit transparent */
  219. saa_regs[norm][SAA7196_FMTS] &= ~0x3;
  220. break;
  221. case 1:
  222. case 4:
  223. /* RGB888 1x24-bit + 8-bit transparent */
  224. saa_regs[norm][SAA7196_FMTS] &= ~0x1;
  225. saa_regs[norm][SAA7196_FMTS] |= 0x2;
  226. break;
  227. default:
  228. return -EINVAL;
  229. }
  230. ht = (interlace ? height / 2 : height);
  231. saa_regs[norm][SAA7196_OUTPIX] = (unsigned char) (width & 0x00ff);
  232. saa_regs[norm][SAA7196_HFILT] = (saa_regs[norm][SAA7196_HFILT] & ~0x3)
  233. | (width >> 8 & 0x3);
  234. saa_regs[norm][SAA7196_OUTLINE] = (unsigned char) (ht & 0xff);
  235. saa_regs[norm][SAA7196_VYP] = (saa_regs[norm][SAA7196_VYP] & ~0x3)
  236. | (ht >> 8 & 0x3);
  237. /* feed both fields if interlaced, or else feed only even fields */
  238. saa_regs[norm][SAA7196_FMTS] = (interlace) ?
  239. (saa_regs[norm][SAA7196_FMTS] & ~0x60)
  240. : (saa_regs[norm][SAA7196_FMTS] | 0x60);
  241. /* transparent mode; extended format enabled */
  242. saa_regs[norm][SAA7196_DPATH] |= 0x3;
  244. return 0;
  245. }
  247. /***************************/
  248. /* DBDMA support functions */
  249. /***************************/
  251. static inline void planb_dbdma_restart(volatile struct dbdma_regs *ch)
  252. {
  253. out_le32(&ch->control, PLANB_CLR(RUN));
  254. out_le32(&ch->control, PLANB_SET(RUN|WAKE) | PLANB_CLR(PAUSE));
  255. }
  257. static inline void planb_dbdma_stop(volatile struct dbdma_regs *ch)
  258. {
  259. int i = 0;
  261. out_le32(&ch->control, PLANB_CLR(RUN) | PLANB_SET(FLUSH));
  262. while((in_le32(&ch->status) == (ACTIVE | FLUSH)) && (i < 999)) {
  263. IDEBUG("PlanB: waiting for DMA to stopn");
  264. i++;
  265. }
  266. }
  268. static inline void tab_cmd_dbdma(volatile struct dbdma_cmd *ch,
  269. unsigned short command, unsigned int cmd_dep)
  270. {
  271. st_le16(&ch->command, command);
  272. st_le32(&ch->cmd_dep, cmd_dep);
  273. }
  275. static inline void tab_cmd_store(volatile struct dbdma_cmd *ch,
  276. unsigned int phy_addr, unsigned int cmd_dep)
  277. {
  278. st_le16(&ch->command, STORE_WORD | KEY_SYSTEM);
  279. st_le16(&ch->req_count, 4);
  280. st_le32(&ch->phy_addr, phy_addr);
  281. st_le32(&ch->cmd_dep, cmd_dep);
  282. }
  284. static inline void tab_cmd_gen(volatile struct dbdma_cmd *ch,
  285. unsigned short command, unsigned short req_count,
  286. unsigned int phy_addr, unsigned int cmd_dep)
  287. {
  288. st_le16(&ch->command, command);
  289. st_le16(&ch->req_count, req_count);
  290. st_le32(&ch->phy_addr, phy_addr);
  291. st_le32(&ch->cmd_dep, cmd_dep);
  292. }
  294. static volatile struct dbdma_cmd *cmd_geo_setup(
  295. volatile struct dbdma_cmd *c1, int width, int height, int interlace,
  296. int bpp, int clip, struct planb *pb)
  297. {
  298. int norm = pb->win.norm;
  300. if((saa_geo_setup(width, height, interlace, bpp, pb)) != 0)
  301. return (volatile struct dbdma_cmd *)NULL;
  302. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->saa_addr),
  303. SAA7196_FMTS);
  304. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->saa_regval),
  305. saa_regs[norm][SAA7196_FMTS]);
  306. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->saa_addr),
  307. SAA7196_DPATH);
  308. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->saa_regval),
  309. saa_regs[norm][SAA7196_DPATH]);
  310. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->even),
  311. bpp | ((clip)? PLANB_CLIPMASK: 0));
  312. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->odd),
  313. bpp | ((clip)? PLANB_CLIPMASK: 0));
  314. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->saa_addr),
  315. SAA7196_OUTPIX);
  316. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->saa_regval),
  317. saa_regs[norm][SAA7196_OUTPIX]);
  318. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->saa_addr),
  319. SAA7196_HFILT);
  320. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->saa_regval),
  321. saa_regs[norm][SAA7196_HFILT]);
  322. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->saa_addr),
  323. SAA7196_OUTLINE);
  324. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->saa_regval),
  325. saa_regs[norm][SAA7196_OUTLINE]);
  326. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->saa_addr),
  327. SAA7196_VYP);
  328. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->saa_regval),
  329. saa_regs[norm][SAA7196_VYP]);
  330. return c1;
  331. }
  333. /******************************/
  334. /* misc. supporting functions */
  335. /******************************/
  337. static inline void planb_lock(struct planb *pb)
  338. {
  339. down(&pb->lock);
  340. }
  342. static inline void planb_unlock(struct planb *pb)
  343. {
  344. up(&pb->lock);
  345. }
  347. /***************/
  348. /* Driver Core */
  349. /***************/
  351. static int planb_prepare_open(struct planb *pb)
  352. {
  353. int i, size;
  355. /* allocate memory for two plus alpha command buffers (size: max lines,
  356.    plus 40 commands handling, plus 1 alignment), plus dummy command buf,
  357.    plus clipmask buffer, plus frame grabbing status */
  358. size = (pb->tab_size*(2+MAX_GBUFFERS*TAB_FACTOR)+1+MAX_GBUFFERS
  359. * PLANB_DUMMY)*sizeof(struct dbdma_cmd)
  360. +(PLANB_MAXLINES*((PLANB_MAXPIXELS+7)& ~7))/8
  361. +MAX_GBUFFERS*sizeof(unsigned int);
  362. if ((pb->priv_space = kmalloc (size, GFP_KERNEL)) == 0)
  363. return -ENOMEM;
  364. memset ((void *) pb->priv_space, 0, size);
  365. pb->overlay_last1 = pb->ch1_cmd = (volatile struct dbdma_cmd *)
  366. DBDMA_ALIGN (pb->priv_space);
  367. pb->overlay_last2 = pb->ch2_cmd = pb->ch1_cmd + pb->tab_size;
  368. pb->ch1_cmd_phys = virt_to_bus(pb->ch1_cmd);
  369. pb->cap_cmd[0] = pb->ch2_cmd + pb->tab_size;
  370. pb->pre_cmd[0] = pb->cap_cmd[0] + pb->tab_size * TAB_FACTOR;
  371. for (i = 1; i < MAX_GBUFFERS; i++) {
  372. pb->cap_cmd[i] = pb->pre_cmd[i-1] + PLANB_DUMMY;
  373. pb->pre_cmd[i] = pb->cap_cmd[i] + pb->tab_size * TAB_FACTOR;
  374. }
  375. pb->frame_stat=(volatile unsigned int *)(pb->pre_cmd[MAX_GBUFFERS-1]
  376. + PLANB_DUMMY);
  377. pb->mask = (unsigned char *)(pb->frame_stat+MAX_GBUFFERS);
  379. pb->rawbuf = NULL;
  380. pb->rawbuf_size = 0;
  381. pb->grabbing = 0;
  382. for (i = 0; i < MAX_GBUFFERS; i++) {
  383. pb->frame_stat[i] = GBUFFER_UNUSED;
  384. pb->gwidth[i] = 0;
  385. pb->gheight[i] = 0;
  386. pb->gfmt[i] = 0;
  387. pb->gnorm_switch[i] = 0;
  388. #ifndef PLANB_GSCANLINE
  389. pb->lsize[i] = 0;
  390. pb->lnum[i] = 0;
  391. #endif /* PLANB_GSCANLINE */
  392. }
  393. pb->gcount = 0;
  394. pb->suspend = 0;
  395. pb->last_fr = -999;
  396. pb->prev_last_fr = -999;
  398. /* Reset DMA controllers */
  399. planb_dbdma_stop(&pb->planb_base->ch2);
  400. planb_dbdma_stop(&pb->planb_base->ch1);
  402. return 0;
  403. }
  405. static void planb_prepare_close(struct planb *pb)
  406. {
  407. int i;
  409. /* make sure the dma's are idle */
  410. planb_dbdma_stop(&pb->planb_base->ch2);
  411. planb_dbdma_stop(&pb->planb_base->ch1);
  412. /* free kernel memory of command buffers */
  413. if(pb->priv_space != 0) {
  414. kfree (pb->priv_space);
  415. pb->priv_space = 0;
  416. pb->cmd_buff_inited = 0;
  417. }
  418. if(pb->rawbuf) {
  419. for (i = 0; i < pb->rawbuf_size; i++) {
  420. mem_map_unreserve(virt_to_page(pb->rawbuf[i]));
  421. free_pages((unsigned long)pb->rawbuf[i], 0);
  422. }
  423. kfree(pb->rawbuf);
  424. }
  425. pb->rawbuf = NULL;
  426. }
  428. /*****************************/
  429. /* overlay support functions */
  430. /*****************************/
  432. static void overlay_start(struct planb *pb)
  433. {
  435. DEBUG("PlanB: overlay_start()n");
  437. if(ACTIVE & in_le32(&pb->planb_base->ch1.status)) {
  439. DEBUG("PlanB: presumably, grabbing is in progress...n");
  441. planb_dbdma_stop(&pb->planb_base->ch2);
  442. out_le32 (&pb->planb_base->ch2.cmdptr,
  443. virt_to_bus(pb->ch2_cmd));
  444. planb_dbdma_restart(&pb->planb_base->ch2);
  445. st_le16 (&pb->ch1_cmd->command, DBDMA_NOP);
  446. tab_cmd_dbdma(pb->last_cmd[pb->last_fr],
  447. DBDMA_NOP | BR_ALWAYS,
  448. virt_to_bus(pb->ch1_cmd));
  449. eieio();
  450. pb->prev_last_fr = pb->last_fr;
  451. pb->last_fr = -2;
  452. if(!(ACTIVE & in_le32(&pb->planb_base->ch1.status))) {
  453. IDEBUG("PlanB: became inactive "
  454. "in the mean time... reactivatingn");
  455. planb_dbdma_stop(&pb->planb_base->ch1);
  456. out_le32 (&pb->planb_base->ch1.cmdptr,
  457. virt_to_bus(pb->ch1_cmd));
  458. planb_dbdma_restart(&pb->planb_base->ch1);
  459. }
  460. } else {
  462. DEBUG("PlanB: currently idle, so can do whatevern");
  464. planb_dbdma_stop(&pb->planb_base->ch2);
  465. planb_dbdma_stop(&pb->planb_base->ch1);
  466. st_le32 (&pb->planb_base->ch2.cmdptr,
  467. virt_to_bus(pb->ch2_cmd));
  468. st_le32 (&pb->planb_base->ch1.cmdptr,
  469. virt_to_bus(pb->ch1_cmd));
  470. out_le16 (&pb->ch1_cmd->command, DBDMA_NOP);
  471. planb_dbdma_restart(&pb->planb_base->ch2);
  472. planb_dbdma_restart(&pb->planb_base->ch1);
  473. pb->last_fr = -1;
  474. }
  475. return;
  476. }
  478. static void overlay_stop(struct planb *pb)
  479. {
  480. DEBUG("PlanB: overlay_stop()n");
  482. if(pb->last_fr == -1) {
  484. DEBUG("PlanB: no grabbing, it seems...n");
  486. planb_dbdma_stop(&pb->planb_base->ch2);
  487. planb_dbdma_stop(&pb->planb_base->ch1);
  488. pb->last_fr = -999;
  489. } else if(pb->last_fr == -2) {
  490. unsigned int cmd_dep;
  491. tab_cmd_dbdma(pb->cap_cmd[pb->prev_last_fr], DBDMA_STOP, 0);
  492. eieio();
  493. cmd_dep = (unsigned int)in_le32(&pb->overlay_last1->cmd_dep);
  494. if(overlay_is_active(pb)) {
  496. DEBUG("PlanB: overlay is currently activen");
  498. planb_dbdma_stop(&pb->planb_base->ch2);
  499. planb_dbdma_stop(&pb->planb_base->ch1);
  500. if(cmd_dep != pb->ch1_cmd_phys) {
  501. out_le32(&pb->planb_base->ch1.cmdptr,
  502. virt_to_bus(pb->overlay_last1));
  503. planb_dbdma_restart(&pb->planb_base->ch1);
  504. }
  505. }
  506. pb->last_fr = pb->prev_last_fr;
  507. pb->prev_last_fr = -999;
  508. }
  509. return;
  510. }
  512. static void suspend_overlay(struct planb *pb)
  513. {
  514. int fr = -1;
  515. struct dbdma_cmd last;
  517. DEBUG("PlanB: suspend_overlay: %dn", pb->suspend);
  519. if(pb->suspend++)
  520. return;
  521. if(ACTIVE & in_le32(&pb->planb_base->ch1.status)) {
  522. if(pb->last_fr == -2) {
  523. fr = pb->prev_last_fr;
  524. memcpy(&last, (void*)pb->last_cmd[fr], sizeof(last));
  525. tab_cmd_dbdma(pb->last_cmd[fr], DBDMA_STOP, 0);
  526. }
  527. if(overlay_is_active(pb)) {
  528. planb_dbdma_stop(&pb->planb_base->ch2);
  529. planb_dbdma_stop(&pb->planb_base->ch1);
  530. pb->suspended.overlay = 1;
  531. pb->suspended.frame = fr;
  532. memcpy(&pb->suspended.cmd, &last, sizeof(last));
  533. return;
  534. }
  535. }
  536. pb->suspended.overlay = 0;
  537. pb->suspended.frame = fr;
  538. memcpy(&pb->suspended.cmd, &last, sizeof(last));
  539. return;
  540. }
  542. static void resume_overlay(struct planb *pb)
  543. {
  545. DEBUG("PlanB: resume_overlay: %dn", pb->suspend);
  547. if(pb->suspend > 1)
  548. return;
  549. if(pb->suspended.frame != -1) {
  550. memcpy((void*)pb->last_cmd[pb->suspended.frame],
  551. &pb->suspended.cmd, sizeof(pb->suspended.cmd));
  552. }
  553. if(ACTIVE & in_le32(&pb->planb_base->ch1.status)) {
  554. goto finish;
  555. }
  556. if(pb->suspended.overlay) {
  558. DEBUG("PlanB: overlay being resumedn");
  560. st_le16 (&pb->ch1_cmd->command, DBDMA_NOP);
  561. st_le16 (&pb->ch2_cmd->command, DBDMA_NOP);
  562. /* Set command buffer addresses */
  563. st_le32(&pb->planb_base->ch1.cmdptr,
  564. virt_to_bus(pb->overlay_last1));
  565. out_le32(&pb->planb_base->ch2.cmdptr,
  566. virt_to_bus(pb->overlay_last2));
  567. /* Start the DMA controller */
  568. out_le32 (&pb->planb_base->ch2.control,
  569. PLANB_CLR(PAUSE) | PLANB_SET(RUN|WAKE));
  570. out_le32 (&pb->planb_base->ch1.control,
  571. PLANB_CLR(PAUSE) | PLANB_SET(RUN|WAKE));
  572. } else if(pb->suspended.frame != -1) {
  573. out_le32(&pb->planb_base->ch1.cmdptr,
  574. virt_to_bus(pb->last_cmd[pb->suspended.frame]));
  575. out_le32 (&pb->planb_base->ch1.control,
  576. PLANB_CLR(PAUSE) | PLANB_SET(RUN|WAKE));
  577. }
  579. finish:
  580. pb->suspend--;
  581. wake_up_interruptible(&pb->suspendq);
  582. }
  584. static void add_clip(struct planb *pb, struct video_clip *clip) 
  585. {
  586. volatile unsigned char *base;
  587. int xc = clip->x, yc = clip->y;
  588. int wc = clip->width, hc = clip->height;
  589. int ww = pb->win.width, hw = pb->win.height;
  590. int x, y, xtmp1, xtmp2;
  592. DEBUG("PlanB: clip %dx%d+%d+%dn", wc, hc, xc, yc);
  594. if(xc < 0) {
  595. wc += xc;
  596. xc = 0;
  597. }
  598. if(yc < 0) {
  599. hc += yc;
  600. yc = 0;
  601. }
  602. if(xc + wc > ww)
  603. wc = ww - xc;
  604. if(wc <= 0) /* Nothing to do */
  605. return;
  606. if(yc + hc > hw)
  607. hc = hw - yc;
  609. for (y = yc; y < yc+hc; y++) {
  610. xtmp1=xc>>3;
  611. xtmp2=(xc+wc)>>3;
  612. base = pb->mask + y*96;
  613. if(xc != 0 || wc >= 8)
  614. *(base + xtmp1) &= (unsigned char)(0x00ff &
  615. (0xff00 >> (xc&7)));
  616. for (x = xtmp1 + 1; x < xtmp2; x++) {
  617. *(base + x) = 0;
  618. }
  619. if(xc < (ww & ~0x7))
  620. *(base + xtmp2) &= (unsigned char)(0x00ff >>
  621. ((xc+wc) & 7));
  622. }
  624. return;
  625. }
  627. static void fill_cmd_buff(struct planb *pb)
  628. {
  629. int restore = 0;
  630. volatile struct dbdma_cmd last;
  632. DEBUG("PlanB: fill_cmd_buff()n");
  634. if(pb->overlay_last1 != pb->ch1_cmd) {
  635. restore = 1;
  636. last = *(pb->overlay_last1);
  637. }
  638. memset ((void *) pb->ch1_cmd, 0, 2 * pb->tab_size
  639. * sizeof(struct dbdma_cmd));
  640. cmd_buff (pb);
  641. if(restore)
  642. *(pb->overlay_last1) = last;
  643. if(pb->suspended.overlay) {
  644. unsigned long jump_addr = in_le32(&pb->overlay_last1->cmd_dep);
  645. if(jump_addr != pb->ch1_cmd_phys) {
  646. int i;
  648. DEBUG("PlanB: adjusting ch1's jump addressn");
  650. for(i = 0; i < MAX_GBUFFERS; i++) {
  651. if(pb->need_pre_capture[i]) {
  652.     if(jump_addr == virt_to_bus(pb->pre_cmd[i]))
  653. goto found;
  654. } else {
  655.     if(jump_addr == virt_to_bus(pb->cap_cmd[i]))
  656. goto found;
  657. }
  658. }
  660. DEBUG("PlanB: not found...n");
  662. goto out;
  663. found:
  664. if(pb->need_pre_capture[i])
  665. out_le32(&pb->pre_cmd[i]->phy_addr,
  666. virt_to_bus(pb->overlay_last1));
  667. else
  668. out_le32(&pb->cap_cmd[i]->phy_addr,
  669. virt_to_bus(pb->overlay_last1));
  670. }
  671. }
  672. out:
  673. pb->cmd_buff_inited = 1;
  675. return;
  676. }
  678. static void cmd_buff(struct planb *pb)
  679. {
  680. int i, bpp, count, nlines, stepsize, interlace;
  681. unsigned long base, jump, addr_com, addr_dep;
  682. volatile struct dbdma_cmd *c1 = pb->ch1_cmd;
  683. volatile struct dbdma_cmd *c2 = pb->ch2_cmd;
  685. interlace = pb->win.interlace;
  686. bpp = pb->win.bpp;
  687. count = (bpp * ((pb->win.x + pb->win.width > pb->win.swidth) ?
  688. (pb->win.swidth - pb->win.x) : pb->win.width));
  689. nlines = ((pb->win.y + pb->win.height > pb->win.sheight) ?
  690. (pb->win.sheight - pb->win.y) : pb->win.height);
  692. /* Do video in: */
  694. /* Preamble commands: */
  695. addr_com = virt_to_bus(c1);
  696. addr_dep = virt_to_bus(&c1->cmd_dep);
  697. tab_cmd_dbdma(c1++, DBDMA_NOP, 0);
  698. jump = virt_to_bus(c1+16); /* 14 by cmd_geo_setup() and 2 for padding */
  699. if((c1 = cmd_geo_setup(c1, pb->win.width, pb->win.height, interlace,
  700. bpp, 1, pb)) == NULL) {
  701. printk(KERN_WARNING "PlanB: encountered serious problemsn");
  702. tab_cmd_dbdma(pb->ch1_cmd + 1, DBDMA_STOP, 0);
  703. tab_cmd_dbdma(pb->ch2_cmd + 1, DBDMA_STOP, 0);
  704. return;
  705. }
  706. tab_cmd_store(c1++, addr_com, (unsigned)(DBDMA_NOP | BR_ALWAYS) << 16);
  707. tab_cmd_store(c1++, addr_dep, jump);
  708. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.wait_sel),
  709. PLANB_SET(FIELD_SYNC));
  710. /* (1) wait for field sync to be set */
  711. tab_cmd_dbdma(c1++, DBDMA_NOP | WAIT_IFCLR, 0);
  712. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.br_sel),
  713. PLANB_SET(ODD_FIELD));
  714. /* wait for field sync to be cleared */
  715. tab_cmd_dbdma(c1++, DBDMA_NOP | WAIT_IFSET, 0);
  716. /* if not odd field, wait until field sync is set again */
  717. tab_cmd_dbdma(c1, DBDMA_NOP | BR_IFSET, virt_to_bus(c1-3)); c1++;
  718. /* assert ch_sync to ch2 */
  719. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch2.control),
  720. PLANB_SET(CH_SYNC));
  721. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.br_sel),
  722. PLANB_SET(DMA_ABORT));
  724. base = (pb->frame_buffer_phys + pb->offset + pb->win.y * (pb->win.bpl
  725. + pb->win.pad) + pb->win.x * bpp);
  727. if (interlace) {
  728. stepsize = 2;
  729. jump = virt_to_bus(c1 + (nlines + 1) / 2);
  730. } else {
  731. stepsize = 1;
  732. jump = virt_to_bus(c1 + nlines);
  733. }
  735. /* even field data: */
  736. for (i=0; i < nlines; i += stepsize, c1++)
  737. tab_cmd_gen(c1, INPUT_MORE | KEY_STREAM0 | BR_IFSET,
  738. count, base + i * (pb->win.bpl + pb->win.pad), jump);
  740. /* For non-interlaced, we use even fields only */
  741. if (!interlace)
  742. goto cmd_tab_data_end;
  744. /* Resync to odd field */
  745. /* (2) wait for field sync to be set */
  746. tab_cmd_dbdma(c1++, DBDMA_NOP | WAIT_IFCLR, 0);
  747. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.br_sel),
  748. PLANB_SET(ODD_FIELD));
  749. /* wait for field sync to be cleared */
  750. tab_cmd_dbdma(c1++, DBDMA_NOP | WAIT_IFSET, 0);
  751. /* if not odd field, wait until field sync is set again */
  752. tab_cmd_dbdma(c1, DBDMA_NOP | BR_IFCLR, virt_to_bus(c1-3)); c1++;
  753. /* assert ch_sync to ch2 */
  754. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch2.control),
  755. PLANB_SET(CH_SYNC));
  756. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.br_sel),
  757. PLANB_SET(DMA_ABORT));
  759. /* odd field data: */
  760. jump = virt_to_bus(c1 + nlines / 2);
  761. for (i=1; i < nlines; i += stepsize, c1++)
  762. tab_cmd_gen(c1, INPUT_MORE | KEY_STREAM0 | BR_IFSET, count,
  763. base + i * (pb->win.bpl + pb->win.pad), jump);
  765. /* And jump back to the start */
  766. cmd_tab_data_end:
  767. pb->overlay_last1 = c1; /* keep a pointer to the last command */
  768. tab_cmd_dbdma(c1, DBDMA_NOP | BR_ALWAYS, virt_to_bus(pb->ch1_cmd));
  770. /* Clipmask command buffer */
  772. /* Preamble commands: */
  773. tab_cmd_dbdma(c2++, DBDMA_NOP, 0);
  774. tab_cmd_store(c2++, (unsigned)(&pb->planb_base_phys->ch2.wait_sel),
  775. PLANB_SET(CH_SYNC));
  776. /* wait until ch1 asserts ch_sync */
  777. tab_cmd_dbdma(c2++, DBDMA_NOP | WAIT_IFCLR, 0);
  778. /* clear ch_sync asserted by ch1 */
  779. tab_cmd_store(c2++, (unsigned)(&pb->planb_base_phys->ch2.control),
  780. PLANB_CLR(CH_SYNC));
  781. tab_cmd_store(c2++, (unsigned)(&pb->planb_base_phys->ch2.wait_sel),
  782. PLANB_SET(FIELD_SYNC));
  783. tab_cmd_store(c2++, (unsigned)(&pb->planb_base_phys->ch2.br_sel),
  784. PLANB_SET(ODD_FIELD));
  786. /* jump to end of even field if appropriate */
  787. /* this points to (interlace)? pos. C: pos. B */
  788. jump = (interlace) ? virt_to_bus(c2 + (nlines + 1) / 2 + 2):
  789. virt_to_bus(c2 + nlines + 2);
  790. /* if odd field, skip over to odd field clipmasking */
  791. tab_cmd_dbdma(c2++, DBDMA_NOP | BR_IFSET, jump);
  793. /* even field mask: */
  794. tab_cmd_store(c2++, (unsigned)(&pb->planb_base_phys->ch2.br_sel),
  795. PLANB_SET(DMA_ABORT));
  796. /* this points to pos. B */
  797. jump = (interlace) ? virt_to_bus(c2 + nlines + 1):
  798. virt_to_bus(c2 + nlines);
  799. base = virt_to_bus(pb->mask);
  800. for (i=0; i < nlines; i += stepsize, c2++)
  801. tab_cmd_gen(c2, OUTPUT_MORE | KEY_STREAM0 | BR_IFSET, 96,
  802. base + i * 96, jump);
  804. /* For non-interlaced, we use only even fields */
  805. if(!interlace)
  806. goto cmd_tab_mask_end;
  808. /* odd field mask: */
  809. /* C */ tab_cmd_store(c2++, (unsigned)(&pb->planb_base_phys->ch2.br_sel),
  810. PLANB_SET(DMA_ABORT));
  811. /* this points to pos. B */
  812. jump = virt_to_bus(c2 + nlines / 2);
  813. base = virt_to_bus(pb->mask);
  814. for (i=1; i < nlines; i += 2, c2++)     /* abort if set */
  815. tab_cmd_gen(c2, OUTPUT_MORE | KEY_STREAM0 | BR_IFSET, 96,
  816. base + i * 96, jump);
  818. /* Inform channel 1 and jump back to start */
  819. cmd_tab_mask_end:
  820. /* ok, I just realized this is kind of flawed. */
  821. /* this part is reached only after odd field clipmasking. */
  822. /* wanna clean up? */
  823. /* wait for field sync to be set */
  824. /* corresponds to fsync (1) of ch1 */
  825. /* B */ tab_cmd_dbdma(c2++, DBDMA_NOP | WAIT_IFCLR, 0);
  826. /* restart ch1, meant to clear any dead bit or something */
  827. tab_cmd_store(c2++, (unsigned)(&pb->planb_base_phys->ch1.control),
  828. PLANB_CLR(RUN));
  829. tab_cmd_store(c2++, (unsigned)(&pb->planb_base_phys->ch1.control),
  830. PLANB_SET(RUN));
  831. pb->overlay_last2 = c2; /* keep a pointer to the last command */
  832. /* start over even field clipmasking */
  833. tab_cmd_dbdma(c2, DBDMA_NOP | BR_ALWAYS, virt_to_bus(pb->ch2_cmd));
  835. eieio();
  836. return;
  837. }
  839. /*********************************/
  840. /* grabdisplay support functions */
  841. /*********************************/
  843. static int palette2fmt[] = {
  844.        0,
  845.        PLANB_GRAY,
  846.        0,
  847.        0,
  848.        0,
  849.        PLANB_COLOUR32,
  850.        PLANB_COLOUR15,
  851.        0,
  852.        0,
  853.        0,
  854.        0,
  855.        0,
  856.        0,
  857.        0,
  858.        0,
  859. };
  861. #define PLANB_PALETTE_MAX 15
  863. static inline int overlay_is_active(struct planb *pb)
  864. {
  865. unsigned int size = pb->tab_size * sizeof(struct dbdma_cmd);
  866. unsigned int caddr = (unsigned)in_le32(&pb->planb_base->ch1.cmdptr);
  868. return (in_le32(&pb->overlay_last1->cmd_dep) == pb->ch1_cmd_phys)
  869. && (caddr < (pb->ch1_cmd_phys + size))
  870. && (caddr >= (unsigned)pb->ch1_cmd_phys);
  871. }
  873. static int vgrab(struct planb *pb, struct video_mmap *mp)
  874. {
  875. unsigned int fr = mp->frame;
  876. unsigned int format;
  878. if(pb->rawbuf==NULL) {
  879. int err;
  880. if((err=grabbuf_alloc(pb)))
  881. return err;
  882. }
  884. IDEBUG("PlanB: grab %d: %dx%d(%u)n", pb->grabbing,
  885. mp->width, mp->height, fr);
  887. if(pb->grabbing >= MAX_GBUFFERS)
  888. return -ENOBUFS;
  889. if(fr > (MAX_GBUFFERS - 1) || fr < 0)
  890. return -EINVAL;
  891. if(mp->height <= 0 || mp->width <= 0)
  892. return -EINVAL;
  893. if(mp->format < 0 || mp->format >= PLANB_PALETTE_MAX)
  894. return -EINVAL;
  895. if((format = palette2fmt[mp->format]) == 0)
  896. return -EINVAL;
  897. if (mp->height * mp->width * format > PLANB_MAX_FBUF) /* format = bpp */
  898. return -EINVAL;
  900. planb_lock(pb);
  901. if(mp->width != pb->gwidth[fr] || mp->height != pb->gheight[fr] ||
  902. format != pb->gfmt[fr] || (pb->gnorm_switch[fr])) {
  903. int i;
  904. #ifndef PLANB_GSCANLINE
  905. unsigned int osize = pb->gwidth[fr] * pb->gheight[fr]
  906. * pb->gfmt[fr];
  907. unsigned int nsize = mp->width * mp->height * format;
  908. #endif
  910. IDEBUG("PlanB: gwidth = %d, gheight = %d, mp->format = %un",
  911. mp->width, mp->height, mp->format);
  913. #ifndef PLANB_GSCANLINE
  914. if(pb->gnorm_switch[fr])
  915. nsize = 0;
  916. if (nsize < osize) {
  917. for(i = pb->gbuf_idx[fr]; osize > 0; i++) {
  918. memset((void *)pb->rawbuf[i], 0, PAGE_SIZE);
  919. osize -= PAGE_SIZE;
  920. }
  921. }
  922. for(i = pb->l_fr_addr_idx[fr]; i < pb->l_fr_addr_idx[fr]
  923. + pb->lnum[fr]; i++)
  924. memset((void *)pb->rawbuf[i], 0, PAGE_SIZE);
  925. #else
  926. /* XXX TODO */
  927. /*
  928. if(pb->gnorm_switch[fr])
  929. memset((void *)pb->gbuffer[fr], 0,
  930. pb->gbytes_per_line * pb->gheight[fr]);
  931. else {
  932. if(mp->
  933. for(i = 0; i < pb->gheight[fr]; i++) {
  934. memset((void *)(pb->gbuffer[fr]
  935. + pb->gbytes_per_line * i
  936. }
  937. }
  938. */
  939. #endif
  940. pb->gwidth[fr] = mp->width;
  941. pb->gheight[fr] = mp->height;
  942. pb->gfmt[fr] = format;
  943. pb->last_cmd[fr] = setup_grab_cmd(fr, pb);
  944. planb_pre_capture(fr, pb->gfmt[fr], pb); /* gfmt = bpp */
  945. pb->need_pre_capture[fr] = 1;
  946. pb->gnorm_switch[fr] = 0;
  947. } else
  948. pb->need_pre_capture[fr] = 0;
  949. pb->frame_stat[fr] = GBUFFER_GRABBING;
  950. if(!(ACTIVE & in_le32(&pb->planb_base->ch1.status))) {
  952. IDEBUG("PlanB: ch1 inactive, initiating grabbingn");
  954. planb_dbdma_stop(&pb->planb_base->ch1);
  955. if(pb->need_pre_capture[fr]) {
  957. IDEBUG("PlanB: padding pre-capture sequencen");
  959. out_le32 (&pb->planb_base->ch1.cmdptr,
  960. virt_to_bus(pb->pre_cmd[fr]));
  961. } else {
  962. tab_cmd_dbdma(pb->last_cmd[fr], DBDMA_STOP, 0);
  963. tab_cmd_dbdma(pb->cap_cmd[fr], DBDMA_NOP, 0);
  964. /* let's be on the safe side. here is not timing critical. */
  965. tab_cmd_dbdma((pb->cap_cmd[fr] + 1), DBDMA_NOP, 0);
  966. out_le32 (&pb->planb_base->ch1.cmdptr,
  967. virt_to_bus(pb->cap_cmd[fr]));
  968. }
  969. planb_dbdma_restart(&pb->planb_base->ch1);
  970. pb->last_fr = fr;
  971. } else {
  972. int i;
  974. IDEBUG("PlanB: ch1 active, grabbing being queuedn");
  976. if((pb->last_fr == -1) || ((pb->last_fr == -2) &&
  977. overlay_is_active(pb))) {
  979. IDEBUG("PlanB: overlay is active, grabbing deferedn");
  981. tab_cmd_dbdma(pb->last_cmd[fr],
  982. DBDMA_NOP | BR_ALWAYS,
  983. virt_to_bus(pb->ch1_cmd));
  984. if(pb->need_pre_capture[fr]) {
  986. IDEBUG("PlanB: padding pre-capture sequencen");
  988. tab_cmd_store(pb->pre_cmd[fr],
  989.     virt_to_bus(&pb->overlay_last1->cmd_dep),
  990. virt_to_bus(pb->ch1_cmd));
  991. eieio();
  992. out_le32 (&pb->overlay_last1->cmd_dep,
  993. virt_to_bus(pb->pre_cmd[fr]));
  994. } else {
  995. tab_cmd_store(pb->cap_cmd[fr],
  996.     virt_to_bus(&pb->overlay_last1->cmd_dep),
  997. virt_to_bus(pb->ch1_cmd));
  998. tab_cmd_dbdma((pb->cap_cmd[fr] + 1),
  999. DBDMA_NOP, 0);
  1000. eieio();
  1001. out_le32 (&pb->overlay_last1->cmd_dep,
  1002. virt_to_bus(pb->cap_cmd[fr]));
  1003. }
  1004. for(i = 0; overlay_is_active(pb) && i < 999; i++)
  1005. IDEBUG("PlanB: waiting for overlay donen");
  1006. tab_cmd_dbdma(pb->ch1_cmd, DBDMA_NOP, 0);
  1007. pb->prev_last_fr = fr;
  1008. pb->last_fr = -2;
  1009. } else if(pb->last_fr == -2) {
  1011. IDEBUG("PlanB: mixed mode detected, grabbing"
  1012. " will be done before activating overlayn");
  1014. tab_cmd_dbdma(pb->ch1_cmd, DBDMA_NOP, 0);
  1015. if(pb->need_pre_capture[fr]) {
  1017. IDEBUG("PlanB: padding pre-capture sequencen");
  1019. tab_cmd_dbdma(pb->last_cmd[pb->prev_last_fr],
  1020. DBDMA_NOP | BR_ALWAYS,
  1021. virt_to_bus(pb->pre_cmd[fr]));
  1022. eieio();
  1023. } else {
  1024. tab_cmd_dbdma(pb->cap_cmd[fr], DBDMA_NOP, 0);
  1025. if(pb->gwidth[pb->prev_last_fr] !=
  1026. pb->gwidth[fr]
  1027. || pb->gheight[pb->prev_last_fr] !=
  1028. pb->gheight[fr]
  1029. || pb->gfmt[pb->prev_last_fr] !=
  1030. pb->gfmt[fr])
  1031. tab_cmd_dbdma((pb->cap_cmd[fr] + 1),
  1032. DBDMA_NOP, 0);
  1033. else
  1034. tab_cmd_dbdma((pb->cap_cmd[fr] + 1),
  1035.     DBDMA_NOP | BR_ALWAYS,
  1036.     virt_to_bus(pb->cap_cmd[fr] + 16));
  1037. tab_cmd_dbdma(pb->last_cmd[pb->prev_last_fr],
  1038. DBDMA_NOP | BR_ALWAYS,
  1039. virt_to_bus(pb->cap_cmd[fr]));
  1040. eieio();
  1041. }
  1042. tab_cmd_dbdma(pb->last_cmd[fr],
  1043. DBDMA_NOP | BR_ALWAYS,
  1044. virt_to_bus(pb->ch1_cmd));
  1045. eieio();
  1046. pb->prev_last_fr = fr;
  1047. pb->last_fr = -2;
  1048. } else {
  1050. IDEBUG("PlanB: active grabbing session detectedn");
  1052. if(pb->need_pre_capture[fr]) {
  1054. IDEBUG("PlanB: padding pre-capture sequencen");
  1056. tab_cmd_dbdma(pb->last_cmd[pb->last_fr],
  1057. DBDMA_NOP | BR_ALWAYS,
  1058. virt_to_bus(pb->pre_cmd[fr]));
  1059. eieio();
  1060. } else {
  1061. tab_cmd_dbdma(pb->last_cmd[fr], DBDMA_STOP, 0);
  1062. tab_cmd_dbdma(pb->cap_cmd[fr], DBDMA_NOP, 0);
  1063. if(pb->gwidth[pb->last_fr] != pb->gwidth[fr]
  1064. || pb->gheight[pb->last_fr] !=
  1065. pb->gheight[fr]
  1066. || pb->gfmt[pb->last_fr] !=
  1067. pb->gfmt[fr])
  1068. tab_cmd_dbdma((pb->cap_cmd[fr] + 1),
  1069. DBDMA_NOP, 0);
  1070. else
  1071. tab_cmd_dbdma((pb->cap_cmd[fr] + 1),
  1072.     DBDMA_NOP | BR_ALWAYS,
  1073.     virt_to_bus(pb->cap_cmd[fr] + 16));
  1074. tab_cmd_dbdma(pb->last_cmd[pb->last_fr],
  1075. DBDMA_NOP | BR_ALWAYS,
  1076. virt_to_bus(pb->cap_cmd[fr]));
  1077. eieio();
  1078. }
  1079. pb->last_fr = fr;
  1080. }
  1081. if(!(ACTIVE & in_le32(&pb->planb_base->ch1.status))) {
  1083. IDEBUG("PlanB: became inactive in the mean time..."
  1084. "reactivatingn");
  1086. planb_dbdma_stop(&pb->planb_base->ch1);
  1087. out_le32 (&pb->planb_base->ch1.cmdptr,
  1088. virt_to_bus(pb->cap_cmd[fr]));
  1089. planb_dbdma_restart(&pb->planb_base->ch1);
  1090. }
  1091. }
  1092. pb->grabbing++;
  1093. planb_unlock(pb);
  1095. return 0;
  1096. }
  1098. static void planb_pre_capture(int fr, int bpp, struct planb *pb)
  1099. {
  1100. volatile struct dbdma_cmd *c1 = pb->pre_cmd[fr];
  1101. int interlace = (pb->gheight[fr] > pb->maxlines/2)? 1: 0;
  1103. tab_cmd_dbdma(c1++, DBDMA_NOP, 0);
  1104. if((c1 = cmd_geo_setup(c1, pb->gwidth[fr], pb->gheight[fr], interlace,
  1105. bpp, 0, pb)) == NULL) {
  1106. printk(KERN_WARNING "PlanB: encountered some problemsn");
  1107. tab_cmd_dbdma(pb->pre_cmd[fr] + 1, DBDMA_STOP, 0);
  1108. return;
  1109. }
  1110. /* Sync to even field */
  1111. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.wait_sel),
  1112. PLANB_SET(FIELD_SYNC));
  1113. tab_cmd_dbdma(c1++, DBDMA_NOP | WAIT_IFCLR, 0);
  1114. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.br_sel),
  1115. PLANB_SET(ODD_FIELD));
  1116. tab_cmd_dbdma(c1++, DBDMA_NOP | WAIT_IFSET, 0);
  1117. tab_cmd_dbdma(c1, DBDMA_NOP | BR_IFSET, virt_to_bus(c1-3)); c1++;
  1118. tab_cmd_dbdma(c1++, DBDMA_NOP | INTR_ALWAYS, 0);
  1119. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.br_sel),
  1120. PLANB_SET(DMA_ABORT));
  1121. /* For non-interlaced, we use even fields only */
  1122. if (pb->gheight[fr] <= pb->maxlines/2)
  1123. goto cmd_tab_data_end;
  1124. /* Sync to odd field */
  1125. tab_cmd_dbdma(c1++, DBDMA_NOP | WAIT_IFCLR, 0);
  1126. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.br_sel),
  1127. PLANB_SET(ODD_FIELD));
  1128. tab_cmd_dbdma(c1++, DBDMA_NOP | WAIT_IFSET, 0);
  1129. tab_cmd_dbdma(c1, DBDMA_NOP | BR_IFCLR, virt_to_bus(c1-3)); c1++;
  1130. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.br_sel),
  1131. PLANB_SET(DMA_ABORT));
  1132. cmd_tab_data_end:
  1133. tab_cmd_dbdma(c1, DBDMA_NOP | BR_ALWAYS, virt_to_bus(pb->cap_cmd[fr]));
  1135. eieio();
  1136. }
  1138. static volatile struct dbdma_cmd *setup_grab_cmd(int fr, struct planb *pb)
  1139. {
  1140. int i, bpp, count, nlines, stepsize, interlace;
  1141. #ifdef PLANB_GSCANLINE
  1142. int scanline;
  1143. #else
  1144. int nlpp, leftover1;
  1145. unsigned long base;
  1146. #endif
  1147. unsigned long jump;
  1148. int pagei;
  1149. volatile struct dbdma_cmd *c1;
  1150. volatile struct dbdma_cmd *jump_addr;
  1152. c1 = pb->cap_cmd[fr];
  1153. interlace = (pb->gheight[fr] > pb->maxlines/2)? 1: 0;
  1154. bpp = pb->gfmt[fr]; /* gfmt = bpp */
  1155. count = bpp * pb->gwidth[fr];
  1156. nlines = pb->gheight[fr];
  1157. #ifdef PLANB_GSCANLINE
  1158. scanline = pb->gbytes_per_line;
  1159. #else
  1160. pb->lsize[fr] = count;
  1161. pb->lnum[fr] = 0;
  1162. #endif
  1164. /* Do video in: */
  1166. /* Preamble commands: */
  1167. tab_cmd_dbdma(c1++, DBDMA_NOP, 0);
  1168. tab_cmd_dbdma(c1, DBDMA_NOP | BR_ALWAYS, virt_to_bus(c1 + 16)); c1++;
  1169. if((c1 = cmd_geo_setup(c1, pb->gwidth[fr], pb->gheight[fr], interlace,
  1170. bpp, 0, pb)) == NULL) {
  1171. printk(KERN_WARNING "PlanB: encountered serious problemsn");
  1172. tab_cmd_dbdma(pb->cap_cmd[fr] + 1, DBDMA_STOP, 0);
  1173. return (pb->cap_cmd[fr] + 2);
  1174. }
  1175. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.wait_sel),
  1176. PLANB_SET(FIELD_SYNC));
  1177. tab_cmd_dbdma(c1++, DBDMA_NOP | WAIT_IFCLR, 0);
  1178. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.br_sel),
  1179. PLANB_SET(ODD_FIELD));
  1180. tab_cmd_dbdma(c1++, DBDMA_NOP | WAIT_IFSET, 0);
  1181. tab_cmd_dbdma(c1, DBDMA_NOP | BR_IFSET, virt_to_bus(c1-3)); c1++;
  1182. tab_cmd_dbdma(c1++, DBDMA_NOP | INTR_ALWAYS, 0);
  1183. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.br_sel),
  1184. PLANB_SET(DMA_ABORT));
  1186. if (interlace) {
  1187. stepsize = 2;
  1188. jump_addr = c1 + TAB_FACTOR * (nlines + 1) / 2;
  1189. } else {
  1190. stepsize = 1;
  1191. jump_addr = c1 + TAB_FACTOR * nlines;
  1192. }
  1193. jump = virt_to_bus(jump_addr);
  1195. /* even field data: */
  1197. pagei = pb->gbuf_idx[fr];
  1198. #ifdef PLANB_GSCANLINE
  1199. for (i = 0; i < nlines; i += stepsize) {
  1200. tab_cmd_gen(c1++, INPUT_MORE | BR_IFSET, count,
  1201. virt_to_bus(pb->rawbuf[pagei
  1202. + i * scanline / PAGE_SIZE]), jump);
  1203. }
  1204. #else
  1205. i = 0;
  1206. leftover1 = 0;
  1207. do {
  1208.     int j;
  1210.     base = virt_to_bus(pb->rawbuf[pagei]);
  1211.     nlpp = (PAGE_SIZE - leftover1) / count / stepsize;
  1212.     for(j = 0; j < nlpp && i < nlines; j++, i += stepsize, c1++)
  1213. tab_cmd_gen(c1, INPUT_MORE | KEY_STREAM0 | BR_IFSET,
  1214.   count, base + count * j * stepsize + leftover1, jump);
  1215.     if(i < nlines) {
  1216. int lov0 = PAGE_SIZE - count * nlpp * stepsize - leftover1;
  1218. if(lov0 == 0)
  1219.     leftover1 = 0;
  1220. else {
  1221.     if(lov0 >= count) {
  1222. tab_cmd_gen(c1++, INPUT_MORE | BR_IFSET, count, base
  1223. + count * nlpp * stepsize + leftover1, jump);
  1224.     } else {
  1225. pb->l_to_addr[fr][pb->lnum[fr]] = pb->rawbuf[pagei]
  1226. + count * nlpp * stepsize + leftover1;
  1227. pb->l_to_next_idx[fr][pb->lnum[fr]] = pagei + 1;
  1228. pb->l_to_next_size[fr][pb->lnum[fr]] = count - lov0;
  1229. tab_cmd_gen(c1++, INPUT_MORE | BR_IFSET, count,
  1230. virt_to_bus(pb->rawbuf[pb->l_fr_addr_idx[fr]
  1231. + pb->lnum[fr]]), jump);
  1232. if(++pb->lnum[fr] > MAX_LNUM)
  1233. pb->lnum[fr]--;
  1234.     }
  1235.     leftover1 = count * stepsize - lov0;
  1236.     i += stepsize;
  1237. }
  1238.     }
  1239.     pagei++;
  1240. } while(i < nlines);
  1241. tab_cmd_dbdma(c1, DBDMA_NOP | BR_ALWAYS, jump);
  1242. c1 = jump_addr;
  1243. #endif /* PLANB_GSCANLINE */
  1245. /* For non-interlaced, we use even fields only */
  1246. if (!interlace)
  1247. goto cmd_tab_data_end;
  1249. /* Sync to odd field */
  1250. tab_cmd_dbdma(c1++, DBDMA_NOP | WAIT_IFCLR, 0);
  1251. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.br_sel),
  1252. PLANB_SET(ODD_FIELD));
  1253. tab_cmd_dbdma(c1++, DBDMA_NOP | WAIT_IFSET, 0);
  1254. tab_cmd_dbdma(c1, DBDMA_NOP | BR_IFCLR, virt_to_bus(c1-3)); c1++;
  1255. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->ch1.br_sel),
  1256. PLANB_SET(DMA_ABORT));
  1258. /* odd field data: */
  1259. jump_addr = c1 + TAB_FACTOR * nlines / 2;
  1260. jump = virt_to_bus(jump_addr);
  1261. #ifdef PLANB_GSCANLINE
  1262. for (i = 1; i < nlines; i += stepsize) {
  1263. tab_cmd_gen(c1++, INPUT_MORE | BR_IFSET, count,
  1264. virt_to_bus(pb->rawbuf[pagei
  1265. + i * scanline / PAGE_SIZE]), jump);
  1266. }
  1267. #else
  1268. i = 1;
  1269. leftover1 = 0;
  1270. pagei = pb->gbuf_idx[fr];
  1271. if(nlines <= 1)
  1272.     goto skip;
  1273. do {
  1274.     int j;
  1276.     base = virt_to_bus(pb->rawbuf[pagei]);
  1277.     nlpp = (PAGE_SIZE - leftover1) / count / stepsize;
  1278.     if(leftover1 >= count) {
  1279. tab_cmd_gen(c1++, INPUT_MORE | KEY_STREAM0 | BR_IFSET, count,
  1280. base + leftover1 - count, jump);
  1281. i += stepsize;
  1282.     }
  1283.     for(j = 0; j < nlpp && i < nlines; j++, i += stepsize, c1++)
  1284. tab_cmd_gen(c1, INPUT_MORE | KEY_STREAM0 | BR_IFSET, count,
  1285. base + count * (j * stepsize + 1) + leftover1, jump);
  1286.     if(i < nlines) {
  1287. int lov0 = PAGE_SIZE - count * nlpp * stepsize - leftover1;
  1289. if(lov0 == 0)
  1290.     leftover1 = 0;
  1291. else {
  1292.     if(lov0 > count) {
  1293. pb->l_to_addr[fr][pb->lnum[fr]] = pb->rawbuf[pagei]
  1294. + count * (nlpp * stepsize + 1) + leftover1;
  1295. pb->l_to_next_idx[fr][pb->lnum[fr]] = pagei + 1;
  1296. pb->l_to_next_size[fr][pb->lnum[fr]] = count * stepsize
  1297. - lov0;
  1298. tab_cmd_gen(c1++, INPUT_MORE | BR_IFSET, count,
  1299. virt_to_bus(pb->rawbuf[pb->l_fr_addr_idx[fr]
  1300. + pb->lnum[fr]]), jump);
  1301. if(++pb->lnum[fr] > MAX_LNUM)
  1302. pb->lnum[fr]--;
  1303. i += stepsize;
  1304.     }
  1305.     leftover1 = count * stepsize - lov0;
  1306. }
  1307.     }
  1308.     pagei++;
  1309. } while(i < nlines);
  1310. skip:
  1311. tab_cmd_dbdma(c1, DBDMA_NOP | BR_ALWAYS, jump);
  1312. c1 = jump_addr;
  1313. #endif /* PLANB_GSCANLINE */
  1315. cmd_tab_data_end:
  1316. tab_cmd_store(c1++, (unsigned)(&pb->planb_base_phys->intr_stat),
  1317. (fr << 9) | PLANB_FRM_IRQ | PLANB_GEN_IRQ);
  1318. /* stop it */
  1319. tab_cmd_dbdma(c1, DBDMA_STOP, 0);
  1321. eieio();
  1322. return c1;
  1323. }
  1325. static void planb_irq(int irq, void *dev_id, struct pt_regs * regs)
  1326. {
  1327. unsigned int stat, astat;
  1328. struct planb *pb = (struct planb *)dev_id;
  1330. IDEBUG("PlanB: planb_irq()n");
  1332. /* get/clear interrupt status bits */
  1333. eieio();
  1334. stat = in_le32(&pb->planb_base->intr_stat);
  1335. astat = stat & pb->intr_mask;
  1336. out_le32(&pb->planb_base->intr_stat, PLANB_FRM_IRQ
  1337. & ~astat & stat & ~PLANB_GEN_IRQ);
  1338. IDEBUG("PlanB: stat = %X, astat = %Xn", stat, astat);
  1340. if(astat & PLANB_FRM_IRQ) {
  1341. unsigned int fr = stat >> 9;
  1342. #ifndef PLANB_GSCANLINE
  1343. int i;
  1344. #endif
  1345. IDEBUG("PlanB: PLANB_FRM_IRQn");
  1347. pb->gcount++;
  1349. IDEBUG("PlanB: grab %d: fr = %d, gcount = %dn",
  1350. pb->grabbing, fr, pb->gcount);
  1351. #ifndef PLANB_GSCANLINE
  1352. IDEBUG("PlanB: %d * %d bytes are being copied overn",
  1353. pb->lnum[fr], pb->lsize[fr]);
  1354. for(i = 0; i < pb->lnum[fr]; i++) {
  1355. int first = pb->lsize[fr] - pb->l_to_next_size[fr][i];
  1357. memcpy(pb->l_to_addr[fr][i],
  1358. pb->rawbuf[pb->l_fr_addr_idx[fr] + i],
  1359. first);
  1360. memcpy(pb->rawbuf[pb->l_to_next_idx[fr][i]],
  1361. pb->rawbuf[pb->l_fr_addr_idx[fr] + i] + first,
  1362. pb->l_to_next_size[fr][i]);
  1363. }
  1364. #endif
  1365. pb->frame_stat[fr] = GBUFFER_DONE;
  1366. pb->grabbing--;
  1367. wake_up_interruptible(&pb->capq);
  1368. return;
  1369. }
  1370. /* incorrect interrupts? */
  1371. pb->intr_mask = PLANB_CLR_IRQ;
  1372. out_le32(&pb->planb_base->intr_stat, PLANB_CLR_IRQ);
  1373. printk(KERN_ERR "PlanB: IRQ lockup, cleared intrrupts"
  1374. " unconditionallyn");
  1375. }
  1377. /*******************************
  1378.  * Device Operations functions *
  1379.  *******************************/
  1381. static int planb_open(struct video_device *dev, int mode)
  1382. {
  1383. struct planb *pb = (struct planb *)dev;
  1385. if (pb->user == 0) {
  1386. int err;
  1387. if((err = planb_prepare_open(pb)) != 0)
  1388. return err;
  1389. }
  1390. pb->user++;
  1392. DEBUG("PlanB: device openedn");
  1394. MOD_INC_USE_COUNT;
  1395. return 0;   
  1396. }
  1398. static void planb_close(struct video_device *dev)
  1399. {
  1400. struct planb *pb = (struct planb *)dev;
  1402. if(pb->user < 1) /* ??? */
  1403. return;
  1404. planb_lock(pb);
  1405. if (pb->user == 1) {
  1406. if (pb->overlay) {
  1407. planb_dbdma_stop(&pb->planb_base->ch2);
  1408. planb_dbdma_stop(&pb->planb_base->ch1);
  1409. pb->overlay = 0;
  1410. }
  1411. planb_prepare_close(pb);
  1412. }
  1413. pb->user--;
  1414. planb_unlock(pb);
  1416. DEBUG("PlanB: device closedn");
  1418. MOD_DEC_USE_COUNT;  
  1419. }
  1421. static long planb_read(struct video_device *v, char *buf, unsigned long count,
  1422. int nonblock)
  1423. {
  1424. DEBUG("planb: read requestn");
  1425. return -EINVAL;
  1426. }
  1428. static long planb_write(struct video_device *v, const char *buf,
  1429. unsigned long count, int nonblock)
  1430. {
  1431. DEBUG("planb: write requestn");
  1432. return -EINVAL;
  1433. }
  1435. static int planb_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
  1436. {
  1437. struct planb *pb=(struct planb *)dev;
  1438.   
  1439. switch (cmd)
  1440. {
  1441. case VIDIOCGCAP:
  1442. {
  1443. struct video_capability b;
  1445. DEBUG("PlanB: IOCTL VIDIOCGCAPn");
  1447. strcpy (b.name, pb->video_dev.name);
  1448. b.type = VID_TYPE_OVERLAY | VID_TYPE_CLIPPING |
  1449.  VID_TYPE_FRAMERAM | VID_TYPE_SCALES |
  1450.  VID_TYPE_CAPTURE;
  1451. b.channels = 2; /* composite & svhs */
  1452. b.audios = 0;
  1453. b.maxwidth = PLANB_MAXPIXELS;
  1454.                         b.maxheight = PLANB_MAXLINES;
  1455.                         b.minwidth = 32; /* wild guess */
  1456.                         b.minheight = 32;
  1457.                         if (copy_to_user(arg,&b,sizeof(b)))
  1458.                                 return -EFAULT;
  1459. return 0;
  1460. }
  1461. case VIDIOCSFBUF:
  1462. {
  1463.                         struct video_buffer v;
  1464. unsigned short bpp;
  1465. unsigned int fmt;
  1467. DEBUG("PlanB: IOCTL VIDIOCSFBUFn");
  1469.                         if (!capable(CAP_SYS_ADMIN)
  1470. || !capable(CAP_SYS_RAWIO))
  1471.                                 return -EPERM;
  1472.                         if (copy_from_user(&v, arg,sizeof(v)))
  1473.                                 return -EFAULT;
  1474. planb_lock(pb);
  1475. switch(v.depth) {
  1476. case 8:
  1477. bpp = 1;
  1478. fmt = PLANB_GRAY;
  1479. break;
  1480. case 15:
  1481. case 16:
  1482. bpp = 2;
  1483. fmt = PLANB_COLOUR15;
  1484. break;
  1485. case 24:
  1486. case 32:
  1487. bpp = 4;
  1488. fmt = PLANB_COLOUR32;
  1489. break;
  1490. default:
  1491. planb_unlock(pb);
  1492.                                 return -EINVAL;
  1493. }
  1494. if (bpp * v.width > v.bytesperline) {
  1495. planb_unlock(pb);
  1496. return -EINVAL;
  1497. }
  1498. pb->win.bpp = bpp;
  1499. pb->win.color_fmt = fmt;
  1500. pb->frame_buffer_phys = (unsigned long) v.base;
  1501. pb->win.sheight = v.height;
  1502. pb->win.swidth = v.width;
  1503. pb->picture.depth = pb->win.depth = v.depth;
  1504. pb->win.bpl = pb->win.bpp * pb->win.swidth;
  1505. pb->win.pad = v.bytesperline - pb->win.bpl;
  1507.                         DEBUG("PlanB: Display at %p is %d by %d, bytedepth %d,"
  1508. " bpl %d (+ %d)n", v.base, v.width,v.height,
  1509. pb->win.bpp, pb->win.bpl, pb->win.pad);
  1511. pb->cmd_buff_inited = 0;
  1512. if(pb->overlay) {
  1513. suspend_overlay(pb);
  1514. fill_cmd_buff(pb);
  1515. resume_overlay(pb);
  1516. }
  1517. planb_unlock(pb);
  1518. return 0;
  1519. }
  1520. case VIDIOCGFBUF:
  1521. {
  1522.                         struct video_buffer v;
  1524. DEBUG("PlanB: IOCTL VIDIOCGFBUFn");
  1526. v.base = (void *)pb->frame_buffer_phys;
  1527. v.height = pb->win.sheight;
  1528. v.width = pb->win.swidth;
  1529. v.depth = pb->win.depth;
  1530. v.bytesperline = pb->win.bpl + pb->win.pad;
  1531. if (copy_to_user(arg, &v, sizeof(v)))
  1532.                                 return -EFAULT;
  1533. return 0;
  1534. }
  1535. case VIDIOCCAPTURE:
  1536. {
  1537. int i;
  1539.                         if(copy_from_user(&i, arg, sizeof(i)))
  1540.                                 return -EFAULT;
  1541. if(i==0) {
  1542. DEBUG("PlanB: IOCTL VIDIOCCAPTURE Stopn");
  1544. if (!(pb->overlay))
  1545. return 0;
  1546. planb_lock(pb);
  1547. pb->overlay = 0;
  1548. overlay_stop(pb);
  1549. planb_unlock(pb);
  1550. } else {
  1551. DEBUG("PlanB: IOCTL VIDIOCCAPTURE Startn");
  1553. if (pb->frame_buffer_phys == 0 ||
  1554.   pb->win.width == 0 ||
  1555.   pb->win.height == 0)
  1556. return -EINVAL;
  1557. if (pb->overlay)
  1558. return 0;
  1559. planb_lock(pb);
  1560. pb->overlay = 1;
  1561. if(!(pb->cmd_buff_inited))
  1562. fill_cmd_buff(pb);
  1563. overlay_start(pb);
  1564. planb_unlock(pb);
  1565. }
  1566. return 0;
  1567. }
  1568. case VIDIOCGCHAN:
  1569. {
  1570. struct video_channel v;
  1572. DEBUG("PlanB: IOCTL VIDIOCGCHANn");
  1574. if(copy_from_user(&v, arg,sizeof(v)))
  1575. return -EFAULT;
  1576. v.flags = 0;
  1577. v.tuners = 0;
  1578. v.type = VIDEO_TYPE_CAMERA;
  1579. v.norm = pb->win.norm;
  1580. switch(v.channel)
  1581. {
  1582. case 0:
  1583. strcpy(v.name,"Composite");
  1584. break;
  1585. case 1:
  1586. strcpy(v.name,"SVHS");
  1587. break;
  1588. default:
  1589. return -EINVAL;
  1590. break;
  1591. }
  1592. if(copy_to_user(arg,&v,sizeof(v)))
  1593. return -EFAULT;
  1595. return 0;
  1596. }
  1597. case VIDIOCSCHAN:
  1598. {
  1599. struct video_channel v;
  1601. DEBUG("PlanB: IOCTL VIDIOCSCHANn");
  1603. if(copy_from_user(&v, arg, sizeof(v)))
  1604. return -EFAULT;
  1606. if (v.norm != pb->win.norm) {
  1607. int i, maxlines;
  1609. switch (v.norm)
  1610. {
  1611. case VIDEO_MODE_PAL:
  1612. case VIDEO_MODE_SECAM:
  1613. maxlines = PLANB_MAXLINES;
  1614. break;
  1615. case VIDEO_MODE_NTSC:
  1616. maxlines = PLANB_NTSC_MAXLINES;
  1617. break;
  1618. default:
  1619. return -EINVAL;
  1620. break;
  1621. }
  1622. planb_lock(pb);
  1623. /* empty the grabbing queue */
  1624. while(pb->grabbing)
  1625. interruptible_sleep_on(&pb->capq);
  1626. pb->maxlines = maxlines;
  1627. pb->win.norm = v.norm;
  1628. /* Stop overlay if running */
  1629. suspend_overlay(pb);
  1630. for(i = 0; i < MAX_GBUFFERS; i++)
  1631. pb->gnorm_switch[i] = 1;
  1632. /* I know it's an overkill, but.... */
  1633. fill_cmd_buff(pb);
  1634. /* ok, now init it accordingly */
  1635. saa_init_regs (pb);
  1636. /* restart overlay if it was running */
  1637. resume_overlay(pb);
  1638. planb_unlock(pb);
  1639. }
  1641. switch(v.channel)
  1642. {
  1643. case 0: /* Composite */
  1644. saa_set (SAA7196_IOCC,
  1645. ((saa_regs[pb->win.norm][SAA7196_IOCC] &
  1646.   ~7) | 3), pb);
  1647. break;
  1648. case 1: /* SVHS */
  1649. saa_set (SAA7196_IOCC,
  1650. ((saa_regs[pb->win.norm][SAA7196_IOCC] &
  1651.   ~7) | 4), pb);
  1652. break;
  1653. default:
  1654. return -EINVAL;
  1655. break;
  1656. }
  1658. return 0;
  1659. }
  1660. case VIDIOCGPICT:
  1661. {
  1662. struct video_picture vp = pb->picture;
  1664. DEBUG("PlanB: IOCTL VIDIOCGPICTn");
  1666. switch(pb->win.color_fmt) {
  1667. case PLANB_GRAY:
  1668. vp.palette = VIDEO_PALETTE_GREY;
  1669. case PLANB_COLOUR15:
  1670. vp.palette = VIDEO_PALETTE_RGB555;
  1671. break;
  1672. case PLANB_COLOUR32:
  1673. vp.palette = VIDEO_PALETTE_RGB32;
  1674. break;
  1675. default:
  1676. vp.palette = 0;
  1677. break;
  1678. }
  1680. if(copy_to_user(arg,&vp,sizeof(vp)))
  1681. return -EFAULT;
  1682. return 0;
  1683. }
  1684. case VIDIOCSPICT:
  1685. {
  1686. struct video_picture vp;
  1688. DEBUG("PlanB: IOCTL VIDIOCSPICTn");
  1690. if(copy_from_user(&vp,arg,sizeof(vp)))
  1691. return -EFAULT;
  1692. pb->picture = vp;
  1693. /* Should we do sanity checks here? */
  1694. saa_set (SAA7196_BRIG, (unsigned char)
  1695.     ((pb->picture.brightness) >> 8), pb);
  1696. saa_set (SAA7196_HUEC, (unsigned char)
  1697.     ((pb->picture.hue) >> 8) ^ 0x80, pb);
  1698. saa_set (SAA7196_CSAT, (unsigned char)
  1699.     ((pb->picture.colour) >> 9), pb);
  1700. saa_set (SAA7196_CONT, (unsigned char)
  1701.     ((pb->picture.contrast) >> 9), pb);
  1703. return 0;
  1704. }
  1705. case VIDIOCSWIN:
  1706. {
  1707. struct video_window vw;
  1708. struct video_clip clip;
  1709. int  i;
  1711. DEBUG("PlanB: IOCTL VIDIOCSWINn");
  1713. if(copy_from_user(&vw,arg,sizeof(vw)))
  1714. return -EFAULT;
  1716. planb_lock(pb);
  1717. /* Stop overlay if running */
  1718. suspend_overlay(pb);
  1719. pb->win.interlace = (vw.height > pb->maxlines/2)? 1: 0;
  1720. if (pb->win.x != vw.x ||
  1721.     pb->win.y != vw.y ||
  1722.     pb->win.width != vw.width ||
  1723.     pb->win.height != vw.height ||
  1724.     !pb->cmd_buff_inited) {
  1725. pb->win.x = vw.x;
  1726. pb->win.y = vw.y;
  1727. pb->win.width = vw.width;
  1728. pb->win.height = vw.height;
  1729. fill_cmd_buff(pb);
  1730. }
  1731. /* Reset clip mask */
  1732. memset ((void *) pb->mask, 0xff, (pb->maxlines
  1733. * ((PLANB_MAXPIXELS + 7) & ~7)) / 8);
  1734. /* Add any clip rects */
  1735. for (i = 0; i < vw.clipcount; i++) {
  1736. if (copy_from_user(&clip, vw.clips + i,
  1737. sizeof(struct video_clip)))
  1738. return -EFAULT;
  1739. add_clip(pb, &clip);
  1740. }
  1741. /* restart overlay if it was running */
  1742. resume_overlay(pb);
  1743. planb_unlock(pb);
  1744. return 0;
  1745. }
  1746. case VIDIOCGWIN:
  1747. {
  1748. struct video_window vw;
  1750. DEBUG("PlanB: IOCTL VIDIOCGWINn");
  1752. vw.x=pb->win.x;
  1753. vw.y=pb->win.y;
  1754. vw.width=pb->win.width;
  1755. vw.height=pb->win.height;
  1756. vw.chromakey=0;
  1757. vw.flags=0;
  1758. if(pb->win.interlace)
  1759. vw.flags|=VIDEO_WINDOW_INTERLACE;
  1760. if(copy_to_user(arg,&vw,sizeof(vw)))
  1761. return -EFAULT;
  1762. return 0;
  1763. }
  1764.         case VIDIOCSYNC: {
  1765. int i;
  1767. IDEBUG("PlanB: IOCTL VIDIOCSYNCn");
  1769. if(copy_from_user((void *)&i,arg,sizeof(int)))
  1770. return -EFAULT;
  1772. IDEBUG("PlanB: sync to frame %dn", i);
  1774.                         if(i > (MAX_GBUFFERS - 1) || i < 0)
  1775.                                 return -EINVAL;
  1776. chk_grab:
  1777.                         switch (pb->frame_stat[i]) {
  1778.                         case GBUFFER_UNUSED:
  1779.                                 return -EINVAL;
  1780. case GBUFFER_GRABBING:
  1781. IDEBUG("PlanB: waiting for grab"
  1782. " done (%d)n", i);
  1783.           interruptible_sleep_on(&pb->capq);
  1784. if(signal_pending(current))
  1785. return -EINTR;
  1786. goto chk_grab;
  1787.                         case GBUFFER_DONE:
  1788.                                 pb->frame_stat[i] = GBUFFER_UNUSED;
  1789.                                 break;
  1790.                         }
  1791.                         return 0;
  1792. }
  1794.         case VIDIOCMCAPTURE:
  1795. {
  1796.                         struct video_mmap vm;
  1797. volatile unsigned int status;
  1799. IDEBUG("PlanB: IOCTL VIDIOCMCAPTUREn");
  1801. if(copy_from_user((void *) &vm,(void *)arg,sizeof(vm)))
  1802. return -EFAULT;
  1803.                         status = pb->frame_stat[vm.frame];
  1804.                         if (status != GBUFFER_UNUSED)
  1805.                                 return -EBUSY;
  1807.         return vgrab(pb, &vm);
  1808. }
  1810. case VIDIOCGMBUF:
  1811. {
  1812. int i;
  1813. struct video_mbuf vm;
  1815. DEBUG("PlanB: IOCTL VIDIOCGMBUFn");
  1817. memset(&vm, 0 , sizeof(vm));
  1818. vm.size = PLANB_MAX_FBUF * MAX_GBUFFERS;
  1819. vm.frames = MAX_GBUFFERS;
  1820. for(i = 0; i<MAX_GBUFFERS; i++)
  1821. vm.offsets[i] = PLANB_MAX_FBUF * i;
  1822. if(copy_to_user((void *)arg, (void *)&vm, sizeof(vm)))
  1823. return -EFAULT;
  1824. return 0;
  1825. }
  1827. case PLANBIOCGSAAREGS:
  1828. {
  1829. struct planb_saa_regs preg;
  1831. DEBUG("PlanB: IOCTL PLANBIOCGSAAREGSn");
  1833. if(copy_from_user(&preg, arg, sizeof(preg)))
  1834. return -EFAULT;
  1835. if(preg.addr >= SAA7196_NUMREGS)
  1836. return -EINVAL;
  1837. preg.val = saa_regs[pb->win.norm][preg.addr];
  1838. if(copy_to_user((void *)arg, (void *)&preg,
  1839. sizeof(preg)))
  1840. return -EFAULT;
  1841. return 0;
  1842. }
  1844. case PLANBIOCSSAAREGS:
  1845. {
  1846. struct planb_saa_regs preg;
  1848. DEBUG("PlanB: IOCTL PLANBIOCSSAAREGSn");
  1850. if(copy_from_user(&preg, arg, sizeof(preg)))
  1851. return -EFAULT;
  1852. if(preg.addr >= SAA7196_NUMREGS)
  1853. return -EINVAL;
  1854. saa_set (preg.addr, preg.val, pb);
  1855. return 0;
  1856. }
  1858. case PLANBIOCGSTAT:
  1859. {
  1860. struct planb_stat_regs pstat;
  1862. DEBUG("PlanB: IOCTL PLANBIOCGSTATn");
  1864. pstat.ch1_stat = in_le32(&pb->planb_base->ch1.status);
  1865. pstat.ch2_stat = in_le32(&pb->planb_base->ch2.status);
  1866. pstat.saa_stat0 = saa_status(0, pb);
  1867. pstat.saa_stat1 = saa_status(1, pb);
  1869. if(copy_to_user((void *)arg, (void *)&pstat,
  1870. sizeof(pstat)))
  1871. return -EFAULT;
  1872. return 0;
  1873. }
  1875. case PLANBIOCSMODE: {
  1876. int v;
  1878. DEBUG("PlanB: IOCTL PLANBIOCSMODEn");
  1880. if(copy_from_user(&v, arg, sizeof(v)))
  1881. return -EFAULT;
  1883. switch(v)
  1884. {
  1885. case PLANB_TV_MODE:
  1886. saa_set (SAA7196_STDC,
  1887. (saa_regs[pb->win.norm][SAA7196_STDC] &
  1888.   0x7f), pb);
  1889. break;
  1890. case PLANB_VTR_MODE:
  1891. saa_set (SAA7196_STDC,
  1892. (saa_regs[pb->win.norm][SAA7196_STDC] |
  1893.   0x80), pb);
  1894. break;
  1895. default:
  1896. return -EINVAL;
  1897. break;
  1898. }
  1899. pb->win.mode = v;
  1900. return 0;
  1901. }
  1902. case PLANBIOCGMODE: {
  1903. int v=pb->win.mode;
  1905. DEBUG("PlanB: IOCTL PLANBIOCGMODEn");
  1907. if(copy_to_user(arg,&v,sizeof(v)))
  1908. return -EFAULT;
  1909. return 0;
  1910. }
  1911. #ifdef PLANB_GSCANLINE
  1912. case PLANBG_GRAB_BPL: {
  1913. int v=pb->gbytes_per_line;
  1915. DEBUG("PlanB: IOCTL PLANBG_GRAB_BPLn");
  1917. if(copy_to_user(arg,&v,sizeof(v)))
  1918. return -EFAULT;
  1919. return 0;
  1920. }
  1921. #endif /* PLANB_GSCANLINE */
  1922. case PLANB_INTR_DEBUG: {
  1923. int i;
  1925. DEBUG("PlanB: IOCTL PLANB_INTR_DEBUGn");
  1927. if(copy_from_user(&i, arg, sizeof(i)))
  1928. return -EFAULT;
  1930. /* avoid hang ups all together */
  1931. for (i = 0; i < MAX_GBUFFERS; i++) {
  1932. if(pb->frame_stat[i] == GBUFFER_GRABBING) {
  1933. pb->frame_stat[i] = GBUFFER_DONE;
  1934. }
  1935. }
  1936. if(pb->grabbing)
  1937. pb->grabbing--;
  1938. wake_up_interruptible(&pb->capq);
  1939. return 0;
  1940. }
  1941. case PLANB_INV_REGS: {
  1942. int i;
  1943. struct planb_any_regs any;
  1945. DEBUG("PlanB: IOCTL PLANB_INV_REGSn");
  1947. if(copy_from_user(&any, arg, sizeof(any)))
  1948. return -EFAULT;
  1949. if(any.offset < 0 || any.offset + any.bytes > 0x400)
  1950. return -EINVAL;
  1951. if(any.bytes > 128)
  1952. return -EINVAL;
  1953. for (i = 0; i < any.bytes; i++) {
  1954. any.data[i] =
  1955. in_8((unsigned char *)pb->planb_base
  1956. + any.offset + i);
  1957. }
  1958. if(copy_to_user(arg,&any,sizeof(any)))
  1959. return -EFAULT;
  1960. return 0;
  1961. }
  1962. default:
  1963. {
  1964. DEBUG("PlanB: Unimplemented IOCTLn");
  1965. return -ENOIOCTLCMD;
  1966. }
  1967. /* Some IOCTLs are currently unsupported on PlanB */
  1968. case VIDIOCGTUNER: {
  1969. DEBUG("PlanB: IOCTL VIDIOCGTUNERn");
  1970. goto unimplemented; }
  1971. case VIDIOCSTUNER: {
  1972. DEBUG("PlanB: IOCTL VIDIOCSTUNERn");
  1973. goto unimplemented; }
  1974. case VIDIOCSFREQ: {
  1975. DEBUG("PlanB: IOCTL VIDIOCSFREQn");
  1976. goto unimplemented; }
  1977. case VIDIOCGFREQ: {
  1978. DEBUG("PlanB: IOCTL VIDIOCGFREQn");
  1979. goto unimplemented; }
  1980. case VIDIOCKEY: {
  1981. DEBUG("PlanB: IOCTL VIDIOCKEYn");
  1982. goto unimplemented; }
  1983. case VIDIOCSAUDIO: {
  1984. DEBUG("PlanB: IOCTL VIDIOCSAUDIOn");
  1985. goto unimplemented; }
  1986. case VIDIOCGAUDIO: {
  1987. DEBUG("PlanB: IOCTL VIDIOCGAUDIOn");
  1988. goto unimplemented; }
  1989. unimplemented:
  1990. DEBUG("       Unimplementedn");
  1991. return -ENOIOCTLCMD;
  1992. }
  1993. return 0;
  1994. }
  1996. static int planb_mmap(struct video_device *dev, const char *adr, unsigned long size)
  1997. {
  1998. int i;
  1999. struct planb *pb = (struct planb *)dev;
  2000.         unsigned long start = (unsigned long)adr;
  2002. if (size > MAX_GBUFFERS * PLANB_MAX_FBUF)
  2003.         return -EINVAL;
  2004. if (!pb->rawbuf) {
  2005. int err;
  2006. if((err=grabbuf_alloc(pb)))
  2007. return err;
  2008. }
  2009. for (i = 0; i < pb->rawbuf_size; i++) {
  2010. if (remap_page_range(start, virt_to_phys((void *)pb->rawbuf[i]),
  2011. PAGE_SIZE, PAGE_SHARED))
  2012. return -EAGAIN;
  2013. start += PAGE_SIZE;
  2014. if (size <= PAGE_SIZE)
  2015. break;
  2016. size -= PAGE_SIZE;
  2017. }
  2018. return 0;
  2019. }
  2021. static struct video_device planb_template=
  2022. {
  2023. owner: THIS_MODULE,
  2024. name: PLANB_DEVICE_NAME,
  2025. type: VID_TYPE_OVERLAY,
  2026. hardware: VID_HARDWARE_PLANB,
  2027. open: planb_open,
  2028. close: planb_close,
  2029. read: planb_read,
  2030. write: planb_write,
  2031. ioctl: planb_ioctl,
  2032. mmap: planb_mmap, /* mmap? */
  2033. };
  2035. static int init_planb(struct planb *pb)
  2036. {
  2037. unsigned char saa_rev;
  2038. int i, result;
  2039. unsigned long flags;
  2041. memset ((void *) &pb->win, 0, sizeof (struct planb_window));
  2042. /* Simple sanity check */
  2043. if(def_norm >= NUM_SUPPORTED_NORM || def_norm < 0) {
  2044. printk(KERN_ERR "PlanB: Option(s) invalidn");
  2045. return -2;
  2046. }
  2047. pb->win.norm = def_norm;
  2048. pb->win.mode = PLANB_TV_MODE; /* TV mode */
  2049. pb->win.interlace=1;
  2050. pb->win.x=0;
  2051. pb->win.y=0;
  2052. pb->win.width=768; /* 640 */
  2053. pb->win.height=576; /* 480 */
  2054. pb->maxlines=576;
  2055. #if 0
  2056. btv->win.cropwidth=768; /* 640 */
  2057. btv->win.cropheight=576; /* 480 */
  2058. btv->win.cropx=0;
  2059. btv->win.cropy=0;
  2060. #endif
  2061. pb->win.pad=0;
  2062. pb->win.bpp=4;
  2063. pb->win.depth=32;
  2064. pb->win.color_fmt=PLANB_COLOUR32;
  2065. pb->win.bpl=1024*pb->win.bpp;
  2066. pb->win.swidth=1024;
  2067. pb->win.sheight=768;
  2068. #ifdef PLANB_GSCANLINE
  2069. if((pb->gbytes_per_line = PLANB_MAXPIXELS * 4) > PAGE_SIZE
  2070. || (pb->gbytes_per_line <= 0))
  2071. return -3;
  2072. else {
  2073. /* page align pb->gbytes_per_line for DMA purpose */
  2074. for(i = PAGE_SIZE; pb->gbytes_per_line < (i>>1);)
  2075. i>>=1;
  2076. pb->gbytes_per_line = i;
  2077. }
  2078. #endif
  2079. pb->tab_size = PLANB_MAXLINES + 40;
  2080. pb->suspend = 0;
  2081. init_MUTEX(&pb->lock);
  2082. pb->ch1_cmd = 0;
  2083. pb->ch2_cmd = 0;
  2084. pb->mask = 0;
  2085. pb->priv_space = 0;
  2086. pb->offset = 0;
  2087. pb->user = 0;
  2088. pb->overlay = 0;
  2089. init_waitqueue_head(&pb->suspendq);
  2090. pb->cmd_buff_inited = 0;
  2091. pb->frame_buffer_phys = 0;
  2093. /* Reset DMA controllers */
  2094. planb_dbdma_stop(&pb->planb_base->ch2);
  2095. planb_dbdma_stop(&pb->planb_base->ch1);
  2097. saa_rev =  (saa_status(0, pb) & 0xf0) >> 4;
  2098. printk(KERN_INFO "PlanB: SAA7196 video processor rev. %dn", saa_rev);
  2099. /* Initialize the SAA registers in memory and on chip */
  2100. saa_init_regs (pb);
  2102. /* clear interrupt mask */
  2103. pb->intr_mask = PLANB_CLR_IRQ;
  2105. save_flags(flags); cli();
  2106.         result = request_irq(pb->irq, planb_irq, 0, "PlanB", (void *)pb);
  2107.         if (result < 0) {
  2108.         if (result==-EINVAL)
  2109.                 printk(KERN_ERR "PlanB: Bad irq number (%d) "
  2110. "or handlern", (int)pb->irq);
  2111. else if (result==-EBUSY)
  2112. printk(KERN_ERR "PlanB: I don't know why, "
  2113. "but IRQ %d is busyn", (int)pb->irq);
  2114. restore_flags(flags);
  2115. return result;
  2116. }
  2117. disable_irq(pb->irq);
  2118. restore_flags(flags);
  2119.         
  2120. /* Now add the template and register the device unit. */
  2121. memcpy(&pb->video_dev,&planb_template,sizeof(planb_template));
  2123. pb->picture.brightness=0x90<<8;
  2124. pb->picture.contrast = 0x70 << 8;
  2125. pb->picture.colour = 0x70<<8;
  2126. pb->picture.hue = 0x8000;
  2127. pb->picture.whiteness = 0;
  2128. pb->picture.depth = pb->win.depth;
  2130. pb->frame_stat=NULL;
  2131. init_waitqueue_head(&pb->capq);
  2132. for(i=0; i<MAX_GBUFFERS; i++) {
  2133. pb->gbuf_idx[i] = PLANB_MAX_FBUF * i / PAGE_SIZE;
  2134. pb->gwidth[i]=0;
  2135. pb->gheight[i]=0;
  2136. pb->gfmt[i]=0;
  2137. pb->cap_cmd[i]=NULL;
  2138. #ifndef PLANB_GSCANLINE
  2139. pb->l_fr_addr_idx[i] = MAX_GBUFFERS * (PLANB_MAX_FBUF
  2140. / PAGE_SIZE + 1) + MAX_LNUM * i;
  2141. pb->lsize[i] = 0;
  2142. pb->lnum[i] = 0;
  2143. #endif
  2144. }
  2145. pb->rawbuf=NULL;
  2146. pb->grabbing=0;
  2148. /* enable interrupts */
  2149. out_le32(&pb->planb_base->intr_stat, PLANB_CLR_IRQ);
  2150. pb->intr_mask = PLANB_FRM_IRQ;
  2151. enable_irq(pb->irq);
  2153. if(video_register_device(&pb->video_dev, VFL_TYPE_GRABBER, video_nr)<0)
  2154. return -1;
  2156. return 0;
  2157. }
  2159. /*
  2160.  * Scan for a PlanB controller, request the irq and map the io memory 
  2161.  */
  2163. static int find_planb(void)
  2164. {
  2165. struct planb *pb;
  2166. struct device_node *planb_devices;
  2167. unsigned char dev_fn, confreg, bus;
  2168. unsigned int old_base, new_base;
  2169. unsigned int irq;
  2170. struct pci_dev  *pdev;
  2172. if (_machine != _MACH_Pmac)
  2173. return 0;
  2175. planb_devices = find_devices("planb");
  2176. if (planb_devices == 0) {
  2177. planb_num=0;
  2178. printk(KERN_WARNING "PlanB: no device found!n");
  2179. return planb_num;
  2180. }
  2182. if (planb_devices->next != NULL)
  2183. printk(KERN_ERR "Warning: only using first PlanB device!n");
  2184. pb = &planbs[0];
  2185. planb_num = 1;
  2187.         if (planb_devices->n_addrs != 1) {
  2188.                 printk (KERN_WARNING "PlanB: expecting 1 address for planb "
  2189.                  "(got %d)", planb_devices->n_addrs);
  2190. return 0;
  2191. }
  2193. if (planb_devices->n_intrs == 0) {
  2194. printk(KERN_WARNING "PlanB: no intrs for device %sn",
  2195.        planb_devices->full_name);
  2196. return 0;
  2197. } else {
  2198. irq = planb_devices->intrs[0].line;
  2199. }
  2201. /* Initialize PlanB's PCI registers */
  2203. /* There is a bug with the way OF assigns addresses
  2204.    to the devices behind the chaos bridge.
  2205.    control needs only 0x1000 of space, but decodes only
  2206.    the upper 16 bits. It therefore occupies a full 64K.
  2207.    OF assigns the planb controller memory within this space;
  2208.    so we need to change that here in order to access planb. */
  2210. /* We remap to 0xf1000000 in hope that nobody uses it ! */
  2212. bus = (planb_devices->addrs[0].space >> 16) & 0xff;
  2213. dev_fn = (planb_devices->addrs[0].space >> 8) & 0xff;
  2214. confreg = planb_devices->addrs[0].space & 0xff;
  2215. old_base = planb_devices->addrs[0].address;
  2216. new_base = 0xf1000000;
  2218. DEBUG("PlanB: Found on bus %d, dev %d, func %d, "
  2219. "membase 0x%x (base reg. 0x%x)n",
  2220. bus, PCI_SLOT(dev_fn), PCI_FUNC(dev_fn), old_base, confreg);
  2222. pdev = pci_find_slot (bus, dev_fn);
  2223. if (!pdev) {
  2224. printk(KERN_ERR "cannot find slotn");
  2225. /* XXX handle error */
  2226. }
  2228. /* Enable response in memory space, bus mastering,
  2229.    use memory write and invalidate */
  2230. pci_write_config_word (pdev, PCI_COMMAND,
  2231. PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER |
  2232. PCI_COMMAND_INVALIDATE);
  2233. /* Set PCI Cache line size & latency timer */
  2234. pci_write_config_byte (pdev, PCI_CACHE_LINE_SIZE, 0x8);
  2235. pci_write_config_byte (pdev, PCI_LATENCY_TIMER, 0x40);
  2237. /* Set the new base address */
  2238. pci_write_config_dword (pdev, confreg, new_base);
  2240. planb_regs = (volatile struct planb_registers *)
  2241. ioremap (new_base, 0x400);
  2242. pb->planb_base = planb_regs;
  2243. pb->planb_base_phys = (struct planb_registers *)new_base;
  2244. pb->irq = irq;
  2246. return planb_num;
  2247. }
  2249. static void release_planb(void)
  2250. {
  2251. int i;
  2252. struct planb *pb;
  2254. for (i=0;i<planb_num; i++) 
  2255. {
  2256. pb=&planbs[i];
  2258. /* stop and flash DMAs unconditionally */
  2259. planb_dbdma_stop(&pb->planb_base->ch2);
  2260. planb_dbdma_stop(&pb->planb_base->ch1);
  2262. /* clear and free interrupts */
  2263. pb->intr_mask = PLANB_CLR_IRQ;
  2264. out_le32 (&pb->planb_base->intr_stat, PLANB_CLR_IRQ);
  2265. free_irq(pb->irq, pb);
  2267. /* make sure all allocated memory are freed */
  2268. planb_prepare_close(pb);
  2270. printk(KERN_INFO "PlanB: unregistering with v4ln");
  2271. video_unregister_device(&pb->video_dev);
  2273. /* note that iounmap() does nothing on the PPC right now */
  2274. iounmap ((void *)pb->planb_base);
  2275. }
  2276. }
  2278. static int __init init_planbs(void)
  2279. {
  2280. int i;
  2281.   
  2282. if (find_planb()<=0)
  2283. return -EIO;
  2285. for (i=0; i<planb_num; i++) {
  2286. if (init_planb(&planbs[i])<0) {
  2287. printk(KERN_ERR "PlanB: error registering device %d"
  2288. " with v4ln", i);
  2289. release_planb();
  2290. return -EIO;
  2291. } 
  2292. printk(KERN_INFO "PlanB: registered device %d with v4ln", i);
  2293. }  
  2294. return 0;
  2295. }
  2297. static void __exit exit_planbs(void)
  2298. {
  2299. release_planb();
  2300. }
  2302. module_init(init_planbs);
  2303. module_exit(exit_planbs);