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/config.h>
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/major.h>
26 #include <linux/errno.h>
27 #include <linux/ioctl.h>
28 #include <linux/proc_fs.h>
29 #include <linux/poll.h>
30 #include <linux/pci.h>
31 #include <linux/workqueue.h>
33 #define IN_CARD_SERVICES
34 #include <pcmcia/version.h>
35 #include <pcmcia/cs_types.h>
36 #include <pcmcia/cs.h>
37 #include <pcmcia/cistpl.h>
38 #include <pcmcia/ds.h>
39 #include <pcmcia/ss.h>
41 #include "cs_internal.h"
42 #include "ds_internal.h"
44 static int major_dev = -1;
47 /* Device user information */
49 #define USER_MAGIC 0x7ea4
50 #define CHECK_USER(u) \
51 (((u) == NULL) || ((u)->user_magic != USER_MAGIC))
53 typedef struct user_info_t {
55 int event_head, event_tail;
56 event_t event[MAX_EVENTS];
57 struct user_info_t *next;
58 struct pcmcia_socket *socket;
63 extern int ds_pc_debug;
64 #define cs_socket_name(skt) ((skt)->dev.class_id)
66 #define ds_dbg(lvl, fmt, arg...) do { \
67 if (ds_pc_debug >= lvl) \
68 printk(KERN_DEBUG "ds: " fmt , ## arg); \
71 #define ds_dbg(lvl, fmt, arg...) do { } while (0)
75 /* backwards-compatible accessing of driver --- by name! */
77 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info)
79 struct device_driver *drv;
80 struct pcmcia_driver *p_drv;
82 drv = driver_find((char *) dev_info, &pcmcia_bus_type);
86 p_drv = container_of(drv, struct pcmcia_driver, drv);
93 static struct proc_dir_entry *proc_pccard = NULL;
95 static int proc_read_drivers_callback(struct device_driver *driver, void *d)
98 struct pcmcia_driver *p_drv = container_of(driver,
99 struct pcmcia_driver, drv);
101 *p += sprintf(*p, "%-24.24s 1 %d\n", p_drv->drv.name,
102 #ifdef CONFIG_MODULE_UNLOAD
103 (p_drv->owner) ? module_refcount(p_drv->owner) : 1
113 static int proc_read_drivers(char *buf, char **start, off_t pos,
114 int count, int *eof, void *data)
118 bus_for_each_drv(&pcmcia_bus_type, NULL,
119 (void *) &p, proc_read_drivers_callback);
125 /*======================================================================
127 These manage a ring buffer of events pending for one user process
129 ======================================================================*/
132 static int queue_empty(user_info_t *user)
134 return (user->event_head == user->event_tail);
137 static event_t get_queued_event(user_info_t *user)
139 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
140 return user->event[user->event_tail];
143 static void queue_event(user_info_t *user, event_t event)
145 user->event_head = (user->event_head+1) % MAX_EVENTS;
146 if (user->event_head == user->event_tail)
147 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
148 user->event[user->event_head] = event;
151 void handle_event(struct pcmcia_socket *s, event_t event)
154 for (user = s->user; user; user = user->next)
155 queue_event(user, event);
156 wake_up_interruptible(&s->queue);
160 /*======================================================================
162 bind_request() and bind_device() are merged by now. Register_client()
163 is called right at the end of bind_request(), during the driver's
164 ->attach() call. Individual descriptions:
166 bind_request() connects a socket to a particular client driver.
167 It looks up the specified device ID in the list of registered
168 drivers, binds it to the socket, and tries to create an instance
169 of the device. unbind_request() deletes a driver instance.
171 Bind_device() associates a device driver with a particular socket.
172 It is normally called by Driver Services after it has identified
173 a newly inserted card. An instance of that driver will then be
174 eligible to register as a client of this socket.
176 Register_client() uses the dev_info_t handle to match the
177 caller with a socket. The driver must have already been bound
178 to a socket with bind_device() -- in fact, bind_device()
179 allocates the client structure that will be used.
181 ======================================================================*/
183 static int bind_request(struct pcmcia_socket *s, bind_info_t *bind_info)
185 struct pcmcia_driver *p_drv;
186 struct pcmcia_device *p_dev;
190 s = pcmcia_get_socket(s);
194 ds_dbg(2, "bind_request(%d, '%s')\n", s->sock,
195 (char *)bind_info->dev_info);
197 p_drv = get_pcmcia_driver(&bind_info->dev_info);
203 if (!try_module_get(p_drv->owner)) {
208 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
209 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
210 if (p_dev->func == bind_info->function) {
211 if ((p_dev->dev.driver == &p_drv->drv)) {
212 if (p_dev->cardmgr) {
213 /* if there's already a device
214 * registered, and it was registered
215 * by userspace before, we need to
216 * return the "instance". */
217 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
218 bind_info->instance = p_dev->instance;
222 /* the correct driver managed to bind
223 * itself magically to the correct
225 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
226 p_dev->cardmgr = p_drv;
230 } else if (!p_dev->dev.driver) {
231 /* there's already a device available where
232 * no device has been bound to yet. So we don't
233 * need to register a device! */
234 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
239 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
241 p_dev = pcmcia_device_add(s, bind_info->function);
248 p_dev->cardmgr = p_drv;
250 /* if a driver is already running, we can abort */
251 if (p_dev->dev.driver)
255 * Prevent this racing with a card insertion.
258 bus_rescan_devices(&pcmcia_bus_type);
261 /* check whether the driver indeed matched. I don't care if this
262 * is racy or not, because it can only happen on cardmgr access
265 if (!(p_dev->dev.driver == &p_drv->drv))
266 p_dev->cardmgr = NULL;
269 module_put(p_drv->owner);
271 put_driver(&p_drv->drv);
273 pcmcia_put_socket(s);
278 #ifdef CONFIG_CARDBUS
280 static struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
282 if (!s || !(s->state & SOCKET_CARDBUS))
285 return s->cb_dev->subordinate;
289 static int get_device_info(struct pcmcia_socket *s, bind_info_t *bind_info, int first)
292 struct pcmcia_device *p_dev;
296 #ifdef CONFIG_CARDBUS
298 * Some unbelievably ugly code to associate the PCI cardbus
299 * device and its driver with the PCMCIA "bind" information.
304 bus = pcmcia_lookup_bus(s);
306 struct list_head *list;
307 struct pci_dev *dev = NULL;
309 list = bus->devices.next;
310 while (list != &bus->devices) {
311 struct pci_dev *pdev = pci_dev_b(list);
319 /* Try to handle "next" here some way? */
321 if (dev && dev->driver) {
322 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
323 bind_info->major = 0;
324 bind_info->minor = 0;
325 bind_info->next = NULL;
332 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
333 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
334 if (p_dev->func == bind_info->function) {
335 p_dev = pcmcia_get_dev(p_dev);
341 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
345 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
347 if ((!p_dev->instance) ||
348 (p_dev->instance->state & DEV_CONFIG_PENDING)) {
354 node = p_dev->instance->dev;
356 for (node = p_dev->instance->dev; node; node = node->next)
357 if (node == bind_info->next)
364 strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
365 bind_info->major = node->major;
366 bind_info->minor = node->minor;
367 bind_info->next = node->next;
370 pcmcia_put_dev(p_dev);
372 } /* get_device_info */
375 static int ds_open(struct inode *inode, struct file *file)
377 socket_t i = iminor(inode);
378 struct pcmcia_socket *s;
381 ds_dbg(0, "ds_open(socket %d)\n", i);
383 s = pcmcia_get_socket_by_nr(i);
386 s = pcmcia_get_socket(s);
390 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
391 if (s->pcmcia_state.busy) {
392 pcmcia_put_socket(s);
396 s->pcmcia_state.busy = 1;
399 user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
401 pcmcia_put_socket(s);
404 user->event_tail = user->event_head = 0;
405 user->next = s->user;
406 user->user_magic = USER_MAGIC;
409 file->private_data = user;
411 if (s->pcmcia_state.present)
412 queue_event(user, CS_EVENT_CARD_INSERTION);
416 /*====================================================================*/
418 static int ds_release(struct inode *inode, struct file *file)
420 struct pcmcia_socket *s;
421 user_info_t *user, **link;
423 ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
425 user = file->private_data;
426 if (CHECK_USER(user))
431 /* Unlink user data structure */
432 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
433 s->pcmcia_state.busy = 0;
435 file->private_data = NULL;
436 for (link = &s->user; *link; link = &(*link)->next)
437 if (*link == user) break;
441 user->user_magic = 0;
443 pcmcia_put_socket(s);
448 /*====================================================================*/
450 static ssize_t ds_read(struct file *file, char __user *buf,
451 size_t count, loff_t *ppos)
453 struct pcmcia_socket *s;
457 ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));
462 user = file->private_data;
463 if (CHECK_USER(user))
467 if (s->pcmcia_state.dead)
470 ret = wait_event_interruptible(s->queue, !queue_empty(user));
472 ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
477 /*====================================================================*/
479 static ssize_t ds_write(struct file *file, const char __user *buf,
480 size_t count, loff_t *ppos)
482 ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));
486 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
492 /*====================================================================*/
494 /* No kernel lock - fine */
495 static u_int ds_poll(struct file *file, poll_table *wait)
497 struct pcmcia_socket *s;
500 ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
502 user = file->private_data;
503 if (CHECK_USER(user))
507 * We don't check for a dead socket here since that
508 * will send cardmgr into an endless spin.
510 poll_wait(file, &s->queue, wait);
511 if (!queue_empty(user))
512 return POLLIN | POLLRDNORM;
516 /*====================================================================*/
518 extern int pcmcia_adjust_resource_info(adjust_t *adj);
520 static int ds_ioctl(struct inode * inode, struct file * file,
521 u_int cmd, u_long arg)
523 struct pcmcia_socket *s;
524 void __user *uarg = (char __user *)arg;
530 ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
532 user = file->private_data;
533 if (CHECK_USER(user))
537 if (s->pcmcia_state.dead)
540 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
541 if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
543 /* Permission check */
544 if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
548 if (!access_ok(VERIFY_READ, uarg, size)) {
549 ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
554 if (!access_ok(VERIFY_WRITE, uarg, size)) {
555 ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
559 buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
565 if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size);
568 case DS_ADJUST_RESOURCE_INFO:
569 ret = pcmcia_adjust_resource_info(&buf->adjust);
571 case DS_GET_CONFIGURATION_INFO:
572 if (buf->config.Function &&
573 (buf->config.Function >= s->functions))
576 ret = pccard_get_configuration_info(s,
577 buf->config.Function, &buf->config);
579 case DS_GET_FIRST_TUPLE:
581 pcmcia_validate_mem(s);
583 ret = pccard_get_first_tuple(s, BIND_FN_ALL, &buf->tuple);
585 case DS_GET_NEXT_TUPLE:
586 ret = pccard_get_next_tuple(s, BIND_FN_ALL, &buf->tuple);
588 case DS_GET_TUPLE_DATA:
589 buf->tuple.TupleData = buf->tuple_parse.data;
590 buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
591 ret = pccard_get_tuple_data(s, &buf->tuple);
594 buf->tuple.TupleData = buf->tuple_parse.data;
595 ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
598 ret = pccard_reset_card(s);
601 if (buf->status.Function &&
602 (buf->status.Function >= s->functions))
605 ret = pccard_get_status(s, buf->status.Function, &buf->status);
607 case DS_VALIDATE_CIS:
609 pcmcia_validate_mem(s);
611 ret = pccard_validate_cis(s, BIND_FN_ALL, &buf->cisinfo);
613 case DS_SUSPEND_CARD:
614 ret = pcmcia_suspend_card(s);
617 ret = pcmcia_resume_card(s);
620 err = pcmcia_eject_card(s);
623 err = pcmcia_insert_card(s);
625 case DS_ACCESS_CONFIGURATION_REGISTER:
626 if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
630 if (buf->conf_reg.Function &&
631 (buf->conf_reg.Function >= s->functions))
634 ret = pccard_access_configuration_register(s,
635 buf->conf_reg.Function, &buf->conf_reg);
637 case DS_GET_FIRST_REGION:
638 case DS_GET_NEXT_REGION:
640 if (!capable(CAP_SYS_ADMIN)) {
644 static int printed = 0;
646 printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
647 printk(KERN_WARNING "MTD handling any more.\n");
654 case DS_GET_FIRST_WINDOW:
655 ret = pcmcia_get_window(s, &buf->win_info.handle, 0,
656 &buf->win_info.window);
658 case DS_GET_NEXT_WINDOW:
659 ret = pcmcia_get_window(s, &buf->win_info.handle,
660 buf->win_info.handle->index + 1, &buf->win_info.window);
662 case DS_GET_MEM_PAGE:
663 ret = pcmcia_get_mem_page(buf->win_info.handle,
667 ret = pcmcia_replace_cis(s, &buf->cisdump);
669 case DS_BIND_REQUEST:
670 if (!capable(CAP_SYS_ADMIN)) {
674 err = bind_request(s, &buf->bind_info);
676 case DS_GET_DEVICE_INFO:
677 err = get_device_info(s, &buf->bind_info, 1);
679 case DS_GET_NEXT_DEVICE:
680 err = get_device_info(s, &buf->bind_info, 0);
682 case DS_UNBIND_REQUEST:
689 if ((err == 0) && (ret != CS_SUCCESS)) {
690 ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
692 case CS_BAD_SOCKET: case CS_NO_CARD:
693 err = -ENODEV; break;
694 case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
696 err = -EINVAL; break;
699 case CS_OUT_OF_RESOURCE:
700 err = -ENOSPC; break;
701 case CS_NO_MORE_ITEMS:
702 err = -ENODATA; break;
703 case CS_UNSUPPORTED_FUNCTION:
704 err = -ENOSYS; break;
711 if (__copy_to_user(uarg, (char *)buf, size))
720 /*====================================================================*/
722 static struct file_operations ds_fops = {
723 .owner = THIS_MODULE,
725 .release = ds_release,
732 void __init pcmcia_setup_ioctl(void) {
735 /* Set up character device for user mode clients */
736 i = register_chrdev(0, "pcmcia", &ds_fops);
738 printk(KERN_NOTICE "unable to find a free device # for "
739 "Driver Services (error=%d)\n", i);
743 #ifdef CONFIG_PROC_FS
744 proc_pccard = proc_mkdir("pccard", proc_bus);
746 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
751 void __exit pcmcia_cleanup_ioctl(void) {
752 #ifdef CONFIG_PROC_FS
754 remove_proc_entry("drivers", proc_pccard);
755 remove_proc_entry("pccard", proc_bus);
759 unregister_chrdev(major_dev, "pcmcia");