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
  45         for (i = 0; i < len; ++i) {
  46                 char c;
  47                 if (get_user(c, data + i))
  48                         return -EFAULT;
  49                 switch (c) {
  50                 case '0':
  51                         scx200_gpio_set(m, 0);
  52                         break;
  53                 case '1':
  54                         scx200_gpio_set(m, 1);
  55                         break;
  56                 case 'O':
  57                         printk(KERN_INFO NAME ": GPIO%d output enabled\n", m);
  58                         scx200_gpio_configure(m, ~1, 1);
  59                         break;
  60                 case 'o':
  61                         printk(KERN_INFO NAME ": GPIO%d output disabled\n", m);
  62                         scx200_gpio_configure(m, ~1, 0);
  63                         break;
  64                 case 'T':
  65                         printk(KERN_INFO NAME ": GPIO%d output is push pull\n", m);
  66                         scx200_gpio_configure(m, ~2, 2);
  67                         break;
  68                 case 't':
  69                         printk(KERN_INFO NAME ": GPIO%d output is open drain\n", m);
  70                         scx200_gpio_configure(m, ~2, 0);
  71                         break;
  72                 case 'P':
  73                         printk(KERN_INFO NAME ": GPIO%d pull up enabled\n", m);
  74                         scx200_gpio_configure(m, ~4, 4);
  75                         break;
  76                 case 'p':
  77                         printk(KERN_INFO NAME ": GPIO%d pull up disabled\n", m);
  78                         scx200_gpio_configure(m, ~4, 0);
  79                         break;
  80                 }
  81         }
  82
  83         return len;
  84 }
  85
  86 static ssize_t scx200_gpio_read(struct file *file, char __user *buf,
  87                                 size_t len, loff_t *ppos)
  88 {
  89         unsigned m = iminor(file->f_dentry->d_inode);
  90         int value;
  91
  92         value = scx200_gpio_get(m);
  93         if (put_user(value ? '1' : '0', buf))
  94                 return -EFAULT;
  95
  96         return 1;
  97 }
  98
  99 static int scx200_gpio_open(struct inode *inode, struct file *file)
 100 {
 101         unsigned m = iminor(inode);
 102         if (m > 63)
 103                 return -EINVAL;
 104         return nonseekable_open(inode, file);
 105 }
 106
 107 static int scx200_gpio_release(struct inode *inode, struct file *file)
 108 {
 109         return 0;
 110 }
 111
 112
 113 static struct file_operations scx200_gpio_fops = {
 114         .owner   = THIS_MODULE,
 115         .write   = scx200_gpio_write,
 116         .read    = scx200_gpio_read,
 117         .open    = scx200_gpio_open,
 118         .release = scx200_gpio_release,
 119 };
 120
 121 struct cdev *scx200_devices;
 122 static int num_pins = 32;
 123
 124 static int __init scx200_gpio_init(void)
 125 {
 126         int rc, i;
 127         dev_t dev = MKDEV(major, 0);
 128
 129         if (!scx200_gpio_present()) {
 130                 printk(KERN_ERR NAME ": no SCx200 gpio present\n");
 131                 return -ENODEV;
 132         }
 133
 134         /* support dev_dbg() with pdev->dev */
 135         pdev = platform_device_alloc(DEVNAME, 0);
 136         if (!pdev)
 137                 return -ENOMEM;
 138
 139         rc = platform_device_add(pdev);
 140         if (rc)
 141                 goto undo_malloc;
 142
 143         if (major)
 144                 rc = register_chrdev_region(dev, num_pins, "scx200_gpio");
 145         else {
 146                 rc = alloc_chrdev_region(&dev, 0, num_pins, "scx200_gpio");
 147                 major = MAJOR(dev);
 148         }
 149         if (rc < 0) {
 150                 dev_err(&pdev->dev, "SCx200 chrdev_region err: %d\n", rc);
 151                 goto undo_platform_device_add;
 152         }
 153         scx200_devices = kzalloc(num_pins * sizeof(struct cdev), GFP_KERNEL);
 154         if (!scx200_devices) {
 155                 rc = -ENOMEM;
 156                 goto undo_chrdev_region;
 157         }
 158         for (i = 0; i < num_pins; i++) {
 159                 struct cdev *cdev = &scx200_devices[i];
 160                 cdev_init(cdev, &scx200_gpio_fops);
 161                 cdev->owner = THIS_MODULE;
 162                 rc = cdev_add(cdev, MKDEV(major, i), 1);
 163                 /* tolerate 'minor' errors */
 164                 if (rc)
 165                         dev_err(&pdev->dev, "Error %d on minor %d", rc, i);
 166         }
 167
 168         return 0; /* succeed */
 169
 170 undo_chrdev_region:
 171         unregister_chrdev_region(dev, num_pins);
 172 undo_platform_device_add:
 173         platform_device_put(pdev);
 174 undo_malloc:
 175         kfree(pdev);
 176         return rc;
 177 }
 178
 179 static void __exit scx200_gpio_cleanup(void)
 180 {
 181         kfree(scx200_devices);
 182         unregister_chrdev_region(MKDEV(major, 0), num_pins);
 183         platform_device_put(pdev);
 184         platform_device_unregister(pdev);
 185         /* kfree(pdev); */
 186 }
 187
 188 module_init(scx200_gpio_init);
 189 module_exit(scx200_gpio_cleanup);