Commit | Line | Data |
---|---|---|
27590d06 HS |
1 | /* |
2 | ||
3 | Driver for the Marvell 8385 based compact flash WLAN cards. | |
4 | ||
5 | (C) 2007 by Holger Schurig <hs4233@mail.mn-solutions.de> | |
6 | ||
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 2 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program; see the file COPYING. If not, write to | |
19 | the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor, | |
20 | Boston, MA 02110-1301, USA. | |
21 | ||
22 | */ | |
23 | ||
24 | #include <linux/module.h> | |
25 | #include <linux/delay.h> | |
26 | #include <linux/moduleparam.h> | |
27 | #include <linux/firmware.h> | |
28 | #include <linux/netdevice.h> | |
29 | ||
30 | #include <pcmcia/cs_types.h> | |
31 | #include <pcmcia/cs.h> | |
32 | #include <pcmcia/cistpl.h> | |
33 | #include <pcmcia/ds.h> | |
34 | ||
35 | #include <linux/io.h> | |
36 | ||
37 | #define DRV_NAME "libertas_cs" | |
38 | ||
39 | #include "decl.h" | |
40 | #include "defs.h" | |
41 | #include "dev.h" | |
42 | ||
43 | ||
44 | /********************************************************************/ | |
45 | /* Module stuff */ | |
46 | /********************************************************************/ | |
47 | ||
48 | MODULE_AUTHOR("Holger Schurig <hs4233@mail.mn-solutions.de>"); | |
49 | MODULE_DESCRIPTION("Driver for Marvell 83xx compact flash WLAN cards"); | |
50 | MODULE_LICENSE("GPL"); | |
51 | ||
52 | ||
53 | ||
54 | /********************************************************************/ | |
55 | /* Data structures */ | |
56 | /********************************************************************/ | |
57 | ||
58 | struct if_cs_card { | |
59 | struct pcmcia_device *p_dev; | |
69f9032d | 60 | struct lbs_private *priv; |
27590d06 | 61 | void __iomem *iobase; |
9d45368a | 62 | bool align_regs; |
27590d06 HS |
63 | }; |
64 | ||
65 | ||
66 | ||
67 | /********************************************************************/ | |
68 | /* Hardware access */ | |
69 | /********************************************************************/ | |
70 | ||
71 | /* This define enables wrapper functions which allow you | |
72 | to dump all register accesses. You normally won't this, | |
73 | except for development */ | |
74 | /* #define DEBUG_IO */ | |
75 | ||
76 | #ifdef DEBUG_IO | |
77 | static int debug_output = 0; | |
78 | #else | |
79 | /* This way the compiler optimizes the printk's away */ | |
80 | #define debug_output 0 | |
81 | #endif | |
82 | ||
83 | static inline unsigned int if_cs_read8(struct if_cs_card *card, uint reg) | |
84 | { | |
85 | unsigned int val = ioread8(card->iobase + reg); | |
86 | if (debug_output) | |
7919b89c | 87 | printk(KERN_INFO "inb %08x<%02x\n", reg, val); |
27590d06 HS |
88 | return val; |
89 | } | |
90 | static inline unsigned int if_cs_read16(struct if_cs_card *card, uint reg) | |
91 | { | |
92 | unsigned int val = ioread16(card->iobase + reg); | |
93 | if (debug_output) | |
7919b89c | 94 | printk(KERN_INFO "inw %08x<%04x\n", reg, val); |
27590d06 HS |
95 | return val; |
96 | } | |
97 | static inline void if_cs_read16_rep( | |
98 | struct if_cs_card *card, | |
99 | uint reg, | |
100 | void *buf, | |
101 | unsigned long count) | |
102 | { | |
103 | if (debug_output) | |
7919b89c | 104 | printk(KERN_INFO "insw %08x<(0x%lx words)\n", |
27590d06 HS |
105 | reg, count); |
106 | ioread16_rep(card->iobase + reg, buf, count); | |
107 | } | |
108 | ||
109 | static inline void if_cs_write8(struct if_cs_card *card, uint reg, u8 val) | |
110 | { | |
111 | if (debug_output) | |
7919b89c | 112 | printk(KERN_INFO "outb %08x>%02x\n", reg, val); |
27590d06 HS |
113 | iowrite8(val, card->iobase + reg); |
114 | } | |
115 | ||
116 | static inline void if_cs_write16(struct if_cs_card *card, uint reg, u16 val) | |
117 | { | |
118 | if (debug_output) | |
7919b89c | 119 | printk(KERN_INFO "outw %08x>%04x\n", reg, val); |
27590d06 HS |
120 | iowrite16(val, card->iobase + reg); |
121 | } | |
122 | ||
123 | static inline void if_cs_write16_rep( | |
124 | struct if_cs_card *card, | |
125 | uint reg, | |
6dfff895 | 126 | const void *buf, |
27590d06 HS |
127 | unsigned long count) |
128 | { | |
129 | if (debug_output) | |
7919b89c | 130 | printk(KERN_INFO "outsw %08x>(0x%lx words)\n", |
27590d06 HS |
131 | reg, count); |
132 | iowrite16_rep(card->iobase + reg, buf, count); | |
133 | } | |
134 | ||
135 | ||
136 | /* | |
137 | * I know that polling/delaying is frowned upon. However, this procedure | |
138 | * with polling is needed while downloading the firmware. At this stage, | |
139 | * the hardware does unfortunately not create any interrupts. | |
140 | * | |
141 | * Fortunately, this function is never used once the firmware is in | |
142 | * the card. :-) | |
143 | * | |
144 | * As a reference, see the "Firmware Specification v5.1", page 18 | |
145 | * and 19. I did not follow their suggested timing to the word, | |
146 | * but this works nice & fast anyway. | |
147 | */ | |
148 | static int if_cs_poll_while_fw_download(struct if_cs_card *card, uint addr, u8 reg) | |
149 | { | |
150 | int i; | |
151 | ||
93416c87 | 152 | for (i = 0; i < 100000; i++) { |
27590d06 HS |
153 | u8 val = if_cs_read8(card, addr); |
154 | if (val == reg) | |
1fac36ee | 155 | return 0; |
93416c87 | 156 | udelay(5); |
27590d06 HS |
157 | } |
158 | return -ETIME; | |
159 | } | |
160 | ||
161 | ||
162 | ||
53143256 HS |
163 | /* |
164 | * First the bitmasks for the host/card interrupt/status registers: | |
165 | */ | |
78cf0747 HS |
166 | #define IF_CS_BIT_TX 0x0001 |
167 | #define IF_CS_BIT_RX 0x0002 | |
168 | #define IF_CS_BIT_COMMAND 0x0004 | |
169 | #define IF_CS_BIT_RESP 0x0008 | |
170 | #define IF_CS_BIT_EVENT 0x0010 | |
171 | #define IF_CS_BIT_MASK 0x001f | |
27590d06 | 172 | |
53143256 HS |
173 | |
174 | ||
175 | /* | |
176 | * It's not really clear to me what the host status register is for. It | |
177 | * needs to be set almost in union with "host int cause". The following | |
178 | * bits from above are used: | |
179 | * | |
180 | * IF_CS_BIT_TX driver downloaded a data packet | |
181 | * IF_CS_BIT_RX driver got a data packet | |
182 | * IF_CS_BIT_COMMAND driver downloaded a command | |
183 | * IF_CS_BIT_RESP not used (has some meaning with powerdown) | |
184 | * IF_CS_BIT_EVENT driver read a host event | |
185 | */ | |
78cf0747 | 186 | #define IF_CS_HOST_STATUS 0x00000000 |
27590d06 | 187 | |
53143256 HS |
188 | /* |
189 | * With the host int cause register can the host (that is, Linux) cause | |
190 | * an interrupt in the firmware, to tell the firmware about those events: | |
191 | * | |
192 | * IF_CS_BIT_TX a data packet has been downloaded | |
193 | * IF_CS_BIT_RX a received data packet has retrieved | |
194 | * IF_CS_BIT_COMMAND a firmware block or a command has been downloaded | |
195 | * IF_CS_BIT_RESP not used (has some meaning with powerdown) | |
196 | * IF_CS_BIT_EVENT a host event (link lost etc) has been retrieved | |
197 | */ | |
78cf0747 | 198 | #define IF_CS_HOST_INT_CAUSE 0x00000002 |
27590d06 | 199 | |
53143256 HS |
200 | /* |
201 | * The host int mask register is used to enable/disable interrupt. However, | |
202 | * I have the suspicion that disabled interrupts are lost. | |
203 | */ | |
78cf0747 | 204 | #define IF_CS_HOST_INT_MASK 0x00000004 |
27590d06 | 205 | |
53143256 HS |
206 | /* |
207 | * Used to send or receive data packets: | |
208 | */ | |
a78a8325 HS |
209 | #define IF_CS_WRITE 0x00000016 |
210 | #define IF_CS_WRITE_LEN 0x00000014 | |
78cf0747 HS |
211 | #define IF_CS_READ 0x00000010 |
212 | #define IF_CS_READ_LEN 0x00000024 | |
27590d06 | 213 | |
53143256 HS |
214 | /* |
215 | * Used to send commands (and to send firmware block) and to | |
216 | * receive command responses: | |
217 | */ | |
a78a8325 HS |
218 | #define IF_CS_CMD 0x0000001A |
219 | #define IF_CS_CMD_LEN 0x00000018 | |
220 | #define IF_CS_RESP 0x00000012 | |
221 | #define IF_CS_RESP_LEN 0x00000030 | |
27590d06 | 222 | |
53143256 HS |
223 | /* |
224 | * The card status registers shows what the card/firmware actually | |
225 | * accepts: | |
226 | * | |
227 | * IF_CS_BIT_TX you may send a data packet | |
228 | * IF_CS_BIT_RX you may retrieve a data packet | |
229 | * IF_CS_BIT_COMMAND you may send a command | |
230 | * IF_CS_BIT_RESP you may retrieve a command response | |
231 | * IF_CS_BIT_EVENT the card has a event for use (link lost, snr low etc) | |
232 | * | |
233 | * When reading this register several times, you will get back the same | |
234 | * results --- with one exception: the IF_CS_BIT_EVENT clear itself | |
235 | * automatically. | |
236 | * | |
237 | * Not that we don't rely on BIT_RX,_BIT_RESP or BIT_EVENT because | |
238 | * we handle this via the card int cause register. | |
239 | */ | |
78cf0747 HS |
240 | #define IF_CS_CARD_STATUS 0x00000020 |
241 | #define IF_CS_CARD_STATUS_MASK 0x7f00 | |
27590d06 | 242 | |
53143256 HS |
243 | /* |
244 | * The card int cause register is used by the card/firmware to notify us | |
245 | * about the following events: | |
246 | * | |
247 | * IF_CS_BIT_TX a data packet has successfully been sentx | |
248 | * IF_CS_BIT_RX a data packet has been received and can be retrieved | |
249 | * IF_CS_BIT_COMMAND not used | |
250 | * IF_CS_BIT_RESP the firmware has a command response for us | |
251 | * IF_CS_BIT_EVENT the card has a event for use (link lost, snr low etc) | |
252 | */ | |
78cf0747 | 253 | #define IF_CS_CARD_INT_CAUSE 0x00000022 |
27590d06 | 254 | |
53143256 HS |
255 | /* |
256 | * This is used to for handshaking with the card's bootloader/helper image | |
257 | * to synchronize downloading of firmware blocks. | |
258 | */ | |
a78a8325 HS |
259 | #define IF_CS_SQ_READ_LOW 0x00000028 |
260 | #define IF_CS_SQ_HELPER_OK 0x10 | |
27590d06 | 261 | |
53143256 HS |
262 | /* |
263 | * The scratch register tells us ... | |
264 | * | |
265 | * IF_CS_SCRATCH_BOOT_OK the bootloader runs | |
266 | * IF_CS_SCRATCH_HELPER_OK the helper firmware already runs | |
267 | */ | |
27590d06 | 268 | #define IF_CS_SCRATCH 0x0000003F |
53143256 HS |
269 | #define IF_CS_SCRATCH_BOOT_OK 0x00 |
270 | #define IF_CS_SCRATCH_HELPER_OK 0x5a | |
27590d06 | 271 | |
4c55523e HS |
272 | /* |
273 | * Used to detect ancient chips: | |
274 | */ | |
275 | #define IF_CS_PRODUCT_ID 0x0000001C | |
276 | #define IF_CS_CF8385_B1_REV 0x12 | |
dc7d243d | 277 | #define IF_CS_CF8381_B3_REV 0x04 |
9d45368a | 278 | #define IF_CS_CF8305_B1_REV 0x03 |
4c55523e | 279 | |
dc7d243d MV |
280 | /* |
281 | * Used to detect other cards than CF8385 since their revisions of silicon | |
282 | * doesn't match those from CF8385, eg. CF8381 B3 works with this driver. | |
283 | */ | |
9d45368a MV |
284 | #define CF8305_MANFID 0x02db |
285 | #define CF8305_CARDID 0x8103 | |
dc7d243d MV |
286 | #define CF8381_MANFID 0x02db |
287 | #define CF8381_CARDID 0x6064 | |
288 | #define CF8385_MANFID 0x02df | |
289 | #define CF8385_CARDID 0x8103 | |
290 | ||
9d45368a MV |
291 | static inline int if_cs_hw_is_cf8305(struct pcmcia_device *p_dev) |
292 | { | |
293 | return (p_dev->manf_id == CF8305_MANFID && | |
294 | p_dev->card_id == CF8305_CARDID); | |
295 | } | |
296 | ||
dc7d243d MV |
297 | static inline int if_cs_hw_is_cf8381(struct pcmcia_device *p_dev) |
298 | { | |
299 | return (p_dev->manf_id == CF8381_MANFID && | |
300 | p_dev->card_id == CF8381_CARDID); | |
301 | } | |
302 | ||
303 | static inline int if_cs_hw_is_cf8385(struct pcmcia_device *p_dev) | |
304 | { | |
305 | return (p_dev->manf_id == CF8385_MANFID && | |
306 | p_dev->card_id == CF8385_CARDID); | |
307 | } | |
27590d06 | 308 | |
27590d06 | 309 | /********************************************************************/ |
43d01c56 | 310 | /* I/O and interrupt handling */ |
27590d06 HS |
311 | /********************************************************************/ |
312 | ||
43d01c56 HS |
313 | static inline void if_cs_enable_ints(struct if_cs_card *card) |
314 | { | |
315 | lbs_deb_enter(LBS_DEB_CS); | |
78cf0747 | 316 | if_cs_write16(card, IF_CS_HOST_INT_MASK, 0); |
43d01c56 HS |
317 | } |
318 | ||
319 | static inline void if_cs_disable_ints(struct if_cs_card *card) | |
320 | { | |
321 | lbs_deb_enter(LBS_DEB_CS); | |
78cf0747 | 322 | if_cs_write16(card, IF_CS_HOST_INT_MASK, IF_CS_BIT_MASK); |
43d01c56 HS |
323 | } |
324 | ||
27590d06 HS |
325 | /* |
326 | * Called from if_cs_host_to_card to send a command to the hardware | |
327 | */ | |
69f9032d | 328 | static int if_cs_send_cmd(struct lbs_private *priv, u8 *buf, u16 nb) |
27590d06 HS |
329 | { |
330 | struct if_cs_card *card = (struct if_cs_card *)priv->card; | |
331 | int ret = -1; | |
332 | int loops = 0; | |
333 | ||
334 | lbs_deb_enter(LBS_DEB_CS); | |
43d01c56 | 335 | if_cs_disable_ints(card); |
27590d06 HS |
336 | |
337 | /* Is hardware ready? */ | |
338 | while (1) { | |
a78a8325 HS |
339 | u16 status = if_cs_read16(card, IF_CS_CARD_STATUS); |
340 | if (status & IF_CS_BIT_COMMAND) | |
27590d06 HS |
341 | break; |
342 | if (++loops > 100) { | |
343 | lbs_pr_err("card not ready for commands\n"); | |
344 | goto done; | |
345 | } | |
346 | mdelay(1); | |
347 | } | |
348 | ||
a78a8325 | 349 | if_cs_write16(card, IF_CS_CMD_LEN, nb); |
27590d06 | 350 | |
a78a8325 | 351 | if_cs_write16_rep(card, IF_CS_CMD, buf, nb / 2); |
27590d06 HS |
352 | /* Are we supposed to transfer an odd amount of bytes? */ |
353 | if (nb & 1) | |
a78a8325 | 354 | if_cs_write8(card, IF_CS_CMD, buf[nb-1]); |
27590d06 HS |
355 | |
356 | /* "Assert the download over interrupt command in the Host | |
357 | * status register" */ | |
78cf0747 | 358 | if_cs_write16(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND); |
27590d06 HS |
359 | |
360 | /* "Assert the download over interrupt command in the Card | |
361 | * interrupt case register" */ | |
78cf0747 | 362 | if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND); |
27590d06 HS |
363 | ret = 0; |
364 | ||
365 | done: | |
43d01c56 | 366 | if_cs_enable_ints(card); |
27590d06 HS |
367 | lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret); |
368 | return ret; | |
369 | } | |
370 | ||
27590d06 HS |
371 | /* |
372 | * Called from if_cs_host_to_card to send a data to the hardware | |
373 | */ | |
69f9032d | 374 | static void if_cs_send_data(struct lbs_private *priv, u8 *buf, u16 nb) |
27590d06 HS |
375 | { |
376 | struct if_cs_card *card = (struct if_cs_card *)priv->card; | |
43d01c56 | 377 | u16 status; |
27590d06 HS |
378 | |
379 | lbs_deb_enter(LBS_DEB_CS); | |
43d01c56 HS |
380 | if_cs_disable_ints(card); |
381 | ||
78cf0747 HS |
382 | status = if_cs_read16(card, IF_CS_CARD_STATUS); |
383 | BUG_ON((status & IF_CS_BIT_TX) == 0); | |
27590d06 | 384 | |
a78a8325 | 385 | if_cs_write16(card, IF_CS_WRITE_LEN, nb); |
27590d06 HS |
386 | |
387 | /* write even number of bytes, then odd byte if necessary */ | |
a78a8325 | 388 | if_cs_write16_rep(card, IF_CS_WRITE, buf, nb / 2); |
27590d06 | 389 | if (nb & 1) |
a78a8325 | 390 | if_cs_write8(card, IF_CS_WRITE, buf[nb-1]); |
27590d06 | 391 | |
78cf0747 HS |
392 | if_cs_write16(card, IF_CS_HOST_STATUS, IF_CS_BIT_TX); |
393 | if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_TX); | |
43d01c56 | 394 | if_cs_enable_ints(card); |
27590d06 HS |
395 | |
396 | lbs_deb_leave(LBS_DEB_CS); | |
397 | } | |
398 | ||
27590d06 HS |
399 | /* |
400 | * Get the command result out of the card. | |
401 | */ | |
69f9032d | 402 | static int if_cs_receive_cmdres(struct lbs_private *priv, u8 *data, u32 *len) |
27590d06 | 403 | { |
7919b89c | 404 | unsigned long flags; |
27590d06 | 405 | int ret = -1; |
78cf0747 | 406 | u16 status; |
27590d06 HS |
407 | |
408 | lbs_deb_enter(LBS_DEB_CS); | |
409 | ||
410 | /* is hardware ready? */ | |
78cf0747 HS |
411 | status = if_cs_read16(priv->card, IF_CS_CARD_STATUS); |
412 | if ((status & IF_CS_BIT_RESP) == 0) { | |
413 | lbs_pr_err("no cmd response in card\n"); | |
414 | *len = 0; | |
27590d06 HS |
415 | goto out; |
416 | } | |
417 | ||
a78a8325 | 418 | *len = if_cs_read16(priv->card, IF_CS_RESP_LEN); |
ddac4526 | 419 | if ((*len == 0) || (*len > LBS_CMD_BUFFER_SIZE)) { |
27590d06 HS |
420 | lbs_pr_err("card cmd buffer has invalid # of bytes (%d)\n", *len); |
421 | goto out; | |
422 | } | |
423 | ||
424 | /* read even number of bytes, then odd byte if necessary */ | |
a78a8325 | 425 | if_cs_read16_rep(priv->card, IF_CS_RESP, data, *len/sizeof(u16)); |
27590d06 | 426 | if (*len & 1) |
a78a8325 | 427 | data[*len-1] = if_cs_read8(priv->card, IF_CS_RESP); |
27590d06 | 428 | |
09d4fad6 HS |
429 | /* This is a workaround for a firmware that reports too much |
430 | * bytes */ | |
431 | *len -= 8; | |
27590d06 | 432 | ret = 0; |
7919b89c HS |
433 | |
434 | /* Clear this flag again */ | |
435 | spin_lock_irqsave(&priv->driver_lock, flags); | |
436 | priv->dnld_sent = DNLD_RES_RECEIVED; | |
437 | spin_unlock_irqrestore(&priv->driver_lock, flags); | |
438 | ||
27590d06 HS |
439 | out: |
440 | lbs_deb_leave_args(LBS_DEB_CS, "ret %d, len %d", ret, *len); | |
441 | return ret; | |
442 | } | |
443 | ||
69f9032d | 444 | static struct sk_buff *if_cs_receive_data(struct lbs_private *priv) |
27590d06 HS |
445 | { |
446 | struct sk_buff *skb = NULL; | |
447 | u16 len; | |
448 | u8 *data; | |
449 | ||
450 | lbs_deb_enter(LBS_DEB_CS); | |
451 | ||
78cf0747 | 452 | len = if_cs_read16(priv->card, IF_CS_READ_LEN); |
27590d06 HS |
453 | if (len == 0 || len > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) { |
454 | lbs_pr_err("card data buffer has invalid # of bytes (%d)\n", len); | |
bbfc6b78 | 455 | priv->dev->stats.rx_dropped++; |
27590d06 HS |
456 | goto dat_err; |
457 | } | |
458 | ||
f31ce76b | 459 | skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + 2); |
27590d06 HS |
460 | if (!skb) |
461 | goto out; | |
f31ce76b VD |
462 | skb_put(skb, len); |
463 | skb_reserve(skb, 2);/* 16 byte align */ | |
464 | data = skb->data; | |
27590d06 HS |
465 | |
466 | /* read even number of bytes, then odd byte if necessary */ | |
78cf0747 | 467 | if_cs_read16_rep(priv->card, IF_CS_READ, data, len/sizeof(u16)); |
27590d06 | 468 | if (len & 1) |
78cf0747 | 469 | data[len-1] = if_cs_read8(priv->card, IF_CS_READ); |
27590d06 HS |
470 | |
471 | dat_err: | |
78cf0747 HS |
472 | if_cs_write16(priv->card, IF_CS_HOST_STATUS, IF_CS_BIT_RX); |
473 | if_cs_write16(priv->card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_RX); | |
27590d06 HS |
474 | |
475 | out: | |
476 | lbs_deb_leave_args(LBS_DEB_CS, "ret %p", skb); | |
477 | return skb; | |
478 | } | |
479 | ||
7919b89c HS |
480 | static irqreturn_t if_cs_interrupt(int irq, void *data) |
481 | { | |
482 | struct if_cs_card *card = data; | |
483 | struct lbs_private *priv = card->priv; | |
484 | u16 cause; | |
485 | ||
486 | lbs_deb_enter(LBS_DEB_CS); | |
487 | ||
43d01c56 | 488 | /* Ask card interrupt cause register if there is something for us */ |
78cf0747 | 489 | cause = if_cs_read16(card, IF_CS_CARD_INT_CAUSE); |
30735561 HS |
490 | lbs_deb_cs("cause 0x%04x\n", cause); |
491 | ||
7919b89c HS |
492 | if (cause == 0) { |
493 | /* Not for us */ | |
494 | return IRQ_NONE; | |
495 | } | |
496 | ||
497 | if (cause == 0xffff) { | |
498 | /* Read in junk, the card has probably been removed */ | |
499 | card->priv->surpriseremoved = 1; | |
500 | return IRQ_HANDLED; | |
501 | } | |
502 | ||
78cf0747 | 503 | if (cause & IF_CS_BIT_RX) { |
7919b89c HS |
504 | struct sk_buff *skb; |
505 | lbs_deb_cs("rx packet\n"); | |
506 | skb = if_cs_receive_data(priv); | |
507 | if (skb) | |
508 | lbs_process_rxed_packet(priv, skb); | |
509 | } | |
510 | ||
78cf0747 | 511 | if (cause & IF_CS_BIT_TX) { |
43d01c56 | 512 | lbs_deb_cs("tx done\n"); |
7919b89c HS |
513 | lbs_host_to_card_done(priv); |
514 | } | |
515 | ||
78cf0747 | 516 | if (cause & IF_CS_BIT_RESP) { |
7919b89c HS |
517 | unsigned long flags; |
518 | u8 i; | |
519 | ||
43d01c56 | 520 | lbs_deb_cs("cmd resp\n"); |
7919b89c HS |
521 | spin_lock_irqsave(&priv->driver_lock, flags); |
522 | i = (priv->resp_idx == 0) ? 1 : 0; | |
523 | spin_unlock_irqrestore(&priv->driver_lock, flags); | |
524 | ||
525 | BUG_ON(priv->resp_len[i]); | |
526 | if_cs_receive_cmdres(priv, priv->resp_buf[i], | |
527 | &priv->resp_len[i]); | |
528 | ||
529 | spin_lock_irqsave(&priv->driver_lock, flags); | |
530 | lbs_notify_command_response(priv, i); | |
531 | spin_unlock_irqrestore(&priv->driver_lock, flags); | |
532 | } | |
533 | ||
78cf0747 | 534 | if (cause & IF_CS_BIT_EVENT) { |
a78a8325 | 535 | u16 status = if_cs_read16(priv->card, IF_CS_CARD_STATUS); |
78cf0747 HS |
536 | if_cs_write16(priv->card, IF_CS_HOST_INT_CAUSE, |
537 | IF_CS_BIT_EVENT); | |
a78a8325 | 538 | lbs_queue_event(priv, (status & IF_CS_CARD_STATUS_MASK) >> 8); |
7919b89c HS |
539 | } |
540 | ||
30735561 HS |
541 | /* Clear interrupt cause */ |
542 | if_cs_write16(card, IF_CS_CARD_INT_CAUSE, cause & IF_CS_BIT_MASK); | |
543 | ||
43d01c56 | 544 | lbs_deb_leave(LBS_DEB_CS); |
7919b89c HS |
545 | return IRQ_HANDLED; |
546 | } | |
547 | ||
548 | ||
549 | ||
550 | ||
27590d06 HS |
551 | /********************************************************************/ |
552 | /* Firmware */ | |
553 | /********************************************************************/ | |
554 | ||
555 | /* | |
556 | * Tries to program the helper firmware. | |
557 | * | |
558 | * Return 0 on success | |
559 | */ | |
560 | static int if_cs_prog_helper(struct if_cs_card *card) | |
561 | { | |
562 | int ret = 0; | |
563 | int sent = 0; | |
564 | u8 scratch; | |
565 | const struct firmware *fw; | |
566 | ||
567 | lbs_deb_enter(LBS_DEB_CS); | |
568 | ||
9d45368a MV |
569 | /* |
570 | * This is the only place where an unaligned register access happens on | |
571 | * the CF8305 card, therefore for the sake of speed of the driver, we do | |
572 | * the alignment correction here. | |
573 | */ | |
574 | if (card->align_regs) | |
575 | scratch = if_cs_read16(card, IF_CS_SCRATCH) >> 8; | |
576 | else | |
577 | scratch = if_cs_read8(card, IF_CS_SCRATCH); | |
27590d06 HS |
578 | |
579 | /* "If the value is 0x5a, the firmware is already | |
580 | * downloaded successfully" | |
581 | */ | |
53143256 | 582 | if (scratch == IF_CS_SCRATCH_HELPER_OK) |
27590d06 HS |
583 | goto done; |
584 | ||
585 | /* "If the value is != 00, it is invalid value of register */ | |
53143256 | 586 | if (scratch != IF_CS_SCRATCH_BOOT_OK) { |
27590d06 HS |
587 | ret = -ENODEV; |
588 | goto done; | |
589 | } | |
590 | ||
591 | /* TODO: make firmware file configurable */ | |
592 | ret = request_firmware(&fw, "libertas_cs_helper.fw", | |
593 | &handle_to_dev(card->p_dev)); | |
594 | if (ret) { | |
595 | lbs_pr_err("can't load helper firmware\n"); | |
596 | ret = -ENODEV; | |
597 | goto done; | |
598 | } | |
4ecd41bd | 599 | lbs_deb_cs("helper size %td\n", fw->size); |
27590d06 HS |
600 | |
601 | /* "Set the 5 bytes of the helper image to 0" */ | |
602 | /* Not needed, this contains an ARM branch instruction */ | |
603 | ||
604 | for (;;) { | |
605 | /* "the number of bytes to send is 256" */ | |
606 | int count = 256; | |
607 | int remain = fw->size - sent; | |
608 | ||
609 | if (remain < count) | |
610 | count = remain; | |
27590d06 HS |
611 | |
612 | /* "write the number of bytes to be sent to the I/O Command | |
613 | * write length register" */ | |
a78a8325 | 614 | if_cs_write16(card, IF_CS_CMD_LEN, count); |
27590d06 HS |
615 | |
616 | /* "write this to I/O Command port register as 16 bit writes */ | |
617 | if (count) | |
a78a8325 | 618 | if_cs_write16_rep(card, IF_CS_CMD, |
27590d06 HS |
619 | &fw->data[sent], |
620 | count >> 1); | |
621 | ||
622 | /* "Assert the download over interrupt command in the Host | |
623 | * status register" */ | |
78cf0747 | 624 | if_cs_write8(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND); |
27590d06 HS |
625 | |
626 | /* "Assert the download over interrupt command in the Card | |
627 | * interrupt case register" */ | |
78cf0747 | 628 | if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND); |
27590d06 HS |
629 | |
630 | /* "The host polls the Card Status register ... for 50 ms before | |
631 | declaring a failure */ | |
78cf0747 HS |
632 | ret = if_cs_poll_while_fw_download(card, IF_CS_CARD_STATUS, |
633 | IF_CS_BIT_COMMAND); | |
27590d06 HS |
634 | if (ret < 0) { |
635 | lbs_pr_err("can't download helper at 0x%x, ret %d\n", | |
636 | sent, ret); | |
9a52028e | 637 | goto err_release; |
27590d06 HS |
638 | } |
639 | ||
640 | if (count == 0) | |
641 | break; | |
642 | ||
643 | sent += count; | |
644 | } | |
645 | ||
9a52028e | 646 | err_release: |
27590d06 | 647 | release_firmware(fw); |
27590d06 HS |
648 | done: |
649 | lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret); | |
650 | return ret; | |
651 | } | |
652 | ||
653 | ||
654 | static int if_cs_prog_real(struct if_cs_card *card) | |
655 | { | |
656 | const struct firmware *fw; | |
657 | int ret = 0; | |
658 | int retry = 0; | |
659 | int len = 0; | |
660 | int sent; | |
661 | ||
662 | lbs_deb_enter(LBS_DEB_CS); | |
663 | ||
664 | /* TODO: make firmware file configurable */ | |
665 | ret = request_firmware(&fw, "libertas_cs.fw", | |
666 | &handle_to_dev(card->p_dev)); | |
667 | if (ret) { | |
668 | lbs_pr_err("can't load firmware\n"); | |
669 | ret = -ENODEV; | |
670 | goto done; | |
671 | } | |
4ecd41bd | 672 | lbs_deb_cs("fw size %td\n", fw->size); |
27590d06 | 673 | |
a78a8325 HS |
674 | ret = if_cs_poll_while_fw_download(card, IF_CS_SQ_READ_LOW, |
675 | IF_CS_SQ_HELPER_OK); | |
27590d06 | 676 | if (ret < 0) { |
27590d06 | 677 | lbs_pr_err("helper firmware doesn't answer\n"); |
27590d06 HS |
678 | goto err_release; |
679 | } | |
680 | ||
681 | for (sent = 0; sent < fw->size; sent += len) { | |
a78a8325 | 682 | len = if_cs_read16(card, IF_CS_SQ_READ_LOW); |
27590d06 HS |
683 | if (len & 1) { |
684 | retry++; | |
685 | lbs_pr_info("odd, need to retry this firmware block\n"); | |
686 | } else { | |
687 | retry = 0; | |
688 | } | |
689 | ||
690 | if (retry > 20) { | |
691 | lbs_pr_err("could not download firmware\n"); | |
692 | ret = -ENODEV; | |
693 | goto err_release; | |
694 | } | |
695 | if (retry) { | |
696 | sent -= len; | |
697 | } | |
698 | ||
699 | ||
a78a8325 | 700 | if_cs_write16(card, IF_CS_CMD_LEN, len); |
27590d06 | 701 | |
a78a8325 | 702 | if_cs_write16_rep(card, IF_CS_CMD, |
27590d06 HS |
703 | &fw->data[sent], |
704 | (len+1) >> 1); | |
78cf0747 HS |
705 | if_cs_write8(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND); |
706 | if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND); | |
27590d06 | 707 | |
78cf0747 HS |
708 | ret = if_cs_poll_while_fw_download(card, IF_CS_CARD_STATUS, |
709 | IF_CS_BIT_COMMAND); | |
27590d06 HS |
710 | if (ret < 0) { |
711 | lbs_pr_err("can't download firmware at 0x%x\n", sent); | |
712 | goto err_release; | |
713 | } | |
714 | } | |
715 | ||
716 | ret = if_cs_poll_while_fw_download(card, IF_CS_SCRATCH, 0x5a); | |
9a52028e | 717 | if (ret < 0) |
27590d06 | 718 | lbs_pr_err("firmware download failed\n"); |
27590d06 HS |
719 | |
720 | err_release: | |
721 | release_firmware(fw); | |
722 | ||
723 | done: | |
724 | lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret); | |
725 | return ret; | |
726 | } | |
727 | ||
728 | ||
729 | ||
730 | /********************************************************************/ | |
731 | /* Callback functions for libertas.ko */ | |
732 | /********************************************************************/ | |
733 | ||
27590d06 | 734 | /* Send commands or data packets to the card */ |
69f9032d HS |
735 | static int if_cs_host_to_card(struct lbs_private *priv, |
736 | u8 type, | |
737 | u8 *buf, | |
738 | u16 nb) | |
27590d06 HS |
739 | { |
740 | int ret = -1; | |
741 | ||
742 | lbs_deb_enter_args(LBS_DEB_CS, "type %d, bytes %d", type, nb); | |
743 | ||
744 | switch (type) { | |
745 | case MVMS_DAT: | |
6f05cbe5 | 746 | priv->dnld_sent = DNLD_DATA_SENT; |
27590d06 HS |
747 | if_cs_send_data(priv, buf, nb); |
748 | ret = 0; | |
749 | break; | |
750 | case MVMS_CMD: | |
6f05cbe5 | 751 | priv->dnld_sent = DNLD_CMD_SENT; |
27590d06 HS |
752 | ret = if_cs_send_cmd(priv, buf, nb); |
753 | break; | |
754 | default: | |
c94c93da | 755 | lbs_pr_err("%s: unsupported type %d\n", __func__, type); |
27590d06 HS |
756 | } |
757 | ||
758 | lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret); | |
759 | return ret; | |
760 | } | |
761 | ||
762 | ||
27590d06 HS |
763 | /********************************************************************/ |
764 | /* Card Services */ | |
765 | /********************************************************************/ | |
766 | ||
767 | /* | |
768 | * After a card is removed, if_cs_release() will unregister the | |
769 | * device, and release the PCMCIA configuration. If the device is | |
770 | * still open, this will be postponed until it is closed. | |
771 | */ | |
772 | static void if_cs_release(struct pcmcia_device *p_dev) | |
773 | { | |
774 | struct if_cs_card *card = p_dev->priv; | |
775 | ||
776 | lbs_deb_enter(LBS_DEB_CS); | |
777 | ||
27590d06 | 778 | free_irq(p_dev->irq.AssignedIRQ, card); |
fdfb92ea | 779 | pcmcia_disable_device(p_dev); |
27590d06 HS |
780 | if (card->iobase) |
781 | ioport_unmap(card->iobase); | |
782 | ||
783 | lbs_deb_leave(LBS_DEB_CS); | |
784 | } | |
785 | ||
786 | ||
787 | /* | |
788 | * This creates an "instance" of the driver, allocating local data | |
789 | * structures for one device. The device is registered with Card | |
790 | * Services. | |
791 | * | |
792 | * The dev_link structure is initialized, but we don't actually | |
793 | * configure the card at this point -- we wait until we receive a card | |
794 | * insertion event. | |
795 | */ | |
796 | static int if_cs_probe(struct pcmcia_device *p_dev) | |
797 | { | |
798 | int ret = -ENOMEM; | |
dc7d243d | 799 | unsigned int prod_id; |
69f9032d | 800 | struct lbs_private *priv; |
27590d06 HS |
801 | struct if_cs_card *card; |
802 | /* CIS parsing */ | |
803 | tuple_t tuple; | |
804 | cisparse_t parse; | |
805 | cistpl_cftable_entry_t *cfg = &parse.cftable_entry; | |
806 | cistpl_io_t *io = &cfg->io; | |
807 | u_char buf[64]; | |
808 | ||
809 | lbs_deb_enter(LBS_DEB_CS); | |
810 | ||
811 | card = kzalloc(sizeof(struct if_cs_card), GFP_KERNEL); | |
812 | if (!card) { | |
813 | lbs_pr_err("error in kzalloc\n"); | |
814 | goto out; | |
815 | } | |
816 | card->p_dev = p_dev; | |
817 | p_dev->priv = card; | |
818 | ||
819 | p_dev->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING; | |
820 | p_dev->irq.Handler = NULL; | |
821 | p_dev->irq.IRQInfo1 = IRQ_INFO2_VALID | IRQ_LEVEL_ID; | |
822 | ||
823 | p_dev->conf.Attributes = 0; | |
824 | p_dev->conf.IntType = INT_MEMORY_AND_IO; | |
825 | ||
826 | tuple.Attributes = 0; | |
827 | tuple.TupleData = buf; | |
828 | tuple.TupleDataMax = sizeof(buf); | |
829 | tuple.TupleOffset = 0; | |
830 | ||
831 | tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY; | |
832 | if ((ret = pcmcia_get_first_tuple(p_dev, &tuple)) != 0 || | |
833 | (ret = pcmcia_get_tuple_data(p_dev, &tuple)) != 0 || | |
2f3061eb | 834 | (ret = pcmcia_parse_tuple(&tuple, &parse)) != 0) |
27590d06 HS |
835 | { |
836 | lbs_pr_err("error in pcmcia_get_first_tuple etc\n"); | |
837 | goto out1; | |
838 | } | |
839 | ||
840 | p_dev->conf.ConfigIndex = cfg->index; | |
841 | ||
842 | /* Do we need to allocate an interrupt? */ | |
843 | if (cfg->irq.IRQInfo1) { | |
844 | p_dev->conf.Attributes |= CONF_ENABLE_IRQ; | |
845 | } | |
846 | ||
847 | /* IO window settings */ | |
848 | if (cfg->io.nwin != 1) { | |
849 | lbs_pr_err("wrong CIS (check number of IO windows)\n"); | |
850 | ret = -ENODEV; | |
851 | goto out1; | |
852 | } | |
853 | p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO; | |
854 | p_dev->io.BasePort1 = io->win[0].base; | |
855 | p_dev->io.NumPorts1 = io->win[0].len; | |
856 | ||
857 | /* This reserves IO space but doesn't actually enable it */ | |
858 | ret = pcmcia_request_io(p_dev, &p_dev->io); | |
859 | if (ret) { | |
860 | lbs_pr_err("error in pcmcia_request_io\n"); | |
861 | goto out1; | |
862 | } | |
863 | ||
864 | /* | |
865 | * Allocate an interrupt line. Note that this does not assign | |
866 | * a handler to the interrupt, unless the 'Handler' member of | |
867 | * the irq structure is initialized. | |
868 | */ | |
869 | if (p_dev->conf.Attributes & CONF_ENABLE_IRQ) { | |
870 | ret = pcmcia_request_irq(p_dev, &p_dev->irq); | |
871 | if (ret) { | |
872 | lbs_pr_err("error in pcmcia_request_irq\n"); | |
873 | goto out1; | |
874 | } | |
875 | } | |
876 | ||
877 | /* Initialize io access */ | |
878 | card->iobase = ioport_map(p_dev->io.BasePort1, p_dev->io.NumPorts1); | |
879 | if (!card->iobase) { | |
880 | lbs_pr_err("error in ioport_map\n"); | |
881 | ret = -EIO; | |
882 | goto out1; | |
883 | } | |
884 | ||
885 | /* | |
886 | * This actually configures the PCMCIA socket -- setting up | |
887 | * the I/O windows and the interrupt mapping, and putting the | |
888 | * card and host interface into "Memory and IO" mode. | |
889 | */ | |
890 | ret = pcmcia_request_configuration(p_dev, &p_dev->conf); | |
891 | if (ret) { | |
892 | lbs_pr_err("error in pcmcia_request_configuration\n"); | |
893 | goto out2; | |
894 | } | |
895 | ||
896 | /* Finally, report what we've done */ | |
897 | lbs_deb_cs("irq %d, io 0x%04x-0x%04x\n", | |
898 | p_dev->irq.AssignedIRQ, p_dev->io.BasePort1, | |
899 | p_dev->io.BasePort1 + p_dev->io.NumPorts1 - 1); | |
900 | ||
9d45368a MV |
901 | /* |
902 | * Most of the libertas cards can do unaligned register access, but some | |
903 | * weird ones can not. That's especially true for the CF8305 card. | |
904 | */ | |
905 | card->align_regs = 0; | |
906 | ||
4c55523e | 907 | /* Check if we have a current silicon */ |
dc7d243d | 908 | prod_id = if_cs_read8(card, IF_CS_PRODUCT_ID); |
9d45368a MV |
909 | if (if_cs_hw_is_cf8305(p_dev)) { |
910 | card->align_regs = 1; | |
911 | if (prod_id < IF_CS_CF8305_B1_REV) { | |
912 | lbs_pr_err("old chips like 8305 rev B3 " | |
913 | "aren't supported\n"); | |
914 | ret = -ENODEV; | |
915 | goto out2; | |
916 | } | |
917 | } | |
918 | ||
dc7d243d MV |
919 | if (if_cs_hw_is_cf8381(p_dev) && prod_id < IF_CS_CF8381_B3_REV) { |
920 | lbs_pr_err("old chips like 8381 rev B3 aren't supported\n"); | |
921 | ret = -ENODEV; | |
922 | goto out2; | |
923 | } | |
924 | ||
925 | if (if_cs_hw_is_cf8385(p_dev) && prod_id < IF_CS_CF8385_B1_REV) { | |
4c55523e HS |
926 | lbs_pr_err("old chips like 8385 rev B1 aren't supported\n"); |
927 | ret = -ENODEV; | |
928 | goto out2; | |
929 | } | |
27590d06 HS |
930 | |
931 | /* Load the firmware early, before calling into libertas.ko */ | |
932 | ret = if_cs_prog_helper(card); | |
9d45368a | 933 | if (ret == 0 && !if_cs_hw_is_cf8305(p_dev)) |
27590d06 HS |
934 | ret = if_cs_prog_real(card); |
935 | if (ret) | |
936 | goto out2; | |
937 | ||
938 | /* Make this card known to the libertas driver */ | |
10078321 | 939 | priv = lbs_add_card(card, &p_dev->dev); |
27590d06 HS |
940 | if (!priv) { |
941 | ret = -ENOMEM; | |
942 | goto out2; | |
943 | } | |
944 | ||
7919b89c | 945 | /* Finish setting up fields in lbs_private */ |
954ee164 | 946 | card->priv = priv; |
27590d06 | 947 | priv->card = card; |
7919b89c | 948 | priv->hw_host_to_card = if_cs_host_to_card; |
aa21c004 | 949 | priv->fw_ready = 1; |
954ee164 | 950 | |
27590d06 HS |
951 | /* Now actually get the IRQ */ |
952 | ret = request_irq(p_dev->irq.AssignedIRQ, if_cs_interrupt, | |
953 | IRQF_SHARED, DRV_NAME, card); | |
954 | if (ret) { | |
955 | lbs_pr_err("error in request_irq\n"); | |
956 | goto out3; | |
957 | } | |
958 | ||
4ef31702 HS |
959 | /* Clear any interrupt cause that happend while sending |
960 | * firmware/initializing card */ | |
78cf0747 | 961 | if_cs_write16(card, IF_CS_CARD_INT_CAUSE, IF_CS_BIT_MASK); |
28de0b36 RM |
962 | if_cs_enable_ints(card); |
963 | ||
27590d06 | 964 | /* And finally bring the card up */ |
10078321 | 965 | if (lbs_start_card(priv) != 0) { |
27590d06 HS |
966 | lbs_pr_err("could not activate card\n"); |
967 | goto out3; | |
968 | } | |
969 | ||
970 | ret = 0; | |
971 | goto out; | |
972 | ||
973 | out3: | |
10078321 | 974 | lbs_remove_card(priv); |
27590d06 HS |
975 | out2: |
976 | ioport_unmap(card->iobase); | |
977 | out1: | |
978 | pcmcia_disable_device(p_dev); | |
979 | out: | |
980 | lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret); | |
981 | return ret; | |
982 | } | |
983 | ||
984 | ||
985 | /* | |
986 | * This deletes a driver "instance". The device is de-registered with | |
987 | * Card Services. If it has been released, all local data structures | |
988 | * are freed. Otherwise, the structures will be freed when the device | |
989 | * is released. | |
990 | */ | |
991 | static void if_cs_detach(struct pcmcia_device *p_dev) | |
992 | { | |
993 | struct if_cs_card *card = p_dev->priv; | |
994 | ||
995 | lbs_deb_enter(LBS_DEB_CS); | |
996 | ||
10078321 HS |
997 | lbs_stop_card(card->priv); |
998 | lbs_remove_card(card->priv); | |
28de0b36 | 999 | if_cs_disable_ints(card); |
27590d06 HS |
1000 | if_cs_release(p_dev); |
1001 | kfree(card); | |
1002 | ||
1003 | lbs_deb_leave(LBS_DEB_CS); | |
1004 | } | |
1005 | ||
1006 | ||
1007 | ||
1008 | /********************************************************************/ | |
1009 | /* Module initialization */ | |
1010 | /********************************************************************/ | |
1011 | ||
1012 | static struct pcmcia_device_id if_cs_ids[] = { | |
9d45368a | 1013 | PCMCIA_DEVICE_MANF_CARD(CF8305_MANFID, CF8305_CARDID), |
dc7d243d MV |
1014 | PCMCIA_DEVICE_MANF_CARD(CF8381_MANFID, CF8381_CARDID), |
1015 | PCMCIA_DEVICE_MANF_CARD(CF8385_MANFID, CF8385_CARDID), | |
27590d06 HS |
1016 | PCMCIA_DEVICE_NULL, |
1017 | }; | |
1018 | MODULE_DEVICE_TABLE(pcmcia, if_cs_ids); | |
1019 | ||
1020 | ||
10078321 | 1021 | static struct pcmcia_driver lbs_driver = { |
27590d06 HS |
1022 | .owner = THIS_MODULE, |
1023 | .drv = { | |
1024 | .name = DRV_NAME, | |
1025 | }, | |
1026 | .probe = if_cs_probe, | |
1027 | .remove = if_cs_detach, | |
1028 | .id_table = if_cs_ids, | |
1029 | }; | |
1030 | ||
1031 | ||
1032 | static int __init if_cs_init(void) | |
1033 | { | |
1034 | int ret; | |
1035 | ||
1036 | lbs_deb_enter(LBS_DEB_CS); | |
10078321 | 1037 | ret = pcmcia_register_driver(&lbs_driver); |
27590d06 HS |
1038 | lbs_deb_leave(LBS_DEB_CS); |
1039 | return ret; | |
1040 | } | |
1041 | ||
1042 | ||
1043 | static void __exit if_cs_exit(void) | |
1044 | { | |
1045 | lbs_deb_enter(LBS_DEB_CS); | |
10078321 | 1046 | pcmcia_unregister_driver(&lbs_driver); |
27590d06 HS |
1047 | lbs_deb_leave(LBS_DEB_CS); |
1048 | } | |
1049 | ||
1050 | ||
1051 | module_init(if_cs_init); | |
1052 | module_exit(if_cs_exit); |