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;
66 mutex_lock(&s->ops_mutex);
67 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
68 if (p_dev->func == function) {
69 mutex_unlock(&s->ops_mutex);
70 return pcmcia_get_dev(p_dev);
73 mutex_unlock(&s->ops_mutex);
77 /* backwards-compatible accessing of driver --- by name! */
79 static struct pcmcia_driver *get_pcmcia_driver(dev_info_t *dev_info)
81 struct device_driver *drv;
82 struct pcmcia_driver *p_drv;
84 drv = driver_find((char *) dev_info, &pcmcia_bus_type);
88 p_drv = container_of(drv, struct pcmcia_driver, drv);
95 static struct proc_dir_entry *proc_pccard;
97 static int proc_read_drivers_callback(struct device_driver *driver, void *_m)
99 struct seq_file *m = _m;
100 struct pcmcia_driver *p_drv = container_of(driver,
101 struct pcmcia_driver, drv);
103 seq_printf(m, "%-24.24s 1 %d\n", p_drv->drv.name,
104 #ifdef CONFIG_MODULE_UNLOAD
105 (p_drv->owner) ? module_refcount(p_drv->owner) : 1
113 static int pccard_drivers_proc_show(struct seq_file *m, void *v)
115 return bus_for_each_drv(&pcmcia_bus_type, NULL,
116 m, proc_read_drivers_callback);
119 static int pccard_drivers_proc_open(struct inode *inode, struct file *file)
121 return single_open(file, pccard_drivers_proc_show, NULL);
124 static const struct file_operations pccard_drivers_proc_fops = {
125 .owner = THIS_MODULE,
126 .open = pccard_drivers_proc_open,
129 .release = single_release,
134 #ifdef CONFIG_PCMCIA_PROBE
136 static int adjust_irq(struct pcmcia_socket *s, adjust_t *adj)
141 irq = adj->resource.irq.IRQ;
142 if ((irq < 0) || (irq > 15))
145 if (adj->Action != REMOVE_MANAGED_RESOURCE)
150 if (!(s->irq_mask & mask))
153 s->irq_mask &= ~mask;
160 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;
172 down_read(&pcmcia_socket_list_rwsem);
173 list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
175 if (adj->Resource == RES_IRQ)
176 ret = adjust_irq(s, adj);
178 else if (s->resource_ops->add_io) {
179 unsigned long begin, end;
181 /* you can't use the old interface if the new
182 * one was used before */
183 mutex_lock(&s->ops_mutex);
184 if ((s->resource_setup_new) &&
185 !(s->resource_setup_old)) {
186 mutex_unlock(&s->ops_mutex);
188 } else if (!(s->resource_setup_old))
189 s->resource_setup_old = 1;
190 mutex_unlock(&s->ops_mutex);
192 switch (adj->Resource) {
193 case RES_MEMORY_RANGE:
194 begin = adj->resource.memory.Base;
195 end = adj->resource.memory.Base + adj->resource.memory.Size - 1;
196 if (s->resource_ops->add_mem)
197 ret = s->resource_ops->add_mem(s, adj->Action, begin, end);
199 begin = adj->resource.io.BasePort;
200 end = adj->resource.io.BasePort + adj->resource.io.NumPorts - 1;
201 if (s->resource_ops->add_io)
202 ret = s->resource_ops->add_io(s, adj->Action, begin, end);
205 /* as there's no way we know this is the
206 * last call to adjust_resource_info, we
207 * always need to assume this is the latest
209 mutex_lock(&s->ops_mutex);
210 s->resource_setup_done = 1;
211 mutex_unlock(&s->ops_mutex);
215 up_read(&pcmcia_socket_list_rwsem);
221 /** pcmcia_get_window
223 static int pcmcia_get_window(struct pcmcia_socket *s, window_handle_t *wh_out,
224 window_handle_t wh, win_req_t *req)
230 if (!s || !(s->state & SOCKET_PRESENT))
234 for (w = wh; w < MAX_WIN; w++)
235 if (s->state & SOCKET_WIN_REQ(w))
240 req->Base = win->res->start;
241 req->Size = win->res->end - win->res->start + 1;
242 req->AccessSpeed = win->speed;
244 if (win->flags & MAP_ATTRIB)
245 req->Attributes |= WIN_MEMORY_TYPE_AM;
246 if (win->flags & MAP_ACTIVE)
247 req->Attributes |= WIN_ENABLE;
248 if (win->flags & MAP_16BIT)
249 req->Attributes |= WIN_DATA_WIDTH_16;
250 if (win->flags & MAP_USE_WAIT)
251 req->Attributes |= WIN_USE_WAIT;
255 } /* pcmcia_get_window */
258 /** pcmcia_get_mem_page
260 * Change the card address of an already open memory window.
262 static int pcmcia_get_mem_page(struct pcmcia_socket *skt, window_handle_t wh,
270 req->CardOffset = skt->win[wh].card_start;
272 } /* pcmcia_get_mem_page */
275 /** pccard_get_status
277 * Get the current socket state bits. We don't support the latched
278 * SocketState yet: I haven't seen any point for it.
281 static int pccard_get_status(struct pcmcia_socket *s,
282 struct pcmcia_device *p_dev,
288 s->ops->get_status(s, &val);
289 status->CardState = status->SocketState = 0;
290 status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
291 status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
292 status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
293 status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
294 if (s->state & SOCKET_SUSPEND)
295 status->CardState |= CS_EVENT_PM_SUSPEND;
296 if (!(s->state & SOCKET_PRESENT))
299 c = (p_dev) ? p_dev->function_config : NULL;
301 if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
302 (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
304 if (c->CardValues & PRESENT_PIN_REPLACE) {
305 pcmcia_read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, ®);
307 (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
309 (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
311 (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
313 (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
315 /* No PRR? Then assume we're always ready */
316 status->CardState |= CS_EVENT_READY_CHANGE;
318 if (c->CardValues & PRESENT_EXT_STATUS) {
319 pcmcia_read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, ®);
321 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
326 (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
328 (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
330 (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
332 (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
334 } /* pccard_get_status */
336 static int pccard_get_configuration_info(struct pcmcia_socket *s,
337 struct pcmcia_device *p_dev,
338 config_info_t *config)
342 if (!(s->state & SOCKET_PRESENT))
346 #ifdef CONFIG_CARDBUS
347 if (s->state & SOCKET_CARDBUS) {
348 memset(config, 0, sizeof(config_info_t));
349 config->Vcc = s->socket.Vcc;
350 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
351 config->Option = s->cb_dev->subordinate->number;
352 if (s->state & SOCKET_CARDBUS_CONFIG) {
353 config->Attributes = CONF_VALID_CLIENT;
354 config->IntType = INT_CARDBUS;
355 config->AssignedIRQ = s->irq.AssignedIRQ;
356 if (config->AssignedIRQ)
357 config->Attributes |= CONF_ENABLE_IRQ;
359 config->BasePort1 = s->io[0].res->start;
360 config->NumPorts1 = s->io[0].res->end -
361 config->BasePort1 + 1;
369 c = p_dev->function_config;
370 config->Function = p_dev->func;
373 config->Function = 0;
376 if ((c == NULL) || !(c->state & CONFIG_LOCKED)) {
377 config->Attributes = 0;
378 config->Vcc = s->socket.Vcc;
379 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
383 config->Attributes = c->Attributes | CONF_VALID_CLIENT;
384 config->Vcc = s->socket.Vcc;
385 config->Vpp1 = config->Vpp2 = s->socket.Vpp;
386 config->IntType = c->IntType;
387 config->ConfigBase = c->ConfigBase;
388 config->Status = c->Status;
389 config->Pin = c->Pin;
390 config->Copy = c->Copy;
391 config->Option = c->Option;
392 config->ExtStatus = c->ExtStatus;
393 config->Present = config->CardValues = c->CardValues;
394 config->IRQAttributes = c->irq.Attributes;
395 config->AssignedIRQ = s->irq.AssignedIRQ;
396 config->BasePort1 = c->io.BasePort1;
397 config->NumPorts1 = c->io.NumPorts1;
398 config->Attributes1 = c->io.Attributes1;
399 config->BasePort2 = c->io.BasePort2;
400 config->NumPorts2 = c->io.NumPorts2;
401 config->Attributes2 = c->io.Attributes2;
402 config->IOAddrLines = c->io.IOAddrLines;
405 } /* pccard_get_configuration_info */
408 /*======================================================================
410 These manage a ring buffer of events pending for one user process
412 ======================================================================*/
415 static int queue_empty(user_info_t *user)
417 return (user->event_head == user->event_tail);
420 static event_t get_queued_event(user_info_t *user)
422 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
423 return user->event[user->event_tail];
426 static void queue_event(user_info_t *user, event_t event)
428 user->event_head = (user->event_head+1) % MAX_EVENTS;
429 if (user->event_head == user->event_tail)
430 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
431 user->event[user->event_head] = event;
434 void handle_event(struct pcmcia_socket *s, event_t event)
437 for (user = s->user; user; user = user->next)
438 queue_event(user, event);
439 wake_up_interruptible(&s->queue);
443 /*======================================================================
445 bind_request() and bind_device() are merged by now. Register_client()
446 is called right at the end of bind_request(), during the driver's
447 ->attach() call. Individual descriptions:
449 bind_request() connects a socket to a particular client driver.
450 It looks up the specified device ID in the list of registered
451 drivers, binds it to the socket, and tries to create an instance
452 of the device. unbind_request() deletes a driver instance.
454 Bind_device() associates a device driver with a particular socket.
455 It is normally called by Driver Services after it has identified
456 a newly inserted card. An instance of that driver will then be
457 eligible to register as a client of this socket.
459 Register_client() uses the dev_info_t handle to match the
460 caller with a socket. The driver must have already been bound
461 to a socket with bind_device() -- in fact, bind_device()
462 allocates the client structure that will be used.
464 ======================================================================*/
466 static int bind_request(struct pcmcia_socket *s, bind_info_t *bind_info)
468 struct pcmcia_driver *p_drv;
469 struct pcmcia_device *p_dev;
472 s = pcmcia_get_socket(s);
476 pr_debug("bind_request(%d, '%s')\n", s->sock,
477 (char *)bind_info->dev_info);
479 p_drv = get_pcmcia_driver(&bind_info->dev_info);
485 if (!try_module_get(p_drv->owner)) {
490 mutex_lock(&s->ops_mutex);
491 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
492 if (p_dev->func == bind_info->function) {
493 if ((p_dev->dev.driver == &p_drv->drv)) {
494 if (p_dev->cardmgr) {
495 /* if there's already a device
496 * registered, and it was registered
497 * by userspace before, we need to
498 * return the "instance". */
499 mutex_unlock(&s->ops_mutex);
500 bind_info->instance = p_dev;
504 /* the correct driver managed to bind
505 * itself magically to the correct
507 mutex_unlock(&s->ops_mutex);
508 p_dev->cardmgr = p_drv;
512 } else if (!p_dev->dev.driver) {
513 /* there's already a device available where
514 * no device has been bound to yet. So we don't
515 * need to register a device! */
516 mutex_unlock(&s->ops_mutex);
521 mutex_unlock(&s->ops_mutex);
523 p_dev = pcmcia_device_add(s, bind_info->function);
530 p_dev->cardmgr = p_drv;
532 /* if a driver is already running, we can abort */
533 if (p_dev->dev.driver)
537 * Prevent this racing with a card insertion.
539 mutex_lock(&s->skt_mutex);
540 ret = bus_rescan_devices(&pcmcia_bus_type);
541 mutex_unlock(&s->skt_mutex);
545 /* check whether the driver indeed matched. I don't care if this
546 * is racy or not, because it can only happen on cardmgr access
549 if (!(p_dev->dev.driver == &p_drv->drv))
550 p_dev->cardmgr = NULL;
553 module_put(p_drv->owner);
555 put_driver(&p_drv->drv);
557 pcmcia_put_socket(s);
562 #ifdef CONFIG_CARDBUS
564 static struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
566 if (!s || !(s->state & SOCKET_CARDBUS))
569 return s->cb_dev->subordinate;
573 static int get_device_info(struct pcmcia_socket *s, bind_info_t *bind_info, int first)
576 struct pcmcia_device *p_dev;
577 struct pcmcia_driver *p_drv;
580 #ifdef CONFIG_CARDBUS
582 * Some unbelievably ugly code to associate the PCI cardbus
583 * device and its driver with the PCMCIA "bind" information.
588 bus = pcmcia_lookup_bus(s);
590 struct list_head *list;
591 struct pci_dev *dev = NULL;
593 list = bus->devices.next;
594 while (list != &bus->devices) {
595 struct pci_dev *pdev = pci_dev_b(list);
603 /* Try to handle "next" here some way? */
605 if (dev && dev->driver) {
606 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
607 bind_info->major = 0;
608 bind_info->minor = 0;
609 bind_info->next = NULL;
616 mutex_lock(&s->ops_mutex);
617 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
618 if (p_dev->func == bind_info->function) {
619 p_dev = pcmcia_get_dev(p_dev);
625 mutex_unlock(&s->ops_mutex);
629 mutex_unlock(&s->ops_mutex);
631 p_drv = to_pcmcia_drv(p_dev->dev.driver);
632 if (p_drv && !p_dev->_locked) {
638 node = p_dev->dev_node;
640 for (node = p_dev->dev_node; node; node = node->next)
641 if (node == bind_info->next)
648 strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
649 bind_info->major = node->major;
650 bind_info->minor = node->minor;
651 bind_info->next = node->next;
654 pcmcia_put_dev(p_dev);
656 } /* get_device_info */
659 static int ds_open(struct inode *inode, struct file *file)
661 socket_t i = iminor(inode);
662 struct pcmcia_socket *s;
664 static int warning_printed;
667 pr_debug("ds_open(socket %d)\n", i);
670 s = pcmcia_get_socket_by_nr(i);
675 s = pcmcia_get_socket(s);
681 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
682 if (s->pcmcia_state.busy) {
683 pcmcia_put_socket(s);
688 s->pcmcia_state.busy = 1;
691 user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
693 pcmcia_put_socket(s);
697 user->event_tail = user->event_head = 0;
698 user->next = s->user;
699 user->user_magic = USER_MAGIC;
702 file->private_data = user;
704 if (!warning_printed) {
705 printk(KERN_INFO "pcmcia: Detected deprecated PCMCIA ioctl "
706 "usage from process: %s.\n", current->comm);
707 printk(KERN_INFO "pcmcia: This interface will soon be removed from "
708 "the kernel; please expect breakage unless you upgrade "
710 printk(KERN_INFO "pcmcia: see http://www.kernel.org/pub/linux/"
711 "utils/kernel/pcmcia/pcmcia.html for details.\n");
715 if (s->pcmcia_state.present)
716 queue_event(user, CS_EVENT_CARD_INSERTION);
722 /*====================================================================*/
724 static int ds_release(struct inode *inode, struct file *file)
726 struct pcmcia_socket *s;
727 user_info_t *user, **link;
729 pr_debug("ds_release(socket %d)\n", iminor(inode));
731 user = file->private_data;
732 if (CHECK_USER(user))
737 /* Unlink user data structure */
738 if ((file->f_flags & O_ACCMODE) != O_RDONLY)
739 s->pcmcia_state.busy = 0;
741 file->private_data = NULL;
742 for (link = &s->user; *link; link = &(*link)->next)
748 user->user_magic = 0;
750 pcmcia_put_socket(s);
755 /*====================================================================*/
757 static ssize_t ds_read(struct file *file, char __user *buf,
758 size_t count, loff_t *ppos)
760 struct pcmcia_socket *s;
764 pr_debug("ds_read(socket %d)\n", iminor(file->f_path.dentry->d_inode));
769 user = file->private_data;
770 if (CHECK_USER(user))
774 if (s->pcmcia_state.dead)
777 ret = wait_event_interruptible(s->queue, !queue_empty(user));
779 ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
784 /*====================================================================*/
786 static ssize_t ds_write(struct file *file, const char __user *buf,
787 size_t count, loff_t *ppos)
789 pr_debug("ds_write(socket %d)\n", iminor(file->f_path.dentry->d_inode));
793 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
799 /*====================================================================*/
801 /* No kernel lock - fine */
802 static u_int ds_poll(struct file *file, poll_table *wait)
804 struct pcmcia_socket *s;
807 pr_debug("ds_poll(socket %d)\n", iminor(file->f_path.dentry->d_inode));
809 user = file->private_data;
810 if (CHECK_USER(user))
814 * We don't check for a dead socket here since that
815 * will send cardmgr into an endless spin.
817 poll_wait(file, &s->queue, wait);
818 if (!queue_empty(user))
819 return POLLIN | POLLRDNORM;
823 /*====================================================================*/
825 static int ds_ioctl(struct inode *inode, struct file *file,
826 u_int cmd, u_long arg)
828 struct pcmcia_socket *s;
829 void __user *uarg = (char __user *)arg;
835 pr_debug("ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
837 user = file->private_data;
838 if (CHECK_USER(user))
842 if (s->pcmcia_state.dead)
845 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
846 if (size > sizeof(ds_ioctl_arg_t))
849 /* Permission check */
850 if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
854 if (!access_ok(VERIFY_READ, uarg, size)) {
855 pr_debug("ds_ioctl(): verify_read = %d\n", -EFAULT);
860 if (!access_ok(VERIFY_WRITE, uarg, size)) {
861 pr_debug("ds_ioctl(): verify_write = %d\n", -EFAULT);
865 buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
872 if (__copy_from_user((char *)buf, uarg, size)) {
879 case DS_ADJUST_RESOURCE_INFO:
880 ret = pcmcia_adjust_resource_info(&buf->adjust);
882 case DS_GET_CONFIGURATION_INFO:
883 if (buf->config.Function &&
884 (buf->config.Function >= s->functions))
887 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->config.Function);
888 ret = pccard_get_configuration_info(s, p_dev, &buf->config);
889 pcmcia_put_dev(p_dev);
892 case DS_GET_FIRST_TUPLE:
893 mutex_lock(&s->skt_mutex);
894 pcmcia_validate_mem(s);
895 mutex_unlock(&s->skt_mutex);
896 ret = pccard_get_first_tuple(s, BIND_FN_ALL, &buf->tuple);
898 case DS_GET_NEXT_TUPLE:
899 ret = pccard_get_next_tuple(s, BIND_FN_ALL, &buf->tuple);
901 case DS_GET_TUPLE_DATA:
902 buf->tuple.TupleData = buf->tuple_parse.data;
903 buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
904 ret = pccard_get_tuple_data(s, &buf->tuple);
907 buf->tuple.TupleData = buf->tuple_parse.data;
908 ret = pcmcia_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
911 ret = pcmcia_reset_card(s);
914 if (buf->status.Function &&
915 (buf->status.Function >= s->functions))
918 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->status.Function);
919 ret = pccard_get_status(s, p_dev, &buf->status);
920 pcmcia_put_dev(p_dev);
923 case DS_VALIDATE_CIS:
924 mutex_lock(&s->skt_mutex);
925 pcmcia_validate_mem(s);
926 mutex_unlock(&s->skt_mutex);
927 ret = pccard_validate_cis(s, &buf->cisinfo.Chains);
929 case DS_SUSPEND_CARD:
930 ret = pcmcia_suspend_card(s);
933 ret = pcmcia_resume_card(s);
936 err = pcmcia_eject_card(s);
939 err = pcmcia_insert_card(s);
941 case DS_ACCESS_CONFIGURATION_REGISTER:
942 if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
949 if (!(buf->conf_reg.Function &&
950 (buf->conf_reg.Function >= s->functions))) {
951 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->conf_reg.Function);
953 ret = pcmcia_access_configuration_register(p_dev, &buf->conf_reg);
954 pcmcia_put_dev(p_dev);
958 case DS_GET_FIRST_REGION:
959 case DS_GET_NEXT_REGION:
961 if (!capable(CAP_SYS_ADMIN)) {
965 printk_once(KERN_WARNING
966 "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
967 printk_once(KERN_WARNING "MTD handling any more.\n");
972 case DS_GET_FIRST_WINDOW:
973 ret = pcmcia_get_window(s, &buf->win_info.handle, 1,
974 &buf->win_info.window);
976 case DS_GET_NEXT_WINDOW:
977 ret = pcmcia_get_window(s, &buf->win_info.handle,
978 buf->win_info.handle + 1, &buf->win_info.window);
980 case DS_GET_MEM_PAGE:
981 ret = pcmcia_get_mem_page(s, buf->win_info.handle,
985 ret = pcmcia_replace_cis(s, buf->cisdump.Data, buf->cisdump.Length);
987 case DS_BIND_REQUEST:
988 if (!capable(CAP_SYS_ADMIN)) {
992 err = bind_request(s, &buf->bind_info);
994 case DS_GET_DEVICE_INFO:
995 err = get_device_info(s, &buf->bind_info, 1);
997 case DS_GET_NEXT_DEVICE:
998 err = get_device_info(s, &buf->bind_info, 0);
1000 case DS_UNBIND_REQUEST:
1007 if ((err == 0) && (ret != 0)) {
1008 pr_debug("ds_ioctl: ret = %d\n", ret);
1017 err = -ENOSPC; break;
1019 err = -ENODATA; break;
1025 if (cmd & IOC_OUT) {
1026 if (__copy_to_user(uarg, (char *)buf, size))
1035 /*====================================================================*/
1037 static const struct file_operations ds_fops = {
1038 .owner = THIS_MODULE,
1040 .release = ds_release,
1047 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)
1069 #ifdef CONFIG_PROC_FS
1071 remove_proc_entry("drivers", proc_pccard);
1072 remove_proc_entry("bus/pccard", NULL);
1075 if (major_dev != -1)
1076 unregister_chrdev(major_dev, "pcmcia");