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