1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) 2013 Intel Corporation. All rights reserved.
6 #define pr_fmt(fmt) "nci_spi: %s: " fmt, __func__
8 #include <linux/module.h>
10 #include <linux/export.h>
11 #include <linux/spi/spi.h>
12 #include <linux/crc-ccitt.h>
13 #include <net/nfc/nci_core.h>
15 #define NCI_SPI_ACK_SHIFT 6
16 #define NCI_SPI_MSB_PAYLOAD_MASK 0x3F
18 #define NCI_SPI_SEND_TIMEOUT (NCI_CMD_TIMEOUT > NCI_DATA_TIMEOUT ? \
19 NCI_CMD_TIMEOUT : NCI_DATA_TIMEOUT)
21 #define NCI_SPI_DIRECT_WRITE 0x01
22 #define NCI_SPI_DIRECT_READ 0x02
24 #define ACKNOWLEDGE_NONE 0
25 #define ACKNOWLEDGE_ACK 1
26 #define ACKNOWLEDGE_NACK 2
28 #define CRC_INIT 0xFFFF
30 static int __nci_spi_send(struct nci_spi
*nspi
, struct sk_buff
*skb
,
34 struct spi_transfer t
;
36 memset(&t
, 0, sizeof(struct spi_transfer
));
37 /* a NULL skb means we just want the SPI chip select line to raise */
42 /* still set tx_buf non NULL to make the driver happy */
46 t
.cs_change
= cs_change
;
47 t
.delay
.value
= nspi
->xfer_udelay
;
48 t
.delay
.unit
= SPI_DELAY_UNIT_USECS
;
49 t
.speed_hz
= nspi
->xfer_speed_hz
;
52 spi_message_add_tail(&t
, &m
);
54 return spi_sync(nspi
->spi
, &m
);
57 int nci_spi_send(struct nci_spi
*nspi
,
58 struct completion
*write_handshake_completion
,
61 unsigned int payload_len
= skb
->len
;
66 /* add the NCI SPI header to the start of the buffer */
67 hdr
= skb_push(skb
, NCI_SPI_HDR_LEN
);
68 hdr
[0] = NCI_SPI_DIRECT_WRITE
;
69 hdr
[1] = nspi
->acknowledge_mode
;
70 hdr
[2] = payload_len
>> 8;
71 hdr
[3] = payload_len
& 0xFF;
73 if (nspi
->acknowledge_mode
== NCI_SPI_CRC_ENABLED
) {
76 crc
= crc_ccitt(CRC_INIT
, skb
->data
, skb
->len
);
77 skb_put_u8(skb
, crc
>> 8);
78 skb_put_u8(skb
, crc
& 0xFF);
81 if (write_handshake_completion
) {
82 /* Trick SPI driver to raise chip select */
83 ret
= __nci_spi_send(nspi
, NULL
, 1);
87 /* wait for NFC chip hardware handshake to complete */
88 if (wait_for_completion_timeout(write_handshake_completion
,
89 msecs_to_jiffies(1000)) == 0) {
95 ret
= __nci_spi_send(nspi
, skb
, 0);
96 if (ret
!= 0 || nspi
->acknowledge_mode
== NCI_SPI_CRC_DISABLED
)
99 reinit_completion(&nspi
->req_completion
);
100 completion_rc
= wait_for_completion_interruptible_timeout(
101 &nspi
->req_completion
,
102 NCI_SPI_SEND_TIMEOUT
);
104 if (completion_rc
<= 0 || nspi
->req_result
== ACKNOWLEDGE_NACK
)
112 EXPORT_SYMBOL_GPL(nci_spi_send
);
114 /* ---- Interface to NCI SPI drivers ---- */
117 * nci_spi_allocate_spi - allocate a new nci spi
120 * @acknowledge_mode: Acknowledge mode used by the NFC device
121 * @delay: delay between transactions in us
122 * @ndev: nci dev to send incoming nci frames to
124 struct nci_spi
*nci_spi_allocate_spi(struct spi_device
*spi
,
125 u8 acknowledge_mode
, unsigned int delay
,
126 struct nci_dev
*ndev
)
128 struct nci_spi
*nspi
;
130 nspi
= devm_kzalloc(&spi
->dev
, sizeof(struct nci_spi
), GFP_KERNEL
);
134 nspi
->acknowledge_mode
= acknowledge_mode
;
135 nspi
->xfer_udelay
= delay
;
136 /* Use controller max SPI speed by default */
137 nspi
->xfer_speed_hz
= 0;
140 init_completion(&nspi
->req_completion
);
144 EXPORT_SYMBOL_GPL(nci_spi_allocate_spi
);
146 static int send_acknowledge(struct nci_spi
*nspi
, u8 acknowledge
)
153 skb
= nci_skb_alloc(nspi
->ndev
, 0, GFP_KERNEL
);
155 /* add the NCI SPI header to the start of the buffer */
156 hdr
= skb_push(skb
, NCI_SPI_HDR_LEN
);
157 hdr
[0] = NCI_SPI_DIRECT_WRITE
;
158 hdr
[1] = NCI_SPI_CRC_ENABLED
;
159 hdr
[2] = acknowledge
<< NCI_SPI_ACK_SHIFT
;
162 crc
= crc_ccitt(CRC_INIT
, skb
->data
, skb
->len
);
163 skb_put_u8(skb
, crc
>> 8);
164 skb_put_u8(skb
, crc
& 0xFF);
166 ret
= __nci_spi_send(nspi
, skb
, 0);
173 static struct sk_buff
*__nci_spi_read(struct nci_spi
*nspi
)
176 struct spi_message m
;
177 unsigned char req
[2], resp_hdr
[2];
178 struct spi_transfer tx
, rx
;
179 unsigned short rx_len
= 0;
182 spi_message_init(&m
);
184 memset(&tx
, 0, sizeof(struct spi_transfer
));
185 req
[0] = NCI_SPI_DIRECT_READ
;
186 req
[1] = nspi
->acknowledge_mode
;
190 tx
.speed_hz
= nspi
->xfer_speed_hz
;
191 spi_message_add_tail(&tx
, &m
);
193 memset(&rx
, 0, sizeof(struct spi_transfer
));
194 rx
.rx_buf
= resp_hdr
;
197 rx
.speed_hz
= nspi
->xfer_speed_hz
;
198 spi_message_add_tail(&rx
, &m
);
200 ret
= spi_sync(nspi
->spi
, &m
);
204 if (nspi
->acknowledge_mode
== NCI_SPI_CRC_ENABLED
)
205 rx_len
= ((resp_hdr
[0] & NCI_SPI_MSB_PAYLOAD_MASK
) << 8) +
206 resp_hdr
[1] + NCI_SPI_CRC_LEN
;
208 rx_len
= (resp_hdr
[0] << 8) | resp_hdr
[1];
210 skb
= nci_skb_alloc(nspi
->ndev
, rx_len
, GFP_KERNEL
);
214 spi_message_init(&m
);
216 memset(&rx
, 0, sizeof(struct spi_transfer
));
217 rx
.rx_buf
= skb_put(skb
, rx_len
);
220 rx
.delay
.value
= nspi
->xfer_udelay
;
221 rx
.delay
.unit
= SPI_DELAY_UNIT_USECS
;
222 rx
.speed_hz
= nspi
->xfer_speed_hz
;
223 spi_message_add_tail(&rx
, &m
);
225 ret
= spi_sync(nspi
->spi
, &m
);
229 if (nspi
->acknowledge_mode
== NCI_SPI_CRC_ENABLED
) {
230 *(u8
*)skb_push(skb
, 1) = resp_hdr
[1];
231 *(u8
*)skb_push(skb
, 1) = resp_hdr
[0];
242 static int nci_spi_check_crc(struct sk_buff
*skb
)
244 u16 crc_data
= (skb
->data
[skb
->len
- 2] << 8) |
245 skb
->data
[skb
->len
- 1];
248 ret
= (crc_ccitt(CRC_INIT
, skb
->data
, skb
->len
- NCI_SPI_CRC_LEN
)
251 skb_trim(skb
, skb
->len
- NCI_SPI_CRC_LEN
);
256 static u8
nci_spi_get_ack(struct sk_buff
*skb
)
260 ret
= skb
->data
[0] >> NCI_SPI_ACK_SHIFT
;
262 /* Remove NFCC part of the header: ACK, NACK and MSB payload len */
269 * nci_spi_read - read frame from NCI SPI drivers
274 * This call may only be used from a context that may sleep. The sleep
275 * is non-interruptible, and has no timeout.
277 * It returns an allocated skb containing the frame on success, or NULL.
279 struct sk_buff
*nci_spi_read(struct nci_spi
*nspi
)
283 /* Retrieve frame from SPI */
284 skb
= __nci_spi_read(nspi
);
288 if (nspi
->acknowledge_mode
== NCI_SPI_CRC_ENABLED
) {
289 if (!nci_spi_check_crc(skb
)) {
290 send_acknowledge(nspi
, ACKNOWLEDGE_NACK
);
294 /* In case of acknowledged mode: if ACK or NACK received,
295 * unblock completion of latest frame sent.
297 nspi
->req_result
= nci_spi_get_ack(skb
);
298 if (nspi
->req_result
)
299 complete(&nspi
->req_completion
);
302 /* If there is no payload (ACK/NACK only frame),
303 * free the socket buffer
311 if (nspi
->acknowledge_mode
== NCI_SPI_CRC_ENABLED
)
312 send_acknowledge(nspi
, ACKNOWLEDGE_ACK
);
318 EXPORT_SYMBOL_GPL(nci_spi_read
);
320 MODULE_LICENSE("GPL");