NFC: Add NCI over SPI receive

Before any operation, driver interruption is de-asserted to prevent
race condition between TX and RX.

Transaction starts by emitting "Direct read" and acknowledged mode
bytes. Then packet length is read allowing to allocate correct NCI
socket buffer. After that payload is retrieved.

A delay after the transaction can be added.
This delay is determined by the driver during nci_spi_allocate_device()
call and can be 0.

If acknowledged mode is set:
- CRC of header and payload is checked
- if frame reception fails (CRC error): NACK is sent
- if received frame has ACK or NACK flag: unblock nci_spi_send()

Payload is passed to NCI module.

At the end, driver interruption is re asserted.

Signed-off-by: Frederic Danis <frederic.danis@linux.intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>

diff --git a/include/net/nfc/nci_core.h b/include/net/nfc/nci_core.h
index 36df525d2ab38aefaaab5b44abb17e549bfd7bf4..fc1296db237b9fa6fcdaef7826472039f26164d5 100644 (file)
--- a/include/net/nfc/nci_core.h
+++ b/include/net/nfc/nci_core.h
@@ -242,6 +242,7 @@ struct nci_spi_dev *nci_spi_allocate_device(struct spi_device *spi,
 void nci_spi_free_device(struct nci_spi_dev *ndev);
 int nci_spi_register_device(struct nci_spi_dev *ndev);
 void nci_spi_unregister_device(struct nci_spi_dev *ndev);
+int nci_spi_recv_frame(struct nci_spi_dev *ndev);
 
 static inline void nci_spi_set_drvdata(struct nci_spi_dev *ndev,
                                            void *data)

diff --git a/net/nfc/nci/spi.c b/net/nfc/nci/spi.c
index 6258461e6998f93f0e05b221446f7c480792eb97..70afc387a9659f1bb28ea977b28aaebcfe8bc6c0 100644 (file)
--- a/net/nfc/nci/spi.c
+++ b/net/nfc/nci/spi.c
@@ -26,6 +26,8 @@
 
 #define NCI_SPI_HDR_LEN                        4
 #define NCI_SPI_CRC_LEN                        2
+#define NCI_SPI_ACK_SHIFT              6
+#define NCI_SPI_MSB_PAYLOAD_MASK       0x3F
 
 #define NCI_SPI_SEND_TIMEOUT   (NCI_CMD_TIMEOUT > NCI_DATA_TIMEOUT ? \
                                        NCI_CMD_TIMEOUT : NCI_DATA_TIMEOUT)
@@ -203,3 +205,175 @@ void nci_spi_unregister_device(struct nci_spi_dev *ndev)
        nci_unregister_device(ndev->nci_dev);
 }
 EXPORT_SYMBOL_GPL(nci_spi_unregister_device);
