drivers/nfc/fdp/i2c.c

   1 /* -------------------------------------------------------------------------
   2  * Copyright (C) 2014-2016, Intel Corporation
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2 of the License, or
   7  *  (at your option) any later version.
   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  */
  15
  16 #include <linux/module.h>
  17 #include <linux/acpi.h>
  18 #include <linux/i2c.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/nfc.h>
  21 #include <linux/delay.h>
  22 #include <linux/gpio/consumer.h>
  23 #include <net/nfc/nfc.h>
  24 #include <net/nfc/nci_core.h>
  25
  26 #include "fdp.h"
  27
  28 #define FDP_I2C_DRIVER_NAME     "fdp_nci_i2c"
  29
  30 #define FDP_DP_CLOCK_TYPE_NAME  "clock-type"
  31 #define FDP_DP_CLOCK_FREQ_NAME  "clock-freq"
  32 #define FDP_DP_FW_VSC_CFG_NAME  "fw-vsc-cfg"
  33
  34 #define FDP_FRAME_HEADROOM      2
  35 #define FDP_FRAME_TAILROOM      1
  36
  37 #define FDP_NCI_I2C_MIN_PAYLOAD 5
  38 #define FDP_NCI_I2C_MAX_PAYLOAD 261
  39
  40 #define FDP_POWER_OFF           0
  41 #define FDP_POWER_ON            1
  42
  43 #define fdp_nci_i2c_dump_skb(dev, prefix, skb)                          \
  44         print_hex_dump(KERN_DEBUG, prefix": ", DUMP_PREFIX_OFFSET,      \
  45                        16, 1, (skb)->data, (skb)->len, 0)
  46
  47 static void fdp_nci_i2c_reset(struct fdp_i2c_phy *phy)
  48 {
  49         /* Reset RST/WakeUP for at least 100 micro-second */
  50         gpiod_set_value_cansleep(phy->power_gpio, FDP_POWER_OFF);
  51         usleep_range(1000, 4000);
  52         gpiod_set_value_cansleep(phy->power_gpio, FDP_POWER_ON);
  53         usleep_range(10000, 14000);
  54 }
  55
  56 static int fdp_nci_i2c_enable(void *phy_id)
  57 {
  58         struct fdp_i2c_phy *phy = phy_id;
  59
  60         dev_dbg(&phy->i2c_dev->dev, "%s\n", __func__);
  61         fdp_nci_i2c_reset(phy);
  62
  63         return 0;
  64 }
  65
  66 static void fdp_nci_i2c_disable(void *phy_id)
  67 {
  68         struct fdp_i2c_phy *phy = phy_id;
  69
  70         dev_dbg(&phy->i2c_dev->dev, "%s\n", __func__);
  71         fdp_nci_i2c_reset(phy);
  72 }
  73
  74 static void fdp_nci_i2c_add_len_lrc(struct sk_buff *skb)
  75 {
  76         u8 lrc = 0;
  77         u16 len, i;
  78
  79         /* Add length header */
  80         len = skb->len;
  81         *(u8 *)skb_push(skb, 1) = len & 0xff;
  82         *(u8 *)skb_push(skb, 1) = len >> 8;
  83
  84         /* Compute and add lrc */
  85         for (i = 0; i < len + 2; i++)
  86                 lrc ^= skb->data[i];
  87
  88         skb_put_u8(skb, lrc);
  89 }
  90
  91 static void fdp_nci_i2c_remove_len_lrc(struct sk_buff *skb)
  92 {
  93         skb_pull(skb, FDP_FRAME_HEADROOM);
  94         skb_trim(skb, skb->len - FDP_FRAME_TAILROOM);
  95 }
  96
  97 static int fdp_nci_i2c_write(void *phy_id, struct sk_buff *skb)
  98 {
  99         struct fdp_i2c_phy *phy = phy_id;
 100         struct i2c_client *client = phy->i2c_dev;
 101         int r;
 102
 103         if (phy->hard_fault != 0)
 104                 return phy->hard_fault;
 105
 106         fdp_nci_i2c_add_len_lrc(skb);
 107         fdp_nci_i2c_dump_skb(&client->dev, "fdp_wr", skb);
 108
 109         r = i2c_master_send(client, skb->data, skb->len);
 110         if (r == -EREMOTEIO) {  /* Retry, chip was in standby */
 111                 usleep_range(1000, 4000);
 112                 r = i2c_master_send(client, skb->data, skb->len);
 113         }
 114
 115         if (r < 0 || r != skb->len)
 116                 dev_dbg(&client->dev, "%s: error err=%d len=%d\n",
 117                         __func__, r, skb->len);
 118
 119         if (r >= 0) {
 120                 if (r != skb->len) {
 121                         phy->hard_fault = r;
 122                         r = -EREMOTEIO;
 123                 } else {
 124                         r = 0;
 125                 }
 126         }
 127
 128         fdp_nci_i2c_remove_len_lrc(skb);
 129
 130         return r;
 131 }
 132
 133 static struct nfc_phy_ops i2c_phy_ops = {
 134         .write = fdp_nci_i2c_write,
 135         .enable = fdp_nci_i2c_enable,
 136         .disable = fdp_nci_i2c_disable,
 137 };
 138
 139 static int fdp_nci_i2c_read(struct fdp_i2c_phy *phy, struct sk_buff **skb)
 140 {
 141         int r, len;
 142         u8 tmp[FDP_NCI_I2C_MAX_PAYLOAD], lrc, k;
 143         u16 i;
 144         struct i2c_client *client = phy->i2c_dev;
 145
 146         *skb = NULL;
 147
 148         /* Read the length packet and the data packet */
 149         for (k = 0; k < 2; k++) {
 150
 151                 len = phy->next_read_size;
 152
 153                 r = i2c_master_recv(client, tmp, len);
 154                 if (r != len) {
 155                         dev_dbg(&client->dev, "%s: i2c recv err: %d\n",
 156                                 __func__, r);
 157                         goto flush;
 158                 }
 159
 160                 /* Check packet integruty */
 161                 for (lrc = i = 0; i < r; i++)
 162                         lrc ^= tmp[i];
 163
 164                 /*
 165                  * LRC check failed. This may due to transmission error or
 166                  * desynchronization between driver and FDP. Drop the paquet
 167                  * and force resynchronization
 168                  */
 169                 if (lrc) {
 170                         dev_dbg(&client->dev, "%s: corrupted packet\n",
 171                                 __func__);
 172                         phy->next_read_size = 5;
 173                         goto flush;
 174                 }
 175
 176                 /* Packet that contains a length */
 177                 if (tmp[0] == 0 && tmp[1] == 0) {
 178                         phy->next_read_size = (tmp[2] << 8) + tmp[3] + 3;
 179                 } else {
 180                         phy->next_read_size = FDP_NCI_I2C_MIN_PAYLOAD;
 181
 182                         *skb = alloc_skb(len, GFP_KERNEL);
 183                         if (*skb == NULL) {
 184                                 r = -ENOMEM;
 185                                 goto flush;
 186                         }
 187
 188                         skb_put_data(*skb, tmp, len);
 189                         fdp_nci_i2c_dump_skb(&client->dev, "fdp_rd", *skb);
 190
 191                         fdp_nci_i2c_remove_len_lrc(*skb);
 192                 }
 193         }
 194
 195         return 0;
 196
 197 flush:
 198         /* Flush the remaining data */
 199         if (i2c_master_recv(client, tmp, sizeof(tmp)) < 0)
 200                 r = -EREMOTEIO;
 201
 202         return r;
 203 }
 204
 205 static irqreturn_t fdp_nci_i2c_irq_thread_fn(int irq, void *phy_id)
 206 {
 207         struct fdp_i2c_phy *phy = phy_id;
 208         struct i2c_client *client;
 209         struct sk_buff *skb;
 210         int r;
 211
 212         if (!phy || irq != phy->i2c_dev->irq) {
 213                 WARN_ON_ONCE(1);
 214                 return IRQ_NONE;
 215         }
 216
 217         client = phy->i2c_dev;
 218         dev_dbg(&client->dev, "%s\n", __func__);
 219
 220         r = fdp_nci_i2c_read(phy, &skb);
 221
 222         if (r == -EREMOTEIO)
 223                 return IRQ_HANDLED;
 224         else if (r == -ENOMEM || r == -EBADMSG)
 225                 return IRQ_HANDLED;
 226
 227         if (skb != NULL)
 228                 fdp_nci_recv_frame(phy->ndev, skb);
 229
 230         return IRQ_HANDLED;
 231 }
 232
 233 static void fdp_nci_i2c_read_device_properties(struct device *dev,
 234                                                u8 *clock_type, u32 *clock_freq,
 235                                                u8 **fw_vsc_cfg)
 236 {
 237         int r;
 238         u8 len;
 239
 240         r = device_property_read_u8(dev, FDP_DP_CLOCK_TYPE_NAME, clock_type);
 241         if (r) {
 242                 dev_dbg(dev, "Using default clock type");
 243                 *clock_type = 0;
 244         }
 245
 246         r = device_property_read_u32(dev, FDP_DP_CLOCK_FREQ_NAME, clock_freq);
 247         if (r) {
 248                 dev_dbg(dev, "Using default clock frequency\n");
 249                 *clock_freq = 26000;
 250         }
 251
 252         if (device_property_present(dev, FDP_DP_FW_VSC_CFG_NAME)) {
 253                 r = device_property_read_u8(dev, FDP_DP_FW_VSC_CFG_NAME,
 254                                             &len);
 255
 256                 if (r || len <= 0)
 257                         goto vsc_read_err;
 258
 259                 /* Add 1 to the length to inclue the length byte itself */
 260                 len++;
 261
 262                 *fw_vsc_cfg = devm_kmalloc(dev,
 263                                            len * sizeof(**fw_vsc_cfg),
 264                                            GFP_KERNEL);
 265
 266                 r = device_property_read_u8_array(dev, FDP_DP_FW_VSC_CFG_NAME,
 267                                                   *fw_vsc_cfg, len);
 268
 269                 if (r) {
 270                         devm_kfree(dev, fw_vsc_cfg);
 271                         goto vsc_read_err;
 272                 }
 273         } else {
 274 vsc_read_err:
 275                 dev_dbg(dev, "FW vendor specific commands not present\n");
 276                 *fw_vsc_cfg = NULL;
 277         }
 278
 279         dev_dbg(dev, "Clock type: %d, clock frequency: %d, VSC: %s",
 280                 *clock_type, *clock_freq, *fw_vsc_cfg != NULL ? "yes" : "no");
 281 }
 282
 283 static const struct acpi_gpio_params power_gpios = { 0, 0, false };
 284
 285 static const struct acpi_gpio_mapping acpi_fdp_gpios[] = {
 286         { "power-gpios", &power_gpios, 1 },
 287         {},
 288 };
 289
 290 static int fdp_nci_i2c_probe(struct i2c_client *client)
 291 {
 292         struct fdp_i2c_phy *phy;
 293         struct device *dev = &client->dev;
 294         u8 *fw_vsc_cfg;
 295         u8 clock_type;
 296         u32 clock_freq;
 297         int r = 0;
 298
 299         dev_dbg(dev, "%s\n", __func__);
 300
 301         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 302                 nfc_err(dev, "No I2C_FUNC_I2C support\n");
 303                 return -ENODEV;
 304         }
 305
 306         /* Checking if we have an irq */
 307         if (client->irq <= 0) {
 308                 nfc_err(dev, "IRQ not present\n");
 309                 return -ENODEV;
 310         }
 311
 312         phy = devm_kzalloc(dev, sizeof(struct fdp_i2c_phy), GFP_KERNEL);
 313         if (!phy)
 314                 return -ENOMEM;
 315
 316         phy->i2c_dev = client;
 317         phy->next_read_size = FDP_NCI_I2C_MIN_PAYLOAD;
 318         i2c_set_clientdata(client, phy);
 319
 320         r = devm_request_threaded_irq(dev, client->irq,
 321                                       NULL, fdp_nci_i2c_irq_thread_fn,
 322                                       IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 323                                       FDP_I2C_DRIVER_NAME, phy);
 324
 325         if (r < 0) {
 326                 nfc_err(&client->dev, "Unable to register IRQ handler\n");
 327                 return r;
 328         }
 329
 330         r = devm_acpi_dev_add_driver_gpios(dev, acpi_fdp_gpios);
 331         if (r)
 332                 dev_dbg(dev, "Unable to add GPIO mapping table\n");
 333
 334         /* Requesting the power gpio */
 335         phy->power_gpio = devm_gpiod_get(dev, "power", GPIOD_OUT_LOW);
 336         if (IS_ERR(phy->power_gpio)) {
 337                 nfc_err(dev, "Power GPIO request failed\n");
 338                 return PTR_ERR(phy->power_gpio);
 339         }
 340
 341         /* read device properties to get the clock and production settings */
 342         fdp_nci_i2c_read_device_properties(dev, &clock_type, &clock_freq,
 343                                            &fw_vsc_cfg);
 344
 345         /* Call the NFC specific probe function */
 346         r = fdp_nci_probe(phy, &i2c_phy_ops, &phy->ndev,
 347                           FDP_FRAME_HEADROOM, FDP_FRAME_TAILROOM,
 348                           clock_type, clock_freq, fw_vsc_cfg);
 349         if (r < 0) {
 350                 nfc_err(dev, "NCI probing error\n");
 351                 return r;
 352         }
 353
 354         dev_dbg(dev, "I2C driver loaded\n");
 355         return 0;
 356 }
 357
 358 static int fdp_nci_i2c_remove(struct i2c_client *client)
 359 {
 360         struct fdp_i2c_phy *phy = i2c_get_clientdata(client);
 361
 362         dev_dbg(&client->dev, "%s\n", __func__);
 363
 364         fdp_nci_remove(phy->ndev);
 365         fdp_nci_i2c_disable(phy);
 366
 367         return 0;
 368 }
 369
 370 static const struct acpi_device_id fdp_nci_i2c_acpi_match[] = {
 371         {"INT339A", 0},
 372         {}
 373 };
 374 MODULE_DEVICE_TABLE(acpi, fdp_nci_i2c_acpi_match);
 375
 376 static struct i2c_driver fdp_nci_i2c_driver = {
 377         .driver = {
 378                    .name = FDP_I2C_DRIVER_NAME,
 379                    .acpi_match_table = ACPI_PTR(fdp_nci_i2c_acpi_match),
 380                   },
 381         .probe_new = fdp_nci_i2c_probe,
 382         .remove = fdp_nci_i2c_remove,
 383 };
 384 module_i2c_driver(fdp_nci_i2c_driver);
 385
 386 MODULE_LICENSE("GPL");
 387 MODULE_DESCRIPTION("I2C driver for Intel Fields Peak NFC controller");
 388 MODULE_AUTHOR("Robert Dolca <robert.dolca@intel.com>");