1/*
2 * nokia-modem.c
3 *
4 * HSI client driver for Nokia N900 modem.
5 *
6 * Copyright (C) 2014 Sebastian Reichel <sre@kernel.org>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
21 */
22
23#include <linux/gpio/consumer.h>
24#include <linux/hsi/hsi.h>
25#include <linux/init.h>
26#include <linux/interrupt.h>
27#include <linux/of.h>
28#include <linux/of_irq.h>
29#include <linux/of_gpio.h>
30#include <linux/hsi/ssi_protocol.h>
31
32static unsigned int pm = 1;
33module_param(pm, int, 0400);
34MODULE_PARM_DESC(pm,
35	"Enable power management (0=disabled, 1=userland based [default])");
36
37struct nokia_modem_gpio {
38	struct gpio_desc	*gpio;
39	const char		*name;
40};
41
42struct nokia_modem_device {
43	struct tasklet_struct	nokia_modem_rst_ind_tasklet;
44	int			nokia_modem_rst_ind_irq;
45	struct device		*device;
46	struct nokia_modem_gpio	*gpios;
47	int			gpio_amount;
48	struct hsi_client	*ssi_protocol;
49	struct hsi_client	*cmt_speech;
50};
51
52static void do_nokia_modem_rst_ind_tasklet(unsigned long data)
53{
54	struct nokia_modem_device *modem = (struct nokia_modem_device *)data;
55
56	if (!modem)
57		return;
58
59	dev_info(modem->device, "CMT rst line change detected\n");
60
61	if (modem->ssi_protocol)
62		ssip_reset_event(modem->ssi_protocol);
63}
64
65static irqreturn_t nokia_modem_rst_ind_isr(int irq, void *data)
66{
67	struct nokia_modem_device *modem = (struct nokia_modem_device *)data;
68
69	tasklet_schedule(&modem->nokia_modem_rst_ind_tasklet);
70
71	return IRQ_HANDLED;
72}
73
74static void nokia_modem_gpio_unexport(struct device *dev)
75{
76	struct nokia_modem_device *modem = dev_get_drvdata(dev);
77	int i;
78
79	for (i = 0; i < modem->gpio_amount; i++) {
80		sysfs_remove_link(&dev->kobj, modem->gpios[i].name);
81		gpiod_unexport(modem->gpios[i].gpio);
82	}
83}
84
85static int nokia_modem_gpio_probe(struct device *dev)
86{
87	struct device_node *np = dev->of_node;
88	struct nokia_modem_device *modem = dev_get_drvdata(dev);
89	int gpio_count, gpio_name_count, i, err;
90
91	gpio_count = of_gpio_count(np);
92
93	if (gpio_count < 0) {
94		dev_err(dev, "missing gpios: %d\n", gpio_count);
95		return gpio_count;
96	}
97
98	gpio_name_count = of_property_count_strings(np, "gpio-names");
99
100	if (gpio_count != gpio_name_count) {
101		dev_err(dev, "number of gpios does not equal number of gpio names\n");
102		return -EINVAL;
103	}
104
105	modem->gpios = devm_kzalloc(dev, gpio_count *
106				sizeof(struct nokia_modem_gpio), GFP_KERNEL);
107	if (!modem->gpios) {
108		dev_err(dev, "Could not allocate memory for gpios\n");
109		return -ENOMEM;
110	}
111
112	modem->gpio_amount = gpio_count;
113
114	for (i = 0; i < gpio_count; i++) {
115		modem->gpios[i].gpio = devm_gpiod_get_index(dev, NULL, i);
116		if (IS_ERR(modem->gpios[i].gpio)) {
117			dev_err(dev, "Could not get gpio %d\n", i);
118			return PTR_ERR(modem->gpios[i].gpio);
119		}
120
121		err = of_property_read_string_index(np, "gpio-names", i,
122						&(modem->gpios[i].name));
123		if (err) {
124			dev_err(dev, "Could not get gpio name %d\n", i);
125			return err;
126		}
127
128		err = gpiod_direction_output(modem->gpios[i].gpio, 0);
129		if (err)
130			return err;
131
132		err = gpiod_export(modem->gpios[i].gpio, 0);
133		if (err)
134			return err;
135
136		err = gpiod_export_link(dev, modem->gpios[i].name,
137							modem->gpios[i].gpio);
138		if (err)
139			return err;
140	}
141
142	return 0;
143}
144
145static int nokia_modem_probe(struct device *dev)
146{
147	struct device_node *np;
148	struct nokia_modem_device *modem;
149	struct hsi_client *cl = to_hsi_client(dev);
150	struct hsi_port *port = hsi_get_port(cl);
151	int irq, pflags, err;
152	struct hsi_board_info ssip;
153	struct hsi_board_info cmtspeech;
154
155	np = dev->of_node;
156	if (!np) {
157		dev_err(dev, "device tree node not found\n");
158		return -ENXIO;
159	}
160
161	modem = devm_kzalloc(dev, sizeof(*modem), GFP_KERNEL);
162	if (!modem) {
163		dev_err(dev, "Could not allocate memory for nokia_modem_device\n");
164		return -ENOMEM;
165	}
166	dev_set_drvdata(dev, modem);
167	modem->device = dev;
168
169	irq = irq_of_parse_and_map(np, 0);
170	if (!irq) {
171		dev_err(dev, "Invalid rst_ind interrupt (%d)\n", irq);
172		return -EINVAL;
173	}
174	modem->nokia_modem_rst_ind_irq = irq;
175	pflags = irq_get_trigger_type(irq);
176
177	tasklet_init(&modem->nokia_modem_rst_ind_tasklet,
178			do_nokia_modem_rst_ind_tasklet, (unsigned long)modem);
179	err = devm_request_irq(dev, irq, nokia_modem_rst_ind_isr,
180				pflags, "modem_rst_ind", modem);
181	if (err < 0) {
182		dev_err(dev, "Request rst_ind irq(%d) failed (flags %d)\n",
183								irq, pflags);
184		return err;
185	}
186	enable_irq_wake(irq);
187
188	if(pm) {
189		err = nokia_modem_gpio_probe(dev);
190		if (err < 0) {
191			dev_err(dev, "Could not probe GPIOs\n");
192			goto error1;
193		}
194	}
195
196	ssip.name = "ssi-protocol";
197	ssip.tx_cfg = cl->tx_cfg;
198	ssip.rx_cfg = cl->rx_cfg;
199	ssip.platform_data = NULL;
200	ssip.archdata = NULL;
201
202	modem->ssi_protocol = hsi_new_client(port, &ssip);
203	if (!modem->ssi_protocol) {
204		dev_err(dev, "Could not register ssi-protocol device\n");
205		err = -ENOMEM;
206		goto error2;
207	}
208
209	err = device_attach(&modem->ssi_protocol->device);
210	if (err == 0) {
211		dev_err(dev, "Missing ssi-protocol driver\n");
212		err = -EPROBE_DEFER;
213		goto error3;
214	} else if (err < 0) {
215		dev_err(dev, "Could not load ssi-protocol driver (%d)\n", err);
216		goto error3;
217	}
218
219	cmtspeech.name = "cmt-speech";
220	cmtspeech.tx_cfg = cl->tx_cfg;
221	cmtspeech.rx_cfg = cl->rx_cfg;
222	cmtspeech.platform_data = NULL;
223	cmtspeech.archdata = NULL;
224
225	modem->cmt_speech = hsi_new_client(port, &cmtspeech);
226	if (!modem->cmt_speech) {
227		dev_err(dev, "Could not register cmt-speech device\n");
228		err = -ENOMEM;
229		goto error3;
230	}
231
232	err = device_attach(&modem->cmt_speech->device);
233	if (err == 0) {
234		dev_err(dev, "Missing cmt-speech driver\n");
235		err = -EPROBE_DEFER;
236		goto error4;
237	} else if (err < 0) {
238		dev_err(dev, "Could not load cmt-speech driver (%d)\n", err);
239		goto error4;
240	}
241
242	dev_info(dev, "Registered Nokia HSI modem\n");
243
244	return 0;
245
246error4:
247	hsi_remove_client(&modem->cmt_speech->device, NULL);
248error3:
249	hsi_remove_client(&modem->ssi_protocol->device, NULL);
250error2:
251	nokia_modem_gpio_unexport(dev);
252error1:
253	disable_irq_wake(modem->nokia_modem_rst_ind_irq);
254	tasklet_kill(&modem->nokia_modem_rst_ind_tasklet);
255
256	return err;
257}
258
259static int nokia_modem_remove(struct device *dev)
260{
261	struct nokia_modem_device *modem = dev_get_drvdata(dev);
262
263	if (!modem)
264		return 0;
265
266	if (modem->cmt_speech) {
267		hsi_remove_client(&modem->cmt_speech->device, NULL);
268		modem->cmt_speech = NULL;
269	}
270
271	if (modem->ssi_protocol) {
272		hsi_remove_client(&modem->ssi_protocol->device, NULL);
273		modem->ssi_protocol = NULL;
274	}
275
276	nokia_modem_gpio_unexport(dev);
277	dev_set_drvdata(dev, NULL);
278	disable_irq_wake(modem->nokia_modem_rst_ind_irq);
279	tasklet_kill(&modem->nokia_modem_rst_ind_tasklet);
280
281	return 0;
282}
283
284#ifdef CONFIG_OF
285static const struct of_device_id nokia_modem_of_match[] = {
286	{ .compatible = "nokia,n900-modem", },
287	{},
288};
289MODULE_DEVICE_TABLE(of, nokia_modem_of_match);
290#endif
291
292static struct hsi_client_driver nokia_modem_driver = {
293	.driver = {
294		.name	= "nokia-modem",
295		.owner	= THIS_MODULE,
296		.probe	= nokia_modem_probe,
297		.remove	= nokia_modem_remove,
298		.of_match_table = of_match_ptr(nokia_modem_of_match),
299	},
300};
301
302static int __init nokia_modem_init(void)
303{
304	return hsi_register_client_driver(&nokia_modem_driver);
305}
306module_init(nokia_modem_init);
307
308static void __exit nokia_modem_exit(void)
309{
310	hsi_unregister_client_driver(&nokia_modem_driver);
311}
312module_exit(nokia_modem_exit);
313
314MODULE_ALIAS("hsi:nokia-modem");
315MODULE_AUTHOR("Sebastian Reichel <sre@kernel.org>");
316MODULE_DESCRIPTION("HSI driver module for Nokia N900 Modem");
317MODULE_LICENSE("GPL");
318