1 /* ////////////////////////////////////////////////////////////////////////// */
3 /* Copyright (c) Atmel Corporation. All rights reserved. */
5 /* Module Name: wilc_spi.c */
8 /* //////////////////////////////////////////////////////////////////////////// */
9 #include <linux/module.h>
10 #include <linux/init.h>
11 #include <linux/kernel.h>
13 #include <linux/slab.h>
14 #include <linux/types.h>
15 #include <linux/cdev.h>
16 #include <linux/uaccess.h>
17 #include <linux/device.h>
18 #include <linux/spi/spi.h>
19 #include <linux/of_gpio.h>
21 #include <linux/string.h>
22 #include "wilc_wlan_if.h"
23 #include "wilc_wlan.h"
24 #include "wilc_wfi_netdevice.h"
32 static struct wilc_spi g_spi
;
34 static int wilc_spi_read(struct wilc
*wilc
, u32
, u8
*, u32
);
35 static int wilc_spi_write(struct wilc
*wilc
, u32
, u8
*, u32
);
37 /********************************************
41 ********************************************/
43 static const u8 crc7_syndrome_table
[256] = {
44 0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f,
45 0x48, 0x41, 0x5a, 0x53, 0x6c, 0x65, 0x7e, 0x77,
46 0x19, 0x10, 0x0b, 0x02, 0x3d, 0x34, 0x2f, 0x26,
47 0x51, 0x58, 0x43, 0x4a, 0x75, 0x7c, 0x67, 0x6e,
48 0x32, 0x3b, 0x20, 0x29, 0x16, 0x1f, 0x04, 0x0d,
49 0x7a, 0x73, 0x68, 0x61, 0x5e, 0x57, 0x4c, 0x45,
50 0x2b, 0x22, 0x39, 0x30, 0x0f, 0x06, 0x1d, 0x14,
51 0x63, 0x6a, 0x71, 0x78, 0x47, 0x4e, 0x55, 0x5c,
52 0x64, 0x6d, 0x76, 0x7f, 0x40, 0x49, 0x52, 0x5b,
53 0x2c, 0x25, 0x3e, 0x37, 0x08, 0x01, 0x1a, 0x13,
54 0x7d, 0x74, 0x6f, 0x66, 0x59, 0x50, 0x4b, 0x42,
55 0x35, 0x3c, 0x27, 0x2e, 0x11, 0x18, 0x03, 0x0a,
56 0x56, 0x5f, 0x44, 0x4d, 0x72, 0x7b, 0x60, 0x69,
57 0x1e, 0x17, 0x0c, 0x05, 0x3a, 0x33, 0x28, 0x21,
58 0x4f, 0x46, 0x5d, 0x54, 0x6b, 0x62, 0x79, 0x70,
59 0x07, 0x0e, 0x15, 0x1c, 0x23, 0x2a, 0x31, 0x38,
60 0x41, 0x48, 0x53, 0x5a, 0x65, 0x6c, 0x77, 0x7e,
61 0x09, 0x00, 0x1b, 0x12, 0x2d, 0x24, 0x3f, 0x36,
62 0x58, 0x51, 0x4a, 0x43, 0x7c, 0x75, 0x6e, 0x67,
63 0x10, 0x19, 0x02, 0x0b, 0x34, 0x3d, 0x26, 0x2f,
64 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c,
65 0x3b, 0x32, 0x29, 0x20, 0x1f, 0x16, 0x0d, 0x04,
66 0x6a, 0x63, 0x78, 0x71, 0x4e, 0x47, 0x5c, 0x55,
67 0x22, 0x2b, 0x30, 0x39, 0x06, 0x0f, 0x14, 0x1d,
68 0x25, 0x2c, 0x37, 0x3e, 0x01, 0x08, 0x13, 0x1a,
69 0x6d, 0x64, 0x7f, 0x76, 0x49, 0x40, 0x5b, 0x52,
70 0x3c, 0x35, 0x2e, 0x27, 0x18, 0x11, 0x0a, 0x03,
71 0x74, 0x7d, 0x66, 0x6f, 0x50, 0x59, 0x42, 0x4b,
72 0x17, 0x1e, 0x05, 0x0c, 0x33, 0x3a, 0x21, 0x28,
73 0x5f, 0x56, 0x4d, 0x44, 0x7b, 0x72, 0x69, 0x60,
74 0x0e, 0x07, 0x1c, 0x15, 0x2a, 0x23, 0x38, 0x31,
75 0x46, 0x4f, 0x54, 0x5d, 0x62, 0x6b, 0x70, 0x79
78 static u8
crc7_byte(u8 crc
, u8 data
)
80 return crc7_syndrome_table
[(crc
<< 1) ^ data
];
83 static u8
crc7(u8 crc
, const u8
*buffer
, u32 len
)
86 crc
= crc7_byte(crc
, *buffer
++);
90 /********************************************
92 * Spi protocol Function
94 ********************************************/
96 #define CMD_DMA_WRITE 0xc1
97 #define CMD_DMA_READ 0xc2
98 #define CMD_INTERNAL_WRITE 0xc3
99 #define CMD_INTERNAL_READ 0xc4
100 #define CMD_TERMINATE 0xc5
101 #define CMD_REPEAT 0xc6
102 #define CMD_DMA_EXT_WRITE 0xc7
103 #define CMD_DMA_EXT_READ 0xc8
104 #define CMD_SINGLE_WRITE 0xc9
105 #define CMD_SINGLE_READ 0xca
106 #define CMD_RESET 0xcf
113 #define DATA_PKT_SZ_256 256
114 #define DATA_PKT_SZ_512 512
115 #define DATA_PKT_SZ_1K 1024
116 #define DATA_PKT_SZ_4K (4 * 1024)
117 #define DATA_PKT_SZ_8K (8 * 1024)
118 #define DATA_PKT_SZ DATA_PKT_SZ_8K
120 #define USE_SPI_DMA 0
122 static int wilc_bus_probe(struct spi_device
*spi
)
127 gpio
= of_get_gpio(spi
->dev
.of_node
, 0);
131 ret
= wilc_netdev_init(&wilc
, NULL
, HIF_SPI
, GPIO_NUM
, &wilc_hif_spi
);
135 spi_set_drvdata(spi
, wilc
);
136 wilc
->dev
= &spi
->dev
;
141 static int wilc_bus_remove(struct spi_device
*spi
)
143 wilc_netdev_cleanup(spi_get_drvdata(spi
));
147 static const struct of_device_id wilc1000_of_match
[] = {
148 { .compatible
= "atmel,wilc_spi", },
151 MODULE_DEVICE_TABLE(of
, wilc1000_of_match
);
153 static struct spi_driver wilc1000_spi_driver
= {
156 .of_match_table
= wilc1000_of_match
,
158 .probe
= wilc_bus_probe
,
159 .remove
= wilc_bus_remove
,
161 module_spi_driver(wilc1000_spi_driver
);
162 MODULE_LICENSE("GPL");
164 static int wilc_spi_tx(struct wilc
*wilc
, u8
*b
, u32 len
)
166 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
168 struct spi_message msg
;
171 struct spi_transfer tr
= {
176 char *r_buffer
= kzalloc(len
, GFP_KERNEL
);
181 tr
.rx_buf
= r_buffer
;
182 dev_dbg(&spi
->dev
, "Request writing %d bytes\n", len
);
184 memset(&msg
, 0, sizeof(msg
));
185 spi_message_init(&msg
);
187 msg
.is_dma_mapped
= USE_SPI_DMA
;
188 spi_message_add_tail(&tr
, &msg
);
190 ret
= spi_sync(spi
, &msg
);
192 dev_err(&spi
->dev
, "SPI transaction failed\n");
197 "can't write data with the following length: %d\n",
205 static int wilc_spi_rx(struct wilc
*wilc
, u8
*rb
, u32 rlen
)
207 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
211 struct spi_message msg
;
212 struct spi_transfer tr
= {
218 char *t_buffer
= kzalloc(rlen
, GFP_KERNEL
);
223 tr
.tx_buf
= t_buffer
;
225 memset(&msg
, 0, sizeof(msg
));
226 spi_message_init(&msg
);
228 msg
.is_dma_mapped
= USE_SPI_DMA
;
229 spi_message_add_tail(&tr
, &msg
);
231 ret
= spi_sync(spi
, &msg
);
233 dev_err(&spi
->dev
, "SPI transaction failed\n");
237 "can't read data with the following length: %u\n",
245 static int wilc_spi_tx_rx(struct wilc
*wilc
, u8
*wb
, u8
*rb
, u32 rlen
)
247 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
251 struct spi_message msg
;
252 struct spi_transfer tr
= {
261 memset(&msg
, 0, sizeof(msg
));
262 spi_message_init(&msg
);
264 msg
.is_dma_mapped
= USE_SPI_DMA
;
266 spi_message_add_tail(&tr
, &msg
);
267 ret
= spi_sync(spi
, &msg
);
269 dev_err(&spi
->dev
, "SPI transaction failed\n");
272 "can't read data with the following length: %u\n",
280 static int spi_cmd_complete(struct wilc
*wilc
, u8 cmd
, u32 adr
, u8
*b
, u32 sz
,
283 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
293 case CMD_SINGLE_READ
: /* single word (4 bytes) read */
294 wb
[1] = (u8
)(adr
>> 16);
295 wb
[2] = (u8
)(adr
>> 8);
300 case CMD_INTERNAL_READ
: /* internal register read */
301 wb
[1] = (u8
)(adr
>> 8);
309 case CMD_TERMINATE
: /* termination */
316 case CMD_REPEAT
: /* repeat */
323 case CMD_RESET
: /* reset */
330 case CMD_DMA_WRITE
: /* dma write */
331 case CMD_DMA_READ
: /* dma read */
332 wb
[1] = (u8
)(adr
>> 16);
333 wb
[2] = (u8
)(adr
>> 8);
335 wb
[4] = (u8
)(sz
>> 8);
340 case CMD_DMA_EXT_WRITE
: /* dma extended write */
341 case CMD_DMA_EXT_READ
: /* dma extended read */
342 wb
[1] = (u8
)(adr
>> 16);
343 wb
[2] = (u8
)(adr
>> 8);
345 wb
[4] = (u8
)(sz
>> 16);
346 wb
[5] = (u8
)(sz
>> 8);
351 case CMD_INTERNAL_WRITE
: /* internal register write */
352 wb
[1] = (u8
)(adr
>> 8);
363 case CMD_SINGLE_WRITE
: /* single word write */
364 wb
[1] = (u8
)(adr
>> 16);
365 wb
[2] = (u8
)(adr
>> 8);
383 wb
[len
- 1] = (crc7(0x7f, (const u8
*)&wb
[0], len
- 1)) << 1;
387 #define NUM_SKIP_BYTES (1)
388 #define NUM_RSP_BYTES (2)
389 #define NUM_DATA_HDR_BYTES (1)
390 #define NUM_DATA_BYTES (4)
391 #define NUM_CRC_BYTES (2)
392 #define NUM_DUMMY_BYTES (3)
393 if ((cmd
== CMD_RESET
) ||
394 (cmd
== CMD_TERMINATE
) ||
395 (cmd
== CMD_REPEAT
)) {
396 len2
= len
+ (NUM_SKIP_BYTES
+ NUM_RSP_BYTES
+ NUM_DUMMY_BYTES
);
397 } else if ((cmd
== CMD_INTERNAL_READ
) || (cmd
== CMD_SINGLE_READ
)) {
398 if (!g_spi
.crc_off
) {
399 len2
= len
+ (NUM_RSP_BYTES
+ NUM_DATA_HDR_BYTES
+ NUM_DATA_BYTES
400 + NUM_CRC_BYTES
+ NUM_DUMMY_BYTES
);
402 len2
= len
+ (NUM_RSP_BYTES
+ NUM_DATA_HDR_BYTES
+ NUM_DATA_BYTES
406 len2
= len
+ (NUM_RSP_BYTES
+ NUM_DUMMY_BYTES
);
408 #undef NUM_DUMMY_BYTES
410 if (len2
> ARRAY_SIZE(wb
)) {
411 dev_err(&spi
->dev
, "spi buffer size too small (%d) (%zu)\n",
412 len2
, ARRAY_SIZE(wb
));
416 /* zero spi write buffers. */
417 for (wix
= len
; wix
< len2
; wix
++)
421 if (wilc_spi_tx_rx(wilc
, wb
, rb
, len2
)) {
422 dev_err(&spi
->dev
, "Failed cmd write, bus error...\n");
428 * Command/Control response
430 if ((cmd
== CMD_RESET
) ||
431 (cmd
== CMD_TERMINATE
) ||
432 (cmd
== CMD_REPEAT
)) {
433 rix
++; /* skip 1 byte */
438 /* if(rsp == cmd) break; */
439 /* } while(&rptr[1] <= &rb[len2]); */
443 "Failed cmd response, cmd (%02x), resp (%02x)\n",
454 dev_err(&spi
->dev
, "Failed cmd state response state (%02x)\n",
460 if ((cmd
== CMD_INTERNAL_READ
) || (cmd
== CMD_SINGLE_READ
)
461 || (cmd
== CMD_DMA_READ
) || (cmd
== CMD_DMA_EXT_READ
)) {
463 /* u16 crc1, crc2; */
466 * Data Respnose header
470 /* ensure there is room in buffer later to read data and crc */
477 if (((rsp
>> 4) & 0xf) == 0xf)
483 "Error, data read response (%02x)\n", rsp
);
488 if ((cmd
== CMD_INTERNAL_READ
) || (cmd
== CMD_SINGLE_READ
)) {
492 if ((rix
+ 3) < len2
) {
499 "buffer overrun when reading data.\n");
504 if (!g_spi
.crc_off
) {
508 if ((rix
+ 1) < len2
) {
512 dev_err(&spi
->dev
, "buffer overrun when reading crc.\n");
517 } else if ((cmd
== CMD_DMA_READ
) || (cmd
== CMD_DMA_EXT_READ
)) {
520 /* some data may be read in response to dummy bytes. */
521 for (ix
= 0; (rix
< len2
) && (ix
< sz
); )
529 if (sz
<= (DATA_PKT_SZ
- ix
))
532 nbytes
= DATA_PKT_SZ
- ix
;
537 if (wilc_spi_rx(wilc
, &b
[ix
], nbytes
)) {
538 dev_err(&spi
->dev
, "Failed data block read, bus error...\n");
546 if (!g_spi
.crc_off
) {
547 if (wilc_spi_rx(wilc
, crc
, 2)) {
548 dev_err(&spi
->dev
, "Failed data block crc read, bus error...\n");
559 /* if any data in left unread, then read the rest using normal DMA code.*/
563 if (sz
<= DATA_PKT_SZ
)
566 nbytes
= DATA_PKT_SZ
;
569 * read data response only on the next DMA cycles not
570 * the first DMA since data response header is already
571 * handled above for the first DMA.
574 * Data Respnose header
578 if (wilc_spi_rx(wilc
, &rsp
, 1)) {
579 dev_err(&spi
->dev
, "Failed data response read, bus error...\n");
583 if (((rsp
>> 4) & 0xf) == 0xf)
587 if (result
== N_FAIL
)
594 if (wilc_spi_rx(wilc
, &b
[ix
], nbytes
)) {
595 dev_err(&spi
->dev
, "Failed data block read, bus error...\n");
603 if (!g_spi
.crc_off
) {
604 if (wilc_spi_rx(wilc
, crc
, 2)) {
605 dev_err(&spi
->dev
, "Failed data block crc read, bus error...\n");
620 static int spi_data_write(struct wilc
*wilc
, u8
*b
, u32 sz
)
622 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
625 u8 cmd
, order
, crc
[2] = {0};
633 if (sz
<= DATA_PKT_SZ
)
636 nbytes
= DATA_PKT_SZ
;
643 if (sz
<= DATA_PKT_SZ
)
649 if (sz
<= DATA_PKT_SZ
)
655 if (wilc_spi_tx(wilc
, &cmd
, 1)) {
657 "Failed data block cmd write, bus error...\n");
665 if (wilc_spi_tx(wilc
, &b
[ix
], nbytes
)) {
667 "Failed data block write, bus error...\n");
675 if (!g_spi
.crc_off
) {
676 if (wilc_spi_tx(wilc
, crc
, 2)) {
677 dev_err(&spi
->dev
, "Failed data block crc write, bus error...\n");
684 * No need to wait for response
694 /********************************************
696 * Spi Internal Read/Write Function
698 ********************************************/
700 static int spi_internal_write(struct wilc
*wilc
, u32 adr
, u32 dat
)
702 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
705 dat
= cpu_to_le32(dat
);
706 result
= spi_cmd_complete(wilc
, CMD_INTERNAL_WRITE
, adr
, (u8
*)&dat
, 4,
709 dev_err(&spi
->dev
, "Failed internal write cmd...\n");
714 static int spi_internal_read(struct wilc
*wilc
, u32 adr
, u32
*data
)
716 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
719 result
= spi_cmd_complete(wilc
, CMD_INTERNAL_READ
, adr
, (u8
*)data
, 4,
721 if (result
!= N_OK
) {
722 dev_err(&spi
->dev
, "Failed internal read cmd...\n");
726 *data
= cpu_to_le32(*data
);
731 /********************************************
735 ********************************************/
737 static int wilc_spi_write_reg(struct wilc
*wilc
, u32 addr
, u32 data
)
739 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
741 u8 cmd
= CMD_SINGLE_WRITE
;
744 data
= cpu_to_le32(data
);
746 /* Clockless register*/
747 cmd
= CMD_INTERNAL_WRITE
;
751 result
= spi_cmd_complete(wilc
, cmd
, addr
, (u8
*)&data
, 4, clockless
);
753 dev_err(&spi
->dev
, "Failed cmd, write reg (%08x)...\n", addr
);
758 static int wilc_spi_write(struct wilc
*wilc
, u32 addr
, u8
*buf
, u32 size
)
760 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
762 u8 cmd
= CMD_DMA_EXT_WRITE
;
765 * has to be greated than 4
770 result
= spi_cmd_complete(wilc
, cmd
, addr
, NULL
, size
, 0);
771 if (result
!= N_OK
) {
773 "Failed cmd, write block (%08x)...\n", addr
);
780 result
= spi_data_write(wilc
, buf
, size
);
782 dev_err(&spi
->dev
, "Failed block data write...\n");
787 static int wilc_spi_read_reg(struct wilc
*wilc
, u32 addr
, u32
*data
)
789 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
791 u8 cmd
= CMD_SINGLE_READ
;
795 /* dev_err(&spi->dev, "***** read addr %d\n\n", addr); */
796 /* Clockless register*/
797 cmd
= CMD_INTERNAL_READ
;
801 result
= spi_cmd_complete(wilc
, cmd
, addr
, (u8
*)data
, 4, clockless
);
802 if (result
!= N_OK
) {
803 dev_err(&spi
->dev
, "Failed cmd, read reg (%08x)...\n", addr
);
807 *data
= cpu_to_le32(*data
);
812 static int wilc_spi_read(struct wilc
*wilc
, u32 addr
, u8
*buf
, u32 size
)
814 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
815 u8 cmd
= CMD_DMA_EXT_READ
;
821 result
= spi_cmd_complete(wilc
, cmd
, addr
, buf
, size
, 0);
822 if (result
!= N_OK
) {
823 dev_err(&spi
->dev
, "Failed cmd, read block (%08x)...\n", addr
);
830 /********************************************
834 ********************************************/
836 static int _wilc_spi_deinit(struct wilc
*wilc
)
844 static int wilc_spi_init(struct wilc
*wilc
, bool resume
)
846 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
854 if (!wilc_spi_read_reg(wilc
, 0x1000, &chipid
)) {
855 dev_err(&spi
->dev
, "Fail cmd read chip id...\n");
861 memset(&g_spi
, 0, sizeof(struct wilc_spi
));
868 /* TODO: We can remove the CRC trials if there is a definite way to reset */
869 /* the SPI to it's initial value. */
870 if (!spi_internal_read(wilc
, WILC_SPI_PROTOCOL_OFFSET
, ®
)) {
871 /* Read failed. Try with CRC off. This might happen when module
872 * is removed but chip isn't reset*/
874 dev_err(&spi
->dev
, "Failed internal read protocol with CRC on, retyring with CRC off...\n");
875 if (!spi_internal_read(wilc
, WILC_SPI_PROTOCOL_OFFSET
, ®
)) {
876 /* Reaad failed with both CRC on and off, something went bad */
878 "Failed internal read protocol...\n");
882 if (g_spi
.crc_off
== 0) {
883 reg
&= ~0xc; /* disable crc checking */
886 if (!spi_internal_write(wilc
, WILC_SPI_PROTOCOL_OFFSET
, reg
)) {
887 dev_err(&spi
->dev
, "[wilc spi %d]: Failed internal write protocol reg...\n", __LINE__
);
895 * make sure can read back chip id correctly
897 if (!wilc_spi_read_reg(wilc
, 0x1000, &chipid
)) {
898 dev_err(&spi
->dev
, "Fail cmd read chip id...\n");
901 /* dev_err(&spi->dev, "chipid (%08x)\n", chipid); */
903 g_spi
.has_thrpt_enh
= 1;
910 static int wilc_spi_read_size(struct wilc
*wilc
, u32
*size
)
912 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
915 if (g_spi
.has_thrpt_enh
) {
916 ret
= spi_internal_read(wilc
, 0xe840 - WILC_SPI_REG_BASE
,
918 *size
= *size
& IRQ_DMA_WD_CNT_MASK
;
923 ret
= wilc_spi_read_reg(wilc
, WILC_VMM_TO_HOST_SIZE
,
927 "Failed read WILC_VMM_TO_HOST_SIZE ...\n");
930 tmp
= (byte_cnt
>> 2) & IRQ_DMA_WD_CNT_MASK
;
942 static int wilc_spi_read_int(struct wilc
*wilc
, u32
*int_status
)
944 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
947 if (g_spi
.has_thrpt_enh
) {
948 ret
= spi_internal_read(wilc
, 0xe840 - WILC_SPI_REG_BASE
,
954 ret
= wilc_spi_read_reg(wilc
, WILC_VMM_TO_HOST_SIZE
,
958 "Failed read WILC_VMM_TO_HOST_SIZE ...\n");
961 tmp
= (byte_cnt
>> 2) & IRQ_DMA_WD_CNT_MASK
;
972 wilc_spi_read_reg(wilc
, 0x1a90, &irq_flags
);
973 tmp
|= ((irq_flags
>> 27) << IRG_FLAGS_OFFSET
);
975 if (g_spi
.nint
> 5) {
976 wilc_spi_read_reg(wilc
, 0x1a94,
978 tmp
|= (((irq_flags
>> 0) & 0x7) << (IRG_FLAGS_OFFSET
+ 5));
984 unkmown_mask
= ~((1ul << g_spi
.nint
) - 1);
986 if ((tmp
>> IRG_FLAGS_OFFSET
) & unkmown_mask
) {
987 dev_err(&spi
->dev
, "Unexpected interrupt (2): j=%d, tmp=%x, mask=%x\n", j
, tmp
, unkmown_mask
);
1003 static int wilc_spi_clear_int_ext(struct wilc
*wilc
, u32 val
)
1005 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
1008 if (g_spi
.has_thrpt_enh
) {
1009 ret
= spi_internal_write(wilc
, 0xe844 - WILC_SPI_REG_BASE
,
1014 flags
= val
& (BIT(MAX_NUM_INT
) - 1);
1019 for (i
= 0; i
< g_spi
.nint
; i
++) {
1020 /* No matter what you write 1 or 0, it will clear interrupt. */
1022 ret
= wilc_spi_write_reg(wilc
, 0x10c8 + i
* 4, 1);
1029 "Failed wilc_spi_write_reg, set reg %x ...\n",
1033 for (i
= g_spi
.nint
; i
< MAX_NUM_INT
; i
++) {
1036 "Unexpected interrupt cleared %d...\n",
1046 /* select VMM table 0 */
1047 if ((val
& SEL_VMM_TBL0
) == SEL_VMM_TBL0
)
1049 /* select VMM table 1 */
1050 if ((val
& SEL_VMM_TBL1
) == SEL_VMM_TBL1
)
1053 ret
= wilc_spi_write_reg(wilc
, WILC_VMM_TBL_CTL
,
1057 "fail write reg vmm_tbl_ctl...\n");
1061 if ((val
& EN_VMM
) == EN_VMM
) {
1063 * enable vmm transfer.
1065 ret
= wilc_spi_write_reg(wilc
,
1066 WILC_VMM_CORE_CTL
, 1);
1068 dev_err(&spi
->dev
, "fail write reg vmm_core_ctl...\n");
1078 static int wilc_spi_sync_ext(struct wilc
*wilc
, int nint
)
1080 struct spi_device
*spi
= to_spi_device(wilc
->dev
);
1084 if (nint
> MAX_NUM_INT
) {
1085 dev_err(&spi
->dev
, "Too many interrupts (%d)...\n", nint
);
1092 * interrupt pin mux select
1094 ret
= wilc_spi_read_reg(wilc
, WILC_PIN_MUX_0
, ®
);
1096 dev_err(&spi
->dev
, "Failed read reg (%08x)...\n",
1101 ret
= wilc_spi_write_reg(wilc
, WILC_PIN_MUX_0
, reg
);
1103 dev_err(&spi
->dev
, "Failed write reg (%08x)...\n",
1111 ret
= wilc_spi_read_reg(wilc
, WILC_INTR_ENABLE
, ®
);
1113 dev_err(&spi
->dev
, "Failed read reg (%08x)...\n",
1118 for (i
= 0; (i
< 5) && (nint
> 0); i
++, nint
--)
1119 reg
|= (BIT((27 + i
)));
1121 ret
= wilc_spi_write_reg(wilc
, WILC_INTR_ENABLE
, reg
);
1123 dev_err(&spi
->dev
, "Failed write reg (%08x)...\n",
1128 ret
= wilc_spi_read_reg(wilc
, WILC_INTR2_ENABLE
, ®
);
1130 dev_err(&spi
->dev
, "Failed read reg (%08x)...\n",
1135 for (i
= 0; (i
< 3) && (nint
> 0); i
++, nint
--)
1138 ret
= wilc_spi_read_reg(wilc
, WILC_INTR2_ENABLE
, ®
);
1140 dev_err(&spi
->dev
, "Failed write reg (%08x)...\n",
1148 /********************************************
1150 * Global spi HIF function table
1152 ********************************************/
1153 const struct wilc_hif_func wilc_hif_spi
= {
1154 .hif_init
= wilc_spi_init
,
1155 .hif_deinit
= _wilc_spi_deinit
,
1156 .hif_read_reg
= wilc_spi_read_reg
,
1157 .hif_write_reg
= wilc_spi_write_reg
,
1158 .hif_block_rx
= wilc_spi_read
,
1159 .hif_block_tx
= wilc_spi_write
,
1160 .hif_read_int
= wilc_spi_read_int
,
1161 .hif_clear_int_ext
= wilc_spi_clear_int_ext
,
1162 .hif_read_size
= wilc_spi_read_size
,
1163 .hif_block_tx_ext
= wilc_spi_write
,
1164 .hif_block_rx_ext
= wilc_spi_read
,
1165 .hif_sync_ext
= wilc_spi_sync_ext
,