[deliverable/linux.git] / drivers / pcmcia / pcmcia_ioctl.c

/*
 * pcmcia_ioctl.c -- ioctl interface for cardmgr and cardctl
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * The initial developer of the original code is David A. Hinds
 * <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
 * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
 *
 * (C) 1999		David A. Hinds
 * (C) 2003 - 2004	Dominik Brodowski
 */

/*
 * This file will go away soon.
 */


#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/major.h>
#include <linux/errno.h>
#include <linux/ioctl.h>
#include <linux/proc_fs.h>
#include <linux/poll.h>
#include <linux/pci.h>
#include <linux/workqueue.h>

#define IN_CARD_SERVICES
#include <pcmcia/cs_types.h>
#include <pcmcia/cs.h>
#include <pcmcia/cistpl.h>
#include <pcmcia/ds.h>
#include <pcmcia/ss.h>

#include "cs_internal.h"
#include "ds_internal.h"

static int major_dev = -1;


/* Device user information */
#define MAX_EVENTS	32
#define USER_MAGIC	0x7ea4
#define CHECK_USER(u) \
    (((u) == NULL) || ((u)->user_magic != USER_MAGIC))

typedef struct user_info_t {
	u_int			user_magic;
	int			event_head, event_tail;
	event_t			event[MAX_EVENTS];
	struct user_info_t	*next;
	struct pcmcia_socket	*socket;
} user_info_t;


#ifdef DEBUG
extern int ds_pc_debug;
#define cs_socket_name(skt)    ((skt)->dev.class_id)

#define ds_dbg(lvl, fmt, arg...) do {		\
	if (ds_pc_debug >= lvl)				\
		printk(KERN_DEBUG "ds: " fmt , ## arg);		\
} while (0)
#else
#define ds_dbg(lvl, fmt, arg...) do { } while (0)
#endif


/* backwards-compatible accessing of driver --- by name! */

static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info)
{
	struct device_driver *drv;
	struct pcmcia_driver *p_drv;

	drv = driver_find((char *) dev_info, &pcmcia_bus_type);
	if (!drv)
		return NULL;

	p_drv = container_of(drv, struct pcmcia_driver, drv);

	return (p_drv);
}


#ifdef CONFIG_PROC_FS
static struct proc_dir_entry *proc_pccard = NULL;

static int proc_read_drivers_callback(struct device_driver *driver, void *d)
{
	char **p = d;
	struct pcmcia_driver *p_drv = container_of(driver,
						   struct pcmcia_driver, drv);

	*p += sprintf(*p, "%-24.24s 1 %d\n", p_drv->drv.name,
#ifdef CONFIG_MODULE_UNLOAD
		      (p_drv->owner) ? module_refcount(p_drv->owner) : 1
#else
		      1
#endif
	);
	d = (void *) p;

	return 0;
}

static int proc_read_drivers(char *buf, char **start, off_t pos,
			     int count, int *eof, void *data)
{
	char *p = buf;

	bus_for_each_drv(&pcmcia_bus_type, NULL,
			 (void *) &p, proc_read_drivers_callback);

	return (p - buf);
}
#endif

/*======================================================================

    These manage a ring buffer of events pending for one user process

======================================================================*/


static int queue_empty(user_info_t *user)
{
    return (user->event_head == user->event_tail);
}

static event_t get_queued_event(user_info_t *user)
{
    user->event_tail = (user->event_tail+1) % MAX_EVENTS;
    return user->event[user->event_tail];
}

static void queue_event(user_info_t *user, event_t event)
{
    user->event_head = (user->event_head+1) % MAX_EVENTS;
    if (user->event_head == user->event_tail)
	user->event_tail = (user->event_tail+1) % MAX_EVENTS;
    user->event[user->event_head] = event;
}

void handle_event(struct pcmcia_socket *s, event_t event)
{
    user_info_t *user;
    for (user = s->user; user; user = user->next)
	queue_event(user, event);
    wake_up_interruptible(&s->queue);
}


/*======================================================================

    bind_request() and bind_device() are merged by now. Register_client()
    is called right at the end of bind_request(), during the driver's
    ->attach() call. Individual descriptions:

    bind_request() connects a socket to a particular client driver.
    It looks up the specified device ID in the list of registered
    drivers, binds it to the socket, and tries to create an instance
    of the device.  unbind_request() deletes a driver instance.

    Bind_device() associates a device driver with a particular socket.
    It is normally called by Driver Services after it has identified
    a newly inserted card.  An instance of that driver will then be
    eligible to register as a client of this socket.

    Register_client() uses the dev_info_t handle to match the
    caller with a socket.  The driver must have already been bound
    to a socket with bind_device() -- in fact, bind_device()
    allocates the client structure that will be used.

======================================================================*/

static int bind_request(struct pcmcia_socket *s, bind_info_t *bind_info)
{
	struct pcmcia_driver *p_drv;
	struct pcmcia_device *p_dev;
	int ret = 0;
	unsigned long flags;

	s = pcmcia_get_socket(s);
	if (!s)
		return -EINVAL;

	ds_dbg(2, "bind_request(%d, '%s')\n", s->sock,
	       (char *)bind_info->dev_info);

	p_drv = get_pcmcia_driver(&bind_info->dev_info);
	if (!p_drv) {
		ret = -EINVAL;
		goto err_put;
	}

	if (!try_module_get(p_drv->owner)) {
		ret = -EINVAL;
		goto err_put_driver;
	}

	spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
        list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
		if (p_dev->func == bind_info->function) {
			if ((p_dev->dev.driver == &p_drv->drv)) {
				if (p_dev->cardmgr) {
					/* if there's already a device
					 * registered, and it was registered
					 * by userspace before, we need to
					 * return the "instance". */
					spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
					bind_info->instance = p_dev->instance;
					ret = -EBUSY;
					goto err_put_module;
				} else {
					/* the correct driver managed to bind
					 * itself magically to the correct
					 * device. */
					spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
					p_dev->cardmgr = p_drv;
					ret = 0;
					goto err_put_module;
				}
			} else if (!p_dev->dev.driver) {
				/* there's already a device available where
				 * no device has been bound to yet. So we don't
				 * need to register a device! */
				spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
				goto rescan;
			}
		}
	}
	spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);

	p_dev = pcmcia_device_add(s, bind_info->function);
	if (!p_dev) {
		ret = -EIO;
		goto err_put_module;
	}

