2 * pcmcia_ioctl.c -- ioctl interface for cardmgr and cardctl
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.
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.
12 * (C) 1999 David A. Hinds
13 * (C) 2003 - 2004 Dominik Brodowski
17 * This file will go away soon.
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/major.h>
25 #include <linux/errno.h>
26 #include <linux/ioctl.h>
27 #include <linux/proc_fs.h>
28 #include <linux/poll.h>
29 #include <linux/pci.h>
30 #include <linux/seq_file.h>
31 #include <linux/smp_lock.h>
32 #include <linux/workqueue.h>
34 #include <pcmcia/cs_types.h>
35 #include <pcmcia/cs.h>
36 #include <pcmcia/cistpl.h>
37 #include <pcmcia/cisreg.h>
38 #include <pcmcia/ds.h>
39 #include <pcmcia/ss.h>
41 #include "cs_internal.h"
43 static int major_dev = -1;
46 /* Device user information */
48 #define USER_MAGIC 0x7ea4
49 #define CHECK_USER(u) \
50 (((u) == NULL) || ((u)->user_magic != USER_MAGIC))
52 typedef struct user_info_t {
54 int event_head, event_tail;
55 event_t event[MAX_EVENTS];
56 struct user_info_t *next;
57 struct pcmcia_socket *socket;
61 static struct pcmcia_device *get_pcmcia_device(struct pcmcia_socket *s,
62 unsigned int function)
64 struct pcmcia_device *p_dev = NULL;
67 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
68 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
69 if (p_dev->func == function) {
70 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
71 return pcmcia_get_dev(p_dev);
74 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
78 /* backwards-compatible accessing of driver --- by name! */
80 static struct pcmcia_driver *get_pcmcia_driver(dev_info_t *dev_info)
82 struct device_driver *drv;
83 struct pcmcia_driver *p_drv;
85 drv = driver_find((char *) dev_info, &pcmcia_bus_type);
89 p_drv = container_of(drv, struct pcmcia_driver, drv);
96 static struct proc_dir_entry *proc_pccard = NULL;
98 static int proc_read_drivers_callback(struct device_driver *driver, void *_m)
100 struct seq_file *m = _m;
101 struct pcmcia_driver *p_drv = container_of(driver,
102 struct pcmcia_driver, drv);
104 seq_printf(m, "%-24.24s 1 %d\n", p_drv->drv.name,
105 #ifdef CONFIG_MODULE_UNLOAD
106 (p_drv->owner) ? module_refcount(p_drv->owner) : 1
114 static int pccard_drivers_proc_show(struct seq_file *m, void *v)
116 return bus_for_each_drv(&pcmcia_bus_type, NULL,
117 m, proc_read_drivers_callback);
120 static int pccard_drivers_proc_open(struct inode *inode, struct file *file)
122 return single_open(file, pccard_drivers_proc_show, NULL);
125 static const struct file_operations pccard_drivers_proc_fops = {
126 .owner = THIS_MODULE,
127 .open = pccard_drivers_proc_open,
130 .release = single_release,
135 #ifdef CONFIG_PCMCIA_PROBE
137 static int adjust_irq(struct pcmcia_socket *s, adjust_t *adj)
142 irq = adj->resource.irq.IRQ;
143 if ((irq < 0) || (irq > 15))
146 if (adj->Action != REMOVE_MANAGED_RESOURCE)
151 if (!(s->irq_mask & mask))
154 s->irq_mask &= ~mask;
161 static inline int adjust_irq(struct pcmcia_socket *s, adjust_t *adj) {
167 static int pcmcia_adjust_resource_info(adjust_t *adj)
169 struct pcmcia_socket *s;
173 down_read(&pcmcia_socket_list_rwsem);
174 list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
176 if (adj->Resource == RES_IRQ)
177 ret = adjust_irq(s, adj);
179 else if (s->resource_ops->add_io) {
180 unsigned long begin, end;
182 /* you can't use the old interface if the new
183 * one was used before */
184 spin_lock_irqsave(&s->lock, flags);
185 if ((s->resource_setup_new) &&
186 !(s->resource_setup_old)) {
187 spin_unlock_irqrestore(&s->lock, flags);
189 } else if (!(s->resource_setup_old))
190 s->resource_setup_old = 1;
191 spin_unlock_irqrestore(&s->lock, flags);
193 switch (adj->Resource) {
194 case RES_MEMORY_RANGE:
195 begin = adj->resource.memory.Base;
196 end = adj->resource.memory.Base + adj->resource.memory.Size - 1;
197 if (s->resource_ops->add_mem)
198 ret =s->resource_ops->add_mem(s, adj->Action, begin, end);
200 begin = adj->resource.io.BasePort;
201 end = adj->resource.io.BasePort + adj->resource.io.NumPorts - 1;
202 if (s->resource_ops->add_io)
203 ret = s->resource_ops->add_io(s, adj->Action, begin, end);
206 /* as there's no way we know this is the
207 * last call to adjust_resource_info, we
208 * always need to assume this is the latest
210 spin_lock_irqsave(&s->lock, flags);
211 s->resource_setup_done = 1;
212 spin_unlock_irqrestore(&s->lock, flags);
216 up_read(&pcmcia_socket_list_rwsem);
222 /** pcmcia_get_window
224 static int pcmcia_get_window(struct pcmcia_socket *s, window_handle_t *wh_out,
225 window_handle_t wh, win_req_t *req)
231 if (!s || !(s->state & SOCKET_PRESENT))
235 for (w = wh; w < MAX_WIN; w++)
236 if (s->state & SOCKET_WIN_REQ(w))
241 req->Base = win->res->start;
242 req->Size = win->res->end - win->res->start + 1;
243 req->AccessSpeed = win->speed;
245 if (win->flags & MAP_ATTRIB)
246 req->Attributes |= WIN_MEMORY_TYPE_AM;
247 if (win->flags & MAP_ACTIVE)
248 req->Attributes |= WIN_ENABLE;
249 if (win->flags & MAP_16BIT)
250 req->Attributes |= WIN_DATA_WIDTH_16;
251 if (win->flags & MAP_USE_WAIT)
252 req->Attributes |= WIN_USE_WAIT;
256 } /* pcmcia_get_window */
259 /** pcmcia_get_mem_page
261 * Change the card address of an already open memory window.
263 static int pcmcia_get_mem_page(struct pcmcia_socket *skt, window_handle_t wh,
271 req->CardOffset = skt->win[wh].card_start;
273 } /* pcmcia_get_mem_page */
276 /** pccard_get_status
278 * Get the current socket state bits. We don't support the latched
279 * SocketState yet: I haven't seen any point for it.
282 static int pccard_get_status(struct pcmcia_socket *s,
283 struct pcmcia_device *p_dev,
289 s->ops->get_status(s, &val);
290 status->CardState = status->SocketState = 0;
291 status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
292 status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
293 status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
294 status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
295 if (s->state & SOCKET_SUSPEND)
296 status->CardState |= CS_EVENT_PM_SUSPEND;
297 if (!(s->state & SOCKET_PRESENT))
300 c = (p_dev) ? p_dev->function_config : NULL;
302 if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
303 (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
305 if (c->CardValues & PRESENT_PIN_REPLACE) {
306 pcmcia_read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, ®);
308 (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
310 (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
312 (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
314 (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
316 /* No PRR? Then assume we're always ready */
317 status->CardState |= CS_EVENT_READY_CHANGE;
319 if (c->CardValues & PRESENT_EXT_STATUS) {
320 pcmcia_read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, ®);
322 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
327 (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
329 (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
331 (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
333 (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
335 } /* pccard_get_status */
337 static int pccard_get_configuration_info(struct pcmcia_socket *s,
338 struct pcmcia_device *p_dev,
339 config_info_t *config)
343 if (!(s->state & SOCKET_PRESENT))
347 #ifdef CONFIG_CARDBUS
348 if (s->state & SOCKET_CARDBUS) {
349 memset(config, 0, sizeof(config_info_t));
350 config->Vcc = s->socket.Vcc;
351 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
352 config->Option = s->cb_dev->subordinate->number;
353 if (s->state & SOCKET_CARDBUS_CONFIG) {
354 config->Attributes = CONF_VALID_CLIENT;
355 config->IntType = INT_CARDBUS;
356 config->AssignedIRQ = s->irq.AssignedIRQ;
357 if (config->AssignedIRQ)
358 config->Attributes |= CONF_ENABLE_IRQ;
360 config->BasePort1 = s->io[0].res->start;
361 config->NumPorts1 = s->io[0].res->end -
362 config->BasePort1 + 1;
370 c = p_dev->function_config;
371 config->Function = p_dev->func;
374 config->Function = 0;
377 if ((c == NULL) || !(c->state & CONFIG_LOCKED)) {
378 config->Attributes = 0;
379 config->Vcc = s->socket.Vcc;
380 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
384 config->Attributes = c->Attributes | CONF_VALID_CLIENT;
385 config->Vcc = s->socket.Vcc;
386 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
387 config->IntType = c->IntType;
388 config->ConfigBase = c->ConfigBase;
389 config->Status = c->Status;
390 config->Pin = c->Pin;
391 config->Copy = c->Copy;
392 config->Option = c->Option;
393 config->ExtStatus = c->ExtStatus;
394 config->Present = config->CardValues = c->CardValues;
395 config->IRQAttributes = c->irq.Attributes;
396 config->AssignedIRQ = s->irq.AssignedIRQ;
397 config->BasePort1 = c->io.BasePort1;
398 config->NumPorts1 = c->io.NumPorts1;
399 config->Attributes1 = c->io.Attributes1;
400 config->BasePort2 = c->io.BasePort2;
401 config->NumPorts2 = c->io.NumPorts2;
402 config->Attributes2 = c->io.Attributes2;
403 config->IOAddrLines = c->io.IOAddrLines;
406 } /* pccard_get_configuration_info */
409 /*======================================================================
411 These manage a ring buffer of events pending for one user process
413 ======================================================================*/
416 static int queue_empty(user_info_t *user)
418 return (user->event_head == user->event_tail);
421 static event_t get_queued_event(user_info_t *user)
423 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
424 return user->event[user->event_tail];
427 static void queue_event(user_info_t *user, event_t event)
429 user->event_head = (user->event_head+1) % MAX_EVENTS;
430 if (user->event_head == user->event_tail)
431 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
432 user->event[user->event_head] = event;
435 void handle_event(struct pcmcia_socket *s, event_t event)
438 for (user = s->user; user; user = user->next)
439 queue_event(user, event);
440 wake_up_interruptible(&s->queue);
444 /*======================================================================
446 bind_request() and bind_device() are merged by now. Register_client()
447 is called right at the end of bind_request(), during the driver's
448 ->attach() call. Individual descriptions:
450 bind_request() connects a socket to a particular client driver.
451 It looks up the specified device ID in the list of registered
452 drivers, binds it to the socket, and tries to create an instance
453 of the device. unbind_request() deletes a driver instance.
455 Bind_device() associates a device driver with a particular socket.
456 It is normally called by Driver Services after it has identified
457 a newly inserted card. An instance of that driver will then be
458 eligible to register as a client of this socket.
460 Register_client() uses the dev_info_t handle to match the
461 caller with a socket. The driver must have already been bound
462 to a socket with bind_device() -- in fact, bind_device()
463 allocates the client structure that will be used.
465 ======================================================================*/
467 static int bind_request(struct pcmcia_socket *s, bind_info_t *bind_info)
469 struct pcmcia_driver *p_drv;
470 struct pcmcia_device *p_dev;
474 s = pcmcia_get_socket(s);
478 pr_debug("bind_request(%d, '%s')\n", s->sock,
479 (char *)bind_info->dev_info);
481 p_drv = get_pcmcia_driver(&bind_info->dev_info);
487 if (!try_module_get(p_drv->owner)) {
492 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
493 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
494 if (p_dev->func == bind_info->function) {
495 if ((p_dev->dev.driver == &p_drv->drv)) {
496 if (p_dev->cardmgr) {
497 /* if there's already a device
498 * registered, and it was registered
499 * by userspace before, we need to
500 * return the "instance". */
501 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
502 bind_info->instance = p_dev;
506 /* the correct driver managed to bind
507 * itself magically to the correct
509 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
510 p_dev->cardmgr = p_drv;
514 } else if (!p_dev->dev.driver) {
515 /* there's already a device available where
516 * no device has been bound to yet. So we don't
517 * need to register a device! */
518 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
523 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
525 p_dev = pcmcia_device_add(s, bind_info->function);
532 p_dev->cardmgr = p_drv;
534 /* if a driver is already running, we can abort */
535 if (p_dev->dev.driver)
539 * Prevent this racing with a card insertion.
541 mutex_lock(&s->skt_mutex);
542 ret = bus_rescan_devices(&pcmcia_bus_type);
543 mutex_unlock(&s->skt_mutex);
547 /* check whether the driver indeed matched. I don't care if this
548 * is racy or not, because it can only happen on cardmgr access
551 if (!(p_dev->dev.driver == &p_drv->drv))
552 p_dev->cardmgr = NULL;
555 module_put(p_drv->owner);
557 put_driver(&p_drv->drv);
559 pcmcia_put_socket(s);
564 #ifdef CONFIG_CARDBUS
566 static struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
568 if (!s || !(s->state & SOCKET_CARDBUS))
571 return s->cb_dev->subordinate;
575 static int get_device_info(struct pcmcia_socket *s, bind_info_t *bind_info, int first)
578 struct pcmcia_device *p_dev;
579 struct pcmcia_driver *p_drv;
583 #ifdef CONFIG_CARDBUS
585 * Some unbelievably ugly code to associate the PCI cardbus
586 * device and its driver with the PCMCIA "bind" information.
591 bus = pcmcia_lookup_bus(s);
593 struct list_head *list;
594 struct pci_dev *dev = NULL;
596 list = bus->devices.next;
597 while (list != &bus->devices) {
598 struct pci_dev *pdev = pci_dev_b(list);
606 /* Try to handle "next" here some way? */
608 if (dev && dev->driver) {
609 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
610 bind_info->major = 0;
611 bind_info->minor = 0;
612 bind_info->next = NULL;
619 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
620 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
621 if (p_dev->func == bind_info->function) {
622 p_dev = pcmcia_get_dev(p_dev);
628 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
632 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
634 p_drv = to_pcmcia_drv(p_dev->dev.driver);
635 if (p_drv && !p_dev->_locked) {
641 node = p_dev->dev_node;
643 for (node = p_dev->dev_node; node; node = node->next)
644 if (node == bind_info->next)
651 strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
652 bind_info->major = node->major;
653 bind_info->minor = node->minor;
654 bind_info->next = node->next;
657 pcmcia_put_dev(p_dev);
659 } /* get_device_info */
662 static int ds_open(struct inode *inode, struct file *file)
664 socket_t i = iminor(inode);
665 struct pcmcia_socket *s;
667 static int warning_printed = 0;
670 pr_debug("ds_open(socket %d)\n", i);
673 s = pcmcia_get_socket_by_nr(i);
678 s = pcmcia_get_socket(s);
684 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
685 if (s->pcmcia_state.busy) {
686 pcmcia_put_socket(s);
691 s->pcmcia_state.busy = 1;
694 user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
696 pcmcia_put_socket(s);
700 user->event_tail = user->event_head = 0;
701 user->next = s->user;
702 user->user_magic = USER_MAGIC;
705 file->private_data = user;
707 if (!warning_printed) {
708 printk(KERN_INFO "pcmcia: Detected deprecated PCMCIA ioctl "
709 "usage from process: %s.\n", current->comm);
710 printk(KERN_INFO "pcmcia: This interface will soon be removed from "
711 "the kernel; please expect breakage unless you upgrade "
713 printk(KERN_INFO "pcmcia: see http://www.kernel.org/pub/linux/"
714 "utils/kernel/pcmcia/pcmcia.html for details.\n");
718 if (s->pcmcia_state.present)
719 queue_event(user, CS_EVENT_CARD_INSERTION);
725 /*====================================================================*/
727 static int ds_release(struct inode *inode, struct file *file)
729 struct pcmcia_socket *s;
730 user_info_t *user, **link;
732 pr_debug("ds_release(socket %d)\n", iminor(inode));
734 user = file->private_data;
735 if (CHECK_USER(user))
740 /* Unlink user data structure */
741 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
742 s->pcmcia_state.busy = 0;
744 file->private_data = NULL;
745 for (link = &s->user; *link; link = &(*link)->next)
746 if (*link == user) break;
750 user->user_magic = 0;
752 pcmcia_put_socket(s);
757 /*====================================================================*/
759 static ssize_t ds_read(struct file *file, char __user *buf,
760 size_t count, loff_t *ppos)
762 struct pcmcia_socket *s;
766 pr_debug("ds_read(socket %d)\n", iminor(file->f_path.dentry->d_inode));
771 user = file->private_data;
772 if (CHECK_USER(user))
776 if (s->pcmcia_state.dead)
779 ret = wait_event_interruptible(s->queue, !queue_empty(user));
781 ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
786 /*====================================================================*/
788 static ssize_t ds_write(struct file *file, const char __user *buf,
789 size_t count, loff_t *ppos)
791 pr_debug("ds_write(socket %d)\n", iminor(file->f_path.dentry->d_inode));
795 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
801 /*====================================================================*/
803 /* No kernel lock - fine */
804 static u_int ds_poll(struct file *file, poll_table *wait)
806 struct pcmcia_socket *s;
809 pr_debug("ds_poll(socket %d)\n", iminor(file->f_path.dentry->d_inode));
811 user = file->private_data;
812 if (CHECK_USER(user))
816 * We don't check for a dead socket here since that
817 * will send cardmgr into an endless spin.
819 poll_wait(file, &s->queue, wait);
820 if (!queue_empty(user))
821 return POLLIN | POLLRDNORM;
825 /*====================================================================*/
827 static int ds_ioctl(struct inode * inode, struct file * file,
828 u_int cmd, u_long arg)
830 struct pcmcia_socket *s;
831 void __user *uarg = (char __user *)arg;
837 pr_debug("ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
839 user = file->private_data;
840 if (CHECK_USER(user))
844 if (s->pcmcia_state.dead)
847 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
848 if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
850 /* Permission check */
851 if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
855 if (!access_ok(VERIFY_READ, uarg, size)) {
856 pr_debug("ds_ioctl(): verify_read = %d\n", -EFAULT);
861 if (!access_ok(VERIFY_WRITE, uarg, size)) {
862 pr_debug("ds_ioctl(): verify_write = %d\n", -EFAULT);
866 buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
873 if (__copy_from_user((char *)buf, uarg, size)) {
880 case DS_ADJUST_RESOURCE_INFO:
881 ret = pcmcia_adjust_resource_info(&buf->adjust);
883 case DS_GET_CONFIGURATION_INFO:
884 if (buf->config.Function &&
885 (buf->config.Function >= s->functions))
888 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->config.Function);
889 ret = pccard_get_configuration_info(s, p_dev, &buf->config);
890 pcmcia_put_dev(p_dev);
893 case DS_GET_FIRST_TUPLE:
894 mutex_lock(&s->skt_mutex);
895 pcmcia_validate_mem(s);
896 mutex_unlock(&s->skt_mutex);
897 ret = pccard_get_first_tuple(s, BIND_FN_ALL, &buf->tuple);
899 case DS_GET_NEXT_TUPLE:
900 ret = pccard_get_next_tuple(s, BIND_FN_ALL, &buf->tuple);
902 case DS_GET_TUPLE_DATA:
903 buf->tuple.TupleData = buf->tuple_parse.data;
904 buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
905 ret = pccard_get_tuple_data(s, &buf->tuple);
908 buf->tuple.TupleData = buf->tuple_parse.data;
909 ret = pcmcia_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
912 ret = pcmcia_reset_card(s);
915 if (buf->status.Function &&
916 (buf->status.Function >= s->functions))
919 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->status.Function);
920 ret = pccard_get_status(s, p_dev, &buf->status);
921 pcmcia_put_dev(p_dev);
924 case DS_VALIDATE_CIS:
925 mutex_lock(&s->skt_mutex);
926 pcmcia_validate_mem(s);
927 mutex_unlock(&s->skt_mutex);
928 ret = pccard_validate_cis(s, &buf->cisinfo.Chains);
930 case DS_SUSPEND_CARD:
931 ret = pcmcia_suspend_card(s);
934 ret = pcmcia_resume_card(s);
937 err = pcmcia_eject_card(s);
940 err = pcmcia_insert_card(s);
942 case DS_ACCESS_CONFIGURATION_REGISTER:
943 if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
950 if (!(buf->conf_reg.Function &&
951 (buf->conf_reg.Function >= s->functions))) {
952 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->conf_reg.Function);
954 ret = pcmcia_access_configuration_register(p_dev, &buf->conf_reg);
955 pcmcia_put_dev(p_dev);
959 case DS_GET_FIRST_REGION:
960 case DS_GET_NEXT_REGION:
962 if (!capable(CAP_SYS_ADMIN)) {
966 printk_once(KERN_WARNING
967 "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
968 printk_once(KERN_WARNING "MTD handling any more.\n");
973 case DS_GET_FIRST_WINDOW:
974 ret = pcmcia_get_window(s, &buf->win_info.handle, 1,
975 &buf->win_info.window);
977 case DS_GET_NEXT_WINDOW:
978 ret = pcmcia_get_window(s, &buf->win_info.handle,
979 buf->win_info.handle + 1, &buf->win_info.window);
981 case DS_GET_MEM_PAGE:
982 ret = pcmcia_get_mem_page(s, buf->win_info.handle,
986 ret = pcmcia_replace_cis(s, buf->cisdump.Data, buf->cisdump.Length);
988 case DS_BIND_REQUEST:
989 if (!capable(CAP_SYS_ADMIN)) {
993 err = bind_request(s, &buf->bind_info);
995 case DS_GET_DEVICE_INFO:
996 err = get_device_info(s, &buf->bind_info, 1);
998 case DS_GET_NEXT_DEVICE:
999 err = get_device_info(s, &buf->bind_info, 0);
1001 case DS_UNBIND_REQUEST:
1008 if ((err == 0) && (ret != 0)) {
1009 pr_debug("ds_ioctl: ret = %d\n", ret);
1018 err = -ENOSPC; break;
1020 err = -ENODATA; break;
1026 if (cmd & IOC_OUT) {
1027 if (__copy_to_user(uarg, (char *)buf, size))
1036 /*====================================================================*/
1038 static const struct file_operations ds_fops = {
1039 .owner = THIS_MODULE,
1041 .release = ds_release,
1048 void __init pcmcia_setup_ioctl(void) {
1051 /* Set up character device for user mode clients */
1052 i = register_chrdev(0, "pcmcia", &ds_fops);
1054 printk(KERN_NOTICE "unable to find a free device # for "
1055 "Driver Services (error=%d)\n", i);
1059 #ifdef CONFIG_PROC_FS
1060 proc_pccard = proc_mkdir("bus/pccard", NULL);
1062 proc_create("drivers", 0, proc_pccard, &pccard_drivers_proc_fops);
1067 void __exit pcmcia_cleanup_ioctl(void) {
1068 #ifdef CONFIG_PROC_FS
1070 remove_proc_entry("drivers", proc_pccard);
1071 remove_proc_entry("bus/pccard", NULL);
1074 if (major_dev != -1)
1075 unregister_chrdev(major_dev, "pcmcia");