if_spi.c 31.8 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
 *	linux/drivers/net/wireless/libertas/if_spi.c
 *
 *	Driver for Marvell SPI WLAN cards.
 *
 *	Copyright 2008 Analog Devices Inc.
 *
 *	Authors:
 *	Andrey Yurovsky <andrey@cozybit.com>
 *	Colin McCabe <colin@cozybit.com>
 *
 *	Inspired by if_sdio.c, Copyright 2007-2008 Pierre Ossman
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

20
21
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

22
23
#include <linux/hardirq.h>
#include <linux/interrupt.h>
24
25
26
27
28
#include <linux/moduleparam.h>
#include <linux/firmware.h>
#include <linux/jiffies.h>
#include <linux/list.h>
#include <linux/netdevice.h>
29
#include <linux/slab.h>
30
31
32
33
34
35
36
37
38
#include <linux/spi/libertas_spi.h>
#include <linux/spi/spi.h>

#include "host.h"
#include "decl.h"
#include "defs.h"
#include "dev.h"
#include "if_spi.h"

39
40
41
42
43
44
struct if_spi_packet {
	struct list_head		list;
	u16				blen;
	u8				buffer[0] __attribute__((aligned(4)));
};

45
46
47
struct if_spi_card {
	struct spi_device		*spi;
	struct lbs_private		*priv;
48
	struct libertas_spi_platform_data *pdata;
49
50
51
52
53
54
55
56
57
58
59
60
61

	/* The card ID and card revision, as reported by the hardware. */
	u16				card_id;
	u8				card_rev;

	/* The last time that we initiated an SPU operation */
	unsigned long			prev_xfer_time;

	int				use_dummy_writes;
	unsigned long			spu_port_delay;
	unsigned long			spu_reg_delay;

	/* Handles all SPI communication (except for FW load) */
62
63
	struct workqueue_struct		*workqueue;
	struct work_struct		packet_work;
64
	struct work_struct		resume_work;
65
66

	u8				cmd_buffer[IF_SPI_CMD_BUF_SIZE];
67
68
69
70
71
72
73
74
75

	/* A buffer of incoming packets from libertas core.
	 * Since we can't sleep in hw_host_to_card, we have to buffer
	 * them. */
	struct list_head		cmd_packet_list;
	struct list_head		data_packet_list;

	/* Protects cmd_packet_list and data_packet_list */
	spinlock_t			buffer_lock;
76
77
78

	/* True is card suspended */
	u8				suspended;
79
80
81
82
};

static void free_if_spi_card(struct if_spi_card *card)
{
83
84
85
86
87
88
89
90
91
92
93
94
95
	struct list_head *cursor, *next;
	struct if_spi_packet *packet;

	list_for_each_safe(cursor, next, &card->cmd_packet_list) {
		packet = container_of(cursor, struct if_spi_packet, list);
		list_del(&packet->list);
		kfree(packet);
	}
	list_for_each_safe(cursor, next, &card->data_packet_list) {
		packet = container_of(cursor, struct if_spi_packet, list);
		list_del(&packet->list);
		kfree(packet);
	}
96
97
98
99
	spi_set_drvdata(card->spi, NULL);
	kfree(card);
}

100
101
102
103
104
105
106
107
108
109
110
#define MODEL_8385	0x04
#define MODEL_8686	0x0b
#define MODEL_8688	0x10

static const struct lbs_fw_table fw_table[] = {
	{ MODEL_8385, "libertas/gspi8385_helper.bin", "libertas/gspi8385.bin" },
	{ MODEL_8385, "libertas/gspi8385_hlp.bin", "libertas/gspi8385.bin" },
	{ MODEL_8686, "libertas/gspi8686_v9_helper.bin", "libertas/gspi8686_v9.bin" },
	{ MODEL_8686, "libertas/gspi8686_hlp.bin", "libertas/gspi8686.bin" },
	{ MODEL_8688, "libertas/gspi8688_helper.bin", "libertas/gspi8688.bin" },
	{ 0, NULL, NULL }
111
};
112
113
114
115
116
117
118
119
120
121
MODULE_FIRMWARE("libertas/gspi8385_helper.bin");
MODULE_FIRMWARE("libertas/gspi8385_hlp.bin");
MODULE_FIRMWARE("libertas/gspi8385.bin");
MODULE_FIRMWARE("libertas/gspi8686_v9_helper.bin");
MODULE_FIRMWARE("libertas/gspi8686_v9.bin");
MODULE_FIRMWARE("libertas/gspi8686_hlp.bin");
MODULE_FIRMWARE("libertas/gspi8686.bin");
MODULE_FIRMWARE("libertas/gspi8688_helper.bin");
MODULE_FIRMWARE("libertas/gspi8688.bin");

122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

/*
 * SPI Interface Unit Routines
 *
 * The SPU sits between the host and the WLAN module.
 * All communication with the firmware is through SPU transactions.
 *
 * First we have to put a SPU register name on the bus. Then we can
 * either read from or write to that register.
 *
 */

static void spu_transaction_init(struct if_spi_card *card)
{
	if (!time_after(jiffies, card->prev_xfer_time + 1)) {
		/* Unfortunately, the SPU requires a delay between successive
		 * transactions. If our last transaction was more than a jiffy
		 * ago, we have obviously already delayed enough.
		 * If not, we have to busy-wait to be on the safe side. */
		ndelay(400);
	}
}

static void spu_transaction_finish(struct if_spi_card *card)
{
	card->prev_xfer_time = jiffies;
}

150
151
152
153
/*
 * Write out a byte buffer to an SPI register,
 * using a series of 16-bit transfers.
 */
