Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Helpers for controlling modem lines via GPIO |
| 3 | * |
| 4 | * Copyright (C) 2014 Paratronic S.A. |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 15 | */ |
| 16 | |
| 17 | #include <linux/err.h> |
| 18 | #include <linux/device.h> |
Uwe Kleine-König | ce59e48 | 2015-09-30 10:19:41 +0200 | [diff] [blame] | 19 | #include <linux/irq.h> |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 20 | #include <linux/gpio/consumer.h> |
Alexander Shiyan | 93b8877 | 2014-09-20 09:34:45 +0400 | [diff] [blame] | 21 | #include <linux/termios.h> |
Uwe Kleine-König | ce59e48 | 2015-09-30 10:19:41 +0200 | [diff] [blame] | 22 | #include <linux/serial_core.h> |
Romain Izard | 82a3f87 | 2016-02-23 15:54:54 +0100 | [diff] [blame] | 23 | #include <linux/module.h> |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 24 | |
| 25 | #include "serial_mctrl_gpio.h" |
| 26 | |
| 27 | struct mctrl_gpios { |
Uwe Kleine-König | ce59e48 | 2015-09-30 10:19:41 +0200 | [diff] [blame] | 28 | struct uart_port *port; |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 29 | struct gpio_desc *gpio[UART_GPIO_MAX]; |
Uwe Kleine-König | ce59e48 | 2015-09-30 10:19:41 +0200 | [diff] [blame] | 30 | int irq[UART_GPIO_MAX]; |
| 31 | unsigned int mctrl_prev; |
| 32 | bool mctrl_on; |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 33 | }; |
| 34 | |
| 35 | static const struct { |
| 36 | const char *name; |
| 37 | unsigned int mctrl; |
| 38 | bool dir_out; |
| 39 | } mctrl_gpios_desc[UART_GPIO_MAX] = { |
| 40 | { "cts", TIOCM_CTS, false, }, |
| 41 | { "dsr", TIOCM_DSR, false, }, |
| 42 | { "dcd", TIOCM_CD, false, }, |
| 43 | { "rng", TIOCM_RNG, false, }, |
| 44 | { "rts", TIOCM_RTS, true, }, |
| 45 | { "dtr", TIOCM_DTR, true, }, |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 46 | }; |
| 47 | |
| 48 | void mctrl_gpio_set(struct mctrl_gpios *gpios, unsigned int mctrl) |
| 49 | { |
| 50 | enum mctrl_gpio_idx i; |
Rojhalat Ibrahim | 834296a | 2014-11-17 18:31:30 +0100 | [diff] [blame] | 51 | struct gpio_desc *desc_array[UART_GPIO_MAX]; |
| 52 | int value_array[UART_GPIO_MAX]; |
| 53 | unsigned int count = 0; |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 54 | |
Yegor Yefremov | 434be0a | 2016-05-31 10:59:17 +0200 | [diff] [blame] | 55 | if (gpios == NULL) |
| 56 | return; |
| 57 | |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 58 | for (i = 0; i < UART_GPIO_MAX; i++) |
Uwe Kleine-König | 445df7f | 2015-05-19 21:56:29 +0200 | [diff] [blame] | 59 | if (gpios->gpio[i] && mctrl_gpios_desc[i].dir_out) { |
Rojhalat Ibrahim | 834296a | 2014-11-17 18:31:30 +0100 | [diff] [blame] | 60 | desc_array[count] = gpios->gpio[i]; |
| 61 | value_array[count] = !!(mctrl & mctrl_gpios_desc[i].mctrl); |
| 62 | count++; |
| 63 | } |
Rojhalat Ibrahim | 3fff99b | 2015-05-13 11:04:56 +0200 | [diff] [blame] | 64 | gpiod_set_array_value(count, desc_array, value_array); |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 65 | } |
| 66 | EXPORT_SYMBOL_GPL(mctrl_gpio_set); |
| 67 | |
| 68 | struct gpio_desc *mctrl_gpio_to_gpiod(struct mctrl_gpios *gpios, |
| 69 | enum mctrl_gpio_idx gidx) |
| 70 | { |
Adam Ford | c9e709d | 2019-10-06 11:33:11 -0500 | [diff] [blame^] | 71 | if (gpios == NULL) |
| 72 | return NULL; |
| 73 | |
Uwe Kleine-König | 9e9f079 | 2015-02-12 15:24:41 +0100 | [diff] [blame] | 74 | return gpios->gpio[gidx]; |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 75 | } |
| 76 | EXPORT_SYMBOL_GPL(mctrl_gpio_to_gpiod); |
| 77 | |
| 78 | unsigned int mctrl_gpio_get(struct mctrl_gpios *gpios, unsigned int *mctrl) |
| 79 | { |
| 80 | enum mctrl_gpio_idx i; |
| 81 | |
Yegor Yefremov | 434be0a | 2016-05-31 10:59:17 +0200 | [diff] [blame] | 82 | if (gpios == NULL) |
| 83 | return *mctrl; |
| 84 | |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 85 | for (i = 0; i < UART_GPIO_MAX; i++) { |
Uwe Kleine-König | 9e9f079 | 2015-02-12 15:24:41 +0100 | [diff] [blame] | 86 | if (gpios->gpio[i] && !mctrl_gpios_desc[i].dir_out) { |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 87 | if (gpiod_get_value(gpios->gpio[i])) |
| 88 | *mctrl |= mctrl_gpios_desc[i].mctrl; |
| 89 | else |
| 90 | *mctrl &= ~mctrl_gpios_desc[i].mctrl; |
| 91 | } |
| 92 | } |
| 93 | |
| 94 | return *mctrl; |
| 95 | } |
| 96 | EXPORT_SYMBOL_GPL(mctrl_gpio_get); |
| 97 | |
Yegor Yefremov | bf5cee6 | 2016-05-31 10:59:16 +0200 | [diff] [blame] | 98 | unsigned int |
| 99 | mctrl_gpio_get_outputs(struct mctrl_gpios *gpios, unsigned int *mctrl) |
| 100 | { |
| 101 | enum mctrl_gpio_idx i; |
| 102 | |
Yegor Yefremov | 434be0a | 2016-05-31 10:59:17 +0200 | [diff] [blame] | 103 | if (gpios == NULL) |
| 104 | return *mctrl; |
| 105 | |
Yegor Yefremov | bf5cee6 | 2016-05-31 10:59:16 +0200 | [diff] [blame] | 106 | for (i = 0; i < UART_GPIO_MAX; i++) { |
| 107 | if (gpios->gpio[i] && mctrl_gpios_desc[i].dir_out) { |
| 108 | if (gpiod_get_value(gpios->gpio[i])) |
| 109 | *mctrl |= mctrl_gpios_desc[i].mctrl; |
| 110 | else |
| 111 | *mctrl &= ~mctrl_gpios_desc[i].mctrl; |
| 112 | } |
| 113 | } |
| 114 | |
| 115 | return *mctrl; |
| 116 | } |
| 117 | EXPORT_SYMBOL_GPL(mctrl_gpio_get_outputs); |
| 118 | |
Uwe Kleine-König | 7d8c70d | 2015-09-30 10:19:40 +0200 | [diff] [blame] | 119 | struct mctrl_gpios *mctrl_gpio_init_noauto(struct device *dev, unsigned int idx) |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 120 | { |
| 121 | struct mctrl_gpios *gpios; |
| 122 | enum mctrl_gpio_idx i; |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 123 | |
| 124 | gpios = devm_kzalloc(dev, sizeof(*gpios), GFP_KERNEL); |
| 125 | if (!gpios) |
| 126 | return ERR_PTR(-ENOMEM); |
| 127 | |
| 128 | for (i = 0; i < UART_GPIO_MAX; i++) { |
Uwe Kleine-König | 1d267ea | 2015-02-12 15:24:42 +0100 | [diff] [blame] | 129 | enum gpiod_flags flags; |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 130 | |
| 131 | if (mctrl_gpios_desc[i].dir_out) |
Uwe Kleine-König | 1d267ea | 2015-02-12 15:24:42 +0100 | [diff] [blame] | 132 | flags = GPIOD_OUT_LOW; |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 133 | else |
Uwe Kleine-König | 1d267ea | 2015-02-12 15:24:42 +0100 | [diff] [blame] | 134 | flags = GPIOD_IN; |
| 135 | |
| 136 | gpios->gpio[i] = |
| 137 | devm_gpiod_get_index_optional(dev, |
| 138 | mctrl_gpios_desc[i].name, |
| 139 | idx, flags); |
| 140 | |
| 141 | if (IS_ERR(gpios->gpio[i])) |
Fabio Estevam | 13bc2bb | 2015-03-10 12:23:18 -0300 | [diff] [blame] | 142 | return ERR_CAST(gpios->gpio[i]); |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 143 | } |
| 144 | |
| 145 | return gpios; |
| 146 | } |
Uwe Kleine-König | 7d8c70d | 2015-09-30 10:19:40 +0200 | [diff] [blame] | 147 | EXPORT_SYMBOL_GPL(mctrl_gpio_init_noauto); |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 148 | |
Uwe Kleine-König | ce59e48 | 2015-09-30 10:19:41 +0200 | [diff] [blame] | 149 | #define MCTRL_ANY_DELTA (TIOCM_RI | TIOCM_DSR | TIOCM_CD | TIOCM_CTS) |
| 150 | static irqreturn_t mctrl_gpio_irq_handle(int irq, void *context) |
| 151 | { |
| 152 | struct mctrl_gpios *gpios = context; |
| 153 | struct uart_port *port = gpios->port; |
| 154 | u32 mctrl = gpios->mctrl_prev; |
| 155 | u32 mctrl_diff; |
Yegor Yefremov | d11df618 | 2016-04-29 10:45:07 +0200 | [diff] [blame] | 156 | unsigned long flags; |
Uwe Kleine-König | ce59e48 | 2015-09-30 10:19:41 +0200 | [diff] [blame] | 157 | |
| 158 | mctrl_gpio_get(gpios, &mctrl); |
| 159 | |
Yegor Yefremov | d11df618 | 2016-04-29 10:45:07 +0200 | [diff] [blame] | 160 | spin_lock_irqsave(&port->lock, flags); |
| 161 | |
Uwe Kleine-König | ce59e48 | 2015-09-30 10:19:41 +0200 | [diff] [blame] | 162 | mctrl_diff = mctrl ^ gpios->mctrl_prev; |
| 163 | gpios->mctrl_prev = mctrl; |
| 164 | |
| 165 | if (mctrl_diff & MCTRL_ANY_DELTA && port->state != NULL) { |
| 166 | if ((mctrl_diff & mctrl) & TIOCM_RI) |
| 167 | port->icount.rng++; |
| 168 | |
| 169 | if ((mctrl_diff & mctrl) & TIOCM_DSR) |
| 170 | port->icount.dsr++; |
| 171 | |
| 172 | if (mctrl_diff & TIOCM_CD) |
| 173 | uart_handle_dcd_change(port, mctrl & TIOCM_CD); |
| 174 | |
| 175 | if (mctrl_diff & TIOCM_CTS) |
| 176 | uart_handle_cts_change(port, mctrl & TIOCM_CTS); |
| 177 | |
| 178 | wake_up_interruptible(&port->state->port.delta_msr_wait); |
| 179 | } |
| 180 | |
Yegor Yefremov | d11df618 | 2016-04-29 10:45:07 +0200 | [diff] [blame] | 181 | spin_unlock_irqrestore(&port->lock, flags); |
| 182 | |
Uwe Kleine-König | ce59e48 | 2015-09-30 10:19:41 +0200 | [diff] [blame] | 183 | return IRQ_HANDLED; |
| 184 | } |
| 185 | |
| 186 | struct mctrl_gpios *mctrl_gpio_init(struct uart_port *port, unsigned int idx) |
| 187 | { |
| 188 | struct mctrl_gpios *gpios; |
| 189 | enum mctrl_gpio_idx i; |
| 190 | |
| 191 | gpios = mctrl_gpio_init_noauto(port->dev, idx); |
| 192 | if (IS_ERR(gpios)) |
| 193 | return gpios; |
| 194 | |
| 195 | gpios->port = port; |
| 196 | |
| 197 | for (i = 0; i < UART_GPIO_MAX; ++i) { |
| 198 | int ret; |
| 199 | |
| 200 | if (!gpios->gpio[i] || mctrl_gpios_desc[i].dir_out) |
| 201 | continue; |
| 202 | |
| 203 | ret = gpiod_to_irq(gpios->gpio[i]); |
| 204 | if (ret <= 0) { |
| 205 | dev_err(port->dev, |
| 206 | "failed to find corresponding irq for %s (idx=%d, err=%d)\n", |
| 207 | mctrl_gpios_desc[i].name, idx, ret); |
| 208 | return ERR_PTR(ret); |
| 209 | } |
| 210 | gpios->irq[i] = ret; |
| 211 | |
| 212 | /* irqs should only be enabled in .enable_ms */ |
| 213 | irq_set_status_flags(gpios->irq[i], IRQ_NOAUTOEN); |
| 214 | |
| 215 | ret = devm_request_irq(port->dev, gpios->irq[i], |
| 216 | mctrl_gpio_irq_handle, |
| 217 | IRQ_TYPE_EDGE_BOTH, dev_name(port->dev), |
| 218 | gpios); |
| 219 | if (ret) { |
| 220 | /* alternatively implement polling */ |
| 221 | dev_err(port->dev, |
| 222 | "failed to request irq for %s (idx=%d, err=%d)\n", |
| 223 | mctrl_gpios_desc[i].name, idx, ret); |
| 224 | return ERR_PTR(ret); |
| 225 | } |
| 226 | } |
| 227 | |
| 228 | return gpios; |
| 229 | } |
Uwe Kleine-König | 4f71a2e | 2015-12-13 11:30:02 +0100 | [diff] [blame] | 230 | EXPORT_SYMBOL_GPL(mctrl_gpio_init); |
Uwe Kleine-König | ce59e48 | 2015-09-30 10:19:41 +0200 | [diff] [blame] | 231 | |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 232 | void mctrl_gpio_free(struct device *dev, struct mctrl_gpios *gpios) |
| 233 | { |
| 234 | enum mctrl_gpio_idx i; |
| 235 | |
Yegor Yefremov | 434be0a | 2016-05-31 10:59:17 +0200 | [diff] [blame] | 236 | if (gpios == NULL) |
| 237 | return; |
| 238 | |
Uwe Kleine-König | ce59e48 | 2015-09-30 10:19:41 +0200 | [diff] [blame] | 239 | for (i = 0; i < UART_GPIO_MAX; i++) { |
| 240 | if (gpios->irq[i]) |
| 241 | devm_free_irq(gpios->port->dev, gpios->irq[i], gpios); |
| 242 | |
Uwe Kleine-König | 445df7f | 2015-05-19 21:56:29 +0200 | [diff] [blame] | 243 | if (gpios->gpio[i]) |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 244 | devm_gpiod_put(dev, gpios->gpio[i]); |
Uwe Kleine-König | ce59e48 | 2015-09-30 10:19:41 +0200 | [diff] [blame] | 245 | } |
Richard Genoud | 84130aa | 2014-05-13 20:20:43 +0200 | [diff] [blame] | 246 | devm_kfree(dev, gpios); |
| 247 | } |
| 248 | EXPORT_SYMBOL_GPL(mctrl_gpio_free); |
Uwe Kleine-König | ce59e48 | 2015-09-30 10:19:41 +0200 | [diff] [blame] | 249 | |
| 250 | void mctrl_gpio_enable_ms(struct mctrl_gpios *gpios) |
| 251 | { |
| 252 | enum mctrl_gpio_idx i; |
| 253 | |
Yegor Yefremov | 434be0a | 2016-05-31 10:59:17 +0200 | [diff] [blame] | 254 | if (gpios == NULL) |
| 255 | return; |
| 256 | |
Uwe Kleine-König | ce59e48 | 2015-09-30 10:19:41 +0200 | [diff] [blame] | 257 | /* .enable_ms may be called multiple times */ |
| 258 | if (gpios->mctrl_on) |
| 259 | return; |
| 260 | |
| 261 | gpios->mctrl_on = true; |
| 262 | |
| 263 | /* get initial status of modem lines GPIOs */ |
| 264 | mctrl_gpio_get(gpios, &gpios->mctrl_prev); |
| 265 | |
| 266 | for (i = 0; i < UART_GPIO_MAX; ++i) { |
| 267 | if (!gpios->irq[i]) |
| 268 | continue; |
| 269 | |
| 270 | enable_irq(gpios->irq[i]); |
| 271 | } |
| 272 | } |
| 273 | EXPORT_SYMBOL_GPL(mctrl_gpio_enable_ms); |
| 274 | |
| 275 | void mctrl_gpio_disable_ms(struct mctrl_gpios *gpios) |
| 276 | { |
| 277 | enum mctrl_gpio_idx i; |
| 278 | |
Yegor Yefremov | 434be0a | 2016-05-31 10:59:17 +0200 | [diff] [blame] | 279 | if (gpios == NULL) |
| 280 | return; |
| 281 | |
Uwe Kleine-König | ce59e48 | 2015-09-30 10:19:41 +0200 | [diff] [blame] | 282 | if (!gpios->mctrl_on) |
| 283 | return; |
| 284 | |
| 285 | gpios->mctrl_on = false; |
| 286 | |
| 287 | for (i = 0; i < UART_GPIO_MAX; ++i) { |
| 288 | if (!gpios->irq[i]) |
| 289 | continue; |
| 290 | |
| 291 | disable_irq(gpios->irq[i]); |
| 292 | } |
| 293 | } |
Uwe Kleine-König | 4f71a2e | 2015-12-13 11:30:02 +0100 | [diff] [blame] | 294 | EXPORT_SYMBOL_GPL(mctrl_gpio_disable_ms); |
Romain Izard | 82a3f87 | 2016-02-23 15:54:54 +0100 | [diff] [blame] | 295 | |
| 296 | MODULE_LICENSE("GPL"); |