[linux-2.6-block.git] / drivers / char / pcmcia / scr24x_cs.c

/*
 * SCR24x PCMCIA Smart Card Reader Driver
 *
 * Copyright (C) 2005-2006 TL Sudheendran
 * Copyright (C) 2016 Lubomir Rintel
 *
 * Derived from "scr24x_v4.2.6_Release.tar.gz" driver by TL Sudheendran.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file COPYING.  If not, write to
 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/device.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/uaccess.h>

#include <pcmcia/cistpl.h>
#include <pcmcia/ds.h>

#define CCID_HEADER_SIZE	10
#define CCID_LENGTH_OFFSET	1
#define CCID_MAX_LEN		271

#define SCR24X_DATA(n)		(1 + n)
#define SCR24X_CMD_STATUS	7
#define CMD_START		0x40
#define CMD_WRITE_BYTE		0x41
#define CMD_READ_BYTE		0x42
#define STATUS_BUSY		0x80

struct scr24x_dev {
	struct device *dev;
	struct cdev c_dev;
	unsigned char buf[CCID_MAX_LEN];
	int devno;
	struct mutex lock;
	struct kref refcnt;
	u8 __iomem *regs;
};

#define SCR24X_DEVS 8
static DECLARE_BITMAP(scr24x_minors, SCR24X_DEVS);

static struct class *scr24x_class;
static dev_t scr24x_devt;

static void scr24x_delete(struct kref *kref)
{
	struct scr24x_dev *dev = container_of(kref, struct scr24x_dev,
								refcnt);

	kfree(dev);
}

static int scr24x_wait_ready(struct scr24x_dev *dev)
{
	u_char status;
	int timeout = 100;

	do {
		status = ioread8(dev->regs + SCR24X_CMD_STATUS);
		if (!(status & STATUS_BUSY))
			return 0;

		msleep(20);
	} while (--timeout);

	return -EIO;
}

static int scr24x_open(struct inode *inode, struct file *filp)
{
	struct scr24x_dev *dev = container_of(inode->i_cdev,
				struct scr24x_dev, c_dev);

	kref_get(&dev->refcnt);
	filp->private_data = dev;

	return nonseekable_open(inode, filp);
}

static int scr24x_release(struct inode *inode, struct file *filp)
{
	struct scr24x_dev *dev = filp->private_data;

	/* We must not take the dev->lock here as scr24x_delete()
	 * might be called to remove the dev structure altogether.
	 * We don't need the lock anyway, since after the reference
	 * acquired in probe() is released in remove() the chrdev
	 * is already unregistered and noone can possibly acquire
	 * a reference via open() anymore. */
	kref_put(&dev->refcnt, scr24x_delete);
	return 0;
}

static int read_chunk(struct scr24x_dev *dev, size_t offset, size_t limit)
{
	size_t i, y;
	int ret;

	for (i = offset; i < limit; i += 5) {
		iowrite8(CMD_READ_BYTE, dev->regs + SCR24X_CMD_STATUS);
		ret = scr24x_wait_ready(dev);
		if (ret < 0)
			return ret;

		for (y = 0; y < 5 && i + y < limit; y++)
			dev->buf[i + y] = ioread8(dev->regs + SCR24X_DATA(y));
	}

	return 0;
}

static ssize_t scr24x_read(struct file *filp, char __user *buf, size_t count,
								loff_t *ppos)
{
	struct scr24x_dev *dev = filp->private_data;
	int ret;
	int len;

	if (count < CCID_HEADER_SIZE)
		return -EINVAL;

	if (mutex_lock_interruptible(&dev->lock))
		return -ERESTARTSYS;

	if (!dev->dev) {
		ret = -ENODEV;
		goto out;
	}

	ret = scr24x_wait_ready(dev);
	if (ret < 0)
		goto out;
	len = CCID_HEADER_SIZE;
	ret = read_chunk(dev, 0, len);
	if (ret < 0)
		goto out;

	len += le32_to_cpu(*(__le32 *)(&dev->buf[CCID_LENGTH_OFFSET]));
	if (len > sizeof(dev->buf)) {
		ret = -EIO;
		goto out;
	}
	ret = read_chunk(dev, CCID_HEADER_SIZE, len);
	if (ret < 0)
		goto out;

	if (len < count)
		count = len;

	if (copy_to_user(buf, dev->buf, count)) {
		ret = -EFAULT;
		goto out;
	}

	ret = count;
out:
	mutex_unlock(&dev->lock);
	return ret;
}

static ssize_t scr24x_write(struct file *filp, const char __user *buf,
					size_t count, loff_t *ppos)
{
	struct scr24x_dev *dev = filp->private_data;
	size_t i, y;
	int ret;

	if (mutex_lock_interruptible(&dev->lock))
		return -ERESTARTSYS;

	if (!dev->dev) {
		ret = -ENODEV;
		goto out;
	}

	if (count > sizeof(dev->buf)) {
		ret = -EINVAL;
		goto out;
	}

	if (copy_from_user(dev->buf, buf, count)) {
		ret = -EFAULT;
		goto out;
	}

	ret = scr24x_wait_ready(dev);
	if (ret < 0)
		goto out;

	iowrite8(CMD_START, dev->regs + SCR24X_CMD_STATUS);
	ret = scr24x_wait_ready(dev);
	if (ret < 0)
		goto out;

	for (i = 0; i < count; i += 5) {
		for (y = 0; y < 5 && i + y < count; y++)
			iowrite8(dev->buf[i + y], dev->regs + SCR24X_DATA(y));

		iowrite8(CMD_WRITE_BYTE, dev->regs + SCR24X_CMD_STATUS);
		ret = scr24x_wait_ready(dev);
		if (ret < 0)
			goto out;
	}

	ret = count;
out:
	mutex_unlock(&dev->lock);
	return ret;
}

