1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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
43static int major_dev = -1;
44
45
46
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;
57 struct pcmcia_socket *socket;
58} user_info_t;
59
60
61#ifdef CONFIG_PCMCIA_DEBUG
62extern 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
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}
88
89
90
91static 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
107static struct proc_dir_entry *proc_pccard = NULL;
108
109static 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
125static 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
131static int pccard_drivers_proc_open(struct inode *inode, struct file *file)
132{
133 return single_open(file, pccard_drivers_proc_show, NULL);
134}
135
136static 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
148static 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
172static inline int adjust_irq(struct pcmcia_socket *s, adjust_t *adj) {
173 return 0;
174}
175
176#endif
177
178static 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
194
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
218
219
220
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
233
234
235
236
237
238static 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, ®);
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
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, ®);
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}
292
293static 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}
363
364
365
366
367
368
369
370
371
372static int queue_empty(user_info_t *user)
373{
374 return (user->event_head == user->event_tail);
375}
376
377static 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
383static 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
391void 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
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423static 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
454
455
456
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
463
464
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
472
473
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
487rescan:
488 p_dev->cardmgr = p_drv;
489
490
491 if (p_dev->dev.driver)
492 goto err_put_module;
493
494
495
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
504
505
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}
519
520#ifdef CONFIG_CARDBUS
521
522static 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
531static 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
542
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
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}
616
617
618static 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);
676out:
677 unlock_kernel();
678 return ret;
679}
680
681
682
683static 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
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);
709out:
710 return 0;
711}
712
713
714
715static 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}
741
742
743
744static 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}
756
757
758
759
760static 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
773
774
775 poll_wait(file, &s->queue, wait);
776 if (!queue_empty(user))
777 return POLLIN | POLLRDNORM;
778 return 0;
779}
780
781
782
783static 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
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, &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
987free_out:
988 kfree(buf);
989 return err;
990}
991
992
993
994static 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
1004void __init pcmcia_setup_ioctl(void) {
1005 int i;
1006
1007
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
1023void __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}
1033