git.oblomov.eu Git - linux-2.6/blob - 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/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>
  32
  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>
  40
  41 #include "cs_internal.h"
  42 #include "ds_internal.h"
  43
  44 static int major_dev = -1;
  45
  46
  47 /* Device user information */
  48 #define MAX_EVENTS      32
  49 #define USER_MAGIC      0x7ea4
  50 #define CHECK_USER(u) \
  51     (((u) == NULL) || ((u)->user_magic != USER_MAGIC))
  52
  53 typedef struct user_info_t {
  54         u_int                   user_magic;
  55         int                     event_head, event_tail;
  56         event_t                 event[MAX_EVENTS];
  57         struct user_info_t      *next;
  58         struct pcmcia_socket    *socket;
  59 } user_info_t;
  60
  61
  62 #ifdef DEBUG
  63 extern int ds_pc_debug;
  64 #define cs_socket_name(skt)    ((skt)->dev.class_id)
  65
  66 #define ds_dbg(lvl, fmt, arg...) do {           \
  67         if (ds_pc_debug >= lvl)                         \
  68                 printk(KERN_DEBUG "ds: " fmt , ## arg);         \
  69 } while (0)
  70 #else
  71 #define ds_dbg(lvl, fmt, arg...) do { } while (0)
  72 #endif
  73
  74 static const char *release = "Linux Kernel Card Services";
  75
  76 /** pcmcia_get_card_services_info
  77  *
  78  * Return information about this version of Card Services
  79  */
  80 static int pcmcia_get_card_services_info(servinfo_t *info)
  81 {
  82         unsigned int socket_count = 0;
  83         struct list_head *tmp;
  84         info->Signature[0] = 'C';
  85         info->Signature[1] = 'S';
  86         down_read(&pcmcia_socket_list_rwsem);
  87         list_for_each(tmp, &pcmcia_socket_list)
  88                 socket_count++;
  89         up_read(&pcmcia_socket_list_rwsem);
  90         info->Count = socket_count;
  91         info->Revision = CS_RELEASE_CODE;
  92         info->CSLevel = 0x0210;
  93         info->VendorString = (char *)release;
  94         return CS_SUCCESS;
  95 } /* get_card_services_info */
  96
  97
  98 /* backwards-compatible accessing of driver --- by name! */
  99
 100 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info)
 101 {
 102         struct device_driver *drv;
 103         struct pcmcia_driver *p_drv;
 104
 105         drv = driver_find((char *) dev_info, &pcmcia_bus_type);
 106         if (!drv)
 107                 return NULL;
 108
 109         p_drv = container_of(drv, struct pcmcia_driver, drv);
 110
 111         return (p_drv);
 112 }
 113
 114
 115 #ifdef CONFIG_PROC_FS
 116 static struct proc_dir_entry *proc_pccard = NULL;
 117
 118 static int proc_read_drivers_callback(struct device_driver *driver, void *d)
 119 {
 120         char **p = d;
 121         struct pcmcia_driver *p_drv = container_of(driver,
 122                                                    struct pcmcia_driver, drv);
 123
 124         *p += sprintf(*p, "%-24.24s 1 %d\n", p_drv->drv.name,
 125 #ifdef CONFIG_MODULE_UNLOAD
 126                       (p_drv->owner) ? module_refcount(p_drv->owner) : 1
 127 #else
 128                       1
 129 #endif
 130         );
 131         d = (void *) p;
 132
 133         return 0;
 134 }
 135
 136 static int proc_read_drivers(char *buf, char **start, off_t pos,
 137                              int count, int *eof, void *data)
 138 {
 139         char *p = buf;
 140
 141         bus_for_each_drv(&pcmcia_bus_type, NULL,
 142                          (void *) &p, proc_read_drivers_callback);
 143
 144         return (p - buf);
 145 }
 146 #endif
 147
 148 /*======================================================================
 149
 150     These manage a ring buffer of events pending for one user process
 151
 152 ======================================================================*/
 153
 154
 155 static int queue_empty(user_info_t *user)
 156 {
 157     return (user->event_head == user->event_tail);
 158 }
 159
 160 static event_t get_queued_event(user_info_t *user)
 161 {
 162     user->event_tail = (user->event_tail+1) % MAX_EVENTS;
 163     return user->event[user->event_tail];
 164 }
 165
 166 static void queue_event(user_info_t *user, event_t event)
 167 {
 168     user->event_head = (user->event_head+1) % MAX_EVENTS;
 169     if (user->event_head == user->event_tail)
 170         user->event_tail = (user->event_tail+1) % MAX_EVENTS;
 171     user->event[user->event_head] = event;
 172 }
 173
 174 void handle_event(struct pcmcia_socket *s, event_t event)
 175 {
 176     user_info_t *user;
 177     for (user = s->user; user; user = user->next)
 178         queue_event(user, event);
 179     wake_up_interruptible(&s->queue);
 180 }
 181
 182
 183 /*======================================================================
 184
 185     bind_request() and bind_device() are merged by now. Register_client()
 186     is called right at the end of bind_request(), during the driver's
 187     ->attach() call. Individual descriptions:
 188
 189     bind_request() connects a socket to a particular client driver.
 190     It looks up the specified device ID in the list of registered
 191     drivers, binds it to the socket, and tries to create an instance
 192     of the device.  unbind_request() deletes a driver instance.
 193
 194     Bind_device() associates a device driver with a particular socket.
 195     It is normally called by Driver Services after it has identified
 196     a newly inserted card.  An instance of that driver will then be
 197     eligible to register as a client of this socket.
 198
 199     Register_client() uses the dev_info_t handle to match the
 200     caller with a socket.  The driver must have already been bound
 201     to a socket with bind_device() -- in fact, bind_device()
 202     allocates the client structure that will be used.
 203
 204 ======================================================================*/
 205
 206 static int bind_request(struct pcmcia_socket *s, bind_info_t *bind_info)
 207 {
 208         struct pcmcia_driver *p_drv;
 209         struct pcmcia_device *p_dev;
 210         int ret = 0;
 211         unsigned long flags;
 212
 213         s = pcmcia_get_socket(s);
 214         if (!s)
 215                 return -EINVAL;
 216
 217         ds_dbg(2, "bind_request(%d, '%s')\n", s->sock,
 218                (char *)bind_info->dev_info);
 219
 220         p_drv = get_pcmcia_driver(&bind_info->dev_info);
 221         if (!p_drv) {
 222                 ret = -EINVAL;
 223                 goto err_put;
 224         }
 225
 226         if (!try_module_get(p_drv->owner)) {
 227                 ret = -EINVAL;
 228                 goto err_put_driver;
 229         }
 230
 231         spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
 232         list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
 233                 if (p_dev->func == bind_info->function) {
 234                         if ((p_dev->dev.driver == &p_drv->drv)) {
 235                                 if (p_dev->cardmgr) {
 236                                         /* if there's already a device
 237                                          * registered, and it was registered
 238                                          * by userspace before, we need to
 239                                          * return the "instance". */
 240                                         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
 241                                         bind_info->instance = p_dev->instance;
 242                                         ret = -EBUSY;
 243                                         goto err_put_module;
 244                                 } else {
 245                                         /* the correct driver managed to bind
 246                                          * itself magically to the correct
 247                                          * device. */
 248                                         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
 249                                         p_dev->cardmgr = p_drv;
 250                                         ret = 0;
 251                                         goto err_put_module;
 252                                 }
 253                         } else if (!p_dev->dev.driver) {
 254                                 /* there's already a device available where
 255                                  * no device has been bound to yet. So we don't
 256                                  * need to register a device! */
 257                                 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
 258                                 goto rescan;
 259                         }
 260                 }
 261         }
 262         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
 263
 264         p_dev = pcmcia_device_add(s, bind_info->function);
 265         if (!p_dev) {
 266                 ret = -EIO;
 267                 goto err_put_module;
 268         }
 269
 270 rescan:
 271         p_dev->cardmgr = p_drv;
 272
 273         /* if a driver is already running, we can abort */
 274         if (p_dev->dev.driver)
 275                 goto err_put_module;
 276
 277         /*
 278          * Prevent this racing with a card insertion.
 279          */
 280         down(&s->skt_sem);
 281         bus_rescan_devices(&pcmcia_bus_type);
 282         up(&s->skt_sem);
 283
 284         /* check whether the driver indeed matched. I don't care if this
 285          * is racy or not, because it can only happen on cardmgr access
 286          * paths...
 287          */
 288         if (!(p_dev->dev.driver == &p_drv->drv))
 289                 p_dev->cardmgr = NULL;
 290
 291  err_put_module:
 292         module_put(p_drv->owner);
 293  err_put_driver:
 294         put_driver(&p_drv->drv);
 295  err_put:
 296         pcmcia_put_socket(s);
 297
 298         return (ret);
 299 } /* bind_request */
 300
 301 #ifdef CONFIG_CARDBUS
 302
 303 static struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
 304 {
 305         if (!s || !(s->state & SOCKET_CARDBUS))
 306                 return NULL;
 307
 308         return s->cb_dev->subordinate;
 309 }
 310 #endif
 311
 312 static int get_device_info(struct pcmcia_socket *s, bind_info_t *bind_info, int first)
 313 {
 314         dev_node_t *node;
 315         struct pcmcia_device *p_dev;
 316         unsigned long flags;
 317         int ret = 0;
 318
 319 #ifdef CONFIG_CARDBUS
 320         /*
 321          * Some unbelievably ugly code to associate the PCI cardbus
 322          * device and its driver with the PCMCIA "bind" information.
 323          */
 324         {
 325                 struct pci_bus *bus;
 326
 327                 bus = pcmcia_lookup_bus(s);
 328                 if (bus) {
 329                         struct list_head *list;
 330                         struct pci_dev *dev = NULL;
 331
 332                         list = bus->devices.next;
 333                         while (list != &bus->devices) {
 334                                 struct pci_dev *pdev = pci_dev_b(list);
 335                                 list = list->next;
 336
 337                                 if (first) {
 338                                         dev = pdev;
 339                                         break;
 340                                 }
 341
 342                                 /* Try to handle "next" here some way? */
 343                         }
 344                         if (dev && dev->driver) {
 345                                 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
 346                                 bind_info->major = 0;
 347                                 bind_info->minor = 0;
 348                                 bind_info->next = NULL;
 349                                 return 0;
 350                         }
 351                 }
 352         }
 353 #endif
 354
 355         spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
 356         list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
 357                 if (p_dev->func == bind_info->function) {
 358                         p_dev = pcmcia_get_dev(p_dev);
 359                         if (!p_dev)
 360                                 continue;
 361                         goto found;
 362                 }
 363         }
 364         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
 365         return -ENODEV;
 366
 367  found:
 368         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
 369
 370         if ((!p_dev->instance) ||
 371             (p_dev->instance->state & DEV_CONFIG_PENDING)) {
 372                 ret = -EAGAIN;
 373                 goto err_put;
 374         }
 375
 376         if (first)
 377                 node = p_dev->instance->dev;
 378         else
 379                 for (node = p_dev->instance->dev; node; node = node->next)
 380                         if (node == bind_info->next)
 381                                 break;
 382         if (!node) {
 383                 ret = -ENODEV;
 384                 goto err_put;
 385         }
 386
 387         strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
 388         bind_info->major = node->major;
 389         bind_info->minor = node->minor;
 390         bind_info->next = node->next;
 391
 392  err_put:
 393         pcmcia_put_dev(p_dev);
 394         return (ret);
 395 } /* get_device_info */
 396
 397
 398 static int ds_open(struct inode *inode, struct file *file)
 399 {
 400     socket_t i = iminor(inode);
 401     struct pcmcia_socket *s;
 402     user_info_t *user;
 403
 404     ds_dbg(0, "ds_open(socket %d)\n", i);
 405
 406     s = pcmcia_get_socket_by_nr(i);
 407     if (!s)
 408             return -ENODEV;
 409     s = pcmcia_get_socket(s);
 410     if (!s)
 411             return -ENODEV;
 412
 413     if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
 414             if (s->pcmcia_state.busy) {
 415                     pcmcia_put_socket(s);
 416                     return -EBUSY;
 417             }
 418         else
 419             s->pcmcia_state.busy = 1;
 420     }
 421
 422     user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
 423     if (!user) {
 424             pcmcia_put_socket(s);
 425             return -ENOMEM;
 426     }
 427     user->event_tail = user->event_head = 0;
 428     user->next = s->user;
 429     user->user_magic = USER_MAGIC;
 430     user->socket = s;
 431     s->user = user;
 432     file->private_data = user;
 433
 434     if (s->pcmcia_state.present)
 435         queue_event(user, CS_EVENT_CARD_INSERTION);
 436     return 0;
 437 } /* ds_open */
 438
 439 /*====================================================================*/
 440
 441 static int ds_release(struct inode *inode, struct file *file)
 442 {
 443     struct pcmcia_socket *s;
 444     user_info_t *user, **link;
 445
 446     ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
 447
 448     user = file->private_data;
 449     if (CHECK_USER(user))
 450         goto out;
 451
 452     s = user->socket;
 453
 454     /* Unlink user data structure */
 455     if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
 456         s->pcmcia_state.busy = 0;
 457     }
 458     file->private_data = NULL;
 459     for (link = &s->user; *link; link = &(*link)->next)
 460         if (*link == user) break;
 461     if (link == NULL)
 462         goto out;
 463     *link = user->next;
 464     user->user_magic = 0;
 465     kfree(user);
 466     pcmcia_put_socket(s);
 467 out:
 468     return 0;
 469 } /* ds_release */
 470
 471 /*====================================================================*/
 472
 473 static ssize_t ds_read(struct file *file, char __user *buf,
 474                        size_t count, loff_t *ppos)
 475 {
 476     struct pcmcia_socket *s;
 477     user_info_t *user;
 478     int ret;
 479
 480     ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));
 481
 482     if (count < 4)
 483         return -EINVAL;
 484
 485     user = file->private_data;
 486     if (CHECK_USER(user))
 487         return -EIO;
 488
 489     s = user->socket;
 490     if (s->pcmcia_state.dead)
 491         return -EIO;
 492
 493     ret = wait_event_interruptible(s->queue, !queue_empty(user));
 494     if (ret == 0)
 495         ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
 496
 497     return ret;
 498 } /* ds_read */
 499
 500 /*====================================================================*/
 501
 502 static ssize_t ds_write(struct file *file, const char __user *buf,
 503                         size_t count, loff_t *ppos)
 504 {
 505     ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));
 506
 507     if (count != 4)
 508         return -EINVAL;
 509     if ((file->f_flags & O_ACCMODE) == O_RDONLY)
 510         return -EBADF;
 511
 512     return -EIO;
 513 } /* ds_write */
 514
 515 /*====================================================================*/
 516
 517 /* No kernel lock - fine */
 518 static u_int ds_poll(struct file *file, poll_table *wait)
 519 {
 520     struct pcmcia_socket *s;
 521     user_info_t *user;
 522
 523     ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
 524
 525     user = file->private_data;
 526     if (CHECK_USER(user))
 527         return POLLERR;
 528     s = user->socket;
 529     /*
 530      * We don't check for a dead socket here since that
 531      * will send cardmgr into an endless spin.
 532      */
 533     poll_wait(file, &s->queue, wait);
 534     if (!queue_empty(user))
 535         return POLLIN | POLLRDNORM;
 536     return 0;
 537 } /* ds_poll */
 538
 539 /*====================================================================*/
 540
 541 extern int pcmcia_adjust_resource_info(adjust_t *adj);
 542
 543 static int ds_ioctl(struct inode * inode, struct file * file,
 544                     u_int cmd, u_long arg)
 545 {
 546     struct pcmcia_socket *s;
 547     void __user *uarg = (char __user *)arg;
 548     u_int size;
 549     int ret, err;
 550     ds_ioctl_arg_t *buf;
 551     user_info_t *user;
 552
 553     ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
 554
 555     user = file->private_data;
 556     if (CHECK_USER(user))
 557         return -EIO;
 558
 559     s = user->socket;
 560     if (s->pcmcia_state.dead)
 561         return -EIO;
 562
 563     size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
 564     if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
 565
 566     /* Permission check */
 567     if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
 568         return -EPERM;
 569
 570     if (cmd & IOC_IN) {
 571         if (!access_ok(VERIFY_READ, uarg, size)) {
 572             ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
 573             return -EFAULT;
 574         }
 575     }
 576     if (cmd & IOC_OUT) {
 577         if (!access_ok(VERIFY_WRITE, uarg, size)) {
 578             ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
 579             return -EFAULT;
 580         }
 581     }
 582     buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
 583     if (!buf)
 584         return -ENOMEM;
 585
 586     err = ret = 0;
 587
 588     if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size);
 589
 590     switch (cmd) {
 591     case DS_ADJUST_RESOURCE_INFO:
 592         ret = pcmcia_adjust_resource_info(&buf->adjust);
 593         break;
 594     case DS_GET_CARD_SERVICES_INFO:
 595         ret = pcmcia_get_card_services_info(&buf->servinfo);
 596         break;
 597     case DS_GET_CONFIGURATION_INFO:
 598         if (buf->config.Function &&
 599            (buf->config.Function >= s->functions))
 600             ret = CS_BAD_ARGS;
 601         else
 602             ret = pccard_get_configuration_info(s,
 603                         buf->config.Function, &buf->config);
 604         break;
 605     case DS_GET_FIRST_TUPLE:
 606         down(&s->skt_sem);
 607         pcmcia_validate_mem(s);
 608         up(&s->skt_sem);
 609         ret = pccard_get_first_tuple(s, BIND_FN_ALL, &buf->tuple);
 610         break;
 611     case DS_GET_NEXT_TUPLE:
 612         ret = pccard_get_next_tuple(s, BIND_FN_ALL, &buf->tuple);
 613         break;
 614     case DS_GET_TUPLE_DATA:
 615         buf->tuple.TupleData = buf->tuple_parse.data;
 616         buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
 617         ret = pccard_get_tuple_data(s, &buf->tuple);
 618         break;
 619     case DS_PARSE_TUPLE:
 620         buf->tuple.TupleData = buf->tuple_parse.data;
 621         ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
 622         break;
 623     case DS_RESET_CARD:
 624         ret = pccard_reset_card(s);
 625         break;
 626     case DS_GET_STATUS:
 627         if (buf->status.Function &&
 628            (buf->status.Function >= s->functions))
 629             ret = CS_BAD_ARGS;
 630         else
 631         ret = pccard_get_status(s, buf->status.Function, &buf->status);
 632         break;
 633     case DS_VALIDATE_CIS:
 634         down(&s->skt_sem);
 635         pcmcia_validate_mem(s);
 636         up(&s->skt_sem);
 637         ret = pccard_validate_cis(s, BIND_FN_ALL, &buf->cisinfo);
 638         break;
 639     case DS_SUSPEND_CARD:
 640         ret = pcmcia_suspend_card(s);
 641         break;
 642     case DS_RESUME_CARD:
 643         ret = pcmcia_resume_card(s);
 644         break;
 645     case DS_EJECT_CARD:
 646         err = pcmcia_eject_card(s);
 647         break;
 648     case DS_INSERT_CARD:
 649         err = pcmcia_insert_card(s);
 650         break;
 651     case DS_ACCESS_CONFIGURATION_REGISTER:
 652         if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
 653             err = -EPERM;
 654             goto free_out;
 655         }
 656         if (buf->conf_reg.Function &&
 657            (buf->conf_reg.Function >= s->functions))
 658             ret = CS_BAD_ARGS;
 659         else
 660             ret = pccard_access_configuration_register(s,
 661                         buf->conf_reg.Function, &buf->conf_reg);
 662         break;
 663     case DS_GET_FIRST_REGION:
 664     case DS_GET_NEXT_REGION:
 665     case DS_BIND_MTD:
 666         if (!capable(CAP_SYS_ADMIN)) {
 667                 err = -EPERM;
 668                 goto free_out;
 669         } else {
 670                 static int printed = 0;
 671                 if (!printed) {
 672                         printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
 673                         printk(KERN_WARNING "MTD handling any more.\n");
 674                         printed++;
 675                 }
 676         }
 677         err = -EINVAL;
 678         goto free_out;
 679         break;
 680     case DS_GET_FIRST_WINDOW:
 681         ret = pcmcia_get_window(s, &buf->win_info.handle, 0,
 682                         &buf->win_info.window);
 683         break;
 684     case DS_GET_NEXT_WINDOW:
 685         ret = pcmcia_get_window(s, &buf->win_info.handle,
 686                         buf->win_info.handle->index + 1, &buf->win_info.window);
 687         break;
 688     case DS_GET_MEM_PAGE:
 689         ret = pcmcia_get_mem_page(buf->win_info.handle,
 690                            &buf->win_info.map);
 691         break;
 692     case DS_REPLACE_CIS:
 693         ret = pcmcia_replace_cis(s, &buf->cisdump);
 694         break;
 695     case DS_BIND_REQUEST:
 696         if (!capable(CAP_SYS_ADMIN)) {
 697                 err = -EPERM;
 698                 goto free_out;
 699         }
 700         err = bind_request(s, &buf->bind_info);
 701         break;
 702     case DS_GET_DEVICE_INFO:
 703         err = get_device_info(s, &buf->bind_info, 1);
 704         break;
 705     case DS_GET_NEXT_DEVICE:
 706         err = get_device_info(s, &buf->bind_info, 0);
 707         break;
 708     case DS_UNBIND_REQUEST:
 709         err = 0;
 710         break;
 711     default:
 712         err = -EINVAL;
 713     }
 714
 715     if ((err == 0) && (ret != CS_SUCCESS)) {
 716         ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
 717         switch (ret) {
 718         case CS_BAD_SOCKET: case CS_NO_CARD:
 719             err = -ENODEV; break;
 720         case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
 721         case CS_BAD_TUPLE:
 722             err = -EINVAL; break;
 723         case CS_IN_USE:
 724             err = -EBUSY; break;
 725         case CS_OUT_OF_RESOURCE:
 726             err = -ENOSPC; break;
 727         case CS_NO_MORE_ITEMS:
 728             err = -ENODATA; break;
 729         case CS_UNSUPPORTED_FUNCTION:
 730             err = -ENOSYS; break;
 731         default:
 732             err = -EIO; break;
 733         }
 734     }
 735
 736     if (cmd & IOC_OUT) {
 737         if (__copy_to_user(uarg, (char *)buf, size))
 738             err = -EFAULT;
 739     }
 740
 741 free_out:
 742     kfree(buf);
 743     return err;
 744 } /* ds_ioctl */
 745
 746 /*====================================================================*/
 747
 748 static struct file_operations ds_fops = {
 749         .owner          = THIS_MODULE,
 750         .open           = ds_open,
 751         .release        = ds_release,
 752         .ioctl          = ds_ioctl,
 753         .read           = ds_read,
 754         .write          = ds_write,
 755         .poll           = ds_poll,
 756 };
 757
 758 void __init pcmcia_setup_ioctl(void) {
 759         int i;
 760
 761         /* Set up character device for user mode clients */
 762         i = register_chrdev(0, "pcmcia", &ds_fops);
 763         if (i < 0)
 764                 printk(KERN_NOTICE "unable to find a free device # for "
 765                        "Driver Services (error=%d)\n", i);
 766         else
 767                 major_dev = i;
 768
 769 #ifdef CONFIG_PROC_FS
 770         proc_pccard = proc_mkdir("pccard", proc_bus);
 771         if (proc_pccard)
 772                 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
 773 #endif
 774 }
 775
 776
 777 void __exit pcmcia_cleanup_ioctl(void) {
 778 #ifdef CONFIG_PROC_FS
 779         if (proc_pccard) {
 780                 remove_proc_entry("drivers", proc_pccard);
 781                 remove_proc_entry("pccard", proc_bus);
 782         }
 783 #endif
 784         if (major_dev != -1)
 785                 unregister_chrdev(major_dev, "pcmcia");
 786 }