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