Merge branch 'bkl-removal' of git://git.lwn.net/linux-2.6
[linux-2.6.git] / drivers / pcmcia / pcmcia_ioctl.c
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/smp_lock.h>
31 #include <linux/workqueue.h>
32
33 #include <pcmcia/cs_types.h>
34 #include <pcmcia/cs.h>
35 #include <pcmcia/cistpl.h>
36 #include <pcmcia/cisreg.h>
37 #include <pcmcia/ds.h>
38 #include <pcmcia/ss.h>
39
40 #include "cs_internal.h"
41 #include "ds_internal.h"
42
43 static int major_dev = -1;
44
45
46 /* Device user information */
47 #define MAX_EVENTS      32
48 #define USER_MAGIC      0x7ea4
49 #define CHECK_USER(u) \
50     (((u) == NULL) || ((u)->user_magic != USER_MAGIC))
51
52 typedef struct user_info_t {
53         u_int                   user_magic;
54         int                     event_head, event_tail;
55         event_t                 event[MAX_EVENTS];
56         struct user_info_t      *next;
57         struct pcmcia_socket    *socket;
58 } user_info_t;
59
60
61 #ifdef DEBUG
62 extern int ds_pc_debug;
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         int rc;
132
133         rc = bus_for_each_drv(&pcmcia_bus_type, NULL,
134                               (void *) &p, proc_read_drivers_callback);
135         if (rc < 0)
136                 return rc;
137
138         return (p - buf);
139 }
140 #endif
141
142
143 #ifdef CONFIG_PCMCIA_PROBE
144
145 static int adjust_irq(struct pcmcia_socket *s, adjust_t *adj)
146 {
147         int irq;
148         u32 mask;
149
150         irq = adj->resource.irq.IRQ;
151         if ((irq < 0) || (irq > 15))
152                 return CS_BAD_IRQ;
153
154         if (adj->Action != REMOVE_MANAGED_RESOURCE)
155                 return 0;
156
157         mask = 1 << irq;
158
159         if (!(s->irq_mask & mask))
160                 return 0;
161
162         s->irq_mask &= ~mask;
163
164         return 0;
165 }
166
167 #else
168
169 static inline int adjust_irq(struct pcmcia_socket *s, adjust_t *adj) {
170         return CS_SUCCESS;
171 }
172
173 #endif
174
175 static int pcmcia_adjust_resource_info(adjust_t *adj)
176 {
177         struct pcmcia_socket *s;
178         int ret = CS_UNSUPPORTED_FUNCTION;
179         unsigned long flags;
180
181         down_read(&pcmcia_socket_list_rwsem);
182         list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
183
184                 if (adj->Resource == RES_IRQ)
185                         ret = adjust_irq(s, adj);
186
187                 else if (s->resource_ops->add_io) {
188                         unsigned long begin, end;
189
190                         /* you can't use the old interface if the new
191                          * one was used before */
192                         spin_lock_irqsave(&s->lock, flags);
193                         if ((s->resource_setup_new) &&
194                             !(s->resource_setup_old)) {
195                                 spin_unlock_irqrestore(&s->lock, flags);
196                                 continue;
197                         } else if (!(s->resource_setup_old))
198                                 s->resource_setup_old = 1;
199                         spin_unlock_irqrestore(&s->lock, flags);
200
201                         switch (adj->Resource) {
202                         case RES_MEMORY_RANGE:
203                                 begin = adj->resource.memory.Base;
204                                 end = adj->resource.memory.Base + adj->resource.memory.Size - 1;
205                                 if (s->resource_ops->add_mem)
206                                         ret =s->resource_ops->add_mem(s, adj->Action, begin, end);
207                         case RES_IO_RANGE:
208                                 begin = adj->resource.io.BasePort;
209                                 end = adj->resource.io.BasePort + adj->resource.io.NumPorts - 1;
210                                 if (s->resource_ops->add_io)
211                                         ret = s->resource_ops->add_io(s, adj->Action, begin, end);
212                         }
213                         if (!ret) {
214                                 /* as there's no way we know this is the
215                                  * last call to adjust_resource_info, we
216                                  * always need to assume this is the latest
217                                  * one... */
218                                 spin_lock_irqsave(&s->lock, flags);
219                                 s->resource_setup_done = 1;
220                                 spin_unlock_irqrestore(&s->lock, flags);
221                         }
222                 }
223         }
224         up_read(&pcmcia_socket_list_rwsem);
225
226         return (ret);
227 }
228
229 /** pccard_get_status
230  *
231  * Get the current socket state bits.  We don't support the latched
232  * SocketState yet: I haven't seen any point for it.
233  */
234
235 static int pccard_get_status(struct pcmcia_socket *s,
236                              struct pcmcia_device *p_dev,
237                              cs_status_t *status)
238 {
239         config_t *c;
240         int val;
241
242         s->ops->get_status(s, &val);
243         status->CardState = status->SocketState = 0;
244         status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
245         status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
246         status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
247         status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
248         if (s->state & SOCKET_SUSPEND)
249                 status->CardState |= CS_EVENT_PM_SUSPEND;
250         if (!(s->state & SOCKET_PRESENT))
251                 return CS_NO_CARD;
252
253         c = (p_dev) ? p_dev->function_config : NULL;
254
255         if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
256             (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
257                 u_char reg;
258                 if (c->CardValues & PRESENT_PIN_REPLACE) {
259                         pcmcia_read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, &reg);
260                         status->CardState |=
261                                 (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
262                         status->CardState |=
263                                 (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
264                         status->CardState |=
265                                 (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
266                         status->CardState |=
267                                 (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
268                 } else {
269                         /* No PRR?  Then assume we're always ready */
270                         status->CardState |= CS_EVENT_READY_CHANGE;
271                 }
272                 if (c->CardValues & PRESENT_EXT_STATUS) {
273                         pcmcia_read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, &reg);
274                         status->CardState |=
275                                 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
276                 }
277                 return CS_SUCCESS;
278         }
279         status->CardState |=
280                 (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
281         status->CardState |=
282                 (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
283         status->CardState |=
284                 (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
285         status->CardState |=
286                 (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
287         return CS_SUCCESS;
288 } /* pccard_get_status */
289
290 /*======================================================================
291
292     These manage a ring buffer of events pending for one user process
293
294 ======================================================================*/
295
296
297 static int queue_empty(user_info_t *user)
298 {
299     return (user->event_head == user->event_tail);
300 }
301
302 static event_t get_queued_event(user_info_t *user)
303 {
304     user->event_tail = (user->event_tail+1) % MAX_EVENTS;
305     return user->event[user->event_tail];
306 }
307
308 static void queue_event(user_info_t *user, event_t event)
309 {
310     user->event_head = (user->event_head+1) % MAX_EVENTS;
311     if (user->event_head == user->event_tail)
312         user->event_tail = (user->event_tail+1) % MAX_EVENTS;
313     user->event[user->event_head] = event;
314 }
315
316 void handle_event(struct pcmcia_socket *s, event_t event)
317 {
318     user_info_t *user;
319     for (user = s->user; user; user = user->next)
320         queue_event(user, event);
321     wake_up_interruptible(&s->queue);
322 }
323
324
325 /*======================================================================
326
327     bind_request() and bind_device() are merged by now. Register_client()
328     is called right at the end of bind_request(), during the driver's
329     ->attach() call. Individual descriptions:
330
331     bind_request() connects a socket to a particular client driver.
332     It looks up the specified device ID in the list of registered
333     drivers, binds it to the socket, and tries to create an instance
334     of the device.  unbind_request() deletes a driver instance.
335
336     Bind_device() associates a device driver with a particular socket.
337     It is normally called by Driver Services after it has identified
338     a newly inserted card.  An instance of that driver will then be
339     eligible to register as a client of this socket.
340
341     Register_client() uses the dev_info_t handle to match the
342     caller with a socket.  The driver must have already been bound
343     to a socket with bind_device() -- in fact, bind_device()
344     allocates the client structure that will be used.
345
346 ======================================================================*/
347
348 static int bind_request(struct pcmcia_socket *s, bind_info_t *bind_info)
349 {
350         struct pcmcia_driver *p_drv;
351         struct pcmcia_device *p_dev;
352         int ret = 0;
353         unsigned long flags;
354
355         s = pcmcia_get_socket(s);
356         if (!s)
357                 return -EINVAL;
358
359         ds_dbg(2, "bind_request(%d, '%s')\n", s->sock,
360                (char *)bind_info->dev_info);
361
362         p_drv = get_pcmcia_driver(&bind_info->dev_info);
363         if (!p_drv) {
364                 ret = -EINVAL;
365                 goto err_put;
366         }
367
368         if (!try_module_get(p_drv->owner)) {
369                 ret = -EINVAL;
370                 goto err_put_driver;
371         }
372
373         spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
374         list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
375                 if (p_dev->func == bind_info->function) {
376                         if ((p_dev->dev.driver == &p_drv->drv)) {
377                                 if (p_dev->cardmgr) {
378                                         /* if there's already a device
379                                          * registered, and it was registered
380                                          * by userspace before, we need to
381                                          * return the "instance". */
382                                         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
383                                         bind_info->instance = p_dev;
384                                         ret = -EBUSY;
385                                         goto err_put_module;
386                                 } else {
387                                         /* the correct driver managed to bind
388                                          * itself magically to the correct
389                                          * device. */
390                                         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
391                                         p_dev->cardmgr = p_drv;
392                                         ret = 0;
393                                         goto err_put_module;
394                                 }
395                         } else if (!p_dev->dev.driver) {
396                                 /* there's already a device available where
397                                  * no device has been bound to yet. So we don't
398                                  * need to register a device! */
399                                 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
400                                 goto rescan;
401                         }
402                 }
403         }
404         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
405
406         p_dev = pcmcia_device_add(s, bind_info->function);
407         if (!p_dev) {
408                 ret = -EIO;
409                 goto err_put_module;
410         }
411
412 rescan:
413         p_dev->cardmgr = p_drv;
414
415         /* if a driver is already running, we can abort */
416         if (p_dev->dev.driver)
417                 goto err_put_module;
418
419         /*
420          * Prevent this racing with a card insertion.
421          */
422         mutex_lock(&s->skt_mutex);
423         ret = bus_rescan_devices(&pcmcia_bus_type);
424         mutex_unlock(&s->skt_mutex);
425         if (ret)
426                 goto err_put_module;
427
428         /* check whether the driver indeed matched. I don't care if this
429          * is racy or not, because it can only happen on cardmgr access
430          * paths...
431          */
432         if (!(p_dev->dev.driver == &p_drv->drv))
433                 p_dev->cardmgr = NULL;
434
435  err_put_module:
436         module_put(p_drv->owner);
437  err_put_driver:
438         put_driver(&p_drv->drv);
439  err_put:
440         pcmcia_put_socket(s);
441
442         return (ret);
443 } /* bind_request */
444
445 #ifdef CONFIG_CARDBUS
446
447 static struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
448 {
449         if (!s || !(s->state & SOCKET_CARDBUS))
450                 return NULL;
451
452         return s->cb_dev->subordinate;
453 }
454 #endif
455
456 static int get_device_info(struct pcmcia_socket *s, bind_info_t *bind_info, int first)
457 {
458         dev_node_t *node;
459         struct pcmcia_device *p_dev;
460         struct pcmcia_driver *p_drv;
461         unsigned long flags;
462         int ret = 0;
463
464 #ifdef CONFIG_CARDBUS
465         /*
466          * Some unbelievably ugly code to associate the PCI cardbus
467          * device and its driver with the PCMCIA "bind" information.
468          */
469         {
470                 struct pci_bus *bus;
471
472                 bus = pcmcia_lookup_bus(s);
473                 if (bus) {
474                         struct list_head *list;
475                         struct pci_dev *dev = NULL;
476
477                         list = bus->devices.next;
478                         while (list != &bus->devices) {
479                                 struct pci_dev *pdev = pci_dev_b(list);
480                                 list = list->next;
481
482                                 if (first) {
483                                         dev = pdev;
484                                         break;
485                                 }
486
487                                 /* Try to handle "next" here some way? */
488                         }
489                         if (dev && dev->driver) {
490                                 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
491                                 bind_info->major = 0;
492                                 bind_info->minor = 0;
493                                 bind_info->next = NULL;
494                                 return 0;
495                         }
496                 }
497         }
498 #endif
499
500         spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
501         list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
502                 if (p_dev->func == bind_info->function) {
503                         p_dev = pcmcia_get_dev(p_dev);
504                         if (!p_dev)
505                                 continue;
506                         goto found;
507                 }
508         }
509         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
510         return -ENODEV;
511
512  found:
513         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
514
515         p_drv = to_pcmcia_drv(p_dev->dev.driver);
516         if (p_drv && !p_dev->_locked) {
517                 ret = -EAGAIN;
518                 goto err_put;
519         }
520
521         if (first)
522                 node = p_dev->dev_node;
523         else
524                 for (node = p_dev->dev_node; node; node = node->next)
525                         if (node == bind_info->next)
526                                 break;
527         if (!node) {
528                 ret = -ENODEV;
529                 goto err_put;
530         }
531
532         strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
533         bind_info->major = node->major;
534         bind_info->minor = node->minor;
535         bind_info->next = node->next;
536
537  err_put:
538         pcmcia_put_dev(p_dev);
539         return (ret);
540 } /* get_device_info */
541
542
543 static int ds_open(struct inode *inode, struct file *file)
544 {
545     socket_t i = iminor(inode);
546     struct pcmcia_socket *s;
547     user_info_t *user;
548     static int warning_printed = 0;
549     int ret = 0;
550
551     ds_dbg(0, "ds_open(socket %d)\n", i);
552
553     lock_kernel();
554     s = pcmcia_get_socket_by_nr(i);
555     if (!s) {
556             ret = -ENODEV;
557             goto out;
558     }
559     s = pcmcia_get_socket(s);
560     if (!s) {
561             ret = -ENODEV;
562             goto out;
563     }
564
565     if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
566             if (s->pcmcia_state.busy) {
567                     pcmcia_put_socket(s);
568                     ret = -EBUSY;
569                     goto out;
570             }
571         else
572             s->pcmcia_state.busy = 1;
573     }
574
575     user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
576     if (!user) {
577             pcmcia_put_socket(s);
578             ret = -ENOMEM;
579             goto out;
580     }
581     user->event_tail = user->event_head = 0;
582     user->next = s->user;
583     user->user_magic = USER_MAGIC;
584     user->socket = s;
585     s->user = user;
586     file->private_data = user;
587
588     if (!warning_printed) {
589             printk(KERN_INFO "pcmcia: Detected deprecated PCMCIA ioctl "
590                         "usage from process: %s.\n", current->comm);
591             printk(KERN_INFO "pcmcia: This interface will soon be removed from "
592                         "the kernel; please expect breakage unless you upgrade "
593                         "to new tools.\n");
594             printk(KERN_INFO "pcmcia: see http://www.kernel.org/pub/linux/"
595                         "utils/kernel/pcmcia/pcmcia.html for details.\n");
596             warning_printed = 1;
597     }
598
599     if (s->pcmcia_state.present)
600         queue_event(user, CS_EVENT_CARD_INSERTION);
601 out:
602     unlock_kernel();
603     return ret;
604 } /* ds_open */
605
606 /*====================================================================*/
607
608 static int ds_release(struct inode *inode, struct file *file)
609 {
610     struct pcmcia_socket *s;
611     user_info_t *user, **link;
612
613     ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
614
615     user = file->private_data;
616     if (CHECK_USER(user))
617         goto out;
618
619     s = user->socket;
620
621     /* Unlink user data structure */
622     if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
623         s->pcmcia_state.busy = 0;
624     }
625     file->private_data = NULL;
626     for (link = &s->user; *link; link = &(*link)->next)
627         if (*link == user) break;
628     if (link == NULL)
629         goto out;
630     *link = user->next;
631     user->user_magic = 0;
632     kfree(user);
633     pcmcia_put_socket(s);
634 out:
635     return 0;
636 } /* ds_release */
637
638 /*====================================================================*/
639
640 static ssize_t ds_read(struct file *file, char __user *buf,
641                        size_t count, loff_t *ppos)
642 {
643     struct pcmcia_socket *s;
644     user_info_t *user;
645     int ret;
646
647     ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_path.dentry->d_inode));
648
649     if (count < 4)
650         return -EINVAL;
651
652     user = file->private_data;
653     if (CHECK_USER(user))
654         return -EIO;
655
656     s = user->socket;
657     if (s->pcmcia_state.dead)
658         return -EIO;
659
660     ret = wait_event_interruptible(s->queue, !queue_empty(user));
661     if (ret == 0)
662         ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
663
664     return ret;
665 } /* ds_read */
666
667 /*====================================================================*/
668
669 static ssize_t ds_write(struct file *file, const char __user *buf,
670                         size_t count, loff_t *ppos)
671 {
672     ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_path.dentry->d_inode));
673
674     if (count != 4)
675         return -EINVAL;
676     if ((file->f_flags & O_ACCMODE) == O_RDONLY)
677         return -EBADF;
678
679     return -EIO;
680 } /* ds_write */
681
682 /*====================================================================*/
683
684 /* No kernel lock - fine */
685 static u_int ds_poll(struct file *file, poll_table *wait)
686 {
687     struct pcmcia_socket *s;
688     user_info_t *user;
689
690     ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_path.dentry->d_inode));
691
692     user = file->private_data;
693     if (CHECK_USER(user))
694         return POLLERR;
695     s = user->socket;
696     /*
697      * We don't check for a dead socket here since that
698      * will send cardmgr into an endless spin.
699      */
700     poll_wait(file, &s->queue, wait);
701     if (!queue_empty(user))
702         return POLLIN | POLLRDNORM;
703     return 0;
704 } /* ds_poll */
705
706 /*====================================================================*/
707
708 static int ds_ioctl(struct inode * inode, struct file * file,
709                     u_int cmd, u_long arg)
710 {
711     struct pcmcia_socket *s;
712     void __user *uarg = (char __user *)arg;
713     u_int size;
714     int ret, err;
715     ds_ioctl_arg_t *buf;
716     user_info_t *user;
717
718     ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
719
720     user = file->private_data;
721     if (CHECK_USER(user))
722         return -EIO;
723
724     s = user->socket;
725     if (s->pcmcia_state.dead)
726         return -EIO;
727
728     size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
729     if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
730
731     /* Permission check */
732     if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
733         return -EPERM;
734
735     if (cmd & IOC_IN) {
736         if (!access_ok(VERIFY_READ, uarg, size)) {
737             ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
738             return -EFAULT;
739         }
740     }
741     if (cmd & IOC_OUT) {
742         if (!access_ok(VERIFY_WRITE, uarg, size)) {
743             ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
744             return -EFAULT;
745         }
746     }
747     buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
748     if (!buf)
749         return -ENOMEM;
750
751     err = ret = 0;
752
753     if (cmd & IOC_IN) {
754         if (__copy_from_user((char *)buf, uarg, size)) {
755             err = -EFAULT;
756             goto free_out;
757         }
758     }
759
760     switch (cmd) {
761     case DS_ADJUST_RESOURCE_INFO:
762         ret = pcmcia_adjust_resource_info(&buf->adjust);
763         break;
764     case DS_GET_CONFIGURATION_INFO:
765         if (buf->config.Function &&
766            (buf->config.Function >= s->functions))
767             ret = CS_BAD_ARGS;
768         else {
769             struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->config.Function);
770             ret = pccard_get_configuration_info(s, p_dev, &buf->config);
771             pcmcia_put_dev(p_dev);
772         }
773         break;
774     case DS_GET_FIRST_TUPLE:
775         mutex_lock(&s->skt_mutex);
776         pcmcia_validate_mem(s);
777         mutex_unlock(&s->skt_mutex);
778         ret = pccard_get_first_tuple(s, BIND_FN_ALL, &buf->tuple);
779         break;
780     case DS_GET_NEXT_TUPLE:
781         ret = pccard_get_next_tuple(s, BIND_FN_ALL, &buf->tuple);
782         break;
783     case DS_GET_TUPLE_DATA:
784         buf->tuple.TupleData = buf->tuple_parse.data;
785         buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
786         ret = pccard_get_tuple_data(s, &buf->tuple);
787         break;
788     case DS_PARSE_TUPLE:
789         buf->tuple.TupleData = buf->tuple_parse.data;
790         ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
791         break;
792     case DS_RESET_CARD:
793         ret = pccard_reset_card(s);
794         break;
795     case DS_GET_STATUS:
796             if (buf->status.Function &&
797                 (buf->status.Function >= s->functions))
798                     ret = CS_BAD_ARGS;
799             else {
800                     struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->status.Function);
801                     ret = pccard_get_status(s, p_dev, &buf->status);
802                     pcmcia_put_dev(p_dev);
803             }
804             break;
805     case DS_VALIDATE_CIS:
806         mutex_lock(&s->skt_mutex);
807         pcmcia_validate_mem(s);
808         mutex_unlock(&s->skt_mutex);
809         ret = pccard_validate_cis(s, BIND_FN_ALL, &buf->cisinfo.Chains);
810         break;
811     case DS_SUSPEND_CARD:
812         ret = pcmcia_suspend_card(s);
813         break;
814     case DS_RESUME_CARD:
815         ret = pcmcia_resume_card(s);
816         break;
817     case DS_EJECT_CARD:
818         err = pcmcia_eject_card(s);
819         break;
820     case DS_INSERT_CARD:
821         err = pcmcia_insert_card(s);
822         break;
823     case DS_ACCESS_CONFIGURATION_REGISTER:
824         if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
825             err = -EPERM;
826             goto free_out;
827         }
828
829         ret = CS_BAD_ARGS;
830
831         if (!(buf->conf_reg.Function &&
832              (buf->conf_reg.Function >= s->functions))) {
833                 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->conf_reg.Function);
834                 if (p_dev) {
835                         ret = pcmcia_access_configuration_register(p_dev, &buf->conf_reg);
836                         pcmcia_put_dev(p_dev);
837                 }
838         }
839         break;
840     case DS_GET_FIRST_REGION:
841     case DS_GET_NEXT_REGION:
842     case DS_BIND_MTD:
843         if (!capable(CAP_SYS_ADMIN)) {
844                 err = -EPERM;
845                 goto free_out;
846         } else {
847                 static int printed = 0;
848                 if (!printed) {
849                         printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
850                         printk(KERN_WARNING "MTD handling any more.\n");
851                         printed++;
852                 }
853         }
854         err = -EINVAL;
855         goto free_out;
856         break;
857     case DS_GET_FIRST_WINDOW:
858         ret = pcmcia_get_window(s, &buf->win_info.handle, 0,
859                         &buf->win_info.window);
860         break;
861     case DS_GET_NEXT_WINDOW:
862         ret = pcmcia_get_window(s, &buf->win_info.handle,
863                         buf->win_info.handle->index + 1, &buf->win_info.window);
864         break;
865     case DS_GET_MEM_PAGE:
866         ret = pcmcia_get_mem_page(buf->win_info.handle,
867                            &buf->win_info.map);
868         break;
869     case DS_REPLACE_CIS:
870         ret = pcmcia_replace_cis(s, &buf->cisdump);
871         break;
872     case DS_BIND_REQUEST:
873         if (!capable(CAP_SYS_ADMIN)) {
874                 err = -EPERM;
875                 goto free_out;
876         }
877         err = bind_request(s, &buf->bind_info);
878         break;
879     case DS_GET_DEVICE_INFO:
880         err = get_device_info(s, &buf->bind_info, 1);
881         break;
882     case DS_GET_NEXT_DEVICE:
883         err = get_device_info(s, &buf->bind_info, 0);
884         break;
885     case DS_UNBIND_REQUEST:
886         err = 0;
887         break;
888     default:
889         err = -EINVAL;
890     }
891
892     if ((err == 0) && (ret != CS_SUCCESS)) {
893         ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
894         switch (ret) {
895         case CS_BAD_SOCKET: case CS_NO_CARD:
896             err = -ENODEV; break;
897         case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
898         case CS_BAD_TUPLE:
899             err = -EINVAL; break;
900         case CS_IN_USE:
901             err = -EBUSY; break;
902         case CS_OUT_OF_RESOURCE:
903             err = -ENOSPC; break;
904         case CS_NO_MORE_ITEMS:
905             err = -ENODATA; break;
906         case CS_UNSUPPORTED_FUNCTION:
907             err = -ENOSYS; break;
908         default:
909             err = -EIO; break;
910         }
911     }
912
913     if (cmd & IOC_OUT) {
914         if (__copy_to_user(uarg, (char *)buf, size))
915             err = -EFAULT;
916     }
917
918 free_out:
919     kfree(buf);
920     return err;
921 } /* ds_ioctl */
922
923 /*====================================================================*/
924
925 static const struct file_operations ds_fops = {
926         .owner          = THIS_MODULE,
927         .open           = ds_open,
928         .release        = ds_release,
929         .ioctl          = ds_ioctl,
930         .read           = ds_read,
931         .write          = ds_write,
932         .poll           = ds_poll,
933 };
934
935 void __init pcmcia_setup_ioctl(void) {
936         int i;
937
938         /* Set up character device for user mode clients */
939         i = register_chrdev(0, "pcmcia", &ds_fops);
940         if (i < 0)
941                 printk(KERN_NOTICE "unable to find a free device # for "
942                        "Driver Services (error=%d)\n", i);
943         else
944                 major_dev = i;
945
946 #ifdef CONFIG_PROC_FS
947         proc_pccard = proc_mkdir("bus/pccard", NULL);
948         if (proc_pccard)
949                 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
950 #endif
951 }
952
953
954 void __exit pcmcia_cleanup_ioctl(void) {
955 #ifdef CONFIG_PROC_FS
956         if (proc_pccard) {
957                 remove_proc_entry("drivers", proc_pccard);
958                 remove_proc_entry("bus/pccard", NULL);
959         }
960 #endif
961         if (major_dev != -1)
962                 unregister_chrdev(major_dev, "pcmcia");
963 }