154
155
156
static int spu_write(struct if_spi_card *card, u16 reg, const u8 *buf, int len)
{
	int err = 0;
157
	__le16 reg_out = cpu_to_le16(reg | IF_SPI_WRITE_OPERATION_MASK);
158
159
160
161
162
163
164
	struct spi_message m;
	struct spi_transfer reg_trans;
	struct spi_transfer data_trans;

	spi_message_init(&m);
	memset(&reg_trans, 0, sizeof(reg_trans));
	memset(&data_trans, 0, sizeof(data_trans));
165
166
167
168
169
170
171
172

	/* You must give an even number of bytes to the SPU, even if it
	 * doesn't care about the last one.  */
	BUG_ON(len & 0x1);

	spu_transaction_init(card);

	/* write SPU register index */
173
174
	reg_trans.tx_buf = &reg_out;
	reg_trans.len = sizeof(reg_out);
175

176
177
	data_trans.tx_buf = buf;
	data_trans.len = len;
178

179
180
181
182
	spi_message_add_tail(&reg_trans, &m);
	spi_message_add_tail(&data_trans, &m);

	err = spi_sync(card->spi, &m);
183
184
185
186
187
188
	spu_transaction_finish(card);
	return err;
}

static inline int spu_write_u16(struct if_spi_card *card, u16 reg, u16 val)
{
189
	__le16 buff;
190

191
192
	buff = cpu_to_le16(val);
	return spu_write(card, reg, (u8 *)&buff, sizeof(u16));
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
}

static inline int spu_reg_is_port_reg(u16 reg)
{
	switch (reg) {
	case IF_SPI_IO_RDWRPORT_REG:
	case IF_SPI_CMD_RDWRPORT_REG:
	case IF_SPI_DATA_RDWRPORT_REG:
		return 1;
	default:
		return 0;
	}
}

static int spu_read(struct if_spi_card *card, u16 reg, u8 *buf, int len)
{
209
	unsigned int delay;
210
	int err = 0;
211
	__le16 reg_out = cpu_to_le16(reg | IF_SPI_READ_OPERATION_MASK);
212
213
214
215
	struct spi_message m;
	struct spi_transfer reg_trans;
	struct spi_transfer dummy_trans;
	struct spi_transfer data_trans;
216

217
218
219
220
	/*
	 * You must take an even number of bytes from the SPU, even if you
	 * don't care about the last one.
	 */
221
222
223
224
	BUG_ON(len & 0x1);

	spu_transaction_init(card);

225
226
227
228
229
	spi_message_init(&m);
	memset(&reg_trans, 0, sizeof(reg_trans));
	memset(&dummy_trans, 0, sizeof(dummy_trans));
	memset(&data_trans, 0, sizeof(data_trans));

230
	/* write SPU register index */
231
232
233
	reg_trans.tx_buf = &reg_out;
	reg_trans.len = sizeof(reg_out);
	spi_message_add_tail(&reg_trans, &m);
234
235
236
237
238

	delay = spu_reg_is_port_reg(reg) ? card->spu_port_delay :
						card->spu_reg_delay;
	if (card->use_dummy_writes) {
		/* Clock in dummy cycles while the SPU fills the FIFO */
239
240
		dummy_trans.len = delay / 8;
		spi_message_add_tail(&dummy_trans, &m);
241
242
	} else {
		/* Busy-wait while the SPU fills the FIFO */
243
244
		reg_trans.delay_usecs =
			DIV_ROUND_UP((100 + (delay * 10)), 1000);
245
246
247
	}

	/* read in data */
248
249
250
	data_trans.rx_buf = buf;
	data_trans.len = len;
	spi_message_add_tail(&data_trans, &m);
251

252
	err = spi_sync(card->spi, &m);
253
254
255
256
257
258
259
	spu_transaction_finish(card);
	return err;
}

/* Read 16 bits from an SPI register */
static inline int spu_read_u16(struct if_spi_card *card, u16 reg, u16 *val)
{
260
	__le16 buf;
261
262
263
264
265
266
	int ret;

	ret = spu_read(card, reg, (u8 *)&buf, sizeof(buf));
	if (ret == 0)
		*val = le16_to_cpup(&buf);
	return ret;
267
268
}

269
270
271
272
/*
 * Read 32 bits from an SPI register.
 * The low 16 bits are read first.
 */
273
274
static int spu_read_u32(struct if_spi_card *card, u16 reg, u32 *val)
{
275
	__le32 buf;
276
	int err;
277
278

	err = spu_read(card, reg, (u8 *)&buf, sizeof(buf));
279
	if (!err)
280
		*val = le32_to_cpup(&buf);
281
282
283
	return err;
}

284
285
/*
 * Keep reading 16 bits from an SPI register until you get the correct result.
286
287
288
289
290
 *
 * If mask = 0, the correct result is any non-zero number.
 * If mask != 0, the correct result is any number where
 * number & target_mask == target
 *
291
292
 * Returns -ETIMEDOUT if a second passes without the correct result.
 */
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
static int spu_wait_for_u16(struct if_spi_card *card, u16 reg,
			u16 target_mask, u16 target)
{
	int err;
	unsigned long timeout = jiffies + 5*HZ;
	while (1) {
		u16 val;
		err = spu_read_u16(card, reg, &val);
		if (err)
			return err;
		if (target_mask) {
			if ((val & target_mask) == target)
				return 0;
		} else {
			if (val)
				return 0;
		}
		udelay(100);
		if (time_after(jiffies, timeout)) {
312
			pr_err("%s: timeout with val=%02x, target_mask=%02x, target=%02x\n",
313
314
315
316
317
318
			       __func__, val, target_mask, target);
			return -ETIMEDOUT;
		}
	}
}

319
320
321
322
/*
 * Read 16 bits from an SPI register until you receive a specific value.
 * Returns -ETIMEDOUT if a 4 tries pass without success.
 */
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
static int spu_wait_for_u32(struct if_spi_card *card, u32 reg, u32 target)
{
	int err, try;
	for (try = 0; try < 4; ++try) {
		u32 val = 0;
		err = spu_read_u32(card, reg, &val);
		if (err)
			return err;
		if (val == target)
			return 0;
		mdelay(100);
	}
	return -ETIMEDOUT;
}

