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 
32 static unsigned int pm = 1;
33 module_param(pm, int, 0400);
34 MODULE_PARM_DESC(pm,
35 	"Enable power management (0=disabled, 1=userland based [default])");
36 
37 struct nokia_modem_gpio {
38 	struct gpio_desc	*gpio;
39 	const char		*name;
40 };
41 
42 struct 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 
52 static 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 
65 static 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 
74 static 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 
85 static 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 
145 static 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 
246 error4:
247 	hsi_remove_client(&modem->cmt_speech->device, NULL);
248 error3:
249 	hsi_remove_client(&modem->ssi_protocol->device, NULL);
250 error2:
251 	nokia_modem_gpio_unexport(dev);
252 error1:
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 
259 static 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
285 static const struct of_device_id nokia_modem_of_match[] = {
286 	{ .compatible = "nokia,n900-modem", },
287 	{},
288 };
289 MODULE_DEVICE_TABLE(of, nokia_modem_of_match);
290 #endif
291 
292 static 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 
302 static int __init nokia_modem_init(void)
303 {
304 	return hsi_register_client_driver(&nokia_modem_driver);
305 }
306 module_init(nokia_modem_init);
307 
308 static void __exit nokia_modem_exit(void)
309 {
310 	hsi_unregister_client_driver(&nokia_modem_driver);
311 }
312 module_exit(nokia_modem_exit);
313 
314 MODULE_ALIAS("hsi:nokia-modem");
315 MODULE_AUTHOR("Sebastian Reichel <sre@kernel.org>");
316 MODULE_DESCRIPTION("HSI driver module for Nokia N900 Modem");
317 MODULE_LICENSE("GPL");
318