nfc/nxp-nci/i2c.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * I2C link layer for the NXP NCI driver
0004  *
0005  * Copyright (C) 2014  NXP Semiconductors  All rights reserved.
0006  * Copyright (C) 2012-2015  Intel Corporation. All rights reserved.
0007  *
0008  * Authors: Clément Perrochaud <clement.perrochaud@nxp.com>
0009  * Authors: Oleg Zhurakivskyy <oleg.zhurakivskyy@intel.com>
0010  *
0011  * Derived from PN544 device driver:
0012  * Copyright (C) 2012  Intel Corporation. All rights reserved.
0013  */
0014
0015 #include <linux/acpi.h>
0016 #include <linux/delay.h>
0017 #include <linux/i2c.h>
0018 #include <linux/interrupt.h>
0019 #include <linux/module.h>
0020 #include <linux/nfc.h>
0021 #include <linux/gpio/consumer.h>
0022 #include <asm/unaligned.h>
0023
0024 #include <net/nfc/nfc.h>
0025
0026 #include "nxp-nci.h"
0027
0028 #define NXP_NCI_I2C_DRIVER_NAME "nxp-nci_i2c"
0029
0030 #define NXP_NCI_I2C_MAX_PAYLOAD 32
0031
0032 struct nxp_nci_i2c_phy {
0033     struct i2c_client *i2c_dev;
0034     struct nci_dev *ndev;
0035
0036     struct gpio_desc *gpiod_en;
0037     struct gpio_desc *gpiod_fw;
0038
0039     int hard_fault; /*
0040              * < 0 if hardware error occurred (e.g. i2c err)
0041              * and prevents normal operation.
0042              */
0043 };
0044
0045 static int nxp_nci_i2c_set_mode(void *phy_id,
0046                     enum nxp_nci_mode mode)
0047 {
0048     struct nxp_nci_i2c_phy *phy = (struct nxp_nci_i2c_phy *) phy_id;
0049
0050     gpiod_set_value(phy->gpiod_fw, (mode == NXP_NCI_MODE_FW) ? 1 : 0);
0051     gpiod_set_value(phy->gpiod_en, (mode != NXP_NCI_MODE_COLD) ? 1 : 0);
0052     usleep_range(10000, 15000);
0053
0054     if (mode == NXP_NCI_MODE_COLD)
0055         phy->hard_fault = 0;
0056
0057     return 0;
0058 }
0059
0060 static int nxp_nci_i2c_write(void *phy_id, struct sk_buff *skb)
0061 {
0062     int r;
0063     struct nxp_nci_i2c_phy *phy = phy_id;
0064     struct i2c_client *client = phy->i2c_dev;
0065
0066     if (phy->hard_fault != 0)
0067         return phy->hard_fault;
0068
0069     r = i2c_master_send(client, skb->data, skb->len);
0070     if (r < 0) {
0071         /* Retry, chip was in standby */
0072         msleep(110);
0073         r = i2c_master_send(client, skb->data, skb->len);
0074     }
0075
0076     if (r < 0) {
0077         nfc_err(&client->dev, "Error %d on I2C send\n", r);
0078     } else if (r != skb->len) {
0079         nfc_err(&client->dev,
0080             "Invalid length sent: %u (expected %u)\n",
0081             r, skb->len);
0082         r = -EREMOTEIO;
0083     } else {
0084         /* Success but return 0 and not number of bytes */
0085         r = 0;
0086     }
0087
0088     return r;
0089 }
0090
0091 static const struct nxp_nci_phy_ops i2c_phy_ops = {
0092     .set_mode = nxp_nci_i2c_set_mode,
0093     .write = nxp_nci_i2c_write,
0094 };
0095
0096 static int nxp_nci_i2c_fw_read(struct nxp_nci_i2c_phy *phy,
0097                    struct sk_buff **skb)
0098 {
0099     struct i2c_client *client = phy->i2c_dev;
0100     u16 header;
0101     size_t frame_len;
0102     int r;
0103
0104     r = i2c_master_recv(client, (u8 *) &header, NXP_NCI_FW_HDR_LEN);
0105     if (r < 0) {
0106         goto fw_read_exit;
0107     } else if (r != NXP_NCI_FW_HDR_LEN) {
0108         nfc_err(&client->dev, "Incorrect header length: %u\n", r);
0109         r = -EBADMSG;
0110         goto fw_read_exit;
0111     }
0112
0113     frame_len = (be16_to_cpu(header) & NXP_NCI_FW_FRAME_LEN_MASK) +
0114             NXP_NCI_FW_CRC_LEN;
0115
0116     *skb = alloc_skb(NXP_NCI_FW_HDR_LEN + frame_len, GFP_KERNEL);
0117     if (*skb == NULL) {
0118         r = -ENOMEM;
0119         goto fw_read_exit;
0120     }
0121
0122     skb_put_data(*skb, &header, NXP_NCI_FW_HDR_LEN);
0123
0124     r = i2c_master_recv(client, skb_put(*skb, frame_len), frame_len);
0125     if (r < 0) {
0126         goto fw_read_exit_free_skb;
0127     } else if (r != frame_len) {
0128         nfc_err(&client->dev,
0129             "Invalid frame length: %u (expected %zu)\n",
0130             r, frame_len);
0131         r = -EBADMSG;
0132         goto fw_read_exit_free_skb;
0133     }
0134
0135     return 0;
0136
0137 fw_read_exit_free_skb:
0138     kfree_skb(*skb);
0139 fw_read_exit:
0140     return r;
0141 }
0142
0143 static int nxp_nci_i2c_nci_read(struct nxp_nci_i2c_phy *phy,
0144                 struct sk_buff **skb)
0145 {
0146     struct nci_ctrl_hdr header; /* May actually be a data header */
0147     struct i2c_client *client = phy->i2c_dev;
0148     int r;
0149
0150     r = i2c_master_recv(client, (u8 *) &header, NCI_CTRL_HDR_SIZE);
0151     if (r < 0) {
0152         goto nci_read_exit;
0153     } else if (r != NCI_CTRL_HDR_SIZE) {
0154         nfc_err(&client->dev, "Incorrect header length: %u\n", r);
0155         r = -EBADMSG;
0156         goto nci_read_exit;
0157     }
0158
0159     *skb = alloc_skb(NCI_CTRL_HDR_SIZE + header.plen, GFP_KERNEL);
0160     if (*skb == NULL) {
0161         r = -ENOMEM;
0162         goto nci_read_exit;
0163     }
0164
0165     skb_put_data(*skb, (void *)&header, NCI_CTRL_HDR_SIZE);
0166
0167     if (!header.plen)
0168         return 0;
0169
0170     r = i2c_master_recv(client, skb_put(*skb, header.plen), header.plen);
0171     if (r < 0) {
0172         goto nci_read_exit_free_skb;
0173     } else if (r != header.plen) {
0174         nfc_err(&client->dev,
0175             "Invalid frame payload length: %u (expected %u)\n",
0176             r, header.plen);
0177         r = -EBADMSG;
0178         goto nci_read_exit_free_skb;
0179     }
0180
0181     return 0;
0182
0183 nci_read_exit_free_skb:
0184     kfree_skb(*skb);
0185 nci_read_exit:
0186     return r;
0187 }
0188
0189 static irqreturn_t nxp_nci_i2c_irq_thread_fn(int irq, void *phy_id)
0190 {
0191     struct nxp_nci_i2c_phy *phy = phy_id;
0192     struct i2c_client *client;
0193     struct nxp_nci_info *info;
0194
0195     struct sk_buff *skb = NULL;
0196     int r = 0;
0197
0198     if (!phy || !phy->ndev)
0199         goto exit_irq_none;
0200
0201     client = phy->i2c_dev;
0202
0203     if (!client || irq != client->irq)
0204         goto exit_irq_none;
0205
0206     info = nci_get_drvdata(phy->ndev);
0207
0208     if (!info)
0209         goto exit_irq_none;
0210
0211     mutex_lock(&info->info_lock);
0212
0213     if (phy->hard_fault != 0)
0214         goto exit_irq_handled;
0215
0216     switch (info->mode) {
0217     case NXP_NCI_MODE_NCI:
0218         r = nxp_nci_i2c_nci_read(phy, &skb);
0219         break;
0220     case NXP_NCI_MODE_FW:
0221         r = nxp_nci_i2c_fw_read(phy, &skb);
0222         break;
0223     case NXP_NCI_MODE_COLD:
0224         r = -EREMOTEIO;
0225         break;
0226     }
0227
0228     if (r == -EREMOTEIO) {
0229         phy->hard_fault = r;
0230         if (info->mode == NXP_NCI_MODE_FW)
0231             nxp_nci_fw_recv_frame(phy->ndev, NULL);
0232     }
0233     if (r < 0) {
0234         nfc_err(&client->dev, "Read failed with error %d\n", r);
0235         goto exit_irq_handled;
0236     }
0237
0238     switch (info->mode) {
0239     case NXP_NCI_MODE_NCI:
0240         nci_recv_frame(phy->ndev, skb);
0241         break;
0242     case NXP_NCI_MODE_FW:
0243         nxp_nci_fw_recv_frame(phy->ndev, skb);
0244         break;
0245     case NXP_NCI_MODE_COLD:
0246         break;
0247     }
0248
0249 exit_irq_handled:
0250     mutex_unlock(&info->info_lock);
0251     return IRQ_HANDLED;
0252 exit_irq_none:
0253     WARN_ON_ONCE(1);
0254     return IRQ_NONE;
0255 }
0256
0257 static const struct acpi_gpio_params firmware_gpios = { 1, 0, false };
0258 static const struct acpi_gpio_params enable_gpios = { 2, 0, false };
0259
0260 static const struct acpi_gpio_mapping acpi_nxp_nci_gpios[] = {
0261     { "enable-gpios", &enable_gpios, 1 },
0262     { "firmware-gpios", &firmware_gpios, 1 },
0263     { }
0264 };
0265
0266 static int nxp_nci_i2c_probe(struct i2c_client *client,
0267                 const struct i2c_device_id *id)
0268 {
0269     struct device *dev = &client->dev;
0270     struct nxp_nci_i2c_phy *phy;
0271     int r;
0272
0273     if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
0274         nfc_err(&client->dev, "Need I2C_FUNC_I2C\n");
0275         return -ENODEV;
0276     }
0277
0278     phy = devm_kzalloc(&client->dev, sizeof(struct nxp_nci_i2c_phy),
0279                GFP_KERNEL);
0280     if (!phy)
0281         return -ENOMEM;
0282
0283     phy->i2c_dev = client;
0284     i2c_set_clientdata(client, phy);
0285
0286     r = devm_acpi_dev_add_driver_gpios(dev, acpi_nxp_nci_gpios);
0287     if (r)
0288         dev_dbg(dev, "Unable to add GPIO mapping table\n");
0289
0290     phy->gpiod_en = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW);
0291     if (IS_ERR(phy->gpiod_en)) {
0292         nfc_err(dev, "Failed to get EN gpio\n");
0293         return PTR_ERR(phy->gpiod_en);
0294     }
0295
0296     phy->gpiod_fw = devm_gpiod_get_optional(dev, "firmware", GPIOD_OUT_LOW);
0297     if (IS_ERR(phy->gpiod_fw)) {
0298         nfc_err(dev, "Failed to get FW gpio\n");
0299         return PTR_ERR(phy->gpiod_fw);
0300     }
0301
0302     r = nxp_nci_probe(phy, &client->dev, &i2c_phy_ops,
0303               NXP_NCI_I2C_MAX_PAYLOAD, &phy->ndev);
0304     if (r < 0)
0305         return r;
0306
0307     r = request_threaded_irq(client->irq, NULL,
0308                  nxp_nci_i2c_irq_thread_fn,
0309                  IRQF_TRIGGER_RISING | IRQF_ONESHOT,
0310                  NXP_NCI_I2C_DRIVER_NAME, phy);
0311     if (r < 0)
0312         nfc_err(&client->dev, "Unable to register IRQ handler\n");
0313
0314     return r;
0315 }
0316
0317 static int nxp_nci_i2c_remove(struct i2c_client *client)
0318 {
0319     struct nxp_nci_i2c_phy *phy = i2c_get_clientdata(client);
0320
0321     nxp_nci_remove(phy->ndev);
0322     free_irq(client->irq, phy);
0323
0324     return 0;
0325 }
0326
0327 static const struct i2c_device_id nxp_nci_i2c_id_table[] = {
0328     {"nxp-nci_i2c", 0},
0329     {}
0330 };
0331 MODULE_DEVICE_TABLE(i2c, nxp_nci_i2c_id_table);
0332
0333 static const struct of_device_id of_nxp_nci_i2c_match[] = {
0334     { .compatible = "nxp,nxp-nci-i2c", },
0335     {}
0336 };
0337 MODULE_DEVICE_TABLE(of, of_nxp_nci_i2c_match);
0338
0339 #ifdef CONFIG_ACPI
0340 static const struct acpi_device_id acpi_id[] = {
0341     { "NXP1001" },
0342     { "NXP7471" },
0343     { }
0344 };
0345 MODULE_DEVICE_TABLE(acpi, acpi_id);
0346 #endif
0347
0348 static struct i2c_driver nxp_nci_i2c_driver = {
0349     .driver = {
0350            .name = NXP_NCI_I2C_DRIVER_NAME,
0351            .acpi_match_table = ACPI_PTR(acpi_id),
0352            .of_match_table = of_nxp_nci_i2c_match,
0353           },
0354     .probe = nxp_nci_i2c_probe,
0355     .id_table = nxp_nci_i2c_id_table,
0356     .remove = nxp_nci_i2c_remove,
0357 };
0358
0359 module_i2c_driver(nxp_nci_i2c_driver);
0360
0361 MODULE_LICENSE("GPL");
0362 MODULE_DESCRIPTION("I2C driver for NXP NCI NFC controllers");
0363 MODULE_AUTHOR("Clément Perrochaud <clement.perrochaud@nxp.com>");
0364 MODULE_AUTHOR("Oleg Zhurakivskyy <oleg.zhurakivskyy@intel.com>");