static int spu_set_interrupt_mode(struct if_spi_card *card,
			   int suppress_host_int,
			   int auto_int)
{
	int err = 0;

344
345
346
347
	/*
	 * We can suppress a host interrupt by clearing the appropriate
	 * bit in the "host interrupt status mask" register
	 */
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
	if (suppress_host_int) {
		err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_MASK_REG, 0);
		if (err)
			return err;
	} else {
		err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_MASK_REG,
			      IF_SPI_HISM_TX_DOWNLOAD_RDY |
			      IF_SPI_HISM_RX_UPLOAD_RDY |
			      IF_SPI_HISM_CMD_DOWNLOAD_RDY |
			      IF_SPI_HISM_CARDEVENT |
			      IF_SPI_HISM_CMD_UPLOAD_RDY);
		if (err)
			return err;
	}

363
364
	/*
	 * If auto-interrupts are on, the completion of certain transactions
365
366
	 * will trigger an interrupt automatically. If auto-interrupts
	 * are off, we need to set the "Card Interrupt Cause" register to
367
368
	 * trigger a card interrupt.
	 */
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
	if (auto_int) {
		err = spu_write_u16(card, IF_SPI_HOST_INT_CTRL_REG,
				IF_SPI_HICT_TX_DOWNLOAD_OVER_AUTO |
				IF_SPI_HICT_RX_UPLOAD_OVER_AUTO |
				IF_SPI_HICT_CMD_DOWNLOAD_OVER_AUTO |
				IF_SPI_HICT_CMD_UPLOAD_OVER_AUTO);
		if (err)
			return err;
	} else {
		err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_MASK_REG, 0);
		if (err)
			return err;
	}
	return err;
}

static int spu_get_chip_revision(struct if_spi_card *card,
				  u16 *card_id, u8 *card_rev)
{
	int err = 0;
	u32 dev_ctrl;
	err = spu_read_u32(card, IF_SPI_DEVICEID_CTRL_REG, &dev_ctrl);
	if (err)
		return err;
	*card_id = IF_SPI_DEVICEID_CTRL_REG_TO_CARD_ID(dev_ctrl);
	*card_rev = IF_SPI_DEVICEID_CTRL_REG_TO_CARD_REV(dev_ctrl);
	return err;
}

static int spu_set_bus_mode(struct if_spi_card *card, u16 mode)
{
	int err = 0;
	u16 rval;
	/* set bus mode */
	err = spu_write_u16(card, IF_SPI_SPU_BUS_MODE_REG, mode);
	if (err)
		return err;
	/* Check that we were able to read back what we just wrote. */
	err = spu_read_u16(card, IF_SPI_SPU_BUS_MODE_REG, &rval);
	if (err)
		return err;
410
	if ((rval & 0xF) != mode) {
411
		pr_err("Can't read bus mode register\n");
412
413
414
415
416
417
418
419
420
421
		return -EIO;
	}
	return 0;
}

static int spu_init(struct if_spi_card *card, int use_dummy_writes)
{
	int err = 0;
	u32 delay;

422
423
424
425
	/*
	 * We have to start up in timed delay mode so that we can safely
	 * read the Delay Read Register.
	 */
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
	card->use_dummy_writes = 0;
	err = spu_set_bus_mode(card,
				IF_SPI_BUS_MODE_SPI_CLOCK_PHASE_RISING |
				IF_SPI_BUS_MODE_DELAY_METHOD_TIMED |
				IF_SPI_BUS_MODE_16_BIT_ADDRESS_16_BIT_DATA);
	if (err)
		return err;
	card->spu_port_delay = 1000;
	card->spu_reg_delay = 1000;
	err = spu_read_u32(card, IF_SPI_DELAY_READ_REG, &delay);
	if (err)
		return err;
	card->spu_port_delay = delay & 0x0000ffff;
	card->spu_reg_delay = (delay & 0xffff0000) >> 16;

	/* If dummy clock delay mode has been requested, switch to it now */
	if (use_dummy_writes) {
		card->use_dummy_writes = 1;
		err = spu_set_bus_mode(card,
				IF_SPI_BUS_MODE_SPI_CLOCK_PHASE_RISING |
				IF_SPI_BUS_MODE_DELAY_METHOD_DUMMY_CLOCK |
				IF_SPI_BUS_MODE_16_BIT_ADDRESS_16_BIT_DATA);
		if (err)
			return err;
	}

	lbs_deb_spi("Initialized SPU unit. "
		    "spu_port_delay=0x%04lx, spu_reg_delay=0x%04lx\n",
		    card->spu_port_delay, card->spu_reg_delay);
	return err;
}

/*
 * Firmware Loading
 */

462
463
static int if_spi_prog_helper_firmware(struct if_spi_card *card,
					const struct firmware *firmware)
464
465
466
467
468
469
470
471
472
473
474
{
	int err = 0;
	int bytes_remaining;
	const u8 *fw;
	u8 temp[HELPER_FW_LOAD_CHUNK_SZ];

	lbs_deb_enter(LBS_DEB_SPI);

	err = spu_set_interrupt_mode(card, 1, 0);
	if (err)
		goto out;
475

476
477
478
479
480
	bytes_remaining = firmware->size;
	fw = firmware->data;

	/* Load helper firmware image */
	while (bytes_remaining > 0) {
481
482
483
484
		/*
		 * Scratch pad 1 should contain the number of bytes we
		 * want to download to the firmware
		 */
485
486
487
		err = spu_write_u16(card, IF_SPI_SCRATCH_1_REG,
					HELPER_FW_LOAD_CHUNK_SZ);
		if (err)
488
			goto out;
489
490
491
492
493

		err = spu_wait_for_u16(card, IF_SPI_HOST_INT_STATUS_REG,
					IF_SPI_HIST_CMD_DOWNLOAD_RDY,
					IF_SPI_HIST_CMD_DOWNLOAD_RDY);
		if (err)
494
			goto out;
495

496
497
498
499
		/*
		 * Feed the data into the command read/write port reg
		 * in chunks of 64 bytes
		 */
500
501
502
503
504
505
506
		memset(temp, 0, sizeof(temp));
		memcpy(temp, fw,
		       min(bytes_remaining, HELPER_FW_LOAD_CHUNK_SZ));
		mdelay(10);
		err = spu_write(card, IF_SPI_CMD_RDWRPORT_REG,
					temp, HELPER_FW_LOAD_CHUNK_SZ);
		if (err)
507
			goto out;
508
509
510
511

		/* Interrupt the boot code */
		err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_REG, 0);
		if (err)
512
			goto out;
513
514
515
		err = spu_write_u16(card, IF_SPI_CARD_INT_CAUSE_REG,
				       IF_SPI_CIC_CMD_DOWNLOAD_OVER);
		if (err)
516
			goto out;
517
518
519
520
		bytes_remaining -= HELPER_FW_LOAD_CHUNK_SZ;
		fw += HELPER_FW_LOAD_CHUNK_SZ;
	}

