| @@ -0,0 +1,290 @@ |
| | 1 | /** |
| | 2 | * Marvell NFC-over-I2C driver: I2C interface related functions |
| | 3 | * |
| | 4 | * Copyright (C) 2015, Marvell International Ltd. |
| | 5 | * |
| | 6 | * This software file (the "File") is distributed by Marvell International |
| | 7 | * Ltd. under the terms of the GNU General Public License Version 2, June 1991 |
| | 8 | * (the "License"). You may use, redistribute and/or modify this File in |
| | 9 | * accordance with the terms and conditions of the License, a copy of which |
| | 10 | * is available on the worldwide web at |
| | 11 | * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. |
| | 12 | * |
| | 13 | * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE |
| | 14 | * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE |
| | 15 | * ARE EXPRESSLY DISCLAIMED. The License provides additional details about |
| | 16 | * this warranty disclaimer. |
| | 17 | **/ |
| | 18 | |
| | 19 | #include <linux/module.h> |
| | 20 | #include <linux/interrupt.h> |
| | 21 | #include <linux/i2c.h> |
| | 22 | #include <linux/pm_runtime.h> |
| | 23 | #include <linux/nfc.h> |
| | 24 | #include <linux/gpio.h> |
| | 25 | #include <linux/delay.h> |
| | 26 | #include <linux/of_irq.h> |
| | 27 | #include <linux/of_gpio.h> |
| | 28 | #include <net/nfc/nci.h> |
| | 29 | #include <net/nfc/nci_core.h> |
| | 30 | #include "nfcmrvl.h" |
| | 31 | |
| | 32 | struct nfcmrvl_i2c_drv_data { |
| | 33 | unsigned long flags; |
| | 34 | struct device *dev; |
| | 35 | struct i2c_client *i2c; |
| | 36 | struct nfcmrvl_private *priv; |
| | 37 | }; |
| | 38 | |
| | 39 | static int nfcmrvl_i2c_read(struct nfcmrvl_i2c_drv_data *drv_data, |
| | 40 | struct sk_buff **skb) |
| | 41 | { |
| | 42 | int ret; |
| | 43 | struct nci_ctrl_hdr nci_hdr; |
| | 44 | |
| | 45 | /* Read NCI header to know the payload size */ |
| | 46 | ret = i2c_master_recv(drv_data->i2c, (u8 *)&nci_hdr, NCI_CTRL_HDR_SIZE); |
| | 47 | if (ret != NCI_CTRL_HDR_SIZE) { |
| | 48 | nfc_err(&drv_data->i2c->dev, "cannot read NCI header\n"); |
| | 49 | return -EBADMSG; |
| | 50 | } |
| | 51 | |
| | 52 | if (nci_hdr.plen > NCI_MAX_PAYLOAD_SIZE) { |
| | 53 | nfc_err(&drv_data->i2c->dev, "invalid packet payload size\n"); |
| | 54 | return -EBADMSG; |
| | 55 | } |
| | 56 | |
| | 57 | *skb = nci_skb_alloc(drv_data->priv->ndev, |
| | 58 | nci_hdr.plen + NCI_CTRL_HDR_SIZE, GFP_KERNEL); |
| | 59 | if (!*skb) |
| | 60 | return -ENOMEM; |
| | 61 | |
| | 62 | /* Copy NCI header into the SKB */ |
| | 63 | memcpy(skb_put(*skb, NCI_CTRL_HDR_SIZE), &nci_hdr, NCI_CTRL_HDR_SIZE); |
| | 64 | |
| | 65 | if (nci_hdr.plen) { |
| | 66 | /* Read the NCI payload */ |
| | 67 | ret = i2c_master_recv(drv_data->i2c, |
| | 68 | skb_put(*skb, nci_hdr.plen), |
| | 69 | nci_hdr.plen); |
| | 70 | |
| | 71 | if (ret != nci_hdr.plen) { |
| | 72 | nfc_err(&drv_data->i2c->dev, |
| | 73 | "Invalid frame payload length: %u (expected %u)\n", |
| | 74 | ret, nci_hdr.plen); |
| | 75 | kfree_skb(*skb); |
| | 76 | return -EBADMSG; |
| | 77 | } |
| | 78 | } |
| | 79 | |
| | 80 | return 0; |
| | 81 | } |
| | 82 | |
| | 83 | static irqreturn_t nfcmrvl_i2c_int_irq_thread_fn(int irq, void *drv_data_ptr) |
| | 84 | { |
| | 85 | struct nfcmrvl_i2c_drv_data *drv_data = drv_data_ptr; |
| | 86 | struct sk_buff *skb = NULL; |
| | 87 | int ret; |
| | 88 | |
| | 89 | if (!drv_data->priv) |
| | 90 | return IRQ_HANDLED; |
| | 91 | |
| | 92 | if (test_bit(NFCMRVL_PHY_ERROR, &drv_data->priv->flags)) |
| | 93 | return IRQ_HANDLED; |
| | 94 | |
| | 95 | ret = nfcmrvl_i2c_read(drv_data, &skb); |
| | 96 | |
| | 97 | switch (ret) { |
| | 98 | case -EREMOTEIO: |
| | 99 | set_bit(NFCMRVL_PHY_ERROR, &drv_data->priv->flags); |
| | 100 | break; |
| | 101 | case -ENOMEM: |
| | 102 | case -EBADMSG: |
| | 103 | nfc_err(&drv_data->i2c->dev, "read failed %d\n", ret); |
| | 104 | break; |
| | 105 | default: |
| | 106 | if (nfcmrvl_nci_recv_frame(drv_data->priv, skb) < 0) |
| | 107 | nfc_err(&drv_data->i2c->dev, "corrupted RX packet\n"); |
| | 108 | break; |
| | 109 | } |
| | 110 | return IRQ_HANDLED; |
| | 111 | } |
| | 112 | |
| | 113 | static int nfcmrvl_i2c_nci_open(struct nfcmrvl_private *priv) |
| | 114 | { |
| | 115 | struct nfcmrvl_i2c_drv_data *drv_data = priv->drv_data; |
| | 116 | |
| | 117 | if (!drv_data) |
| | 118 | return -ENODEV; |
| | 119 | |
| | 120 | return 0; |
| | 121 | } |
| | 122 | |
| | 123 | static int nfcmrvl_i2c_nci_close(struct nfcmrvl_private *priv) |
| | 124 | { |
| | 125 | return 0; |
| | 126 | } |
| | 127 | |
| | 128 | static int nfcmrvl_i2c_nci_send(struct nfcmrvl_private *priv, |
| | 129 | struct sk_buff *skb) |
| | 130 | { |
| | 131 | struct nfcmrvl_i2c_drv_data *drv_data = priv->drv_data; |
| | 132 | int ret; |
| | 133 | |
| | 134 | if (test_bit(NFCMRVL_PHY_ERROR, &priv->flags)) |
| | 135 | return -EREMOTEIO; |
| | 136 | |
| | 137 | ret = i2c_master_send(drv_data->i2c, skb->data, skb->len); |
| | 138 | |
| | 139 | /* Retry if chip was in standby */ |
| | 140 | if (ret == -EREMOTEIO) { |
| | 141 | nfc_info(drv_data->dev, "chip may sleep, retry\n"); |
| | 142 | usleep_range(6000, 10000); |
| | 143 | ret = i2c_master_send(drv_data->i2c, skb->data, skb->len); |
| | 144 | } |
| | 145 | |
| | 146 | if (ret >= 0) { |
| | 147 | if (ret != skb->len) { |
| | 148 | nfc_err(drv_data->dev, |
| | 149 | "Invalid length sent: %u (expected %u)\n", |
| | 150 | ret, skb->len); |
| | 151 | ret = -EREMOTEIO; |
| | 152 | } else |
| | 153 | ret = 0; |
| | 154 | kfree_skb(skb); |
| | 155 | } |
| | 156 | |
| | 157 | return ret; |
| | 158 | } |
| | 159 | |
| | 160 | static void nfcmrvl_i2c_nci_update_config(struct nfcmrvl_private *priv, |
| | 161 | const void *param) |
| | 162 | { |
| | 163 | } |
| | 164 | |
| | 165 | static struct nfcmrvl_if_ops i2c_ops = { |
| | 166 | .nci_open = nfcmrvl_i2c_nci_open, |
| | 167 | .nci_close = nfcmrvl_i2c_nci_close, |
| | 168 | .nci_send = nfcmrvl_i2c_nci_send, |
| | 169 | .nci_update_config = nfcmrvl_i2c_nci_update_config, |
| | 170 | }; |
| | 171 | |
| | 172 | static int nfcmrvl_i2c_parse_dt(struct device_node *node, |
| | 173 | struct nfcmrvl_platform_data *pdata) |
| | 174 | { |
| | 175 | int ret; |
| | 176 | |
| | 177 | ret = nfcmrvl_parse_dt(node, pdata); |
| | 178 | if (ret < 0) { |
| | 179 | pr_err("Failed to get generic entries\n"); |
| | 180 | return ret; |
| | 181 | } |
| | 182 | |
| | 183 | if (of_find_property(node, "i2c-int-falling", NULL)) |
| | 184 | pdata->irq_polarity = IRQF_TRIGGER_FALLING; |
| | 185 | else |
| | 186 | pdata->irq_polarity = IRQF_TRIGGER_RISING; |
| | 187 | |
| | 188 | ret = irq_of_parse_and_map(node, 0); |
| | 189 | if (ret < 0) { |
| | 190 | pr_err("Unable to get irq, error: %d\n", ret); |
| | 191 | return ret; |
| | 192 | } |
| | 193 | pdata->irq = ret; |
| | 194 | |
| | 195 | return 0; |
| | 196 | } |
| | 197 | |
| | 198 | static int nfcmrvl_i2c_probe(struct i2c_client *client, |
| | 199 | const struct i2c_device_id *id) |
| | 200 | { |
| | 201 | struct nfcmrvl_i2c_drv_data *drv_data; |
| | 202 | struct nfcmrvl_platform_data *pdata; |
| | 203 | struct nfcmrvl_platform_data config; |
| | 204 | int ret; |
| | 205 | |
| | 206 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { |
| | 207 | nfc_err(&client->dev, "Need I2C_FUNC_I2C\n"); |
| | 208 | return -ENODEV; |
| | 209 | } |
| | 210 | |
| | 211 | drv_data = devm_kzalloc(&client->dev, sizeof(*drv_data), GFP_KERNEL); |
| | 212 | if (!drv_data) |
| | 213 | return -ENOMEM; |
| | 214 | |
| | 215 | drv_data->i2c = client; |
| | 216 | drv_data->dev = &client->dev; |
| | 217 | drv_data->priv = NULL; |
| | 218 | |
| | 219 | i2c_set_clientdata(client, drv_data); |
| | 220 | |
| | 221 | pdata = client->dev.platform_data; |
| | 222 | |
| | 223 | if (!pdata && client->dev.of_node) |
| | 224 | if (nfcmrvl_i2c_parse_dt(client->dev.of_node, &config) == 0) |
| | 225 | pdata = &config; |
| | 226 | |
| | 227 | if (!pdata) |
| | 228 | return -EINVAL; |
| | 229 | |
| | 230 | /* Request the read IRQ */ |
| | 231 | ret = devm_request_threaded_irq(&drv_data->i2c->dev, pdata->irq, |
| | 232 | NULL, nfcmrvl_i2c_int_irq_thread_fn, |
| | 233 | pdata->irq_polarity | IRQF_ONESHOT, |
| | 234 | "nfcmrvl_i2c_int", drv_data); |
| | 235 | if (ret < 0) { |
| | 236 | nfc_err(&drv_data->i2c->dev, |
| | 237 | "Unable to register IRQ handler\n"); |
| | 238 | return ret; |
| | 239 | } |
| | 240 | |
| | 241 | drv_data->priv = nfcmrvl_nci_register_dev(NFCMRVL_PHY_I2C, |
| | 242 | drv_data, &i2c_ops, |
| | 243 | &drv_data->i2c->dev, pdata); |
| | 244 | |
| | 245 | if (IS_ERR(drv_data->priv)) |
| | 246 | return PTR_ERR(drv_data->priv); |
| | 247 | |
| | 248 | drv_data->priv->support_fw_dnld = true; |
| | 249 | |
| | 250 | return 0; |
| | 251 | } |
| | 252 | |
| | 253 | static int nfcmrvl_i2c_remove(struct i2c_client *client) |
| | 254 | { |
| | 255 | struct nfcmrvl_i2c_drv_data *drv_data = i2c_get_clientdata(client); |
| | 256 | |
| | 257 | nfcmrvl_nci_unregister_dev(drv_data->priv); |
| | 258 | |
| | 259 | return 0; |
| | 260 | } |
| | 261 | |
| | 262 | |
| | 263 | static const struct of_device_id of_nfcmrvl_i2c_match[] = { |
| | 264 | { .compatible = "mrvl,nfc-i2c", }, |
| | 265 | {}, |
| | 266 | }; |
| | 267 | MODULE_DEVICE_TABLE(of, of_nfcmrvl_i2c_match); |
| | 268 | |
| | 269 | static struct i2c_device_id nfcmrvl_i2c_id_table[] = { |
| | 270 | { "nfcmrvl_i2c", 0 }, |
| | 271 | {} |
| | 272 | }; |
| | 273 | MODULE_DEVICE_TABLE(i2c, nfcmrvl_i2c_id_table); |
| | 274 | |
| | 275 | static struct i2c_driver nfcmrvl_i2c_driver = { |
| | 276 | .probe = nfcmrvl_i2c_probe, |
| | 277 | .id_table = nfcmrvl_i2c_id_table, |
| | 278 | .remove = nfcmrvl_i2c_remove, |
| | 279 | .driver = { |
| | 280 | .name = "nfcmrvl_i2c", |
| | 281 | .owner = THIS_MODULE, |
| | 282 | .of_match_table = of_match_ptr(of_nfcmrvl_i2c_match), |
| | 283 | }, |
| | 284 | }; |
| | 285 | |
| | 286 | module_i2c_driver(nfcmrvl_i2c_driver); |
| | 287 | |
| | 288 | MODULE_AUTHOR("Marvell International Ltd."); |
| | 289 | MODULE_DESCRIPTION("Marvell NFC-over-I2C driver"); |
| | 290 | MODULE_LICENSE("GPL v2"); |