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.
 15 */
 16
 17#include <linux/err.h>
 18#include <linux/device.h>
 19#include <linux/irq.h>
 20#include <linux/gpio/consumer.h>
 21#include <linux/termios.h>
 22#include <linux/serial_core.h>
 23#include <linux/module.h>
 24
 25#include "serial_mctrl_gpio.h"
 26
 27struct mctrl_gpios {
 28	struct uart_port *port;
 29	struct gpio_desc *gpio[UART_GPIO_MAX];
 30	int irq[UART_GPIO_MAX];
 31	unsigned int mctrl_prev;
 32	bool mctrl_on;
 33};
 34
 35static 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, },
 46	{ "out1", TIOCM_OUT1, true, },
 47	{ "out2", TIOCM_OUT2, true, },
 48};
 49
 50void mctrl_gpio_set(struct mctrl_gpios *gpios, unsigned int mctrl)
 51{
 52	enum mctrl_gpio_idx i;
 53	struct gpio_desc *desc_array[UART_GPIO_MAX];
 54	int value_array[UART_GPIO_MAX];
 55	unsigned int count = 0;
 56
 
 
 
 57	for (i = 0; i < UART_GPIO_MAX; i++)
 58		if (gpios->gpio[i] && mctrl_gpios_desc[i].dir_out) {
 59			desc_array[count] = gpios->gpio[i];
 60			value_array[count] = !!(mctrl & mctrl_gpios_desc[i].mctrl);
 61			count++;
 62		}
 63	gpiod_set_array_value(count, desc_array, value_array);
 64}
 65EXPORT_SYMBOL_GPL(mctrl_gpio_set);
 66
 67struct gpio_desc *mctrl_gpio_to_gpiod(struct mctrl_gpios *gpios,
 68				      enum mctrl_gpio_idx gidx)
 69{
 70	return gpios->gpio[gidx];
 71}
 72EXPORT_SYMBOL_GPL(mctrl_gpio_to_gpiod);
 73
 74unsigned int mctrl_gpio_get(struct mctrl_gpios *gpios, unsigned int *mctrl)
 75{
 76	enum mctrl_gpio_idx i;
 77
 
 
 
 78	for (i = 0; i < UART_GPIO_MAX; i++) {
 79		if (gpios->gpio[i] && !mctrl_gpios_desc[i].dir_out) {
 80			if (gpiod_get_value(gpios->gpio[i]))
 81				*mctrl |= mctrl_gpios_desc[i].mctrl;
 82			else
 83				*mctrl &= ~mctrl_gpios_desc[i].mctrl;
 84		}
 85	}
 86
 87	return *mctrl;
 88}
 89EXPORT_SYMBOL_GPL(mctrl_gpio_get);
 90
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 91struct mctrl_gpios *mctrl_gpio_init_noauto(struct device *dev, unsigned int idx)
 92{
 93	struct mctrl_gpios *gpios;
 94	enum mctrl_gpio_idx i;
 95
 96	gpios = devm_kzalloc(dev, sizeof(*gpios), GFP_KERNEL);
 97	if (!gpios)
 98		return ERR_PTR(-ENOMEM);
 99
100	for (i = 0; i < UART_GPIO_MAX; i++) {
101		enum gpiod_flags flags;
102
103		if (mctrl_gpios_desc[i].dir_out)
104			flags = GPIOD_OUT_LOW;
105		else
106			flags = GPIOD_IN;
107
108		gpios->gpio[i] =
109			devm_gpiod_get_index_optional(dev,
110						      mctrl_gpios_desc[i].name,
111						      idx, flags);
112
113		if (IS_ERR(gpios->gpio[i]))
114			return ERR_CAST(gpios->gpio[i]);
115	}
116
117	return gpios;
118}
119EXPORT_SYMBOL_GPL(mctrl_gpio_init_noauto);
120
121#define MCTRL_ANY_DELTA (TIOCM_RI | TIOCM_DSR | TIOCM_CD | TIOCM_CTS)
122static irqreturn_t mctrl_gpio_irq_handle(int irq, void *context)
123{
124	struct mctrl_gpios *gpios = context;
125	struct uart_port *port = gpios->port;
126	u32 mctrl = gpios->mctrl_prev;
127	u32 mctrl_diff;
 
128
129	mctrl_gpio_get(gpios, &mctrl);
130
 
 
131	mctrl_diff = mctrl ^ gpios->mctrl_prev;
132	gpios->mctrl_prev = mctrl;
133
134	if (mctrl_diff & MCTRL_ANY_DELTA && port->state != NULL) {
135		if ((mctrl_diff & mctrl) & TIOCM_RI)
136			port->icount.rng++;
137
138		if ((mctrl_diff & mctrl) & TIOCM_DSR)
139			port->icount.dsr++;
140
141		if (mctrl_diff & TIOCM_CD)
142			uart_handle_dcd_change(port, mctrl & TIOCM_CD);
143
144		if (mctrl_diff & TIOCM_CTS)
145			uart_handle_cts_change(port, mctrl & TIOCM_CTS);
146
147		wake_up_interruptible(&port->state->port.delta_msr_wait);
148	}
149
 
 
150	return IRQ_HANDLED;
151}
152
153struct mctrl_gpios *mctrl_gpio_init(struct uart_port *port, unsigned int idx)
154{
155	struct mctrl_gpios *gpios;
156	enum mctrl_gpio_idx i;
157
158	gpios = mctrl_gpio_init_noauto(port->dev, idx);
159	if (IS_ERR(gpios))
160		return gpios;
161
162	gpios->port = port;
163
164	for (i = 0; i < UART_GPIO_MAX; ++i) {
165		int ret;
166
167		if (!gpios->gpio[i] || mctrl_gpios_desc[i].dir_out)
168			continue;
169
170		ret = gpiod_to_irq(gpios->gpio[i]);
171		if (ret <= 0) {
172			dev_err(port->dev,
173				"failed to find corresponding irq for %s (idx=%d, err=%d)\n",
174				mctrl_gpios_desc[i].name, idx, ret);
175			return ERR_PTR(ret);
176		}
177		gpios->irq[i] = ret;
178
179		/* irqs should only be enabled in .enable_ms */
180		irq_set_status_flags(gpios->irq[i], IRQ_NOAUTOEN);
181
182		ret = devm_request_irq(port->dev, gpios->irq[i],
183				       mctrl_gpio_irq_handle,
184				       IRQ_TYPE_EDGE_BOTH, dev_name(port->dev),
185				       gpios);
186		if (ret) {
187			/* alternatively implement polling */
188			dev_err(port->dev,
189				"failed to request irq for %s (idx=%d, err=%d)\n",
190				mctrl_gpios_desc[i].name, idx, ret);
191			return ERR_PTR(ret);
192		}
193	}
194
195	return gpios;
196}
197EXPORT_SYMBOL_GPL(mctrl_gpio_init);
198
199void mctrl_gpio_free(struct device *dev, struct mctrl_gpios *gpios)
200{
201	enum mctrl_gpio_idx i;
202
 
 
 
203	for (i = 0; i < UART_GPIO_MAX; i++) {
204		if (gpios->irq[i])
205			devm_free_irq(gpios->port->dev, gpios->irq[i], gpios);
206
207		if (gpios->gpio[i])
208			devm_gpiod_put(dev, gpios->gpio[i]);
209	}
210	devm_kfree(dev, gpios);
211}
212EXPORT_SYMBOL_GPL(mctrl_gpio_free);
213
214void mctrl_gpio_enable_ms(struct mctrl_gpios *gpios)
215{
216	enum mctrl_gpio_idx i;
217
 
 
 
218	/* .enable_ms may be called multiple times */
219	if (gpios->mctrl_on)
220		return;
221
222	gpios->mctrl_on = true;
223
224	/* get initial status of modem lines GPIOs */
225	mctrl_gpio_get(gpios, &gpios->mctrl_prev);
226
227	for (i = 0; i < UART_GPIO_MAX; ++i) {
228		if (!gpios->irq[i])
229			continue;
230
231		enable_irq(gpios->irq[i]);
232	}
233}
234EXPORT_SYMBOL_GPL(mctrl_gpio_enable_ms);
235
236void mctrl_gpio_disable_ms(struct mctrl_gpios *gpios)
237{
238	enum mctrl_gpio_idx i;
 
 
 
239
240	if (!gpios->mctrl_on)
241		return;
242
243	gpios->mctrl_on = false;
244
245	for (i = 0; i < UART_GPIO_MAX; ++i) {
246		if (!gpios->irq[i])
247			continue;
248
249		disable_irq(gpios->irq[i]);
250	}
251}
252EXPORT_SYMBOL_GPL(mctrl_gpio_disable_ms);
253
254MODULE_LICENSE("GPL");

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