SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/char/scx200_gpio.c

   1 /* linux/drivers/char/scx200_gpio.c
   2
   3    National Semiconductor SCx200 GPIO driver.  Allows a user space
   4    process to play with the GPIO pins.
   5
   6    Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com> */
   7
   8 #include <linux/config.h>
   9 #include <linux/device.h>
  10 #include <linux/fs.h>
  11 #include <linux/module.h>
  12 #include <linux/errno.h>
  13 #include <linux/kernel.h>
  14 #include <linux/init.h>
  15 #include <linux/platform_device.h>
  16 #include <asm/uaccess.h>
  17 #include <asm/io.h>
  18
  19 #include <linux/types.h>
  20 #include <linux/cdev.h>
  21
  22 #include <linux/scx200_gpio.h>
  23
  24 #define NAME "scx200_gpio"
  25 #define DEVNAME NAME
  26
  27 static struct platform_device *pdev;
  28
  29 MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>");
  30 MODULE_DESCRIPTION("NatSemi SCx200 GPIO Pin Driver");
  31 MODULE_LICENSE("GPL");
  32
  33 static int major = 0;           /* default to dynamic major */
  34 module_param(major, int, 0);
  35 MODULE_PARM_DESC(major, "Major device number");
  36
  37 extern void scx200_gpio_dump(unsigned index);
  38
  39 static ssize_t scx200_gpio_write(struct file *file, const char __user *data,
  40                                  size_t len, loff_t *ppos)
  41 {
  42         unsigned m = iminor(file->f_dentry->d_inode);
  43         size_t i;
  44         int err = 0;
  45
  46         for (i = 0; i < len; ++i) {
  47                 char c;
  48                 if (get_user(c, data + i))
  49                         return -EFAULT;
  50                 switch (c) {
  51                 case '0':
  52                         scx200_gpio_set(m, 0);
  53                         break;
  54                 case '1':
  55                         scx200_gpio_set(m, 1);
  56                         break;
  57                 case 'O':
  58                         printk(KERN_INFO NAME ": GPIO%d output enabled\n", m);
  59                         scx200_gpio_configure(m, ~1, 1);
  60                         break;
  61                 case 'o':
  62                         printk(KERN_INFO NAME ": GPIO%d output disabled\n", m);
  63                         scx200_gpio_configure(m, ~1, 0);
  64                         break;
  65                 case 'T':
  66                         printk(KERN_INFO NAME ": GPIO%d output is push pull\n", m);
  67                         scx200_gpio_configure(m, ~2, 2);
  68                         break;
  69                 case 't':
  70                         printk(KERN_INFO NAME ": GPIO%d output is open drain\n", m);
  71                         scx200_gpio_configure(m, ~2, 0);
  72                         break;
  73                 case 'P':
  74                         printk(KERN_INFO NAME ": GPIO%d pull up enabled\n", m);
  75                         scx200_gpio_configure(m, ~4, 4);
  76                         break;
  77                 case 'p':
  78                         printk(KERN_INFO NAME ": GPIO%d pull up disabled\n", m);
  79                         scx200_gpio_configure(m, ~4, 0);
  80                         break;
  81
  82                 case 'v':
  83                         /* View Current pin settings */
  84                         scx200_gpio_dump(m);
  85                         break;
  86                 case '\n':
  87                         /* end of settings string, do nothing */
  88                         break;
  89                 default:
  90                         printk(KERN_ERR NAME
  91                                ": GPIO-%2d bad setting: chr<0x%2x>\n", m,
  92                                (int)c);
  93                         err++;
  94                 }
  95         }
  96         if (err)
  97                 return -EINVAL; /* full string handled, report error */
  98
  99         return len;
 100 }
 101
 102 static ssize_t scx200_gpio_read(struct file *file, char __user *buf,
 103                                 size_t len, loff_t *ppos)
 104 {
 105         unsigned m = iminor(file->f_dentry->d_inode);
 106         int value;
 107
 108         value = scx200_gpio_get(m);
 109         if (put_user(value ? '1' : '0', buf))
 110                 return -EFAULT;
 111
 112         return 1;
 113 }
 114
 115 static int scx200_gpio_open(struct inode *inode, struct file *file)
 116 {
 117         unsigned m = iminor(inode);
 118         if (m > 63)
 119                 return -EINVAL;
 120         return nonseekable_open(inode, file);
 121 }
 122
 123 static int scx200_gpio_release(struct inode *inode, struct file *file)
 124 {
 125         return 0;
 126 }
 127
 128
 129 static struct file_operations scx200_gpio_fops = {
 130         .owner   = THIS_MODULE,
 131         .write   = scx200_gpio_write,
 132         .read    = scx200_gpio_read,
 133         .open    = scx200_gpio_open,
 134         .release = scx200_gpio_release,
 135 };
 136
 137 struct cdev *scx200_devices;
 138 static int num_pins = 32;
 139
 140 static int __init scx200_gpio_init(void)
 141 {
 142         int rc, i;
 143         dev_t dev = MKDEV(major, 0);
 144
 145         if (!scx200_gpio_present()) {
 146                 printk(KERN_ERR NAME ": no SCx200 gpio present\n");
 147                 return -ENODEV;
 148         }
 149
 150         /* support dev_dbg() with pdev->dev */
 151         pdev = platform_device_alloc(DEVNAME, 0);
 152         if (!pdev)
 153                 return -ENOMEM;
 154
 155         rc = platform_device_add(pdev);
 156         if (rc)
 157                 goto undo_malloc;
 158
 159         if (major)
 160                 rc = register_chrdev_region(dev, num_pins, "scx200_gpio");
 161         else {
 162                 rc = alloc_chrdev_region(&dev, 0, num_pins, "scx200_gpio");
 163                 major = MAJOR(dev);
 164         }
 165         if (rc < 0) {
 166                 dev_err(&pdev->dev, "SCx200 chrdev_region err: %d\n", rc);
 167                 goto undo_platform_device_add;
 168         }
 169         scx200_devices = kzalloc(num_pins * sizeof(struct cdev), GFP_KERNEL);
 170         if (!scx200_devices) {
 171                 rc = -ENOMEM;
 172                 goto undo_chrdev_region;
 173         }
 174         for (i = 0; i < num_pins; i++) {
 175                 struct cdev *cdev = &scx200_devices[i];
 176                 cdev_init(cdev, &scx200_gpio_fops);
 177                 cdev->owner = THIS_MODULE;
 178                 rc = cdev_add(cdev, MKDEV(major, i), 1);
 179                 /* tolerate 'minor' errors */
 180                 if (rc)
 181                         dev_err(&pdev->dev, "Error %d on minor %d", rc, i);
 182         }
 183
 184         return 0; /* succeed */
 185
 186 undo_chrdev_region:
 187         unregister_chrdev_region(dev, num_pins);
 188 undo_platform_device_add:
 189         platform_device_put(pdev);
 190 undo_malloc:
 191         kfree(pdev);
 192         return rc;
 193 }
 194
 195 static void __exit scx200_gpio_cleanup(void)
 196 {
 197         kfree(scx200_devices);
 198         unregister_chrdev_region(MKDEV(major, 0), num_pins);
 199         platform_device_put(pdev);
 200         platform_device_unregister(pdev);
 201         /* kfree(pdev); */
 202 }
 203
 204 module_init(scx200_gpio_init);
 205 module_exit(scx200_gpio_cleanup);