projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Linux 2.6.27-rc1
[linux-2.6-block.git] / drivers / pcmcia / pcmcia_ioctl.c
CommitLineData
e7a480d2
DB		 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
3b659fb8 21#include <linux/kernel.h>
e7a480d2 22#include <linux/module.h>
e7a480d2 23#include <linux/init.h>
e7a480d2 24#include <linux/major.h>
e7a480d2 25#include <linux/errno.h>
e7a480d2
DB		 26#include <linux/ioctl.h>
27#include <linux/proc_fs.h>
28#include <linux/poll.h>
29#include <linux/pci.h>
0bec0bba 30#include <linux/smp_lock.h>
e7a480d2 31#include <linux/workqueue.h>
e7a480d2 32
e7a480d2
DB		 33#include <pcmcia/cs_types.h>
34#include <pcmcia/cs.h>
e7a480d2 35#include <pcmcia/cistpl.h>
4aeba013 36#include <pcmcia/cisreg.h>
e7a480d2
DB		 37#include <pcmcia/ds.h>
38#include <pcmcia/ss.h>
39
40#include "cs_internal.h"
41#include "ds_internal.h"
42
43static 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
52typedef 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;
dc109497 57 struct pcmcia_socket *socket;
e7a480d2
DB		 58} user_info_t;
59
60
61#ifdef DEBUG
62extern int ds_pc_debug;
e7a480d2
DB		 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
855cdf13
DB		 72static 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}
e7a480d2 88
e7a480d2
DB		 89/* backwards-compatible accessing of driver --- by name! */
90
855cdf13 91static struct pcmcia_driver *get_pcmcia_driver(dev_info_t *dev_info)
e7a480d2
DB		 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
107static struct proc_dir_entry *proc_pccard = NULL;
108
109static 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
127static int proc_read_drivers(char *buf, char **start, off_t pos,
128 int count, int *eof, void *data)
129{
130 char *p = buf;
4deb7c1e 131 int rc;
e7a480d2 132
4deb7c1e
JG		 133 rc = bus_for_each_drv(&pcmcia_bus_type, NULL,
134 (void *) &p, proc_read_drivers_callback);
135 if (rc < 0)
136 return rc;
e7a480d2
DB		 137
138 return (p - buf);
139}
140#endif
141
c5023801
DB		 142
143#ifdef CONFIG_PCMCIA_PROBE
144
145static 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
169static inline int adjust_irq(struct pcmcia_socket *s, adjust_t *adj) {
170 return CS_SUCCESS;
171}
172
173#endif
174
175static 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
4aeba013
DB		 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
235static 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 CS_SUCCESS;
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 CS_SUCCESS;
288} /* pccard_get_status */
c5023801 289
e7a480d2
DB		 290/*======================================================================
291
292 These manage a ring buffer of events pending for one user process
293
294======================================================================*/
295
296
297static int queue_empty(user_info_t *user)
298{
299 return (user->event_head == user->event_tail);
300}
301
302static event_t get_queued_event(user_info_t *user)
303{
304 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
305 return user->event[user->event_tail];
306}
307
308static void queue_event(user_info_t *user, event_t event)
309{
310 user->event_head = (user->event_head+1) % MAX_EVENTS;
311 if (user->event_head == user->event_tail)
312 user->event_tail = (user->event_tail+1) % MAX_EVENTS;
313 user->event[user->event_head] = event;
314}
315
dc109497 316void handle_event(struct pcmcia_socket *s, event_t event)
e7a480d2
DB		 317{
318 user_info_t *user;
319 for (user = s->user; user; user = user->next)
320 queue_event(user, event);
321 wake_up_interruptible(&s->queue);
322}
323
324
325/*======================================================================
326
327 bind_request() and bind_device() are merged by now. Register_client()
328 is called right at the end of bind_request(), during the driver's
329 ->attach() call. Individual descriptions:
330
331 bind_request() connects a socket to a particular client driver.
332 It looks up the specified device ID in the list of registered
333 drivers, binds it to the socket, and tries to create an instance
334 of the device. unbind_request() deletes a driver instance.
335
336 Bind_device() associates a device driver with a particular socket.
337 It is normally called by Driver Services after it has identified
338 a newly inserted card. An instance of that driver will then be
339 eligible to register as a client of this socket.
340
341 Register_client() uses the dev_info_t handle to match the
342 caller with a socket. The driver must have already been bound
343 to a socket with bind_device() -- in fact, bind_device()
344 allocates the client structure that will be used.
345
346======================================================================*/
347
dc109497 348static int bind_request(struct pcmcia_socket *s, bind_info_t *bind_info)
e7a480d2
DB		 349{
350 struct pcmcia_driver *p_drv;
351 struct pcmcia_device *p_dev;
352 int ret = 0;
353 unsigned long flags;
354
dc109497 355 s = pcmcia_get_socket(s);
e7a480d2
DB		 356 if (!s)
357 return -EINVAL;
358
dc109497 359 ds_dbg(2, "bind_request(%d, '%s')\n", s->sock,
e7a480d2
DB		 360 (char *)bind_info->dev_info);
361
362 p_drv = get_pcmcia_driver(&bind_info->dev_info);
363 if (!p_drv) {
364 ret = -EINVAL;
365 goto err_put;
366 }
367
368 if (!try_module_get(p_drv->owner)) {
369 ret = -EINVAL;
370 goto err_put_driver;
371 }
372
373 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
374 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
375 if (p_dev->func == bind_info->function) {
376 if ((p_dev->dev.driver == &p_drv->drv)) {
377 if (p_dev->cardmgr) {
378 /* if there's already a device
379 * registered, and it was registered
380 * by userspace before, we need to
381 * return the "instance". */
382 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
fd238232 383 bind_info->instance = p_dev;
e7a480d2
DB		 384 ret = -EBUSY;
385 goto err_put_module;
386 } else {
387 /* the correct driver managed to bind
388 * itself magically to the correct
389 * device. */
390 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
391 p_dev->cardmgr = p_drv;
392 ret = 0;
393 goto err_put_module;
394 }
395 } else if (!p_dev->dev.driver) {
396 /* there's already a device available where
397 * no device has been bound to yet. So we don't
398 * need to register a device! */
399 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
400 goto rescan;
401 }
402 }
403 }
404 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
405
406 p_dev = pcmcia_device_add(s, bind_info->function);
407 if (!p_dev) {
408 ret = -EIO;
409 goto err_put_module;
410 }
411
412rescan:
413 p_dev->cardmgr = p_drv;
414
415 /* if a driver is already running, we can abort */
416 if (p_dev->dev.driver)
417 goto err_put_module;
418
419 /*
420 * Prevent this racing with a card insertion.
421 */
7fe908dd 422 mutex_lock(&s->skt_mutex);
4deb7c1e 423 ret = bus_rescan_devices(&pcmcia_bus_type);
7fe908dd 424 mutex_unlock(&s->skt_mutex);
4deb7c1e
JG		 425 if (ret)
426 goto err_put_module;
e7a480d2
DB		 427
428 /* check whether the driver indeed matched. I don't care if this
429 * is racy or not, because it can only happen on cardmgr access
430 * paths...
431 */
432 if (!(p_dev->dev.driver == &p_drv->drv))
433 p_dev->cardmgr = NULL;
434
435 err_put_module:
436 module_put(p_drv->owner);
437 err_put_driver:
438 put_driver(&p_drv->drv);
439 err_put:
dc109497 440 pcmcia_put_socket(s);
e7a480d2
DB		 441
442 return (ret);
443} /* bind_request */
444
33519ddd
DB		 445#ifdef CONFIG_CARDBUS
446
447static struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
448{
449 if (!s || !(s->state & SOCKET_CARDBUS))
450 return NULL;
e7a480d2 451
33519ddd
DB		 452 return s->cb_dev->subordinate;
453}
454#endif
e7a480d2 455
dc109497 456static int get_device_info(struct pcmcia_socket *s, bind_info_t *bind_info, int first)
e7a480d2
DB		 457{
458 dev_node_t *node;
459 struct pcmcia_device *p_dev;
e2d40963 460 struct pcmcia_driver *p_drv;
e7a480d2
DB		 461 unsigned long flags;
462 int ret = 0;
463
464#ifdef CONFIG_CARDBUS
465 /*
466 * Some unbelievably ugly code to associate the PCI cardbus
467 * device and its driver with the PCMCIA "bind" information.
468 */
469 {
470 struct pci_bus *bus;
471
dc109497 472 bus = pcmcia_lookup_bus(s);
e7a480d2
DB		 473 if (bus) {
474 struct list_head *list;
475 struct pci_dev *dev = NULL;
476
477 list = bus->devices.next;
478 while (list != &bus->devices) {
479 struct pci_dev *pdev = pci_dev_b(list);
480 list = list->next;
481
482 if (first) {
483 dev = pdev;
484 break;
485 }
486
487 /* Try to handle "next" here some way? */
488 }
489 if (dev && dev->driver) {
490 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
491 bind_info->major = 0;
492 bind_info->minor = 0;
493 bind_info->next = NULL;
494 return 0;
495 }
496 }
497 }
498#endif
499
500 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
501 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
502 if (p_dev->func == bind_info->function) {
503 p_dev = pcmcia_get_dev(p_dev);
504 if (!p_dev)
505 continue;
506 goto found;
507 }
508 }
509 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
510 return -ENODEV;
511
512 found:
513 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
514
e2d40963
DB		 515 p_drv = to_pcmcia_drv(p_dev->dev.driver);
516 if (p_drv && !p_dev->_locked) {
e7a480d2
DB		 517 ret = -EAGAIN;
518 goto err_put;
519 }
520
521 if (first)
fd238232 522 node = p_dev->dev_node;
e7a480d2 523 else
fd238232 524 for (node = p_dev->dev_node; node; node = node->next)
e7a480d2
DB		 525 if (node == bind_info->next)
526 break;
527 if (!node) {
528 ret = -ENODEV;
529 goto err_put;
530 }
531
532 strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
533 bind_info->major = node->major;
534 bind_info->minor = node->minor;
535 bind_info->next = node->next;
536
537 err_put:
538 pcmcia_put_dev(p_dev);
539 return (ret);
540} /* get_device_info */
541
542
543static int ds_open(struct inode *inode, struct file *file)
544{
545 socket_t i = iminor(inode);
dc109497 546 struct pcmcia_socket *s;
e7a480d2 547 user_info_t *user;
c352ec8a 548 static int warning_printed = 0;
0bec0bba 549 int ret = 0;
e7a480d2
DB		 550
551 ds_dbg(0, "ds_open(socket %d)\n", i);
552
0bec0bba 553 lock_kernel();
dc109497 554 s = pcmcia_get_socket_by_nr(i);
0bec0bba
JC		 555 if (!s) {
556 ret = -ENODEV;
557 goto out;
558 }
dc109497 559 s = pcmcia_get_socket(s);
0bec0bba
JC		 560 if (!s) {
561 ret = -ENODEV;
562 goto out;
563 }
e7a480d2
DB		 564
565 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
b5e43913 566 if (s->pcmcia_state.busy) {
dc109497 567 pcmcia_put_socket(s);
0bec0bba
JC		 568 ret = -EBUSY;
569 goto out;
e7a480d2
DB		 570 }
571 else
b5e43913 572 s->pcmcia_state.busy = 1;
e7a480d2
DB		 573 }
574
575 user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
576 if (!user) {
dc109497 577 pcmcia_put_socket(s);
0bec0bba
JC		 578 ret = -ENOMEM;
579 goto out;
e7a480d2
DB		 580 }
581 user->event_tail = user->event_head = 0;
582 user->next = s->user;
583 user->user_magic = USER_MAGIC;
584 user->socket = s;
585 s->user = user;
586 file->private_data = user;
587
c352ec8a
DB		 588 if (!warning_printed) {
589 printk(KERN_INFO "pcmcia: Detected deprecated PCMCIA ioctl "
73d58588 590 "usage from process: %s.\n", current->comm);
c352ec8a
DB		 591 printk(KERN_INFO "pcmcia: This interface will soon be removed from "
592 "the kernel; please expect breakage unless you upgrade "
593 "to new tools.\n");
594 printk(KERN_INFO "pcmcia: see http://www.kernel.org/pub/linux/"
595 "utils/kernel/pcmcia/pcmcia.html for details.\n");
596 warning_printed = 1;
597 }
598
b5e43913 599 if (s->pcmcia_state.present)
e7a480d2 600 queue_event(user, CS_EVENT_CARD_INSERTION);
0bec0bba
JC		 601out:
602 unlock_kernel();
603 return ret;
e7a480d2
DB		 604} /* ds_open */
605
606/*====================================================================*/
607
608static int ds_release(struct inode *inode, struct file *file)
609{
dc109497 610 struct pcmcia_socket *s;
e7a480d2
DB		 611 user_info_t *user, **link;
612
613 ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
614
615 user = file->private_data;
616 if (CHECK_USER(user))
617 goto out;
618
619 s = user->socket;
620
621 /* Unlink user data structure */
622 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
b5e43913 623 s->pcmcia_state.busy = 0;
e7a480d2
DB		 624 }
625 file->private_data = NULL;
626 for (link = &s->user; *link; link = &(*link)->next)
627 if (*link == user) break;
628 if (link == NULL)
629 goto out;
630 *link = user->next;
631 user->user_magic = 0;
632 kfree(user);
dc109497 633 pcmcia_put_socket(s);
e7a480d2
DB		 634out:
635 return 0;
636} /* ds_release */
637
638/*====================================================================*/
639
640static ssize_t ds_read(struct file *file, char __user *buf,
641 size_t count, loff_t *ppos)
642{
dc109497 643 struct pcmcia_socket *s;
e7a480d2
DB		 644 user_info_t *user;
645 int ret;
646
40fad04b 647 ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_path.dentry->d_inode));
e7a480d2
DB		 648
649 if (count < 4)
650 return -EINVAL;
651
652 user = file->private_data;
653 if (CHECK_USER(user))
654 return -EIO;
655
656 s = user->socket;
b5e43913 657 if (s->pcmcia_state.dead)
e7a480d2
DB		 658 return -EIO;
659
660 ret = wait_event_interruptible(s->queue, !queue_empty(user));
661 if (ret == 0)
662 ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
663
664 return ret;
665} /* ds_read */
666
667/*====================================================================*/
668
669static ssize_t ds_write(struct file *file, const char __user *buf,
670 size_t count, loff_t *ppos)
671{
40fad04b 672 ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_path.dentry->d_inode));
e7a480d2
DB		 673
674 if (count != 4)
675 return -EINVAL;
676 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
677 return -EBADF;
678
679 return -EIO;
680} /* ds_write */
681
682/*====================================================================*/
683
684/* No kernel lock - fine */
685static u_int ds_poll(struct file *file, poll_table *wait)
686{
dc109497 687 struct pcmcia_socket *s;
e7a480d2
DB		 688 user_info_t *user;
689
40fad04b 690 ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_path.dentry->d_inode));
e7a480d2
DB		 691
692 user = file->private_data;
693 if (CHECK_USER(user))
694 return POLLERR;
695 s = user->socket;
696 /*
697 * We don't check for a dead socket here since that
698 * will send cardmgr into an endless spin.
699 */
700 poll_wait(file, &s->queue, wait);
701 if (!queue_empty(user))
702 return POLLIN | POLLRDNORM;
703 return 0;
704} /* ds_poll */
705
706/*====================================================================*/
707
e7a480d2
DB		 708static int ds_ioctl(struct inode * inode, struct file * file,
709 u_int cmd, u_long arg)
710{
dc109497 711 struct pcmcia_socket *s;
e7a480d2
DB		 712 void __user *uarg = (char __user *)arg;
713 u_int size;
714 int ret, err;
715 ds_ioctl_arg_t *buf;
716 user_info_t *user;
717
718 ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
719
720 user = file->private_data;
721 if (CHECK_USER(user))
722 return -EIO;
723
724 s = user->socket;
b5e43913 725 if (s->pcmcia_state.dead)
e7a480d2
DB		 726 return -EIO;
727
728 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
729 if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
730
731 /* Permission check */
732 if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
733 return -EPERM;
734
735 if (cmd & IOC_IN) {
736 if (!access_ok(VERIFY_READ, uarg, size)) {
737 ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
738 return -EFAULT;
739 }
740 }
741 if (cmd & IOC_OUT) {
742 if (!access_ok(VERIFY_WRITE, uarg, size)) {
743 ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
744 return -EFAULT;
745 }
746 }
747 buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
748 if (!buf)
749 return -ENOMEM;
750
751 err = ret = 0;
752
9374074f
DB		 753 if (cmd & IOC_IN) {
754 if (__copy_from_user((char *)buf, uarg, size)) {
755 err = -EFAULT;
756 goto free_out;
757 }
758 }
e7a480d2
DB		 759
760 switch (cmd) {
761 case DS_ADJUST_RESOURCE_INFO:
762 ret = pcmcia_adjust_resource_info(&buf->adjust);
763 break;
e7a480d2
DB		 764 case DS_GET_CONFIGURATION_INFO:
765 if (buf->config.Function &&
dc109497 766 (buf->config.Function >= s->functions))
e7a480d2 767 ret = CS_BAD_ARGS;
855cdf13
DB		 768 else {
769 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->config.Function);
f47ad214
DR		 770 ret = pccard_get_configuration_info(s, p_dev, &buf->config);
771 pcmcia_put_dev(p_dev);
855cdf13 772 }
e7a480d2
DB		 773 break;
774 case DS_GET_FIRST_TUPLE:
7fe908dd 775 mutex_lock(&s->skt_mutex);
dc109497 776 pcmcia_validate_mem(s);
7fe908dd 777 mutex_unlock(&s->skt_mutex);
dc109497 778 ret = pccard_get_first_tuple(s, BIND_FN_ALL, &buf->tuple);
e7a480d2
DB		 779 break;
780 case DS_GET_NEXT_TUPLE:
dc109497 781 ret = pccard_get_next_tuple(s, BIND_FN_ALL, &buf->tuple);
e7a480d2
DB		 782 break;
783 case DS_GET_TUPLE_DATA:
784 buf->tuple.TupleData = buf->tuple_parse.data;
785 buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
dc109497 786 ret = pccard_get_tuple_data(s, &buf->tuple);
e7a480d2
DB		 787 break;
788 case DS_PARSE_TUPLE:
789 buf->tuple.TupleData = buf->tuple_parse.data;
790 ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
791 break;
792 case DS_RESET_CARD:
dc109497 793 ret = pccard_reset_card(s);
e7a480d2
DB		 794 break;
795 case DS_GET_STATUS:
855cdf13
DB		 796 if (buf->status.Function &&
797 (buf->status.Function >= s->functions))
798 ret = CS_BAD_ARGS;
799 else {
800 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->status.Function);
f47ad214
DR		 801 ret = pccard_get_status(s, p_dev, &buf->status);
802 pcmcia_put_dev(p_dev);
855cdf13
DB		 803 }
804 break;
e7a480d2 805 case DS_VALIDATE_CIS:
7fe908dd 806 mutex_lock(&s->skt_mutex);
dc109497 807 pcmcia_validate_mem(s);
7fe908dd 808 mutex_unlock(&s->skt_mutex);
c5081d5f 809 ret = pccard_validate_cis(s, BIND_FN_ALL, &buf->cisinfo.Chains);
e7a480d2
DB		 810 break;
811 case DS_SUSPEND_CARD:
dc109497 812 ret = pcmcia_suspend_card(s);
e7a480d2
DB		 813 break;
814 case DS_RESUME_CARD:
dc109497 815 ret = pcmcia_resume_card(s);
e7a480d2
DB		 816 break;
817 case DS_EJECT_CARD:
dc109497 818 err = pcmcia_eject_card(s);
e7a480d2
DB		 819 break;
820 case DS_INSERT_CARD:
dc109497 821 err = pcmcia_insert_card(s);
e7a480d2
DB		 822 break;
823 case DS_ACCESS_CONFIGURATION_REGISTER:
824 if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
825 err = -EPERM;
826 goto free_out;
827 }
855cdf13
DB		 828
829 ret = CS_BAD_ARGS;
830
831 if (!(buf->conf_reg.Function &&
832 (buf->conf_reg.Function >= s->functions))) {
833 struct pcmcia_device *p_dev = get_pcmcia_device(s, buf->conf_reg.Function);
73d58588 834 if (p_dev) {
855cdf13 835 ret = pcmcia_access_configuration_register(p_dev, &buf->conf_reg);
73d58588
BH		 836 pcmcia_put_dev(p_dev);
837 }
855cdf13 838 }
e7a480d2
DB		 839 break;
840 case DS_GET_FIRST_REGION:
841 case DS_GET_NEXT_REGION:
842 case DS_BIND_MTD:
843 if (!capable(CAP_SYS_ADMIN)) {
844 err = -EPERM;
845 goto free_out;
846 } else {
847 static int printed = 0;
848 if (!printed) {
849 printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
850 printk(KERN_WARNING "MTD handling any more.\n");
851 printed++;
852 }
853 }
854 err = -EINVAL;
855 goto free_out;
856 break;
857 case DS_GET_FIRST_WINDOW:
dc109497 858 ret = pcmcia_get_window(s, &buf->win_info.handle, 0,
e7a480d2
DB		 859 &buf->win_info.window);
860 break;
861 case DS_GET_NEXT_WINDOW:
dc109497 862 ret = pcmcia_get_window(s, &buf->win_info.handle,
e7a480d2
DB		 863 buf->win_info.handle->index + 1, &buf->win_info.window);
864 break;
865 case DS_GET_MEM_PAGE:
866 ret = pcmcia_get_mem_page(buf->win_info.handle,
867 &buf->win_info.map);
868 break;
869 case DS_REPLACE_CIS:
dc109497 870 ret = pcmcia_replace_cis(s, &buf->cisdump);
e7a480d2
DB		 871 break;
872 case DS_BIND_REQUEST:
873 if (!capable(CAP_SYS_ADMIN)) {
874 err = -EPERM;
875 goto free_out;
876 }
877 err = bind_request(s, &buf->bind_info);
878 break;
879 case DS_GET_DEVICE_INFO:
880 err = get_device_info(s, &buf->bind_info, 1);
881 break;
882 case DS_GET_NEXT_DEVICE:
883 err = get_device_info(s, &buf->bind_info, 0);
884 break;
885 case DS_UNBIND_REQUEST:
886 err = 0;
887 break;
888 default:
889 err = -EINVAL;
890 }
891
892 if ((err == 0) && (ret != CS_SUCCESS)) {
893 ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
894 switch (ret) {
895 case CS_BAD_SOCKET: case CS_NO_CARD:
896 err = -ENODEV; break;
897 case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
898 case CS_BAD_TUPLE:
899 err = -EINVAL; break;
900 case CS_IN_USE:
901 err = -EBUSY; break;
902 case CS_OUT_OF_RESOURCE:
903 err = -ENOSPC; break;
904 case CS_NO_MORE_ITEMS:
905 err = -ENODATA; break;
906 case CS_UNSUPPORTED_FUNCTION:
907 err = -ENOSYS; break;
908 default:
909 err = -EIO; break;
910 }
911 }
912
913 if (cmd & IOC_OUT) {
914 if (__copy_to_user(uarg, (char *)buf, size))
915 err = -EFAULT;
916 }
917
918free_out:
919 kfree(buf);
920 return err;
921} /* ds_ioctl */
922
923/*====================================================================*/
924
d54b1fdb 925static const struct file_operations ds_fops = {
e7a480d2
DB		 926 .owner = THIS_MODULE,
927 .open = ds_open,
928 .release = ds_release,
929 .ioctl = ds_ioctl,
930 .read = ds_read,
931 .write = ds_write,
932 .poll = ds_poll,
933};
934
935void __init pcmcia_setup_ioctl(void) {
936 int i;
937
938 /* Set up character device for user mode clients */
939 i = register_chrdev(0, "pcmcia", &ds_fops);
1a8ceafc 940 if (i < 0)
e7a480d2 941 printk(KERN_NOTICE "unable to find a free device # for "
1a8ceafc 942 "Driver Services (error=%d)\n", i);
e7a480d2
DB		 943 else
944 major_dev = i;
945
946#ifdef CONFIG_PROC_FS
97094dcf 947 proc_pccard = proc_mkdir("bus/pccard", NULL);
e7a480d2
DB		 948 if (proc_pccard)
949 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
950#endif
951}
952
953
954void __exit pcmcia_cleanup_ioctl(void) {
955#ifdef CONFIG_PROC_FS
956 if (proc_pccard) {
957 remove_proc_entry("drivers", proc_pccard);
97094dcf 958 remove_proc_entry("bus/pccard", NULL);
e7a480d2
DB		 959 }
960#endif
961 if (major_dev != -1)
962 unregister_chrdev(major_dev, "pcmcia");
963}
Linux 6.x block layer and io_uring tree(s)