cm4040_cs.c

linux-2.6.15.6

	}

	DEBUGP(2, dev, "<- cm4040_write (successfully)\n");
	return count;
}

static unsigned int cm4040_poll(struct file *filp, poll_table *wait)
{
	struct reader_dev *dev = filp->private_data;
	unsigned int mask = 0;

	poll_wait(filp, &dev->poll_wait, wait);

	if (test_and_clear_bit(BS_READABLE, &dev->buffer_status))
		mask |= POLLIN | POLLRDNORM;
	if (test_and_clear_bit(BS_WRITABLE, &dev->buffer_status))
		mask |= POLLOUT | POLLWRNORM;

	DEBUGP(2, dev, "<- cm4040_poll(%u)\n", mask);

	return mask;
}

static int cm4040_open(struct inode *inode, struct file *filp)
{
	struct reader_dev *dev;
	dev_link_t *link;
	int minor = iminor(inode);

	if (minor >= CM_MAX_DEV)
		return -ENODEV;

	link = dev_table[minor];
	if (link == NULL || !(DEV_OK(link)))
		return -ENODEV;

	if (link->open)
		return -EBUSY;

	dev = link->priv;
	filp->private_data = dev;

	if (filp->f_flags & O_NONBLOCK) {
		DEBUGP(4, dev, "filep->f_flags O_NONBLOCK set\n");
		return -EAGAIN;
	}

	link->open = 1;

	dev->poll_timer.data = (unsigned long) dev;
	mod_timer(&dev->poll_timer, jiffies + POLL_PERIOD);

	DEBUGP(2, dev, "<- cm4040_open (successfully)\n");
	return nonseekable_open(inode, filp);
}

static int cm4040_close(struct inode *inode, struct file *filp)
{
	struct reader_dev *dev = filp->private_data;
	dev_link_t *link;
	int minor = iminor(inode);

	DEBUGP(2, dev, "-> cm4040_close(maj/min=%d.%d)\n", imajor(inode),
	      iminor(inode));

	if (minor >= CM_MAX_DEV)
		return -ENODEV;

	link = dev_table[minor];
	if (link == NULL)
		return -ENODEV;

	cm4040_stop_poll(dev);

	link->open = 0;
	wake_up(&dev->devq);

	DEBUGP(2, dev, "<- cm4040_close\n");
	return 0;
}

static void cm4040_reader_release(dev_link_t *link)
{
	struct reader_dev *dev = link->priv;

	DEBUGP(3, dev, "-> cm4040_reader_release\n");
	while (link->open) {
		DEBUGP(3, dev, KERN_INFO MODULE_NAME ": delaying release "
		       "until process has terminated\n");
 		wait_event(dev->devq, (link->open == 0));
	}
	DEBUGP(3, dev, "<- cm4040_reader_release\n");
	return;
}

