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