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>"); 389