+
+static int send_acknowledge(struct nci_spi_dev *ndev, u8 acknowledge)
+{
+       struct sk_buff *skb;
+       unsigned char *hdr;
+       u16 crc;
+       int ret;
+
+       skb = nci_skb_alloc(ndev->nci_dev, 0, GFP_KERNEL);
+
+       /* add the NCI SPI header to the start of the buffer */
+       hdr = skb_push(skb, NCI_SPI_HDR_LEN);
+       hdr[0] = NCI_SPI_DIRECT_WRITE;
+       hdr[1] = NCI_SPI_CRC_ENABLED;
+       hdr[2] = acknowledge << NCI_SPI_ACK_SHIFT;
+       hdr[3] = 0;
+
+       crc = crc_ccitt(CRC_INIT, skb->data, skb->len);
+       *skb_put(skb, 1) = crc >> 8;
+       *skb_put(skb, 1) = crc & 0xFF;
+
+       ret = __nci_spi_send(ndev, skb);
+
+       kfree_skb(skb);
+
+       return ret;
+}
+
+static struct sk_buff *__nci_spi_recv_frame(struct nci_spi_dev *ndev)
+{
+       struct sk_buff *skb;
+       struct spi_message m;
+       unsigned char req[2], resp_hdr[2];
+       struct spi_transfer tx, rx;
+       unsigned short rx_len = 0;
+       int ret;
+
+       spi_message_init(&m);
+       req[0] = NCI_SPI_DIRECT_READ;
+       req[1] = ndev->acknowledge_mode;
+       tx.tx_buf = req;
+       tx.len = 2;
+       tx.cs_change = 0;
+       spi_message_add_tail(&tx, &m);
+       rx.rx_buf = resp_hdr;
+       rx.len = 2;
+       rx.cs_change = 1;
+       spi_message_add_tail(&rx, &m);
+       ret = spi_sync(ndev->spi, &m);
+
+       if (ret)
+               return NULL;
+
+       if (ndev->acknowledge_mode == NCI_SPI_CRC_ENABLED)
+               rx_len = ((resp_hdr[0] & NCI_SPI_MSB_PAYLOAD_MASK) << 8) +
+                               resp_hdr[1] + NCI_SPI_CRC_LEN;
+       else
+               rx_len = (resp_hdr[0] << 8) | resp_hdr[1];
+
+       skb = nci_skb_alloc(ndev->nci_dev, rx_len, GFP_KERNEL);
+       if (!skb)
+               return NULL;
+
+       spi_message_init(&m);
+       rx.rx_buf = skb_put(skb, rx_len);
+       rx.len = rx_len;
+       rx.cs_change = 0;
+       rx.delay_usecs = ndev->xfer_udelay;
+       spi_message_add_tail(&rx, &m);
+       ret = spi_sync(ndev->spi, &m);
+
+       if (ret)
+               goto receive_error;
+
+       if (ndev->acknowledge_mode == NCI_SPI_CRC_ENABLED) {
+               *skb_push(skb, 1) = resp_hdr[1];
+               *skb_push(skb, 1) = resp_hdr[0];
+       }
+
+       return skb;
+
+receive_error:
+       kfree_skb(skb);
+
+       return NULL;
+}
+
+static int nci_spi_check_crc(struct sk_buff *skb)
+{
+       u16 crc_data = (skb->data[skb->len - 2] << 8) |
+                       skb->data[skb->len - 1];
+       int ret;
+
+       ret = (crc_ccitt(CRC_INIT, skb->data, skb->len - NCI_SPI_CRC_LEN)
+                       == crc_data);
+
+       skb_trim(skb, skb->len - NCI_SPI_CRC_LEN);
+
+       return ret;
+}
+
+static u8 nci_spi_get_ack(struct sk_buff *skb)
+{
+       u8 ret;
+
+       ret = skb->data[0] >> NCI_SPI_ACK_SHIFT;
+
+       /* Remove NFCC part of the header: ACK, NACK and MSB payload len */
+       skb_pull(skb, 2);
+
+       return ret;
+}
+
+/**
+ * nci_spi_recv_frame - receive frame from NCI SPI drivers
+ *
+ * @ndev: The nci spi device
+ * Context: can sleep
+ *
+ * This call may only be used from a context that may sleep.  The sleep
+ * is non-interruptible, and has no timeout.
+ *
+ * It returns zero on success, else a negative error code.
+ */
+int nci_spi_recv_frame(struct nci_spi_dev *ndev)
+{
+       struct sk_buff *skb;
+       int ret = 0;
+
+       ndev->ops->deassert_int(ndev);
+
+       /* Retrieve frame from SPI */
+       skb = __nci_spi_recv_frame(ndev);
+       if (!skb) {
+               ret = -EIO;
+               goto done;
+       }
+
+       if (ndev->acknowledge_mode == NCI_SPI_CRC_ENABLED) {
+               if (!nci_spi_check_crc(skb)) {
+                       send_acknowledge(ndev, ACKNOWLEDGE_NACK);
+                       goto done;
+               }
+
+               /* In case of acknowledged mode: if ACK or NACK received,
+                * unblock completion of latest frame sent.
+                */
+               ndev->req_result = nci_spi_get_ack(skb);
+               if (ndev->req_result)
+                       complete(&ndev->req_completion);
+       }
+
+       /* If there is no payload (ACK/NACK only frame),
+        * free the socket buffer
+        */
+       if (skb->len == 0) {
+               kfree_skb(skb);
+               goto done;
+       }
+
+       if (ndev->acknowledge_mode == NCI_SPI_CRC_ENABLED)
+               send_acknowledge(ndev, ACKNOWLEDGE_ACK);
+
+       /* Forward skb to NCI core layer */
+       ret = nci_recv_frame(ndev->nci_dev, skb);
+
+done:
+       ndev->ops->assert_int(ndev);
+
+       return ret;
+}
+EXPORT_SYMBOL_GPL(nci_spi_recv_frame);