| Message ID | 20181101100216.613-4-poeschel@lemonage.de (mailing list archive) |
|---|---|
| State | Superseded |
| Delegated to: | Samuel Ortiz |
| Headers | show |
| Series | [v4,1/6] nfc: pn533: i2c: "pn532" as dt compatible string | expand |
On Thu, Nov 01, 2018 at 11:02:12AM +0100, Lars Poeschel wrote: > This adds the UART phy interface for the pn533 driver. > The pn533 driver can be used through UART interface this way. > It is implemented as a serdev device. > > Signed-off-by: Lars Poeschel <poeschel@lemonage.de> Please make sure to include reviewers on CC. > --- > Changes in v4: > - SPDX-License-Identifier: GPL-2.0+ > - Source code comments above refering items > - Error check for serdev_device_write's > - Change if (xxx == NULL) to if (!xxx) > - Remove device name from a dev_err > - move pn533_register in _probe a bit towards the end of _probe > - make use of newly added dev_up / dev_down phy_ops > - control send_wakeup variable from dev_up / dev_down > > Changes in v3: > - depend on SERIAL_DEV_BUS in Kconfig > > Changes in v2: > - switched from tty line discipline to serdev, resulting in many > simplifications > - SPDX License Identifier > > drivers/nfc/pn533/Kconfig | 11 ++ > drivers/nfc/pn533/Makefile | 2 + > drivers/nfc/pn533/pn533.h | 8 + > drivers/nfc/pn533/uart.c | 311 +++++++++++++++++++++++++++++++++++++ > 4 files changed, 332 insertions(+) > create mode 100644 drivers/nfc/pn533/uart.c > > +static void pn532_dev_up(struct pn533 *dev) > +{ > + struct pn532_uart_phy *pn532 = dev->phy; > + > + serdev_device_open(pn532->serdev); > + pn532->send_wakeup = PN532_SEND_LAST_WAKEUP; > +} > + > +static void pn532_dev_down(struct pn533 *dev) > +{ > + struct pn532_uart_phy *pn532 = dev->phy; > + > + serdev_device_close(pn532->serdev); > + pn532->send_wakeup = PN532_SEND_WAKEUP; > +} > + > +static struct pn533_phy_ops uart_phy_ops = { > + .send_frame = pn532_uart_send_frame, > + .send_ack = pn532_uart_send_ack, > + .abort_cmd = pn532_uart_abort_cmd, > + .dev_up = pn532_dev_up, > + .dev_down = pn532_dev_down, > +}; > +static int pn532_uart_probe(struct serdev_device *serdev) > +{ > + struct pn532_uart_phy *pn532; > + struct pn533 *priv; > + int err; > + > + err = -ENOMEM; > + pn532 = kzalloc(sizeof(*pn532), GFP_KERNEL); > + if (!pn532) > + goto err_exit; > + > + pn532->recv_skb = alloc_skb(PN532_UART_SKB_BUFF_LEN, GFP_KERNEL); > + if (!pn532->recv_skb) > + goto err_free; > + > + pn532->serdev = serdev; > + serdev_device_set_drvdata(serdev, pn532); > + serdev_device_set_client_ops(serdev, &pn532_serdev_ops); > + err = serdev_device_open(serdev); > + if (err) { > + dev_err(&serdev->dev, "Unable to open device\n"); > + goto err_skb; > + } > + > + err = serdev_device_set_baudrate(serdev, 115200); > + if (err != 115200) { > + err = -EINVAL; > + goto err_serdev; > + } > + > + serdev_device_set_flow_control(serdev, false); > + pn532->send_wakeup = PN532_SEND_WAKEUP; > + timer_setup(&pn532->cmd_timeout, pn532_cmd_timeout, 0); > + priv = pn533_register_device(PN533_DEVICE_PN532, > + PN533_NO_TYPE_B_PROTOCOLS, > + PN533_PROTO_REQ_ACK_RESP, > + pn532, &uart_phy_ops, NULL, > + &pn532->serdev->dev, > + &serdev->dev); > + if (IS_ERR(priv)) { > + err = PTR_ERR(priv); > + goto err_serdev; > + } > + > + pn532->priv = priv; > + err = pn533_finalize_setup(pn532->priv); > + if (err) > + goto err_unregister; > + > + serdev_device_close(serdev); This looks broken; what if the NFC interface is brought up before this point? You'd get a double open, which is likely to crash things, but even if you survive that, the port would not be closed despite the interface being up. Can't you finalise your setup before registering the interface? > + return 0; > + > +err_unregister: > + pn533_unregister_device(pn532->priv); > +err_serdev: > + serdev_device_close(serdev); > +err_skb: > + kfree_skb(pn532->recv_skb); > +err_free: > + kfree(pn532); > +err_exit: > + return err; > +} > + > +static void pn532_uart_remove(struct serdev_device *serdev) > +{ > + struct pn532_uart_phy *pn532 = serdev_device_get_drvdata(serdev); > + > + pn533_unregister_device(pn532->priv); > + serdev_device_close(serdev); This is also broken; the port should have been closed when the interface was deregistered. > + kfree_skb(pn532->recv_skb); > + kfree(pn532); > +} Johan
On Wed, Nov 14, 2018 at 04:35:17PM +0100, Johan Hovold wrote: > On Thu, Nov 01, 2018 at 11:02:12AM +0100, Lars Poeschel wrote: > > This adds the UART phy interface for the pn533 driver. > > The pn533 driver can be used through UART interface this way. > > It is implemented as a serdev device. > > > > Signed-off-by: Lars Poeschel <poeschel@lemonage.de> > > Please make sure to include reviewers on CC. It's hard to do all things right, about how to correctly email patches, patch sets and follow ups and send what to whom. I am still learning. Sorry about that. > > --- > > Changes in v4: > > - SPDX-License-Identifier: GPL-2.0+ > > - Source code comments above refering items > > - Error check for serdev_device_write's > > - Change if (xxx == NULL) to if (!xxx) > > - Remove device name from a dev_err > > - move pn533_register in _probe a bit towards the end of _probe > > - make use of newly added dev_up / dev_down phy_ops > > - control send_wakeup variable from dev_up / dev_down > > > > Changes in v3: > > - depend on SERIAL_DEV_BUS in Kconfig > > > > Changes in v2: > > - switched from tty line discipline to serdev, resulting in many > > simplifications > > - SPDX License Identifier > > > > drivers/nfc/pn533/Kconfig | 11 ++ > > drivers/nfc/pn533/Makefile | 2 + > > drivers/nfc/pn533/pn533.h | 8 + > > drivers/nfc/pn533/uart.c | 311 +++++++++++++++++++++++++++++++++++++ > > 4 files changed, 332 insertions(+) > > create mode 100644 drivers/nfc/pn533/uart.c > > > > +static void pn532_dev_up(struct pn533 *dev) > > +{ > > + struct pn532_uart_phy *pn532 = dev->phy; > > + > > + serdev_device_open(pn532->serdev); > > + pn532->send_wakeup = PN532_SEND_LAST_WAKEUP; > > +} > > + > > +static void pn532_dev_down(struct pn533 *dev) > > +{ > > + struct pn532_uart_phy *pn532 = dev->phy; > > + > > + serdev_device_close(pn532->serdev); > > + pn532->send_wakeup = PN532_SEND_WAKEUP; > > +} > > + > > +static struct pn533_phy_ops uart_phy_ops = { > > + .send_frame = pn532_uart_send_frame, > > + .send_ack = pn532_uart_send_ack, > > + .abort_cmd = pn532_uart_abort_cmd, > > + .dev_up = pn532_dev_up, > > + .dev_down = pn532_dev_down, > > +}; > > > +static int pn532_uart_probe(struct serdev_device *serdev) > > +{ > > + struct pn532_uart_phy *pn532; > > + struct pn533 *priv; > > + int err; > > + > > + err = -ENOMEM; > > + pn532 = kzalloc(sizeof(*pn532), GFP_KERNEL); > > + if (!pn532) > > + goto err_exit; > > + > > + pn532->recv_skb = alloc_skb(PN532_UART_SKB_BUFF_LEN, GFP_KERNEL); > > + if (!pn532->recv_skb) > > + goto err_free; > > + > > + pn532->serdev = serdev; > > + serdev_device_set_drvdata(serdev, pn532); > > + serdev_device_set_client_ops(serdev, &pn532_serdev_ops); > > + err = serdev_device_open(serdev); > > + if (err) { > > + dev_err(&serdev->dev, "Unable to open device\n"); > > + goto err_skb; > > + } > > + > > + err = serdev_device_set_baudrate(serdev, 115200); > > + if (err != 115200) { > > + err = -EINVAL; > > + goto err_serdev; > > + } > > + > > + serdev_device_set_flow_control(serdev, false); > > + pn532->send_wakeup = PN532_SEND_WAKEUP; > > + timer_setup(&pn532->cmd_timeout, pn532_cmd_timeout, 0); > > + priv = pn533_register_device(PN533_DEVICE_PN532, > > + PN533_NO_TYPE_B_PROTOCOLS, > > + PN533_PROTO_REQ_ACK_RESP, > > + pn532, &uart_phy_ops, NULL, > > + &pn532->serdev->dev, > > + &serdev->dev); > > + if (IS_ERR(priv)) { > > + err = PTR_ERR(priv); > > + goto err_serdev; > > + } > > + > > + pn532->priv = priv; > > + err = pn533_finalize_setup(pn532->priv); > > + if (err) > > + goto err_unregister; > > + > > + serdev_device_close(serdev); > > This looks broken; what if the NFC interface is brought up before this > point? You'd get a double open, which is likely to crash things, but > even if you survive that, the port would not be closed despite the > interface being up. I understand the problem and would like to solve it with a mutex. I will not have time to work on that until next year. Please be patient. I will send a new patchset. > Can't you finalise your setup before registering the interface? Well, propably I can do that. But I did it the way the other drivers (usb and i2c) are already doing and reusing the code of the pn533 core driver. Since their probe works very similar to mine, I suspect them to have the same problems. I can rewrite the probe for my driver, but not for the other two. I can not test them. Would you prefer that I rewrite my own _register_device and _finalize_setup functions, not using the ones from the core driver ? > > + return 0; > > + > > +err_unregister: > > + pn533_unregister_device(pn532->priv); > > +err_serdev: > > + serdev_device_close(serdev); > > +err_skb: > > + kfree_skb(pn532->recv_skb); > > +err_free: > > + kfree(pn532); > > +err_exit: > > + return err; > > +} > > + > > +static void pn532_uart_remove(struct serdev_device *serdev) > > +{ > > + struct pn532_uart_phy *pn532 = serdev_device_get_drvdata(serdev); > > + > > + pn533_unregister_device(pn532->priv); > > + serdev_device_close(serdev); > > This is also broken; the port should have been closed when the interface > was deregistered. Same as above. > > + kfree_skb(pn532->recv_skb); > > + kfree(pn532); > > +} Thank you for your very valuable feedback. Regards, Lars
On Mon, Dec 03, 2018 at 03:26:22PM +0100, Lars Poeschel wrote: > On Wed, Nov 14, 2018 at 04:35:17PM +0100, Johan Hovold wrote: > > On Thu, Nov 01, 2018 at 11:02:12AM +0100, Lars Poeschel wrote: > > > This adds the UART phy interface for the pn533 driver. > > > The pn533 driver can be used through UART interface this way. > > > It is implemented as a serdev device. > > > > > > Signed-off-by: Lars Poeschel <poeschel@lemonage.de> > > > > Please make sure to include reviewers on CC. > > It's hard to do all things right, about how to correctly email patches, > patch sets and follow ups and send what to whom. > I am still learning. Sorry about that. No problem, I fully understand that. > > > + err = serdev_device_open(serdev); > > > + if (err) { > > > + dev_err(&serdev->dev, "Unable to open device\n"); > > > + goto err_skb; > > > + } > > > + > > > + err = serdev_device_set_baudrate(serdev, 115200); > > > + if (err != 115200) { > > > + err = -EINVAL; > > > + goto err_serdev; > > > + } > > > + > > > + serdev_device_set_flow_control(serdev, false); > > > + pn532->send_wakeup = PN532_SEND_WAKEUP; > > > + timer_setup(&pn532->cmd_timeout, pn532_cmd_timeout, 0); > > > + priv = pn533_register_device(PN533_DEVICE_PN532, > > > + PN533_NO_TYPE_B_PROTOCOLS, > > > + PN533_PROTO_REQ_ACK_RESP, > > > + pn532, &uart_phy_ops, NULL, > > > + &pn532->serdev->dev, > > > + &serdev->dev); > > > + if (IS_ERR(priv)) { > > > + err = PTR_ERR(priv); > > > + goto err_serdev; > > > + } > > > + > > > + pn532->priv = priv; > > > + err = pn533_finalize_setup(pn532->priv); > > > + if (err) > > > + goto err_unregister; > > > + > > > + serdev_device_close(serdev); > > > > This looks broken; what if the NFC interface is brought up before this > > point? You'd get a double open, which is likely to crash things, but > > even if you survive that, the port would not be closed despite the > > interface being up. > > I understand the problem and would like to solve it with a mutex. I will > not have time to work on that until next year. Please be patient. I will > send a new patchset. I'm in no hurry here. :) But I still think doing that setup before registering the device might be preferred if it's possible as you wouldn't need a mutex then. > > Can't you finalise your setup before registering the interface? > > Well, propably I can do that. But I did it the way the other drivers > (usb and i2c) are already doing and reusing the code of the pn533 core > driver. Since their probe works very similar to mine, I suspect them to > have the same problems. Quite possibly. > I can rewrite the probe for my driver, but not for the other two. I can > not test them. > Would you prefer that I rewrite my own _register_device and > _finalize_setup functions, not using the ones from the core driver ? If you add common paths that you can test using your driver I think it should be fine to convert the others unless it ends up being really complicated. Perhaps the authors of those driver can help out with testing too. > Thank you for your very valuable feedback. You're welcome. Johan
diff --git a/drivers/nfc/pn533/Kconfig b/drivers/nfc/pn533/Kconfig index d94122dd30e4..29df7d97d209 100644 --- a/drivers/nfc/pn533/Kconfig +++ b/drivers/nfc/pn533/Kconfig @@ -25,3 +25,14 @@ config NFC_PN533_I2C If you choose to build a module, it'll be called pn533_i2c. Say N if unsure. + +config NFC_PN532_UART + tristate "NFC PN532 device support (UART)" + depends on SERIAL_DEV_BUS + select NFC_PN533 + ---help--- + This module adds support for the NXP pn532 UART interface. + Select this if your platform is using the UART bus. + + If you choose to build a module, it'll be called pn532_uart. + Say N if unsure. diff --git a/drivers/nfc/pn533/Makefile b/drivers/nfc/pn533/Makefile index 51d24c622fcb..bdfd6860d5e4 100644 --- a/drivers/nfc/pn533/Makefile +++ b/drivers/nfc/pn533/Makefile @@ -3,7 +3,9 @@ # pn533_usb-objs = usb.o pn533_i2c-objs = i2c.o +pn532_uart-objs = uart.o obj-$(CONFIG_NFC_PN533) += pn533.o obj-$(CONFIG_NFC_PN533_USB) += pn533_usb.o obj-$(CONFIG_NFC_PN533_I2C) += pn533_i2c.o +obj-$(CONFIG_NFC_PN532_UART) += pn532_uart.o diff --git a/drivers/nfc/pn533/pn533.h b/drivers/nfc/pn533/pn533.h index eb5ccefc32e5..d1a0543f66a8 100644 --- a/drivers/nfc/pn533/pn533.h +++ b/drivers/nfc/pn533/pn533.h @@ -55,6 +55,11 @@ /* Preamble (1), SoPC (2), ACK Code (2), Postamble (1) */ #define PN533_STD_FRAME_ACK_SIZE 6 +/* + * Preamble (1), SoPC (2), Packet Length (1), Packet Length Checksum (1), + * Specific Application Level Error Code (1) , Postamble (1) + */ +#define PN533_STD_ERROR_FRAME_SIZE 8 #define PN533_STD_FRAME_CHECKSUM(f) (f->data[f->datalen]) #define PN533_STD_FRAME_POSTAMBLE(f) (f->data[f->datalen + 1]) /* Half start code (3), LEN (4) should be 0xffff for extended frame */ @@ -96,6 +101,9 @@ #define PN533_CMD_MI_MASK 0x40 #define PN533_CMD_RET_SUCCESS 0x00 +#define PN533_FRAME_DATALEN_ACK 0x00 +#define PN533_FRAME_DATALEN_ERROR 0x01 +#define PN533_FRAME_DATALEN_EXTENDED 0xFF enum pn533_protocol_type { PN533_PROTO_REQ_ACK_RESP = 0, diff --git a/drivers/nfc/pn533/uart.c b/drivers/nfc/pn533/uart.c new file mode 100644 index 000000000000..7df6d2fb8466 --- /dev/null +++ b/drivers/nfc/pn533/uart.c @@ -0,0 +1,311 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Driver for NXP PN532 NFC Chip - UART transport layer + * + * Copyright (C) 2018 Lemonage Software GmbH + * Author: Lars Pöschel <poeschel@lemonage.de> + * All rights reserved. + */ + +#include <linux/device.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/nfc.h> +#include <linux/netdevice.h> +#include <linux/of.h> +#include <linux/serdev.h> +#include "pn533.h" + +#define PN532_UART_SKB_BUFF_LEN (PN533_CMD_DATAEXCH_DATA_MAXLEN * 2) + +enum send_wakeup { + PN532_SEND_NO_WAKEUP = 0, + PN532_SEND_WAKEUP, + PN532_SEND_LAST_WAKEUP, +}; + + +struct pn532_uart_phy { + struct serdev_device *serdev; + struct sk_buff *recv_skb; + struct pn533 *priv; + enum send_wakeup send_wakeup; + struct timer_list cmd_timeout; + struct sk_buff *cur_out_buf; +}; + +static int pn532_uart_send_frame(struct pn533 *dev, + struct sk_buff *out) +{ + /* wakeup sequence and dummy bytes for waiting time */ + static const u8 wakeup[] = { + 0x55, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + struct pn532_uart_phy *pn532 = dev->phy; + int err; + + print_hex_dump_debug("PN532_uart TX: ", DUMP_PREFIX_NONE, 16, 1, + out->data, out->len, false); + + pn532->cur_out_buf = out; + if (pn532->send_wakeup) { + err= serdev_device_write(pn532->serdev, + wakeup, sizeof(wakeup), + MAX_SCHEDULE_TIMEOUT); + if (err < 0) + return err; + } + + if (pn532->send_wakeup == PN532_SEND_LAST_WAKEUP) { + pn532->send_wakeup = PN532_SEND_NO_WAKEUP; + } + + err = serdev_device_write(pn532->serdev, out->data, out->len, + MAX_SCHEDULE_TIMEOUT); + if (err < 0) + return err; + + mod_timer(&pn532->cmd_timeout, HZ / 40 + jiffies); + return 0; +} + +static int pn532_uart_send_ack(struct pn533 *dev, gfp_t flags) +{ + struct pn532_uart_phy *pn532 = dev->phy; + /* spec 7.1.1.3: Preamble, SoPC (2), ACK Code (2), Postamble */ + static const u8 ack[PN533_STD_FRAME_ACK_SIZE] = { + 0x00, 0x00, 0xff, 0x00, 0xff, 0x00}; + int err; + + err = serdev_device_write(pn532->serdev, ack, sizeof(ack), + MAX_SCHEDULE_TIMEOUT); + if (err < 0) + return err; + + return 0; +} + +static void pn532_uart_abort_cmd(struct pn533 *dev, gfp_t flags) +{ + /* An ack will cancel the last issued command */ + pn532_uart_send_ack(dev, flags); + /* schedule cmd_complete_work to finish current command execution */ + pn533_recv_frame(dev, NULL, -ENOENT); +} + +static void pn532_dev_up(struct pn533 *dev) +{ + struct pn532_uart_phy *pn532 = dev->phy; + + serdev_device_open(pn532->serdev); + pn532->send_wakeup = PN532_SEND_LAST_WAKEUP; +} + +static void pn532_dev_down(struct pn533 *dev) +{ + struct pn532_uart_phy *pn532 = dev->phy; + + serdev_device_close(pn532->serdev); + pn532->send_wakeup = PN532_SEND_WAKEUP; +} + +static struct pn533_phy_ops uart_phy_ops = { + .send_frame = pn532_uart_send_frame, + .send_ack = pn532_uart_send_ack, + .abort_cmd = pn532_uart_abort_cmd, + .dev_up = pn532_dev_up, + .dev_down = pn532_dev_down, +}; + +static void pn532_cmd_timeout(struct timer_list *t) +{ + struct pn532_uart_phy *dev = from_timer(dev, t, cmd_timeout); + + pn532_uart_send_frame(dev->priv, dev->cur_out_buf); +} + +/* + * scans the buffer if it contains a pn532 frame. It is not checked if the + * frame is really valid. This is later done with pn533_rx_frame_is_valid. + * This is useful for malformed or errornous transmitted frames. Adjusts the + * bufferposition where the frame starts, since pn533_recv_frame expects a + * well formed frame. + */ +static int pn532_uart_rx_is_frame(struct sk_buff *skb) +{ + int i; + u16 frame_len; + struct pn533_std_frame *std; + struct pn533_ext_frame *ext; + + for (i = 0; i + PN533_STD_FRAME_ACK_SIZE <= skb->len; i++) { + std = (struct pn533_std_frame *)&skb->data[i]; + /* search start code */ + if (std->start_frame != cpu_to_be16(PN533_STD_FRAME_SOF)) + continue; + + /* frame type */ + switch (std->datalen) { + case PN533_FRAME_DATALEN_ACK: + if (std->datalen_checksum == 0xff) { + skb_pull(skb, i); + return 1; + } + + break; + case PN533_FRAME_DATALEN_ERROR: + if ((std->datalen_checksum == 0xff) && + (skb->len >= + PN533_STD_ERROR_FRAME_SIZE)) { + skb_pull(skb, i); + return 1; + } + + break; + case PN533_FRAME_DATALEN_EXTENDED: + ext = (struct pn533_ext_frame *)&skb->data[i]; + frame_len = ext->datalen; + if (skb->len >= frame_len + + sizeof(struct pn533_ext_frame) + + 2 /* CKS + Postamble */) { + skb_pull(skb, i); + return 1; + } + + break; + default: /* normal information frame */ + frame_len = std->datalen; + if (skb->len >= frame_len + + sizeof(struct pn533_std_frame) + + 2 /* CKS + Postamble */) { + skb_pull(skb, i); + return 1; + } + + break; + } + } + + return 0; +} + +static int pn532_receive_buf(struct serdev_device *serdev, + const unsigned char *data, size_t count) +{ + struct pn532_uart_phy *dev = serdev_device_get_drvdata(serdev); + size_t i; + + del_timer(&dev->cmd_timeout); + for (i = 0; i < count; i++) { + skb_put_u8(dev->recv_skb, *data++); + if (!pn532_uart_rx_is_frame(dev->recv_skb)) + continue; + + pn533_recv_frame(dev->priv, dev->recv_skb, 0); + dev->recv_skb = alloc_skb(PN532_UART_SKB_BUFF_LEN, GFP_KERNEL); + if (!dev->recv_skb) + return 0; + } + + return i; +} + +static struct serdev_device_ops pn532_serdev_ops = { + .receive_buf = pn532_receive_buf, + .write_wakeup = serdev_device_write_wakeup, +}; + +static const struct of_device_id pn532_uart_of_match[] = { + { .compatible = "nxp,pn532-uart", }, + {}, +}; +MODULE_DEVICE_TABLE(of, pn532_uart_of_match); + +static int pn532_uart_probe(struct serdev_device *serdev) +{ + struct pn532_uart_phy *pn532; + struct pn533 *priv; + int err; + + err = -ENOMEM; + pn532 = kzalloc(sizeof(*pn532), GFP_KERNEL); + if (!pn532) + goto err_exit; + + pn532->recv_skb = alloc_skb(PN532_UART_SKB_BUFF_LEN, GFP_KERNEL); + if (!pn532->recv_skb) + goto err_free; + + pn532->serdev = serdev; + serdev_device_set_drvdata(serdev, pn532); + serdev_device_set_client_ops(serdev, &pn532_serdev_ops); + err = serdev_device_open(serdev); + if (err) { + dev_err(&serdev->dev, "Unable to open device\n"); + goto err_skb; + } + + err = serdev_device_set_baudrate(serdev, 115200); + if (err != 115200) { + err = -EINVAL; + goto err_serdev; + } + + serdev_device_set_flow_control(serdev, false); + pn532->send_wakeup = PN532_SEND_WAKEUP; + timer_setup(&pn532->cmd_timeout, pn532_cmd_timeout, 0); + priv = pn533_register_device(PN533_DEVICE_PN532, + PN533_NO_TYPE_B_PROTOCOLS, + PN533_PROTO_REQ_ACK_RESP, + pn532, &uart_phy_ops, NULL, + &pn532->serdev->dev, + &serdev->dev); + if (IS_ERR(priv)) { + err = PTR_ERR(priv); + goto err_serdev; + } + + pn532->priv = priv; + err = pn533_finalize_setup(pn532->priv); + if (err) + goto err_unregister; + + serdev_device_close(serdev); + return 0; + +err_unregister: + pn533_unregister_device(pn532->priv); +err_serdev: + serdev_device_close(serdev); +err_skb: + kfree_skb(pn532->recv_skb); +err_free: + kfree(pn532); +err_exit: + return err; +} + +static void pn532_uart_remove(struct serdev_device *serdev) +{ + struct pn532_uart_phy *pn532 = serdev_device_get_drvdata(serdev); + + pn533_unregister_device(pn532->priv); + serdev_device_close(serdev); + kfree_skb(pn532->recv_skb); + kfree(pn532); +} + +static struct serdev_device_driver pn532_uart_driver = { + .probe = pn532_uart_probe, + .remove = pn532_uart_remove, + .driver = { + .name = "pn532_uart", + .of_match_table = of_match_ptr(pn532_uart_of_match), + }, +}; + +module_serdev_device_driver(pn532_uart_driver); + +MODULE_AUTHOR("Lars Pöschel <poeschel@lemonage.de>"); +MODULE_DESCRIPTION("PN532 UART driver"); +MODULE_LICENSE("GPL");
This adds the UART phy interface for the pn533 driver. The pn533 driver can be used through UART interface this way. It is implemented as a serdev device. Signed-off-by: Lars Poeschel <poeschel@lemonage.de> --- Changes in v4: - SPDX-License-Identifier: GPL-2.0+ - Source code comments above refering items - Error check for serdev_device_write's - Change if (xxx == NULL) to if (!xxx) - Remove device name from a dev_err - move pn533_register in _probe a bit towards the end of _probe - make use of newly added dev_up / dev_down phy_ops - control send_wakeup variable from dev_up / dev_down Changes in v3: - depend on SERIAL_DEV_BUS in Kconfig Changes in v2: - switched from tty line discipline to serdev, resulting in many simplifications - SPDX License Identifier drivers/nfc/pn533/Kconfig | 11 ++ drivers/nfc/pn533/Makefile | 2 + drivers/nfc/pn533/pn533.h | 8 + drivers/nfc/pn533/uart.c | 311 +++++++++++++++++++++++++++++++++++++ 4 files changed, 332 insertions(+) create mode 100644 drivers/nfc/pn533/uart.c