drivers/nfc/st-nci/spi.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * SPI Link Layer for ST NCI based Driver
   4  * Copyright (C) 2014-2015 STMicroelectronics SAS. All rights reserved.
   5  */
   6
   7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   8
   9 #include <linux/module.h>
  10 #include <linux/spi/spi.h>
  11 #include <linux/gpio/consumer.h>
  12 #include <linux/acpi.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/delay.h>
  15 #include <linux/nfc.h>
  16 #include <linux/of.h>
  17 #include <net/nfc/nci.h>
  18
  19 #include "st-nci.h"
  20
  21 #define DRIVER_DESC "NCI NFC driver for ST_NCI"
  22
  23 /* ndlc header */
  24 #define ST_NCI_FRAME_HEADROOM   1
  25 #define ST_NCI_FRAME_TAILROOM   0
  26
  27 #define ST_NCI_SPI_MIN_SIZE 4   /* PCB(1) + NCI Packet header(3) */
  28 #define ST_NCI_SPI_MAX_SIZE 250 /* req 4.2.1 */
  29
  30 #define ST_NCI_DRIVER_NAME "st_nci"
  31 #define ST_NCI_SPI_DRIVER_NAME "st_nci_spi"
  32
  33 struct st_nci_spi_phy {
  34         struct spi_device *spi_dev;
  35         struct llt_ndlc *ndlc;
  36
  37         bool irq_active;
  38
  39         struct gpio_desc *gpiod_reset;
  40
  41         struct st_nci_se_status se_status;
  42 };
  43
  44 static int st_nci_spi_enable(void *phy_id)
  45 {
  46         struct st_nci_spi_phy *phy = phy_id;
  47
  48         gpiod_set_value(phy->gpiod_reset, 0);
  49         usleep_range(10000, 15000);
  50         gpiod_set_value(phy->gpiod_reset, 1);
  51         usleep_range(80000, 85000);
  52
  53         if (phy->ndlc->powered == 0 && phy->irq_active == 0) {
  54                 enable_irq(phy->spi_dev->irq);
  55                 phy->irq_active = true;
  56         }
  57
  58         return 0;
  59 }
  60
  61 static void st_nci_spi_disable(void *phy_id)
  62 {
  63         struct st_nci_spi_phy *phy = phy_id;
  64
  65         disable_irq_nosync(phy->spi_dev->irq);
  66         phy->irq_active = false;
  67 }
  68
  69 /*
  70  * Writing a frame must not return the number of written bytes.
  71  * It must return either zero for success, or <0 for error.
  72  * In addition, it must not alter the skb
  73  */
  74 static int st_nci_spi_write(void *phy_id, struct sk_buff *skb)
  75 {
  76         int r;
  77         struct st_nci_spi_phy *phy = phy_id;
  78         struct spi_device *dev = phy->spi_dev;
  79         struct sk_buff *skb_rx;
  80         u8 buf[ST_NCI_SPI_MAX_SIZE + NCI_DATA_HDR_SIZE +
  81                ST_NCI_FRAME_HEADROOM + ST_NCI_FRAME_TAILROOM];
  82         struct spi_transfer spi_xfer = {
  83                 .tx_buf = skb->data,
  84                 .rx_buf = buf,
  85                 .len = skb->len,
  86         };
  87
  88         if (phy->ndlc->hard_fault != 0)
  89                 return phy->ndlc->hard_fault;
  90
  91         r = spi_sync_transfer(dev, &spi_xfer, 1);
  92         /*
  93          * We may have received some valuable data on miso line.
  94          * Send them back in the ndlc state machine.
  95          */
  96         if (!r) {
  97                 skb_rx = alloc_skb(skb->len, GFP_KERNEL);
  98                 if (!skb_rx) {
  99                         r = -ENOMEM;
 100                         goto exit;
 101                 }
 102
 103                 skb_put(skb_rx, skb->len);
 104                 memcpy(skb_rx->data, buf, skb->len);
 105                 ndlc_recv(phy->ndlc, skb_rx);
 106         }
 107
 108 exit:
 109         return r;
 110 }
 111
 112 /*
 113  * Reads an ndlc frame and returns it in a newly allocated sk_buff.
 114  * returns:
 115  * 0 : if received frame is complete
 116  * -EREMOTEIO : i2c read error (fatal)
 117  * -EBADMSG : frame was incorrect and discarded
 118  * -ENOMEM : cannot allocate skb, frame dropped
 119  */
 120 static int st_nci_spi_read(struct st_nci_spi_phy *phy,
 121                         struct sk_buff **skb)
 122 {
 123         int r;
 124         u8 len;
 125         u8 buf[ST_NCI_SPI_MAX_SIZE];
 126         struct spi_device *dev = phy->spi_dev;
 127         struct spi_transfer spi_xfer = {
 128                 .rx_buf = buf,
 129                 .len = ST_NCI_SPI_MIN_SIZE,
 130         };
 131
 132         r = spi_sync_transfer(dev, &spi_xfer, 1);
 133         if (r < 0)
 134                 return -EREMOTEIO;
 135
 136         len = be16_to_cpu(*(__be16 *) (buf + 2));
 137         if (len > ST_NCI_SPI_MAX_SIZE) {
 138                 nfc_err(&dev->dev, "invalid frame len\n");
 139                 phy->ndlc->hard_fault = 1;
 140                 return -EBADMSG;
 141         }
 142
 143         *skb = alloc_skb(ST_NCI_SPI_MIN_SIZE + len, GFP_KERNEL);
 144         if (*skb == NULL)
 145                 return -ENOMEM;
 146
 147         skb_reserve(*skb, ST_NCI_SPI_MIN_SIZE);
 148         skb_put(*skb, ST_NCI_SPI_MIN_SIZE);
 149         memcpy((*skb)->data, buf, ST_NCI_SPI_MIN_SIZE);
 150
 151         if (!len)
 152                 return 0;
 153
 154         spi_xfer.len = len;
 155         r = spi_sync_transfer(dev, &spi_xfer, 1);
 156         if (r < 0) {
 157                 kfree_skb(*skb);
 158                 return -EREMOTEIO;
 159         }
 160
 161         skb_put(*skb, len);
 162         memcpy((*skb)->data + ST_NCI_SPI_MIN_SIZE, buf, len);
 163
 164         return 0;
 165 }
 166
 167 /*
 168  * Reads an ndlc frame from the chip.
 169  *
 170  * On ST21NFCB, IRQ goes in idle state when read starts.
 171  */
 172 static irqreturn_t st_nci_irq_thread_fn(int irq, void *phy_id)
 173 {
 174         struct st_nci_spi_phy *phy = phy_id;
 175         struct spi_device *dev;
 176         struct sk_buff *skb = NULL;
 177         int r;
 178
 179         if (!phy || !phy->ndlc || irq != phy->spi_dev->irq) {
 180                 WARN_ON_ONCE(1);
 181                 return IRQ_NONE;
 182         }
 183
 184         dev = phy->spi_dev;
 185         dev_dbg(&dev->dev, "IRQ\n");
 186
 187         if (phy->ndlc->hard_fault)
 188                 return IRQ_HANDLED;
 189
 190         if (!phy->ndlc->powered) {
 191                 st_nci_spi_disable(phy);
 192                 return IRQ_HANDLED;
 193         }
 194
 195         r = st_nci_spi_read(phy, &skb);
 196         if (r == -EREMOTEIO || r == -ENOMEM || r == -EBADMSG)
 197                 return IRQ_HANDLED;
 198
 199         ndlc_recv(phy->ndlc, skb);
 200
 201         return IRQ_HANDLED;
 202 }
 203
 204 static struct nfc_phy_ops spi_phy_ops = {
 205         .write = st_nci_spi_write,
 206         .enable = st_nci_spi_enable,
 207         .disable = st_nci_spi_disable,
 208 };
 209
 210 static const struct acpi_gpio_params reset_gpios = { 1, 0, false };
 211
 212 static const struct acpi_gpio_mapping acpi_st_nci_gpios[] = {
 213         { "reset-gpios", &reset_gpios, 1 },
 214         {},
 215 };
 216
 217 static int st_nci_spi_probe(struct spi_device *dev)
 218 {
 219         struct st_nci_spi_phy *phy;
 220         int r;
 221
 222         dev_dbg(&dev->dev, "%s\n", __func__);
 223         dev_dbg(&dev->dev, "IRQ: %d\n", dev->irq);
 224
 225         /* Check SPI platform functionnalities */
 226         if (!dev) {
 227                 pr_debug("%s: dev is NULL. Device is not accessible.\n",
 228                         __func__);
 229                 return -ENODEV;
 230         }
 231
 232         phy = devm_kzalloc(&dev->dev, sizeof(struct st_nci_spi_phy),
 233                            GFP_KERNEL);
 234         if (!phy)
 235                 return -ENOMEM;
 236
 237         phy->spi_dev = dev;
 238
 239         spi_set_drvdata(dev, phy);
 240
 241         r = devm_acpi_dev_add_driver_gpios(&dev->dev, acpi_st_nci_gpios);
 242         if (r)
 243                 dev_dbg(&dev->dev, "Unable to add GPIO mapping table\n");
 244
 245         /* Get RESET GPIO */
 246         phy->gpiod_reset = devm_gpiod_get(&dev->dev, "reset", GPIOD_OUT_HIGH);
 247         if (IS_ERR(phy->gpiod_reset)) {
 248                 nfc_err(&dev->dev, "Unable to get RESET GPIO\n");
 249                 return PTR_ERR(phy->gpiod_reset);
 250         }
 251
 252         phy->se_status.is_ese_present =
 253                         device_property_read_bool(&dev->dev, "ese-present");
 254         phy->se_status.is_uicc_present =
 255                         device_property_read_bool(&dev->dev, "uicc-present");
 256
 257         r = ndlc_probe(phy, &spi_phy_ops, &dev->dev,
 258                         ST_NCI_FRAME_HEADROOM, ST_NCI_FRAME_TAILROOM,
 259                         &phy->ndlc, &phy->se_status);
 260         if (r < 0) {
 261                 nfc_err(&dev->dev, "Unable to register ndlc layer\n");
 262                 return r;
 263         }
 264
 265         phy->irq_active = true;
 266         r = devm_request_threaded_irq(&dev->dev, dev->irq, NULL,
 267                                 st_nci_irq_thread_fn,
 268                                 IRQF_ONESHOT,
 269                                 ST_NCI_SPI_DRIVER_NAME, phy);
 270         if (r < 0)
 271                 nfc_err(&dev->dev, "Unable to register IRQ handler\n");
 272
 273         return r;
 274 }
 275
 276 static int st_nci_spi_remove(struct spi_device *dev)
 277 {
 278         struct st_nci_spi_phy *phy = spi_get_drvdata(dev);
 279
 280         dev_dbg(&dev->dev, "%s\n", __func__);
 281
 282         ndlc_remove(phy->ndlc);
 283
 284         return 0;
 285 }
 286
 287 static struct spi_device_id st_nci_spi_id_table[] = {
 288         {ST_NCI_SPI_DRIVER_NAME, 0},
 289         {}
 290 };
 291 MODULE_DEVICE_TABLE(spi, st_nci_spi_id_table);
 292
 293 static const struct acpi_device_id st_nci_spi_acpi_match[] = {
 294         {"SMO2101", 0},
 295         {}
 296 };
 297 MODULE_DEVICE_TABLE(acpi, st_nci_spi_acpi_match);
 298
 299 static const struct of_device_id of_st_nci_spi_match[] = {
 300         { .compatible = "st,st21nfcb-spi", },
 301         {}
 302 };
 303 MODULE_DEVICE_TABLE(of, of_st_nci_spi_match);
 304
 305 static struct spi_driver st_nci_spi_driver = {
 306         .driver = {
 307                 .name = ST_NCI_SPI_DRIVER_NAME,
 308                 .of_match_table = of_match_ptr(of_st_nci_spi_match),
 309                 .acpi_match_table = ACPI_PTR(st_nci_spi_acpi_match),
 310         },
 311         .probe = st_nci_spi_probe,
 312         .id_table = st_nci_spi_id_table,
 313         .remove = st_nci_spi_remove,
 314 };
 315 module_spi_driver(st_nci_spi_driver);
 316
 317 MODULE_LICENSE("GPL");
 318 MODULE_DESCRIPTION(DRIVER_DESC);