static void reader_config(dev_link_t *link, int devno)
{
	client_handle_t handle;
	struct reader_dev *dev;
	tuple_t tuple;
	cisparse_t parse;
	config_info_t conf;
	u_char buf[64];
	int fail_fn, fail_rc;
	int rc;

	handle = link->handle;

	tuple.DesiredTuple = CISTPL_CONFIG;
	tuple.Attributes = 0;
	tuple.TupleData = buf;
	tuple.TupleDataMax = sizeof(buf);
 	tuple.TupleOffset = 0;

	if ((fail_rc = pcmcia_get_first_tuple(handle, &tuple)) != CS_SUCCESS) {
		fail_fn = GetFirstTuple;
		goto cs_failed;
	}
	if ((fail_rc = pcmcia_get_tuple_data(handle, &tuple)) != CS_SUCCESS) {
		fail_fn = GetTupleData;
		goto cs_failed;
	}
	if ((fail_rc = pcmcia_parse_tuple(handle, &tuple, &parse))
							!= CS_SUCCESS) {
		fail_fn = ParseTuple;
		goto cs_failed;
	}
	if ((fail_rc = pcmcia_get_configuration_info(handle, &conf))
							!= CS_SUCCESS) {
		fail_fn = GetConfigurationInfo;
		goto cs_failed;
	}

	link->state |= DEV_CONFIG;
	link->conf.ConfigBase = parse.config.base;
	link->conf.Present = parse.config.rmask[0];
	link->conf.Vcc = conf.Vcc;

	link->io.BasePort2 = 0;
	link->io.NumPorts2 = 0;
	link->io.Attributes2 = 0;
	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	for (rc = pcmcia_get_first_tuple(handle, &tuple);
	     rc == CS_SUCCESS;
	     rc = pcmcia_get_next_tuple(handle, &tuple)) {
		rc = pcmcia_get_tuple_data(handle, &tuple);
		if (rc != CS_SUCCESS)
			continue;
		rc = pcmcia_parse_tuple(handle, &tuple, &parse);
		if (rc != CS_SUCCESS)
			continue;

		link->conf.ConfigIndex = parse.cftable_entry.index;

		if (!parse.cftable_entry.io.nwin)
			continue;

		link->io.BasePort1 = parse.cftable_entry.io.win[0].base;
		link->io.NumPorts1 = parse.cftable_entry.io.win[0].len;
		link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
		if (!(parse.cftable_entry.io.flags & CISTPL_IO_8BIT))
			link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
		if (!(parse.cftable_entry.io.flags & CISTPL_IO_16BIT))
			link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
		link->io.IOAddrLines = parse.cftable_entry.io.flags
						& CISTPL_IO_LINES_MASK;
		rc = pcmcia_request_io(handle, &link->io);

		dev_printk(KERN_INFO, &handle_to_dev(handle), "foo");
		if (rc == CS_SUCCESS)
			break;
		else
			dev_printk(KERN_INFO, &handle_to_dev(handle),
				   "pcmcia_request_io failed 0x%x\n", rc);
	}
	if (rc != CS_SUCCESS)
		goto cs_release;

	link->conf.IntType = 00000002;

	if ((fail_rc = pcmcia_request_configuration(handle,&link->conf))
								!=CS_SUCCESS) {
		fail_fn = RequestConfiguration;
		dev_printk(KERN_INFO, &handle_to_dev(handle),
			   "pcmcia_request_configuration failed 0x%x\n",
			   fail_rc);
		goto cs_release;
	}

	dev = link->priv;
	sprintf(dev->node.dev_name, DEVICE_NAME "%d", devno);
	dev->node.major = major;
	dev->node.minor = devno;
	dev->node.next = NULL;
	link->dev = &dev->node;
	link->state &= ~DEV_CONFIG_PENDING;

	DEBUGP(2, dev, "device " DEVICE_NAME "%d at 0x%.4x-0x%.4x\n", devno,
	      link->io.BasePort1, link->io.BasePort1+link->io.NumPorts1);
	DEBUGP(2, dev, "<- reader_config (succ)\n");

	return;

cs_failed:
	cs_error(handle, fail_fn, fail_rc);
cs_release:
	reader_release(link);
	link->state &= ~DEV_CONFIG_PENDING;
}

static int reader_event(event_t event, int priority,
			event_callback_args_t *args)
{
	dev_link_t *link;
	struct reader_dev *dev;
	int devno;

	link = args->client_data;
	dev = link->priv;
	DEBUGP(3, dev, "-> reader_event\n");
	for (devno = 0; devno < CM_MAX_DEV; devno++) {
		if (dev_table[devno] == link)
			break;
	}
	if (devno == CM_MAX_DEV)
		return CS_BAD_ADAPTER;

	switch (event) {
		case CS_EVENT_CARD_INSERTION:
			DEBUGP(5, dev, "CS_EVENT_CARD_INSERTION\n");
			link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
			reader_config(link, devno);
			break;
		case CS_EVENT_CARD_REMOVAL:
			DEBUGP(5, dev, "CS_EVENT_CARD_REMOVAL\n");
			link->state &= ~DEV_PRESENT;
			break;
		case CS_EVENT_PM_SUSPEND:
			DEBUGP(5, dev, "CS_EVENT_PM_SUSPEND "
			      "(fall-through to CS_EVENT_RESET_PHYSICAL)\n");
			link->state |= DEV_SUSPEND;

		case CS_EVENT_RESET_PHYSICAL:
			DEBUGP(5, dev, "CS_EVENT_RESET_PHYSICAL\n");
			if (link->state & DEV_CONFIG) {
		  		DEBUGP(5, dev, "ReleaseConfiguration\n");
		  		pcmcia_release_configuration(link->handle);
			}
			break;
		case CS_EVENT_PM_RESUME:
			DEBUGP(5, dev, "CS_EVENT_PM_RESUME "
			      "(fall-through to CS_EVENT_CARD_RESET)\n");
			link->state &= ~DEV_SUSPEND;

		case CS_EVENT_CARD_RESET:
			DEBUGP(5, dev, "CS_EVENT_CARD_RESET\n");
			if ((link->state & DEV_CONFIG)) {
				DEBUGP(5, dev, "RequestConfiguration\n");
		  		pcmcia_request_configuration(link->handle,
							     &link->conf);
			}
			break;
		default:
			DEBUGP(5, dev, "reader_event: unknown event %.2x\n",
			       event);
			break;
	}
	DEBUGP(3, dev, "<- reader_event\n");
	return CS_SUCCESS;
}