rescan:
	p_dev->cardmgr = p_drv;

	/* if a driver is already running, we can abort */
	if (p_dev->dev.driver)
		goto err_put_module;

	/*
	 * Prevent this racing with a card insertion.
	 */
	down(&s->skt_sem);
	bus_rescan_devices(&pcmcia_bus_type);
	up(&s->skt_sem);

	/* check whether the driver indeed matched. I don't care if this
	 * is racy or not, because it can only happen on cardmgr access
	 * paths...
	 */
	if (!(p_dev->dev.driver == &p_drv->drv))
		p_dev->cardmgr = NULL;

 err_put_module:
	module_put(p_drv->owner);
 err_put_driver:
	put_driver(&p_drv->drv);
 err_put:
	pcmcia_put_socket(s);

	return (ret);
} /* bind_request */

#ifdef CONFIG_CARDBUS

static struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
{
	if (!s || !(s->state & SOCKET_CARDBUS))
		return NULL;

	return s->cb_dev->subordinate;
}
#endif

static int get_device_info(struct pcmcia_socket *s, bind_info_t *bind_info, int first)
{
	dev_node_t *node;
	struct pcmcia_device *p_dev;
	unsigned long flags;
	int ret = 0;

#ifdef CONFIG_CARDBUS
	/*
	 * Some unbelievably ugly code to associate the PCI cardbus
	 * device and its driver with the PCMCIA "bind" information.
	 */
	{
		struct pci_bus *bus;

		bus = pcmcia_lookup_bus(s);
		if (bus) {
			struct list_head *list;
			struct pci_dev *dev = NULL;

			list = bus->devices.next;
			while (list != &bus->devices) {
				struct pci_dev *pdev = pci_dev_b(list);
				list = list->next;

				if (first) {
					dev = pdev;
					break;
				}

				/* Try to handle "next" here some way? */
			}
			if (dev && dev->driver) {
				strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
				bind_info->major = 0;
				bind_info->minor = 0;
				bind_info->next = NULL;
				return 0;
			}
		}
	}
#endif

	spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
	list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
		if (p_dev->func == bind_info->function) {
			p_dev = pcmcia_get_dev(p_dev);
			if (!p_dev)
				continue;
			goto found;
		}
	}
	spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
	return -ENODEV;

 found:
	spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);

	if ((!p_dev->instance) ||
	    (p_dev->instance->state & DEV_CONFIG_PENDING)) {
		ret = -EAGAIN;
		goto err_put;
	}

	if (first)
		node = p_dev->instance->dev;
	else
		for (node = p_dev->instance->dev; node; node = node->next)
			if (node == bind_info->next)
				break;
	if (!node) {
		ret = -ENODEV;
		goto err_put;
	}

	strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
	bind_info->major = node->major;
	bind_info->minor = node->minor;
	bind_info->next = node->next;

 err_put:
	pcmcia_put_dev(p_dev);
	return (ret);
} /* get_device_info */


static int ds_open(struct inode *inode, struct file *file)
{
    socket_t i = iminor(inode);
    struct pcmcia_socket *s;
    user_info_t *user;

    ds_dbg(0, "ds_open(socket %d)\n", i);

    s = pcmcia_get_socket_by_nr(i);
    if (!s)
	    return -ENODEV;
    s = pcmcia_get_socket(s);
    if (!s)
	    return -ENODEV;

    if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
	    if (s->pcmcia_state.busy) {
		    pcmcia_put_socket(s);
		    return -EBUSY;
	    }
	else
	    s->pcmcia_state.busy = 1;
    }

    user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
    if (!user) {
	    pcmcia_put_socket(s);
	    return -ENOMEM;
    }
    user->event_tail = user->event_head = 0;
    user->next = s->user;
    user->user_magic = USER_MAGIC;
    user->socket = s;
    s->user = user;
    file->private_data = user;

    if (s->pcmcia_state.present)
	queue_event(user, CS_EVENT_CARD_INSERTION);
    return 0;
} /* ds_open */

/*====================================================================*/

static int ds_release(struct inode *inode, struct file *file)
{
    struct pcmcia_socket *s;
    user_info_t *user, **link;

    ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));

    user = file->private_data;
    if (CHECK_USER(user))
	goto out;

    s = user->socket;

    /* Unlink user data structure */
    if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
	s->pcmcia_state.busy = 0;
    }
    file->private_data = NULL;
    for (link = &s->user; *link; link = &(*link)->next)
	if (*link == user) break;
    if (link == NULL)
	goto out;
    *link = user->next;
    user->user_magic = 0;
    kfree(user);
    pcmcia_put_socket(s);
out:
    return 0;
} /* ds_release */

/*====================================================================*/

static ssize_t ds_read(struct file *file, char __user *buf,
		       size_t count, loff_t *ppos)
{
    struct pcmcia_socket *s;
    user_info_t *user;
    int ret;

    ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));

    if (count < 4)
	return -EINVAL;

    user = file->private_data;
    if (CHECK_USER(user))
	return -EIO;

    s = user->socket;
    if (s->pcmcia_state.dead)
        return -EIO;

    ret = wait_event_interruptible(s->queue, !queue_empty(user));
    if (ret == 0)
	ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;

    return ret;
} /* ds_read */