521
522
	/*
	 * Once the helper / single stage firmware download is complete,
523
	 * write 0 to scratch pad 1 and interrupt the
524
525
	 * bootloader. This completes the helper download.
	 */
526
527
	err = spu_write_u16(card, IF_SPI_SCRATCH_1_REG, FIRMWARE_DNLD_OK);
	if (err)
528
		goto out;
529
530
	err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_REG, 0);
	if (err)
531
		goto out;
532
533
534
535
	err = spu_write_u16(card, IF_SPI_CARD_INT_CAUSE_REG,
				IF_SPI_CIC_CMD_DOWNLOAD_OVER);
out:
	if (err)
536
		pr_err("failed to load helper firmware (err=%d)\n", err);
537
538
539
540
	lbs_deb_leave_args(LBS_DEB_SPI, "err %d", err);
	return err;
}

541
542
543
544
/*
 * Returns the length of the next packet the firmware expects us to send.
 * Sets crc_err if the previous transfer had a CRC error.
 */
545
546
547
548
549
550
static int if_spi_prog_main_firmware_check_len(struct if_spi_card *card,
						int *crc_err)
{
	u16 len;
	int err = 0;

551
552
553
554
	/*
	 * wait until the host interrupt status register indicates
	 * that we are ready to download
	 */
555
556
557
558
	err = spu_wait_for_u16(card, IF_SPI_HOST_INT_STATUS_REG,
				IF_SPI_HIST_CMD_DOWNLOAD_RDY,
				IF_SPI_HIST_CMD_DOWNLOAD_RDY);
	if (err) {
559
		pr_err("timed out waiting for host_int_status\n");
560
561
562
563
564
565
566
567
568
		return err;
	}

	/* Ask the device how many bytes of firmware it wants. */
	err = spu_read_u16(card, IF_SPI_SCRATCH_1_REG, &len);
	if (err)
		return err;

	if (len > IF_SPI_CMD_BUF_SIZE) {
569
570
		pr_err("firmware load device requested a larger transfer than we are prepared to handle (len = %d)\n",
		       len);
571
572
573
574
575
576
577
578
579
580
581
582
		return -EIO;
	}
	if (len & 0x1) {
		lbs_deb_spi("%s: crc error\n", __func__);
		len &= ~0x1;
		*crc_err = 1;
	} else
		*crc_err = 0;

	return len;
}

583
584
static int if_spi_prog_main_firmware(struct if_spi_card *card,
					const struct firmware *firmware)
585
{
586
	struct lbs_private *priv = card->priv;
587
588
589
590
591
592
593
594
595
596
597
598
599
	int len, prev_len;
	int bytes, crc_err = 0, err = 0;
	const u8 *fw;
	u16 num_crc_errs;

	lbs_deb_enter(LBS_DEB_SPI);

	err = spu_set_interrupt_mode(card, 1, 0);
	if (err)
		goto out;

	err = spu_wait_for_u16(card, IF_SPI_SCRATCH_1_REG, 0, 0);
	if (err) {
600
601
602
		netdev_err(priv->dev,
			   "%s: timed out waiting for initial scratch reg = 0\n",
			   __func__);
603
		goto out;
604
605
606
607
608
609
610
611
612
	}

	num_crc_errs = 0;
	prev_len = 0;
	bytes = firmware->size;
	fw = firmware->data;
	while ((len = if_spi_prog_main_firmware_check_len(card, &crc_err))) {
		if (len < 0) {
			err = len;
613
			goto out;
614
615
		}
		if (bytes < 0) {
616
617
618
619
			/*
			 * If there are no more bytes left, we would normally
			 * expect to have terminated with len = 0
			 */
620
621
			netdev_err(priv->dev,
				   "Firmware load wants more bytes than we have to offer.\n");
622
623
624
625
626
			break;
		}
		if (crc_err) {
			/* Previous transfer failed. */
			if (++num_crc_errs > MAX_MAIN_FW_LOAD_CRC_ERR) {
627
				pr_err("Too many CRC errors encountered in firmware load.\n");
628
				err = -EIO;
629
				goto out;
630
631
632
633
634
635
636
637
638
639
640
641
642
643
			}
		} else {
			/* Previous transfer succeeded. Advance counters. */
			bytes -= prev_len;
			fw += prev_len;
		}
		if (bytes < len) {
			memset(card->cmd_buffer, 0, len);
			memcpy(card->cmd_buffer, fw, bytes);
		} else
			memcpy(card->cmd_buffer, fw, len);

		err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_REG, 0);
		if (err)
644
			goto out;
645
646
647
		err = spu_write(card, IF_SPI_CMD_RDWRPORT_REG,
				card->cmd_buffer, len);
		if (err)
648
			goto out;
649
650
651
		err = spu_write_u16(card, IF_SPI_CARD_INT_CAUSE_REG ,
					IF_SPI_CIC_CMD_DOWNLOAD_OVER);
		if (err)
652
			goto out;
653
654
655
		prev_len = len;
	}
	if (bytes > prev_len) {
656
		pr_err("firmware load wants fewer bytes than we have to offer\n");
657
658
659
660
661
662
	}

	/* Confirm firmware download */
	err = spu_wait_for_u32(card, IF_SPI_SCRATCH_4_REG,
					SUCCESSFUL_FW_DOWNLOAD_MAGIC);
	if (err) {
663
		pr_err("failed to confirm the firmware download\n");
664
		goto out;
665
666
667
668
	}

