drivers/tty/serial/serial_mctrl_gpio.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Helpers for controlling modem lines via GPIO
   4  *
   5  * Copyright (C) 2014 Paratronic S.A.
   6  */
   7
   8 #include <linux/err.h>
   9 #include <linux/device.h>
  10 #include <linux/irq.h>
  11 #include <linux/gpio/consumer.h>
  12 #include <linux/termios.h>
  13 #include <linux/serial_core.h>
  14 #include <linux/module.h>
  15 #include <linux/property.h>
  16
  17 #include "serial_mctrl_gpio.h"
  18
  19 struct mctrl_gpios {
  20         struct uart_port *port;
  21         struct gpio_desc *gpio[UART_GPIO_MAX];
  22         int irq[UART_GPIO_MAX];
  23         unsigned int mctrl_prev;
  24         bool mctrl_on;
  25 };
  26
  27 static const struct {
  28         const char *name;
  29         unsigned int mctrl;
  30         bool dir_out;
  31 } mctrl_gpios_desc[UART_GPIO_MAX] = {
  32         { "cts", TIOCM_CTS, false, },
  33         { "dsr", TIOCM_DSR, false, },
  34         { "dcd", TIOCM_CD, false, },
  35         { "rng", TIOCM_RNG, false, },
  36         { "rts", TIOCM_RTS, true, },
  37         { "dtr", TIOCM_DTR, true, },
  38 };
  39
  40 void mctrl_gpio_set(struct mctrl_gpios *gpios, unsigned int mctrl)
  41 {
  42         enum mctrl_gpio_idx i;
  43         struct gpio_desc *desc_array[UART_GPIO_MAX];
  44         int value_array[UART_GPIO_MAX];
  45         unsigned int count = 0;
  46
  47         if (gpios == NULL)
  48                 return;
  49
  50         for (i = 0; i < UART_GPIO_MAX; i++)
  51                 if (gpios->gpio[i] && mctrl_gpios_desc[i].dir_out) {
  52                         desc_array[count] = gpios->gpio[i];
  53                         value_array[count] = !!(mctrl & mctrl_gpios_desc[i].mctrl);
  54                         count++;
  55                 }
  56         gpiod_set_array_value(count, desc_array, value_array);
  57 }
  58 EXPORT_SYMBOL_GPL(mctrl_gpio_set);
  59
  60 struct gpio_desc *mctrl_gpio_to_gpiod(struct mctrl_gpios *gpios,
  61                                       enum mctrl_gpio_idx gidx)
  62 {
  63         if (gpios == NULL)
  64                 return NULL;
  65
  66         return gpios->gpio[gidx];
  67 }
  68 EXPORT_SYMBOL_GPL(mctrl_gpio_to_gpiod);
  69
  70 unsigned int mctrl_gpio_get(struct mctrl_gpios *gpios, unsigned int *mctrl)
  71 {
  72         enum mctrl_gpio_idx i;
  73
  74         if (gpios == NULL)
  75                 return *mctrl;
  76
  77         for (i = 0; i < UART_GPIO_MAX; i++) {
  78                 if (gpios->gpio[i] && !mctrl_gpios_desc[i].dir_out) {
  79                         if (gpiod_get_value(gpios->gpio[i]))
  80                                 *mctrl |= mctrl_gpios_desc[i].mctrl;
  81                         else
  82                                 *mctrl &= ~mctrl_gpios_desc[i].mctrl;
  83                 }
  84         }
  85
  86         return *mctrl;
  87 }
  88 EXPORT_SYMBOL_GPL(mctrl_gpio_get);
  89
  90 unsigned int
  91 mctrl_gpio_get_outputs(struct mctrl_gpios *gpios, unsigned int *mctrl)
  92 {
  93         enum mctrl_gpio_idx i;
  94
  95         if (gpios == NULL)
  96                 return *mctrl;
  97
  98         for (i = 0; i < UART_GPIO_MAX; i++) {
  99                 if (gpios->gpio[i] && mctrl_gpios_desc[i].dir_out) {
 100                         if (gpiod_get_value(gpios->gpio[i]))
 101                                 *mctrl |= mctrl_gpios_desc[i].mctrl;
 102                         else
 103                                 *mctrl &= ~mctrl_gpios_desc[i].mctrl;
 104                 }
 105         }
 106
 107         return *mctrl;
 108 }
 109 EXPORT_SYMBOL_GPL(mctrl_gpio_get_outputs);
 110
 111 struct mctrl_gpios *mctrl_gpio_init_noauto(struct device *dev, unsigned int idx)
 112 {
 113         struct mctrl_gpios *gpios;
 114         enum mctrl_gpio_idx i;
 115
 116         gpios = devm_kzalloc(dev, sizeof(*gpios), GFP_KERNEL);
 117         if (!gpios)
 118                 return ERR_PTR(-ENOMEM);
 119
 120         for (i = 0; i < UART_GPIO_MAX; i++) {
 121                 enum gpiod_flags flags;
 122                 char *gpio_str;
 123                 bool present;
 124
 125                 /* Check if GPIO property exists and continue if not */
 126                 gpio_str = kasprintf(GFP_KERNEL, "%s-gpios",
 127                                      mctrl_gpios_desc[i].name);
 128                 if (!gpio_str)
 129                         continue;
 130
 131                 present = device_property_present(dev, gpio_str);
 132                 kfree(gpio_str);
 133                 if (!present)
 134                         continue;
 135
 136                 if (mctrl_gpios_desc[i].dir_out)
 137                         flags = GPIOD_OUT_LOW;
 138                 else
 139                         flags = GPIOD_IN;
 140
 141                 gpios->gpio[i] =
 142                         devm_gpiod_get_index_optional(dev,
 143                                                       mctrl_gpios_desc[i].name,
 144                                                       idx, flags);
 145
 146                 if (IS_ERR(gpios->gpio[i]))
 147                         return ERR_CAST(gpios->gpio[i]);
 148         }
 149
 150         return gpios;
 151 }
 152 EXPORT_SYMBOL_GPL(mctrl_gpio_init_noauto);
 153
 154 #define MCTRL_ANY_DELTA (TIOCM_RI | TIOCM_DSR | TIOCM_CD | TIOCM_CTS)
 155 static irqreturn_t mctrl_gpio_irq_handle(int irq, void *context)
 156 {
 157         struct mctrl_gpios *gpios = context;
 158         struct uart_port *port = gpios->port;
 159         u32 mctrl = gpios->mctrl_prev;
 160         u32 mctrl_diff;
 161         unsigned long flags;
 162
 163         mctrl_gpio_get(gpios, &mctrl);
 164
 165         spin_lock_irqsave(&port->lock, flags);
 166
 167         mctrl_diff = mctrl ^ gpios->mctrl_prev;
 168         gpios->mctrl_prev = mctrl;
 169
 170         if (mctrl_diff & MCTRL_ANY_DELTA && port->state != NULL) {
 171                 if ((mctrl_diff & mctrl) & TIOCM_RI)
 172                         port->icount.rng++;
 173
 174                 if ((mctrl_diff & mctrl) & TIOCM_DSR)
 175                         port->icount.dsr++;
 176
 177                 if (mctrl_diff & TIOCM_CD)
 178                         uart_handle_dcd_change(port, mctrl & TIOCM_CD);
 179
 180                 if (mctrl_diff & TIOCM_CTS)
 181                         uart_handle_cts_change(port, mctrl & TIOCM_CTS);
 182
 183                 wake_up_interruptible(&port->state->port.delta_msr_wait);
 184         }
 185
 186         spin_unlock_irqrestore(&port->lock, flags);
 187
 188         return IRQ_HANDLED;
 189 }
 190
 191 struct mctrl_gpios *mctrl_gpio_init(struct uart_port *port, unsigned int idx)
 192 {
 193         struct mctrl_gpios *gpios;
 194         enum mctrl_gpio_idx i;
 195
 196         gpios = mctrl_gpio_init_noauto(port->dev, idx);
 197         if (IS_ERR(gpios))
 198                 return gpios;
 199
 200         gpios->port = port;
 201
 202         for (i = 0; i < UART_GPIO_MAX; ++i) {
 203                 int ret;
 204
 205                 if (!gpios->gpio[i] || mctrl_gpios_desc[i].dir_out)
 206                         continue;
 207
 208                 ret = gpiod_to_irq(gpios->gpio[i]);
 209                 if (ret <= 0) {
 210                         dev_err(port->dev,
 211                                 "failed to find corresponding irq for %s (idx=%d, err=%d)\n",
 212                                 mctrl_gpios_desc[i].name, idx, ret);
 213                         return ERR_PTR(ret);
 214                 }
 215                 gpios->irq[i] = ret;
 216
 217                 /* irqs should only be enabled in .enable_ms */
 218                 irq_set_status_flags(gpios->irq[i], IRQ_NOAUTOEN);
 219
 220                 ret = devm_request_irq(port->dev, gpios->irq[i],
 221                                        mctrl_gpio_irq_handle,
 222                                        IRQ_TYPE_EDGE_BOTH, dev_name(port->dev),
 223                                        gpios);
 224                 if (ret) {
 225                         /* alternatively implement polling */
 226                         dev_err(port->dev,
 227                                 "failed to request irq for %s (idx=%d, err=%d)\n",
 228                                 mctrl_gpios_desc[i].name, idx, ret);
 229                         return ERR_PTR(ret);
 230                 }
 231         }
 232
 233         return gpios;
 234 }
 235 EXPORT_SYMBOL_GPL(mctrl_gpio_init);
 236
 237 void mctrl_gpio_free(struct device *dev, struct mctrl_gpios *gpios)
 238 {
 239         enum mctrl_gpio_idx i;
 240
 241         if (gpios == NULL)
 242                 return;
 243
 244         for (i = 0; i < UART_GPIO_MAX; i++) {
 245                 if (gpios->irq[i])
 246                         devm_free_irq(gpios->port->dev, gpios->irq[i], gpios);
 247
 248                 if (gpios->gpio[i])
 249                         devm_gpiod_put(dev, gpios->gpio[i]);
 250         }
 251         devm_kfree(dev, gpios);
 252 }
 253 EXPORT_SYMBOL_GPL(mctrl_gpio_free);
 254
 255 void mctrl_gpio_enable_ms(struct mctrl_gpios *gpios)
 256 {
 257         enum mctrl_gpio_idx i;
 258
 259         if (gpios == NULL)
 260                 return;
 261
 262         /* .enable_ms may be called multiple times */
 263         if (gpios->mctrl_on)
 264                 return;
 265
 266         gpios->mctrl_on = true;
 267
 268         /* get initial status of modem lines GPIOs */
 269         mctrl_gpio_get(gpios, &gpios->mctrl_prev);
 270
 271         for (i = 0; i < UART_GPIO_MAX; ++i) {
 272                 if (!gpios->irq[i])
 273                         continue;
 274
 275                 enable_irq(gpios->irq[i]);
 276         }
 277 }
 278 EXPORT_SYMBOL_GPL(mctrl_gpio_enable_ms);
 279
 280 void mctrl_gpio_disable_ms(struct mctrl_gpios *gpios)
 281 {
 282         enum mctrl_gpio_idx i;
 283
 284         if (gpios == NULL)
 285                 return;
 286
 287         if (!gpios->mctrl_on)
 288                 return;
 289
 290         gpios->mctrl_on = false;
 291
 292         for (i = 0; i < UART_GPIO_MAX; ++i) {
 293                 if (!gpios->irq[i])
 294                         continue;
 295
 296                 disable_irq(gpios->irq[i]);
 297         }
 298 }
 299 EXPORT_SYMBOL_GPL(mctrl_gpio_disable_ms);
 300
 301 MODULE_LICENSE("GPL");