/*====================================================================*/

static ssize_t ds_write(struct file *file, const char __user *buf,
			size_t count, loff_t *ppos)
{
    ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));

    if (count != 4)
	return -EINVAL;
    if ((file->f_flags & O_ACCMODE) == O_RDONLY)
	return -EBADF;

    return -EIO;
} /* ds_write */

/*====================================================================*/

/* No kernel lock - fine */
static u_int ds_poll(struct file *file, poll_table *wait)
{
    struct pcmcia_socket *s;
    user_info_t *user;

    ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));

    user = file->private_data;
    if (CHECK_USER(user))
	return POLLERR;
    s = user->socket;
    /*
     * We don't check for a dead socket here since that
     * will send cardmgr into an endless spin.
     */
    poll_wait(file, &s->queue, wait);
    if (!queue_empty(user))
	return POLLIN | POLLRDNORM;
    return 0;
} /* ds_poll */

/*====================================================================*/

extern int pcmcia_adjust_resource_info(adjust_t *adj);

static int ds_ioctl(struct inode * inode, struct file * file,
		    u_int cmd, u_long arg)
{
    struct pcmcia_socket *s;
    void __user *uarg = (char __user *)arg;
    u_int size;
    int ret, err;
    ds_ioctl_arg_t *buf;
    user_info_t *user;

    ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);

    user = file->private_data;
    if (CHECK_USER(user))
	return -EIO;

    s = user->socket;
    if (s->pcmcia_state.dead)
        return -EIO;

    size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
    if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;

    /* Permission check */
    if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
	return -EPERM;

    if (cmd & IOC_IN) {
	if (!access_ok(VERIFY_READ, uarg, size)) {
	    ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
	    return -EFAULT;
	}
    }
    if (cmd & IOC_OUT) {
	if (!access_ok(VERIFY_WRITE, uarg, size)) {
	    ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
	    return -EFAULT;
	}
    }
    buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
    if (!buf)
	return -ENOMEM;

    err = ret = 0;

    if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size);

    switch (cmd) {
    case DS_ADJUST_RESOURCE_INFO:
	ret = pcmcia_adjust_resource_info(&buf->adjust);
	break;
    case DS_GET_CONFIGURATION_INFO:
	if (buf->config.Function &&
	   (buf->config.Function >= s->functions))
	    ret = CS_BAD_ARGS;
	else
	    ret = pccard_get_configuration_info(s,
			buf->config.Function, &buf->config);
	break;
    case DS_GET_FIRST_TUPLE:
	down(&s->skt_sem);
	pcmcia_validate_mem(s);
	up(&s->skt_sem);
	ret = pccard_get_first_tuple(s, BIND_FN_ALL, &buf->tuple);
	break;
    case DS_GET_NEXT_TUPLE:
	ret = pccard_get_next_tuple(s, BIND_FN_ALL, &buf->tuple);
	break;
    case DS_GET_TUPLE_DATA:
	buf->tuple.TupleData = buf->tuple_parse.data;
	buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
	ret = pccard_get_tuple_data(s, &buf->tuple);
	break;
    case DS_PARSE_TUPLE:
	buf->tuple.TupleData = buf->tuple_parse.data;
	ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
	break;
    case DS_RESET_CARD:
	ret = pccard_reset_card(s);
	break;
    case DS_GET_STATUS:
	if (buf->status.Function &&
	   (buf->status.Function >= s->functions))
	    ret = CS_BAD_ARGS;
	else
	ret = pccard_get_status(s, buf->status.Function, &buf->status);
	break;
    case DS_VALIDATE_CIS:
	down(&s->skt_sem);
	pcmcia_validate_mem(s);
	up(&s->skt_sem);
	ret = pccard_validate_cis(s, BIND_FN_ALL, &buf->cisinfo);
	break;
    case DS_SUSPEND_CARD:
	ret = pcmcia_suspend_card(s);
	break;
    case DS_RESUME_CARD:
	ret = pcmcia_resume_card(s);
	break;
    case DS_EJECT_CARD:
	err = pcmcia_eject_card(s);
	break;
    case DS_INSERT_CARD:
	err = pcmcia_insert_card(s);
	break;
    case DS_ACCESS_CONFIGURATION_REGISTER:
	if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
	    err = -EPERM;
	    goto free_out;
	}
	if (buf->conf_reg.Function &&
	   (buf->conf_reg.Function >= s->functions))
	    ret = CS_BAD_ARGS;
	else
	    ret = pccard_access_configuration_register(s,
			buf->conf_reg.Function, &buf->conf_reg);
	break;
    case DS_GET_FIRST_REGION:
    case DS_GET_NEXT_REGION:
    case DS_BIND_MTD:
	if (!capable(CAP_SYS_ADMIN)) {
		err = -EPERM;
		goto free_out;
	} else {
		static int printed = 0;
		if (!printed) {
			printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
			printk(KERN_WARNING "MTD handling any more.\n");
			printed++;
		}
	}
	err = -EINVAL;
	goto free_out;
	break;
    case DS_GET_FIRST_WINDOW:
	ret = pcmcia_get_window(s, &buf->win_info.handle, 0,
			&buf->win_info.window);
	break;
    case DS_GET_NEXT_WINDOW:
	ret = pcmcia_get_window(s, &buf->win_info.handle,
			buf->win_info.handle->index + 1, &buf->win_info.window);
	break;
    case DS_GET_MEM_PAGE:
	ret = pcmcia_get_mem_page(buf->win_info.handle,
			   &buf->win_info.map);
	break;
    case DS_REPLACE_CIS:
	ret = pcmcia_replace_cis(s, &buf->cisdump);
	break;
    case DS_BIND_REQUEST:
	if (!capable(CAP_SYS_ADMIN)) {
		err = -EPERM;
		goto free_out;
	}
	err = bind_request(s, &buf->bind_info);
	break;
    case DS_GET_DEVICE_INFO:
	err = get_device_info(s, &buf->bind_info, 1);
	break;
    case DS_GET_NEXT_DEVICE:
	err = get_device_info(s, &buf->bind_info, 0);
	break;
    case DS_UNBIND_REQUEST:
	err = 0;
	break;
    default:
	err = -EINVAL;
    }

    if ((err == 0) && (ret != CS_SUCCESS)) {
	ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
	switch (ret) {
	case CS_BAD_SOCKET: case CS_NO_CARD:
	    err = -ENODEV; break;
	case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
	case CS_BAD_TUPLE:
	    err = -EINVAL; break;
	case CS_IN_USE:
	    err = -EBUSY; break;
	case CS_OUT_OF_RESOURCE:
	    err = -ENOSPC; break;
	case CS_NO_MORE_ITEMS:
	    err = -ENODATA; break;
	case CS_UNSUPPORTED_FUNCTION:
	    err = -ENOSYS; break;
	default:
	    err = -EIO; break;
	}
    }

    if (cmd & IOC_OUT) {
        if (__copy_to_user(uarg, (char *)buf, size))
            err = -EFAULT;
    }

