gio.c

  1 /*
  2  * arch/sh/boards/landisk/gio.c - driver for landisk
  3  *
  4  * This driver will also support the I-O DATA Device, Inc. LANDISK Board.
  5  * LANDISK and USL-5P Button, LED and GIO driver drive function.
  6  *
  7  *   Copylight (C) 2006 kogiidena
  8  *   Copylight (C) 2002 Atom Create Engineering Co., Ltd. *
  9  *
 10  * This file is subject to the terms and conditions of the GNU General Public
 11  * License.  See the file "COPYING" in the main directory of this archive
 12  * for more details.
 13  *
 14  */
 15 #include <linux/module.h>
 16 #include <linux/init.h>
 17 #include <linux/kdev_t.h>
 18 #include <linux/cdev.h>
 19 #include <linux/fs.h>
 20 #include <asm/io.h>
 21 #include <asm/uaccess.h>
 22 #include <mach-landisk/mach/gio.h>
 23 #include <mach-landisk/mach/iodata_landisk.h>
 24 
 25 #define DEVCOUNT                4
 26 #define GIO_MINOR               2       /* GIO minor no. */
 27 
 28 static dev_t dev;
 29 static struct cdev *cdev_p;
 30 static int openCnt;
 31 
 32 static int gio_open(struct inode *inode, struct file *filp)
 33 {
 34         int minor;
 35         int ret = -ENOENT;
 36 
 37         preempt_disable();
 38         minor = MINOR(inode->i_rdev);
 39         if (minor < DEVCOUNT) {
 40                 if (openCnt > 0) {
 41                         ret = -EALREADY;
 42                 } else {
 43                         openCnt++;
 44                         ret = 0;
 45                 }
 46         }
 47         preempt_enable();
 48         return ret;
 49 }
 50 
 51 static int gio_close(struct inode *inode, struct file *filp)
 52 {
 53         int minor;
 54 
 55         minor = MINOR(inode->i_rdev);
 56         if (minor < DEVCOUNT) {
 57                 openCnt--;
 58         }
 59         return 0;
 60 }
 61 
 62 static long gio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 63 {
 64         unsigned int data;
 65         static unsigned int addr = 0;
 66 
 67         if (cmd & 0x01) {       /* write */
 68                 if (copy_from_user(&data, (int *)arg, sizeof(int))) {
 69                         return -EFAULT;
 70                 }
 71         }
 72 
 73         switch (cmd) {
 74         case GIODRV_IOCSGIOSETADDR:     /* address set */
 75                 addr = data;
 76                 break;
 77 
 78         case GIODRV_IOCSGIODATA1:       /* write byte */
 79                 __raw_writeb((unsigned char)(0x0ff & data), addr);
 80                 break;
 81 
 82         case GIODRV_IOCSGIODATA2:       /* write word */
 83                 if (addr & 0x01) {
 84                         return -EFAULT;
 85                 }
 86                 __raw_writew((unsigned short int)(0x0ffff & data), addr);
 87                 break;
 88 
 89         case GIODRV_IOCSGIODATA4:       /* write long */
 90                 if (addr & 0x03) {
 91                         return -EFAULT;
 92                 }
 93                 __raw_writel(data, addr);
 94                 break;
 95 
 96         case GIODRV_IOCGGIODATA1:       /* read byte */
 97                 data = __raw_readb(addr);
 98                 break;
 99 
100         case GIODRV_IOCGGIODATA2:       /* read word */
101                 if (addr & 0x01) {
102                         return -EFAULT;
103                 }
104                 data = __raw_readw(addr);
105                 break;
106 
107         case GIODRV_IOCGGIODATA4:       /* read long */
108                 if (addr & 0x03) {
109                         return -EFAULT;
110                 }
111                 data = __raw_readl(addr);
112                 break;
113         default:
114                 return -EFAULT;
115                 break;
116         }
117 
118         if ((cmd & 0x01) == 0) {        /* read */
119                 if (copy_to_user((int *)arg, &data, sizeof(int))) {
120                         return -EFAULT;
121                 }
122         }
123         return 0;
124 }
125 
126 static const struct file_operations gio_fops = {
127         .owner = THIS_MODULE,
128         .open = gio_open,       /* open */
129         .release = gio_close,   /* release */
130         .unlocked_ioctl = gio_ioctl,
131 };
132 
133 static int __init gio_init(void)
134 {
135         int error;
136 
137         printk(KERN_INFO "gio: driver initialized\n");
138 
139         openCnt = 0;
140 
141         if ((error = alloc_chrdev_region(&dev, 0, DEVCOUNT, "gio")) < 0) {
142                 printk(KERN_ERR
143                        "gio: Couldn't alloc_chrdev_region, error=%d\n",
144                        error);
145                 return 1;
146         }
147 
148         cdev_p = cdev_alloc();
149         cdev_p->ops = &gio_fops;
150         error = cdev_add(cdev_p, dev, DEVCOUNT);
151         if (error) {
152                 printk(KERN_ERR
153                        "gio: Couldn't cdev_add, error=%d\n", error);
154                 return 1;
155         }
156 
157         return 0;
158 }
159 
160 static void __exit gio_exit(void)
161 {
162         cdev_del(cdev_p);
163         unregister_chrdev_region(dev, DEVCOUNT);
164 }
165 
166 module_init(gio_init);
167 module_exit(gio_exit);
168 
169 MODULE_LICENSE("GPL");
170
This page was automatically generated by LXR 0.3.1. • Linux is a registered trademark of Linus Torvalds
Linux Cross Reference

Free Electrons

Embedded Linux Experts

Linux/arch/sh/boards/mach-landisk/gio.c
