nfc/microread/i2c.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * HCI based Driver for Inside Secure microread NFC Chip - i2c layer
0004  *
0005  * Copyright (C) 2013 Intel Corporation. All rights reserved.
0006  */
0007
0008 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0009
0010 #include <linux/module.h>
0011 #include <linux/i2c.h>
0012 #include <linux/delay.h>
0013 #include <linux/slab.h>
0014 #include <linux/interrupt.h>
0015 #include <linux/gpio.h>
0016
0017 #include <linux/nfc.h>
0018 #include <net/nfc/hci.h>
0019 #include <net/nfc/llc.h>
0020
0021 #include "microread.h"
0022
0023 #define MICROREAD_I2C_DRIVER_NAME "microread"
0024
0025 #define MICROREAD_I2C_FRAME_HEADROOM 1
0026 #define MICROREAD_I2C_FRAME_TAILROOM 1
0027
0028 /* framing in HCI mode */
0029 #define MICROREAD_I2C_LLC_LEN       1
0030 #define MICROREAD_I2C_LLC_CRC       1
0031 #define MICROREAD_I2C_LLC_LEN_CRC   (MICROREAD_I2C_LLC_LEN + \
0032                     MICROREAD_I2C_LLC_CRC)
0033 #define MICROREAD_I2C_LLC_MIN_SIZE  (1 + MICROREAD_I2C_LLC_LEN_CRC)
0034 #define MICROREAD_I2C_LLC_MAX_PAYLOAD   29
0035 #define MICROREAD_I2C_LLC_MAX_SIZE  (MICROREAD_I2C_LLC_LEN_CRC + 1 + \
0036                     MICROREAD_I2C_LLC_MAX_PAYLOAD)
0037
0038 struct microread_i2c_phy {
0039     struct i2c_client *i2c_dev;
0040     struct nfc_hci_dev *hdev;
0041
0042     int hard_fault;     /*
0043                  * < 0 if hardware error occured (e.g. i2c err)
0044                  * and prevents normal operation.
0045                  */
0046 };
0047
0048 #define I2C_DUMP_SKB(info, skb)                 \
0049 do {                                \
0050     pr_debug("%s:\n", info);                \
0051     print_hex_dump(KERN_DEBUG, "i2c: ", DUMP_PREFIX_OFFSET, \
0052                16, 1, (skb)->data, (skb)->len, 0);  \
0053 } while (0)
0054
0055 static void microread_i2c_add_len_crc(struct sk_buff *skb)
0056 {
0057     int i;
0058     u8 crc = 0;
0059     int len;
0060
0061     len = skb->len;
0062     *(u8 *)skb_push(skb, 1) = len;
0063
0064     for (i = 0; i < skb->len; i++)
0065         crc = crc ^ skb->data[i];
0066
0067     skb_put_u8(skb, crc);
0068 }
0069
0070 static void microread_i2c_remove_len_crc(struct sk_buff *skb)
0071 {
0072     skb_pull(skb, MICROREAD_I2C_FRAME_HEADROOM);
0073     skb_trim(skb, MICROREAD_I2C_FRAME_TAILROOM);
0074 }
0075
0076 static int check_crc(const struct sk_buff *skb)
0077 {
0078     int i;
0079     u8 crc = 0;
0080
0081     for (i = 0; i < skb->len - 1; i++)
0082         crc = crc ^ skb->data[i];
0083
0084     if (crc != skb->data[skb->len-1]) {
0085         pr_err("CRC error 0x%x != 0x%x\n", crc, skb->data[skb->len-1]);
0086         pr_info("%s: BAD CRC\n", __func__);
0087         return -EPERM;
0088     }
0089
0090     return 0;
0091 }
0092
0093 static int microread_i2c_enable(void *phy_id)
0094 {
0095     return 0;
0096 }
0097
0098 static void microread_i2c_disable(void *phy_id)
0099 {
0100     return;
0101 }
0102
0103 static int microread_i2c_write(void *phy_id, struct sk_buff *skb)
0104 {
0105     int r;
0106     struct microread_i2c_phy *phy = phy_id;
0107     struct i2c_client *client = phy->i2c_dev;
0108
0109     if (phy->hard_fault != 0)
0110         return phy->hard_fault;
0111
0112     usleep_range(3000, 6000);
0113
0114     microread_i2c_add_len_crc(skb);
0115
0116     I2C_DUMP_SKB("i2c frame written", skb);
0117
0118     r = i2c_master_send(client, skb->data, skb->len);
0119
0120     if (r == -EREMOTEIO) {  /* Retry, chip was in standby */
0121         usleep_range(6000, 10000);
0122         r = i2c_master_send(client, skb->data, skb->len);
0123     }
0124
0125     if (r >= 0) {
0126         if (r != skb->len)
0127             r = -EREMOTEIO;
0128         else
0129             r = 0;
0130     }
0131
0132     microread_i2c_remove_len_crc(skb);
0133
0134     return r;
0135 }
0136
0137
0138 static int microread_i2c_read(struct microread_i2c_phy *phy,
0139                   struct sk_buff **skb)
0140 {
0141     int r;
0142     u8 len;
0143     u8 tmp[MICROREAD_I2C_LLC_MAX_SIZE - 1];
0144     struct i2c_client *client = phy->i2c_dev;
0145
0146     r = i2c_master_recv(client, &len, 1);
0147     if (r != 1) {
0148         nfc_err(&client->dev, "cannot read len byte\n");
0149         return -EREMOTEIO;
0150     }
0151
0152     if ((len < MICROREAD_I2C_LLC_MIN_SIZE) ||
0153         (len > MICROREAD_I2C_LLC_MAX_SIZE)) {
0154         nfc_err(&client->dev, "invalid len byte\n");
0155         r = -EBADMSG;
0156         goto flush;
0157     }
0158
0159     *skb = alloc_skb(1 + len, GFP_KERNEL);
0160     if (*skb == NULL) {
0161         r = -ENOMEM;
0162         goto flush;
0163     }
0164
0165     skb_put_u8(*skb, len);
0166
0167     r = i2c_master_recv(client, skb_put(*skb, len), len);
0168     if (r != len) {
0169         kfree_skb(*skb);
0170         return -EREMOTEIO;
0171     }
0172
0173     I2C_DUMP_SKB("cc frame read", *skb);
0174
0175     r = check_crc(*skb);
0176     if (r != 0) {
0177         kfree_skb(*skb);
0178         r = -EBADMSG;
0179         goto flush;
0180     }
0181
0182     skb_pull(*skb, 1);
0183     skb_trim(*skb, (*skb)->len - MICROREAD_I2C_FRAME_TAILROOM);
0184
0185     usleep_range(3000, 6000);
0186
0187     return 0;
0188
0189 flush:
0190     if (i2c_master_recv(client, tmp, sizeof(tmp)) < 0)
0191         r = -EREMOTEIO;
0192
0193     usleep_range(3000, 6000);
0194
0195     return r;
0196 }
0197
0198 static irqreturn_t microread_i2c_irq_thread_fn(int irq, void *phy_id)
0199 {
0200     struct microread_i2c_phy *phy = phy_id;
0201     struct sk_buff *skb = NULL;
0202     int r;
0203
0204     if (!phy || irq != phy->i2c_dev->irq) {
0205         WARN_ON_ONCE(1);
0206         return IRQ_NONE;
0207     }
0208
0209     if (phy->hard_fault != 0)
0210         return IRQ_HANDLED;
0211
0212     r = microread_i2c_read(phy, &skb);
0213     if (r == -EREMOTEIO) {
0214         phy->hard_fault = r;
0215
0216         nfc_hci_recv_frame(phy->hdev, NULL);
0217
0218         return IRQ_HANDLED;
0219     } else if ((r == -ENOMEM) || (r == -EBADMSG)) {
0220         return IRQ_HANDLED;
0221     }
0222
0223     nfc_hci_recv_frame(phy->hdev, skb);
0224
0225     return IRQ_HANDLED;
0226 }
0227
0228 static const struct nfc_phy_ops i2c_phy_ops = {
0229     .write = microread_i2c_write,
0230     .enable = microread_i2c_enable,
0231     .disable = microread_i2c_disable,
0232 };
0233
0234 static int microread_i2c_probe(struct i2c_client *client,
0235                    const struct i2c_device_id *id)
0236 {
0237     struct microread_i2c_phy *phy;
0238     int r;
0239
0240     phy = devm_kzalloc(&client->dev, sizeof(struct microread_i2c_phy),
0241                GFP_KERNEL);
0242     if (!phy)
0243         return -ENOMEM;
0244
0245     i2c_set_clientdata(client, phy);
0246     phy->i2c_dev = client;
0247
0248     r = request_threaded_irq(client->irq, NULL, microread_i2c_irq_thread_fn,
0249                  IRQF_TRIGGER_RISING | IRQF_ONESHOT,
0250                  MICROREAD_I2C_DRIVER_NAME, phy);
0251     if (r) {
0252         nfc_err(&client->dev, "Unable to register IRQ handler\n");
0253         return r;
0254     }
0255
0256     r = microread_probe(phy, &i2c_phy_ops, LLC_SHDLC_NAME,
0257                 MICROREAD_I2C_FRAME_HEADROOM,
0258                 MICROREAD_I2C_FRAME_TAILROOM,
0259                 MICROREAD_I2C_LLC_MAX_PAYLOAD, &phy->hdev);
0260     if (r < 0)
0261         goto err_irq;
0262
0263     return 0;
0264
0265 err_irq:
0266     free_irq(client->irq, phy);
0267
0268     return r;
0269 }
0270
0271 static int microread_i2c_remove(struct i2c_client *client)
0272 {
0273     struct microread_i2c_phy *phy = i2c_get_clientdata(client);
0274
0275     microread_remove(phy->hdev);
0276
0277     free_irq(client->irq, phy);
0278
0279     return 0;
0280 }
0281
0282 static const struct i2c_device_id microread_i2c_id[] = {
0283     { MICROREAD_I2C_DRIVER_NAME, 0},
0284     { }
0285 };
0286 MODULE_DEVICE_TABLE(i2c, microread_i2c_id);
0287
0288 static struct i2c_driver microread_i2c_driver = {
0289     .driver = {
0290         .name = MICROREAD_I2C_DRIVER_NAME,
0291     },
0292     .probe      = microread_i2c_probe,
0293     .remove     = microread_i2c_remove,
0294     .id_table   = microread_i2c_id,
0295 };
0296
0297 module_i2c_driver(microread_i2c_driver);
0298
0299 MODULE_LICENSE("GPL");
0300 MODULE_DESCRIPTION(DRIVER_DESC);