free_out:
    kfree(buf);
    return err;
} /* ds_ioctl */

/*====================================================================*/

static struct file_operations ds_fops = {
	.owner		= THIS_MODULE,
	.open		= ds_open,
	.release	= ds_release,
	.ioctl		= ds_ioctl,
	.read		= ds_read,
	.write		= ds_write,
	.poll		= ds_poll,
};

void __init pcmcia_setup_ioctl(void) {
	int i;

	/* Set up character device for user mode clients */
	i = register_chrdev(0, "pcmcia", &ds_fops);
	if (i < 0)
		printk(KERN_NOTICE "unable to find a free device # for "
		       "Driver Services (error=%d)\n", i);
	else
		major_dev = i;

#ifdef CONFIG_PROC_FS
	proc_pccard = proc_mkdir("pccard", proc_bus);
	if (proc_pccard)
		create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
#endif
}


void __exit pcmcia_cleanup_ioctl(void) {
#ifdef CONFIG_PROC_FS
	if (proc_pccard) {
		remove_proc_entry("drivers", proc_pccard);
		remove_proc_entry("pccard", proc_bus);
	}
#endif
	if (major_dev != -1)
		unregister_chrdev(major_dev, "pcmcia");
}
Commit	Line	Data
e7a480d2 DB	1	/*
	2	* pcmcia_ioctl.c -- ioctl interface for cardmgr and cardctl
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License version 2 as
	6	* published by the Free Software Foundation.
	7	*
	8	* The initial developer of the original code is David A. Hinds
	9	* <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
	10	* are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
	11	*
	12	* (C) 1999 David A. Hinds
	13	* (C) 2003 - 2004 Dominik Brodowski
	14	*/
	15
	16	/*
	17	* This file will go away soon.
	18	*/
	19
	20
	21	#include <linux/config.h>
3b659fb8	22	#include <linux/kernel.h>
e7a480d2	23	#include <linux/module.h>
e7a480d2	24	#include <linux/init.h>
e7a480d2	25	#include <linux/major.h>
e7a480d2	26	#include <linux/errno.h>
e7a480d2 DB	27	#include <linux/ioctl.h>
	28	#include <linux/proc_fs.h>
	29	#include <linux/poll.h>
	30	#include <linux/pci.h>
e7a480d2	31	#include <linux/workqueue.h>
e7a480d2 DB	32
e7a480d2 DB	33	#define IN_CARD_SERVICES
e7a480d2 DB	34	#include <pcmcia/cs_types.h>
e7a480d2 DB	35	#include <pcmcia/cs.h>
e7a480d2 DB	36	#include <pcmcia/cistpl.h>
	37	#include <pcmcia/ds.h>
	38	#include <pcmcia/ss.h>
	39
	40	#include "cs_internal.h"
	41	#include "ds_internal.h"
	42
	43	static int major_dev = -1;
	44
	45
	46	/* Device user information */
	47	#define MAX_EVENTS 32
	48	#define USER_MAGIC 0x7ea4
	49	#define CHECK_USER(u) \
	50	(((u) == NULL) \|\| ((u)->user_magic != USER_MAGIC))
	51
	52	typedef struct user_info_t {
	53	u_int user_magic;
	54	int event_head, event_tail;
	55	event_t event[MAX_EVENTS];
	56	struct user_info_t *next;
dc109497	57	struct pcmcia_socket *socket;
e7a480d2 DB	58	} user_info_t;
	59
	60
	61	#ifdef DEBUG
	62	extern int ds_pc_debug;
	63	#define cs_socket_name(skt) ((skt)->dev.class_id)
	64
	65	#define ds_dbg(lvl, fmt, arg...) do { \
	66	if (ds_pc_debug >= lvl) \
	67	printk(KERN_DEBUG "ds: " fmt , ## arg); \
	68	} while (0)
	69	#else
	70	#define ds_dbg(lvl, fmt, arg...) do { } while (0)
	71	#endif
	72
	73
