Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e298c79e authored by John W. Linville's avatar John W. Linville
Browse files

Merge tag 'nfc-next-3.8-1' of git://git.kernel.org/pub/scm/linux/kernel/git/sameo/nfc-3.0 

This is the first NFC pull request for 3.8

With this one we have:

- pn544 p2p support.
- pn544 physical and HCI layers separation. We are getting the pn544 driver
  ready to support non i2c physical layers.
- LLCP SNL (Service Name Lookup). This is the NFC p2p service discovery
  protocol.
- LLCP datagram sockets (connection less) support.
- IDR library usage for NFC devices indexes assignement.
- NFC netlink extension for setting and getting LLCP link characteristics.
- Various code style fixes and cleanups spread over the pn533, LLCP, HCI and
  pn544 code.
parents d1f10302 52feb444

drivers/nfc/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -2,7 +2,7 @@ 
# Makefile for nfc devices

#



obj-$(CONFIG_PN544_HCI_NFC)	+= pn544_hci.o

obj-$(CONFIG_PN544_HCI_NFC)	+= pn544/

obj-$(CONFIG_NFC_PN533)		+= pn533.o

obj-$(CONFIG_NFC_WILINK)	+= nfcwilink.o

drivers/nfc/pn533.c

+10 −8
Original line number Diff line number Diff line
@@ -84,6 +84,10 @@ MODULE_DEVICE_TABLE(usb, pn533_table); 
#define PN533_LISTEN_TIME 2



/* frame definitions */

#define PN533_NORMAL_FRAME_MAX_LEN 262  /* 6   (PREAMBLE, SOF, LEN, LCS, TFI)

					   254 (DATA)

					   2   (DCS, postamble) */



#define PN533_FRAME_TAIL_SIZE 2

#define PN533_FRAME_SIZE(f) (sizeof(struct pn533_frame) + f->datalen + \

				PN533_FRAME_TAIL_SIZE)
@@ -1165,8 +1169,7 @@ static void pn533_poll_create_mod_list(struct pn533 *dev, 
		pn533_poll_add_mod(dev, PN533_LISTEN_MOD);

}



static int pn533_start_poll_complete(struct pn533 *dev, void *arg,

				     u8 *params, int params_len)

static int pn533_start_poll_complete(struct pn533 *dev, u8 *params, int params_len)

{

	struct pn533_poll_response *resp;

	int rc;
@@ -1304,8 +1307,7 @@ static void pn533_wq_tg_get_data(struct work_struct *work) 
}



#define ATR_REQ_GB_OFFSET 17

static int pn533_init_target_complete(struct pn533 *dev, void *arg,

				      u8 *params, int params_len)

static int pn533_init_target_complete(struct pn533 *dev, u8 *params, int params_len)

