Commit | Line | Data |
---|---|---|
b5b3e23e VC |
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[] = { | |
d8e018c0 | 264 | { .compatible = "marvell,nfc-i2c", }, |
b5b3e23e VC |
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"); |