e7a480d2 DB	74	/* backwards-compatible accessing of driver --- by name! */
	75
	76	static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info)
	77	{
	78	struct device_driver *drv;
	79	struct pcmcia_driver *p_drv;
	80
	81	drv = driver_find((char *) dev_info, &pcmcia_bus_type);
	82	if (!drv)
	83	return NULL;
	84
	85	p_drv = container_of(drv, struct pcmcia_driver, drv);
	86
	87	return (p_drv);
	88	}
	89
	90
	91	#ifdef CONFIG_PROC_FS
	92	static struct proc_dir_entry *proc_pccard = NULL;
	93
	94	static int proc_read_drivers_callback(struct device_driver driver, void d)
	95	{
	96	char **p = d;
	97	struct pcmcia_driver *p_drv = container_of(driver,
	98	struct pcmcia_driver, drv);
	99
	100	p += sprintf(p, "%-24.24s 1 %d\n", p_drv->drv.name,
	101	#ifdef CONFIG_MODULE_UNLOAD
	102	(p_drv->owner) ? module_refcount(p_drv->owner) : 1
	103	#else
	104	1
	105	#endif
	106	);
	107	d = (void *) p;
	108
	109	return 0;
	110	}
	111
	112	static int proc_read_drivers(char buf, char *start, off_t pos,
	113	int count, int eof, void data)
	114	{
	115	char *p = buf;
	116
	117	bus_for_each_drv(&pcmcia_bus_type, NULL,
	118	(void *) &p, proc_read_drivers_callback);
	119
	120	return (p - buf);
	121	}
	122	#endif
	123
	124	/*======================================================================
	125
	126	These manage a ring buffer of events pending for one user process
	127
	128	======================================================================*/
	129
	130
	131	static int queue_empty(user_info_t *user)
	132	{
	133	return (user->event_head == user->event_tail);
	134	}
	135
	136	static event_t get_queued_event(user_info_t *user)
	137	{
138	user->event_tail = (user->event_tail+1) % MAX_EVENTS;
139	return user->event[user->event_tail];
140	}
141
142	static void queue_event(user_info_t *user, event_t event)
143	{
144	user->event_head = (user->event_head+1) % MAX_EVENTS;
145	if (user->event_head == user->event_tail)
146	user->event_tail = (user->event_tail+1) % MAX_EVENTS;
147	user->event[user->event_head] = event;
148	}
149
dc109497	150	void handle_event(struct pcmcia_socket *s, event_t event)
e7a480d2 DB	151	{
	152	user_info_t *user;
	153	for (user = s->user; user; user = user->next)
	154	queue_event(user, event);
	155	wake_up_interruptible(&s->queue);
	156	}
	157
	158
	159	/*======================================================================
	160
	161	bind_request() and bind_device() are merged by now. Register_client()
	162	is called right at the end of bind_request(), during the driver's
	163	->attach() call. Individual descriptions:
	164
	165	bind_request() connects a socket to a particular client driver.
	166	It looks up the specified device ID in the list of registered
	167	drivers, binds it to the socket, and tries to create an instance
	168	of the device. unbind_request() deletes a driver instance.
	169
	170	Bind_device() associates a device driver with a particular socket.
	171	It is normally called by Driver Services after it has identified
	172	a newly inserted card. An instance of that driver will then be
	173	eligible to register as a client of this socket.
	174
	175	Register_client() uses the dev_info_t handle to match the
	176	caller with a socket. The driver must have already been bound
	177	to a socket with bind_device() -- in fact, bind_device()
	178	allocates the client structure that will be used.
	179
	180	======================================================================*/
	181
dc109497	182	static int bind_request(struct pcmcia_socket s, bind_info_t bind_info)
e7a480d2 DB	183	{
	184	struct pcmcia_driver *p_drv;
	185	struct pcmcia_device *p_dev;
	186	int ret = 0;
	187	unsigned long flags;
	188
dc109497	189	s = pcmcia_get_socket(s);
e7a480d2 DB	190	if (!s)
	191	return -EINVAL;
	192
dc109497	193	ds_dbg(2, "bind_request(%d, '%s')\n", s->sock,
e7a480d2 DB	194	(char *)bind_info->dev_info);
	195
	196	p_drv = get_pcmcia_driver(&bind_info->dev_info);
	197	if (!p_drv) {
	198	ret = -EINVAL;
	199	goto err_put;
	200	}
	201
	202	if (!try_module_get(p_drv->owner)) {
	203	ret = -EINVAL;
	204	goto err_put_driver;
	205	}
	206
	207	spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
	208	list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
	209	if (p_dev->func == bind_info->function) {
	210	if ((p_dev->dev.driver == &p_drv->drv)) {
	211	if (p_dev->cardmgr) {
	212	/* if there's already a device
	213	* registered, and it was registered
	214	* by userspace before, we need to
	215	* return the "instance". */
	216	spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
	217	bind_info->instance = p_dev->instance;
	218	ret = -EBUSY;
	219	goto err_put_module;
	220	} else {
	221	/* the correct driver managed to bind
	222	* itself magically to the correct
	223	* device. */
	224	spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
	225	p_dev->cardmgr = p_drv;
	226	ret = 0;
	227	goto err_put_module;
	228	}
	229	} else if (!p_dev->dev.driver) {
	230	/* there's already a device available where
	231	* no device has been bound to yet. So we don't
	232	* need to register a device! */
	233	spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
	234	goto rescan;
	235	}
	236	}
	237	}
	238	spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
	239
	240	p_dev = pcmcia_device_add(s, bind_info->function);
	241	if (!p_dev) {
	242	ret = -EIO;
	243	goto err_put_module;
	244	}
	245
	246	rescan:
	247	p_dev->cardmgr = p_drv;
	248
	249	/* if a driver is already running, we can abort */
	250	if (p_dev->dev.driver)
	251	goto err_put_module;
	252
	253	/*
	254	* Prevent this racing with a card insertion.
	255	*/
