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 #include <linux/nsc_gpio.h> 24 25 #define NAME "scx200_gpio" 26 #define DEVNAME NAME 27 28 static struct platform_device *pdev; 29 30 MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>"); 31 MODULE_DESCRIPTION("NatSemi SCx200 GPIO Pin Driver"); 32 MODULE_LICENSE("GPL"); 33 34 static int major = 0; /* default to dynamic major */ 35 module_param(major, int, 0); 36 MODULE_PARM_DESC(major, "Major device number"); 37 38 struct nsc_gpio_ops scx200_access = { 39 .owner = THIS_MODULE, 40 .gpio_config = scx200_gpio_configure, 41 .gpio_dump = nsc_gpio_dump, 42 .gpio_get = scx200_gpio_get, 43 .gpio_set = scx200_gpio_set, 44 .gpio_set_high = scx200_gpio_set_high, 45 .gpio_set_low = scx200_gpio_set_low, 46 .gpio_change = scx200_gpio_change, 47 .gpio_current = scx200_gpio_current 48 }; 49 50 static int scx200_gpio_open(struct inode *inode, struct file *file) 51 { 52 unsigned m = iminor(inode); 53 file->private_data = &scx200_access; 54 55 if (m > 63) 56 return -EINVAL; 57 return nonseekable_open(inode, file); 58 } 59 60 static int scx200_gpio_release(struct inode *inode, struct file *file) 61 { 62 return 0; 63 } 64 65 66 static const struct file_operations scx200_gpio_fops = { 67 .owner = THIS_MODULE, 68 .write = nsc_gpio_write, 69 .read = nsc_gpio_read, 70 .open = scx200_gpio_open, 71 .release = scx200_gpio_release, 72 }; 73 74 struct cdev *scx200_devices; 75 static int num_pins = 32; 76 77 static int __init scx200_gpio_init(void) 78 { 79 int rc, i; 80 dev_t dev = MKDEV(major, 0); 81 82 if (!scx200_gpio_present()) { 83 printk(KERN_ERR NAME ": no SCx200 gpio present\n"); 84 return -ENODEV; 85 } 86 87 /* support dev_dbg() with pdev->dev */ 88 pdev = platform_device_alloc(DEVNAME, 0); 89 if (!pdev) 90 return -ENOMEM; 91 92 rc = platform_device_add(pdev); 93 if (rc) 94 goto undo_malloc; 95 96 /* nsc_gpio uses dev_dbg(), so needs this */ 97 scx200_access.dev = &pdev->dev; 98 99 if (major) 100 rc = register_chrdev_region(dev, num_pins, "scx200_gpio"); 101 else { 102 rc = alloc_chrdev_region(&dev, 0, num_pins, "scx200_gpio"); 103 major = MAJOR(dev); 104 } 105 if (rc < 0) { 106 dev_err(&pdev->dev, "SCx200 chrdev_region err: %d\n", rc); 107 goto undo_platform_device_add; 108 } 109 scx200_devices = kzalloc(num_pins * sizeof(struct cdev), GFP_KERNEL); 110 if (!scx200_devices) { 111 rc = -ENOMEM; 112 goto undo_chrdev_region; 113 } 114 for (i = 0; i < num_pins; i++) { 115 struct cdev *cdev = &scx200_devices[i]; 116 cdev_init(cdev, &scx200_gpio_fops); 117 cdev->owner = THIS_MODULE; 118 rc = cdev_add(cdev, MKDEV(major, i), 1); 119 /* tolerate 'minor' errors */ 120 if (rc) 121 dev_err(&pdev->dev, "Error %d on minor %d", rc, i); 122 } 123 124 return 0; /* succeed */ 125 126 undo_chrdev_region: 127 unregister_chrdev_region(dev, num_pins); 128 undo_platform_device_add: 129 platform_device_del(pdev); 130 undo_malloc: 131 platform_device_put(pdev); 132 133 return rc; 134 } 135 136 static void __exit scx200_gpio_cleanup(void) 137 { 138 kfree(scx200_devices); 139 unregister_chrdev_region(MKDEV(major, 0), num_pins); 140 platform_device_unregister(pdev); 141 /* kfree(pdev); */ 142 } 143 144 module_init(scx200_gpio_init); 145 module_exit(scx200_gpio_cleanup); 146