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