dc109497	256	down(&s->skt_sem);
e7a480d2	257	bus_rescan_devices(&pcmcia_bus_type);
dc109497	258	up(&s->skt_sem);
e7a480d2 DB	259
	260	/* check whether the driver indeed matched. I don't care if this
	261	* is racy or not, because it can only happen on cardmgr access
	262	* paths...
	263	*/
	264	if (!(p_dev->dev.driver == &p_drv->drv))
	265	p_dev->cardmgr = NULL;
	266
	267	err_put_module:
	268	module_put(p_drv->owner);
	269	err_put_driver:
	270	put_driver(&p_drv->drv);
	271	err_put:
dc109497	272	pcmcia_put_socket(s);
e7a480d2 DB	273
	274	return (ret);
	275	} /* bind_request */
	276
33519ddd DB	277	#ifdef CONFIG_CARDBUS
	278
	279	static struct pci_bus pcmcia_lookup_bus(struct pcmcia_socket s)
	280	{
	281	if (!s \|\| !(s->state & SOCKET_CARDBUS))
	282	return NULL;
e7a480d2	283
33519ddd DB	284	return s->cb_dev->subordinate;
	285	}
	286	#endif
e7a480d2	287
dc109497	288	static int get_device_info(struct pcmcia_socket s, bind_info_t bind_info, int first)
e7a480d2 DB	289	{
	290	dev_node_t *node;
	291	struct pcmcia_device *p_dev;
	292	unsigned long flags;
	293	int ret = 0;
	294
	295	#ifdef CONFIG_CARDBUS
	296	/*
	297	* Some unbelievably ugly code to associate the PCI cardbus
	298	* device and its driver with the PCMCIA "bind" information.
	299	*/
	300	{
	301	struct pci_bus *bus;
	302
dc109497	303	bus = pcmcia_lookup_bus(s);
e7a480d2 DB	304	if (bus) {
	305	struct list_head *list;
	306	struct pci_dev *dev = NULL;
	307
	308	list = bus->devices.next;
	309	while (list != &bus->devices) {
	310	struct pci_dev *pdev = pci_dev_b(list);
	311	list = list->next;
	312
	313	if (first) {
	314	dev = pdev;
	315	break;
	316	}
	317
	318	/* Try to handle "next" here some way? */
	319	}
	320	if (dev && dev->driver) {
	321	strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
	322	bind_info->major = 0;
	323	bind_info->minor = 0;
	324	bind_info->next = NULL;
	325	return 0;
	326	}
	327	}
	328	}
	329	#endif
	330
	331	spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
	332	list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
	333	if (p_dev->func == bind_info->function) {
	334	p_dev = pcmcia_get_dev(p_dev);
	335	if (!p_dev)
	336	continue;
	337	goto found;
	338	}
	339	}
	340	spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
	341	return -ENODEV;
	342
	343	found:
	344	spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
	345
	346	if ((!p_dev->instance) \|\|
	347	(p_dev->instance->state & DEV_CONFIG_PENDING)) {
	348	ret = -EAGAIN;
	349	goto err_put;
	350	}
	351
	352	if (first)
	353	node = p_dev->instance->dev;
	354	else
	355	for (node = p_dev->instance->dev; node; node = node->next)
	356	if (node == bind_info->next)
	357	break;
	358	if (!node) {
	359	ret = -ENODEV;
	360	goto err_put;
	361	}
	362
	363	strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
	364	bind_info->major = node->major;
	365	bind_info->minor = node->minor;
	366	bind_info->next = node->next;
	367
368	err_put:
369	pcmcia_put_dev(p_dev);
370	return (ret);
371	} /* get_device_info */
372
373
374	static int ds_open(struct inode inode, struct file file)
375	{
376	socket_t i = iminor(inode);
dc109497	377	struct pcmcia_socket *s;
e7a480d2 DB	378	user_info_t *user;
	379
	380	ds_dbg(0, "ds_open(socket %d)\n", i);
	381
dc109497	382	s = pcmcia_get_socket_by_nr(i);
e7a480d2 DB	383	if (!s)
e7a480d2 DB	384	return -ENODEV;
dc109497	385	s = pcmcia_get_socket(s);
e7a480d2 DB	386	if (!s)
	387	return -ENODEV;
	388
	389	if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
b5e43913	390	if (s->pcmcia_state.busy) {
dc109497	391	pcmcia_put_socket(s);
e7a480d2 DB	392	return -EBUSY;
	393	}
	394	else
b5e43913	395	s->pcmcia_state.busy = 1;
e7a480d2 DB	396	}
	397
	398	user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
	399	if (!user) {
dc109497	400	pcmcia_put_socket(s);
e7a480d2 DB	401	return -ENOMEM;
	402	}
	403	user->event_tail = user->event_head = 0;
	404	user->next = s->user;
	405	user->user_magic = USER_MAGIC;
	406	user->socket = s;
	407	s->user = user;
	408	file->private_data = user;
	409
b5e43913	410	if (s->pcmcia_state.present)
e7a480d2 DB	411	queue_event(user, CS_EVENT_CARD_INSERTION);
	412	return 0;
	413	} /* ds_open */
	414
	415	/====================================================================/
	416
	417	static int ds_release(struct inode inode, struct file file)
	418	{
dc109497	419	struct pcmcia_socket *s;
e7a480d2 DB	420	user_info_t user, *link;
	421
	422	ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
	423
	424	user = file->private_data;
	425	if (CHECK_USER(user))
	426	goto out;
	427
	428	s = user->socket;
	429
	430	/* Unlink user data structure */
	431	if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
b5e43913	432	s->pcmcia_state.busy = 0;
e7a480d2 DB	433	}
	434	file->private_data = NULL;
	435	for (link = &s->user; link; link = &(link)->next)
	436	if (*link == user) break;
	437	if (link == NULL)
	438	goto out;
	439	*link = user->next;
	440	user->user_magic = 0;
	441	kfree(user);