static void reader_release(dev_link_t *link)
{
	cm4040_reader_release(link->priv);
	pcmcia_release_configuration(link->handle);
	pcmcia_release_io(link->handle, &link->io);
}

static dev_link_t *reader_attach(void)
{
	struct reader_dev *dev;
	dev_link_t *link;
	client_reg_t client_reg;
	int i;

	for (i = 0; i < CM_MAX_DEV; i++) {
		if (dev_table[i] == NULL)
			break;
	}

	if (i == CM_MAX_DEV)
		return NULL;

	dev = kzalloc(sizeof(struct reader_dev), GFP_KERNEL);
	if (dev == NULL)
		return NULL;

	dev->timeout = CCID_DRIVER_MINIMUM_TIMEOUT;
	dev->buffer_status = 0;

	link = &dev->link;
	link->priv = dev;

	link->conf.IntType = INT_MEMORY_AND_IO;
	dev_table[i] = link;

	client_reg.dev_info = &dev_info;
	client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
	client_reg.EventMask=
		CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
		CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
		CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
	client_reg.Version = 0x0210;
	client_reg.event_callback_args.client_data = link;
	i = pcmcia_register_client(&link->handle, &client_reg);
	if (i) {
		cs_error(link->handle, RegisterClient, i);
		reader_detach(link);
		return NULL;
	}
	init_waitqueue_head(&dev->devq);
	init_waitqueue_head(&dev->poll_wait);
	init_waitqueue_head(&dev->read_wait);
	init_waitqueue_head(&dev->write_wait);
	init_timer(&dev->poll_timer);
	dev->poll_timer.function = &cm4040_do_poll;

	return link;
}

static void reader_detach_by_devno(int devno, dev_link_t *link)
{
	struct reader_dev *dev = link->priv;

	if (link->state & DEV_CONFIG) {
		DEBUGP(5, dev, "device still configured (try to release it)\n");
		reader_release(link);
	}

	pcmcia_deregister_client(link->handle);
	dev_table[devno] = NULL;
	DEBUGP(5, dev, "freeing dev=%p\n", dev);
	cm4040_stop_poll(dev);
	kfree(dev);
	return;
}

static void reader_detach(dev_link_t *link)
{
	int i;

	/* find device */
	for (i = 0; i < CM_MAX_DEV; i++) {
		if (dev_table[i] == link)
			break;
	}
	if (i == CM_MAX_DEV)
		return;

	reader_detach_by_devno(i, link);
	return;
}

static struct file_operations reader_fops = {
	.owner		= THIS_MODULE,
	.read		= cm4040_read,
	.write		= cm4040_write,
	.open		= cm4040_open,
	.release	= cm4040_close,
	.poll		= cm4040_poll,
};

static struct pcmcia_device_id cm4040_ids[] = {
	PCMCIA_DEVICE_MANF_CARD(0x0223, 0x0200),
	PCMCIA_DEVICE_PROD_ID12("OMNIKEY", "CardMan 4040",
				0xE32CDD8C, 0x8F23318B),
	PCMCIA_DEVICE_NULL,
};
MODULE_DEVICE_TABLE(pcmcia, cm4040_ids);

static struct pcmcia_driver reader_driver = {
  	.owner		= THIS_MODULE,
  	.drv		= {
		.name	= "cm4040_cs",
	},
	.attach		= reader_attach,
	.detach		= reader_detach,
	.event		= reader_event,
	.id_table	= cm4040_ids,
};

static int __init cm4040_init(void)
{
	printk(KERN_INFO "%s\n", version);
	pcmcia_register_driver(&reader_driver);
	major = register_chrdev(0, DEVICE_NAME, &reader_fops);
	if (major < 0) {
		printk(KERN_WARNING MODULE_NAME
			": could not get major number\n");
		return -1;
	}
	return 0;
}

static void __exit cm4040_exit(void)
{
	int i;

	printk(KERN_INFO MODULE_NAME ": unloading\n");
	pcmcia_unregister_driver(&reader_driver);
	for (i = 0; i < CM_MAX_DEV; i++) {
		if (dev_table[i])
			reader_detach_by_devno(i, dev_table[i]);
	}
	unregister_chrdev(major, DEVICE_NAME);
}

module_init(cm4040_init);
module_exit(cm4040_exit);
MODULE_LICENSE("Dual BSD/GPL");