out:
	if (err)
669
		pr_err("failed to load firmware (err=%d)\n", err);
670
671
672
673
674
675
676
	lbs_deb_leave_args(LBS_DEB_SPI, "err %d", err);
	return err;
}

/*
 * SPI Transfer Thread
 *
677
 * The SPI worker handles all SPI transfers, so there is no need for a lock.
678
679
680
681
682
683
684
685
686
687
688
 */

/* Move a command from the card to the host */
static int if_spi_c2h_cmd(struct if_spi_card *card)
{
	struct lbs_private *priv = card->priv;
	unsigned long flags;
	int err = 0;
	u16 len;
	u8 i;

689
690
691
692
	/*
	 * We need a buffer big enough to handle whatever people send to
	 * hw_host_to_card
	 */
693
694
695
	BUILD_BUG_ON(IF_SPI_CMD_BUF_SIZE < LBS_CMD_BUFFER_SIZE);
	BUILD_BUG_ON(IF_SPI_CMD_BUF_SIZE < LBS_UPLD_SIZE);

696
697
698
699
700
	/*
	 * It's just annoying if the buffer size isn't a multiple of 4, because
	 * then we might have len < IF_SPI_CMD_BUF_SIZE but
	 * ALIGN(len, 4) > IF_SPI_CMD_BUF_SIZE
	 */
701
702
703
704
705
706
707
708
709
	BUILD_BUG_ON(IF_SPI_CMD_BUF_SIZE % 4 != 0);

	lbs_deb_enter(LBS_DEB_SPI);

	/* How many bytes are there to read? */
	err = spu_read_u16(card, IF_SPI_SCRATCH_2_REG, &len);
	if (err)
		goto out;
	if (!len) {
710
711
		netdev_err(priv->dev, "%s: error: card has no data for host\n",
			   __func__);
712
713
714
		err = -EINVAL;
		goto out;
	} else if (len > IF_SPI_CMD_BUF_SIZE) {
715
716
717
		netdev_err(priv->dev,
			   "%s: error: response packet too large: %d bytes, but maximum is %d\n",
			   __func__, len, IF_SPI_CMD_BUF_SIZE);
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
		err = -EINVAL;
		goto out;
	}

	/* Read the data from the WLAN module into our command buffer */
	err = spu_read(card, IF_SPI_CMD_RDWRPORT_REG,
				card->cmd_buffer, ALIGN(len, 4));
	if (err)
		goto out;

	spin_lock_irqsave(&priv->driver_lock, flags);
	i = (priv->resp_idx == 0) ? 1 : 0;
	BUG_ON(priv->resp_len[i]);
	priv->resp_len[i] = len;
	memcpy(priv->resp_buf[i], card->cmd_buffer, len);
	lbs_notify_command_response(priv, i);
	spin_unlock_irqrestore(&priv->driver_lock, flags);

out:
	if (err)
738
		netdev_err(priv->dev, "%s: err=%d\n", __func__, err);
739
740
741
742
743
744
745
	lbs_deb_leave(LBS_DEB_SPI);
	return err;
}

/* Move data from the card to the host */
static int if_spi_c2h_data(struct if_spi_card *card)
{
746
	struct lbs_private *priv = card->priv;
747
748
749
750
751
752
753
754
755
756
757
758
	struct sk_buff *skb;
	char *data;
	u16 len;
	int err = 0;

	lbs_deb_enter(LBS_DEB_SPI);

	/* How many bytes are there to read? */
	err = spu_read_u16(card, IF_SPI_SCRATCH_1_REG, &len);
	if (err)
		goto out;
	if (!len) {
759
760
		netdev_err(priv->dev, "%s: error: card has no data for host\n",
			   __func__);
761
762
763
		err = -EINVAL;
		goto out;
	} else if (len > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {
764
765
766
		netdev_err(priv->dev,
			   "%s: error: card has %d bytes of data, but our maximum skb size is %zu\n",
			   __func__, len, MRVDRV_ETH_RX_PACKET_BUFFER_SIZE);
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
		err = -EINVAL;
		goto out;
	}

	/* TODO: should we allocate a smaller skb if we have less data? */
	skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE);
	if (!skb) {
		err = -ENOBUFS;
		goto out;
	}
	skb_reserve(skb, IPFIELD_ALIGN_OFFSET);
	data = skb_put(skb, len);

	/* Read the data from the WLAN module into our skb... */
	err = spu_read(card, IF_SPI_DATA_RDWRPORT_REG, data, ALIGN(len, 4));
	if (err)
		goto free_skb;

	/* pass the SKB to libertas */
	err = lbs_process_rxed_packet(card->priv, skb);
	if (err)
		goto free_skb;

	/* success */
	goto out;

free_skb:
	dev_kfree_skb(skb);
out:
	if (err)
797
		netdev_err(priv->dev, "%s: err=%d\n", __func__, err);
798
799
800
801
	lbs_deb_leave(LBS_DEB_SPI);
	return err;
}

802
803
804
805
/* Move data or a command from the host to the card. */
static void if_spi_h2c(struct if_spi_card *card,
			struct if_spi_packet *packet, int type)
{
806
	struct lbs_private *priv = card->priv;
807
808
809
810
811
812
813
814
815
816
817
818
819
	int err = 0;
	u16 int_type, port_reg;

