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

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

Linux/Unix编程

开发平台：

Unix_Linux

vfc_dev.c：源码内容
  1. /*
  2.  * drivers/sbus/char/vfc_dev.c
  3.  *
  4.  * Driver for the Videopix Frame Grabber.
  5.  * 
  6.  * In order to use the VFC you need to program the video controller
  7.  * chip. This chip is the Phillips SAA9051.  You need to call their
  8.  * documentation ordering line to get the docs.
  9.  *
  10.  * There is very little documentation on the VFC itself.  There is
  11.  * some useful info that can be found in the manuals that come with
  12.  * the card.  I will hopefully write some better docs at a later date.
  13.  *
  14.  * Copyright (C) 1996 Manish Vachharajani (mvachhar@noc.rutgers.edu)
  15.  * */
  17. #include <linux/module.h>
  18. #include <linux/kernel.h>
  19. #include <linux/string.h>
  20. #include <linux/slab.h>
  21. #include <linux/errno.h>
  22. #include <linux/sched.h>
  23. #include <linux/fs.h>
  24. #include <linux/smp_lock.h>
  25. #include <linux/delay.h>
  26. #include <linux/spinlock.h>
  28. #include <asm/openprom.h>
  29. #include <asm/oplib.h>
  30. #include <asm/io.h>
  31. #include <asm/system.h>
  32. #include <asm/sbus.h>
  33. #include <asm/page.h>
  34. #include <asm/pgtable.h>
  35. #include <asm/uaccess.h>
  37. #define VFC_MAJOR (60)
  39. #if 0
  40. #define VFC_IOCTL_DEBUG
  41. #endif
  43. #include "vfc.h"
  44. #include <asm/vfc_ioctls.h>
  46. static struct file_operations vfc_fops;
  47. static devfs_handle_t devfs_handle;  /*  For the directory  */
  48. struct vfc_dev **vfc_dev_lst;
  49. static char vfcstr[]="vfc";
  50. static unsigned char saa9051_init_array[VFC_SAA9051_NR] = {
  51. 0x00, 0x64, 0x72, 0x52,
  52. 0x36, 0x18, 0xff, 0x20,
  53. 0xfc, 0x77, 0xe3, 0x50,
  54. 0x3e
  55. };
  57. void vfc_lock_device(struct vfc_dev *dev)
  58. {
  59. down(&dev->device_lock_sem);
  60. }
  62. void vfc_unlock_device(struct vfc_dev *dev)
  63. {
  64. up(&dev->device_lock_sem);
  65. }
  68. void vfc_captstat_reset(struct vfc_dev *dev) 
  69. {
  70. dev->control_reg |= VFC_CONTROL_CAPTRESET;
  71. sbus_writel(dev->control_reg, &dev->regs->control);
  72. dev->control_reg &= ~VFC_CONTROL_CAPTRESET;
  73. sbus_writel(dev->control_reg, &dev->regs->control);
  74. dev->control_reg |= VFC_CONTROL_CAPTRESET;
  75. sbus_writel(dev->control_reg, &dev->regs->control);
  76. }
  78. void vfc_memptr_reset(struct vfc_dev *dev) 
  79. {
  80. dev->control_reg |= VFC_CONTROL_MEMPTR;
  81. sbus_writel(dev->control_reg, &dev->regs->control);
  82. dev->control_reg &= ~VFC_CONTROL_MEMPTR;
  83. sbus_writel(dev->control_reg, &dev->regs->control);
  84. dev->control_reg |= VFC_CONTROL_MEMPTR; 
  85. sbus_writel(dev->control_reg, &dev->regs->control);
  86. }
  88. int vfc_csr_init(struct vfc_dev *dev)
  89. {
  90. dev->control_reg = 0x80000000;
  91. sbus_writel(dev->control_reg, &dev->regs->control);
  92. udelay(200); 
  93. dev->control_reg &= ~0x80000000;
  94. sbus_writel(dev->control_reg, &dev->regs->control);
  95. udelay(100); 
  96. sbus_writel(0x0f000000, &dev->regs->i2c_magic2);
  98. vfc_memptr_reset(dev);
  100. dev->control_reg &= ~VFC_CONTROL_DIAGMODE;
  101. dev->control_reg &= ~VFC_CONTROL_CAPTURE;
  102. dev->control_reg |= 0x40000000;
  103. sbus_writel(dev->control_reg, &dev->regs->control);
  105. vfc_captstat_reset(dev);
  107. return 0;
  108. }
  110. int vfc_saa9051_init(struct vfc_dev *dev)
  111. {
  112. int i;
  114. for (i = 0; i < VFC_SAA9051_NR; i++)
  115. dev->saa9051_state_array[i] = saa9051_init_array[i];
  117. vfc_i2c_sendbuf(dev,VFC_SAA9051_ADDR,
  118. dev->saa9051_state_array, VFC_SAA9051_NR);
  119. return 0;
  120. }
  122. int init_vfc_hw(struct vfc_dev *dev) 
  123. {
  124. vfc_lock_device(dev);
  125. vfc_csr_init(dev);
  127. vfc_pcf8584_init(dev);
  128. vfc_init_i2c_bus(dev); /* hopefully this doesn't undo the magic
  129.   sun code above*/
  130. vfc_saa9051_init(dev);
  131. vfc_unlock_device(dev);
  132. return 0; 
  133. }
  135. int init_vfc_devstruct(struct vfc_dev *dev, int instance) 
  136. {
  137. dev->instance=instance;
  138. init_MUTEX(&dev->device_lock_sem);
  139. dev->control_reg=0;
  140. init_waitqueue_head(&dev->poll_wait);
  141. dev->busy=0;
  142. return 0;
  143. }
  145. int init_vfc_device(struct sbus_dev *sdev,struct vfc_dev *dev, int instance)
  146. {
  147. char devname[8];
  149. if(dev == NULL) {
  150. printk(KERN_ERR "VFC: Bogus pointer passedn");
  151. return -ENOMEM;
  152. }
  153. printk("Initializing vfc%dn",instance);
  154. dev->regs = NULL;
  155. dev->regs = (volatile struct vfc_regs *)
  156. sbus_ioremap(&sdev->resource[0], 0,
  157.      sizeof(struct vfc_regs), vfcstr);
  158. dev->which_io = sdev->reg_addrs[0].which_io;
  159. dev->phys_regs = (struct vfc_regs *) sdev->reg_addrs[0].phys_addr;
  160. if (dev->regs == NULL)
  161. return -EIO;
  163. printk("vfc%d: registers mapped at phys_addr: 0x%lxn    virt_addr: 0x%lxn",
  164.        instance,(unsigned long)sdev->reg_addrs[0].phys_addr,(unsigned long)dev->regs);
  166. if (init_vfc_devstruct(dev, instance))
  167. return -EINVAL;
  168. if (init_vfc_hw(dev))
  169. return -EIO;
  171. sprintf (devname, "%d", instance);
  172. dev->de = devfs_register (devfs_handle, devname, DEVFS_FL_DEFAULT,
  173.   VFC_MAJOR, instance,
  174.   S_IFCHR | S_IRUSR | S_IWUSR,
  175.   &vfc_fops, NULL);
  176. return 0;
  177. }
  180. struct vfc_dev *vfc_get_dev_ptr(int instance) 
  181. {
  182. return vfc_dev_lst[instance];
  183. }
  185. static spinlock_t vfc_dev_lock = SPIN_LOCK_UNLOCKED;
  187. static int vfc_open(struct inode *inode, struct file *file) 
  188. {
  189. struct vfc_dev *dev;
  191. spin_lock(&vfc_dev_lock);
  192. dev = vfc_get_dev_ptr(MINOR(inode->i_rdev));
  193. if (dev == NULL) {
  194. spin_unlock(&vfc_dev_lock);
  195. return -ENODEV;
  196. }
  197. if (dev->busy) {
  198. spin_unlock(&vfc_dev_lock);
  199. return -EBUSY;
  200. }
  202. dev->busy = 1;
  203. spin_unlock(&vfc_dev_lock);
  205. vfc_lock_device(dev);
  207. vfc_csr_init(dev);
  208. vfc_pcf8584_init(dev);
  209. vfc_init_i2c_bus(dev);
  210. vfc_saa9051_init(dev);
  211. vfc_memptr_reset(dev);
  212. vfc_captstat_reset(dev);
  214. vfc_unlock_device(dev);
  215. return 0;
  216. }
  218. static int vfc_release(struct inode *inode,struct file *file) 
  219. {
  220. struct vfc_dev *dev;
  222. spin_lock(&vfc_dev_lock);
  223. dev = vfc_get_dev_ptr(MINOR(inode->i_rdev));
  224. if (!dev || !dev->busy) {
  225. spin_unlock(&vfc_dev_lock);
  226. return -EINVAL;
  227. }
  228. dev->busy = 0;
  229. spin_unlock(&vfc_dev_lock);
  230. return 0;
  231. }
  233. static int vfc_debug(struct vfc_dev *dev, int cmd, unsigned long arg) 
  234. {
  235. struct vfc_debug_inout inout;
  236. unsigned char *buffer;
  238. if (!capable(CAP_SYS_ADMIN))
  239. return -EPERM;
  241. switch(cmd) {
  242. case VFC_I2C_SEND:
  243. if(copy_from_user(&inout, (void *)arg, sizeof(inout)))
  244. return -EFAULT;
  246. buffer = kmalloc(inout.len*sizeof(char), GFP_KERNEL);
  247. if (buffer == NULL)
  248. return -ENOMEM;
  250. if(copy_from_user(buffer, inout.buffer, 
  251.   inout.len*sizeof(char))) {
  252. kfree(buffer);
  253. return -EFAULT;
  254. }
  257. vfc_lock_device(dev);
  258. inout.ret=
  259. vfc_i2c_sendbuf(dev,inout.addr & 0xff,
  260. inout.buffer,inout.len);
  262. if (copy_to_user((void *)arg,&inout,sizeof(inout))) {
  263. kfree(buffer);
  264. return -EFAULT;
  265. }
  266. vfc_unlock_device(dev);
  268. break;
  269. case VFC_I2C_RECV:
  270. if (copy_from_user(&inout, (void *)arg, sizeof(inout)))
  271. return -EFAULT;
  273. buffer = kmalloc(inout.len, GFP_KERNEL);
  274. if (buffer == NULL)
  275. return -ENOMEM;
  277. memset(buffer,0,inout.len*sizeof(char));
  278. vfc_lock_device(dev);
  279. inout.ret=
  280. vfc_i2c_recvbuf(dev,inout.addr & 0xff
  281. ,buffer,inout.len);
  282. vfc_unlock_device(dev);
  284. if (copy_to_user(inout.buffer, buffer, inout.len)) {
  285. kfree(buffer);
  286. return -EFAULT;
  287. }
  288. if (copy_to_user((void *)arg,&inout,sizeof(inout))) {
  289. kfree(buffer);
  290. return -EFAULT;
  291. }
  292. kfree(buffer);
  293. break;
  294. default:
  295. return -EINVAL;
  296. };
  298. return 0;
  299. }
  301. int vfc_capture_start(struct vfc_dev *dev) 
  302. {
  303. vfc_captstat_reset(dev);
  304. dev->control_reg = sbus_readl(&dev->regs->control);
  305. if((dev->control_reg & VFC_STATUS_CAPTURE)) {
  306. printk(KERN_ERR "vfc%d: vfc capture status not resetn",
  307.        dev->instance);
  308. return -EIO;
  309. }
  311. vfc_lock_device(dev);
  312. dev->control_reg &= ~VFC_CONTROL_CAPTURE;
  313. sbus_writel(dev->control_reg, &dev->regs->control);
  314. dev->control_reg |= VFC_CONTROL_CAPTURE;
  315. sbus_writel(dev->control_reg, &dev->regs->control);
  316. dev->control_reg &= ~VFC_CONTROL_CAPTURE;
  317. sbus_writel(dev->control_reg, &dev->regs->control);
  318. vfc_unlock_device(dev);
  320. return 0;
  321. }
  323. int vfc_capture_poll(struct vfc_dev *dev) 
  324. {
  325. int timeout = 1000;
  327. while (!timeout--) {
  328. if (dev->regs->control & VFC_STATUS_CAPTURE)
  329. break;
  330. vfc_i2c_delay_no_busy(dev, 100);
  331. }
  332. if(!timeout) {
  333. printk(KERN_WARNING "vfc%d: capture timed outn",
  334.        dev->instance);
  335. return -ETIMEDOUT;
  336. }
  337. return 0;
  338. }
  342. static int vfc_set_control_ioctl(struct inode *inode, struct file *file, 
  343.   struct vfc_dev *dev, unsigned long arg) 
  344. {
  345. int setcmd, ret = 0;
  347. if (copy_from_user(&setcmd,(void *)arg,sizeof(unsigned int)))
  348. return -EFAULT;
  350. VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCSCTRL) arg=0x%xn",
  351. dev->instance,setcmd));
  353. switch(setcmd) {
  354. case MEMPRST:
  355. vfc_lock_device(dev);
  356. vfc_memptr_reset(dev);
  357. vfc_unlock_device(dev);
  358. ret=0;
  359. break;
  360. case CAPTRCMD:
  361. vfc_capture_start(dev);
  362. vfc_capture_poll(dev);
  363. break;
  364. case DIAGMODE:
  365. if(capable(CAP_SYS_ADMIN)) {
  366. vfc_lock_device(dev);
  367. dev->control_reg |= VFC_CONTROL_DIAGMODE;
  368. sbus_writel(dev->control_reg, &dev->regs->control);
  369. vfc_unlock_device(dev);
  370. ret = 0;
  371. } else {
  372. ret = -EPERM; 
  373. }
  374. break;
  375. case NORMMODE:
  376. vfc_lock_device(dev);
  377. dev->control_reg &= ~VFC_CONTROL_DIAGMODE;
  378. sbus_writel(dev->control_reg, &dev->regs->control);
  379. vfc_unlock_device(dev);
  380. ret = 0;
  381. break;
  382. case CAPTRSTR:
  383. vfc_capture_start(dev);
  384. ret = 0;
  385. break;
  386. case CAPTRWAIT:
  387. vfc_capture_poll(dev);
  388. ret = 0;
  389. break;
  390. default:
  391. ret = -EINVAL;
  392. break;
  393. };
  395. return ret;
  396. }
  399. int vfc_port_change_ioctl(struct inode *inode, struct file *file, 
  400.   struct vfc_dev *dev, unsigned long arg) 
  401. {
  402. int ret = 0;
  403. int cmd;
  405. if(copy_from_user(&cmd, (void *)arg, sizeof(unsigned int))) {
  406. VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
  407. "vfc_port_change_ioctln",
  408. dev->instance));
  409. return -EFAULT;
  410. }
  412. VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCPORTCHG) arg=0x%xn",
  413. dev->instance, cmd));
  415. switch(cmd) {
  416. case 1:
  417. case 2:
  418. VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_START) = 0x72; 
  419. VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_STOP) = 0x52;
  420. VFC_SAA9051_SA(dev,VFC_SAA9051_HC_START) = 0x36;
  421. VFC_SAA9051_SA(dev,VFC_SAA9051_HC_STOP) = 0x18;
  422. VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) = VFC_SAA9051_BP2;
  423. VFC_SAA9051_SA(dev,VFC_SAA9051_C3) = VFC_SAA9051_CT | VFC_SAA9051_SS3;
  424. VFC_SAA9051_SA(dev,VFC_SAA9051_SECAM_DELAY) = 0x3e;
  425. break;
  426. case 3:
  427. VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_START) = 0x3a;
  428. VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_STOP) = 0x17;
  429. VFC_SAA9051_SA(dev,VFC_SAA9051_HC_START) = 0xfa;
  430. VFC_SAA9051_SA(dev,VFC_SAA9051_HC_STOP) = 0xde;
  431. VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) =
  432. VFC_SAA9051_BY | VFC_SAA9051_PF | VFC_SAA9051_BP2;
  433. VFC_SAA9051_SA(dev,VFC_SAA9051_C3) = VFC_SAA9051_YC;
  434. VFC_SAA9051_SA(dev,VFC_SAA9051_SECAM_DELAY) = 0;
  435. VFC_SAA9051_SA(dev,VFC_SAA9051_C2) &=
  436. ~(VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
  437. break;
  438. default:
  439. ret = -EINVAL;
  440. return ret;
  441. break;
  442. }
  444. switch(cmd) {
  445. case 1:
  446. VFC_SAA9051_SA(dev,VFC_SAA9051_C2) |=
  447. (VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
  448. break;
  449. case 2:
  450. VFC_SAA9051_SA(dev,VFC_SAA9051_C2) &=
  451. ~(VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
  452. VFC_SAA9051_SA(dev,VFC_SAA9051_C2) |= VFC_SAA9051_SS0; 
  453. break;
  454. case 3:
  455. break;
  456. default:
  457. ret = -EINVAL;
  458. return ret;
  459. break;
  460. }
  461. VFC_SAA9051_SA(dev,VFC_SAA9051_C3) &= ~(VFC_SAA9051_SS2);
  462. ret=vfc_update_saa9051(dev);
  463. udelay(500);
  464. VFC_SAA9051_SA(dev,VFC_SAA9051_C3) |= (VFC_SAA9051_SS2);
  465. ret=vfc_update_saa9051(dev);
  466. return ret;
  467. }
  469. int vfc_set_video_ioctl(struct inode *inode, struct file *file, 
  470. struct vfc_dev *dev, unsigned long arg) 
  471. {
  472. int ret = 0;
  473. int cmd;
  475. if(copy_from_user(&cmd, (void *)arg, sizeof(unsigned int))) {
  476. VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
  477. "vfc_set_video_ioctln",
  478. dev->instance));
  479. return ret;
  480. }
  482. VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCSVID) arg=0x%xn",
  483. dev->instance, cmd));
  484. switch(cmd) {
  485. case STD_NTSC:
  486. VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~VFC_SAA9051_ALT;
  487. VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_YPN | 
  488. VFC_SAA9051_CCFR0 | VFC_SAA9051_CCFR1 | VFC_SAA9051_FS;
  489. ret = vfc_update_saa9051(dev);
  490. break;
  491. case STD_PAL:
  492. VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~(VFC_SAA9051_YPN | 
  493. VFC_SAA9051_CCFR1 | 
  494. VFC_SAA9051_CCFR0 |
  495. VFC_SAA9051_FS);
  496. VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_ALT;
  497. ret = vfc_update_saa9051(dev);
  498. break;
  500. case COLOR_ON:
  501. VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_CO;
  502. VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) &=
  503. ~(VFC_SAA9051_BY | VFC_SAA9051_PF);
  504. ret = vfc_update_saa9051(dev);
  505. break;
  506. case MONO:
  507. VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~(VFC_SAA9051_CO);
  508. VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) |=
  509. (VFC_SAA9051_BY | VFC_SAA9051_PF);
  510. ret = vfc_update_saa9051(dev);
  511. break;
  512. default:
  513. ret = -EINVAL;
  514. break;
  515. };
  517. return ret;
  518. }
  520. int vfc_get_video_ioctl(struct inode *inode, struct file *file, 
  521. struct vfc_dev *dev, unsigned long arg) 
  522. {
  523. int ret = 0;
  524. unsigned int status = NO_LOCK;
  525. unsigned char buf[1];
  527. if(vfc_i2c_recvbuf(dev, VFC_SAA9051_ADDR, buf, 1)) {
  528. printk(KERN_ERR "vfc%d: Unable to get statusn",
  529.        dev->instance);
  530. return -EIO;
  531. }
  533. if(buf[0] & VFC_SAA9051_HLOCK) {
  534. status = NO_LOCK;
  535. } else if(buf[0] & VFC_SAA9051_FD) {
  536. if(buf[0] & VFC_SAA9051_CD)
  537. status = NTSC_COLOR;
  538. else
  539. status = NTSC_NOCOLOR;
  540. } else {
  541. if(buf[0] & VFC_SAA9051_CD)
  542. status = PAL_COLOR;
  543. else
  544. status = PAL_NOCOLOR;
  545. }
  546. VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCGVID) returning status 0x%x; "
  547. "buf[0]=%xn", dev->instance, status, buf[0]));
  549. if (copy_to_user((void *)arg,&status,sizeof(unsigned int))) {
  550. VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
  551. "vfc_get_video_ioctln",
  552. dev->instance));
  553. return ret;
  554. }
  555. return ret;
  556. }
  558. static int vfc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
  559.       unsigned long arg) 
  560. {
  561. int ret = 0;
  562. unsigned int tmp;
  563. struct vfc_dev *dev;
  565. dev = vfc_get_dev_ptr(MINOR(inode->i_rdev));
  566. if(dev == NULL)
  567. return -ENODEV;
  569. switch(cmd & 0x0000ffff) {
  570. case VFCGCTRL:
  571. #if 0
  572. VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCGCTRL)n", dev->instance));
  573. #endif
  574. tmp = sbus_readl(&dev->regs->control);
  575. if(copy_to_user((void *)arg, &tmp, sizeof(unsigned int))) {
  576. ret = -EFAULT;
  577. break;
  578. }
  579. ret = 0;
  580. break;
  581. case VFCSCTRL:
  582. ret = vfc_set_control_ioctl(inode, file, dev, arg);
  583. break;
  584. case VFCGVID:
  585. ret = vfc_get_video_ioctl(inode, file, dev, arg);
  586. break;
  587. case VFCSVID:
  588. ret = vfc_set_video_ioctl(inode, file, dev, arg);
  589. break;
  590. case VFCHUE:
  591. VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCHUE)n", dev->instance));
  592. if(copy_from_user(&tmp,(void *)arg,sizeof(unsigned int))) {
  593. VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer "
  594. "to IOCTL(VFCHUE)", dev->instance));
  595. ret = -EFAULT;
  596. } else {
  597. VFC_SAA9051_SA(dev,VFC_SAA9051_HUE) = tmp;
  598. vfc_update_saa9051(dev);
  599. ret = 0;
  600. }
  601. break;
  602. case VFCPORTCHG:
  603. ret = vfc_port_change_ioctl(inode, file, dev, arg);
  604. break;
  605. case VFCRDINFO:
  606. ret = -EINVAL;
  607. VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCRDINFO)n", dev->instance));
  608. break;
  609. default:
  610. ret = vfc_debug(vfc_get_dev_ptr(MINOR(inode->i_rdev)),
  611. cmd, arg);
  612. break;
  613. };
  615. return ret;
  616. }
  618. static int vfc_mmap(struct inode *inode, struct file *file, 
  619.     struct vm_area_struct *vma) 
  620. {
  621. unsigned int map_size, ret, map_offset;
  622. struct vfc_dev *dev;
  624. dev = vfc_get_dev_ptr(MINOR(inode->i_rdev));
  625. if(dev == NULL)
  626. return -ENODEV;
  628. map_size = vma->vm_end - vma->vm_start;
  629. if(map_size > sizeof(struct vfc_regs)) 
  630. map_size = sizeof(struct vfc_regs);
  632. vma->vm_flags |=
  633. (VM_SHM | VM_LOCKED | VM_IO | VM_MAYREAD | VM_MAYWRITE | VM_MAYSHARE);
  634. map_offset = (unsigned int) (long)dev->phys_regs;
  635. ret = io_remap_page_range(vma->vm_start, map_offset, map_size, 
  636.   vma->vm_page_prot, dev->which_io);
  638. if(ret)
  639. return -EAGAIN;
  641. return 0;
  642. }
  645. static struct file_operations vfc_fops = {
  646. owner: THIS_MODULE,
  647. llseek: no_llseek,
  648. ioctl: vfc_ioctl,
  649. mmap: vfc_mmap,
  650. open: vfc_open,
  651. release: vfc_release,
  652. };
  654. static int vfc_probe(void)
  655. {
  656. struct sbus_bus *sbus;
  657. struct sbus_dev *sdev = NULL;
  658. int ret;
  659. int instance = 0, cards = 0;
  661. for_all_sbusdev(sdev, sbus) {
  662. if (strcmp(sdev->prom_name, "vfc") == 0) {
  663. cards++;
  664. continue;
  665. }
  666. }
  668. if (!cards)
  669. return -ENODEV;
  671. vfc_dev_lst = (struct vfc_dev **)kmalloc(sizeof(struct vfc_dev *) *
  672.  (cards+1),
  673.  GFP_KERNEL);
  674. if (vfc_dev_lst == NULL)
  675. return -ENOMEM;
  676. memset(vfc_dev_lst, 0, sizeof(struct vfc_dev *) * (cards + 1));
  677. vfc_dev_lst[cards] = NULL;
  679. ret = devfs_register_chrdev(VFC_MAJOR, vfcstr, &vfc_fops);
  680. if(ret) {
  681. printk(KERN_ERR "Unable to get major number %dn", VFC_MAJOR);
  682. kfree(vfc_dev_lst);
  683. return -EIO;
  684. }
  685. devfs_handle = devfs_mk_dir (NULL, "vfc", NULL);
  687. instance = 0;
  688. for_all_sbusdev(sdev, sbus) {
  689. if (strcmp(sdev->prom_name, "vfc") == 0) {
  690. vfc_dev_lst[instance]=(struct vfc_dev *)
  691. kmalloc(sizeof(struct vfc_dev), GFP_KERNEL);
  692. if (vfc_dev_lst[instance] == NULL)
  693. return -ENOMEM;
  694. ret = init_vfc_device(sdev,
  695.       vfc_dev_lst[instance],
  696.       instance);
  697. if(ret) {
  698. printk(KERN_ERR "Unable to initialize"
  699.        " vfc%d devicen",
  700.        instance);
  701. } else {
  702. }
  704. instance++;
  705. continue;
  706. }
  707. }
  709. return 0;
  710. }
  712. #ifdef MODULE
  713. int init_module(void)
  714. #else 
  715. int vfc_init(void)
  716. #endif
  717. {
  718. return vfc_probe();
  719. }
  721. #ifdef MODULE
  722. static void deinit_vfc_device(struct vfc_dev *dev)
  723. {
  724. if(dev == NULL)
  725. return;
  726. devfs_unregister (dev->de);
  727. sbus_iounmap((unsigned long)dev->regs, sizeof(struct vfc_regs));
  728. kfree(dev);
  729. }
  731. void cleanup_module(void)
  732. {
  733. struct vfc_dev **devp;
  735. devfs_unregister_chrdev(VFC_MAJOR,vfcstr);
  737. for (devp = vfc_dev_lst; *devp; devp++)
  738. deinit_vfc_device(*devp);
  740. devfs_unregister (devfs_handle);
  741. kfree(vfc_dev_lst);
  742. return;
  743. }
  744. #endif