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