drivers/nfc/st-nci/i2c.c

   1 /*
   2  * I2C Link Layer for ST NCI NFC controller familly based Driver
   3  * Copyright (C) 2014-2015 STMicroelectronics SAS. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  19
  20 #include <linux/module.h>
  21 #include <linux/i2c.h>
  22 #include <linux/gpio.h>
  23 #include <linux/of_irq.h>
  24 #include <linux/of_gpio.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/delay.h>
  27 #include <linux/nfc.h>
  28 #include <linux/platform_data/st-nci.h>
  29
  30 #include "ndlc.h"
  31
  32 #define DRIVER_DESC "NCI NFC driver for ST_NCI"
  33
  34 /* ndlc header */
  35 #define ST_NCI_FRAME_HEADROOM   1
  36 #define ST_NCI_FRAME_TAILROOM 0
  37
  38 #define ST_NCI_I2C_MIN_SIZE 4   /* PCB(1) + NCI Packet header(3) */
  39 #define ST_NCI_I2C_MAX_SIZE 250 /* req 4.2.1 */
  40
  41 #define ST_NCI_I2C_DRIVER_NAME "st_nci_i2c"
  42
  43 static struct i2c_device_id st_nci_i2c_id_table[] = {
  44         {ST_NCI_DRIVER_NAME, 0},
  45         {}
  46 };
  47 MODULE_DEVICE_TABLE(i2c, st_nci_i2c_id_table);
  48
  49 struct st_nci_i2c_phy {
  50         struct i2c_client *i2c_dev;
  51         struct llt_ndlc *ndlc;
  52
  53         unsigned int gpio_reset;
  54         unsigned int irq_polarity;
  55 };
  56
  57 #define I2C_DUMP_SKB(info, skb)                                 \
  58 do {                                                            \
  59         pr_debug("%s:\n", info);                                \
  60         print_hex_dump(KERN_DEBUG, "i2c: ", DUMP_PREFIX_OFFSET, \
  61                        16, 1, (skb)->data, (skb)->len, 0);      \
  62 } while (0)
  63
  64 static int st_nci_i2c_enable(void *phy_id)
  65 {
  66         struct st_nci_i2c_phy *phy = phy_id;
  67
  68         gpio_set_value(phy->gpio_reset, 0);
  69         usleep_range(10000, 15000);
  70         gpio_set_value(phy->gpio_reset, 1);
  71         usleep_range(80000, 85000);
  72
  73         if (phy->ndlc->powered == 0)
  74                 enable_irq(phy->i2c_dev->irq);
  75
  76         return 0;
  77 }
  78
  79 static void st_nci_i2c_disable(void *phy_id)
  80 {
  81         struct st_nci_i2c_phy *phy = phy_id;
  82
  83         disable_irq_nosync(phy->i2c_dev->irq);
  84 }
  85
  86 /*
  87  * Writing a frame must not return the number of written bytes.
  88  * It must return either zero for success, or <0 for error.
  89  * In addition, it must not alter the skb
  90  */
  91 static int st_nci_i2c_write(void *phy_id, struct sk_buff *skb)
  92 {
  93         int r = -1;
  94         struct st_nci_i2c_phy *phy = phy_id;
  95         struct i2c_client *client = phy->i2c_dev;
  96
  97         I2C_DUMP_SKB("st_nci_i2c_write", skb);
  98
  99         if (phy->ndlc->hard_fault != 0)
 100                 return phy->ndlc->hard_fault;
 101
 102         r = i2c_master_send(client, skb->data, skb->len);
 103         if (r < 0) {  /* Retry, chip was in standby */
 104                 usleep_range(1000, 4000);
 105                 r = i2c_master_send(client, skb->data, skb->len);
 106         }
 107
 108         if (r >= 0) {
 109                 if (r != skb->len)
 110                         r = -EREMOTEIO;
 111                 else
 112                         r = 0;
 113         }
 114
 115         return r;
 116 }
 117
 118 /*
 119  * Reads an ndlc frame and returns it in a newly allocated sk_buff.
 120  * returns:
 121  * 0 : if received frame is complete
 122  * -EREMOTEIO : i2c read error (fatal)
 123  * -EBADMSG : frame was incorrect and discarded
 124  * -ENOMEM : cannot allocate skb, frame dropped
 125  */
 126 static int st_nci_i2c_read(struct st_nci_i2c_phy *phy,
 127                                  struct sk_buff **skb)
 128 {
 129         int r;
 130         u8 len;
 131         u8 buf[ST_NCI_I2C_MAX_SIZE];
 132         struct i2c_client *client = phy->i2c_dev;
 133
 134         r = i2c_master_recv(client, buf, ST_NCI_I2C_MIN_SIZE);
 135         if (r < 0) {  /* Retry, chip was in standby */
 136                 usleep_range(1000, 4000);
 137                 r = i2c_master_recv(client, buf, ST_NCI_I2C_MIN_SIZE);
 138         }
 139
 140         if (r != ST_NCI_I2C_MIN_SIZE)
 141                 return -EREMOTEIO;
 142
 143         len = be16_to_cpu(*(__be16 *) (buf + 2));
 144         if (len > ST_NCI_I2C_MAX_SIZE) {
 145                 nfc_err(&client->dev, "invalid frame len\n");
 146                 return -EBADMSG;
 147         }
 148
 149         *skb = alloc_skb(ST_NCI_I2C_MIN_SIZE + len, GFP_KERNEL);
 150         if (*skb == NULL)
 151                 return -ENOMEM;
 152
 153         skb_reserve(*skb, ST_NCI_I2C_MIN_SIZE);
 154         skb_put(*skb, ST_NCI_I2C_MIN_SIZE);
 155         memcpy((*skb)->data, buf, ST_NCI_I2C_MIN_SIZE);
 156
 157         if (!len)
 158                 return 0;
 159
 160         r = i2c_master_recv(client, buf, len);
 161         if (r != len) {
 162                 kfree_skb(*skb);
 163                 return -EREMOTEIO;
 164         }
 165
 166         skb_put(*skb, len);
 167         memcpy((*skb)->data + ST_NCI_I2C_MIN_SIZE, buf, len);
 168
 169         I2C_DUMP_SKB("i2c frame read", *skb);
 170
 171         return 0;
 172 }
 173
 174 /*
 175  * Reads an ndlc frame from the chip.
 176  *
 177  * On ST_NCI, IRQ goes in idle state when read starts.
 178  */
 179 static irqreturn_t st_nci_irq_thread_fn(int irq, void *phy_id)
 180 {
 181         struct st_nci_i2c_phy *phy = phy_id;
 182         struct i2c_client *client;
 183         struct sk_buff *skb = NULL;
 184         int r;
 185
 186         if (!phy || !phy->ndlc || irq != phy->i2c_dev->irq) {
 187                 WARN_ON_ONCE(1);
 188                 return IRQ_NONE;
 189         }
 190
 191         client = phy->i2c_dev;
 192         dev_dbg(&client->dev, "IRQ\n");
 193
 194         if (phy->ndlc->hard_fault)
 195                 return IRQ_HANDLED;
 196
 197         if (!phy->ndlc->powered) {
 198                 st_nci_i2c_disable(phy);
 199                 return IRQ_HANDLED;
 200         }
 201
 202         r = st_nci_i2c_read(phy, &skb);
 203         if (r == -EREMOTEIO || r == -ENOMEM || r == -EBADMSG)
 204                 return IRQ_HANDLED;
 205
 206         ndlc_recv(phy->ndlc, skb);
 207
 208         return IRQ_HANDLED;
 209 }
 210
 211 static struct nfc_phy_ops i2c_phy_ops = {
 212         .write = st_nci_i2c_write,
 213         .enable = st_nci_i2c_enable,
 214         .disable = st_nci_i2c_disable,
 215 };
 216
 217 #ifdef CONFIG_OF
 218 static int st_nci_i2c_of_request_resources(struct i2c_client *client)
 219 {
 220         struct st_nci_i2c_phy *phy = i2c_get_clientdata(client);
 221         struct device_node *pp;
 222         int gpio;
 223         int r;
 224
 225         pp = client->dev.of_node;
 226         if (!pp)
 227                 return -ENODEV;
 228
 229         /* Get GPIO from device tree */
 230         gpio = of_get_named_gpio(pp, "reset-gpios", 0);
 231         if (gpio < 0) {
 232                 nfc_err(&client->dev,
 233                         "Failed to retrieve reset-gpios from device tree\n");
 234                 return gpio;
 235         }
 236
 237         /* GPIO request and configuration */
 238         r = devm_gpio_request_one(&client->dev, gpio,
 239                                 GPIOF_OUT_INIT_HIGH, "clf_reset");
 240         if (r) {
 241                 nfc_err(&client->dev, "Failed to request reset pin\n");
 242                 return r;
 243         }
 244         phy->gpio_reset = gpio;
 245
 246         phy->irq_polarity = irq_get_trigger_type(client->irq);
 247
 248         return 0;
 249 }
 250 #else
 251 static int st_nci_i2c_of_request_resources(struct i2c_client *client)
 252 {
 253         return -ENODEV;
 254 }
 255 #endif
 256
 257 static int st_nci_i2c_request_resources(struct i2c_client *client)
 258 {
 259         struct st_nci_nfc_platform_data *pdata;
 260         struct st_nci_i2c_phy *phy = i2c_get_clientdata(client);
 261         int r;
 262
 263         pdata = client->dev.platform_data;
 264         if (pdata == NULL) {
 265                 nfc_err(&client->dev, "No platform data\n");
 266                 return -EINVAL;
 267         }
 268
 269         /* store for later use */
 270         phy->gpio_reset = pdata->gpio_reset;
 271         phy->irq_polarity = pdata->irq_polarity;
 272
 273         r = devm_gpio_request_one(&client->dev,
 274                         phy->gpio_reset, GPIOF_OUT_INIT_HIGH, "clf_reset");
 275         if (r) {
 276                 pr_err("%s : reset gpio_request failed\n", __FILE__);
 277                 return r;
 278         }
 279
 280         return 0;
 281 }
 282
 283 static int st_nci_i2c_probe(struct i2c_client *client,
 284                                   const struct i2c_device_id *id)
 285 {
 286         struct st_nci_i2c_phy *phy;
 287         struct st_nci_nfc_platform_data *pdata;
 288         int r;
 289
 290         dev_dbg(&client->dev, "%s\n", __func__);
 291         dev_dbg(&client->dev, "IRQ: %d\n", client->irq);
 292
 293         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 294                 nfc_err(&client->dev, "Need I2C_FUNC_I2C\n");
 295                 return -ENODEV;
 296         }
 297
 298         phy = devm_kzalloc(&client->dev, sizeof(struct st_nci_i2c_phy),
 299                            GFP_KERNEL);
 300         if (!phy)
 301                 return -ENOMEM;
 302
 303         phy->i2c_dev = client;
 304
 305         i2c_set_clientdata(client, phy);
 306
 307         pdata = client->dev.platform_data;
 308         if (!pdata && client->dev.of_node) {
 309                 r = st_nci_i2c_of_request_resources(client);
 310                 if (r) {
 311                         nfc_err(&client->dev, "No platform data\n");
 312                         return r;
 313                 }
 314         } else if (pdata) {
 315                 r = st_nci_i2c_request_resources(client);
 316                 if (r) {
 317                         nfc_err(&client->dev,
 318                                 "Cannot get platform resources\n");
 319                         return r;
 320                 }
 321         } else {
 322                 nfc_err(&client->dev,
 323                         "st_nci platform resources not available\n");
 324                 return -ENODEV;
 325         }
 326
 327         r = ndlc_probe(phy, &i2c_phy_ops, &client->dev,
 328                         ST_NCI_FRAME_HEADROOM, ST_NCI_FRAME_TAILROOM,
 329                         &phy->ndlc);
 330         if (r < 0) {
 331                 nfc_err(&client->dev, "Unable to register ndlc layer\n");
 332                 return r;
 333         }
 334
 335         r = devm_request_threaded_irq(&client->dev, client->irq, NULL,
 336                                 st_nci_irq_thread_fn,
 337                                 phy->irq_polarity | IRQF_ONESHOT,
 338                                 ST_NCI_DRIVER_NAME, phy);
 339         if (r < 0)
 340                 nfc_err(&client->dev, "Unable to register IRQ handler\n");
 341
 342         return r;
 343 }
 344
 345 static int st_nci_i2c_remove(struct i2c_client *client)
 346 {
 347         struct st_nci_i2c_phy *phy = i2c_get_clientdata(client);
 348
 349         dev_dbg(&client->dev, "%s\n", __func__);
 350
 351         ndlc_remove(phy->ndlc);
 352
 353         return 0;
 354 }
 355
 356 #ifdef CONFIG_OF
 357 static const struct of_device_id of_st_nci_i2c_match[] = {
 358         { .compatible = "st,st21nfcb-i2c", },
 359         { .compatible = "st,st21nfcb_i2c", },
 360         { .compatible = "st,st21nfcc-i2c", },
 361         {}
 362 };
 363 MODULE_DEVICE_TABLE(of, of_st_nci_i2c_match);
 364 #endif
 365
 366 static struct i2c_driver st_nci_i2c_driver = {
 367         .driver = {
 368                 .owner = THIS_MODULE,
 369                 .name = ST_NCI_I2C_DRIVER_NAME,
 370                 .of_match_table = of_match_ptr(of_st_nci_i2c_match),
 371         },
 372         .probe = st_nci_i2c_probe,
 373         .id_table = st_nci_i2c_id_table,
 374         .remove = st_nci_i2c_remove,
 375 };
 376
 377 module_i2c_driver(st_nci_i2c_driver);
 378
 379 MODULE_LICENSE("GPL");
 380 MODULE_DESCRIPTION(DRIVER_DESC);