xref: /linux/drivers/char/scx200_gpio.c (revision 14b42963f64b98ab61fa9723c03d71aa5ef4f862)
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