dc109497	442	pcmcia_put_socket(s);
e7a480d2 DB	443	out:
	444	return 0;
	445	} /* ds_release */
	446
	447	/====================================================================/
	448
	449	static ssize_t ds_read(struct file file, char __user buf,
	450	size_t count, loff_t *ppos)
	451	{
dc109497	452	struct pcmcia_socket *s;
e7a480d2 DB	453	user_info_t *user;
	454	int ret;
	455
	456	ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));
	457
	458	if (count < 4)
	459	return -EINVAL;
	460
	461	user = file->private_data;
	462	if (CHECK_USER(user))
	463	return -EIO;
	464
	465	s = user->socket;
b5e43913	466	if (s->pcmcia_state.dead)
e7a480d2 DB	467	return -EIO;
	468
	469	ret = wait_event_interruptible(s->queue, !queue_empty(user));
	470	if (ret == 0)
	471	ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
	472
	473	return ret;
	474	} /* ds_read */
	475
	476	/====================================================================/
	477
	478	static ssize_t ds_write(struct file file, const char __user buf,
	479	size_t count, loff_t *ppos)
	480	{
	481	ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));
	482
	483	if (count != 4)
	484	return -EINVAL;
	485	if ((file->f_flags & O_ACCMODE) == O_RDONLY)
	486	return -EBADF;
	487
	488	return -EIO;
	489	} /* ds_write */
	490
	491	/====================================================================/
	492
	493	/* No kernel lock - fine */
	494	static u_int ds_poll(struct file file, poll_table wait)
	495	{
dc109497	496	struct pcmcia_socket *s;
e7a480d2 DB	497	user_info_t *user;
	498
	499	ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
	500
	501	user = file->private_data;
	502	if (CHECK_USER(user))
	503	return POLLERR;
	504	s = user->socket;
	505	/*
	506	* We don't check for a dead socket here since that
	507	* will send cardmgr into an endless spin.
	508	*/
	509	poll_wait(file, &s->queue, wait);
	510	if (!queue_empty(user))
	511	return POLLIN \| POLLRDNORM;
	512	return 0;
	513	} /* ds_poll */
	514
	515	/====================================================================/
	516
	517	extern int pcmcia_adjust_resource_info(adjust_t *adj);
	518
	519	static int ds_ioctl(struct inode * inode, struct file * file,
	520	u_int cmd, u_long arg)
	521	{
dc109497	522	struct pcmcia_socket *s;
e7a480d2 DB	523	void __user uarg = (char __user )arg;
	524	u_int size;
	525	int ret, err;
	526	ds_ioctl_arg_t *buf;
	527	user_info_t *user;
	528
	529	ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
	530
	531	user = file->private_data;
	532	if (CHECK_USER(user))
	533	return -EIO;
	534
	535	s = user->socket;
b5e43913	536	if (s->pcmcia_state.dead)
e7a480d2 DB	537	return -EIO;
	538
	539	size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
	540	if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
	541
	542	/* Permission check */
	543	if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
	544	return -EPERM;
	545
	546	if (cmd & IOC_IN) {
	547	if (!access_ok(VERIFY_READ, uarg, size)) {
	548	ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
	549	return -EFAULT;
	550	}
	551	}
	552	if (cmd & IOC_OUT) {
	553	if (!access_ok(VERIFY_WRITE, uarg, size)) {
	554	ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
	555	return -EFAULT;
	556	}
	557	}
	558	buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
	559	if (!buf)
	560	return -ENOMEM;
	561
	562	err = ret = 0;
	563
	564	if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size);
	565
	566	switch (cmd) {
	567	case DS_ADJUST_RESOURCE_INFO:
	568	ret = pcmcia_adjust_resource_info(&buf->adjust);
	569	break;
e7a480d2 DB	570	case DS_GET_CONFIGURATION_INFO:
e7a480d2 DB	571	if (buf->config.Function &&
dc109497	572	(buf->config.Function >= s->functions))
e7a480d2 DB	573	ret = CS_BAD_ARGS;
e7a480d2 DB	574	else
dc109497	575	ret = pccard_get_configuration_info(s,
e7a480d2 DB	576	buf->config.Function, &buf->config);
	577	break;
	578	case DS_GET_FIRST_TUPLE:
dc109497 DB	579	down(&s->skt_sem);
	580	pcmcia_validate_mem(s);
	581	up(&s->skt_sem);
	582	ret = pccard_get_first_tuple(s, BIND_FN_ALL, &buf->tuple);
e7a480d2 DB	583	break;
e7a480d2 DB	584	case DS_GET_NEXT_TUPLE:
dc109497	585	ret = pccard_get_next_tuple(s, BIND_FN_ALL, &buf->tuple);
e7a480d2 DB	586	break;
	587	case DS_GET_TUPLE_DATA:
	588	buf->tuple.TupleData = buf->tuple_parse.data;
	589	buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
dc109497	590	ret = pccard_get_tuple_data(s, &buf->tuple);
e7a480d2 DB	591	break;
	592	case DS_PARSE_TUPLE:
	593	buf->tuple.TupleData = buf->tuple_parse.data;
	594	ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
	595	break;
	596	case DS_RESET_CARD:
dc109497	597	ret = pccard_reset_card(s);
e7a480d2 DB	598	break;
	599	case DS_GET_STATUS:
	600	if (buf->status.Function &&
dc109497	601	(buf->status.Function >= s->functions))
e7a480d2 DB	602	ret = CS_BAD_ARGS;
e7a480d2 DB	603	else
dc109497	604	ret = pccard_get_status(s, buf->status.Function, &buf->status);
e7a480d2 DB	605	break;
e7a480d2 DB	606	case DS_VALIDATE_CIS:
dc109497 DB	607	down(&s->skt_sem);
	608	pcmcia_validate_mem(s);
	609	up(&s->skt_sem);
	610	ret = pccard_validate_cis(s, BIND_FN_ALL, &buf->cisinfo);
e7a480d2 DB	611	break;
e7a480d2 DB	612	case DS_SUSPEND_CARD:
dc109497	613	ret = pcmcia_suspend_card(s);
e7a480d2 DB	614	break;
e7a480d2 DB	615	case DS_RESUME_CARD:
dc109497	616	ret = pcmcia_resume_card(s);
e7a480d2 DB	617	break;
e7a480d2 DB	618	case DS_EJECT_CARD:
dc109497	619	err = pcmcia_eject_card(s);
e7a480d2 DB	620	break;
e7a480d2 DB	621	case DS_INSERT_CARD:
dc109497	622	err = pcmcia_insert_card(s);
e7a480d2 DB	623	break;
	624	case DS_ACCESS_CONFIGURATION_REGISTER:
	625	if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
	626	err = -EPERM;
	627	goto free_out;
	628	}
	629	if (buf->conf_reg.Function &&
dc109497	630	(buf->conf_reg.Function >= s->functions))
e7a480d2 DB	631	ret = CS_BAD_ARGS;
e7a480d2 DB	632	else
dc109497	633	ret = pccard_access_configuration_register(s,
e7a480d2 DB	634	buf->conf_reg.Function, &buf->conf_reg);
	635	break;
	636	case DS_GET_FIRST_REGION:
	637	case DS_GET_NEXT_REGION:
	638	case DS_BIND_MTD:
	639	if (!capable(CAP_SYS_ADMIN)) {
	640	err = -EPERM;
	641	goto free_out;
	642	} else {
	643	static int printed = 0;
	644	if (!printed) {
	645	printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
	646	printk(KERN_WARNING "MTD handling any more.\n");
	647	printed++;
	648	}
	649	}
	650	err = -EINVAL;
	651	goto free_out;
	652	break;
	653	case DS_GET_FIRST_WINDOW:
dc109497	654	ret = pcmcia_get_window(s, &buf->win_info.handle, 0,
e7a480d2 DB	655	&buf->win_info.window);
	656	break;
	657	case DS_GET_NEXT_WINDOW:
dc109497	658	ret = pcmcia_get_window(s, &buf->win_info.handle,
e7a480d2 DB	659	buf->win_info.handle->index + 1, &buf->win_info.window);
	660	break;
	661	case DS_GET_MEM_PAGE:
	662	ret = pcmcia_get_mem_page(buf->win_info.handle,
	663	&buf->win_info.map);
	664	break;
	665	case DS_REPLACE_CIS:
dc109497	666	ret = pcmcia_replace_cis(s, &buf->cisdump);
e7a480d2 DB	667	break;
	668	case DS_BIND_REQUEST:
	669	if (!capable(CAP_SYS_ADMIN)) {
	670	err = -EPERM;
	671	goto free_out;
	672	}
	673	err = bind_request(s, &buf->bind_info);
	674	break;
	675	case DS_GET_DEVICE_INFO:
	676	err = get_device_info(s, &buf->bind_info, 1);
	677	break;
	678	case DS_GET_NEXT_DEVICE:
	679	err = get_device_info(s, &buf->bind_info, 0);
	680	break;
	681	case DS_UNBIND_REQUEST:
	682	err = 0;
	683	break;
	684	default:
	685	err = -EINVAL;
	686	}
	687
	688	if ((err == 0) && (ret != CS_SUCCESS)) {
	689	ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
	690	switch (ret) {
	691	case CS_BAD_SOCKET: case CS_NO_CARD:
	692	err = -ENODEV; break;
	693	case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
	694	case CS_BAD_TUPLE:
	695	err = -EINVAL; break;
	696	case CS_IN_USE:
	697	err = -EBUSY; break;
	698	case CS_OUT_OF_RESOURCE:
	699	err = -ENOSPC; break;
	700	case CS_NO_MORE_ITEMS:
	701	err = -ENODATA; break;
	702	case CS_UNSUPPORTED_FUNCTION:
	703	err = -ENOSYS; break;
	704	default:
	705	err = -EIO; break;
	706	}
	707	}
	708
	709	if (cmd & IOC_OUT) {
	710	if (__copy_to_user(uarg, (char *)buf, size))
	711	err = -EFAULT;
	712	}
	713
	714	free_out:
	715	kfree(buf);
	716	return err;
	717	} /* ds_ioctl */
	718
	719	/====================================================================/
	720
	721	static struct file_operations ds_fops = {
	722	.owner = THIS_MODULE,
	723	.open = ds_open,
	724	.release = ds_release,
	725	.ioctl = ds_ioctl,
	726	.read = ds_read,
	727	.write = ds_write,
	728	.poll = ds_poll,
	729	};
	730
731	void __init pcmcia_setup_ioctl(void) {
732	int i;
733
734	/* Set up character device for user mode clients */
735	i = register_chrdev(0, "pcmcia", &ds_fops);
1a8ceafc	736	if (i < 0)
e7a480d2	737	printk(KERN_NOTICE "unable to find a free device # for "
1a8ceafc	738	"Driver Services (error=%d)\n", i);
e7a480d2 DB	739	else
	740	major_dev = i;
	741
	742	#ifdef CONFIG_PROC_FS
	743	proc_pccard = proc_mkdir("pccard", proc_bus);
	744	if (proc_pccard)
	745	create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
	746	#endif
	747	}
	748
	749
	750	void __exit pcmcia_cleanup_ioctl(void) {
	751	#ifdef CONFIG_PROC_FS
	752	if (proc_pccard) {
	753	remove_proc_entry("drivers", proc_pccard);
	754	remove_proc_entry("pccard", proc_bus);
	755	}
	756	#endif
	757	if (major_dev != -1)
	758	unregister_chrdev(major_dev, "pcmcia");
	759	}