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