drivers/pcmcia/pcmcia_ioctl.c

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