{

	struct pn533_cmd_init_target_response *resp;

	u8 frame, comm_mode = NFC_COMM_PASSIVE, *gb;
@@ -1402,9 +1404,9 @@ static int pn533_poll_complete(struct pn533 *dev, void *arg, 
	if (cur_mod->len == 0) {

		del_timer(&dev->listen_timer);



		return pn533_init_target_complete(dev, arg, params, params_len);

		return pn533_init_target_complete(dev, params, params_len);

	} else {

		rc = pn533_start_poll_complete(dev, arg, params, params_len);

		rc = pn533_start_poll_complete(dev, params, params_len);

		if (!rc)

			return rc;

	}
@@ -2373,9 +2375,9 @@ static int pn533_probe(struct usb_interface *interface, 
		goto error;

	}



	dev->in_frame = kmalloc(dev->in_maxlen, GFP_KERNEL);

	dev->in_frame = kmalloc(PN533_NORMAL_FRAME_MAX_LEN, GFP_KERNEL);

	dev->in_urb = usb_alloc_urb(0, GFP_KERNEL);

	dev->out_frame = kmalloc(dev->out_maxlen, GFP_KERNEL);

	dev->out_frame = kmalloc(PN533_NORMAL_FRAME_MAX_LEN, GFP_KERNEL);

	dev->out_urb = usb_alloc_urb(0, GFP_KERNEL);



	if (!dev->in_frame || !dev->out_frame ||

drivers/nfc/pn544/Makefile

0 → 100644
+7 −0
Original line number Diff line number Diff line 
#

# Makefile for PN544 HCI based NFC driver

#



obj-$(CONFIG_PN544_HCI_NFC)	+= pn544_i2c.o



pn544_i2c-y		:= pn544.o i2c.o

drivers/nfc/pn544/i2c.c

0 → 100644
+500 −0
Original line number Diff line number Diff line 
/*

 * I2C Link Layer for PN544 HCI based Driver

 *

 * Copyright (C) 2012  Intel Corporation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU General Public License,

 * version 2, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the

 * Free Software Foundation, Inc.,

 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

 */



#include <linux/crc-ccitt.h>

#include <linux/module.h>

#include <linux/i2c.h>

#include <linux/gpio.h>

#include <linux/miscdevice.h>

#include <linux/interrupt.h>

#include <linux/delay.h>



#include <linux/nfc/pn544.h>



#include <net/nfc/hci.h>

#include <net/nfc/llc.h>



#include "pn544.h"



#define PN544_I2C_FRAME_HEADROOM 1

#define PN544_I2C_FRAME_TAILROOM 2



/* framing in HCI mode */

#define PN544_HCI_I2C_LLC_LEN		1

#define PN544_HCI_I2C_LLC_CRC		2

#define PN544_HCI_I2C_LLC_LEN_CRC	(PN544_HCI_I2C_LLC_LEN + \

					 PN544_HCI_I2C_LLC_CRC)

#define PN544_HCI_I2C_LLC_MIN_SIZE	(1 + PN544_HCI_I2C_LLC_LEN_CRC)

#define PN544_HCI_I2C_LLC_MAX_PAYLOAD	29

#define PN544_HCI_I2C_LLC_MAX_SIZE	(PN544_HCI_I2C_LLC_LEN_CRC + 1 + \

					 PN544_HCI_I2C_LLC_MAX_PAYLOAD)



static struct i2c_device_id pn544_hci_i2c_id_table[] = {

	{"pn544", 0},

	{}

};



MODULE_DEVICE_TABLE(i2c, pn544_hci_i2c_id_table);



#define PN544_HCI_I2C_DRIVER_NAME "pn544_hci_i2c"



struct pn544_i2c_phy {

	struct i2c_client *i2c_dev;

	struct nfc_hci_dev *hdev;



	unsigned int gpio_en;

	unsigned int gpio_irq;

	unsigned int gpio_fw;

	unsigned int en_polarity;



	int powered;



	int hard_fault;		/*

				 * < 0 if hardware error occured (e.g. i2c err)

				 * and prevents normal operation.

				 */

};



#define I2C_DUMP_SKB(info, skb)					\

do {								\

	pr_debug("%s:\n", info);				\

	print_hex_dump(KERN_DEBUG, "i2c: ", DUMP_PREFIX_OFFSET,	\

		       16, 1, (skb)->data, (skb)->len, 0);	\

} while (0)



static void pn544_hci_i2c_platform_init(struct pn544_i2c_phy *phy)

{

	int polarity, retry, ret;

	char rset_cmd[] = { 0x05, 0xF9, 0x04, 0x00, 0xC3, 0xE5 };

	int count = sizeof(rset_cmd);



	pr_info(DRIVER_DESC ": %s\n", __func__);

	dev_info(&phy->i2c_dev->dev, "Detecting nfc_en polarity\n");



	/* Disable fw download */

	gpio_set_value(phy->gpio_fw, 0);



	for (polarity = 0; polarity < 2; polarity++) {

		phy->en_polarity = polarity;

		retry = 3;

		while (retry--) {

			/* power off */

			gpio_set_value(phy->gpio_en, !phy->en_polarity);

			usleep_range(10000, 15000);



			/* power on */

			gpio_set_value(phy->gpio_en, phy->en_polarity);

			usleep_range(10000, 15000);



			/* send reset */

			dev_dbg(&phy->i2c_dev->dev, "Sending reset cmd\n");

			ret = i2c_master_send(phy->i2c_dev, rset_cmd, count);

			if (ret == count) {

				dev_info(&phy->i2c_dev->dev,

					 "nfc_en polarity : active %s\n",

					 (polarity == 0 ? "low" : "high"));

				goto out;

			}

		}

	}



	dev_err(&phy->i2c_dev->dev,

		"Could not detect nfc_en polarity, fallback to active high\n");



out:

	gpio_set_value(phy->gpio_en, !phy->en_polarity);

}



static int pn544_hci_i2c_enable(void *phy_id)

{

	struct pn544_i2c_phy *phy = phy_id;



	pr_info(DRIVER_DESC ": %s\n", __func__);



	gpio_set_value(phy->gpio_fw, 0);

	gpio_set_value(phy->gpio_en, phy->en_polarity);

	usleep_range(10000, 15000);



	phy->powered = 1;



	return 0;

}



static void pn544_hci_i2c_disable(void *phy_id)

{

	struct pn544_i2c_phy *phy = phy_id;



	pr_info(DRIVER_DESC ": %s\n", __func__);



	gpio_set_value(phy->gpio_fw, 0);

	gpio_set_value(phy->gpio_en, !phy->en_polarity);

	usleep_range(10000, 15000);



	gpio_set_value(phy->gpio_en, phy->en_polarity);

	usleep_range(10000, 15000);



	gpio_set_value(phy->gpio_en, !phy->en_polarity);

	usleep_range(10000, 15000);



	phy->powered = 0;

}



static void pn544_hci_i2c_add_len_crc(struct sk_buff *skb)

{

	u16 crc;

	int len;



	len = skb->len + 2;

	*skb_push(skb, 1) = len;



	crc = crc_ccitt(0xffff, skb->data, skb->len);

	crc = ~crc;

	*skb_put(skb, 1) = crc & 0xff;

	*skb_put(skb, 1) = crc >> 8;

}



static void pn544_hci_i2c_remove_len_crc(struct sk_buff *skb)

{

	skb_pull(skb, PN544_I2C_FRAME_HEADROOM);

	skb_trim(skb, PN544_I2C_FRAME_TAILROOM);

}



/*

 * Writing a frame must not return the number of written bytes.

 * It must return either zero for success, or <0 for error.

 * In addition, it must not alter the skb

 */

static int pn544_hci_i2c_write(void *phy_id, struct sk_buff *skb)

{

	int r;

	struct pn544_i2c_phy *phy = phy_id;

	struct i2c_client *client = phy->i2c_dev;



	if (phy->hard_fault != 0)

		return phy->hard_fault;



	usleep_range(3000, 6000);



	pn544_hci_i2c_add_len_crc(skb);



	I2C_DUMP_SKB("i2c frame written", skb);



	r = i2c_master_send(client, skb->data, skb->len);



	if (r == -EREMOTEIO) {	/* Retry, chip was in standby */

		usleep_range(6000, 10000);

		r = i2c_master_send(client, skb->data, skb->len);

	}



	if (r >= 0) {

		if (r != skb->len)

			r = -EREMOTEIO;

		else

			r = 0;

	}



	pn544_hci_i2c_remove_len_crc(skb);



	return r;

}



static int check_crc(u8 *buf, int buflen)

{

	int len;

	u16 crc;



	len = buf[0] + 1;

	crc = crc_ccitt(0xffff, buf, len - 2);

	crc = ~crc;



	if (buf[len - 2] != (crc & 0xff) || buf[len - 1] != (crc >> 8)) {

		pr_err(PN544_HCI_I2C_DRIVER_NAME

		       ": CRC error 0x%x != 0x%x 0x%x\n",

		       crc, buf[len - 1], buf[len - 2]);



		pr_info(DRIVER_DESC ": %s : BAD CRC\n", __func__);

		print_hex_dump(KERN_DEBUG, "crc: ", DUMP_PREFIX_NONE,

			       16, 2, buf, buflen, false);

		return -EPERM;

	}

	return 0;

}



/*

 * Reads an shdlc frame and returns it in a newly allocated sk_buff. Guarantees

 * that i2c bus will be flushed and that next read will start on a new frame.

 * returned skb contains only LLC header and payload.

 * returns:

 * -EREMOTEIO : i2c read error (fatal)

 * -EBADMSG : frame was incorrect and discarded

 * -ENOMEM : cannot allocate skb, frame dropped

 */

static int pn544_hci_i2c_read(struct pn544_i2c_phy *phy, struct sk_buff **skb)

{

	int r;

	u8 len;

	u8 tmp[PN544_HCI_I2C_LLC_MAX_SIZE - 1];

	struct i2c_client *client = phy->i2c_dev;



	r = i2c_master_recv(client, &len, 1);

	if (r != 1) {

		dev_err(&client->dev, "cannot read len byte\n");

		return -EREMOTEIO;

	}



	if ((len < (PN544_HCI_I2C_LLC_MIN_SIZE - 1)) ||

	    (len > (PN544_HCI_I2C_LLC_MAX_SIZE - 1))) {

		dev_err(&client->dev, "invalid len byte\n");

		r = -EBADMSG;

		goto flush;

	}



	*skb = alloc_skb(1 + len, GFP_KERNEL);

	if (*skb == NULL) {

		r = -ENOMEM;

		goto flush;

	}



	*skb_put(*skb, 1) = len;



	r = i2c_master_recv(client, skb_put(*skb, len), len);

	if (r != len) {

		kfree_skb(*skb);

		return -EREMOTEIO;

	}



	I2C_DUMP_SKB("i2c frame read", *skb);



	r = check_crc((*skb)->data, (*skb)->len);

	if (r != 0) {

		kfree_skb(*skb);

		r = -EBADMSG;

		goto flush;

	}



	skb_pull(*skb, 1);

	skb_trim(*skb, (*skb)->len - 2);



	usleep_range(3000, 6000);



	return 0;



flush:

	if (i2c_master_recv(client, tmp, sizeof(tmp)) < 0)

		r = -EREMOTEIO;



	usleep_range(3000, 6000);



	return r;

}



/*

 * Reads an shdlc frame from the chip. This is not as straightforward as it

 * seems. There are cases where we could loose the frame start synchronization.

 * The frame format is len-data-crc, and corruption can occur anywhere while

 * transiting on i2c bus, such that we could read an invalid len.

 * In order to recover synchronization with the next frame, we must be sure

 * to read the real amount of data without using the len byte. We do this by

 * assuming the following:

 * - the chip will always present only one single complete frame on the bus

 *   before triggering the interrupt

 * - the chip will not present a new frame until we have completely read

 *   the previous one (or until we have handled the interrupt).

 * The tricky case is when we read a corrupted len that is less than the real

 * len. We must detect this here in order to determine that we need to flush

 * the bus. This is the reason why we check the crc here.

 */

static irqreturn_t pn544_hci_i2c_irq_thread_fn(int irq, void *phy_id)

{

	struct pn544_i2c_phy *phy = phy_id;

	struct i2c_client *client;

	struct sk_buff *skb = NULL;

	int r;



	if (!phy || irq != phy->i2c_dev->irq) {

		WARN_ON_ONCE(1);

		return IRQ_NONE;

	}



	client = phy->i2c_dev;

	dev_dbg(&client->dev, "IRQ\n");



	if (phy->hard_fault != 0)

		return IRQ_HANDLED;



	r = pn544_hci_i2c_read(phy, &skb);

	if (r == -EREMOTEIO) {

		phy->hard_fault = r;



		nfc_hci_recv_frame(phy->hdev, NULL);



		return IRQ_HANDLED;

	} else if ((r == -ENOMEM) || (r == -EBADMSG)) {

		return IRQ_HANDLED;

	}



	nfc_hci_recv_frame(phy->hdev, skb);



	return IRQ_HANDLED;

}



static struct nfc_phy_ops i2c_phy_ops = {

	.write = pn544_hci_i2c_write,

	.enable = pn544_hci_i2c_enable,

	.disable = pn544_hci_i2c_disable,

};



static int __devinit pn544_hci_i2c_probe(struct i2c_client *client,

				     const struct i2c_device_id *id)

{

	struct pn544_i2c_phy *phy;

	struct pn544_nfc_platform_data *pdata;

	int r = 0;



	dev_dbg(&client->dev, "%s\n", __func__);

	dev_dbg(&client->dev, "IRQ: %d\n", client->irq);



	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {

		dev_err(&client->dev, "Need I2C_FUNC_I2C\n");

		return -ENODEV;

	}



	phy = kzalloc(sizeof(struct pn544_i2c_phy), GFP_KERNEL);

	if (!phy) {

		dev_err(&client->dev,

			"Cannot allocate memory for pn544 i2c phy.\n");

		r = -ENOMEM;

		goto err_phy_alloc;

	}



	phy->i2c_dev = client;

	i2c_set_clientdata(client, phy);



	pdata = client->dev.platform_data;

	if (pdata == NULL) {

		dev_err(&client->dev, "No platform data\n");

		r = -EINVAL;

		goto err_pdata;

	}



	if (pdata->request_resources == NULL) {

		dev_err(&client->dev, "request_resources() missing\n");

		r = -EINVAL;

		goto err_pdata;

	}



	r = pdata->request_resources(client);

	if (r) {

		dev_err(&client->dev, "Cannot get platform resources\n");

		goto err_pdata;

	}



	phy->gpio_en = pdata->get_gpio(NFC_GPIO_ENABLE);

	phy->gpio_fw = pdata->get_gpio(NFC_GPIO_FW_RESET);

	phy->gpio_irq = pdata->get_gpio(NFC_GPIO_IRQ);



	pn544_hci_i2c_platform_init(phy);



	r = request_threaded_irq(client->irq, NULL, pn544_hci_i2c_irq_thread_fn,

				 IRQF_TRIGGER_RISING | IRQF_ONESHOT,

				 PN544_HCI_I2C_DRIVER_NAME, phy);

	if (r < 0) {

		dev_err(&client->dev, "Unable to register IRQ handler\n");

		goto err_rti;

	}



	r = pn544_hci_probe(phy, &i2c_phy_ops, LLC_SHDLC_NAME,

			    PN544_I2C_FRAME_HEADROOM, PN544_I2C_FRAME_TAILROOM,

			    PN544_HCI_I2C_LLC_MAX_PAYLOAD, &phy->hdev);

	if (r < 0)

		goto err_hci;



	return 0;



err_hci:

	free_irq(client->irq, phy);



err_rti:

	if (pdata->free_resources != NULL)

		pdata->free_resources();



err_pdata:

	kfree(phy);



err_phy_alloc:

	return r;

}



static __devexit int pn544_hci_i2c_remove(struct i2c_client *client)

{

	struct pn544_i2c_phy *phy = i2c_get_clientdata(client);

	struct pn544_nfc_platform_data *pdata = client->dev.platform_data;



	dev_dbg(&client->dev, "%s\n", __func__);



	pn544_hci_remove(phy->hdev);



	if (phy->powered)

		pn544_hci_i2c_disable(phy);



	free_irq(client->irq, phy);

	if (pdata->free_resources)

		pdata->free_resources();



	kfree(phy);



	return 0;

}



static struct i2c_driver pn544_hci_i2c_driver = {

	.driver = {

		   .name = PN544_HCI_I2C_DRIVER_NAME,

		  },

	.probe = pn544_hci_i2c_probe,

	.id_table = pn544_hci_i2c_id_table,

	.remove = __devexit_p(pn544_hci_i2c_remove),

};



static int __init pn544_hci_i2c_init(void)

{

	int r;



	pr_debug(DRIVER_DESC ": %s\n", __func__);



	r = i2c_add_driver(&pn544_hci_i2c_driver);

	if (r) {

		pr_err(PN544_HCI_I2C_DRIVER_NAME

		       ": driver registration failed\n");

		return r;

	}



	return 0;

}



static void __exit pn544_hci_i2c_exit(void)

{

	i2c_del_driver(&pn544_hci_i2c_driver);

}



module_init(pn544_hci_i2c_init);

module_exit(pn544_hci_i2c_exit);



MODULE_LICENSE("GPL");

MODULE_DESCRIPTION(DRIVER_DESC);

drivers/nfc/pn544_hci.c→drivers/nfc/pn544/pn544.c

+259 −420

File changed and moved.

Preview size limit exceeded, changes collapsed.