1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * HCI based Driver for Inside Secure microread NFC Chip - i2c layer 4 * 5 * Copyright (C) 2013 Intel Corporation. All rights reserved. 6 */ 7 8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9 10 #include <linux/module.h> 11 #include <linux/i2c.h> 12 #include <linux/delay.h> 13 #include <linux/slab.h> 14 #include <linux/interrupt.h> 15 16 #include <linux/nfc.h> 17 #include <net/nfc/hci.h> 18 #include <net/nfc/llc.h> 19 20 #include "microread.h" 21 22 #define MICROREAD_I2C_DRIVER_NAME "microread" 23 24 #define MICROREAD_I2C_FRAME_HEADROOM 1 25 #define MICROREAD_I2C_FRAME_TAILROOM 1 26 27 /* framing in HCI mode */ 28 #define MICROREAD_I2C_LLC_LEN 1 29 #define MICROREAD_I2C_LLC_CRC 1 30 #define MICROREAD_I2C_LLC_LEN_CRC (MICROREAD_I2C_LLC_LEN + \ 31 MICROREAD_I2C_LLC_CRC) 32 #define MICROREAD_I2C_LLC_MIN_SIZE (1 + MICROREAD_I2C_LLC_LEN_CRC) 33 #define MICROREAD_I2C_LLC_MAX_PAYLOAD 29 34 #define MICROREAD_I2C_LLC_MAX_SIZE (MICROREAD_I2C_LLC_LEN_CRC + 1 + \ 35 MICROREAD_I2C_LLC_MAX_PAYLOAD) 36 37 struct microread_i2c_phy { 38 struct i2c_client *i2c_dev; 39 struct nfc_hci_dev *hdev; 40 41 int hard_fault; /* 42 * < 0 if hardware error occured (e.g. i2c err) 43 * and prevents normal operation. 44 */ 45 }; 46 47 #define I2C_DUMP_SKB(info, skb) \ 48 do { \ 49 pr_debug("%s:\n", info); \ 50 print_hex_dump(KERN_DEBUG, "i2c: ", DUMP_PREFIX_OFFSET, \ 51 16, 1, (skb)->data, (skb)->len, 0); \ 52 } while (0) 53 54 static void microread_i2c_add_len_crc(struct sk_buff *skb) 55 { 56 int i; 57 u8 crc = 0; 58 int len; 59 60 len = skb->len; 61 *(u8 *)skb_push(skb, 1) = len; 62 63 for (i = 0; i < skb->len; i++) 64 crc = crc ^ skb->data[i]; 65 66 skb_put_u8(skb, crc); 67 } 68 69 static void microread_i2c_remove_len_crc(struct sk_buff *skb) 70 { 71 skb_pull(skb, MICROREAD_I2C_FRAME_HEADROOM); 72 skb_trim(skb, MICROREAD_I2C_FRAME_TAILROOM); 73 } 74 75 static int check_crc(const struct sk_buff *skb) 76 { 77 int i; 78 u8 crc = 0; 79 80 for (i = 0; i < skb->len - 1; i++) 81 crc = crc ^ skb->data[i]; 82 83 if (crc != skb->data[skb->len-1]) { 84 pr_err("CRC error 0x%x != 0x%x\n", crc, skb->data[skb->len-1]); 85 pr_info("%s: BAD CRC\n", __func__); 86 return -EPERM; 87 } 88 89 return 0; 90 } 91 92 static int microread_i2c_enable(void *phy_id) 93 { 94 return 0; 95 } 96 97 static void microread_i2c_disable(void *phy_id) 98 { 99 return; 100 } 101 102 static int microread_i2c_write(void *phy_id, struct sk_buff *skb) 103 { 104 int r; 105 struct microread_i2c_phy *phy = phy_id; 106 struct i2c_client *client = phy->i2c_dev; 107 108 if (phy->hard_fault != 0) 109 return phy->hard_fault; 110 111 usleep_range(3000, 6000); 112 113 microread_i2c_add_len_crc(skb); 114 115 I2C_DUMP_SKB("i2c frame written", skb); 116 117 r = i2c_master_send(client, skb->data, skb->len); 118 119 if (r == -EREMOTEIO) { /* Retry, chip was in standby */ 120 usleep_range(6000, 10000); 121 r = i2c_master_send(client, skb->data, skb->len); 122 } 123 124 if (r >= 0) { 125 if (r != skb->len) 126 r = -EREMOTEIO; 127 else 128 r = 0; 129 } 130 131 microread_i2c_remove_len_crc(skb); 132 133 return r; 134 } 135 136 137 static int microread_i2c_read(struct microread_i2c_phy *phy, 138 struct sk_buff **skb) 139 { 140 int r; 141 u8 len; 142 u8 tmp[MICROREAD_I2C_LLC_MAX_SIZE - 1]; 143 struct i2c_client *client = phy->i2c_dev; 144 145 r = i2c_master_recv(client, &len, 1); 146 if (r != 1) { 147 nfc_err(&client->dev, "cannot read len byte\n"); 148 return -EREMOTEIO; 149 } 150 151 if ((len < MICROREAD_I2C_LLC_MIN_SIZE) || 152 (len > MICROREAD_I2C_LLC_MAX_SIZE)) { 153 nfc_err(&client->dev, "invalid len byte\n"); 154 r = -EBADMSG; 155 goto flush; 156 } 157 158 *skb = alloc_skb(1 + len, GFP_KERNEL); 159 if (*skb == NULL) { 160 r = -ENOMEM; 161 goto flush; 162 } 163 164 skb_put_u8(*skb, len); 165 166 r = i2c_master_recv(client, skb_put(*skb, len), len); 167 if (r != len) { 168 kfree_skb(*skb); 169 return -EREMOTEIO; 170 } 171 172 I2C_DUMP_SKB("cc frame read", *skb); 173 174 r = check_crc(*skb); 175 if (r != 0) { 176 kfree_skb(*skb); 177 r = -EBADMSG; 178 goto flush; 179 } 180 181 skb_pull(*skb, 1); 182 skb_trim(*skb, (*skb)->len - MICROREAD_I2C_FRAME_TAILROOM); 183 184 usleep_range(3000, 6000); 185 186 return 0; 187 188 flush: 189 if (i2c_master_recv(client, tmp, sizeof(tmp)) < 0) 190 r = -EREMOTEIO; 191 192 usleep_range(3000, 6000); 193 194 return r; 195 } 196 197 static irqreturn_t microread_i2c_irq_thread_fn(int irq, void *phy_id) 198 { 199 struct microread_i2c_phy *phy = phy_id; 200 struct sk_buff *skb = NULL; 201 int r; 202 203 if (!phy || irq != phy->i2c_dev->irq) { 204 WARN_ON_ONCE(1); 205 return IRQ_NONE; 206 } 207 208 if (phy->hard_fault != 0) 209 return IRQ_HANDLED; 210 211 r = microread_i2c_read(phy, &skb); 212 if (r == -EREMOTEIO) { 213 phy->hard_fault = r; 214 215 nfc_hci_recv_frame(phy->hdev, NULL); 216 217 return IRQ_HANDLED; 218 } else if ((r == -ENOMEM) || (r == -EBADMSG)) { 219 return IRQ_HANDLED; 220 } 221 222 nfc_hci_recv_frame(phy->hdev, skb); 223 224 return IRQ_HANDLED; 225 } 226 227 static const struct nfc_phy_ops i2c_phy_ops = { 228 .write = microread_i2c_write, 229 .enable = microread_i2c_enable, 230 .disable = microread_i2c_disable, 231 }; 232 233 static int microread_i2c_probe(struct i2c_client *client) 234 { 235 struct microread_i2c_phy *phy; 236 int r; 237 238 phy = devm_kzalloc(&client->dev, sizeof(struct microread_i2c_phy), 239 GFP_KERNEL); 240 if (!phy) 241 return -ENOMEM; 242 243 i2c_set_clientdata(client, phy); 244 phy->i2c_dev = client; 245 246 r = request_threaded_irq(client->irq, NULL, microread_i2c_irq_thread_fn, 247 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 248 MICROREAD_I2C_DRIVER_NAME, phy); 249 if (r) { 250 nfc_err(&client->dev, "Unable to register IRQ handler\n"); 251 return r; 252 } 253 254 r = microread_probe(phy, &i2c_phy_ops, LLC_SHDLC_NAME, 255 MICROREAD_I2C_FRAME_HEADROOM, 256 MICROREAD_I2C_FRAME_TAILROOM, 257 MICROREAD_I2C_LLC_MAX_PAYLOAD, &phy->hdev); 258 if (r < 0) 259 goto err_irq; 260 261 return 0; 262 263 err_irq: 264 free_irq(client->irq, phy); 265 266 return r; 267 } 268 269 static void microread_i2c_remove(struct i2c_client *client) 270 { 271 struct microread_i2c_phy *phy = i2c_get_clientdata(client); 272 273 microread_remove(phy->hdev); 274 275 free_irq(client->irq, phy); 276 } 277 278 static const struct i2c_device_id microread_i2c_id[] = { 279 { MICROREAD_I2C_DRIVER_NAME }, 280 { } 281 }; 282 MODULE_DEVICE_TABLE(i2c, microread_i2c_id); 283 284 static struct i2c_driver microread_i2c_driver = { 285 .driver = { 286 .name = MICROREAD_I2C_DRIVER_NAME, 287 }, 288 .probe = microread_i2c_probe, 289 .remove = microread_i2c_remove, 290 .id_table = microread_i2c_id, 291 }; 292 293 module_i2c_driver(microread_i2c_driver); 294 295 MODULE_LICENSE("GPL"); 296 MODULE_DESCRIPTION(DRIVER_DESC); 297