	switch (type) {
	case MVMS_DAT:
		int_type = IF_SPI_CIC_TX_DOWNLOAD_OVER;
		port_reg = IF_SPI_DATA_RDWRPORT_REG;
		break;
	case MVMS_CMD:
		int_type = IF_SPI_CIC_CMD_DOWNLOAD_OVER;
		port_reg = IF_SPI_CMD_RDWRPORT_REG;
		break;
	default:
820
821
		netdev_err(priv->dev, "can't transfer buffer of type %d\n",
			   type);
822
823
824
825
826
827
828
829
830
831
832
833
834
		err = -EINVAL;
		goto out;
	}

	/* Write the data to the card */
	err = spu_write(card, port_reg, packet->buffer, packet->blen);
	if (err)
		goto out;

out:
	kfree(packet);

	if (err)
835
		netdev_err(priv->dev, "%s: error %d\n", __func__, err);
836
837
}

838
839
840
841
842
843
844
845
846
847
848
/* Inform the host about a card event */
static void if_spi_e2h(struct if_spi_card *card)
{
	int err = 0;
	u32 cause;
	struct lbs_private *priv = card->priv;

	err = spu_read_u32(card, IF_SPI_SCRATCH_3_REG, &cause);
	if (err)
		goto out;

849
850
851
852
853
854
855
	/* re-enable the card event interrupt */
	spu_write_u16(card, IF_SPI_HOST_INT_STATUS_REG,
			~IF_SPI_HICU_CARD_EVENT);

	/* generate a card interrupt */
	spu_write_u16(card, IF_SPI_CARD_INT_CAUSE_REG, IF_SPI_CIC_HOST_EVENT);

856
857
858
	lbs_queue_event(priv, cause & 0xff);
out:
	if (err)
859
		netdev_err(priv->dev, "%s: error %d\n", __func__, err);
860
861
}

862
static void if_spi_host_to_card_worker(struct work_struct *work)
863
864
{
	int err;
865
	struct if_spi_card *card;
866
	u16 hiStatus;
867
868
	unsigned long flags;
	struct if_spi_packet *packet;
869
	struct lbs_private *priv;
870

871
	card = container_of(work, struct if_spi_card, packet_work);
872
	priv = card->priv;
873

874
875
	lbs_deb_enter(LBS_DEB_SPI);

876
877
878
879
	/*
	 * Read the host interrupt status register to see what we
	 * can do.
	 */
880
881
882
	err = spu_read_u16(card, IF_SPI_HOST_INT_STATUS_REG,
				&hiStatus);
	if (err) {
883
		netdev_err(priv->dev, "I/O error\n");
884
885
886
887
888
889
		goto err;
	}

	if (hiStatus & IF_SPI_HIST_CMD_UPLOAD_RDY) {
		err = if_spi_c2h_cmd(card);
		if (err)
890
			goto err;
891
892
893
894
895
896
	}
	if (hiStatus & IF_SPI_HIST_RX_UPLOAD_RDY) {
		err = if_spi_c2h_data(card);
		if (err)
			goto err;
	}
897

898
899
900
901
	/*
	 * workaround: in PS mode, the card does not set the Command
	 * Download Ready bit, but it sets TX Download Ready.
	 */
902
903
904
	if (hiStatus & IF_SPI_HIST_CMD_DOWNLOAD_RDY ||
	   (card->priv->psstate != PS_STATE_FULL_POWER &&
	    (hiStatus & IF_SPI_HIST_TX_DOWNLOAD_RDY))) {
905
906
		/*
		 * This means two things. First of all,
907
908
909
910
911
912
913
		 * if there was a previous command sent, the card has
		 * successfully received it.
		 * Secondly, it is now ready to download another
		 * command.
		 */
		lbs_host_to_card_done(card->priv);

914
		/* Do we have any command packets from the host to send? */
915
916
917
918
919
920
		packet = NULL;
		spin_lock_irqsave(&card->buffer_lock, flags);
		if (!list_empty(&card->cmd_packet_list)) {
			packet = (struct if_spi_packet *)(card->
					cmd_packet_list.next);
			list_del(&packet->list);
921
		}
922
		spin_unlock_irqrestore(&card->buffer_lock, flags);
923

924
925
926
927
		if (packet)
			if_spi_h2c(card, packet, MVMS_CMD);
	}
	if (hiStatus & IF_SPI_HIST_TX_DOWNLOAD_RDY) {
928
		/* Do we have any data packets from the host to send? */
929
930
931
932
933
934
		packet = NULL;
		spin_lock_irqsave(&card->buffer_lock, flags);
		if (!list_empty(&card->data_packet_list)) {
			packet = (struct if_spi_packet *)(card->
					data_packet_list.next);
			list_del(&packet->list);
935
		}
936
		spin_unlock_irqrestore(&card->buffer_lock, flags);
937

938
939
940
941
942
		if (packet)
			if_spi_h2c(card, packet, MVMS_DAT);
	}
	if (hiStatus & IF_SPI_HIST_CARD_EVENT)
		if_spi_e2h(card);
943
944

err:
945
	if (err)
946
		netdev_err(priv->dev, "%s: got error %d\n", __func__, err);
947

948
	lbs_deb_leave(LBS_DEB_SPI);
949
950
951
952
953
954
}

/*
 * Host to Card
 *
 * Called from Libertas to transfer some data to the WLAN device
955
956
 * We can't sleep here.
 */
