?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ACPI: relax BAD_MADT_ENTRY check to allow LSAPIC variable length string UIDs
[linux-2.6/mini2440.git] / drivers / pcmcia / pcmcia_ioctl.c
blob9ad18e62658d6da302f70290027410eaace11c7d
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/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/workqueue.h>
31
32 #define IN_CARD_SERVICES
33 #include <pcmcia/cs_types.h>
34 #include <pcmcia/cs.h>
35 #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
42 static 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
51 typedef 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;
56 struct pcmcia_socket *socket;
57 } user_info_t;
58
59
60 #ifdef DEBUG
61 extern 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
72 static 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 }
88
89 /* backwards-compatible accessing of driver --- by name! */
90
91 static struct pcmcia_driver *get_pcmcia_driver(dev_info_t *dev_info)
92 {
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
107 static struct proc_dir_entry *proc_pccard = NULL;
108
109 static 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
127 static 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
146 static int queue_empty(user_info_t *user)
147 {
148 return (user->event_head == user->event_tail);
149 }
150
151 static 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
157 static 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
165 void handle_event(struct pcmcia_socket *s, event_t event)
166 {
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
197 static int bind_request(struct pcmcia_socket *s, bind_info_t *bind_info)
198 {
199 struct pcmcia_driver *p_drv;
200 struct pcmcia_device *p_dev;
201 int ret = 0;
202 unsigned long flags;
203
204 s = pcmcia_get_socket(s);
205 if (!s)
206 return -EINVAL;
207
208 ds_dbg(2, "bind_request(%d, '%s')\n", s->sock,
209 (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);
232 bind_info->instance = p_dev;
233 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
261 rescan:
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 */
271 mutex_lock(&s->skt_mutex);
272 bus_rescan_devices(&pcmcia_bus_type);
273 mutex_unlock(&s->skt_mutex);
274
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:
287 pcmcia_put_socket(s);
288
289 return (ret);
290 } /* bind_request */
291
292 #ifdef CONFIG_CARDBUS
293
294 static 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
302
303 static int get_device_info(struct pcmcia_socket *s, bind_info_t *bind_info, int first)
304 {
305 dev_node_t *node;
306 struct pcmcia_device *p_dev;
307 struct pcmcia_driver *p_drv;
308 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
319 bus = pcmcia_lookup_bus(s);
320 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
362 p_drv = to_pcmcia_drv(p_dev->dev.driver);
363 if (p_drv && !p_dev->_locked) {
364 ret = -EAGAIN;
365 goto err_put;
366 }
367
368 if (first)
369 node = p_dev->dev_node;
370 else
371 for (node = p_dev->dev_node; node; node = node->next)
372 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
390 static int ds_open(struct inode *inode, struct file *file)
391 {
392 socket_t i = iminor(inode);
393 struct pcmcia_socket *s;
394 user_info_t *user;
395 static int warning_printed = 0;
396
397 ds_dbg(0, "ds_open(socket %d)\n", i);
398
399 s = pcmcia_get_socket_by_nr(i);
400 if (!s)
401 return -ENODEV;
402 s = pcmcia_get_socket(s);
403 if (!s)
404 return -ENODEV;
405
406 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
407 if (s->pcmcia_state.busy) {
408 pcmcia_put_socket(s);
409 return -EBUSY;
410 }
411 else
412 s->pcmcia_state.busy = 1;
413 }
414
415 user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
416 if (!user) {
417 pcmcia_put_socket(s);
418 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
427 if (!warning_printed) {
428 printk(KERN_INFO "pcmcia: Detected deprecated PCMCIA ioctl "
429 "usage from process: %s.\n", current->comm);
430 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
438 if (s->pcmcia_state.present)
439 queue_event(user, CS_EVENT_CARD_INSERTION);
440 return 0;
441 } /* ds_open */
442
443 /*====================================================================*/
444
445 static int ds_release(struct inode *inode, struct file *file)
446 {
447 struct pcmcia_socket *s;
448 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) {
460 s->pcmcia_state.busy = 0;
461 }
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);
470 pcmcia_put_socket(s);
471 out:
472 return 0;
473 } /* ds_release */
474
475 /*====================================================================*/
476
477 static ssize_t ds_read(struct file *file, char __user *buf,
478 size_t count, loff_t *ppos)
479 {
480 struct pcmcia_socket *s;
481 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;
494 if (s->pcmcia_state.dead)
495 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
506 static 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 */
522 static u_int ds_poll(struct file *file, poll_table *wait)
523 {
524 struct pcmcia_socket *s;
525 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
545 extern int pcmcia_adjust_resource_info(adjust_t *adj);
546
547 static int ds_ioctl(struct inode * inode, struct file * file,
548 u_int cmd, u_long arg)
549 {
550 struct pcmcia_socket *s;
551 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;
564 if (s->pcmcia_state.dead)
565 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;
598 case DS_GET_CONFIGURATION_INFO:
599 if (buf->config.Function &&
600 (buf->config.Function >= s->functions))
601 ret = CS_BAD_ARGS;
602 else {
603 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->config.Function);
604 ret = pccard_get_configuration_info(s, p_dev, &buf->config);
605 pcmcia_put_dev(p_dev);
606 }
607 break;
608 case DS_GET_FIRST_TUPLE:
609 mutex_lock(&s->skt_mutex);
610 pcmcia_validate_mem(s);
611 mutex_unlock(&s->skt_mutex);
612 ret = pccard_get_first_tuple(s, BIND_FN_ALL, &buf->tuple);
613 break;
614 case DS_GET_NEXT_TUPLE:
615 ret = pccard_get_next_tuple(s, BIND_FN_ALL, &buf->tuple);
616 break;
617 case DS_GET_TUPLE_DATA:
618 buf->tuple.TupleData = buf->tuple_parse.data;
619 buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
620 ret = pccard_get_tuple_data(s, &buf->tuple);
621 break;
622 case DS_PARSE_TUPLE:
623 buf->tuple.TupleData = buf->tuple_parse.data;
624 ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
625 break;
626 case DS_RESET_CARD:
627 ret = pccard_reset_card(s);
628 break;
629 case DS_GET_STATUS:
630 if (buf->status.Function &&
631 (buf->status.Function >= s->functions))
632 ret = CS_BAD_ARGS;
633 else {
634 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->status.Function);
635 ret = pccard_get_status(s, p_dev, &buf->status);
636 pcmcia_put_dev(p_dev);
637 }
638 break;
639 case DS_VALIDATE_CIS:
640 mutex_lock(&s->skt_mutex);
641 pcmcia_validate_mem(s);
642 mutex_unlock(&s->skt_mutex);
643 ret = pccard_validate_cis(s, BIND_FN_ALL, &buf->cisinfo);
644 break;
645 case DS_SUSPEND_CARD:
646 ret = pcmcia_suspend_card(s);
647 break;
648 case DS_RESUME_CARD:
649 ret = pcmcia_resume_card(s);
650 break;
651 case DS_EJECT_CARD:
652 err = pcmcia_eject_card(s);
653 break;
654 case DS_INSERT_CARD:
655 err = pcmcia_insert_card(s);
656 break;
657 case DS_ACCESS_CONFIGURATION_REGISTER:
658 if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
659 err = -EPERM;
660 goto free_out;
661 }
662
663 ret = CS_BAD_ARGS;
664
665 if (!(buf->conf_reg.Function &&
666 (buf->conf_reg.Function >= s->functions))) {
667 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->conf_reg.Function);
668 if (p_dev) {
669 ret = pcmcia_access_configuration_register(p_dev, &buf->conf_reg);
670 pcmcia_put_dev(p_dev);
671 }
672 }
673 break;
674 case DS_GET_FIRST_REGION:
675 case DS_GET_NEXT_REGION:
676 case DS_BIND_MTD:
677 if (!capable(CAP_SYS_ADMIN)) {
678 err = -EPERM;
679 goto free_out;
680 } else {
681 static int printed = 0;
682 if (!printed) {
683 printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
684 printk(KERN_WARNING "MTD handling any more.\n");
685 printed++;
686 }
687 }
688 err = -EINVAL;
689 goto free_out;
690 break;
691 case DS_GET_FIRST_WINDOW:
692 ret = pcmcia_get_window(s, &buf->win_info.handle, 0,
693 &buf->win_info.window);
694 break;
695 case DS_GET_NEXT_WINDOW:
696 ret = pcmcia_get_window(s, &buf->win_info.handle,
697 buf->win_info.handle->index + 1, &buf->win_info.window);
698 break;
699 case DS_GET_MEM_PAGE:
700 ret = pcmcia_get_mem_page(buf->win_info.handle,
701 &buf->win_info.map);
702 break;
703 case DS_REPLACE_CIS:
704 ret = pcmcia_replace_cis(s, &buf->cisdump);
705 break;
706 case DS_BIND_REQUEST:
707 if (!capable(CAP_SYS_ADMIN)) {
708 err = -EPERM;
709 goto free_out;
710 }
711 err = bind_request(s, &buf->bind_info);
712 break;
713 case DS_GET_DEVICE_INFO:
714 err = get_device_info(s, &buf->bind_info, 1);
715 break;
716 case DS_GET_NEXT_DEVICE:
717 err = get_device_info(s, &buf->bind_info, 0);
718 break;
719 case DS_UNBIND_REQUEST:
720 err = 0;
721 break;
722 default:
723 err = -EINVAL;
724 }
725
726 if ((err == 0) && (ret != CS_SUCCESS)) {
727 ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
728 switch (ret) {
729 case CS_BAD_SOCKET: case CS_NO_CARD:
730 err = -ENODEV; break;
731 case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
732 case CS_BAD_TUPLE:
733 err = -EINVAL; break;
734 case CS_IN_USE:
735 err = -EBUSY; break;
736 case CS_OUT_OF_RESOURCE:
737 err = -ENOSPC; break;
738 case CS_NO_MORE_ITEMS:
739 err = -ENODATA; break;
740 case CS_UNSUPPORTED_FUNCTION:
741 err = -ENOSYS; break;
742 default:
743 err = -EIO; break;
744 }
745 }
746
747 if (cmd & IOC_OUT) {
748 if (__copy_to_user(uarg, (char *)buf, size))
749 err = -EFAULT;
750 }
751
752 free_out:
753 kfree(buf);
754 return err;
755 } /* ds_ioctl */
756
757 /*====================================================================*/
758
759 static struct file_operations ds_fops = {
760 .owner = THIS_MODULE,
761 .open = ds_open,
762 .release = ds_release,
763 .ioctl = ds_ioctl,
764 .read = ds_read,
765 .write = ds_write,
766 .poll = ds_poll,
767 };
768
769 void __init pcmcia_setup_ioctl(void) {
770 int i;
771
772 /* Set up character device for user mode clients */
773 i = register_chrdev(0, "pcmcia", &ds_fops);
774 if (i < 0)
775 printk(KERN_NOTICE "unable to find a free device # for "
776 "Driver Services (error=%d)\n", i);
777 else
778 major_dev = i;
779
780 #ifdef CONFIG_PROC_FS
781 proc_pccard = proc_mkdir("pccard", proc_bus);
782 if (proc_pccard)
783 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
784 #endif
785 }
786
787
788 void __exit pcmcia_cleanup_ioctl(void) {
789 #ifdef CONFIG_PROC_FS
790 if (proc_pccard) {
791 remove_proc_entry("drivers", proc_pccard);
792 remove_proc_entry("pccard", proc_bus);
793 }
794 #endif
795 if (major_dev != -1)
796 unregister_chrdev(major_dev, "pcmcia");
797 }
Support for the Chinese Samsung S3C2440 based development boards