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