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