1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * I2C link layer for the NXP NCI driver 4 * 5 * Copyright (C) 2014 NXP Semiconductors All rights reserved. 6 * Copyright (C) 2012-2015 Intel Corporation. All rights reserved. 7 * 8 * Authors: Clément Perrochaud <clement.perrochaud@nxp.com> 9 * Authors: Oleg Zhurakivskyy <oleg.zhurakivskyy@intel.com> 10 * 11 * Derived from PN544 device driver: 12 * Copyright (C) 2012 Intel Corporation. All rights reserved. 13 */ 14 15 #include <linux/acpi.h> 16 #include <linux/delay.h> 17 #include <linux/i2c.h> 18 #include <linux/interrupt.h> 19 #include <linux/module.h> 20 #include <linux/nfc.h> 21 #include <linux/gpio/consumer.h> 22 #include <asm/unaligned.h> 23 24 #include <net/nfc/nfc.h> 25 26 #include "nxp-nci.h" 27 28 #define NXP_NCI_I2C_DRIVER_NAME "nxp-nci_i2c" 29 30 #define NXP_NCI_I2C_MAX_PAYLOAD 32 31 32 struct nxp_nci_i2c_phy { 33 struct i2c_client *i2c_dev; 34 struct nci_dev *ndev; 35 36 struct gpio_desc *gpiod_en; 37 struct gpio_desc *gpiod_fw; 38 39 int hard_fault; /* 40 * < 0 if hardware error occurred (e.g. i2c err) 41 * and prevents normal operation. 42 */ 43 }; 44 45 static int nxp_nci_i2c_set_mode(void *phy_id, 46 enum nxp_nci_mode mode) 47 { 48 struct nxp_nci_i2c_phy *phy = (struct nxp_nci_i2c_phy *) phy_id; 49 50 gpiod_set_value(phy->gpiod_fw, (mode == NXP_NCI_MODE_FW) ? 1 : 0); 51 gpiod_set_value(phy->gpiod_en, (mode != NXP_NCI_MODE_COLD) ? 1 : 0); 52 usleep_range(10000, 15000); 53 54 if (mode == NXP_NCI_MODE_COLD) 55 phy->hard_fault = 0; 56 57 return 0; 58 } 59 60 static int nxp_nci_i2c_write(void *phy_id, struct sk_buff *skb) 61 { 62 int r; 63 struct nxp_nci_i2c_phy *phy = phy_id; 64 struct i2c_client *client = phy->i2c_dev; 65 66 if (phy->hard_fault != 0) 67 return phy->hard_fault; 68 69 r = i2c_master_send(client, skb->data, skb->len); 70 if (r < 0) { 71 /* Retry, chip was in standby */ 72 msleep(110); 73 r = i2c_master_send(client, skb->data, skb->len); 74 } 75 76 if (r < 0) { 77 nfc_err(&client->dev, "Error %d on I2C send\n", r); 78 } else if (r != skb->len) { 79 nfc_err(&client->dev, 80 "Invalid length sent: %u (expected %u)\n", 81 r, skb->len); 82 r = -EREMOTEIO; 83 } else { 84 /* Success but return 0 and not number of bytes */ 85 r = 0; 86 } 87 88 return r; 89 } 90 91 static const struct nxp_nci_phy_ops i2c_phy_ops = { 92 .set_mode = nxp_nci_i2c_set_mode, 93 .write = nxp_nci_i2c_write, 94 }; 95 96 static int nxp_nci_i2c_fw_read(struct nxp_nci_i2c_phy *phy, 97 struct sk_buff **skb) 98 { 99 struct i2c_client *client = phy->i2c_dev; 100 u16 header; 101 size_t frame_len; 102 int r; 103 104 r = i2c_master_recv(client, (u8 *) &header, NXP_NCI_FW_HDR_LEN); 105 if (r < 0) { 106 goto fw_read_exit; 107 } else if (r != NXP_NCI_FW_HDR_LEN) { 108 nfc_err(&client->dev, "Incorrect header length: %u\n", r); 109 r = -EBADMSG; 110 goto fw_read_exit; 111 } 112 113 frame_len = (be16_to_cpu(header) & NXP_NCI_FW_FRAME_LEN_MASK) + 114 NXP_NCI_FW_CRC_LEN; 115 116 *skb = alloc_skb(NXP_NCI_FW_HDR_LEN + frame_len, GFP_KERNEL); 117 if (*skb == NULL) { 118 r = -ENOMEM; 119 goto fw_read_exit; 120 } 121 122 skb_put_data(*skb, &header, NXP_NCI_FW_HDR_LEN); 123 124 r = i2c_master_recv(client, skb_put(*skb, frame_len), frame_len); 125 if (r != frame_len) { 126 nfc_err(&client->dev, 127 "Invalid frame length: %u (expected %zu)\n", 128 r, frame_len); 129 r = -EBADMSG; 130 goto fw_read_exit_free_skb; 131 } 132 133 return 0; 134 135 fw_read_exit_free_skb: 136 kfree_skb(*skb); 137 fw_read_exit: 138 return r; 139 } 140 141 static int nxp_nci_i2c_nci_read(struct nxp_nci_i2c_phy *phy, 142 struct sk_buff **skb) 143 { 144 struct nci_ctrl_hdr header; /* May actually be a data header */ 145 struct i2c_client *client = phy->i2c_dev; 146 int r; 147 148 r = i2c_master_recv(client, (u8 *) &header, NCI_CTRL_HDR_SIZE); 149 if (r < 0) { 150 goto nci_read_exit; 151 } else if (r != NCI_CTRL_HDR_SIZE) { 152 nfc_err(&client->dev, "Incorrect header length: %u\n", r); 153 r = -EBADMSG; 154 goto nci_read_exit; 155 } 156 157 *skb = alloc_skb(NCI_CTRL_HDR_SIZE + header.plen, GFP_KERNEL); 158 if (*skb == NULL) { 159 r = -ENOMEM; 160 goto nci_read_exit; 161 } 162 163 skb_put_data(*skb, (void *)&header, NCI_CTRL_HDR_SIZE); 164 165 r = i2c_master_recv(client, skb_put(*skb, header.plen), header.plen); 166 if (r != header.plen) { 167 nfc_err(&client->dev, 168 "Invalid frame payload length: %u (expected %u)\n", 169 r, header.plen); 170 r = -EBADMSG; 171 goto nci_read_exit_free_skb; 172 } 173 174 return 0; 175 176 nci_read_exit_free_skb: 177 kfree_skb(*skb); 178 nci_read_exit: 179 return r; 180 } 181 182 static irqreturn_t nxp_nci_i2c_irq_thread_fn(int irq, void *phy_id) 183 { 184 struct nxp_nci_i2c_phy *phy = phy_id; 185 struct i2c_client *client; 186 struct nxp_nci_info *info; 187 188 struct sk_buff *skb = NULL; 189 int r = 0; 190 191 if (!phy || !phy->ndev) 192 goto exit_irq_none; 193 194 client = phy->i2c_dev; 195 196 if (!client || irq != client->irq) 197 goto exit_irq_none; 198 199 info = nci_get_drvdata(phy->ndev); 200 201 if (!info) 202 goto exit_irq_none; 203 204 mutex_lock(&info->info_lock); 205 206 if (phy->hard_fault != 0) 207 goto exit_irq_handled; 208 209 switch (info->mode) { 210 case NXP_NCI_MODE_NCI: 211 r = nxp_nci_i2c_nci_read(phy, &skb); 212 break; 213 case NXP_NCI_MODE_FW: 214 r = nxp_nci_i2c_fw_read(phy, &skb); 215 break; 216 case NXP_NCI_MODE_COLD: 217 r = -EREMOTEIO; 218 break; 219 } 220 221 if (r == -EREMOTEIO) { 222 phy->hard_fault = r; 223 if (info->mode == NXP_NCI_MODE_FW) 224 nxp_nci_fw_recv_frame(phy->ndev, NULL); 225 } 226 if (r < 0) { 227 nfc_err(&client->dev, "Read failed with error %d\n", r); 228 goto exit_irq_handled; 229 } 230 231 switch (info->mode) { 232 case NXP_NCI_MODE_NCI: 233 nci_recv_frame(phy->ndev, skb); 234 break; 235 case NXP_NCI_MODE_FW: 236 nxp_nci_fw_recv_frame(phy->ndev, skb); 237 break; 238 case NXP_NCI_MODE_COLD: 239 break; 240 } 241 242 exit_irq_handled: 243 mutex_unlock(&info->info_lock); 244 return IRQ_HANDLED; 245 exit_irq_none: 246 WARN_ON_ONCE(1); 247 return IRQ_NONE; 248 } 249 250 static const struct acpi_gpio_params firmware_gpios = { 1, 0, false }; 251 static const struct acpi_gpio_params enable_gpios = { 2, 0, false }; 252 253 static const struct acpi_gpio_mapping acpi_nxp_nci_gpios[] = { 254 { "enable-gpios", &enable_gpios, 1 }, 255 { "firmware-gpios", &firmware_gpios, 1 }, 256 { } 257 }; 258 259 static int nxp_nci_i2c_probe(struct i2c_client *client, 260 const struct i2c_device_id *id) 261 { 262 struct device *dev = &client->dev; 263 struct nxp_nci_i2c_phy *phy; 264 int r; 265 266 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 267 nfc_err(&client->dev, "Need I2C_FUNC_I2C\n"); 268 return -ENODEV; 269 } 270 271 phy = devm_kzalloc(&client->dev, sizeof(struct nxp_nci_i2c_phy), 272 GFP_KERNEL); 273 if (!phy) 274 return -ENOMEM; 275 276 phy->i2c_dev = client; 277 i2c_set_clientdata(client, phy); 278 279 r = devm_acpi_dev_add_driver_gpios(dev, acpi_nxp_nci_gpios); 280 if (r) 281 dev_dbg(dev, "Unable to add GPIO mapping table\n"); 282 283 phy->gpiod_en = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW); 284 if (IS_ERR(phy->gpiod_en)) { 285 nfc_err(dev, "Failed to get EN gpio\n"); 286 return PTR_ERR(phy->gpiod_en); 287 } 288 289 phy->gpiod_fw = devm_gpiod_get(dev, "firmware", GPIOD_OUT_LOW); 290 if (IS_ERR(phy->gpiod_fw)) { 291 nfc_err(dev, "Failed to get FW gpio\n"); 292 return PTR_ERR(phy->gpiod_fw); 293 } 294 295 r = nxp_nci_probe(phy, &client->dev, &i2c_phy_ops, 296 NXP_NCI_I2C_MAX_PAYLOAD, &phy->ndev); 297 if (r < 0) 298 return r; 299 300 r = request_threaded_irq(client->irq, NULL, 301 nxp_nci_i2c_irq_thread_fn, 302 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 303 NXP_NCI_I2C_DRIVER_NAME, phy); 304 if (r < 0) 305 nfc_err(&client->dev, "Unable to register IRQ handler\n"); 306 307 return r; 308 } 309 310 static int nxp_nci_i2c_remove(struct i2c_client *client) 311 { 312 struct nxp_nci_i2c_phy *phy = i2c_get_clientdata(client); 313 314 nxp_nci_remove(phy->ndev); 315 free_irq(client->irq, phy); 316 317 return 0; 318 } 319 320 static const struct i2c_device_id nxp_nci_i2c_id_table[] = { 321 {"nxp-nci_i2c", 0}, 322 {} 323 }; 324 MODULE_DEVICE_TABLE(i2c, nxp_nci_i2c_id_table); 325 326 static const struct of_device_id of_nxp_nci_i2c_match[] = { 327 { .compatible = "nxp,nxp-nci-i2c", }, 328 {} 329 }; 330 MODULE_DEVICE_TABLE(of, of_nxp_nci_i2c_match); 331 332 #ifdef CONFIG_ACPI 333 static const struct acpi_device_id acpi_id[] = { 334 { "NXP1001" }, 335 { "NXP7471" }, 336 { } 337 }; 338 MODULE_DEVICE_TABLE(acpi, acpi_id); 339 #endif 340 341 static struct i2c_driver nxp_nci_i2c_driver = { 342 .driver = { 343 .name = NXP_NCI_I2C_DRIVER_NAME, 344 .acpi_match_table = ACPI_PTR(acpi_id), 345 .of_match_table = of_nxp_nci_i2c_match, 346 }, 347 .probe = nxp_nci_i2c_probe, 348 .id_table = nxp_nci_i2c_id_table, 349 .remove = nxp_nci_i2c_remove, 350 }; 351 352 module_i2c_driver(nxp_nci_i2c_driver); 353 354 MODULE_LICENSE("GPL"); 355 MODULE_DESCRIPTION("I2C driver for NXP NCI NFC controllers"); 356 MODULE_AUTHOR("Clément Perrochaud <clement.perrochaud@nxp.com>"); 357 MODULE_AUTHOR("Oleg Zhurakivskyy <oleg.zhurakivskyy@intel.com>"); 358