957
958
959
960
static int if_spi_host_to_card(struct lbs_private *priv,
				u8 type, u8 *buf, u16 nb)
{
	int err = 0;
961
	unsigned long flags;
962
	struct if_spi_card *card = priv->card;
963
964
	struct if_spi_packet *packet;
	u16 blen;
965
966
967

	lbs_deb_enter_args(LBS_DEB_SPI, "type %d, bytes %d", type, nb);

968
	if (nb == 0) {
969
970
		netdev_err(priv->dev, "%s: invalid size requested: %d\n",
			   __func__, nb);
971
972
973
974
975
976
977
978
979
980
981
982
		err = -EINVAL;
		goto out;
	}
	blen = ALIGN(nb, 4);
	packet = kzalloc(sizeof(struct if_spi_packet) + blen, GFP_ATOMIC);
	if (!packet) {
		err = -ENOMEM;
		goto out;
	}
	packet->blen = blen;
	memcpy(packet->buffer, buf, nb);
	memset(packet->buffer + nb, 0, blen - nb);
983
984
985

	switch (type) {
	case MVMS_CMD:
986
987
988
989
		priv->dnld_sent = DNLD_CMD_SENT;
		spin_lock_irqsave(&card->buffer_lock, flags);
		list_add_tail(&packet->list, &card->cmd_packet_list);
		spin_unlock_irqrestore(&card->buffer_lock, flags);
990
991
		break;
	case MVMS_DAT:
992
993
994
995
		priv->dnld_sent = DNLD_DATA_SENT;
		spin_lock_irqsave(&card->buffer_lock, flags);
		list_add_tail(&packet->list, &card->data_packet_list);
		spin_unlock_irqrestore(&card->buffer_lock, flags);
996
997
		break;
	default:
998
		kfree(packet);
999
1000
		netdev_err(priv->dev, "can't transfer buffer of type %d\n",
			   type);
1001
1002
1003
1004
		err = -EINVAL;
		break;
	}

1005
1006
1007
	/* Queue spi xfer work */
	queue_work(card->workqueue, &card->packet_work);
out:
1008
1009
1010
1011
1012
1013
1014
1015
	lbs_deb_leave_args(LBS_DEB_SPI, "err=%d", err);
	return err;
}

/*
 * Host Interrupts
 *
 * Service incoming interrupts from the WLAN device. We can't sleep here, so
1016
 * don't try to talk on the SPI bus, just queue the SPI xfer work.
1017
1018
1019
1020
1021
 */
static irqreturn_t if_spi_host_interrupt(int irq, void *dev_id)
{
	struct if_spi_card *card = dev_id;

1022
1023
	queue_work(card->workqueue, &card->packet_work);

1024
1025
1026
1027
1028
1029
1030
	return IRQ_HANDLED;
}

/*
 * SPI callbacks
 */

1031
static int if_spi_init_card(struct if_spi_card *card)
1032
{
1033
	struct lbs_private *priv = card->priv;
1034
	int err, i;
1035
	u32 scratch;
1036
1037
	const struct firmware *helper = NULL;
	const struct firmware *mainfw = NULL;
1038
1039
1040

	lbs_deb_enter(LBS_DEB_SPI);

1041
	err = spu_init(card, card->pdata->use_dummy_writes);
1042
	if (err)
1043
		goto out;
1044
1045
	err = spu_get_chip_revision(card, &card->card_id, &card->card_rev);
	if (err)
1046
		goto out;
1047
1048
1049

	err = spu_read_u32(card, IF_SPI_SCRATCH_4_REG, &scratch);
	if (err)
1050
		goto out;
1051
1052
1053
1054
	if (scratch == SUCCESSFUL_FW_DOWNLOAD_MAGIC)
		lbs_deb_spi("Firmware is already loaded for "
			    "Marvell WLAN 802.11 adapter\n");
	else {
1055
1056
1057
1058
1059
1060
		/* Check if we support this card */
		for (i = 0; i < ARRAY_SIZE(fw_table); i++) {
			if (card->card_id == fw_table[i].model)
				break;
		}
		if (i == ARRAY_SIZE(fw_table)) {
1061
1062
			netdev_err(priv->dev, "Unsupported chip_id: 0x%02x\n",
				   card->card_id);
1063
			err = -ENODEV;
1064
			goto out;
1065
1066
1067
1068
1069
1070
		}

		err = lbs_get_firmware(&card->spi->dev, NULL, NULL,
					card->card_id, &fw_table[0], &helper,
					&mainfw);
		if (err) {
1071
1072
			netdev_err(priv->dev, "failed to find firmware (%d)\n",
				   err);
1073
			goto out;
1074
		}
1075
1076
1077
1078
1079
1080

		lbs_deb_spi("Initializing FW for Marvell WLAN 802.11 adapter "
				"(chip_id = 0x%04x, chip_rev = 0x%02x) "
				"attached to SPI bus_num %d, chip_select %d. "
				"spi->max_speed_hz=%d\n",
				card->card_id, card->card_rev,
1081
1082
1083
				card->spi->master->bus_num,
				card->spi->chip_select,
				card->spi->max_speed_hz);
1084
		err = if_spi_prog_helper_firmware(card, helper);
1085
		if (err)
1086
			goto out;
1087
		err = if_spi_prog_main_firmware(card, mainfw);
1088
		if (err)
1089
			goto out;
1090
1091
1092
1093
		lbs_deb_spi("loaded FW for Marvell WLAN 802.11 adapter\n");
	}

	err = spu_set_interrupt_mode(card, 0, 1);
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
	if (err)
		goto out;

out:
	if (helper)
		release_firmware(helper);
	if (mainfw)
		release_firmware(mainfw);

	lbs_deb_leave_args(LBS_DEB_SPI, "err %d\n", err);

	return err;
}

1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
static void if_spi_resume_worker(struct work_struct *work)
{
	struct if_spi_card *card;

	card = container_of(work, struct if_spi_card, resume_work);

	if (card->suspended) {
		if (card->pdata->setup)
			card->pdata->setup(card->spi);

		/* Init card ... */
		if_spi_init_card(card);

		enable_irq(card->spi->irq);

		/* And resume it ... */
		lbs_resume(card->priv);

		card->suspended = 0;
	}
}

