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