SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/pcmcia/pcmcia_ioctl.c

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