This source file includes following definitions.
- scr24x_delete
- scr24x_wait_ready
- scr24x_open
- scr24x_release
- read_chunk
- scr24x_read
- scr24x_write
- scr24x_config_check
- scr24x_probe
- scr24x_remove
- scr24x_init
- scr24x_exit
1
2
3
4
5
6
7
8
9
10
11 #include <linux/device.h>
12 #include <linux/module.h>
13 #include <linux/delay.h>
14 #include <linux/cdev.h>
15 #include <linux/slab.h>
16 #include <linux/fs.h>
17 #include <linux/io.h>
18 #include <linux/uaccess.h>
19
20 #include <pcmcia/cistpl.h>
21 #include <pcmcia/ds.h>
22
23 #define CCID_HEADER_SIZE 10
24 #define CCID_LENGTH_OFFSET 1
25 #define CCID_MAX_LEN 271
26
27 #define SCR24X_DATA(n) (1 + n)
28 #define SCR24X_CMD_STATUS 7
29 #define CMD_START 0x40
30 #define CMD_WRITE_BYTE 0x41
31 #define CMD_READ_BYTE 0x42
32 #define STATUS_BUSY 0x80
33
34 struct scr24x_dev {
35 struct device *dev;
36 struct cdev c_dev;
37 unsigned char buf[CCID_MAX_LEN];
38 int devno;
39 struct mutex lock;
40 struct kref refcnt;
41 u8 __iomem *regs;
42 };
43
44 #define SCR24X_DEVS 8
45 static DECLARE_BITMAP(scr24x_minors, SCR24X_DEVS);
46
47 static struct class *scr24x_class;
48 static dev_t scr24x_devt;
49
50 static void scr24x_delete(struct kref *kref)
51 {
52 struct scr24x_dev *dev = container_of(kref, struct scr24x_dev,
53 refcnt);
54
55 kfree(dev);
56 }
57
58 static int scr24x_wait_ready(struct scr24x_dev *dev)
59 {
60 u_char status;
61 int timeout = 100;
62
63 do {
64 status = ioread8(dev->regs + SCR24X_CMD_STATUS);
65 if (!(status & STATUS_BUSY))
66 return 0;
67
68 msleep(20);
69 } while (--timeout);
70
71 return -EIO;
72 }
73
74 static int scr24x_open(struct inode *inode, struct file *filp)
75 {
76 struct scr24x_dev *dev = container_of(inode->i_cdev,
77 struct scr24x_dev, c_dev);
78
79 kref_get(&dev->refcnt);
80 filp->private_data = dev;
81
82 return stream_open(inode, filp);
83 }
84
85 static int scr24x_release(struct inode *inode, struct file *filp)
86 {
87 struct scr24x_dev *dev = filp->private_data;
88
89
90
91
92
93
94
95 kref_put(&dev->refcnt, scr24x_delete);
96 return 0;
97 }
98
99 static int read_chunk(struct scr24x_dev *dev, size_t offset, size_t limit)
100 {
101 size_t i, y;
102 int ret;
103
104 for (i = offset; i < limit; i += 5) {
105 iowrite8(CMD_READ_BYTE, dev->regs + SCR24X_CMD_STATUS);
106 ret = scr24x_wait_ready(dev);
107 if (ret < 0)
108 return ret;
109
110 for (y = 0; y < 5 && i + y < limit; y++)
111 dev->buf[i + y] = ioread8(dev->regs + SCR24X_DATA(y));
112 }
113
114 return 0;
115 }
116
117 static ssize_t scr24x_read(struct file *filp, char __user *buf, size_t count,
118 loff_t *ppos)
119 {
120 struct scr24x_dev *dev = filp->private_data;
121 int ret;
122 int len;
123
124 if (count < CCID_HEADER_SIZE)
125 return -EINVAL;
126
127 if (mutex_lock_interruptible(&dev->lock))
128 return -ERESTARTSYS;
129
130 if (!dev->dev) {
131 ret = -ENODEV;
132 goto out;
133 }
134
135 ret = scr24x_wait_ready(dev);
136 if (ret < 0)
137 goto out;
138 len = CCID_HEADER_SIZE;
139 ret = read_chunk(dev, 0, len);
140 if (ret < 0)
141 goto out;
142
143 len += le32_to_cpu(*(__le32 *)(&dev->buf[CCID_LENGTH_OFFSET]));
144 if (len > sizeof(dev->buf)) {
145 ret = -EIO;
146 goto out;
147 }
148 ret = read_chunk(dev, CCID_HEADER_SIZE, len);
149 if (ret < 0)
150 goto out;
151
152 if (len < count)
153 count = len;
154
155 if (copy_to_user(buf, dev->buf, count)) {
156 ret = -EFAULT;
157 goto out;
158 }
159
160 ret = count;
161 out:
162 mutex_unlock(&dev->lock);
163 return ret;
164 }
165
166 static ssize_t scr24x_write(struct file *filp, const char __user *buf,
167 size_t count, loff_t *ppos)
168 {
169 struct scr24x_dev *dev = filp->private_data;
170 size_t i, y;
171 int ret;
172
173 if (mutex_lock_interruptible(&dev->lock))
174 return -ERESTARTSYS;
175
176 if (!dev->dev) {
177 ret = -ENODEV;
178 goto out;
179 }
180
181 if (count > sizeof(dev->buf)) {
182 ret = -EINVAL;
183 goto out;
184 }
185
186 if (copy_from_user(dev->buf, buf, count)) {
187 ret = -EFAULT;
188 goto out;
189 }
190
191 ret = scr24x_wait_ready(dev);
192 if (ret < 0)
193 goto out;
194
195 iowrite8(CMD_START, dev->regs + SCR24X_CMD_STATUS);
196 ret = scr24x_wait_ready(dev);
197 if (ret < 0)
198 goto out;
199
200 for (i = 0; i < count; i += 5) {
201 for (y = 0; y < 5 && i + y < count; y++)
202 iowrite8(dev->buf[i + y], dev->regs + SCR24X_DATA(y));
203
204 iowrite8(CMD_WRITE_BYTE, dev->regs + SCR24X_CMD_STATUS);
205 ret = scr24x_wait_ready(dev);
206 if (ret < 0)
207 goto out;
208 }
209
210 ret = count;
211 out:
212 mutex_unlock(&dev->lock);
213 return ret;
214 }
215
216 static const struct file_operations scr24x_fops = {
217 .owner = THIS_MODULE,
218 .read = scr24x_read,
219 .write = scr24x_write,
220 .open = scr24x_open,
221 .release = scr24x_release,
222 .llseek = no_llseek,
223 };
224
225 static int scr24x_config_check(struct pcmcia_device *link, void *priv_data)
226 {
227 if (resource_size(link->resource[PCMCIA_IOPORT_0]) != 0x11)
228 return -ENODEV;
229 return pcmcia_request_io(link);
230 }
231
232 static int scr24x_probe(struct pcmcia_device *link)
233 {
234 struct scr24x_dev *dev;
235 int ret;
236
237 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
238 if (!dev)
239 return -ENOMEM;
240
241 dev->devno = find_first_zero_bit(scr24x_minors, SCR24X_DEVS);
242 if (dev->devno >= SCR24X_DEVS) {
243 ret = -EBUSY;
244 goto err;
245 }
246
247 mutex_init(&dev->lock);
248 kref_init(&dev->refcnt);
249
250 link->priv = dev;
251 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
252
253 ret = pcmcia_loop_config(link, scr24x_config_check, NULL);
254 if (ret < 0)
255 goto err;
256
257 dev->dev = &link->dev;
258 dev->regs = devm_ioport_map(&link->dev,
259 link->resource[PCMCIA_IOPORT_0]->start,
260 resource_size(link->resource[PCMCIA_IOPORT_0]));
261 if (!dev->regs) {
262 ret = -EIO;
263 goto err;
264 }
265
266 cdev_init(&dev->c_dev, &scr24x_fops);
267 dev->c_dev.owner = THIS_MODULE;
268 dev->c_dev.ops = &scr24x_fops;
269 ret = cdev_add(&dev->c_dev, MKDEV(MAJOR(scr24x_devt), dev->devno), 1);
270 if (ret < 0)
271 goto err;
272
273 ret = pcmcia_enable_device(link);
274 if (ret < 0) {
275 pcmcia_disable_device(link);
276 goto err;
277 }
278
279 device_create(scr24x_class, NULL, MKDEV(MAJOR(scr24x_devt), dev->devno),
280 NULL, "scr24x%d", dev->devno);
281
282 dev_info(&link->dev, "SCR24x Chip Card Interface\n");
283 return 0;
284
285 err:
286 if (dev->devno < SCR24X_DEVS)
287 clear_bit(dev->devno, scr24x_minors);
288 kfree (dev);
289 return ret;
290 }
291
292 static void scr24x_remove(struct pcmcia_device *link)
293 {
294 struct scr24x_dev *dev = (struct scr24x_dev *)link->priv;
295
296 device_destroy(scr24x_class, MKDEV(MAJOR(scr24x_devt), dev->devno));
297 mutex_lock(&dev->lock);
298 pcmcia_disable_device(link);
299 cdev_del(&dev->c_dev);
300 clear_bit(dev->devno, scr24x_minors);
301 dev->dev = NULL;
302 mutex_unlock(&dev->lock);
303
304 kref_put(&dev->refcnt, scr24x_delete);
305 }
306
307 static const struct pcmcia_device_id scr24x_ids[] = {
308 PCMCIA_DEVICE_PROD_ID12("HP", "PC Card Smart Card Reader",
309 0x53cb94f9, 0xbfdf89a5),
310 PCMCIA_DEVICE_PROD_ID1("SCR241 PCMCIA", 0x6271efa3),
311 PCMCIA_DEVICE_PROD_ID1("SCR243 PCMCIA", 0x2054e8de),
312 PCMCIA_DEVICE_PROD_ID1("SCR24x PCMCIA", 0x54a33665),
313 PCMCIA_DEVICE_NULL
314 };
315 MODULE_DEVICE_TABLE(pcmcia, scr24x_ids);
316
317 static struct pcmcia_driver scr24x_driver = {
318 .owner = THIS_MODULE,
319 .name = "scr24x_cs",
320 .probe = scr24x_probe,
321 .remove = scr24x_remove,
322 .id_table = scr24x_ids,
323 };
324
325 static int __init scr24x_init(void)
326 {
327 int ret;
328
329 scr24x_class = class_create(THIS_MODULE, "scr24x");
330 if (IS_ERR(scr24x_class))
331 return PTR_ERR(scr24x_class);
332
333 ret = alloc_chrdev_region(&scr24x_devt, 0, SCR24X_DEVS, "scr24x");
334 if (ret < 0) {
335 class_destroy(scr24x_class);
336 return ret;
337 }
338
339 ret = pcmcia_register_driver(&scr24x_driver);
340 if (ret < 0) {
341 unregister_chrdev_region(scr24x_devt, SCR24X_DEVS);
342 class_destroy(scr24x_class);
343 }
344
345 return ret;
346 }
347
348 static void __exit scr24x_exit(void)
349 {
350 pcmcia_unregister_driver(&scr24x_driver);
351 unregister_chrdev_region(scr24x_devt, SCR24X_DEVS);
352 class_destroy(scr24x_class);
353 }
354
355 module_init(scr24x_init);
356 module_exit(scr24x_exit);
357
358 MODULE_AUTHOR("Lubomir Rintel");
359 MODULE_DESCRIPTION("SCR24x PCMCIA Smart Card Reader Driver");
360 MODULE_LICENSE("GPL");