2394de4686026c6d7786d1f63787d869db2b393d
[linux-2.6.git] / drivers / pcmcia / pcmcia_resource.c
1 /*
2  * PCMCIA 16-bit resource management functions
3  *
4  * The initial developer of the original code is David A. Hinds
5  * <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
6  * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
7  *
8  * Copyright (C) 1999        David A. Hinds
9  * Copyright (C) 2004-2005   Dominik Brodowski
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License version 2 as
13  * published by the Free Software Foundation.
14  *
15  */
16
17 #include <linux/module.h>
18 #include <linux/kernel.h>
19 #include <linux/interrupt.h>
20 #include <linux/delay.h>
21 #include <linux/pci.h>
22 #include <linux/device.h>
23 #include <linux/netdevice.h>
24 #include <linux/slab.h>
25
26 #include <asm/irq.h>
27
28 #include <pcmcia/ss.h>
29 #include <pcmcia/cs.h>
30 #include <pcmcia/cistpl.h>
31 #include <pcmcia/cisreg.h>
32 #include <pcmcia/ds.h>
33
34 #include "cs_internal.h"
35
36
37 /* Access speed for IO windows */
38 static int io_speed;
39 module_param(io_speed, int, 0444);
40
41
42 int pcmcia_validate_mem(struct pcmcia_socket *s)
43 {
44         if (s->resource_ops->validate_mem)
45                 return s->resource_ops->validate_mem(s);
46         /* if there is no callback, we can assume that everything is OK */
47         return 0;
48 }
49
50 struct resource *pcmcia_find_mem_region(u_long base, u_long num, u_long align,
51                                  int low, struct pcmcia_socket *s)
52 {
53         if (s->resource_ops->find_mem)
54                 return s->resource_ops->find_mem(base, num, align, low, s);
55         return NULL;
56 }
57
58
59 /** alloc_io_space
60  *
61  * Special stuff for managing IO windows, because they are scarce
62  */
63
64 static int alloc_io_space(struct pcmcia_socket *s, u_int attr,
65                           unsigned int *base, unsigned int num, u_int lines)
66 {
67         unsigned int align;
68
69         align = (*base) ? (lines ? 1<<lines : 0) : 1;
70         if (align && (align < num)) {
71                 if (*base) {
72                         dev_dbg(&s->dev, "odd IO request: num %#x align %#x\n",
73                                num, align);
74                         align = 0;
75                 } else
76                         while (align && (align < num))
77                                 align <<= 1;
78         }
79         if (*base & ~(align-1)) {
80                 dev_dbg(&s->dev, "odd IO request: base %#x align %#x\n",
81                        *base, align);
82                 align = 0;
83         }
84
85         return s->resource_ops->find_io(s, attr, base, num, align);
86 } /* alloc_io_space */
87
88
89 static void release_io_space(struct pcmcia_socket *s, unsigned int base,
90                              unsigned int num)
91 {
92         int i;
93
94         for (i = 0; i < MAX_IO_WIN; i++) {
95                 if (!s->io[i].res)
96                         continue;
97                 if ((s->io[i].res->start <= base) &&
98                     (s->io[i].res->end >= base+num-1)) {
99                         s->io[i].InUse -= num;
100                         /* Free the window if no one else is using it */
101                         if (s->io[i].InUse == 0) {
102                                 release_resource(s->io[i].res);
103                                 kfree(s->io[i].res);
104                                 s->io[i].res = NULL;
105                         }
106                 }
107         }
108 } /* release_io_space */
109
110
111 /** pccard_access_configuration_register
112  *
113  * Access_configuration_register() reads and writes configuration
114  * registers in attribute memory.  Memory window 0 is reserved for
115  * this and the tuple reading services.
116  */
117
118 int pcmcia_access_configuration_register(struct pcmcia_device *p_dev,
119                                          conf_reg_t *reg)
120 {
121         struct pcmcia_socket *s;
122         config_t *c;
123         int addr;
124         u_char val;
125         int ret = 0;
126
127         if (!p_dev || !p_dev->function_config)
128                 return -EINVAL;
129
130         s = p_dev->socket;
131
132         mutex_lock(&s->ops_mutex);
133         c = p_dev->function_config;
134
135         if (!(c->state & CONFIG_LOCKED)) {
136                 dev_dbg(&s->dev, "Configuration isnt't locked\n");
137                 mutex_unlock(&s->ops_mutex);
138                 return -EACCES;
139         }
140
141         addr = (c->ConfigBase + reg->Offset) >> 1;
142
143         switch (reg->Action) {
144         case CS_READ:
145                 ret = pcmcia_read_cis_mem(s, 1, addr, 1, &val);
146                 reg->Value = val;
147                 break;
148         case CS_WRITE:
149                 val = reg->Value;
150                 pcmcia_write_cis_mem(s, 1, addr, 1, &val);
151                 break;
152         default:
153                 dev_dbg(&s->dev, "Invalid conf register request\n");
154                 ret = -EINVAL;
155                 break;
156         }
157         mutex_unlock(&s->ops_mutex);
158         return ret;
159 } /* pcmcia_access_configuration_register */
160 EXPORT_SYMBOL(pcmcia_access_configuration_register);
161
162
163 int pcmcia_map_mem_page(struct pcmcia_device *p_dev, window_handle_t wh,
164                         memreq_t *req)
165 {
166         struct pcmcia_socket *s = p_dev->socket;
167         int ret;
168
169         wh--;
170         if (wh >= MAX_WIN)
171                 return -EINVAL;
172         if (req->Page != 0) {
173                 dev_dbg(&s->dev, "failure: requested page is zero\n");
174                 return -EINVAL;
175         }
176         mutex_lock(&s->ops_mutex);
177         s->win[wh].card_start = req->CardOffset;
178         ret = s->ops->set_mem_map(s, &s->win[wh]);
179         if (ret)
180                 dev_warn(&s->dev, "failed to set_mem_map\n");
181         mutex_unlock(&s->ops_mutex);
182         return ret;
183 } /* pcmcia_map_mem_page */
184 EXPORT_SYMBOL(pcmcia_map_mem_page);
185
186
187 /** pcmcia_modify_configuration
188  *
189  * Modify a locked socket configuration
190  */
191 int pcmcia_modify_configuration(struct pcmcia_device *p_dev,
192                                 modconf_t *mod)
193 {
194         struct pcmcia_socket *s;
195         config_t *c;
196         int ret;
197
198         s = p_dev->socket;
199
200         mutex_lock(&s->ops_mutex);
201         c = p_dev->function_config;
202
203         if (!(s->state & SOCKET_PRESENT)) {
204                 dev_dbg(&s->dev, "No card present\n");
205                 ret = -ENODEV;
206                 goto unlock;
207         }
208         if (!(c->state & CONFIG_LOCKED)) {
209                 dev_dbg(&s->dev, "Configuration isnt't locked\n");
210                 ret = -EACCES;
211                 goto unlock;
212         }
213
214         if (mod->Attributes & (CONF_IRQ_CHANGE_VALID | CONF_VCC_CHANGE_VALID)) {
215                 dev_dbg(&s->dev,
216                         "changing Vcc or IRQ is not allowed at this time\n");
217                 ret = -EINVAL;
218                 goto unlock;
219         }
220
221         /* We only allow changing Vpp1 and Vpp2 to the same value */
222         if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) &&
223             (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
224                 if (mod->Vpp1 != mod->Vpp2) {
225                         dev_dbg(&s->dev, "Vpp1 and Vpp2 must be the same\n");
226                         ret = -EINVAL;
227                         goto unlock;
228                 }
229                 s->socket.Vpp = mod->Vpp1;
230                 if (s->ops->set_socket(s, &s->socket)) {
231                         dev_printk(KERN_WARNING, &s->dev,
232                                    "Unable to set VPP\n");
233                         ret = -EIO;
234                         goto unlock;
235                 }
236         } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
237                    (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
238                 dev_dbg(&s->dev, "changing Vcc is not allowed at this time\n");
239                 ret = -EINVAL;
240                 goto unlock;
241         }
242
243         if (mod->Attributes & CONF_IO_CHANGE_WIDTH) {
244                 pccard_io_map io_off = { 0, 0, 0, 0, 1 };
245                 pccard_io_map io_on;
246                 int i;
247
248                 io_on.speed = io_speed;
249                 for (i = 0; i < MAX_IO_WIN; i++) {
250                         if (!s->io[i].res)
251                                 continue;
252                         io_off.map = i;
253                         io_on.map = i;
254
255                         io_on.flags = MAP_ACTIVE | IO_DATA_PATH_WIDTH_8;
256                         io_on.start = s->io[i].res->start;
257                         io_on.stop = s->io[i].res->end;
258
259                         s->ops->set_io_map(s, &io_off);
260                         mdelay(40);
261                         s->ops->set_io_map(s, &io_on);
262                 }
263         }
264         ret = 0;
265 unlock:
266         mutex_unlock(&s->ops_mutex);
267
268         return ret;
269 } /* modify_configuration */
270 EXPORT_SYMBOL(pcmcia_modify_configuration);
271
272
273 int pcmcia_release_configuration(struct pcmcia_device *p_dev)
274 {
275         pccard_io_map io = { 0, 0, 0, 0, 1 };
276         struct pcmcia_socket *s = p_dev->socket;
277         config_t *c;
278         int i;
279
280         mutex_lock(&s->ops_mutex);
281         c = p_dev->function_config;
282         if (p_dev->_locked) {
283                 p_dev->_locked = 0;
284                 if (--(s->lock_count) == 0) {
285                         s->socket.flags = SS_OUTPUT_ENA;   /* Is this correct? */
286                         s->socket.Vpp = 0;
287                         s->socket.io_irq = 0;
288                         s->ops->set_socket(s, &s->socket);
289                 }
290         }
291         if (c->state & CONFIG_LOCKED) {
292                 c->state &= ~CONFIG_LOCKED;
293                 if (c->state & CONFIG_IO_REQ)
294                         for (i = 0; i < MAX_IO_WIN; i++) {
295                                 if (!s->io[i].res)
296                                         continue;
297                                 s->io[i].Config--;
298                                 if (s->io[i].Config != 0)
299                                         continue;
300                                 io.map = i;
301                                 s->ops->set_io_map(s, &io);
302                         }
303         }
304         mutex_unlock(&s->ops_mutex);
305
306         return 0;
307 } /* pcmcia_release_configuration */
308
309
310 /** pcmcia_release_io
311  *
312  * Release_io() releases the I/O ranges allocated by a client.  This
313  * may be invoked some time after a card ejection has already dumped
314  * the actual socket configuration, so if the client is "stale", we
315  * don't bother checking the port ranges against the current socket
316  * values.
317  */
318 static int pcmcia_release_io(struct pcmcia_device *p_dev, io_req_t *req)
319 {
320         struct pcmcia_socket *s = p_dev->socket;
321         int ret = -EINVAL;
322         config_t *c;
323
324         mutex_lock(&s->ops_mutex);
325         c = p_dev->function_config;
326
327         if (!p_dev->_io)
328                 goto out;
329
330         p_dev->_io = 0;
331
332         if ((c->io.BasePort1 != req->BasePort1) ||
333             (c->io.NumPorts1 != req->NumPorts1) ||
334             (c->io.BasePort2 != req->BasePort2) ||
335             (c->io.NumPorts2 != req->NumPorts2))
336                 goto out;
337
338         c->state &= ~CONFIG_IO_REQ;
339
340         release_io_space(s, req->BasePort1, req->NumPorts1);
341         if (req->NumPorts2)
342                 release_io_space(s, req->BasePort2, req->NumPorts2);
343
344 out:
345         mutex_unlock(&s->ops_mutex);
346
347         return ret;
348 } /* pcmcia_release_io */
349
350
351 int pcmcia_release_window(struct pcmcia_device *p_dev, window_handle_t wh)
352 {
353         struct pcmcia_socket *s = p_dev->socket;
354         pccard_mem_map *win;
355
356         wh--;
357         if (wh >= MAX_WIN)
358                 return -EINVAL;
359
360         mutex_lock(&s->ops_mutex);
361         win = &s->win[wh];
362
363         if (!(p_dev->_win & CLIENT_WIN_REQ(wh))) {
364                 dev_dbg(&s->dev, "not releasing unknown window\n");
365                 mutex_unlock(&s->ops_mutex);
366                 return -EINVAL;
367         }
368
369         /* Shut down memory window */
370         win->flags &= ~MAP_ACTIVE;
371         s->ops->set_mem_map(s, win);
372         s->state &= ~SOCKET_WIN_REQ(wh);
373
374         /* Release system memory */
375         if (win->res) {
376                 release_resource(win->res);
377                 kfree(win->res);
378                 win->res = NULL;
379         }
380         p_dev->_win &= ~CLIENT_WIN_REQ(wh);
381         mutex_unlock(&s->ops_mutex);
382
383         return 0;
384 } /* pcmcia_release_window */
385 EXPORT_SYMBOL(pcmcia_release_window);
386
387
388 int pcmcia_request_configuration(struct pcmcia_device *p_dev,
389                                  config_req_t *req)
390 {
391         int i;
392         u_int base;
393         struct pcmcia_socket *s = p_dev->socket;
394         config_t *c;
395         pccard_io_map iomap;
396
397         if (!(s->state & SOCKET_PRESENT))
398                 return -ENODEV;
399
400         if (req->IntType & INT_CARDBUS) {
401                 dev_dbg(&s->dev, "IntType may not be INT_CARDBUS\n");
402                 return -EINVAL;
403         }
404
405         mutex_lock(&s->ops_mutex);
406         c = p_dev->function_config;
407         if (c->state & CONFIG_LOCKED) {
408                 mutex_unlock(&s->ops_mutex);
409                 dev_dbg(&s->dev, "Configuration is locked\n");
410                 return -EACCES;
411         }
412
413         /* Do power control.  We don't allow changes in Vcc. */
414         s->socket.Vpp = req->Vpp;
415         if (s->ops->set_socket(s, &s->socket)) {
416                 mutex_unlock(&s->ops_mutex);
417                 dev_printk(KERN_WARNING, &s->dev,
418                            "Unable to set socket state\n");
419                 return -EINVAL;
420         }
421
422         /* Pick memory or I/O card, DMA mode, interrupt */
423         c->IntType = req->IntType;
424         c->Attributes = req->Attributes;
425         if (req->IntType & INT_MEMORY_AND_IO)
426                 s->socket.flags |= SS_IOCARD;
427         if (req->IntType & INT_ZOOMED_VIDEO)
428                 s->socket.flags |= SS_ZVCARD | SS_IOCARD;
429         if (req->Attributes & CONF_ENABLE_DMA)
430                 s->socket.flags |= SS_DMA_MODE;
431         if (req->Attributes & CONF_ENABLE_SPKR)
432                 s->socket.flags |= SS_SPKR_ENA;
433         if (req->Attributes & CONF_ENABLE_IRQ)
434                 s->socket.io_irq = s->pcmcia_irq;
435         else
436                 s->socket.io_irq = 0;
437         s->ops->set_socket(s, &s->socket);
438         s->lock_count++;
439
440         /* Set up CIS configuration registers */
441         base = c->ConfigBase = req->ConfigBase;
442         c->CardValues = req->Present;
443         if (req->Present & PRESENT_COPY) {
444                 c->Copy = req->Copy;
445                 pcmcia_write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy);
446         }
447         if (req->Present & PRESENT_OPTION) {
448                 if (s->functions == 1) {
449                         c->Option = req->ConfigIndex & COR_CONFIG_MASK;
450                 } else {
451                         c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK;
452                         c->Option |= COR_FUNC_ENA|COR_IREQ_ENA;
453                         if (req->Present & PRESENT_IOBASE_0)
454                                 c->Option |= COR_ADDR_DECODE;
455                 }
456                 if ((req->Attributes & CONF_ENABLE_IRQ) &&
457                         !(req->Attributes & CONF_ENABLE_PULSE_IRQ))
458                         c->Option |= COR_LEVEL_REQ;
459                 pcmcia_write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
460                 mdelay(40);
461         }
462         if (req->Present & PRESENT_STATUS) {
463                 c->Status = req->Status;
464                 pcmcia_write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
465         }
466         if (req->Present & PRESENT_PIN_REPLACE) {
467                 c->Pin = req->Pin;
468                 pcmcia_write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
469         }
470         if (req->Present & PRESENT_EXT_STATUS) {
471                 c->ExtStatus = req->ExtStatus;
472                 pcmcia_write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus);
473         }
474         if (req->Present & PRESENT_IOBASE_0) {
475                 u_char b = c->io.BasePort1 & 0xff;
476                 pcmcia_write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b);
477                 b = (c->io.BasePort1 >> 8) & 0xff;
478                 pcmcia_write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b);
479         }
480         if (req->Present & PRESENT_IOSIZE) {
481                 u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1;
482                 pcmcia_write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b);
483         }
484
485         /* Configure I/O windows */
486         if (c->state & CONFIG_IO_REQ) {
487                 iomap.speed = io_speed;
488                 for (i = 0; i < MAX_IO_WIN; i++)
489                         if (s->io[i].res) {
490                                 iomap.map = i;
491                                 iomap.flags = MAP_ACTIVE;
492                                 switch (s->io[i].res->flags & IO_DATA_PATH_WIDTH) {
493                                 case IO_DATA_PATH_WIDTH_16:
494                                         iomap.flags |= MAP_16BIT; break;
495                                 case IO_DATA_PATH_WIDTH_AUTO:
496                                         iomap.flags |= MAP_AUTOSZ; break;
497                                 default:
498                                         break;
499                                 }
500                                 iomap.start = s->io[i].res->start;
501                                 iomap.stop = s->io[i].res->end;
502                                 s->ops->set_io_map(s, &iomap);
503                                 s->io[i].Config++;
504                         }
505         }
506
507         c->state |= CONFIG_LOCKED;
508         p_dev->_locked = 1;
509         mutex_unlock(&s->ops_mutex);
510         return 0;
511 } /* pcmcia_request_configuration */
512 EXPORT_SYMBOL(pcmcia_request_configuration);
513
514
515 /** pcmcia_request_io
516  *
517  * Request_io() reserves ranges of port addresses for a socket.
518  * I have not implemented range sharing or alias addressing.
519  */
520 int pcmcia_request_io(struct pcmcia_device *p_dev, io_req_t *req)
521 {
522         struct pcmcia_socket *s = p_dev->socket;
523         config_t *c;
524         int ret = -EINVAL;
525
526         mutex_lock(&s->ops_mutex);
527
528         if (!(s->state & SOCKET_PRESENT)) {
529                 dev_dbg(&s->dev, "No card present\n");
530                 goto out;
531         }
532
533         if (!req)
534                 goto out;
535
536         c = p_dev->function_config;
537         if (c->state & CONFIG_LOCKED) {
538                 dev_dbg(&s->dev, "Configuration is locked\n");
539                 goto out;
540         }
541         if (c->state & CONFIG_IO_REQ) {
542                 dev_dbg(&s->dev, "IO already configured\n");
543                 goto out;
544         }
545         if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)) {
546                 dev_dbg(&s->dev, "bad attribute setting for IO region 1\n");
547                 goto out;
548         }
549         if ((req->NumPorts2 > 0) &&
550             (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))) {
551                 dev_dbg(&s->dev, "bad attribute setting for IO region 2\n");
552                 goto out;
553         }
554
555         dev_dbg(&s->dev, "trying to allocate resource 1\n");
556         ret = alloc_io_space(s, req->Attributes1, &req->BasePort1,
557                              req->NumPorts1, req->IOAddrLines);
558         if (ret) {
559                 dev_dbg(&s->dev, "allocation of resource 1 failed\n");
560                 goto out;
561         }
562
563         if (req->NumPorts2) {
564                 dev_dbg(&s->dev, "trying to allocate resource 2\n");
565                 ret = alloc_io_space(s, req->Attributes2, &req->BasePort2,
566                                      req->NumPorts2, req->IOAddrLines);
567                 if (ret) {
568                         dev_dbg(&s->dev, "allocation of resource 2 failed\n");
569                         release_io_space(s, req->BasePort1, req->NumPorts1);
570                         goto out;
571                 }
572         }
573
574         c->io = *req;
575         c->state |= CONFIG_IO_REQ;
576         p_dev->_io = 1;
577         dev_dbg(&s->dev, "allocating resources succeeded: %d\n", ret);
578
579 out:
580         mutex_unlock(&s->ops_mutex);
581
582         return ret;
583 } /* pcmcia_request_io */
584 EXPORT_SYMBOL(pcmcia_request_io);
585
586
587 /**
588  * pcmcia_request_irq() - attempt to request a IRQ for a PCMCIA device
589  *
590  * pcmcia_request_irq() is a wrapper around request_irq which will allow
591  * the PCMCIA core to clean up the registration in pcmcia_disable_device().
592  * Drivers are free to use request_irq() directly, but then they need to
593  * call free_irq themselfves, too. Also, only IRQF_SHARED capable IRQ
594  * handlers are allowed.
595  */
596 int __must_check pcmcia_request_irq(struct pcmcia_device *p_dev,
597                                     irq_handler_t handler)
598 {
599         int ret;
600
601         if (!p_dev->irq)
602                 return -EINVAL;
603
604         ret = request_irq(p_dev->irq, handler, IRQF_SHARED,
605                         p_dev->devname, p_dev->priv);
606         if (!ret)
607                 p_dev->_irq = 1;
608
609         return ret;
610 }
611 EXPORT_SYMBOL(pcmcia_request_irq);
612
613
614 /**
615  * pcmcia_request_exclusive_irq() - attempt to request an exclusive IRQ first
616  *
617  * pcmcia_request_exclusive_irq() is a wrapper around request_irq which
618  * attempts first to request an exclusive IRQ. If it fails, it also accepts
619  * a shared IRQ, but prints out a warning. PCMCIA drivers should allow for
620  * IRQ sharing and either use request_irq directly (then they need to call
621  * free_irq themselves, too), or the pcmcia_request_irq() function.
622  */
623 int __must_check
624 __pcmcia_request_exclusive_irq(struct pcmcia_device *p_dev,
625                         irq_handler_t handler)
626 {
627         int ret;
628
629         if (!p_dev->irq)
630                 return -EINVAL;
631
632         ret = request_irq(p_dev->irq, handler, 0, p_dev->devname, p_dev->priv);
633         if (ret) {
634                 ret = pcmcia_request_irq(p_dev, handler);
635                 dev_printk(KERN_WARNING, &p_dev->dev, "pcmcia: "
636                         "request for exclusive IRQ could not be fulfilled.\n");
637                 dev_printk(KERN_WARNING, &p_dev->dev, "pcmcia: the driver "
638                         "needs updating to supported shared IRQ lines.\n");
639         }
640         if (ret)
641                 dev_printk(KERN_INFO, &p_dev->dev, "request_irq() failed\n");
642         else
643                 p_dev->_irq = 1;
644
645         return ret;
646 } /* pcmcia_request_exclusive_irq */
647 EXPORT_SYMBOL(__pcmcia_request_exclusive_irq);
648
649
650 #ifdef CONFIG_PCMCIA_PROBE
651
652 /* mask of IRQs already reserved by other cards, we should avoid using them */
653 static u8 pcmcia_used_irq[NR_IRQS];
654
655 static irqreturn_t test_action(int cpl, void *dev_id)
656 {
657         return IRQ_NONE;
658 }
659
660 /**
661  * pcmcia_setup_isa_irq() - determine whether an ISA IRQ can be used
662  * @p_dev - the associated PCMCIA device
663  *
664  * locking note: must be called with ops_mutex locked.
665  */
666 static int pcmcia_setup_isa_irq(struct pcmcia_device *p_dev, int type)
667 {
668         struct pcmcia_socket *s = p_dev->socket;
669         unsigned int try, irq;
670         u32 mask = s->irq_mask;
671         int ret = -ENODEV;
672
673         for (try = 0; try < 64; try++) {
674                 irq = try % 32;
675
676                 /* marked as available by driver, not blocked by userspace? */
677                 if (!((mask >> irq) & 1))
678                         continue;
679
680                 /* avoid an IRQ which is already used by another PCMCIA card */
681                 if ((try < 32) && pcmcia_used_irq[irq])
682                         continue;
683
684                 /* register the correct driver, if possible, to check whether
685                  * registering a dummy handle works, i.e. if the IRQ isn't
686                  * marked as used by the kernel resource management core */
687                 ret = request_irq(irq, test_action, type, p_dev->devname,
688                                   p_dev);
689                 if (!ret) {
690                         free_irq(irq, p_dev);
691                         p_dev->irq = s->pcmcia_irq = irq;
692                         pcmcia_used_irq[irq]++;
693                         break;
694                 }
695         }
696
697         return ret;
698 }
699
700 void pcmcia_cleanup_irq(struct pcmcia_socket *s)
701 {
702         pcmcia_used_irq[s->pcmcia_irq]--;
703         s->pcmcia_irq = 0;
704 }
705
706 #else /* CONFIG_PCMCIA_PROBE */
707
708 static int pcmcia_setup_isa_irq(struct pcmcia_device *p_dev, int type)
709 {
710         return -EINVAL;
711 }
712
713 void pcmcia_cleanup_irq(struct pcmcia_socket *s)
714 {
715         s->pcmcia_irq = 0;
716         return;
717 }
718
719 #endif  /* CONFIG_PCMCIA_PROBE */
720
721
722 /**
723  * pcmcia_setup_irq() - determine IRQ to be used for device
724  * @p_dev - the associated PCMCIA device
725  *
726  * locking note: must be called with ops_mutex locked.
727  */
728 int pcmcia_setup_irq(struct pcmcia_device *p_dev)
729 {
730         struct pcmcia_socket *s = p_dev->socket;
731
732         if (p_dev->irq)
733                 return 0;
734
735         /* already assigned? */
736         if (s->pcmcia_irq) {
737                 p_dev->irq = s->pcmcia_irq;
738                 return 0;
739         }
740
741         /* prefer an exclusive ISA irq */
742         if (!pcmcia_setup_isa_irq(p_dev, 0))
743                 return 0;
744
745         /* but accept a shared ISA irq */
746         if (!pcmcia_setup_isa_irq(p_dev, IRQF_SHARED))
747                 return 0;
748
749         /* but use the PCI irq otherwise */
750         if (s->pci_irq) {
751                 p_dev->irq = s->pcmcia_irq = s->pci_irq;
752                 return 0;
753         }
754
755         return -EINVAL;
756 }
757
758
759 /** pcmcia_request_window
760  *
761  * Request_window() establishes a mapping between card memory space
762  * and system memory space.
763  */
764 int pcmcia_request_window(struct pcmcia_device *p_dev, win_req_t *req, window_handle_t *wh)
765 {
766         struct pcmcia_socket *s = p_dev->socket;
767         pccard_mem_map *win;
768         u_long align;
769         int w;
770
771         if (!(s->state & SOCKET_PRESENT)) {
772                 dev_dbg(&s->dev, "No card present\n");
773                 return -ENODEV;
774         }
775         if (req->Attributes & (WIN_PAGED | WIN_SHARED)) {
776                 dev_dbg(&s->dev, "bad attribute setting for iomem region\n");
777                 return -EINVAL;
778         }
779
780         /* Window size defaults to smallest available */
781         if (req->Size == 0)
782                 req->Size = s->map_size;
783         align = (((s->features & SS_CAP_MEM_ALIGN) ||
784                   (req->Attributes & WIN_STRICT_ALIGN)) ?
785                  req->Size : s->map_size);
786         if (req->Size & (s->map_size-1)) {
787                 dev_dbg(&s->dev, "invalid map size\n");
788                 return -EINVAL;
789         }
790         if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) ||
791             (req->Base & (align-1))) {
792                 dev_dbg(&s->dev, "invalid base address\n");
793                 return -EINVAL;
794         }
795         if (req->Base)
796                 align = 0;
797
798         /* Allocate system memory window */
799         for (w = 0; w < MAX_WIN; w++)
800                 if (!(s->state & SOCKET_WIN_REQ(w)))
801                         break;
802         if (w == MAX_WIN) {
803                 dev_dbg(&s->dev, "all windows are used already\n");
804                 return -EINVAL;
805         }
806
807         mutex_lock(&s->ops_mutex);
808         win = &s->win[w];
809
810         if (!(s->features & SS_CAP_STATIC_MAP)) {
811                 win->res = pcmcia_find_mem_region(req->Base, req->Size, align,
812                                                       (req->Attributes & WIN_MAP_BELOW_1MB), s);
813                 if (!win->res) {
814                         dev_dbg(&s->dev, "allocating mem region failed\n");
815                         mutex_unlock(&s->ops_mutex);
816                         return -EINVAL;
817                 }
818         }
819         p_dev->_win |= CLIENT_WIN_REQ(w);
820
821         /* Configure the socket controller */
822         win->map = w+1;
823         win->flags = 0;
824         win->speed = req->AccessSpeed;
825         if (req->Attributes & WIN_MEMORY_TYPE)
826                 win->flags |= MAP_ATTRIB;
827         if (req->Attributes & WIN_ENABLE)
828                 win->flags |= MAP_ACTIVE;
829         if (req->Attributes & WIN_DATA_WIDTH_16)
830                 win->flags |= MAP_16BIT;
831         if (req->Attributes & WIN_USE_WAIT)
832                 win->flags |= MAP_USE_WAIT;
833         win->card_start = 0;
834
835         if (s->ops->set_mem_map(s, win) != 0) {
836                 dev_dbg(&s->dev, "failed to set memory mapping\n");
837                 mutex_unlock(&s->ops_mutex);
838                 return -EIO;
839         }
840         s->state |= SOCKET_WIN_REQ(w);
841
842         /* Return window handle */
843         if (s->features & SS_CAP_STATIC_MAP)
844                 req->Base = win->static_start;
845         else
846                 req->Base = win->res->start;
847
848         mutex_unlock(&s->ops_mutex);
849         *wh = w + 1;
850
851         return 0;
852 } /* pcmcia_request_window */
853 EXPORT_SYMBOL(pcmcia_request_window);
854
855 void pcmcia_disable_device(struct pcmcia_device *p_dev)
856 {
857         pcmcia_release_configuration(p_dev);
858         pcmcia_release_io(p_dev, &p_dev->io);
859         if (p_dev->_irq) {
860                 free_irq(p_dev->irq, p_dev->priv);
861                 p_dev->_irq = 0;
862         }
863         if (p_dev->win)
864                 pcmcia_release_window(p_dev, p_dev->win);
865 }
866 EXPORT_SYMBOL(pcmcia_disable_device);