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