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