2 * PCMCIA 16-bit resource management functions
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.
8 * Copyright (C) 1999 David A. Hinds
9 * Copyright (C) 2004-2005 Dominik Brodowski
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.
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>
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>
35 #include "cs_internal.h"
38 /* Access speed for IO windows */
40 module_param(io_speed
, int, 0444);
43 static int pcmcia_adjust_io_region(struct resource
*res
, unsigned long start
,
44 unsigned long end
, struct pcmcia_socket
*s
)
46 if (s
->resource_ops
->adjust_io_region
)
47 return s
->resource_ops
->adjust_io_region(res
, start
, end
, s
);
51 static struct resource
*pcmcia_find_io_region(unsigned long base
, int num
,
53 struct pcmcia_socket
*s
)
55 if (s
->resource_ops
->find_io
)
56 return s
->resource_ops
->find_io(base
, num
, align
, s
);
60 int pcmcia_validate_mem(struct pcmcia_socket
*s
)
62 if (s
->resource_ops
->validate_mem
)
63 return s
->resource_ops
->validate_mem(s
);
64 /* if there is no callback, we can assume that everything is OK */
68 struct resource
*pcmcia_find_mem_region(u_long base
, u_long num
, u_long align
,
69 int low
, struct pcmcia_socket
*s
)
71 if (s
->resource_ops
->find_mem
)
72 return s
->resource_ops
->find_mem(base
, num
, align
, low
, s
);
79 * Special stuff for managing IO windows, because they are scarce
82 static int alloc_io_space(struct pcmcia_socket
*s
, u_int attr
,
83 unsigned int *base
, unsigned int num
, u_int lines
)
86 unsigned int try, align
;
88 align
= (*base
) ? (lines
? 1<<lines
: 0) : 1;
89 if (align
&& (align
< num
)) {
91 dev_dbg(&s
->dev
, "odd IO request: num %#x align %#x\n",
95 while (align
&& (align
< num
))
98 if (*base
& ~(align
-1)) {
99 dev_dbg(&s
->dev
, "odd IO request: base %#x align %#x\n",
103 if ((s
->features
& SS_CAP_STATIC_MAP
) && s
->io_offset
) {
104 *base
= s
->io_offset
| (*base
& 0x0fff);
107 /* Check for an already-allocated window that must conflict with
108 * what was asked for. It is a hack because it does not catch all
109 * potential conflicts, just the most obvious ones.
111 for (i
= 0; i
< MAX_IO_WIN
; i
++)
112 if ((s
->io
[i
].res
) && *base
&&
113 ((s
->io
[i
].res
->start
& (align
-1)) == *base
))
115 for (i
= 0; i
< MAX_IO_WIN
; i
++) {
117 s
->io
[i
].res
= pcmcia_find_io_region(*base
, num
, align
, s
);
119 *base
= s
->io
[i
].res
->start
;
120 s
->io
[i
].res
->flags
= (s
->io
[i
].res
->flags
& ~IORESOURCE_BITS
) | (attr
& IORESOURCE_BITS
);
121 s
->io
[i
].InUse
= num
;
125 } else if ((s
->io
[i
].res
->flags
& IORESOURCE_BITS
) != (attr
& IORESOURCE_BITS
))
127 /* Try to extend top of window */
128 try = s
->io
[i
].res
->end
+ 1;
129 if ((*base
== 0) || (*base
== try))
130 if (pcmcia_adjust_io_region(s
->io
[i
].res
, s
->io
[i
].res
->start
,
131 s
->io
[i
].res
->end
+ num
, s
) == 0) {
133 s
->io
[i
].InUse
+= num
;
136 /* Try to extend bottom of window */
137 try = s
->io
[i
].res
->start
- num
;
138 if ((*base
== 0) || (*base
== try))
139 if (pcmcia_adjust_io_region(s
->io
[i
].res
, s
->io
[i
].res
->start
- num
,
140 s
->io
[i
].res
->end
, s
) == 0) {
142 s
->io
[i
].InUse
+= num
;
146 return (i
== MAX_IO_WIN
);
147 } /* alloc_io_space */
150 static void release_io_space(struct pcmcia_socket
*s
, unsigned int base
,
155 for (i
= 0; i
< MAX_IO_WIN
; i
++) {
158 if ((s
->io
[i
].res
->start
<= base
) &&
159 (s
->io
[i
].res
->end
>= base
+num
-1)) {
160 s
->io
[i
].InUse
-= num
;
161 /* Free the window if no one else is using it */
162 if (s
->io
[i
].InUse
== 0) {
163 release_resource(s
->io
[i
].res
);
169 } /* release_io_space */
172 /** pccard_access_configuration_register
174 * Access_configuration_register() reads and writes configuration
175 * registers in attribute memory. Memory window 0 is reserved for
176 * this and the tuple reading services.
179 int pcmcia_access_configuration_register(struct pcmcia_device
*p_dev
,
182 struct pcmcia_socket
*s
;
187 if (!p_dev
|| !p_dev
->function_config
)
192 mutex_lock(&s
->ops_mutex
);
193 c
= p_dev
->function_config
;
195 if (!(c
->state
& CONFIG_LOCKED
)) {
196 dev_dbg(&s
->dev
, "Configuration isnt't locked\n");
197 mutex_unlock(&s
->ops_mutex
);
201 addr
= (c
->ConfigBase
+ reg
->Offset
) >> 1;
202 mutex_unlock(&s
->ops_mutex
);
204 switch (reg
->Action
) {
206 pcmcia_read_cis_mem(s
, 1, addr
, 1, &val
);
211 pcmcia_write_cis_mem(s
, 1, addr
, 1, &val
);
214 dev_dbg(&s
->dev
, "Invalid conf register request\n");
219 } /* pcmcia_access_configuration_register */
220 EXPORT_SYMBOL(pcmcia_access_configuration_register
);
223 int pcmcia_map_mem_page(struct pcmcia_device
*p_dev
, window_handle_t wh
,
226 struct pcmcia_socket
*s
= p_dev
->socket
;
232 if (req
->Page
!= 0) {
233 dev_dbg(&s
->dev
, "failure: requested page is zero\n");
236 mutex_lock(&s
->ops_mutex
);
237 s
->win
[wh
].card_start
= req
->CardOffset
;
238 ret
= s
->ops
->set_mem_map(s
, &s
->win
[wh
]);
240 dev_warn(&s
->dev
, "failed to set_mem_map\n");
241 mutex_unlock(&s
->ops_mutex
);
243 } /* pcmcia_map_mem_page */
244 EXPORT_SYMBOL(pcmcia_map_mem_page
);
247 /** pcmcia_modify_configuration
249 * Modify a locked socket configuration
251 int pcmcia_modify_configuration(struct pcmcia_device
*p_dev
,
254 struct pcmcia_socket
*s
;
260 mutex_lock(&s
->ops_mutex
);
261 c
= p_dev
->function_config
;
263 if (!(s
->state
& SOCKET_PRESENT
)) {
264 dev_dbg(&s
->dev
, "No card present\n");
268 if (!(c
->state
& CONFIG_LOCKED
)) {
269 dev_dbg(&s
->dev
, "Configuration isnt't locked\n");
274 if (mod
->Attributes
& (CONF_IRQ_CHANGE_VALID
| CONF_VCC_CHANGE_VALID
)) {
276 "changing Vcc or IRQ is not allowed at this time\n");
281 /* We only allow changing Vpp1 and Vpp2 to the same value */
282 if ((mod
->Attributes
& CONF_VPP1_CHANGE_VALID
) &&
283 (mod
->Attributes
& CONF_VPP2_CHANGE_VALID
)) {
284 if (mod
->Vpp1
!= mod
->Vpp2
) {
285 dev_dbg(&s
->dev
, "Vpp1 and Vpp2 must be the same\n");
289 s
->socket
.Vpp
= mod
->Vpp1
;
290 if (s
->ops
->set_socket(s
, &s
->socket
)) {
291 dev_printk(KERN_WARNING
, &s
->dev
,
292 "Unable to set VPP\n");
296 } else if ((mod
->Attributes
& CONF_VPP1_CHANGE_VALID
) ||
297 (mod
->Attributes
& CONF_VPP2_CHANGE_VALID
)) {
298 dev_dbg(&s
->dev
, "changing Vcc is not allowed at this time\n");
303 if (mod
->Attributes
& CONF_IO_CHANGE_WIDTH
) {
304 pccard_io_map io_off
= { 0, 0, 0, 0, 1 };
308 io_on
.speed
= io_speed
;
309 for (i
= 0; i
< MAX_IO_WIN
; i
++) {
315 io_on
.flags
= MAP_ACTIVE
| IO_DATA_PATH_WIDTH_8
;
316 io_on
.start
= s
->io
[i
].res
->start
;
317 io_on
.stop
= s
->io
[i
].res
->end
;
319 s
->ops
->set_io_map(s
, &io_off
);
321 s
->ops
->set_io_map(s
, &io_on
);
326 mutex_unlock(&s
->ops_mutex
);
329 } /* modify_configuration */
330 EXPORT_SYMBOL(pcmcia_modify_configuration
);
333 int pcmcia_release_configuration(struct pcmcia_device
*p_dev
)
335 pccard_io_map io
= { 0, 0, 0, 0, 1 };
336 struct pcmcia_socket
*s
= p_dev
->socket
;
340 mutex_lock(&s
->ops_mutex
);
341 c
= p_dev
->function_config
;
342 if (p_dev
->_locked
) {
344 if (--(s
->lock_count
) == 0) {
345 s
->socket
.flags
= SS_OUTPUT_ENA
; /* Is this correct? */
347 s
->socket
.io_irq
= 0;
348 s
->ops
->set_socket(s
, &s
->socket
);
351 if (c
->state
& CONFIG_LOCKED
) {
352 c
->state
&= ~CONFIG_LOCKED
;
353 if (c
->state
& CONFIG_IO_REQ
)
354 for (i
= 0; i
< MAX_IO_WIN
; i
++) {
358 if (s
->io
[i
].Config
!= 0)
361 s
->ops
->set_io_map(s
, &io
);
364 mutex_unlock(&s
->ops_mutex
);
367 } /* pcmcia_release_configuration */
370 /** pcmcia_release_io
372 * Release_io() releases the I/O ranges allocated by a client. This
373 * may be invoked some time after a card ejection has already dumped
374 * the actual socket configuration, so if the client is "stale", we
375 * don't bother checking the port ranges against the current socket
378 static int pcmcia_release_io(struct pcmcia_device
*p_dev
, io_req_t
*req
)
380 struct pcmcia_socket
*s
= p_dev
->socket
;
384 mutex_lock(&s
->ops_mutex
);
385 c
= p_dev
->function_config
;
392 if ((c
->io
.BasePort1
!= req
->BasePort1
) ||
393 (c
->io
.NumPorts1
!= req
->NumPorts1
) ||
394 (c
->io
.BasePort2
!= req
->BasePort2
) ||
395 (c
->io
.NumPorts2
!= req
->NumPorts2
))
398 c
->state
&= ~CONFIG_IO_REQ
;
400 release_io_space(s
, req
->BasePort1
, req
->NumPorts1
);
402 release_io_space(s
, req
->BasePort2
, req
->NumPorts2
);
405 mutex_unlock(&s
->ops_mutex
);
408 } /* pcmcia_release_io */
411 static int pcmcia_release_irq(struct pcmcia_device
*p_dev
, irq_req_t
*req
)
413 struct pcmcia_socket
*s
= p_dev
->socket
;
417 mutex_lock(&s
->ops_mutex
);
419 c
= p_dev
->function_config
;
426 if (c
->state
& CONFIG_LOCKED
)
429 if (c
->irq
.Attributes
!= req
->Attributes
) {
430 dev_dbg(&s
->dev
, "IRQ attributes must match assigned ones\n");
433 if (s
->pcmcia_irq
!= req
->AssignedIRQ
) {
434 dev_dbg(&s
->dev
, "IRQ must match assigned one\n");
439 free_irq(req
->AssignedIRQ
, p_dev
->priv
);
444 mutex_unlock(&s
->ops_mutex
);
447 } /* pcmcia_release_irq */
450 int pcmcia_release_window(struct pcmcia_device
*p_dev
, window_handle_t wh
)
452 struct pcmcia_socket
*s
= p_dev
->socket
;
459 mutex_lock(&s
->ops_mutex
);
462 if (!(p_dev
->_win
& CLIENT_WIN_REQ(wh
))) {
463 dev_dbg(&s
->dev
, "not releasing unknown window\n");
464 mutex_unlock(&s
->ops_mutex
);
468 /* Shut down memory window */
469 win
->flags
&= ~MAP_ACTIVE
;
470 s
->ops
->set_mem_map(s
, win
);
471 s
->state
&= ~SOCKET_WIN_REQ(wh
);
473 /* Release system memory */
475 release_resource(win
->res
);
479 p_dev
->_win
&= ~CLIENT_WIN_REQ(wh
);
480 mutex_unlock(&s
->ops_mutex
);
483 } /* pcmcia_release_window */
484 EXPORT_SYMBOL(pcmcia_release_window
);
487 int pcmcia_request_configuration(struct pcmcia_device
*p_dev
,
492 struct pcmcia_socket
*s
= p_dev
->socket
;
496 if (!(s
->state
& SOCKET_PRESENT
))
499 if (req
->IntType
& INT_CARDBUS
) {
500 dev_dbg(&s
->dev
, "IntType may not be INT_CARDBUS\n");
504 mutex_lock(&s
->ops_mutex
);
505 c
= p_dev
->function_config
;
506 if (c
->state
& CONFIG_LOCKED
) {
507 mutex_unlock(&s
->ops_mutex
);
508 dev_dbg(&s
->dev
, "Configuration is locked\n");
512 /* Do power control. We don't allow changes in Vcc. */
513 s
->socket
.Vpp
= req
->Vpp
;
514 if (s
->ops
->set_socket(s
, &s
->socket
)) {
515 mutex_unlock(&s
->ops_mutex
);
516 dev_printk(KERN_WARNING
, &s
->dev
,
517 "Unable to set socket state\n");
521 /* Pick memory or I/O card, DMA mode, interrupt */
522 c
->IntType
= req
->IntType
;
523 c
->Attributes
= req
->Attributes
;
524 if (req
->IntType
& INT_MEMORY_AND_IO
)
525 s
->socket
.flags
|= SS_IOCARD
;
526 if (req
->IntType
& INT_ZOOMED_VIDEO
)
527 s
->socket
.flags
|= SS_ZVCARD
| SS_IOCARD
;
528 if (req
->Attributes
& CONF_ENABLE_DMA
)
529 s
->socket
.flags
|= SS_DMA_MODE
;
530 if (req
->Attributes
& CONF_ENABLE_SPKR
)
531 s
->socket
.flags
|= SS_SPKR_ENA
;
532 if (req
->Attributes
& CONF_ENABLE_IRQ
)
533 s
->socket
.io_irq
= s
->pcmcia_irq
;
535 s
->socket
.io_irq
= 0;
536 s
->ops
->set_socket(s
, &s
->socket
);
538 mutex_unlock(&s
->ops_mutex
);
540 /* Set up CIS configuration registers */
541 base
= c
->ConfigBase
= req
->ConfigBase
;
542 c
->CardValues
= req
->Present
;
543 if (req
->Present
& PRESENT_COPY
) {
545 pcmcia_write_cis_mem(s
, 1, (base
+ CISREG_SCR
)>>1, 1, &c
->Copy
);
547 if (req
->Present
& PRESENT_OPTION
) {
548 if (s
->functions
== 1) {
549 c
->Option
= req
->ConfigIndex
& COR_CONFIG_MASK
;
551 c
->Option
= req
->ConfigIndex
& COR_MFC_CONFIG_MASK
;
552 c
->Option
|= COR_FUNC_ENA
|COR_IREQ_ENA
;
553 if (req
->Present
& PRESENT_IOBASE_0
)
554 c
->Option
|= COR_ADDR_DECODE
;
556 if (req
->Attributes
& CONF_ENABLE_IRQ
)
557 if (!(c
->irq
.Attributes
& IRQ_FORCED_PULSE
))
558 c
->Option
|= COR_LEVEL_REQ
;
559 pcmcia_write_cis_mem(s
, 1, (base
+ CISREG_COR
)>>1, 1, &c
->Option
);
562 if (req
->Present
& PRESENT_STATUS
) {
563 c
->Status
= req
->Status
;
564 pcmcia_write_cis_mem(s
, 1, (base
+ CISREG_CCSR
)>>1, 1, &c
->Status
);
566 if (req
->Present
& PRESENT_PIN_REPLACE
) {
568 pcmcia_write_cis_mem(s
, 1, (base
+ CISREG_PRR
)>>1, 1, &c
->Pin
);
570 if (req
->Present
& PRESENT_EXT_STATUS
) {
571 c
->ExtStatus
= req
->ExtStatus
;
572 pcmcia_write_cis_mem(s
, 1, (base
+ CISREG_ESR
)>>1, 1, &c
->ExtStatus
);
574 if (req
->Present
& PRESENT_IOBASE_0
) {
575 u_char b
= c
->io
.BasePort1
& 0xff;
576 pcmcia_write_cis_mem(s
, 1, (base
+ CISREG_IOBASE_0
)>>1, 1, &b
);
577 b
= (c
->io
.BasePort1
>> 8) & 0xff;
578 pcmcia_write_cis_mem(s
, 1, (base
+ CISREG_IOBASE_1
)>>1, 1, &b
);
580 if (req
->Present
& PRESENT_IOSIZE
) {
581 u_char b
= c
->io
.NumPorts1
+ c
->io
.NumPorts2
- 1;
582 pcmcia_write_cis_mem(s
, 1, (base
+ CISREG_IOSIZE
)>>1, 1, &b
);
585 /* Configure I/O windows */
586 if (c
->state
& CONFIG_IO_REQ
) {
587 mutex_lock(&s
->ops_mutex
);
588 iomap
.speed
= io_speed
;
589 for (i
= 0; i
< MAX_IO_WIN
; i
++)
592 iomap
.flags
= MAP_ACTIVE
;
593 switch (s
->io
[i
].res
->flags
& IO_DATA_PATH_WIDTH
) {
594 case IO_DATA_PATH_WIDTH_16
:
595 iomap
.flags
|= MAP_16BIT
; break;
596 case IO_DATA_PATH_WIDTH_AUTO
:
597 iomap
.flags
|= MAP_AUTOSZ
; break;
601 iomap
.start
= s
->io
[i
].res
->start
;
602 iomap
.stop
= s
->io
[i
].res
->end
;
603 s
->ops
->set_io_map(s
, &iomap
);
606 mutex_unlock(&s
->ops_mutex
);
609 c
->state
|= CONFIG_LOCKED
;
612 } /* pcmcia_request_configuration */
613 EXPORT_SYMBOL(pcmcia_request_configuration
);
616 /** pcmcia_request_io
618 * Request_io() reserves ranges of port addresses for a socket.
619 * I have not implemented range sharing or alias addressing.
621 int pcmcia_request_io(struct pcmcia_device
*p_dev
, io_req_t
*req
)
623 struct pcmcia_socket
*s
= p_dev
->socket
;
627 mutex_lock(&s
->ops_mutex
);
629 if (!(s
->state
& SOCKET_PRESENT
)) {
630 dev_dbg(&s
->dev
, "No card present\n");
637 c
= p_dev
->function_config
;
638 if (c
->state
& CONFIG_LOCKED
) {
639 dev_dbg(&s
->dev
, "Configuration is locked\n");
642 if (c
->state
& CONFIG_IO_REQ
) {
643 dev_dbg(&s
->dev
, "IO already configured\n");
646 if (req
->Attributes1
& (IO_SHARED
| IO_FORCE_ALIAS_ACCESS
)) {
647 dev_dbg(&s
->dev
, "bad attribute setting for IO region 1\n");
650 if ((req
->NumPorts2
> 0) &&
651 (req
->Attributes2
& (IO_SHARED
| IO_FORCE_ALIAS_ACCESS
))) {
652 dev_dbg(&s
->dev
, "bad attribute setting for IO region 2\n");
656 dev_dbg(&s
->dev
, "trying to allocate resource 1\n");
657 ret
= alloc_io_space(s
, req
->Attributes1
, &req
->BasePort1
,
658 req
->NumPorts1
, req
->IOAddrLines
);
660 dev_dbg(&s
->dev
, "allocation of resource 1 failed\n");
664 if (req
->NumPorts2
) {
665 dev_dbg(&s
->dev
, "trying to allocate resource 2\n");
666 ret
= alloc_io_space(s
, req
->Attributes2
, &req
->BasePort2
,
667 req
->NumPorts2
, req
->IOAddrLines
);
669 dev_dbg(&s
->dev
, "allocation of resource 2 failed\n");
670 release_io_space(s
, req
->BasePort1
, req
->NumPorts1
);
676 c
->state
|= CONFIG_IO_REQ
;
678 dev_dbg(&s
->dev
, "allocating resources succeeded: %d\n", ret
);
681 mutex_unlock(&s
->ops_mutex
);
684 } /* pcmcia_request_io */
685 EXPORT_SYMBOL(pcmcia_request_io
);
688 /** pcmcia_request_irq
690 * Request_irq() reserves an irq for this client.
693 int pcmcia_request_irq(struct pcmcia_device
*p_dev
, irq_req_t
*req
)
695 struct pcmcia_socket
*s
= p_dev
->socket
;
697 int ret
= -EINVAL
, irq
= p_dev
->irq_v
;
698 int type
= IRQF_SHARED
;
700 mutex_lock(&s
->ops_mutex
);
702 if (!(s
->state
& SOCKET_PRESENT
)) {
703 dev_dbg(&s
->dev
, "No card present\n");
706 c
= p_dev
->function_config
;
707 if (c
->state
& CONFIG_LOCKED
) {
708 dev_dbg(&s
->dev
, "Configuration is locked\n");
713 dev_dbg(&s
->dev
, "no IRQ available\n");
717 if (!(req
->Attributes
& IRQ_TYPE_DYNAMIC_SHARING
)) {
718 req
->Attributes
|= IRQ_TYPE_DYNAMIC_SHARING
;
719 dev_printk(KERN_WARNING
, &p_dev
->dev
, "pcmcia: the driver "
720 "needs updating to supported shared IRQ lines.\n");
724 ret
= request_irq(irq
, req
->Handler
, type
,
725 p_dev
->devname
, p_dev
->priv
);
727 dev_printk(KERN_INFO
, &s
->dev
,
728 "request_irq() failed\n");
733 c
->irq
.Attributes
= req
->Attributes
;
734 req
->AssignedIRQ
= irq
;
740 mutex_unlock(&s
->ops_mutex
);
742 } /* pcmcia_request_irq */
743 EXPORT_SYMBOL(pcmcia_request_irq
);
746 #ifdef CONFIG_PCMCIA_PROBE
748 /* mask of IRQs already reserved by other cards, we should avoid using them */
749 static u8 pcmcia_used_irq
[NR_IRQS
];
751 static irqreturn_t
test_action(int cpl
, void *dev_id
)
757 * pcmcia_setup_isa_irq() - determine whether an ISA IRQ can be used
758 * @p_dev - the associated PCMCIA device
760 * locking note: must be called with ops_mutex locked.
762 static int pcmcia_setup_isa_irq(struct pcmcia_device
*p_dev
, int type
)
764 struct pcmcia_socket
*s
= p_dev
->socket
;
765 unsigned int try, irq
;
766 u32 mask
= s
->irq_mask
;
769 for (try = 0; try < 64; try++) {
772 /* marked as available by driver, not blocked by userspace? */
773 if (!((mask
>> irq
) & 1))
776 /* avoid an IRQ which is already used by another PCMCIA card */
777 if ((try < 32) && pcmcia_used_irq
[irq
])
780 /* register the correct driver, if possible, to check whether
781 * registering a dummy handle works, i.e. if the IRQ isn't
782 * marked as used by the kernel resource management core */
783 ret
= request_irq(irq
, test_action
, type
, p_dev
->devname
,
786 free_irq(irq
, p_dev
);
787 p_dev
->irq_v
= s
->pcmcia_irq
= irq
;
788 pcmcia_used_irq
[irq
]++;
796 void pcmcia_cleanup_irq(struct pcmcia_socket
*s
)
798 pcmcia_used_irq
[s
->pcmcia_irq
]--;
802 #else /* CONFIG_PCMCIA_PROBE */
804 static int pcmcia_setup_isa_irq(struct pcmcia_device
*p_dev
, int type
)
809 void pcmcia_cleanup_irq(struct pcmcia_socket
*s
)
815 #endif /* CONFIG_PCMCIA_PROBE */
819 * pcmcia_setup_irq() - determine IRQ to be used for device
820 * @p_dev - the associated PCMCIA device
822 * locking note: must be called with ops_mutex locked.
824 int pcmcia_setup_irq(struct pcmcia_device
*p_dev
)
826 struct pcmcia_socket
*s
= p_dev
->socket
;
831 /* already assigned? */
833 p_dev
->irq_v
= s
->pcmcia_irq
;
837 /* prefer an exclusive ISA irq */
838 if (!pcmcia_setup_isa_irq(p_dev
, 0))
841 /* but accept a shared ISA irq */
842 if (!pcmcia_setup_isa_irq(p_dev
, IRQF_SHARED
))
845 /* but use the PCI irq otherwise */
847 p_dev
->irq_v
= s
->pcmcia_irq
= s
->pci_irq
;
855 /** pcmcia_request_window
857 * Request_window() establishes a mapping between card memory space
858 * and system memory space.
860 int pcmcia_request_window(struct pcmcia_device
*p_dev
, win_req_t
*req
, window_handle_t
*wh
)
862 struct pcmcia_socket
*s
= p_dev
->socket
;
867 if (!(s
->state
& SOCKET_PRESENT
)) {
868 dev_dbg(&s
->dev
, "No card present\n");
871 if (req
->Attributes
& (WIN_PAGED
| WIN_SHARED
)) {
872 dev_dbg(&s
->dev
, "bad attribute setting for iomem region\n");
876 /* Window size defaults to smallest available */
878 req
->Size
= s
->map_size
;
879 align
= (((s
->features
& SS_CAP_MEM_ALIGN
) ||
880 (req
->Attributes
& WIN_STRICT_ALIGN
)) ?
881 req
->Size
: s
->map_size
);
882 if (req
->Size
& (s
->map_size
-1)) {
883 dev_dbg(&s
->dev
, "invalid map size\n");
886 if ((req
->Base
&& (s
->features
& SS_CAP_STATIC_MAP
)) ||
887 (req
->Base
& (align
-1))) {
888 dev_dbg(&s
->dev
, "invalid base address\n");
894 /* Allocate system memory window */
895 for (w
= 0; w
< MAX_WIN
; w
++)
896 if (!(s
->state
& SOCKET_WIN_REQ(w
)))
899 dev_dbg(&s
->dev
, "all windows are used already\n");
903 mutex_lock(&s
->ops_mutex
);
906 if (!(s
->features
& SS_CAP_STATIC_MAP
)) {
907 win
->res
= pcmcia_find_mem_region(req
->Base
, req
->Size
, align
,
908 (req
->Attributes
& WIN_MAP_BELOW_1MB
), s
);
910 dev_dbg(&s
->dev
, "allocating mem region failed\n");
911 mutex_unlock(&s
->ops_mutex
);
915 p_dev
->_win
|= CLIENT_WIN_REQ(w
);
917 /* Configure the socket controller */
920 win
->speed
= req
->AccessSpeed
;
921 if (req
->Attributes
& WIN_MEMORY_TYPE
)
922 win
->flags
|= MAP_ATTRIB
;
923 if (req
->Attributes
& WIN_ENABLE
)
924 win
->flags
|= MAP_ACTIVE
;
925 if (req
->Attributes
& WIN_DATA_WIDTH_16
)
926 win
->flags
|= MAP_16BIT
;
927 if (req
->Attributes
& WIN_USE_WAIT
)
928 win
->flags
|= MAP_USE_WAIT
;
931 if (s
->ops
->set_mem_map(s
, win
) != 0) {
932 dev_dbg(&s
->dev
, "failed to set memory mapping\n");
933 mutex_unlock(&s
->ops_mutex
);
936 s
->state
|= SOCKET_WIN_REQ(w
);
938 /* Return window handle */
939 if (s
->features
& SS_CAP_STATIC_MAP
)
940 req
->Base
= win
->static_start
;
942 req
->Base
= win
->res
->start
;
944 mutex_unlock(&s
->ops_mutex
);
948 } /* pcmcia_request_window */
949 EXPORT_SYMBOL(pcmcia_request_window
);
951 void pcmcia_disable_device(struct pcmcia_device
*p_dev
)
953 pcmcia_release_configuration(p_dev
);
954 pcmcia_release_io(p_dev
, &p_dev
->io
);
955 pcmcia_release_irq(p_dev
, &p_dev
->irq
);
957 pcmcia_release_window(p_dev
, p_dev
->win
);
959 EXPORT_SYMBOL(pcmcia_disable_device
);
962 struct pcmcia_cfg_mem
{
963 struct pcmcia_device
*p_dev
;
965 int (*conf_check
) (struct pcmcia_device
*p_dev
,
966 cistpl_cftable_entry_t
*cfg
,
967 cistpl_cftable_entry_t
*dflt
,
971 cistpl_cftable_entry_t dflt
;
975 * pcmcia_do_loop_config() - internal helper for pcmcia_loop_config()
977 * pcmcia_do_loop_config() is the internal callback for the call from
978 * pcmcia_loop_config() to pccard_loop_tuple(). Data is transferred
979 * by a struct pcmcia_cfg_mem.
981 static int pcmcia_do_loop_config(tuple_t
*tuple
, cisparse_t
*parse
, void *priv
)
983 cistpl_cftable_entry_t
*cfg
= &parse
->cftable_entry
;
984 struct pcmcia_cfg_mem
*cfg_mem
= priv
;
987 cfg_mem
->p_dev
->conf
.ConfigIndex
= cfg
->index
;
988 if (cfg
->flags
& CISTPL_CFTABLE_DEFAULT
)
989 cfg_mem
->dflt
= *cfg
;
991 return cfg_mem
->conf_check(cfg_mem
->p_dev
, cfg
, &cfg_mem
->dflt
,
992 cfg_mem
->p_dev
->socket
->socket
.Vcc
,
997 * pcmcia_loop_config() - loop over configuration options
998 * @p_dev: the struct pcmcia_device which we need to loop for.
999 * @conf_check: function to call for each configuration option.
1000 * It gets passed the struct pcmcia_device, the CIS data
1001 * describing the configuration option, and private data
1002 * being passed to pcmcia_loop_config()
1003 * @priv_data: private data to be passed to the conf_check function.
1005 * pcmcia_loop_config() loops over all configuration options, and calls
1006 * the driver-specific conf_check() for each one, checking whether
1007 * it is a valid one. Returns 0 on success or errorcode otherwise.
1009 int pcmcia_loop_config(struct pcmcia_device
*p_dev
,
1010 int (*conf_check
) (struct pcmcia_device
*p_dev
,
1011 cistpl_cftable_entry_t
*cfg
,
1012 cistpl_cftable_entry_t
*dflt
,
1017 struct pcmcia_cfg_mem
*cfg_mem
;
1020 cfg_mem
= kzalloc(sizeof(struct pcmcia_cfg_mem
), GFP_KERNEL
);
1021 if (cfg_mem
== NULL
)
1024 cfg_mem
->p_dev
= p_dev
;
1025 cfg_mem
->conf_check
= conf_check
;
1026 cfg_mem
->priv_data
= priv_data
;
1028 ret
= pccard_loop_tuple(p_dev
->socket
, p_dev
->func
,
1029 CISTPL_CFTABLE_ENTRY
, &cfg_mem
->parse
,
1030 cfg_mem
, pcmcia_do_loop_config
);
1035 EXPORT_SYMBOL(pcmcia_loop_config
);
1038 struct pcmcia_loop_mem
{
1039 struct pcmcia_device
*p_dev
;
1041 int (*loop_tuple
) (struct pcmcia_device
*p_dev
,
1047 * pcmcia_do_loop_tuple() - internal helper for pcmcia_loop_config()
1049 * pcmcia_do_loop_tuple() is the internal callback for the call from
1050 * pcmcia_loop_tuple() to pccard_loop_tuple(). Data is transferred
1051 * by a struct pcmcia_cfg_mem.
1053 static int pcmcia_do_loop_tuple(tuple_t
*tuple
, cisparse_t
*parse
, void *priv
)
1055 struct pcmcia_loop_mem
*loop
= priv
;
1057 return loop
->loop_tuple(loop
->p_dev
, tuple
, loop
->priv_data
);
1061 * pcmcia_loop_tuple() - loop over tuples in the CIS
1062 * @p_dev: the struct pcmcia_device which we need to loop for.
1063 * @code: which CIS code shall we look for?
1064 * @priv_data: private data to be passed to the loop_tuple function.
1065 * @loop_tuple: function to call for each CIS entry of type @function. IT
1066 * gets passed the raw tuple and @priv_data.
1068 * pcmcia_loop_tuple() loops over all CIS entries of type @function, and
1069 * calls the @loop_tuple function for each entry. If the call to @loop_tuple
1070 * returns 0, the loop exits. Returns 0 on success or errorcode otherwise.
1072 int pcmcia_loop_tuple(struct pcmcia_device
*p_dev
, cisdata_t code
,
1073 int (*loop_tuple
) (struct pcmcia_device
*p_dev
,
1078 struct pcmcia_loop_mem loop
= {
1080 .loop_tuple
= loop_tuple
,
1081 .priv_data
= priv_data
};
1083 return pccard_loop_tuple(p_dev
->socket
, p_dev
->func
, code
, NULL
,
1084 &loop
, pcmcia_do_loop_tuple
);
1086 EXPORT_SYMBOL(pcmcia_loop_tuple
);
1089 struct pcmcia_loop_get
{
1095 * pcmcia_do_get_tuple() - internal helper for pcmcia_get_tuple()
1097 * pcmcia_do_get_tuple() is the internal callback for the call from
1098 * pcmcia_get_tuple() to pcmcia_loop_tuple(). As we're only interested in
1099 * the first tuple, return 0 unconditionally. Create a memory buffer large
1100 * enough to hold the content of the tuple, and fill it with the tuple data.
1101 * The caller is responsible to free the buffer.
1103 static int pcmcia_do_get_tuple(struct pcmcia_device
*p_dev
, tuple_t
*tuple
,
1106 struct pcmcia_loop_get
*get
= priv
;
1108 *get
->buf
= kzalloc(tuple
->TupleDataLen
, GFP_KERNEL
);
1110 get
->len
= tuple
->TupleDataLen
;
1111 memcpy(*get
->buf
, tuple
->TupleData
, tuple
->TupleDataLen
);
1113 dev_dbg(&p_dev
->dev
, "do_get_tuple: out of memory\n");
1118 * pcmcia_get_tuple() - get first tuple from CIS
1119 * @p_dev: the struct pcmcia_device which we need to loop for.
1120 * @code: which CIS code shall we look for?
1121 * @buf: pointer to store the buffer to.
1123 * pcmcia_get_tuple() gets the content of the first CIS entry of type @code.
1124 * It returns the buffer length (or zero). The caller is responsible to free
1125 * the buffer passed in @buf.
1127 size_t pcmcia_get_tuple(struct pcmcia_device
*p_dev
, cisdata_t code
,
1128 unsigned char **buf
)
1130 struct pcmcia_loop_get get
= {
1136 pcmcia_loop_tuple(p_dev
, code
, pcmcia_do_get_tuple
, &get
);
1140 EXPORT_SYMBOL(pcmcia_get_tuple
);
1144 * pcmcia_do_get_mac() - internal helper for pcmcia_get_mac_from_cis()
1146 * pcmcia_do_get_mac() is the internal callback for the call from
1147 * pcmcia_get_mac_from_cis() to pcmcia_loop_tuple(). We check whether the
1148 * tuple contains a proper LAN_NODE_ID of length 6, and copy the data
1149 * to struct net_device->dev_addr[i].
1151 static int pcmcia_do_get_mac(struct pcmcia_device
*p_dev
, tuple_t
*tuple
,
1154 struct net_device
*dev
= priv
;
1157 if (tuple
->TupleData
[0] != CISTPL_FUNCE_LAN_NODE_ID
)
1159 if (tuple
->TupleDataLen
< ETH_ALEN
+ 2) {
1160 dev_warn(&p_dev
->dev
, "Invalid CIS tuple length for "
1165 if (tuple
->TupleData
[1] != ETH_ALEN
) {
1166 dev_warn(&p_dev
->dev
, "Invalid header for LAN_NODE_ID\n");
1169 for (i
= 0; i
< 6; i
++)
1170 dev
->dev_addr
[i
] = tuple
->TupleData
[i
+2];
1175 * pcmcia_get_mac_from_cis() - read out MAC address from CISTPL_FUNCE
1176 * @p_dev: the struct pcmcia_device for which we want the address.
1177 * @dev: a properly prepared struct net_device to store the info to.
1179 * pcmcia_get_mac_from_cis() reads out the hardware MAC address from
1180 * CISTPL_FUNCE and stores it into struct net_device *dev->dev_addr which
1181 * must be set up properly by the driver (see examples!).
1183 int pcmcia_get_mac_from_cis(struct pcmcia_device
*p_dev
, struct net_device
*dev
)
1185 return pcmcia_loop_tuple(p_dev
, CISTPL_FUNCE
, pcmcia_do_get_mac
, dev
);
1187 EXPORT_SYMBOL(pcmcia_get_mac_from_cis
);