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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25 
26 #include <linux/module.h>
27 #include <linux/slab.h>
28 #include <linux/delay.h>
29 #include <linux/moduleparam.h>
30 #include <linux/firmware.h>
31 #include <linux/netdevice.h>
32 
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;
61 	struct lbs_private *priv;
62 	void __iomem *iobase;
63 	bool align_regs;
64 	u32 model;
65 };
66 
67 
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 
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)
113 		printk(KERN_INFO "inb %08x<%02x\n", reg, val);
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)
120 		printk(KERN_INFO "inw %08x<%04x\n", reg, val);
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)
130 		printk(KERN_INFO "insw %08x<(0x%lx words)\n",
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)
138 		printk(KERN_INFO "outb %08x>%02x\n", reg, val);
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)
145 		printk(KERN_INFO "outw %08x>%04x\n", reg, val);
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,
152 	const void *buf,
153 	unsigned long count)
154 {
155 	if (debug_output)
156 		printk(KERN_INFO "outsw %08x>(0x%lx words)\n",
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 
178 	for (i = 0; i < 100000; i++) {
179 		u8 val = if_cs_read8(card, addr);
180 		if (val == reg)
181 			return 0;
182 		udelay(5);
183 	}
184 	return -ETIME;
185 }
186 
187 
188 
189 /*
190  * First the bitmasks for the host/card interrupt/status registers:
191  */
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
198 
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  */
212 #define IF_CS_HOST_STATUS		0x00000000
213 
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  */
224 #define IF_CS_HOST_INT_CAUSE		0x00000002
225 
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  */
230 #define IF_CS_HOST_INT_MASK		0x00000004
231 
232 /*
233  * Used to send or receive data packets:
234  */
235 #define IF_CS_WRITE			0x00000016
236 #define IF_CS_WRITE_LEN			0x00000014
237 #define IF_CS_READ			0x00000010
238 #define IF_CS_READ_LEN			0x00000024
239 
240 /*
241  * Used to send commands (and to send firmware block) and to
242  * receive command responses:
243  */
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
248 
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  */
266 #define IF_CS_CARD_STATUS		0x00000020
267 #define IF_CS_CARD_STATUS_MASK		0x7f00
268 
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  */
279 #define IF_CS_CARD_INT_CAUSE		0x00000022
280 
281 /*
282  * This is used to for handshaking with the card's bootloader/helper image
283  * to synchronize downloading of firmware blocks.
284  */
285 #define IF_CS_SQ_READ_LOW		0x00000028
286 #define IF_CS_SQ_HELPER_OK		0x10
287 
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  */
294 #define IF_CS_SCRATCH			0x0000003F
295 #define IF_CS_SCRATCH_BOOT_OK		0x00
296 #define IF_CS_SCRATCH_HELPER_OK		0x5a
297 
298 /*
299  * Used to detect ancient chips:
300  */
301 #define IF_CS_PRODUCT_ID		0x0000001C
302 #define IF_CS_CF8385_B1_REV		0x12
303 #define IF_CS_CF8381_B3_REV		0x04
304 #define IF_CS_CF8305_B1_REV		0x03
305 
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  */
310 #define CF8305_MANFID		0x02db
311 #define CF8305_CARDID		0x8103
312 #define CF8381_MANFID		0x02db
313 #define CF8381_CARDID		0x6064
314 #define CF8385_MANFID		0x02df
315 #define CF8385_CARDID		0x8103
316 
317 /*
318  * FIXME: just use the 'driver_info' field of 'struct pcmcia_device_id' when
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)
322 {
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;
331 }
332 
333 /********************************************************************/
334 /* I/O and interrupt handling                                       */
335 /********************************************************************/
336 
337 static inline void if_cs_enable_ints(struct if_cs_card *card)
338 {
339 	if_cs_write16(card, IF_CS_HOST_INT_MASK, 0);
340 }
341 
342 static inline void if_cs_disable_ints(struct if_cs_card *card)
343 {
344 	if_cs_write16(card, IF_CS_HOST_INT_MASK, IF_CS_BIT_MASK);
345 }
346 
347 /*
348  * Called from if_cs_host_to_card to send a command to the hardware
349  */
350 static int if_cs_send_cmd(struct lbs_private *priv, u8 *buf, u16 nb)
351 {
352 	struct if_cs_card *card = (struct if_cs_card *)priv->card;
353 	int ret = -1;
354 	int loops = 0;
355 
356 	if_cs_disable_ints(card);
357 
358 	/* Is hardware ready? */
359 	while (1) {
360 		u16 status = if_cs_read16(card, IF_CS_CARD_STATUS);
361 		if (status & IF_CS_BIT_COMMAND)
362 			break;
363 		if (++loops > 100) {
364 			netdev_err(priv->dev, "card not ready for commands\n");
365 			goto done;
366 		}
367 		mdelay(1);
368 	}
369 
370 	if_cs_write16(card, IF_CS_CMD_LEN, nb);
371 
372 	if_cs_write16_rep(card, IF_CS_CMD, buf, nb / 2);
373 	/* Are we supposed to transfer an odd amount of bytes? */
374 	if (nb & 1)
375 		if_cs_write8(card, IF_CS_CMD, buf[nb-1]);
376 
377 	/* "Assert the download over interrupt command in the Host
378 	 * status register" */
379 	if_cs_write16(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND);
380 
381 	/* "Assert the download over interrupt command in the Card
382 	 * interrupt case register" */
383 	if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND);
384 	ret = 0;
385 
386 done:
387 	if_cs_enable_ints(card);
388 	return ret;
389 }
390 
391 /*
392  * Called from if_cs_host_to_card to send a data to the hardware
393  */
394 static void if_cs_send_data(struct lbs_private *priv, u8 *buf, u16 nb)
395 {
396 	struct if_cs_card *card = (struct if_cs_card *)priv->card;
397 	u16 status;
398 
399 	if_cs_disable_ints(card);
400 
401 	status = if_cs_read16(card, IF_CS_CARD_STATUS);
402 	BUG_ON((status & IF_CS_BIT_TX) == 0);
403 
404 	if_cs_write16(card, IF_CS_WRITE_LEN, nb);
405 
406 	/* write even number of bytes, then odd byte if necessary */
407 	if_cs_write16_rep(card, IF_CS_WRITE, buf, nb / 2);
408 	if (nb & 1)
409 		if_cs_write8(card, IF_CS_WRITE, buf[nb-1]);
410 
411 	if_cs_write16(card, IF_CS_HOST_STATUS, IF_CS_BIT_TX);
412 	if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_TX);
413 	if_cs_enable_ints(card);
414 }
415 
416 /*
417  * Get the command result out of the card.
418  */
419 static int if_cs_receive_cmdres(struct lbs_private *priv, u8 *data, u32 *len)
420 {
421 	unsigned long flags;
422 	int ret = -1;
423 	u16 status;
424 
425 	/* is hardware ready? */
426 	status = if_cs_read16(priv->card, IF_CS_CARD_STATUS);
427 	if ((status & IF_CS_BIT_RESP) == 0) {
428 		netdev_err(priv->dev, "no cmd response in card\n");
429 		*len = 0;
430 		goto out;
431 	}
432 
433 	*len = if_cs_read16(priv->card, IF_CS_RESP_LEN);
434 	if ((*len == 0) || (*len > LBS_CMD_BUFFER_SIZE)) {
435 		netdev_err(priv->dev,
436 			   "card cmd buffer has invalid # of bytes (%d)\n",
437 			   *len);
438 		goto out;
439 	}
440 
441 	/* read even number of bytes, then odd byte if necessary */
442 	if_cs_read16_rep(priv->card, IF_CS_RESP, data, *len/sizeof(u16));
443 	if (*len & 1)
444 		data[*len-1] = if_cs_read8(priv->card, IF_CS_RESP);
445 
446 	/* This is a workaround for a firmware that reports too much
447 	 * bytes */
448 	*len -= 8;
449 	ret = 0;
450 
451 	/* Clear this flag again */
452 	spin_lock_irqsave(&priv->driver_lock, flags);
453 	priv->dnld_sent = DNLD_RES_RECEIVED;
454 	spin_unlock_irqrestore(&priv->driver_lock, flags);
455 
456 out:
457 	return ret;
458 }
459 
460 static struct sk_buff *if_cs_receive_data(struct lbs_private *priv)
461 {
462 	struct sk_buff *skb = NULL;
463 	u16 len;
464 	u8 *data;
465 
466 	len = if_cs_read16(priv->card, IF_CS_READ_LEN);
467 	if (len == 0 || len > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {
468 		netdev_err(priv->dev,
469 			   "card data buffer has invalid # of bytes (%d)\n",
470 			   len);
471 		priv->dev->stats.rx_dropped++;
472 		goto dat_err;
473 	}
474 
475 	skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + 2);
476 	if (!skb)
477 		goto out;
478 	skb_put(skb, len);
479 	skb_reserve(skb, 2);/* 16 byte align */
480 	data = skb->data;
481 
482 	/* read even number of bytes, then odd byte if necessary */
483 	if_cs_read16_rep(priv->card, IF_CS_READ, data, len/sizeof(u16));
484 	if (len & 1)
485 		data[len-1] = if_cs_read8(priv->card, IF_CS_READ);
486 
487 dat_err:
488 	if_cs_write16(priv->card, IF_CS_HOST_STATUS, IF_CS_BIT_RX);
489 	if_cs_write16(priv->card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_RX);
490 
491 out:
492 	return skb;
493 }
494 
495 static irqreturn_t if_cs_interrupt(int irq, void *data)
496 {
497 	struct if_cs_card *card = data;
498 	struct lbs_private *priv = card->priv;
499 	u16 cause;
500 
501 	/* Ask card interrupt cause register if there is something for us */
502 	cause = if_cs_read16(card, IF_CS_CARD_INT_CAUSE);
503 	lbs_deb_cs("cause 0x%04x\n", cause);
504 
505 	if (cause == 0) {
506 		/* Not for us */
507 		return IRQ_NONE;
508 	}
509 
510 	if (cause == 0xffff) {
511 		/* Read in junk, the card has probably been removed */
512 		card->priv->surpriseremoved = 1;
513 		return IRQ_HANDLED;
514 	}
515 
516 	if (cause & IF_CS_BIT_RX) {
517 		struct sk_buff *skb;
518 		lbs_deb_cs("rx packet\n");
519 		skb = if_cs_receive_data(priv);
520 		if (skb)
521 			lbs_process_rxed_packet(priv, skb);
522 	}
523 
524 	if (cause & IF_CS_BIT_TX) {
525 		lbs_deb_cs("tx done\n");
526 		lbs_host_to_card_done(priv);
527 	}
528 
529 	if (cause & IF_CS_BIT_RESP) {
530 		unsigned long flags;
531 		u8 i;
532 
533 		lbs_deb_cs("cmd resp\n");
534 		spin_lock_irqsave(&priv->driver_lock, flags);
535 		i = (priv->resp_idx == 0) ? 1 : 0;
536 		spin_unlock_irqrestore(&priv->driver_lock, flags);
537 
538 		BUG_ON(priv->resp_len[i]);
539 		if_cs_receive_cmdres(priv, priv->resp_buf[i],
540 			&priv->resp_len[i]);
541 
542 		spin_lock_irqsave(&priv->driver_lock, flags);
543 		lbs_notify_command_response(priv, i);
544 		spin_unlock_irqrestore(&priv->driver_lock, flags);
545 	}
546 
547 	if (cause & IF_CS_BIT_EVENT) {
548 		u16 status = if_cs_read16(priv->card, IF_CS_CARD_STATUS);
549 		if_cs_write16(priv->card, IF_CS_HOST_INT_CAUSE,
550 			IF_CS_BIT_EVENT);
551 		lbs_queue_event(priv, (status & IF_CS_CARD_STATUS_MASK) >> 8);
552 	}
553 
554 	/* Clear interrupt cause */
555 	if_cs_write16(card, IF_CS_CARD_INT_CAUSE, cause & IF_CS_BIT_MASK);
556 
557 	return IRQ_HANDLED;
558 }
559 
560 
561 
562 
563 /********************************************************************/
564 /* Firmware                                                         */
565 /********************************************************************/
566 
567 /*
568  * Tries to program the helper firmware.
569  *
570  * Return 0 on success
571  */
572 static int if_cs_prog_helper(struct if_cs_card *card, const struct firmware *fw)
573 {
574 	int ret = 0;
575 	int sent = 0;
576 	u8  scratch;
577 
578 	/*
579 	 * This is the only place where an unaligned register access happens on
580 	 * the CF8305 card, therefore for the sake of speed of the driver, we do
581 	 * the alignment correction here.
582 	 */
583 	if (card->align_regs)
584 		scratch = if_cs_read16(card, IF_CS_SCRATCH) >> 8;
585 	else
586 		scratch = if_cs_read8(card, IF_CS_SCRATCH);
587 
588 	/* "If the value is 0x5a, the firmware is already
589 	 * downloaded successfully"
590 	 */
591 	if (scratch == IF_CS_SCRATCH_HELPER_OK)
592 		goto done;
593 
594 	/* "If the value is != 00, it is invalid value of register */
595 	if (scratch != IF_CS_SCRATCH_BOOT_OK) {
596 		ret = -ENODEV;
597 		goto done;
598 	}
599 
600 	lbs_deb_cs("helper size %td\n", fw->size);
601 
602 	/* "Set the 5 bytes of the helper image to 0" */
603 	/* Not needed, this contains an ARM branch instruction */
604 
605 	for (;;) {
606 		/* "the number of bytes to send is 256" */
607 		int count = 256;
608 		int remain = fw->size - sent;
609 
610 		if (remain < count)
611 			count = remain;
612 
613 		/*
614 		 * "write the number of bytes to be sent to the I/O Command
615 		 * write length register"
616 		 */
617 		if_cs_write16(card, IF_CS_CMD_LEN, count);
618 
619 		/* "write this to I/O Command port register as 16 bit writes */
620 		if (count)
621 			if_cs_write16_rep(card, IF_CS_CMD,
622 				&fw->data[sent],
623 				count >> 1);
624 
625 		/*
626 		 * "Assert the download over interrupt command in the Host
627 		 * status register"
628 		 */
629 		if_cs_write8(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND);
630 
631 		/*
632 		 * "Assert the download over interrupt command in the Card
633 		 * interrupt case register"
634 		 */
635 		if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND);
636 
637 		/*
638 		 * "The host polls the Card Status register ... for 50 ms before
639 		 * declaring a failure"
640 		 */
641 		ret = if_cs_poll_while_fw_download(card, IF_CS_CARD_STATUS,
642 			IF_CS_BIT_COMMAND);
643 		if (ret < 0) {
644 			pr_err("can't download helper at 0x%x, ret %d\n",
645 			       sent, ret);
646 			goto done;
647 		}
648 
649 		if (count == 0)
650 			break;
651 
652 		sent += count;
653 	}
654 
655 done:
656 	return ret;
657 }
658 
659 
660 static int if_cs_prog_real(struct if_cs_card *card, const struct firmware *fw)
661 {
662 	int ret = 0;
663 	int retry = 0;
664 	int len = 0;
665 	int sent;
666 
667 	lbs_deb_cs("fw size %td\n", fw->size);
668 
669 	ret = if_cs_poll_while_fw_download(card, IF_CS_SQ_READ_LOW,
670 		IF_CS_SQ_HELPER_OK);
671 	if (ret < 0) {
672 		pr_err("helper firmware doesn't answer\n");
673 		goto done;
674 	}
675 
676 	for (sent = 0; sent < fw->size; sent += len) {
677 		len = if_cs_read16(card, IF_CS_SQ_READ_LOW);
678 		if (len & 1) {
679 			retry++;
680 			pr_info("odd, need to retry this firmware block\n");
681 		} else {
682 			retry = 0;
683 		}
684 
685 		if (retry > 20) {
686 			pr_err("could not download firmware\n");
687 			ret = -ENODEV;
688 			goto done;
689 		}
690 		if (retry) {
691 			sent -= len;
692 		}
693 
694 
695 		if_cs_write16(card, IF_CS_CMD_LEN, len);
696 
697 		if_cs_write16_rep(card, IF_CS_CMD,
698 			&fw->data[sent],
699 			(len+1) >> 1);
700 		if_cs_write8(card, IF_CS_HOST_STATUS, IF_CS_BIT_COMMAND);
701 		if_cs_write16(card, IF_CS_HOST_INT_CAUSE, IF_CS_BIT_COMMAND);
702 
703 		ret = if_cs_poll_while_fw_download(card, IF_CS_CARD_STATUS,
704 			IF_CS_BIT_COMMAND);
705 		if (ret < 0) {
706 			pr_err("can't download firmware at 0x%x\n", sent);
707 			goto done;
708 		}
709 	}
710 
711 	ret = if_cs_poll_while_fw_download(card, IF_CS_SCRATCH, 0x5a);
712 	if (ret < 0)
713 		pr_err("firmware download failed\n");
714 
715 done:
716 	return ret;
717 }
718 
719 static void if_cs_prog_firmware(struct lbs_private *priv, int ret,
720 				 const struct firmware *helper,
721 				 const struct firmware *mainfw)
722 {
723 	struct if_cs_card *card = priv->card;
724 
725 	if (ret) {
726 		pr_err("failed to find firmware (%d)\n", ret);
727 		return;
728 	}
729 
730 	/* Load the firmware */
731 	ret = if_cs_prog_helper(card, helper);
732 	if (ret == 0 && (card->model != MODEL_8305))
733 		ret = if_cs_prog_real(card, mainfw);
734 	if (ret)
735 		return;
736 
737 	/* Now actually get the IRQ */
738 	ret = request_irq(card->p_dev->irq, if_cs_interrupt,
739 		IRQF_SHARED, DRV_NAME, card);
740 	if (ret) {
741 		pr_err("error in request_irq\n");
742 		return;
743 	}
744 
745 	/*
746 	 * Clear any interrupt cause that happened while sending
747 	 * firmware/initializing card
748 	 */
749 	if_cs_write16(card, IF_CS_CARD_INT_CAUSE, IF_CS_BIT_MASK);
750 	if_cs_enable_ints(card);
751 
752 	/* And finally bring the card up */
753 	priv->fw_ready = 1;
754 	if (lbs_start_card(priv) != 0) {
755 		pr_err("could not activate card\n");
756 		free_irq(card->p_dev->irq, card);
757 	}
758 }
759 
760 
761 /********************************************************************/
762 /* Callback functions for libertas.ko                               */
763 /********************************************************************/
764 
765 /* Send commands or data packets to the card */
766 static int if_cs_host_to_card(struct lbs_private *priv,
767 	u8 type,
768 	u8 *buf,
769 	u16 nb)
770 {
771 	int ret = -1;
772 
773 	switch (type) {
774 	case MVMS_DAT:
775 		priv->dnld_sent = DNLD_DATA_SENT;
776 		if_cs_send_data(priv, buf, nb);
777 		ret = 0;
778 		break;
779 	case MVMS_CMD:
780 		priv->dnld_sent = DNLD_CMD_SENT;
781 		ret = if_cs_send_cmd(priv, buf, nb);
782 		break;
783 	default:
784 		netdev_err(priv->dev, "%s: unsupported type %d\n",
785 			   __func__, type);
786 	}
787 
788 	return ret;
789 }
790 
791 
792 static void if_cs_release(struct pcmcia_device *p_dev)
793 {
794 	struct if_cs_card *card = p_dev->priv;
795 
796 	free_irq(p_dev->irq, card);
797 	pcmcia_disable_device(p_dev);
798 	if (card->iobase)
799 		ioport_unmap(card->iobase);
800 }
801 
802 
803 static int if_cs_ioprobe(struct pcmcia_device *p_dev, void *priv_data)
804 {
805 	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
806 	p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
807 
808 	if (p_dev->resource[1]->end) {
809 		pr_err("wrong CIS (check number of IO windows)\n");
810 		return -ENODEV;
811 	}
812 
813 	/* This reserves IO space but doesn't actually enable it */
814 	return pcmcia_request_io(p_dev);
815 }
816 
817 static int if_cs_probe(struct pcmcia_device *p_dev)
818 {
819 	int ret = -ENOMEM;
820 	unsigned int prod_id;
821 	struct lbs_private *priv;
822 	struct if_cs_card *card;
823 
824 	card = kzalloc(sizeof(struct if_cs_card), GFP_KERNEL);
825 	if (!card)
826 		goto out;
827 
828 	card->p_dev = p_dev;
829 	p_dev->priv = card;
830 
831 	p_dev->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
832 
833 	if (pcmcia_loop_config(p_dev, if_cs_ioprobe, NULL)) {
834 		pr_err("error in pcmcia_loop_config\n");
835 		goto out1;
836 	}
837 
838 	/*
839 	 * Allocate an interrupt line.  Note that this does not assign
840 	 * a handler to the interrupt, unless the 'Handler' member of
841 	 * the irq structure is initialized.
842 	 */
843 	if (!p_dev->irq)
844 		goto out1;
845 
846 	/* Initialize io access */
847 	card->iobase = ioport_map(p_dev->resource[0]->start,
848 				resource_size(p_dev->resource[0]));
849 	if (!card->iobase) {
850 		pr_err("error in ioport_map\n");
851 		ret = -EIO;
852 		goto out1;
853 	}
854 
855 	ret = pcmcia_enable_device(p_dev);
856 	if (ret) {
857 		pr_err("error in pcmcia_enable_device\n");
858 		goto out2;
859 	}
860 
861 	/* Finally, report what we've done */
862 	lbs_deb_cs("irq %d, io %pR", p_dev->irq, p_dev->resource[0]);
863 
864 	/*
865 	 * Most of the libertas cards can do unaligned register access, but some
866 	 * weird ones cannot. That's especially true for the CF8305 card.
867 	 */
868 	card->align_regs = false;
869 
870 	card->model = get_model(p_dev->manf_id, p_dev->card_id);
871 	if (card->model == MODEL_UNKNOWN) {
872 		pr_err("unsupported manf_id 0x%04x / card_id 0x%04x\n",
873 		       p_dev->manf_id, p_dev->card_id);
874 		ret = -ENODEV;
875 		goto out2;
876 	}
877 
878 	/* Check if we have a current silicon */
879 	prod_id = if_cs_read8(card, IF_CS_PRODUCT_ID);
880 	if (card->model == MODEL_8305) {
881 		card->align_regs = true;
882 		if (prod_id < IF_CS_CF8305_B1_REV) {
883 			pr_err("8305 rev B0 and older are not supported\n");
884 			ret = -ENODEV;
885 			goto out2;
886 		}
887 	}
888 
889 	if ((card->model == MODEL_8381) && prod_id < IF_CS_CF8381_B3_REV) {
890 		pr_err("8381 rev B2 and older are not supported\n");
891 		ret = -ENODEV;
892 		goto out2;
893 	}
894 
895 	if ((card->model == MODEL_8385) && prod_id < IF_CS_CF8385_B1_REV) {
896 		pr_err("8385 rev B0 and older are not supported\n");
897 		ret = -ENODEV;
898 		goto out2;
899 	}
900 
901 	/* Make this card known to the libertas driver */
902 	priv = lbs_add_card(card, &p_dev->dev);
903 	if (IS_ERR(priv)) {
904 		ret = PTR_ERR(priv);
905 		goto out2;
906 	}
907 
908 	/* Set up fields in lbs_private */
909 	card->priv = priv;
910 	priv->card = card;
911 	priv->hw_host_to_card = if_cs_host_to_card;
912 	priv->enter_deep_sleep = NULL;
913 	priv->exit_deep_sleep = NULL;
914 	priv->reset_deep_sleep_wakeup = NULL;
915 
916 	/* Get firmware */
917 	ret = lbs_get_firmware_async(priv, &p_dev->dev, card->model, fw_table,
918 				     if_cs_prog_firmware);
919 	if (ret) {
920 		pr_err("failed to find firmware (%d)\n", ret);
921 		goto out3;
922 	}
923 
924 	goto out;
925 
926 out3:
927 	lbs_remove_card(priv);
928 out2:
929 	ioport_unmap(card->iobase);
930 out1:
931 	pcmcia_disable_device(p_dev);
932 out:
933 	return ret;
934 }
935 
936 
937 static void if_cs_detach(struct pcmcia_device *p_dev)
938 {
939 	struct if_cs_card *card = p_dev->priv;
940 
941 	lbs_stop_card(card->priv);
942 	lbs_remove_card(card->priv);
943 	if_cs_disable_ints(card);
944 	if_cs_release(p_dev);
945 	kfree(card);
946 }
947 
948 
949 
950 /********************************************************************/
951 /* Module initialization                                            */
952 /********************************************************************/
953 
954 static const struct pcmcia_device_id if_cs_ids[] = {
955 	PCMCIA_DEVICE_MANF_CARD(CF8305_MANFID, CF8305_CARDID),
956 	PCMCIA_DEVICE_MANF_CARD(CF8381_MANFID, CF8381_CARDID),
957 	PCMCIA_DEVICE_MANF_CARD(CF8385_MANFID, CF8385_CARDID),
958 	/* NOTE: keep in sync with get_model() */
959 	PCMCIA_DEVICE_NULL,
960 };
961 MODULE_DEVICE_TABLE(pcmcia, if_cs_ids);
962 
963 static struct pcmcia_driver lbs_driver = {
964 	.owner		= THIS_MODULE,
965 	.name		= DRV_NAME,
966 	.probe		= if_cs_probe,
967 	.remove		= if_cs_detach,
968 	.id_table       = if_cs_ids,
969 };
970 module_pcmcia_driver(lbs_driver);
971