2 * HCI based Driver for Inside Secure microread NFC Chip - i2c layer
4 * Copyright (C) 2013 Intel Corporation. All rights reserved.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the
17 * Free Software Foundation, Inc.,
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 #include <linux/module.h>
22 #include <linux/i2c.h>
23 #include <linux/delay.h>
24 #include <linux/slab.h>
25 #include <linux/interrupt.h>
26 #include <linux/gpio.h>
28 #include <linux/nfc.h>
29 #include <net/nfc/hci.h>
30 #include <net/nfc/llc.h>
32 #include "microread.h"
34 #define MICROREAD_I2C_DRIVER_NAME "microread"
36 #define MICROREAD_I2C_FRAME_HEADROOM 1
37 #define MICROREAD_I2C_FRAME_TAILROOM 1
39 /* framing in HCI mode */
40 #define MICROREAD_I2C_LLC_LEN 1
41 #define MICROREAD_I2C_LLC_CRC 1
42 #define MICROREAD_I2C_LLC_LEN_CRC (MICROREAD_I2C_LLC_LEN + \
43 MICROREAD_I2C_LLC_CRC)
44 #define MICROREAD_I2C_LLC_MIN_SIZE (1 + MICROREAD_I2C_LLC_LEN_CRC)
45 #define MICROREAD_I2C_LLC_MAX_PAYLOAD 29
46 #define MICROREAD_I2C_LLC_MAX_SIZE (MICROREAD_I2C_LLC_LEN_CRC + 1 + \
47 MICROREAD_I2C_LLC_MAX_PAYLOAD)
49 struct microread_i2c_phy
{
50 struct i2c_client
*i2c_dev
;
51 struct nfc_hci_dev
*hdev
;
56 * < 0 if hardware error occured (e.g. i2c err)
57 * and prevents normal operation.
61 #define I2C_DUMP_SKB(info, skb) \
63 pr_debug("%s:\n", info); \
64 print_hex_dump(KERN_DEBUG, "i2c: ", DUMP_PREFIX_OFFSET, \
65 16, 1, (skb)->data, (skb)->len, 0); \
68 static void microread_i2c_add_len_crc(struct sk_buff
*skb
)
75 *skb_push(skb
, 1) = len
;
77 for (i
= 0; i
< skb
->len
; i
++)
78 crc
= crc
^ skb
->data
[i
];
80 *skb_put(skb
, 1) = crc
;
83 static void microread_i2c_remove_len_crc(struct sk_buff
*skb
)
85 skb_pull(skb
, MICROREAD_I2C_FRAME_HEADROOM
);
86 skb_trim(skb
, MICROREAD_I2C_FRAME_TAILROOM
);
89 static int check_crc(struct sk_buff
*skb
)
94 for (i
= 0; i
< skb
->len
- 1; i
++)
95 crc
= crc
^ skb
->data
[i
];
97 if (crc
!= skb
->data
[skb
->len
-1]) {
98 pr_err(MICROREAD_I2C_DRIVER_NAME
99 ": CRC error 0x%x != 0x%x\n",
100 crc
, skb
->data
[skb
->len
-1]);
102 pr_info(DRIVER_DESC
": %s : BAD CRC\n", __func__
);
110 static int microread_i2c_enable(void *phy_id
)
115 static void microread_i2c_disable(void *phy_id
)
120 static int microread_i2c_write(void *phy_id
, struct sk_buff
*skb
)
123 struct microread_i2c_phy
*phy
= phy_id
;
124 struct i2c_client
*client
= phy
->i2c_dev
;
126 if (phy
->hard_fault
!= 0)
127 return phy
->hard_fault
;
129 usleep_range(3000, 6000);
131 microread_i2c_add_len_crc(skb
);
133 I2C_DUMP_SKB("i2c frame written", skb
);
135 r
= i2c_master_send(client
, skb
->data
, skb
->len
);
137 if (r
== -EREMOTEIO
) { /* Retry, chip was in standby */
138 usleep_range(6000, 10000);
139 r
= i2c_master_send(client
, skb
->data
, skb
->len
);
149 microread_i2c_remove_len_crc(skb
);
155 static int microread_i2c_read(struct microread_i2c_phy
*phy
,
156 struct sk_buff
**skb
)
160 u8 tmp
[MICROREAD_I2C_LLC_MAX_SIZE
- 1];
161 struct i2c_client
*client
= phy
->i2c_dev
;
163 pr_debug("%s\n", __func__
);
165 r
= i2c_master_recv(client
, &len
, 1);
167 dev_err(&client
->dev
, "cannot read len byte\n");
171 if ((len
< MICROREAD_I2C_LLC_MIN_SIZE
) ||
172 (len
> MICROREAD_I2C_LLC_MAX_SIZE
)) {
173 dev_err(&client
->dev
, "invalid len byte\n");
174 pr_err("invalid len byte\n");
179 *skb
= alloc_skb(1 + len
, GFP_KERNEL
);
185 *skb_put(*skb
, 1) = len
;
187 r
= i2c_master_recv(client
, skb_put(*skb
, len
), len
);
193 I2C_DUMP_SKB("cc frame read", *skb
);
203 skb_trim(*skb
, (*skb
)->len
- MICROREAD_I2C_FRAME_TAILROOM
);
205 usleep_range(3000, 6000);
210 if (i2c_master_recv(client
, tmp
, sizeof(tmp
)) < 0)
213 usleep_range(3000, 6000);
218 static irqreturn_t
microread_i2c_irq_thread_fn(int irq
, void *phy_id
)
220 struct microread_i2c_phy
*phy
= phy_id
;
221 struct i2c_client
*client
;
222 struct sk_buff
*skb
= NULL
;
225 if (!phy
|| irq
!= phy
->i2c_dev
->irq
) {
230 client
= phy
->i2c_dev
;
231 dev_dbg(&client
->dev
, "IRQ\n");
233 if (phy
->hard_fault
!= 0)
236 r
= microread_i2c_read(phy
, &skb
);
237 if (r
== -EREMOTEIO
) {
240 nfc_hci_recv_frame(phy
->hdev
, NULL
);
243 } else if ((r
== -ENOMEM
) || (r
== -EBADMSG
)) {
247 nfc_hci_recv_frame(phy
->hdev
, skb
);
252 static struct nfc_phy_ops i2c_phy_ops
= {
253 .write
= microread_i2c_write
,
254 .enable
= microread_i2c_enable
,
255 .disable
= microread_i2c_disable
,
258 static int microread_i2c_probe(struct i2c_client
*client
,
259 const struct i2c_device_id
*id
)
261 struct microread_i2c_phy
*phy
;
262 struct microread_nfc_platform_data
*pdata
=
263 dev_get_platdata(&client
->dev
);
266 dev_dbg(&client
->dev
, "client %p", client
);
269 dev_err(&client
->dev
, "client %p: missing platform data",
274 phy
= devm_kzalloc(&client
->dev
, sizeof(struct microread_i2c_phy
),
277 dev_err(&client
->dev
, "Can't allocate microread phy");
281 i2c_set_clientdata(client
, phy
);
282 phy
->i2c_dev
= client
;
284 r
= request_threaded_irq(client
->irq
, NULL
, microread_i2c_irq_thread_fn
,
285 IRQF_TRIGGER_RISING
| IRQF_ONESHOT
,
286 MICROREAD_I2C_DRIVER_NAME
, phy
);
288 dev_err(&client
->dev
, "Unable to register IRQ handler");
292 r
= microread_probe(phy
, &i2c_phy_ops
, LLC_SHDLC_NAME
,
293 MICROREAD_I2C_FRAME_HEADROOM
,
294 MICROREAD_I2C_FRAME_TAILROOM
,
295 MICROREAD_I2C_LLC_MAX_PAYLOAD
, &phy
->hdev
);
299 dev_info(&client
->dev
, "Probed");
304 free_irq(client
->irq
, phy
);
309 static int microread_i2c_remove(struct i2c_client
*client
)
311 struct microread_i2c_phy
*phy
= i2c_get_clientdata(client
);
313 dev_dbg(&client
->dev
, "%s\n", __func__
);
315 microread_remove(phy
->hdev
);
317 free_irq(client
->irq
, phy
);
322 static struct i2c_device_id microread_i2c_id
[] = {
323 { MICROREAD_I2C_DRIVER_NAME
, 0},
326 MODULE_DEVICE_TABLE(i2c
, microread_i2c_id
);
328 static struct i2c_driver microread_i2c_driver
= {
330 .name
= MICROREAD_I2C_DRIVER_NAME
,
332 .probe
= microread_i2c_probe
,
333 .remove
= microread_i2c_remove
,
334 .id_table
= microread_i2c_id
,
337 module_i2c_driver(microread_i2c_driver
);
339 MODULE_LICENSE("GPL");
340 MODULE_DESCRIPTION(DRIVER_DESC
);