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 ST21NFCB"
  33
  34 /* ndlc header */
  35 #define ST21NFCB_FRAME_HEADROOM 1
  36 #define ST21NFCB_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  * frame size : if received frame is complete (find ST21NFCB_SOF_EOF at
 122  * end of read)
 123  * -EAGAIN : if received frame is incomplete (not find ST21NFCB_SOF_EOF
 124  * at end of read)
 125  * -EREMOTEIO : i2c read error (fatal)
 126  * -EBADMSG : frame was incorrect and discarded
 127  * (value returned from st_nci_i2c_repack)
 128  * -EIO : if no ST21NFCB_SOF_EOF is found after reaching
 129  * the read length end sequence
 130  */
 131 static int st_nci_i2c_read(struct st_nci_i2c_phy *phy,
 132                                  struct sk_buff **skb)
 133 {
 134         int r;
 135         u8 len;
 136         u8 buf[ST_NCI_I2C_MAX_SIZE];
 137         struct i2c_client *client = phy->i2c_dev;
 138
 139         r = i2c_master_recv(client, buf, ST_NCI_I2C_MIN_SIZE);
 140         if (r < 0) {  /* Retry, chip was in standby */
 141                 usleep_range(1000, 4000);
 142                 r = i2c_master_recv(client, buf, ST_NCI_I2C_MIN_SIZE);
 143         }
 144
 145         if (r != ST_NCI_I2C_MIN_SIZE)
 146                 return -EREMOTEIO;
 147
 148         len = be16_to_cpu(*(__be16 *) (buf + 2));
 149         if (len > ST_NCI_I2C_MAX_SIZE) {
 150                 nfc_err(&client->dev, "invalid frame len\n");
 151                 return -EBADMSG;
 152         }
 153
 154         *skb = alloc_skb(ST_NCI_I2C_MIN_SIZE + len, GFP_KERNEL);
 155         if (*skb == NULL)
 156                 return -ENOMEM;
 157
 158         skb_reserve(*skb, ST_NCI_I2C_MIN_SIZE);
 159         skb_put(*skb, ST_NCI_I2C_MIN_SIZE);
 160         memcpy((*skb)->data, buf, ST_NCI_I2C_MIN_SIZE);
 161
 162         if (!len)
 163                 return 0;
 164
 165         r = i2c_master_recv(client, buf, len);
 166         if (r != len) {
 167                 kfree_skb(*skb);
 168                 return -EREMOTEIO;
 169         }
 170
 171         skb_put(*skb, len);
 172         memcpy((*skb)->data + ST_NCI_I2C_MIN_SIZE, buf, len);
 173
 174         I2C_DUMP_SKB("i2c frame read", *skb);
 175
 176         return 0;
 177 }
 178
 179 /*
 180  * Reads an ndlc frame from the chip.
 181  *
 182  * On ST21NFCB, IRQ goes in idle state when read starts.
 183  */
 184 static irqreturn_t st_nci_irq_thread_fn(int irq, void *phy_id)
 185 {
 186         struct st_nci_i2c_phy *phy = phy_id;
 187         struct i2c_client *client;
 188         struct sk_buff *skb = NULL;
 189         int r;
 190
 191         if (!phy || !phy->ndlc || irq != phy->i2c_dev->irq) {
 192                 WARN_ON_ONCE(1);
 193                 return IRQ_NONE;
 194         }
 195
 196         client = phy->i2c_dev;
 197         dev_dbg(&client->dev, "IRQ\n");
 198
 199         if (phy->ndlc->hard_fault)
 200                 return IRQ_HANDLED;
 201
 202         if (!phy->ndlc->powered) {
 203                 st_nci_i2c_disable(phy);
 204                 return IRQ_HANDLED;
 205         }
 206
 207         r = st_nci_i2c_read(phy, &skb);
 208         if (r == -EREMOTEIO || r == -ENOMEM || r == -EBADMSG)
 209                 return IRQ_HANDLED;
 210
 211         ndlc_recv(phy->ndlc, skb);
 212
 213         return IRQ_HANDLED;
 214 }
 215
 216 static struct nfc_phy_ops i2c_phy_ops = {
 217         .write = st_nci_i2c_write,
 218         .enable = st_nci_i2c_enable,
 219         .disable = st_nci_i2c_disable,
 220 };
 221
 222 #ifdef CONFIG_OF
 223 static int st_nci_i2c_of_request_resources(struct i2c_client *client)
 224 {
 225         struct st_nci_i2c_phy *phy = i2c_get_clientdata(client);
 226         struct device_node *pp;
 227         int gpio;
 228         int r;
 229
 230         pp = client->dev.of_node;
 231         if (!pp)
 232                 return -ENODEV;
 233
 234         /* Get GPIO from device tree */
 235         gpio = of_get_named_gpio(pp, "reset-gpios", 0);
 236         if (gpio < 0) {
 237                 nfc_err(&client->dev,
 238                         "Failed to retrieve reset-gpios from device tree\n");
 239                 return gpio;
 240         }
 241
 242         /* GPIO request and configuration */
 243         r = devm_gpio_request_one(&client->dev, gpio,
 244                                 GPIOF_OUT_INIT_HIGH, "clf_reset");
 245         if (r) {
 246                 nfc_err(&client->dev, "Failed to request reset pin\n");
 247                 return r;
 248         }
 249         phy->gpio_reset = gpio;
 250
 251         phy->irq_polarity = irq_get_trigger_type(client->irq);
 252
 253         return 0;
 254 }
 255 #else
 256 static int st_nci_i2c_of_request_resources(struct i2c_client *client)
 257 {
 258         return -ENODEV;
 259 }
 260 #endif
 261
 262 static int st_nci_i2c_request_resources(struct i2c_client *client)
 263 {
 264         struct st_nci_nfc_platform_data *pdata;
 265         struct st_nci_i2c_phy *phy = i2c_get_clientdata(client);
 266         int r;
 267
 268         pdata = client->dev.platform_data;
 269         if (pdata == NULL) {
 270                 nfc_err(&client->dev, "No platform data\n");
 271                 return -EINVAL;
 272         }
 273
 274         /* store for later use */
 275         phy->gpio_reset = pdata->gpio_reset;
 276         phy->irq_polarity = pdata->irq_polarity;
 277
 278         r = devm_gpio_request_one(&client->dev,
 279                         phy->gpio_reset, GPIOF_OUT_INIT_HIGH, "clf_reset");
 280         if (r) {
 281                 pr_err("%s : reset gpio_request failed\n", __FILE__);
 282                 return r;
 283         }
 284
 285         return 0;
 286 }
 287
 288 static int st_nci_i2c_probe(struct i2c_client *client,
 289                                   const struct i2c_device_id *id)
 290 {
 291         struct st_nci_i2c_phy *phy;
 292         struct st_nci_nfc_platform_data *pdata;
 293         int r;
 294
 295         dev_dbg(&client->dev, "%s\n", __func__);
 296         dev_dbg(&client->dev, "IRQ: %d\n", client->irq);
 297
 298         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 299                 nfc_err(&client->dev, "Need I2C_FUNC_I2C\n");
 300                 return -ENODEV;
 301         }
 302
 303         phy = devm_kzalloc(&client->dev, sizeof(struct st_nci_i2c_phy),
 304                            GFP_KERNEL);
 305         if (!phy)
 306                 return -ENOMEM;
 307
 308         phy->i2c_dev = client;
 309
 310         i2c_set_clientdata(client, phy);
 311
 312         pdata = client->dev.platform_data;
 313         if (!pdata && client->dev.of_node) {
 314                 r = st_nci_i2c_of_request_resources(client);
 315                 if (r) {
 316                         nfc_err(&client->dev, "No platform data\n");
 317                         return r;
 318                 }
 319         } else if (pdata) {
 320                 r = st_nci_i2c_request_resources(client);
 321                 if (r) {
 322                         nfc_err(&client->dev,
 323                                 "Cannot get platform resources\n");
 324                         return r;
 325                 }
 326         } else {
 327                 nfc_err(&client->dev,
 328                         "st21nfcb platform resources not available\n");
 329                 return -ENODEV;
 330         }
 331
 332         r = ndlc_probe(phy, &i2c_phy_ops, &client->dev,
 333                         ST21NFCB_FRAME_HEADROOM, ST21NFCB_FRAME_TAILROOM,
 334                         &phy->ndlc);
 335         if (r < 0) {
 336                 nfc_err(&client->dev, "Unable to register ndlc layer\n");
 337                 return r;
 338         }
 339
 340         r = devm_request_threaded_irq(&client->dev, client->irq, NULL,
 341                                 st_nci_irq_thread_fn,
 342                                 phy->irq_polarity | IRQF_ONESHOT,
 343                                 ST_NCI_DRIVER_NAME, phy);
 344         if (r < 0)
 345                 nfc_err(&client->dev, "Unable to register IRQ handler\n");
 346
 347         return r;
 348 }
 349
 350 static int st_nci_i2c_remove(struct i2c_client *client)
 351 {
 352         struct st_nci_i2c_phy *phy = i2c_get_clientdata(client);
 353
 354         dev_dbg(&client->dev, "%s\n", __func__);
 355
 356         ndlc_remove(phy->ndlc);
 357
 358         return 0;
 359 }
 360
 361 #ifdef CONFIG_OF
 362 static const struct of_device_id of_st_nci_i2c_match[] = {
 363         { .compatible = "st,st21nfcb-i2c", },
 364         { .compatible = "st,st21nfcb_i2c", },
 365         { .compatible = "st,st21nfcc-i2c", },
 366         {}
 367 };
 368 MODULE_DEVICE_TABLE(of, of_st_nci_i2c_match);
 369 #endif
 370
 371 static struct i2c_driver st_nci_i2c_driver = {
 372         .driver = {
 373                 .owner = THIS_MODULE,
 374                 .name = ST_NCI_I2C_DRIVER_NAME,
 375                 .of_match_table = of_match_ptr(of_st_nci_i2c_match),
 376         },
 377         .probe = st_nci_i2c_probe,
 378         .id_table = st_nci_i2c_id_table,
 379         .remove = st_nci_i2c_remove,
 380 };
 381
 382 module_i2c_driver(st_nci_i2c_driver);
 383
 384 MODULE_LICENSE("GPL");
 385 MODULE_DESCRIPTION(DRIVER_DESC);