blob: 738b1ef595a3506fd595f9f742da4c6f966b7e47 [file] [log] [blame]
Dominik Brodowskie7a480d2005-06-27 16:28:47 -07001/*
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
Dominik Brodowskie7a480d2005-06-27 16:28:47 -070021#include <linux/kernel.h>
Dominik Brodowski3b659fb2005-06-27 16:28:51 -070022#include <linux/module.h>
23#include <linux/init.h>
Dominik Brodowskie7a480d2005-06-27 16:28:47 -070024#include <linux/major.h>
Dominik Brodowskie7a480d2005-06-27 16:28:47 -070025#include <linux/errno.h>
Dominik Brodowskie7a480d2005-06-27 16:28:47 -070026#include <linux/ioctl.h>
27#include <linux/proc_fs.h>
28#include <linux/poll.h>
29#include <linux/pci.h>
Dominik Brodowskie7a480d2005-06-27 16:28:47 -070030#include <linux/workqueue.h>
Dominik Brodowskie7a480d2005-06-27 16:28:47 -070031
32#define IN_CARD_SERVICES
Dominik Brodowskie7a480d2005-06-27 16:28:47 -070033#include <pcmcia/cs_types.h>
34#include <pcmcia/cs.h>
Dominik Brodowskie7a480d2005-06-27 16:28:47 -070035#include <pcmcia/cistpl.h>
36#include <pcmcia/ds.h>
37#include <pcmcia/ss.h>
38
39#include "cs_internal.h"
40#include "ds_internal.h"
41
42static int major_dev = -1;
43
44
45/* Device user information */
46#define MAX_EVENTS 32
47#define USER_MAGIC 0x7ea4
48#define CHECK_USER(u) \
49 (((u) == NULL) || ((u)->user_magic != USER_MAGIC))
50
51typedef struct user_info_t {
52 u_int user_magic;
53 int event_head, event_tail;
54 event_t event[MAX_EVENTS];
55 struct user_info_t *next;
Dominik Brodowskidc109492005-06-27 16:28:50 -070056 struct pcmcia_socket *socket;
Dominik Brodowskie7a480d2005-06-27 16:28:47 -070057} user_info_t;
58
59
60#ifdef DEBUG
61extern int ds_pc_debug;
62#define cs_socket_name(skt) ((skt)->dev.class_id)
63
64#define ds_dbg(lvl, fmt, arg...) do { \
65 if (ds_pc_debug >= lvl) \
66 printk(KERN_DEBUG "ds: " fmt , ## arg); \
67} while (0)
68#else
69#define ds_dbg(lvl, fmt, arg...) do { } while (0)
70#endif
71
Dominik Brodowski855cdf12006-01-10 20:48:59 +010072static struct pcmcia_device *get_pcmcia_device(struct pcmcia_socket *s,
73 unsigned int function)
74{
75 struct pcmcia_device *p_dev = NULL;
76 unsigned long flags;
77
78 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
79 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
80 if (p_dev->func == function) {
81 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
82 return pcmcia_get_dev(p_dev);
83 }
84 }
85 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
86 return NULL;
87}
Dominik Brodowskie7a480d2005-06-27 16:28:47 -070088
Dominik Brodowskie7a480d2005-06-27 16:28:47 -070089/* backwards-compatible accessing of driver --- by name! */
90
Dominik Brodowski855cdf12006-01-10 20:48:59 +010091static struct pcmcia_driver *get_pcmcia_driver(dev_info_t *dev_info)
Dominik Brodowskie7a480d2005-06-27 16:28:47 -070092{
93 struct device_driver *drv;
94 struct pcmcia_driver *p_drv;
95
96 drv = driver_find((char *) dev_info, &pcmcia_bus_type);
97 if (!drv)
98 return NULL;
99
100 p_drv = container_of(drv, struct pcmcia_driver, drv);
101
102 return (p_drv);
103}
104
105
106#ifdef CONFIG_PROC_FS
107static struct proc_dir_entry *proc_pccard = NULL;
108
109static int proc_read_drivers_callback(struct device_driver *driver, void *d)
110{
111 char **p = d;
112 struct pcmcia_driver *p_drv = container_of(driver,
113 struct pcmcia_driver, drv);
114
115 *p += sprintf(*p, "%-24.24s 1 %d\n", p_drv->drv.name,
116#ifdef CONFIG_MODULE_UNLOAD
117 (p_drv->owner) ? module_refcount(p_drv->owner) : 1
118#else
119 1
120#endif
121 );
122 d = (void *) p;
123
124 return 0;
125}
126
127static int proc_read_drivers(char *buf, char **start, off_t pos,
128 int count, int *eof, void *data)
129{
130 char *p = buf;
131
132 bus_for_each_drv(&pcmcia_bus_type, NULL,
133 (void *) &p, proc_read_drivers_callback);
134
135 return (p - buf);
136}
137#endif
138
139/*======================================================================
140
141 These manage a ring buffer of events pending for one user process
142
143======================================================================*/
144
145
146static int queue_empty(user_info_t *user)
147{
148 return (user->event_head == user->event_tail);
149}
150
151static event_t get_queued_event(user_info_t *user)
152{
153 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
154 return user->event[user->event_tail];
155}
156
157static void queue_event(user_info_t *user, event_t event)
158{
159 user->event_head = (user->event_head+1) % MAX_EVENTS;
160 if (user->event_head == user->event_tail)
161 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
162 user->event[user->event_head] = event;
163}
164
Dominik Brodowskidc109492005-06-27 16:28:50 -0700165void handle_event(struct pcmcia_socket *s, event_t event)
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700166{
167 user_info_t *user;
168 for (user = s->user; user; user = user->next)
169 queue_event(user, event);
170 wake_up_interruptible(&s->queue);
171}
172
173
174/*======================================================================
175
176 bind_request() and bind_device() are merged by now. Register_client()
177 is called right at the end of bind_request(), during the driver's
178 ->attach() call. Individual descriptions:
179
180 bind_request() connects a socket to a particular client driver.
181 It looks up the specified device ID in the list of registered
182 drivers, binds it to the socket, and tries to create an instance
183 of the device. unbind_request() deletes a driver instance.
184
185 Bind_device() associates a device driver with a particular socket.
186 It is normally called by Driver Services after it has identified
187 a newly inserted card. An instance of that driver will then be
188 eligible to register as a client of this socket.
189
190 Register_client() uses the dev_info_t handle to match the
191 caller with a socket. The driver must have already been bound
192 to a socket with bind_device() -- in fact, bind_device()
193 allocates the client structure that will be used.
194
195======================================================================*/
196
Dominik Brodowskidc109492005-06-27 16:28:50 -0700197static int bind_request(struct pcmcia_socket *s, bind_info_t *bind_info)
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700198{
199 struct pcmcia_driver *p_drv;
200 struct pcmcia_device *p_dev;
201 int ret = 0;
202 unsigned long flags;
203
Dominik Brodowskidc109492005-06-27 16:28:50 -0700204 s = pcmcia_get_socket(s);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700205 if (!s)
206 return -EINVAL;
207
Dominik Brodowskidc109492005-06-27 16:28:50 -0700208 ds_dbg(2, "bind_request(%d, '%s')\n", s->sock,
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700209 (char *)bind_info->dev_info);
210
211 p_drv = get_pcmcia_driver(&bind_info->dev_info);
212 if (!p_drv) {
213 ret = -EINVAL;
214 goto err_put;
215 }
216
217 if (!try_module_get(p_drv->owner)) {
218 ret = -EINVAL;
219 goto err_put_driver;
220 }
221
222 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
223 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
224 if (p_dev->func == bind_info->function) {
225 if ((p_dev->dev.driver == &p_drv->drv)) {
226 if (p_dev->cardmgr) {
227 /* if there's already a device
228 * registered, and it was registered
229 * by userspace before, we need to
230 * return the "instance". */
231 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
Dominik Brodowskifd238232006-03-05 10:45:09 +0100232 bind_info->instance = p_dev;
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700233 ret = -EBUSY;
234 goto err_put_module;
235 } else {
236 /* the correct driver managed to bind
237 * itself magically to the correct
238 * device. */
239 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
240 p_dev->cardmgr = p_drv;
241 ret = 0;
242 goto err_put_module;
243 }
244 } else if (!p_dev->dev.driver) {
245 /* there's already a device available where
246 * no device has been bound to yet. So we don't
247 * need to register a device! */
248 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
249 goto rescan;
250 }
251 }
252 }
253 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
254
255 p_dev = pcmcia_device_add(s, bind_info->function);
256 if (!p_dev) {
257 ret = -EIO;
258 goto err_put_module;
259 }
260
261rescan:
262 p_dev->cardmgr = p_drv;
263
264 /* if a driver is already running, we can abort */
265 if (p_dev->dev.driver)
266 goto err_put_module;
267
268 /*
269 * Prevent this racing with a card insertion.
270 */
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100271 mutex_lock(&s->skt_mutex);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700272 bus_rescan_devices(&pcmcia_bus_type);
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100273 mutex_unlock(&s->skt_mutex);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700274
275 /* check whether the driver indeed matched. I don't care if this
276 * is racy or not, because it can only happen on cardmgr access
277 * paths...
278 */
279 if (!(p_dev->dev.driver == &p_drv->drv))
280 p_dev->cardmgr = NULL;
281
282 err_put_module:
283 module_put(p_drv->owner);
284 err_put_driver:
285 put_driver(&p_drv->drv);
286 err_put:
Dominik Brodowskidc109492005-06-27 16:28:50 -0700287 pcmcia_put_socket(s);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700288
289 return (ret);
290} /* bind_request */
291
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700292#ifdef CONFIG_CARDBUS
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700293
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700294static struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
295{
296 if (!s || !(s->state & SOCKET_CARDBUS))
297 return NULL;
298
299 return s->cb_dev->subordinate;
300}
301#endif
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700302
Dominik Brodowskidc109492005-06-27 16:28:50 -0700303static int get_device_info(struct pcmcia_socket *s, bind_info_t *bind_info, int first)
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700304{
305 dev_node_t *node;
306 struct pcmcia_device *p_dev;
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100307 struct pcmcia_driver *p_drv;
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700308 unsigned long flags;
309 int ret = 0;
310
311#ifdef CONFIG_CARDBUS
312 /*
313 * Some unbelievably ugly code to associate the PCI cardbus
314 * device and its driver with the PCMCIA "bind" information.
315 */
316 {
317 struct pci_bus *bus;
318
Dominik Brodowskidc109492005-06-27 16:28:50 -0700319 bus = pcmcia_lookup_bus(s);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700320 if (bus) {
321 struct list_head *list;
322 struct pci_dev *dev = NULL;
323
324 list = bus->devices.next;
325 while (list != &bus->devices) {
326 struct pci_dev *pdev = pci_dev_b(list);
327 list = list->next;
328
329 if (first) {
330 dev = pdev;
331 break;
332 }
333
334 /* Try to handle "next" here some way? */
335 }
336 if (dev && dev->driver) {
337 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
338 bind_info->major = 0;
339 bind_info->minor = 0;
340 bind_info->next = NULL;
341 return 0;
342 }
343 }
344 }
345#endif
346
347 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
348 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
349 if (p_dev->func == bind_info->function) {
350 p_dev = pcmcia_get_dev(p_dev);
351 if (!p_dev)
352 continue;
353 goto found;
354 }
355 }
356 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
357 return -ENODEV;
358
359 found:
360 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
361
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100362 p_drv = to_pcmcia_drv(p_dev->dev.driver);
363 if (p_drv && !p_dev->_locked) {
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700364 ret = -EAGAIN;
365 goto err_put;
366 }
367
368 if (first)
Dominik Brodowskifd238232006-03-05 10:45:09 +0100369 node = p_dev->dev_node;
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700370 else
Dominik Brodowskifd238232006-03-05 10:45:09 +0100371 for (node = p_dev->dev_node; node; node = node->next)
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700372 if (node == bind_info->next)
373 break;
374 if (!node) {
375 ret = -ENODEV;
376 goto err_put;
377 }
378
379 strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
380 bind_info->major = node->major;
381 bind_info->minor = node->minor;
382 bind_info->next = node->next;
383
384 err_put:
385 pcmcia_put_dev(p_dev);
386 return (ret);
387} /* get_device_info */
388
389
390static int ds_open(struct inode *inode, struct file *file)
391{
392 socket_t i = iminor(inode);
Dominik Brodowskidc109492005-06-27 16:28:50 -0700393 struct pcmcia_socket *s;
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700394 user_info_t *user;
Dominik Brodowskic352ec82005-09-13 01:25:03 -0700395 static int warning_printed = 0;
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700396
397 ds_dbg(0, "ds_open(socket %d)\n", i);
398
Dominik Brodowskidc109492005-06-27 16:28:50 -0700399 s = pcmcia_get_socket_by_nr(i);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700400 if (!s)
401 return -ENODEV;
Dominik Brodowskidc109492005-06-27 16:28:50 -0700402 s = pcmcia_get_socket(s);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700403 if (!s)
404 return -ENODEV;
405
406 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
Dominik Brodowskib5e43912005-06-27 16:28:50 -0700407 if (s->pcmcia_state.busy) {
Dominik Brodowskidc109492005-06-27 16:28:50 -0700408 pcmcia_put_socket(s);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700409 return -EBUSY;
410 }
411 else
Dominik Brodowskib5e43912005-06-27 16:28:50 -0700412 s->pcmcia_state.busy = 1;
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700413 }
414
415 user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
416 if (!user) {
Dominik Brodowskidc109492005-06-27 16:28:50 -0700417 pcmcia_put_socket(s);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700418 return -ENOMEM;
419 }
420 user->event_tail = user->event_head = 0;
421 user->next = s->user;
422 user->user_magic = USER_MAGIC;
423 user->socket = s;
424 s->user = user;
425 file->private_data = user;
426
Dominik Brodowskic352ec82005-09-13 01:25:03 -0700427 if (!warning_printed) {
428 printk(KERN_INFO "pcmcia: Detected deprecated PCMCIA ioctl "
Benjamin Herrenschmidt73d58582006-05-15 09:43:53 -0700429 "usage from process: %s.\n", current->comm);
Dominik Brodowskic352ec82005-09-13 01:25:03 -0700430 printk(KERN_INFO "pcmcia: This interface will soon be removed from "
431 "the kernel; please expect breakage unless you upgrade "
432 "to new tools.\n");
433 printk(KERN_INFO "pcmcia: see http://www.kernel.org/pub/linux/"
434 "utils/kernel/pcmcia/pcmcia.html for details.\n");
435 warning_printed = 1;
436 }
437
Dominik Brodowskib5e43912005-06-27 16:28:50 -0700438 if (s->pcmcia_state.present)
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700439 queue_event(user, CS_EVENT_CARD_INSERTION);
440 return 0;
441} /* ds_open */
442
443/*====================================================================*/
444
445static int ds_release(struct inode *inode, struct file *file)
446{
Dominik Brodowskidc109492005-06-27 16:28:50 -0700447 struct pcmcia_socket *s;
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700448 user_info_t *user, **link;
449
450 ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
451
452 user = file->private_data;
453 if (CHECK_USER(user))
454 goto out;
455
456 s = user->socket;
457
458 /* Unlink user data structure */
459 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
Dominik Brodowskib5e43912005-06-27 16:28:50 -0700460 s->pcmcia_state.busy = 0;
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700461 }
462 file->private_data = NULL;
463 for (link = &s->user; *link; link = &(*link)->next)
464 if (*link == user) break;
465 if (link == NULL)
466 goto out;
467 *link = user->next;
468 user->user_magic = 0;
469 kfree(user);
Dominik Brodowskidc109492005-06-27 16:28:50 -0700470 pcmcia_put_socket(s);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700471out:
472 return 0;
473} /* ds_release */
474
475/*====================================================================*/
476
477static ssize_t ds_read(struct file *file, char __user *buf,
478 size_t count, loff_t *ppos)
479{
Dominik Brodowskidc109492005-06-27 16:28:50 -0700480 struct pcmcia_socket *s;
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700481 user_info_t *user;
482 int ret;
483
484 ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));
485
486 if (count < 4)
487 return -EINVAL;
488
489 user = file->private_data;
490 if (CHECK_USER(user))
491 return -EIO;
492
493 s = user->socket;
Dominik Brodowskib5e43912005-06-27 16:28:50 -0700494 if (s->pcmcia_state.dead)
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700495 return -EIO;
496
497 ret = wait_event_interruptible(s->queue, !queue_empty(user));
498 if (ret == 0)
499 ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
500
501 return ret;
502} /* ds_read */
503
504/*====================================================================*/
505
506static ssize_t ds_write(struct file *file, const char __user *buf,
507 size_t count, loff_t *ppos)
508{
509 ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));
510
511 if (count != 4)
512 return -EINVAL;
513 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
514 return -EBADF;
515
516 return -EIO;
517} /* ds_write */
518
519/*====================================================================*/
520
521/* No kernel lock - fine */
522static u_int ds_poll(struct file *file, poll_table *wait)
523{
Dominik Brodowskidc109492005-06-27 16:28:50 -0700524 struct pcmcia_socket *s;
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700525 user_info_t *user;
526
527 ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
528
529 user = file->private_data;
530 if (CHECK_USER(user))
531 return POLLERR;
532 s = user->socket;
533 /*
534 * We don't check for a dead socket here since that
535 * will send cardmgr into an endless spin.
536 */
537 poll_wait(file, &s->queue, wait);
538 if (!queue_empty(user))
539 return POLLIN | POLLRDNORM;
540 return 0;
541} /* ds_poll */
542
543/*====================================================================*/
544
545extern int pcmcia_adjust_resource_info(adjust_t *adj);
546
547static int ds_ioctl(struct inode * inode, struct file * file,
548 u_int cmd, u_long arg)
549{
Dominik Brodowskidc109492005-06-27 16:28:50 -0700550 struct pcmcia_socket *s;
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700551 void __user *uarg = (char __user *)arg;
552 u_int size;
553 int ret, err;
554 ds_ioctl_arg_t *buf;
555 user_info_t *user;
556
557 ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
558
559 user = file->private_data;
560 if (CHECK_USER(user))
561 return -EIO;
562
563 s = user->socket;
Dominik Brodowskib5e43912005-06-27 16:28:50 -0700564 if (s->pcmcia_state.dead)
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700565 return -EIO;
566
567 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
568 if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
569
570 /* Permission check */
571 if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
572 return -EPERM;
573
574 if (cmd & IOC_IN) {
575 if (!access_ok(VERIFY_READ, uarg, size)) {
576 ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
577 return -EFAULT;
578 }
579 }
580 if (cmd & IOC_OUT) {
581 if (!access_ok(VERIFY_WRITE, uarg, size)) {
582 ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
583 return -EFAULT;
584 }
585 }
586 buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
587 if (!buf)
588 return -ENOMEM;
589
590 err = ret = 0;
591
592 if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size);
593
594 switch (cmd) {
595 case DS_ADJUST_RESOURCE_INFO:
596 ret = pcmcia_adjust_resource_info(&buf->adjust);
597 break;
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700598 case DS_GET_CONFIGURATION_INFO:
599 if (buf->config.Function &&
Dominik Brodowskidc109492005-06-27 16:28:50 -0700600 (buf->config.Function >= s->functions))
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700601 ret = CS_BAD_ARGS;
Dominik Brodowski855cdf12006-01-10 20:48:59 +0100602 else {
603 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->config.Function);
Benjamin Herrenschmidt73d58582006-05-15 09:43:53 -0700604 if (p_dev == NULL)
605 ret = CS_BAD_ARGS;
606 else {
607 ret = pccard_get_configuration_info(s, p_dev, &buf->config);
608 pcmcia_put_dev(p_dev);
609 }
Dominik Brodowski855cdf12006-01-10 20:48:59 +0100610 }
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700611 break;
612 case DS_GET_FIRST_TUPLE:
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100613 mutex_lock(&s->skt_mutex);
Dominik Brodowskidc109492005-06-27 16:28:50 -0700614 pcmcia_validate_mem(s);
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100615 mutex_unlock(&s->skt_mutex);
Dominik Brodowskidc109492005-06-27 16:28:50 -0700616 ret = pccard_get_first_tuple(s, BIND_FN_ALL, &buf->tuple);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700617 break;
618 case DS_GET_NEXT_TUPLE:
Dominik Brodowskidc109492005-06-27 16:28:50 -0700619 ret = pccard_get_next_tuple(s, BIND_FN_ALL, &buf->tuple);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700620 break;
621 case DS_GET_TUPLE_DATA:
622 buf->tuple.TupleData = buf->tuple_parse.data;
623 buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
Dominik Brodowskidc109492005-06-27 16:28:50 -0700624 ret = pccard_get_tuple_data(s, &buf->tuple);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700625 break;
626 case DS_PARSE_TUPLE:
627 buf->tuple.TupleData = buf->tuple_parse.data;
628 ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
629 break;
630 case DS_RESET_CARD:
Dominik Brodowskidc109492005-06-27 16:28:50 -0700631 ret = pccard_reset_card(s);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700632 break;
633 case DS_GET_STATUS:
Dominik Brodowski855cdf12006-01-10 20:48:59 +0100634 if (buf->status.Function &&
635 (buf->status.Function >= s->functions))
636 ret = CS_BAD_ARGS;
637 else {
638 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->status.Function);
Benjamin Herrenschmidt73d58582006-05-15 09:43:53 -0700639 if (p_dev == NULL)
640 ret = CS_BAD_ARGS;
641 else {
642 ret = pccard_get_status(s, p_dev, &buf->status);
643 pcmcia_put_dev(p_dev);
644 }
Dominik Brodowski855cdf12006-01-10 20:48:59 +0100645 }
646 break;
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700647 case DS_VALIDATE_CIS:
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100648 mutex_lock(&s->skt_mutex);
Dominik Brodowskidc109492005-06-27 16:28:50 -0700649 pcmcia_validate_mem(s);
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100650 mutex_unlock(&s->skt_mutex);
Dominik Brodowskidc109492005-06-27 16:28:50 -0700651 ret = pccard_validate_cis(s, BIND_FN_ALL, &buf->cisinfo);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700652 break;
653 case DS_SUSPEND_CARD:
Dominik Brodowskidc109492005-06-27 16:28:50 -0700654 ret = pcmcia_suspend_card(s);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700655 break;
656 case DS_RESUME_CARD:
Dominik Brodowskidc109492005-06-27 16:28:50 -0700657 ret = pcmcia_resume_card(s);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700658 break;
659 case DS_EJECT_CARD:
Dominik Brodowskidc109492005-06-27 16:28:50 -0700660 err = pcmcia_eject_card(s);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700661 break;
662 case DS_INSERT_CARD:
Dominik Brodowskidc109492005-06-27 16:28:50 -0700663 err = pcmcia_insert_card(s);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700664 break;
665 case DS_ACCESS_CONFIGURATION_REGISTER:
666 if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
667 err = -EPERM;
668 goto free_out;
669 }
Dominik Brodowski855cdf12006-01-10 20:48:59 +0100670
671 ret = CS_BAD_ARGS;
672
673 if (!(buf->conf_reg.Function &&
674 (buf->conf_reg.Function >= s->functions))) {
675 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->conf_reg.Function);
Benjamin Herrenschmidt73d58582006-05-15 09:43:53 -0700676 if (p_dev) {
Dominik Brodowski855cdf12006-01-10 20:48:59 +0100677 ret = pcmcia_access_configuration_register(p_dev, &buf->conf_reg);
Benjamin Herrenschmidt73d58582006-05-15 09:43:53 -0700678 pcmcia_put_dev(p_dev);
679 }
Dominik Brodowski855cdf12006-01-10 20:48:59 +0100680 }
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700681 break;
682 case DS_GET_FIRST_REGION:
683 case DS_GET_NEXT_REGION:
684 case DS_BIND_MTD:
685 if (!capable(CAP_SYS_ADMIN)) {
686 err = -EPERM;
687 goto free_out;
688 } else {
689 static int printed = 0;
690 if (!printed) {
691 printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
692 printk(KERN_WARNING "MTD handling any more.\n");
693 printed++;
694 }
695 }
696 err = -EINVAL;
697 goto free_out;
698 break;
699 case DS_GET_FIRST_WINDOW:
Dominik Brodowskidc109492005-06-27 16:28:50 -0700700 ret = pcmcia_get_window(s, &buf->win_info.handle, 0,
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700701 &buf->win_info.window);
702 break;
703 case DS_GET_NEXT_WINDOW:
Dominik Brodowskidc109492005-06-27 16:28:50 -0700704 ret = pcmcia_get_window(s, &buf->win_info.handle,
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700705 buf->win_info.handle->index + 1, &buf->win_info.window);
706 break;
707 case DS_GET_MEM_PAGE:
708 ret = pcmcia_get_mem_page(buf->win_info.handle,
709 &buf->win_info.map);
710 break;
711 case DS_REPLACE_CIS:
Dominik Brodowskidc109492005-06-27 16:28:50 -0700712 ret = pcmcia_replace_cis(s, &buf->cisdump);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700713 break;
714 case DS_BIND_REQUEST:
715 if (!capable(CAP_SYS_ADMIN)) {
716 err = -EPERM;
717 goto free_out;
718 }
719 err = bind_request(s, &buf->bind_info);
720 break;
721 case DS_GET_DEVICE_INFO:
722 err = get_device_info(s, &buf->bind_info, 1);
723 break;
724 case DS_GET_NEXT_DEVICE:
725 err = get_device_info(s, &buf->bind_info, 0);
726 break;
727 case DS_UNBIND_REQUEST:
728 err = 0;
729 break;
730 default:
731 err = -EINVAL;
732 }
733
734 if ((err == 0) && (ret != CS_SUCCESS)) {
735 ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
736 switch (ret) {
737 case CS_BAD_SOCKET: case CS_NO_CARD:
738 err = -ENODEV; break;
739 case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
740 case CS_BAD_TUPLE:
741 err = -EINVAL; break;
742 case CS_IN_USE:
743 err = -EBUSY; break;
744 case CS_OUT_OF_RESOURCE:
745 err = -ENOSPC; break;
746 case CS_NO_MORE_ITEMS:
747 err = -ENODATA; break;
748 case CS_UNSUPPORTED_FUNCTION:
749 err = -ENOSYS; break;
750 default:
751 err = -EIO; break;
752 }
753 }
754
755 if (cmd & IOC_OUT) {
756 if (__copy_to_user(uarg, (char *)buf, size))
757 err = -EFAULT;
758 }
759
760free_out:
761 kfree(buf);
762 return err;
763} /* ds_ioctl */
764
765/*====================================================================*/
766
767static struct file_operations ds_fops = {
768 .owner = THIS_MODULE,
769 .open = ds_open,
770 .release = ds_release,
771 .ioctl = ds_ioctl,
772 .read = ds_read,
773 .write = ds_write,
774 .poll = ds_poll,
775};
776
777void __init pcmcia_setup_ioctl(void) {
778 int i;
779
780 /* Set up character device for user mode clients */
781 i = register_chrdev(0, "pcmcia", &ds_fops);
Dominik Brodowski1a8ceaf2005-06-27 16:29:00 -0700782 if (i < 0)
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700783 printk(KERN_NOTICE "unable to find a free device # for "
Dominik Brodowski1a8ceaf2005-06-27 16:29:00 -0700784 "Driver Services (error=%d)\n", i);
Dominik Brodowskie7a480d2005-06-27 16:28:47 -0700785 else
786 major_dev = i;
787
788#ifdef CONFIG_PROC_FS
789 proc_pccard = proc_mkdir("pccard", proc_bus);
790 if (proc_pccard)
791 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
792#endif
793}
794
795
796void __exit pcmcia_cleanup_ioctl(void) {
797#ifdef CONFIG_PROC_FS
798 if (proc_pccard) {
799 remove_proc_entry("drivers", proc_pccard);
800 remove_proc_entry("pccard", proc_bus);
801 }
802#endif
803 if (major_dev != -1)
804 unregister_chrdev(major_dev, "pcmcia");
805}