static const struct file_operations scr24x_fops = {
	.owner		= THIS_MODULE,
	.read		= scr24x_read,
	.write		= scr24x_write,
	.open		= scr24x_open,
	.release	= scr24x_release,
	.llseek		= no_llseek,
};

static int scr24x_config_check(struct pcmcia_device *link, void *priv_data)
{
	if (resource_size(link->resource[PCMCIA_IOPORT_0]) != 0x11)
		return -ENODEV;
	return pcmcia_request_io(link);
}

static int scr24x_probe(struct pcmcia_device *link)
{
	struct scr24x_dev *dev;
	int ret;

	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (!dev)
		return -ENOMEM;

	dev->devno = find_first_zero_bit(scr24x_minors, SCR24X_DEVS);
	if (dev->devno >= SCR24X_DEVS) {
		ret = -EBUSY;
		goto err;
	}

	mutex_init(&dev->lock);
	kref_init(&dev->refcnt);

	link->priv = dev;
	link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;

	ret = pcmcia_loop_config(link, scr24x_config_check, NULL);
	if (ret < 0)
		goto err;

	dev->dev = &link->dev;
	dev->regs = devm_ioport_map(&link->dev,
				link->resource[PCMCIA_IOPORT_0]->start,
				resource_size(link->resource[PCMCIA_IOPORT_0]));
	if (!dev->regs) {
		ret = -EIO;
		goto err;
	}

	cdev_init(&dev->c_dev, &scr24x_fops);
	dev->c_dev.owner = THIS_MODULE;
	dev->c_dev.ops = &scr24x_fops;
	ret = cdev_add(&dev->c_dev, MKDEV(MAJOR(scr24x_devt), dev->devno), 1);
	if (ret < 0)
		goto err;

	ret = pcmcia_enable_device(link);
	if (ret < 0) {
		pcmcia_disable_device(link);
		goto err;
	}

	device_create(scr24x_class, NULL, MKDEV(MAJOR(scr24x_devt), dev->devno),
		      NULL, "scr24x%d", dev->devno);

	dev_info(&link->dev, "SCR24x Chip Card Interface\n");
	return 0;

err:
	if (dev->devno < SCR24X_DEVS)
		clear_bit(dev->devno, scr24x_minors);
	kfree (dev);
	return ret;
}

static void scr24x_remove(struct pcmcia_device *link)
{
	struct scr24x_dev *dev = (struct scr24x_dev *)link->priv;

	device_destroy(scr24x_class, MKDEV(MAJOR(scr24x_devt), dev->devno));
	mutex_lock(&dev->lock);
	pcmcia_disable_device(link);
	cdev_del(&dev->c_dev);
	clear_bit(dev->devno, scr24x_minors);
	dev->dev = NULL;
	mutex_unlock(&dev->lock);

	kref_put(&dev->refcnt, scr24x_delete);
}

static const struct pcmcia_device_id scr24x_ids[] = {
	PCMCIA_DEVICE_PROD_ID12("HP", "PC Card Smart Card Reader",
					0x53cb94f9, 0xbfdf89a5),
	PCMCIA_DEVICE_PROD_ID1("SCR241 PCMCIA", 0x6271efa3),
	PCMCIA_DEVICE_PROD_ID1("SCR243 PCMCIA", 0x2054e8de),
	PCMCIA_DEVICE_PROD_ID1("SCR24x PCMCIA", 0x54a33665),
	PCMCIA_DEVICE_NULL
};
MODULE_DEVICE_TABLE(pcmcia, scr24x_ids);

static struct pcmcia_driver scr24x_driver = {
	.owner		= THIS_MODULE,
	.name		= "scr24x_cs",
	.probe		= scr24x_probe,
	.remove		= scr24x_remove,
	.id_table	= scr24x_ids,
};

static int __init scr24x_init(void)
{
	int ret;

	scr24x_class = class_create(THIS_MODULE, "scr24x");
	if (IS_ERR(scr24x_class))
		return PTR_ERR(scr24x_class);

	ret = alloc_chrdev_region(&scr24x_devt, 0, SCR24X_DEVS, "scr24x");
	if (ret < 0)  {
		class_destroy(scr24x_class);
		return ret;
	}

	ret = pcmcia_register_driver(&scr24x_driver);
	if (ret < 0) {
		unregister_chrdev_region(scr24x_devt, SCR24X_DEVS);
		class_destroy(scr24x_class);
	}

	return ret;
}

static void __exit scr24x_exit(void)
{
	pcmcia_unregister_driver(&scr24x_driver);
	unregister_chrdev_region(scr24x_devt, SCR24X_DEVS);
	class_destroy(scr24x_class);
}

module_init(scr24x_init);
module_exit(scr24x_exit);

MODULE_AUTHOR("Lubomir Rintel");
MODULE_DESCRIPTION("SCR24x PCMCIA Smart Card Reader Driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
f2ed287b LR	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>
ee76bba7	30	#include <linux/io.h>
f2ed287b LR	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 nonseekable_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	}
999e4bf1	161	ret = read_chunk(dev, CCID_HEADER_SIZE, len);
f2ed287b LR	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");