1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
static int __devinit if_spi_probe(struct spi_device *spi)
{
	struct if_spi_card *card;
	struct lbs_private *priv = NULL;
	struct libertas_spi_platform_data *pdata = spi->dev.platform_data;
	int err = 0;

	lbs_deb_enter(LBS_DEB_SPI);

	if (!pdata) {
		err = -EINVAL;
		goto out;
	}

	if (pdata->setup) {
		err = pdata->setup(spi);
		if (err)
			goto out;
	}

	/* Allocate card structure to represent this specific device */
	card = kzalloc(sizeof(struct if_spi_card), GFP_KERNEL);
	if (!card) {
		err = -ENOMEM;
		goto teardown;
	}
	spi_set_drvdata(spi, card);
	card->pdata = pdata;
	card->spi = spi;
	card->prev_xfer_time = jiffies;

	INIT_LIST_HEAD(&card->cmd_packet_list);
	INIT_LIST_HEAD(&card->data_packet_list);
	spin_lock_init(&card->buffer_lock);

	/* Initialize the SPI Interface Unit */

	/* Firmware load */
	err = if_spi_init_card(card);
1169
	if (err)
1170
		goto free_card;
1171

1172
1173
1174
1175
	/*
	 * Register our card with libertas.
	 * This will call alloc_etherdev.
	 */
1176
1177
1178
	priv = lbs_add_card(card, &spi->dev);
	if (!priv) {
		err = -ENOMEM;
1179
		goto free_card;
1180
1181
	}
	card->priv = priv;
1182
	priv->setup_fw_on_resume = 1;
1183
1184
	priv->card = card;
	priv->hw_host_to_card = if_spi_host_to_card;
1185
1186
1187
	priv->enter_deep_sleep = NULL;
	priv->exit_deep_sleep = NULL;
	priv->reset_deep_sleep_wakeup = NULL;
1188
1189
1190
	priv->fw_ready = 1;

	/* Initialize interrupt handling stuff. */
1191
1192
	card->workqueue = create_workqueue("libertas_spi");
	INIT_WORK(&card->packet_work, if_spi_host_to_card_worker);
1193
	INIT_WORK(&card->resume_work, if_spi_resume_worker);
1194

1195
1196
1197
	err = request_irq(spi->irq, if_spi_host_interrupt,
			IRQF_TRIGGER_FALLING, "libertas_spi", card);
	if (err) {
1198
		pr_err("can't get host irq line-- request_irq failed\n");
1199
		goto terminate_workqueue;
1200
1201
	}

1202
1203
	/*
	 * Start the card.
1204
	 * This will call register_netdev, and we'll start
1205
1206
	 * getting interrupts...
	 */
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
	err = lbs_start_card(priv);
	if (err)
		goto release_irq;

	lbs_deb_spi("Finished initializing WLAN module.\n");

	/* successful exit */
	goto out;

release_irq:
	free_irq(spi->irq, card);
1218
1219
1220
terminate_workqueue:
	flush_workqueue(card->workqueue);
	destroy_workqueue(card->workqueue);
1221
1222
1223
	lbs_remove_card(priv); /* will call free_netdev */
free_card:
	free_if_spi_card(card);
1224
1225
1226
teardown:
	if (pdata->teardown)
		pdata->teardown(spi);
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
out:
	lbs_deb_leave_args(LBS_DEB_SPI, "err %d\n", err);
	return err;
}

static int __devexit libertas_spi_remove(struct spi_device *spi)
{
	struct if_spi_card *card = spi_get_drvdata(spi);
	struct lbs_private *priv = card->priv;

	lbs_deb_spi("libertas_spi_remove\n");
	lbs_deb_enter(LBS_DEB_SPI);

1240
1241
	cancel_work_sync(&card->resume_work);

1242
	lbs_stop_card(priv);
1243
1244
	lbs_remove_card(priv); /* will call free_netdev */

1245
	free_irq(spi->irq, card);
1246
1247
	flush_workqueue(card->workqueue);
	destroy_workqueue(card->workqueue);
1248
1249
	if (card->pdata->teardown)
		card->pdata->teardown(spi);
1250
1251
1252
1253
1254
	free_if_spi_card(card);
	lbs_deb_leave(LBS_DEB_SPI);
	return 0;
}

1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
static int if_spi_suspend(struct device *dev)
{
	struct spi_device *spi = to_spi_device(dev);
	struct if_spi_card *card = spi_get_drvdata(spi);

	if (!card->suspended) {
		lbs_suspend(card->priv);
		flush_workqueue(card->workqueue);
		disable_irq(spi->irq);

		if (card->pdata->teardown)
			card->pdata->teardown(spi);
		card->suspended = 1;
	}

	return 0;
}

static int if_spi_resume(struct device *dev)
{
	struct spi_device *spi = to_spi_device(dev);
	struct if_spi_card *card = spi_get_drvdata(spi);

	/* Schedule delayed work */
	schedule_work(&card->resume_work);

	return 0;
}

static const struct dev_pm_ops if_spi_pm_ops = {
	.suspend	= if_spi_suspend,
	.resume		= if_spi_resume,
};

1289
1290
1291
1292
1293
1294
1295
static struct spi_driver libertas_spi_driver = {
	.probe	= if_spi_probe,
	.remove = __devexit_p(libertas_spi_remove),
	.driver = {
		.name	= "libertas_spi",
		.bus	= &spi_bus_type,
		.owner	= THIS_MODULE,
1296
		.pm	= &if_spi_pm_ops,
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
	},
};

/*
 * Module functions
 */

static int __init if_spi_init_module(void)
{
	int ret = 0;
	lbs_deb_enter(LBS_DEB_SPI);
	printk(KERN_INFO "libertas_spi: Libertas SPI driver\n");
	ret = spi_register_driver(&libertas_spi_driver);
	lbs_deb_leave(LBS_DEB_SPI);
	return ret;
}

static void __exit if_spi_exit_module(void)
{
	lbs_deb_enter(LBS_DEB_SPI);
	spi_unregister_driver(&libertas_spi_driver);
	lbs_deb_leave(LBS_DEB_SPI);
}

module_init(if_spi_init_module);
module_exit(if_spi_exit_module);

MODULE_DESCRIPTION("Libertas SPI WLAN Driver");
MODULE_AUTHOR("Andrey Yurovsky <andrey@cozybit.com>, "
	      "Colin McCabe <colin@cozybit.com>");
MODULE_LICENSE("GPL");
1328
MODULE_ALIAS("spi:libertas_spi");