drivers/nfc/nfcmrvl/uart.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Marvell NFC-over-UART driver
   4  *
   5  * Copyright (C) 2015, Marvell International Ltd.
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/delay.h>
  10 #include <linux/of_gpio.h>
  11 #include <net/nfc/nci.h>
  12 #include <net/nfc/nci_core.h>
  13 #include "nfcmrvl.h"
  14
  15 static unsigned int hci_muxed;
  16 static unsigned int flow_control;
  17 static unsigned int break_control;
  18 static int reset_n_io = -EINVAL;
  19
  20 /*
  21 ** NFCMRVL NCI OPS
  22 */
  23
  24 static int nfcmrvl_uart_nci_open(struct nfcmrvl_private *priv)
  25 {
  26         return 0;
  27 }
  28
  29 static int nfcmrvl_uart_nci_close(struct nfcmrvl_private *priv)
  30 {
  31         return 0;
  32 }
  33
  34 static int nfcmrvl_uart_nci_send(struct nfcmrvl_private *priv,
  35                                  struct sk_buff *skb)
  36 {
  37         struct nci_uart *nu = priv->drv_data;
  38
  39         return nu->ops.send(nu, skb);
  40 }
  41
  42 static void nfcmrvl_uart_nci_update_config(struct nfcmrvl_private *priv,
  43                                            const void *param)
  44 {
  45         struct nci_uart *nu = priv->drv_data;
  46         const struct nfcmrvl_fw_uart_config *config = param;
  47
  48         nci_uart_set_config(nu, le32_to_cpu(config->baudrate),
  49                             config->flow_control);
  50 }
  51
  52 static struct nfcmrvl_if_ops uart_ops = {
  53         .nci_open = nfcmrvl_uart_nci_open,
  54         .nci_close = nfcmrvl_uart_nci_close,
  55         .nci_send = nfcmrvl_uart_nci_send,
  56         .nci_update_config = nfcmrvl_uart_nci_update_config
  57 };
  58
  59 static int nfcmrvl_uart_parse_dt(struct device_node *node,
  60                                  struct nfcmrvl_platform_data *pdata)
  61 {
  62         struct device_node *matched_node;
  63         int ret;
  64
  65         matched_node = of_get_compatible_child(node, "marvell,nfc-uart");
  66         if (!matched_node) {
  67                 matched_node = of_get_compatible_child(node, "mrvl,nfc-uart");
  68                 if (!matched_node)
  69                         return -ENODEV;
  70         }
  71
  72         ret = nfcmrvl_parse_dt(matched_node, pdata);
  73         if (ret < 0) {
  74                 pr_err("Failed to get generic entries\n");
  75                 of_node_put(matched_node);
  76                 return ret;
  77         }
  78
  79         if (of_find_property(matched_node, "flow-control", NULL))
  80                 pdata->flow_control = 1;
  81         else
  82                 pdata->flow_control = 0;
  83
  84         if (of_find_property(matched_node, "break-control", NULL))
  85                 pdata->break_control = 1;
  86         else
  87                 pdata->break_control = 0;
  88
  89         of_node_put(matched_node);
  90
  91         return 0;
  92 }
  93
  94 /*
  95 ** NCI UART OPS
  96 */
  97
  98 static int nfcmrvl_nci_uart_open(struct nci_uart *nu)
  99 {
 100         struct nfcmrvl_private *priv;
 101         struct nfcmrvl_platform_data *pdata = NULL;
 102         struct nfcmrvl_platform_data config;
 103         struct device *dev = nu->tty->dev;
 104
 105         /*
 106          * Platform data cannot be used here since usually it is already used
 107          * by low level serial driver. We can try to retrieve serial device
 108          * and check if DT entries were added.
 109          */
 110
 111         if (dev && dev->parent && dev->parent->of_node)
 112                 if (nfcmrvl_uart_parse_dt(dev->parent->of_node, &config) == 0)
 113                         pdata = &config;
 114
 115         if (!pdata) {
 116                 pr_info("No platform data / DT -> fallback to module params\n");
 117                 config.hci_muxed = hci_muxed;
 118                 config.reset_n_io = reset_n_io;
 119                 config.flow_control = flow_control;
 120                 config.break_control = break_control;
 121                 pdata = &config;
 122         }
 123
 124         priv = nfcmrvl_nci_register_dev(NFCMRVL_PHY_UART, nu, &uart_ops,
 125                                         dev, pdata);
 126         if (IS_ERR(priv))
 127                 return PTR_ERR(priv);
 128
 129         priv->support_fw_dnld = true;
 130
 131         nu->drv_data = priv;
 132         nu->ndev = priv->ndev;
 133
 134         return 0;
 135 }
 136
 137 static void nfcmrvl_nci_uart_close(struct nci_uart *nu)
 138 {
 139         nfcmrvl_nci_unregister_dev((struct nfcmrvl_private *)nu->drv_data);
 140 }
 141
 142 static int nfcmrvl_nci_uart_recv(struct nci_uart *nu, struct sk_buff *skb)
 143 {
 144         return nfcmrvl_nci_recv_frame((struct nfcmrvl_private *)nu->drv_data,
 145                                       skb);
 146 }
 147
 148 static void nfcmrvl_nci_uart_tx_start(struct nci_uart *nu)
 149 {
 150         struct nfcmrvl_private *priv = (struct nfcmrvl_private *)nu->drv_data;
 151
 152         if (priv->ndev->nfc_dev->fw_download_in_progress)
 153                 return;
 154
 155         /* Remove BREAK to wake up the NFCC */
 156         if (priv->config.break_control && nu->tty->ops->break_ctl) {
 157                 nu->tty->ops->break_ctl(nu->tty, 0);
 158                 usleep_range(3000, 5000);
 159         }
 160 }
 161
 162 static void nfcmrvl_nci_uart_tx_done(struct nci_uart *nu)
 163 {
 164         struct nfcmrvl_private *priv = (struct nfcmrvl_private *)nu->drv_data;
 165
 166         if (priv->ndev->nfc_dev->fw_download_in_progress)
 167                 return;
 168
 169         /*
 170         ** To ensure that if the NFCC goes in DEEP SLEEP sate we can wake him
 171         ** up. we set BREAK. Once we will be ready to send again we will remove
 172         ** it.
 173         */
 174         if (priv->config.break_control && nu->tty->ops->break_ctl) {
 175                 nu->tty->ops->break_ctl(nu->tty, -1);
 176                 usleep_range(1000, 3000);
 177         }
 178 }
 179
 180 static struct nci_uart nfcmrvl_nci_uart = {
 181         .owner  = THIS_MODULE,
 182         .name   = "nfcmrvl_uart",
 183         .driver = NCI_UART_DRIVER_MARVELL,
 184         .ops    = {
 185                 .open           = nfcmrvl_nci_uart_open,
 186                 .close          = nfcmrvl_nci_uart_close,
 187                 .recv           = nfcmrvl_nci_uart_recv,
 188                 .tx_start       = nfcmrvl_nci_uart_tx_start,
 189                 .tx_done        = nfcmrvl_nci_uart_tx_done,
 190         }
 191 };
 192
 193 /*
 194 ** Module init
 195 */
 196
 197 static int nfcmrvl_uart_init_module(void)
 198 {
 199         return nci_uart_register(&nfcmrvl_nci_uart);
 200 }
 201
 202 static void nfcmrvl_uart_exit_module(void)
 203 {
 204         nci_uart_unregister(&nfcmrvl_nci_uart);
 205 }
 206
 207 module_init(nfcmrvl_uart_init_module);
 208 module_exit(nfcmrvl_uart_exit_module);
 209
 210 MODULE_AUTHOR("Marvell International Ltd.");
 211 MODULE_DESCRIPTION("Marvell NFC-over-UART");
 212 MODULE_LICENSE("GPL v2");
 213
 214 module_param(flow_control, uint, 0);
 215 MODULE_PARM_DESC(flow_control, "Tell if UART needs flow control at init.");
 216
 217 module_param(break_control, uint, 0);
 218 MODULE_PARM_DESC(break_control, "Tell if UART driver must drive break signal.");
 219
 220 module_param(hci_muxed, uint, 0);
 221 MODULE_PARM_DESC(hci_muxed, "Tell if transport is muxed in HCI one.");
 222
 223 module_param(reset_n_io, int, 0);
 224 MODULE_PARM_DESC(reset_n_io, "GPIO that is wired to RESET_N signal.");