Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 1 | /* |
| 2 | * HCI based Driver for Inside Secure microread NFC Chip - i2c layer |
| 3 | * |
| 4 | * Copyright (C) 2013 Intel Corporation. All rights reserved. |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify it |
| 7 | * under the terms and conditions of the GNU General Public License, |
| 8 | * version 2, as published by the Free Software Foundation. |
| 9 | * |
| 10 | * This program is distributed in the hope that it will be useful, |
| 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 13 | * GNU General Public License for more details. |
| 14 | * |
| 15 | * You should have received a copy of the GNU General Public License |
Jeff Kirsher | 98b32de | 2013-12-06 08:56:16 -0800 | [diff] [blame] | 16 | * along with this program; if not, see <http://www.gnu.org/licenses/>. |
Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 17 | */ |
| 18 | |
Joe Perches | 17936b4 | 2013-04-05 12:27:39 -0700 | [diff] [blame] | 19 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 20 | |
Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 21 | #include <linux/module.h> |
| 22 | #include <linux/i2c.h> |
| 23 | #include <linux/delay.h> |
| 24 | #include <linux/slab.h> |
| 25 | #include <linux/interrupt.h> |
| 26 | #include <linux/gpio.h> |
| 27 | |
| 28 | #include <linux/nfc.h> |
| 29 | #include <net/nfc/hci.h> |
| 30 | #include <net/nfc/llc.h> |
| 31 | |
| 32 | #include "microread.h" |
| 33 | |
| 34 | #define MICROREAD_I2C_DRIVER_NAME "microread" |
| 35 | |
| 36 | #define MICROREAD_I2C_FRAME_HEADROOM 1 |
| 37 | #define MICROREAD_I2C_FRAME_TAILROOM 1 |
| 38 | |
| 39 | /* framing in HCI mode */ |
| 40 | #define MICROREAD_I2C_LLC_LEN 1 |
| 41 | #define MICROREAD_I2C_LLC_CRC 1 |
| 42 | #define MICROREAD_I2C_LLC_LEN_CRC (MICROREAD_I2C_LLC_LEN + \ |
| 43 | MICROREAD_I2C_LLC_CRC) |
| 44 | #define MICROREAD_I2C_LLC_MIN_SIZE (1 + MICROREAD_I2C_LLC_LEN_CRC) |
| 45 | #define MICROREAD_I2C_LLC_MAX_PAYLOAD 29 |
| 46 | #define MICROREAD_I2C_LLC_MAX_SIZE (MICROREAD_I2C_LLC_LEN_CRC + 1 + \ |
| 47 | MICROREAD_I2C_LLC_MAX_PAYLOAD) |
| 48 | |
| 49 | struct microread_i2c_phy { |
| 50 | struct i2c_client *i2c_dev; |
| 51 | struct nfc_hci_dev *hdev; |
| 52 | |
| 53 | int irq; |
| 54 | |
| 55 | int hard_fault; /* |
| 56 | * < 0 if hardware error occured (e.g. i2c err) |
| 57 | * and prevents normal operation. |
| 58 | */ |
| 59 | }; |
| 60 | |
| 61 | #define I2C_DUMP_SKB(info, skb) \ |
| 62 | do { \ |
| 63 | pr_debug("%s:\n", info); \ |
| 64 | print_hex_dump(KERN_DEBUG, "i2c: ", DUMP_PREFIX_OFFSET, \ |
| 65 | 16, 1, (skb)->data, (skb)->len, 0); \ |
| 66 | } while (0) |
| 67 | |
| 68 | static void microread_i2c_add_len_crc(struct sk_buff *skb) |
| 69 | { |
| 70 | int i; |
| 71 | u8 crc = 0; |
| 72 | int len; |
| 73 | |
| 74 | len = skb->len; |
| 75 | *skb_push(skb, 1) = len; |
| 76 | |
| 77 | for (i = 0; i < skb->len; i++) |
| 78 | crc = crc ^ skb->data[i]; |
| 79 | |
| 80 | *skb_put(skb, 1) = crc; |
| 81 | } |
| 82 | |
| 83 | static void microread_i2c_remove_len_crc(struct sk_buff *skb) |
| 84 | { |
| 85 | skb_pull(skb, MICROREAD_I2C_FRAME_HEADROOM); |
| 86 | skb_trim(skb, MICROREAD_I2C_FRAME_TAILROOM); |
| 87 | } |
| 88 | |
| 89 | static int check_crc(struct sk_buff *skb) |
| 90 | { |
| 91 | int i; |
| 92 | u8 crc = 0; |
| 93 | |
| 94 | for (i = 0; i < skb->len - 1; i++) |
| 95 | crc = crc ^ skb->data[i]; |
| 96 | |
| 97 | if (crc != skb->data[skb->len-1]) { |
Joe Perches | 17936b4 | 2013-04-05 12:27:39 -0700 | [diff] [blame] | 98 | pr_err("CRC error 0x%x != 0x%x\n", crc, skb->data[skb->len-1]); |
| 99 | pr_info("%s: BAD CRC\n", __func__); |
Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 100 | return -EPERM; |
| 101 | } |
| 102 | |
| 103 | return 0; |
| 104 | } |
| 105 | |
| 106 | static int microread_i2c_enable(void *phy_id) |
| 107 | { |
| 108 | return 0; |
| 109 | } |
| 110 | |
| 111 | static void microread_i2c_disable(void *phy_id) |
| 112 | { |
| 113 | return; |
| 114 | } |
| 115 | |
| 116 | static int microread_i2c_write(void *phy_id, struct sk_buff *skb) |
| 117 | { |
| 118 | int r; |
| 119 | struct microread_i2c_phy *phy = phy_id; |
| 120 | struct i2c_client *client = phy->i2c_dev; |
| 121 | |
| 122 | if (phy->hard_fault != 0) |
| 123 | return phy->hard_fault; |
| 124 | |
| 125 | usleep_range(3000, 6000); |
| 126 | |
| 127 | microread_i2c_add_len_crc(skb); |
| 128 | |
| 129 | I2C_DUMP_SKB("i2c frame written", skb); |
| 130 | |
| 131 | r = i2c_master_send(client, skb->data, skb->len); |
| 132 | |
| 133 | if (r == -EREMOTEIO) { /* Retry, chip was in standby */ |
| 134 | usleep_range(6000, 10000); |
| 135 | r = i2c_master_send(client, skb->data, skb->len); |
| 136 | } |
| 137 | |
| 138 | if (r >= 0) { |
| 139 | if (r != skb->len) |
| 140 | r = -EREMOTEIO; |
| 141 | else |
| 142 | r = 0; |
| 143 | } |
| 144 | |
| 145 | microread_i2c_remove_len_crc(skb); |
| 146 | |
| 147 | return r; |
| 148 | } |
| 149 | |
| 150 | |
| 151 | static int microread_i2c_read(struct microread_i2c_phy *phy, |
| 152 | struct sk_buff **skb) |
| 153 | { |
| 154 | int r; |
| 155 | u8 len; |
| 156 | u8 tmp[MICROREAD_I2C_LLC_MAX_SIZE - 1]; |
| 157 | struct i2c_client *client = phy->i2c_dev; |
| 158 | |
Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 159 | r = i2c_master_recv(client, &len, 1); |
| 160 | if (r != 1) { |
Joe Perches | 17936b4 | 2013-04-05 12:27:39 -0700 | [diff] [blame] | 161 | nfc_err(&client->dev, "cannot read len byte\n"); |
Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 162 | return -EREMOTEIO; |
| 163 | } |
| 164 | |
| 165 | if ((len < MICROREAD_I2C_LLC_MIN_SIZE) || |
| 166 | (len > MICROREAD_I2C_LLC_MAX_SIZE)) { |
Joe Perches | 17936b4 | 2013-04-05 12:27:39 -0700 | [diff] [blame] | 167 | nfc_err(&client->dev, "invalid len byte\n"); |
Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 168 | r = -EBADMSG; |
| 169 | goto flush; |
| 170 | } |
| 171 | |
| 172 | *skb = alloc_skb(1 + len, GFP_KERNEL); |
| 173 | if (*skb == NULL) { |
| 174 | r = -ENOMEM; |
| 175 | goto flush; |
| 176 | } |
| 177 | |
| 178 | *skb_put(*skb, 1) = len; |
| 179 | |
| 180 | r = i2c_master_recv(client, skb_put(*skb, len), len); |
| 181 | if (r != len) { |
| 182 | kfree_skb(*skb); |
| 183 | return -EREMOTEIO; |
| 184 | } |
| 185 | |
| 186 | I2C_DUMP_SKB("cc frame read", *skb); |
| 187 | |
| 188 | r = check_crc(*skb); |
| 189 | if (r != 0) { |
| 190 | kfree_skb(*skb); |
| 191 | r = -EBADMSG; |
| 192 | goto flush; |
| 193 | } |
| 194 | |
| 195 | skb_pull(*skb, 1); |
| 196 | skb_trim(*skb, (*skb)->len - MICROREAD_I2C_FRAME_TAILROOM); |
| 197 | |
| 198 | usleep_range(3000, 6000); |
| 199 | |
| 200 | return 0; |
| 201 | |
| 202 | flush: |
| 203 | if (i2c_master_recv(client, tmp, sizeof(tmp)) < 0) |
| 204 | r = -EREMOTEIO; |
| 205 | |
| 206 | usleep_range(3000, 6000); |
| 207 | |
| 208 | return r; |
| 209 | } |
| 210 | |
| 211 | static irqreturn_t microread_i2c_irq_thread_fn(int irq, void *phy_id) |
| 212 | { |
| 213 | struct microread_i2c_phy *phy = phy_id; |
| 214 | struct i2c_client *client; |
| 215 | struct sk_buff *skb = NULL; |
| 216 | int r; |
| 217 | |
| 218 | if (!phy || irq != phy->i2c_dev->irq) { |
| 219 | WARN_ON_ONCE(1); |
| 220 | return IRQ_NONE; |
| 221 | } |
| 222 | |
| 223 | client = phy->i2c_dev; |
Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 224 | |
| 225 | if (phy->hard_fault != 0) |
| 226 | return IRQ_HANDLED; |
| 227 | |
| 228 | r = microread_i2c_read(phy, &skb); |
| 229 | if (r == -EREMOTEIO) { |
| 230 | phy->hard_fault = r; |
| 231 | |
| 232 | nfc_hci_recv_frame(phy->hdev, NULL); |
| 233 | |
| 234 | return IRQ_HANDLED; |
| 235 | } else if ((r == -ENOMEM) || (r == -EBADMSG)) { |
| 236 | return IRQ_HANDLED; |
| 237 | } |
| 238 | |
| 239 | nfc_hci_recv_frame(phy->hdev, skb); |
| 240 | |
| 241 | return IRQ_HANDLED; |
| 242 | } |
| 243 | |
| 244 | static struct nfc_phy_ops i2c_phy_ops = { |
| 245 | .write = microread_i2c_write, |
| 246 | .enable = microread_i2c_enable, |
| 247 | .disable = microread_i2c_disable, |
| 248 | }; |
| 249 | |
| 250 | static int microread_i2c_probe(struct i2c_client *client, |
| 251 | const struct i2c_device_id *id) |
| 252 | { |
| 253 | struct microread_i2c_phy *phy; |
| 254 | struct microread_nfc_platform_data *pdata = |
| 255 | dev_get_platdata(&client->dev); |
| 256 | int r; |
| 257 | |
Joe Perches | 17936b4 | 2013-04-05 12:27:39 -0700 | [diff] [blame] | 258 | dev_dbg(&client->dev, "client %p\n", client); |
Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 259 | |
| 260 | if (!pdata) { |
Joe Perches | 17936b4 | 2013-04-05 12:27:39 -0700 | [diff] [blame] | 261 | nfc_err(&client->dev, "client %p: missing platform data\n", |
Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 262 | client); |
| 263 | return -EINVAL; |
| 264 | } |
| 265 | |
| 266 | phy = devm_kzalloc(&client->dev, sizeof(struct microread_i2c_phy), |
| 267 | GFP_KERNEL); |
Joe Perches | 17936b4 | 2013-04-05 12:27:39 -0700 | [diff] [blame] | 268 | if (!phy) |
Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 269 | return -ENOMEM; |
Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 270 | |
| 271 | i2c_set_clientdata(client, phy); |
| 272 | phy->i2c_dev = client; |
| 273 | |
| 274 | r = request_threaded_irq(client->irq, NULL, microread_i2c_irq_thread_fn, |
| 275 | IRQF_TRIGGER_RISING | IRQF_ONESHOT, |
| 276 | MICROREAD_I2C_DRIVER_NAME, phy); |
| 277 | if (r) { |
Joe Perches | 17936b4 | 2013-04-05 12:27:39 -0700 | [diff] [blame] | 278 | nfc_err(&client->dev, "Unable to register IRQ handler\n"); |
Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 279 | return r; |
| 280 | } |
| 281 | |
| 282 | r = microread_probe(phy, &i2c_phy_ops, LLC_SHDLC_NAME, |
| 283 | MICROREAD_I2C_FRAME_HEADROOM, |
| 284 | MICROREAD_I2C_FRAME_TAILROOM, |
| 285 | MICROREAD_I2C_LLC_MAX_PAYLOAD, &phy->hdev); |
| 286 | if (r < 0) |
| 287 | goto err_irq; |
| 288 | |
Joe Perches | 3590ebc | 2015-04-07 00:17:00 -0700 | [diff] [blame^] | 289 | nfc_info(&client->dev, "Probed\n"); |
Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 290 | |
| 291 | return 0; |
| 292 | |
| 293 | err_irq: |
| 294 | free_irq(client->irq, phy); |
| 295 | |
| 296 | return r; |
| 297 | } |
| 298 | |
| 299 | static int microread_i2c_remove(struct i2c_client *client) |
| 300 | { |
| 301 | struct microread_i2c_phy *phy = i2c_get_clientdata(client); |
| 302 | |
Samuel Ortiz | 71054c7 | 2012-12-18 14:56:15 +0100 | [diff] [blame] | 303 | microread_remove(phy->hdev); |
| 304 | |
| 305 | free_irq(client->irq, phy); |
| 306 | |
| 307 | return 0; |
| 308 | } |
| 309 | |
| 310 | static struct i2c_device_id microread_i2c_id[] = { |
| 311 | { MICROREAD_I2C_DRIVER_NAME, 0}, |
| 312 | { } |
| 313 | }; |
| 314 | MODULE_DEVICE_TABLE(i2c, microread_i2c_id); |
| 315 | |
| 316 | static struct i2c_driver microread_i2c_driver = { |
| 317 | .driver = { |
| 318 | .name = MICROREAD_I2C_DRIVER_NAME, |
| 319 | }, |
| 320 | .probe = microread_i2c_probe, |
| 321 | .remove = microread_i2c_remove, |
| 322 | .id_table = microread_i2c_id, |
| 323 | }; |
| 324 | |
| 325 | module_i2c_driver(microread_i2c_driver); |
| 326 | |
| 327 | MODULE_LICENSE("GPL"); |
| 328 | MODULE_DESCRIPTION(DRIVER_DESC); |