xref: /linux/drivers/hsi/controllers/omap_ssi_core.c (revision 0883c2c06fb5bcf5b9e008270827e63c09a88c1e)
1 /* OMAP SSI driver.
2  *
3  * Copyright (C) 2010 Nokia Corporation. All rights reserved.
4  * Copyright (C) 2014 Sebastian Reichel <sre@kernel.org>
5  *
6  * Contact: Carlos Chinea <carlos.chinea@nokia.com>
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/compiler.h>
24 #include <linux/err.h>
25 #include <linux/ioport.h>
26 #include <linux/io.h>
27 #include <linux/clk.h>
28 #include <linux/device.h>
29 #include <linux/platform_device.h>
30 #include <linux/dma-mapping.h>
31 #include <linux/dmaengine.h>
32 #include <linux/delay.h>
33 #include <linux/seq_file.h>
34 #include <linux/scatterlist.h>
35 #include <linux/interrupt.h>
36 #include <linux/spinlock.h>
37 #include <linux/debugfs.h>
38 #include <linux/pinctrl/consumer.h>
39 #include <linux/pm_runtime.h>
40 #include <linux/of_platform.h>
41 #include <linux/hsi/hsi.h>
42 #include <linux/idr.h>
43 
44 #include "omap_ssi_regs.h"
45 #include "omap_ssi.h"
46 
47 /* For automatically allocated device IDs */
48 static DEFINE_IDA(platform_omap_ssi_ida);
49 
50 #ifdef CONFIG_DEBUG_FS
51 static int ssi_debug_show(struct seq_file *m, void *p __maybe_unused)
52 {
53 	struct hsi_controller *ssi = m->private;
54 	struct omap_ssi_controller *omap_ssi = hsi_controller_drvdata(ssi);
55 	void __iomem *sys = omap_ssi->sys;
56 
57 	pm_runtime_get_sync(ssi->device.parent);
58 	seq_printf(m, "REVISION\t: 0x%08x\n",  readl(sys + SSI_REVISION_REG));
59 	seq_printf(m, "SYSCONFIG\t: 0x%08x\n", readl(sys + SSI_SYSCONFIG_REG));
60 	seq_printf(m, "SYSSTATUS\t: 0x%08x\n", readl(sys + SSI_SYSSTATUS_REG));
61 	pm_runtime_put_sync(ssi->device.parent);
62 
63 	return 0;
64 }
65 
66 static int ssi_debug_gdd_show(struct seq_file *m, void *p __maybe_unused)
67 {
68 	struct hsi_controller *ssi = m->private;
69 	struct omap_ssi_controller *omap_ssi = hsi_controller_drvdata(ssi);
70 	void __iomem *gdd = omap_ssi->gdd;
71 	void __iomem *sys = omap_ssi->sys;
72 	int lch;
73 
74 	pm_runtime_get_sync(ssi->device.parent);
75 
76 	seq_printf(m, "GDD_MPU_STATUS\t: 0x%08x\n",
77 		readl(sys + SSI_GDD_MPU_IRQ_STATUS_REG));
78 	seq_printf(m, "GDD_MPU_ENABLE\t: 0x%08x\n\n",
79 		readl(sys + SSI_GDD_MPU_IRQ_ENABLE_REG));
80 	seq_printf(m, "HW_ID\t\t: 0x%08x\n",
81 				readl(gdd + SSI_GDD_HW_ID_REG));
82 	seq_printf(m, "PPORT_ID\t: 0x%08x\n",
83 				readl(gdd + SSI_GDD_PPORT_ID_REG));
84 	seq_printf(m, "MPORT_ID\t: 0x%08x\n",
85 				readl(gdd + SSI_GDD_MPORT_ID_REG));
86 	seq_printf(m, "TEST\t\t: 0x%08x\n",
87 				readl(gdd + SSI_GDD_TEST_REG));
88 	seq_printf(m, "GCR\t\t: 0x%08x\n",
89 				readl(gdd + SSI_GDD_GCR_REG));
90 
91 	for (lch = 0; lch < SSI_MAX_GDD_LCH; lch++) {
92 		seq_printf(m, "\nGDD LCH %d\n=========\n", lch);
93 		seq_printf(m, "CSDP\t\t: 0x%04x\n",
94 				readw(gdd + SSI_GDD_CSDP_REG(lch)));
95 		seq_printf(m, "CCR\t\t: 0x%04x\n",
96 				readw(gdd + SSI_GDD_CCR_REG(lch)));
97 		seq_printf(m, "CICR\t\t: 0x%04x\n",
98 				readw(gdd + SSI_GDD_CICR_REG(lch)));
99 		seq_printf(m, "CSR\t\t: 0x%04x\n",
100 				readw(gdd + SSI_GDD_CSR_REG(lch)));
101 		seq_printf(m, "CSSA\t\t: 0x%08x\n",
102 				readl(gdd + SSI_GDD_CSSA_REG(lch)));
103 		seq_printf(m, "CDSA\t\t: 0x%08x\n",
104 				readl(gdd + SSI_GDD_CDSA_REG(lch)));
105 		seq_printf(m, "CEN\t\t: 0x%04x\n",
106 				readw(gdd + SSI_GDD_CEN_REG(lch)));
107 		seq_printf(m, "CSAC\t\t: 0x%04x\n",
108 				readw(gdd + SSI_GDD_CSAC_REG(lch)));
109 		seq_printf(m, "CDAC\t\t: 0x%04x\n",
110 				readw(gdd + SSI_GDD_CDAC_REG(lch)));
111 		seq_printf(m, "CLNK_CTRL\t: 0x%04x\n",
112 				readw(gdd + SSI_GDD_CLNK_CTRL_REG(lch)));
113 	}
114 
115 	pm_runtime_put_sync(ssi->device.parent);
116 
117 	return 0;
118 }
119 
120 static int ssi_regs_open(struct inode *inode, struct file *file)
121 {
122 	return single_open(file, ssi_debug_show, inode->i_private);
123 }
124 
125 static int ssi_gdd_regs_open(struct inode *inode, struct file *file)
126 {
127 	return single_open(file, ssi_debug_gdd_show, inode->i_private);
128 }
129 
130 static const struct file_operations ssi_regs_fops = {
131 	.open		= ssi_regs_open,
132 	.read		= seq_read,
133 	.llseek		= seq_lseek,
134 	.release	= single_release,
135 };
136 
137 static const struct file_operations ssi_gdd_regs_fops = {
138 	.open		= ssi_gdd_regs_open,
139 	.read		= seq_read,
140 	.llseek		= seq_lseek,
141 	.release	= single_release,
142 };
143 
144 static int ssi_debug_add_ctrl(struct hsi_controller *ssi)
145 {
146 	struct omap_ssi_controller *omap_ssi = hsi_controller_drvdata(ssi);
147 	struct dentry *dir;
148 
149 	/* SSI controller */
150 	omap_ssi->dir = debugfs_create_dir(dev_name(&ssi->device), NULL);
151 	if (!omap_ssi->dir)
152 		return -ENOMEM;
153 
154 	debugfs_create_file("regs", S_IRUGO, omap_ssi->dir, ssi,
155 								&ssi_regs_fops);
156 	/* SSI GDD (DMA) */
157 	dir = debugfs_create_dir("gdd", omap_ssi->dir);
158 	if (!dir)
159 		goto rback;
160 	debugfs_create_file("regs", S_IRUGO, dir, ssi, &ssi_gdd_regs_fops);
161 
162 	return 0;
163 rback:
164 	debugfs_remove_recursive(omap_ssi->dir);
165 
166 	return -ENOMEM;
167 }
168 
169 static void ssi_debug_remove_ctrl(struct hsi_controller *ssi)
170 {
171 	struct omap_ssi_controller *omap_ssi = hsi_controller_drvdata(ssi);
172 
173 	debugfs_remove_recursive(omap_ssi->dir);
174 }
175 #endif /* CONFIG_DEBUG_FS */
176 
177 /*
178  * FIXME: Horrible HACK needed until we remove the useless wakeline test
179  * in the CMT. To be removed !!!!
180  */
181 void ssi_waketest(struct hsi_client *cl, unsigned int enable)
182 {
183 	struct hsi_port *port = hsi_get_port(cl);
184 	struct omap_ssi_port *omap_port = hsi_port_drvdata(port);
185 	struct hsi_controller *ssi = to_hsi_controller(port->device.parent);
186 	struct omap_ssi_controller *omap_ssi = hsi_controller_drvdata(ssi);
187 
188 	omap_port->wktest = !!enable;
189 	if (omap_port->wktest) {
190 		pm_runtime_get_sync(ssi->device.parent);
191 		writel_relaxed(SSI_WAKE(0),
192 				omap_ssi->sys + SSI_SET_WAKE_REG(port->num));
193 	} else {
194 		writel_relaxed(SSI_WAKE(0),
195 				omap_ssi->sys +	SSI_CLEAR_WAKE_REG(port->num));
196 		pm_runtime_put_sync(ssi->device.parent);
197 	}
198 }
199 EXPORT_SYMBOL_GPL(ssi_waketest);
200 
201 static void ssi_gdd_complete(struct hsi_controller *ssi, unsigned int lch)
202 {
203 	struct omap_ssi_controller *omap_ssi = hsi_controller_drvdata(ssi);
204 	struct hsi_msg *msg = omap_ssi->gdd_trn[lch].msg;
205 	struct hsi_port *port = to_hsi_port(msg->cl->device.parent);
206 	struct omap_ssi_port *omap_port = hsi_port_drvdata(port);
207 	unsigned int dir;
208 	u32 csr;
209 	u32 val;
210 
211 	spin_lock(&omap_ssi->lock);
212 
213 	val = readl(omap_ssi->sys + SSI_GDD_MPU_IRQ_ENABLE_REG);
214 	val &= ~SSI_GDD_LCH(lch);
215 	writel_relaxed(val, omap_ssi->sys + SSI_GDD_MPU_IRQ_ENABLE_REG);
216 
217 	if (msg->ttype == HSI_MSG_READ) {
218 		dir = DMA_FROM_DEVICE;
219 		val = SSI_DATAAVAILABLE(msg->channel);
220 		pm_runtime_put_sync(ssi->device.parent);
221 	} else {
222 		dir = DMA_TO_DEVICE;
223 		val = SSI_DATAACCEPT(msg->channel);
224 		/* Keep clocks reference for write pio event */
225 	}
226 	dma_unmap_sg(&ssi->device, msg->sgt.sgl, msg->sgt.nents, dir);
227 	csr = readw(omap_ssi->gdd + SSI_GDD_CSR_REG(lch));
228 	omap_ssi->gdd_trn[lch].msg = NULL; /* release GDD lch */
229 	dev_dbg(&port->device, "DMA completed ch %d ttype %d\n",
230 				msg->channel, msg->ttype);
231 	spin_unlock(&omap_ssi->lock);
232 	if (csr & SSI_CSR_TOUR) { /* Timeout error */
233 		msg->status = HSI_STATUS_ERROR;
234 		msg->actual_len = 0;
235 		spin_lock(&omap_port->lock);
236 		list_del(&msg->link); /* Dequeue msg */
237 		spin_unlock(&omap_port->lock);
238 		msg->complete(msg);
239 		return;
240 	}
241 	spin_lock(&omap_port->lock);
242 	val |= readl(omap_ssi->sys + SSI_MPU_ENABLE_REG(port->num, 0));
243 	writel_relaxed(val, omap_ssi->sys + SSI_MPU_ENABLE_REG(port->num, 0));
244 	spin_unlock(&omap_port->lock);
245 
246 	msg->status = HSI_STATUS_COMPLETED;
247 	msg->actual_len = sg_dma_len(msg->sgt.sgl);
248 }
249 
250 static void ssi_gdd_tasklet(unsigned long dev)
251 {
252 	struct hsi_controller *ssi = (struct hsi_controller *)dev;
253 	struct omap_ssi_controller *omap_ssi = hsi_controller_drvdata(ssi);
254 	void __iomem *sys = omap_ssi->sys;
255 	unsigned int lch;
256 	u32 status_reg;
257 
258 	pm_runtime_get_sync(ssi->device.parent);
259 
260 	status_reg = readl(sys + SSI_GDD_MPU_IRQ_STATUS_REG);
261 	for (lch = 0; lch < SSI_MAX_GDD_LCH; lch++) {
262 		if (status_reg & SSI_GDD_LCH(lch))
263 			ssi_gdd_complete(ssi, lch);
264 	}
265 	writel_relaxed(status_reg, sys + SSI_GDD_MPU_IRQ_STATUS_REG);
266 	status_reg = readl(sys + SSI_GDD_MPU_IRQ_STATUS_REG);
267 
268 	pm_runtime_put_sync(ssi->device.parent);
269 
270 	if (status_reg)
271 		tasklet_hi_schedule(&omap_ssi->gdd_tasklet);
272 	else
273 		enable_irq(omap_ssi->gdd_irq);
274 
275 }
276 
277 static irqreturn_t ssi_gdd_isr(int irq, void *ssi)
278 {
279 	struct omap_ssi_controller *omap_ssi = hsi_controller_drvdata(ssi);
280 
281 	tasklet_hi_schedule(&omap_ssi->gdd_tasklet);
282 	disable_irq_nosync(irq);
283 
284 	return IRQ_HANDLED;
285 }
286 
287 static unsigned long ssi_get_clk_rate(struct hsi_controller *ssi)
288 {
289 	struct omap_ssi_controller *omap_ssi = hsi_controller_drvdata(ssi);
290 	unsigned long rate = clk_get_rate(omap_ssi->fck);
291 	return rate;
292 }
293 
294 static int ssi_clk_event(struct notifier_block *nb, unsigned long event,
295 								void *data)
296 {
297 	struct omap_ssi_controller *omap_ssi = container_of(nb,
298 					struct omap_ssi_controller, fck_nb);
299 	struct hsi_controller *ssi = to_hsi_controller(omap_ssi->dev);
300 	struct clk_notifier_data *clk_data = data;
301 	struct omap_ssi_port *omap_port;
302 	int i;
303 
304 	switch (event) {
305 	case PRE_RATE_CHANGE:
306 		dev_dbg(&ssi->device, "pre rate change\n");
307 
308 		for (i = 0; i < ssi->num_ports; i++) {
309 			omap_port = omap_ssi->port[i];
310 
311 			if (!omap_port)
312 				continue;
313 
314 			/* Workaround for SWBREAK + CAwake down race in CMT */
315 			tasklet_disable(&omap_port->wake_tasklet);
316 
317 			/* stop all ssi communication */
318 			pinctrl_pm_select_idle_state(omap_port->pdev);
319 			udelay(1); /* wait for racing frames */
320 		}
321 
322 		break;
323 	case ABORT_RATE_CHANGE:
324 		dev_dbg(&ssi->device, "abort rate change\n");
325 		/* Fall through */
326 	case POST_RATE_CHANGE:
327 		dev_dbg(&ssi->device, "post rate change (%lu -> %lu)\n",
328 			clk_data->old_rate, clk_data->new_rate);
329 		omap_ssi->fck_rate = DIV_ROUND_CLOSEST(clk_data->new_rate, 1000); /* KHz */
330 
331 		for (i = 0; i < ssi->num_ports; i++) {
332 			omap_port = omap_ssi->port[i];
333 
334 			if (!omap_port)
335 				continue;
336 
337 			omap_ssi_port_update_fclk(ssi, omap_port);
338 
339 			/* resume ssi communication */
340 			pinctrl_pm_select_default_state(omap_port->pdev);
341 			tasklet_enable(&omap_port->wake_tasklet);
342 		}
343 
344 		break;
345 	default:
346 		break;
347 	}
348 
349 	return NOTIFY_DONE;
350 }
351 
352 static int ssi_get_iomem(struct platform_device *pd,
353 		const char *name, void __iomem **pbase, dma_addr_t *phy)
354 {
355 	struct resource *mem;
356 	void __iomem *base;
357 	struct hsi_controller *ssi = platform_get_drvdata(pd);
358 
359 	mem = platform_get_resource_byname(pd, IORESOURCE_MEM, name);
360 	base = devm_ioremap_resource(&ssi->device, mem);
361 	if (IS_ERR(base))
362 		return PTR_ERR(base);
363 
364 	*pbase = base;
365 
366 	if (phy)
367 		*phy = mem->start;
368 
369 	return 0;
370 }
371 
372 static int ssi_add_controller(struct hsi_controller *ssi,
373 						struct platform_device *pd)
374 {
375 	struct omap_ssi_controller *omap_ssi;
376 	int err;
377 
378 	omap_ssi = devm_kzalloc(&ssi->device, sizeof(*omap_ssi), GFP_KERNEL);
379 	if (!omap_ssi) {
380 		dev_err(&pd->dev, "not enough memory for omap ssi\n");
381 		return -ENOMEM;
382 	}
383 
384 	err = ida_simple_get(&platform_omap_ssi_ida, 0, 0, GFP_KERNEL);
385 	if (err < 0)
386 		goto out_err;
387 	ssi->id = err;
388 
389 	ssi->owner = THIS_MODULE;
390 	ssi->device.parent = &pd->dev;
391 	dev_set_name(&ssi->device, "ssi%d", ssi->id);
392 	hsi_controller_set_drvdata(ssi, omap_ssi);
393 	omap_ssi->dev = &ssi->device;
394 	err = ssi_get_iomem(pd, "sys", &omap_ssi->sys, NULL);
395 	if (err < 0)
396 		goto out_err;
397 	err = ssi_get_iomem(pd, "gdd", &omap_ssi->gdd, NULL);
398 	if (err < 0)
399 		goto out_err;
400 	err = platform_get_irq_byname(pd, "gdd_mpu");
401 	if (err < 0) {
402 		dev_err(&pd->dev, "GDD IRQ resource missing\n");
403 		goto out_err;
404 	}
405 	omap_ssi->gdd_irq = err;
406 	tasklet_init(&omap_ssi->gdd_tasklet, ssi_gdd_tasklet,
407 							(unsigned long)ssi);
408 	err = devm_request_irq(&ssi->device, omap_ssi->gdd_irq, ssi_gdd_isr,
409 						0, "gdd_mpu", ssi);
410 	if (err < 0) {
411 		dev_err(&ssi->device, "Request GDD IRQ %d failed (%d)",
412 							omap_ssi->gdd_irq, err);
413 		goto out_err;
414 	}
415 
416 	omap_ssi->port = devm_kzalloc(&ssi->device,
417 		sizeof(struct omap_ssi_port *) * ssi->num_ports, GFP_KERNEL);
418 	if (!omap_ssi->port) {
419 		err = -ENOMEM;
420 		goto out_err;
421 	}
422 
423 	omap_ssi->fck = devm_clk_get(&ssi->device, "ssi_ssr_fck");
424 	if (IS_ERR(omap_ssi->fck)) {
425 		dev_err(&pd->dev, "Could not acquire clock \"ssi_ssr_fck\": %li\n",
426 			PTR_ERR(omap_ssi->fck));
427 		err = -ENODEV;
428 		goto out_err;
429 	}
430 
431 	omap_ssi->fck_nb.notifier_call = ssi_clk_event;
432 	omap_ssi->fck_nb.priority = INT_MAX;
433 	clk_notifier_register(omap_ssi->fck, &omap_ssi->fck_nb);
434 
435 	/* TODO: find register, which can be used to detect context loss */
436 	omap_ssi->get_loss = NULL;
437 
438 	omap_ssi->max_speed = UINT_MAX;
439 	spin_lock_init(&omap_ssi->lock);
440 	err = hsi_register_controller(ssi);
441 
442 	if (err < 0)
443 		goto out_err;
444 
445 	return 0;
446 
447 out_err:
448 	ida_simple_remove(&platform_omap_ssi_ida, ssi->id);
449 	return err;
450 }
451 
452 static int ssi_hw_init(struct hsi_controller *ssi)
453 {
454 	struct omap_ssi_controller *omap_ssi = hsi_controller_drvdata(ssi);
455 	unsigned int i;
456 	u32 val;
457 	int err;
458 
459 	err = pm_runtime_get_sync(ssi->device.parent);
460 	if (err < 0) {
461 		dev_err(&ssi->device, "runtime PM failed %d\n", err);
462 		return err;
463 	}
464 	/* Reseting SSI controller */
465 	writel_relaxed(SSI_SOFTRESET, omap_ssi->sys + SSI_SYSCONFIG_REG);
466 	val = readl(omap_ssi->sys + SSI_SYSSTATUS_REG);
467 	for (i = 0; ((i < 20) && !(val & SSI_RESETDONE)); i++) {
468 		msleep(20);
469 		val = readl(omap_ssi->sys + SSI_SYSSTATUS_REG);
470 	}
471 	if (!(val & SSI_RESETDONE)) {
472 		dev_err(&ssi->device, "SSI HW reset failed\n");
473 		pm_runtime_put_sync(ssi->device.parent);
474 		return -EIO;
475 	}
476 	/* Reseting GDD */
477 	writel_relaxed(SSI_SWRESET, omap_ssi->gdd + SSI_GDD_GRST_REG);
478 	/* Get FCK rate in KHz */
479 	omap_ssi->fck_rate = DIV_ROUND_CLOSEST(ssi_get_clk_rate(ssi), 1000);
480 	dev_dbg(&ssi->device, "SSI fck rate %lu KHz\n", omap_ssi->fck_rate);
481 	/* Set default PM settings */
482 	val = SSI_AUTOIDLE | SSI_SIDLEMODE_SMART | SSI_MIDLEMODE_SMART;
483 	writel_relaxed(val, omap_ssi->sys + SSI_SYSCONFIG_REG);
484 	omap_ssi->sysconfig = val;
485 	writel_relaxed(SSI_CLK_AUTOGATING_ON, omap_ssi->sys + SSI_GDD_GCR_REG);
486 	omap_ssi->gdd_gcr = SSI_CLK_AUTOGATING_ON;
487 	pm_runtime_put_sync(ssi->device.parent);
488 
489 	return 0;
490 }
491 
492 static void ssi_remove_controller(struct hsi_controller *ssi)
493 {
494 	struct omap_ssi_controller *omap_ssi = hsi_controller_drvdata(ssi);
495 	int id = ssi->id;
496 	tasklet_kill(&omap_ssi->gdd_tasklet);
497 	hsi_unregister_controller(ssi);
498 	clk_notifier_unregister(omap_ssi->fck, &omap_ssi->fck_nb);
499 	ida_simple_remove(&platform_omap_ssi_ida, id);
500 }
501 
502 static inline int ssi_of_get_available_ports_count(const struct device_node *np)
503 {
504 	struct device_node *child;
505 	int num = 0;
506 
507 	for_each_available_child_of_node(np, child)
508 		if (of_device_is_compatible(child, "ti,omap3-ssi-port"))
509 			num++;
510 
511 	return num;
512 }
513 
514 static int ssi_remove_ports(struct device *dev, void *c)
515 {
516 	struct platform_device *pdev = to_platform_device(dev);
517 
518 	if (!dev->of_node)
519 		return 0;
520 
521 	of_node_clear_flag(dev->of_node, OF_POPULATED);
522 	of_device_unregister(pdev);
523 
524 	return 0;
525 }
526 
527 static int ssi_probe(struct platform_device *pd)
528 {
529 	struct platform_device *childpdev;
530 	struct device_node *np = pd->dev.of_node;
531 	struct device_node *child;
532 	struct hsi_controller *ssi;
533 	int err;
534 	int num_ports;
535 
536 	if (!np) {
537 		dev_err(&pd->dev, "missing device tree data\n");
538 		return -EINVAL;
539 	}
540 
541 	num_ports = ssi_of_get_available_ports_count(np);
542 
543 	ssi = hsi_alloc_controller(num_ports, GFP_KERNEL);
544 	if (!ssi) {
545 		dev_err(&pd->dev, "No memory for controller\n");
546 		return -ENOMEM;
547 	}
548 
549 	platform_set_drvdata(pd, ssi);
550 
551 	err = ssi_add_controller(ssi, pd);
552 	if (err < 0)
553 		goto out1;
554 
555 	pm_runtime_irq_safe(&pd->dev);
556 	pm_runtime_enable(&pd->dev);
557 
558 	err = ssi_hw_init(ssi);
559 	if (err < 0)
560 		goto out2;
561 #ifdef CONFIG_DEBUG_FS
562 	err = ssi_debug_add_ctrl(ssi);
563 	if (err < 0)
564 		goto out2;
565 #endif
566 
567 	for_each_available_child_of_node(np, child) {
568 		if (!of_device_is_compatible(child, "ti,omap3-ssi-port"))
569 			continue;
570 
571 		childpdev = of_platform_device_create(child, NULL, &pd->dev);
572 		if (!childpdev) {
573 			err = -ENODEV;
574 			dev_err(&pd->dev, "failed to create ssi controller port\n");
575 			goto out3;
576 		}
577 	}
578 
579 	dev_info(&pd->dev, "ssi controller %d initialized (%d ports)!\n",
580 		ssi->id, num_ports);
581 	return err;
582 out3:
583 	device_for_each_child(&pd->dev, NULL, ssi_remove_ports);
584 out2:
585 	ssi_remove_controller(ssi);
586 out1:
587 	platform_set_drvdata(pd, NULL);
588 	pm_runtime_disable(&pd->dev);
589 
590 	return err;
591 }
592 
593 static int ssi_remove(struct platform_device *pd)
594 {
595 	struct hsi_controller *ssi = platform_get_drvdata(pd);
596 
597 	/* cleanup of of_platform_populate() call */
598 	device_for_each_child(&pd->dev, NULL, ssi_remove_ports);
599 
600 #ifdef CONFIG_DEBUG_FS
601 	ssi_debug_remove_ctrl(ssi);
602 #endif
603 	ssi_remove_controller(ssi);
604 	platform_set_drvdata(pd, NULL);
605 
606 	pm_runtime_disable(&pd->dev);
607 
608 	return 0;
609 }
610 
611 #ifdef CONFIG_PM
612 static int omap_ssi_runtime_suspend(struct device *dev)
613 {
614 	struct hsi_controller *ssi = dev_get_drvdata(dev);
615 	struct omap_ssi_controller *omap_ssi = hsi_controller_drvdata(ssi);
616 
617 	dev_dbg(dev, "runtime suspend!\n");
618 
619 	if (omap_ssi->get_loss)
620 		omap_ssi->loss_count =
621 				omap_ssi->get_loss(ssi->device.parent);
622 
623 	return 0;
624 }
625 
626 static int omap_ssi_runtime_resume(struct device *dev)
627 {
628 	struct hsi_controller *ssi = dev_get_drvdata(dev);
629 	struct omap_ssi_controller *omap_ssi = hsi_controller_drvdata(ssi);
630 
631 	dev_dbg(dev, "runtime resume!\n");
632 
633 	if ((omap_ssi->get_loss) && (omap_ssi->loss_count ==
634 				omap_ssi->get_loss(ssi->device.parent)))
635 		return 0;
636 
637 	writel_relaxed(omap_ssi->gdd_gcr, omap_ssi->gdd + SSI_GDD_GCR_REG);
638 
639 	return 0;
640 }
641 
642 static const struct dev_pm_ops omap_ssi_pm_ops = {
643 	SET_RUNTIME_PM_OPS(omap_ssi_runtime_suspend, omap_ssi_runtime_resume,
644 		NULL)
645 };
646 
647 #define DEV_PM_OPS     (&omap_ssi_pm_ops)
648 #else
649 #define DEV_PM_OPS     NULL
650 #endif
651 
652 #ifdef CONFIG_OF
653 static const struct of_device_id omap_ssi_of_match[] = {
654 	{ .compatible = "ti,omap3-ssi", },
655 	{},
656 };
657 MODULE_DEVICE_TABLE(of, omap_ssi_of_match);
658 #else
659 #define omap_ssi_of_match NULL
660 #endif
661 
662 static struct platform_driver ssi_pdriver = {
663 	.probe = ssi_probe,
664 	.remove	= ssi_remove,
665 	.driver	= {
666 		.name	= "omap_ssi",
667 		.pm     = DEV_PM_OPS,
668 		.of_match_table = omap_ssi_of_match,
669 	},
670 };
671 
672 static int __init ssi_init(void) {
673 	int ret;
674 
675 	ret = platform_driver_register(&ssi_pdriver);
676 	if (ret)
677 		return ret;
678 
679 	return platform_driver_register(&ssi_port_pdriver);
680 }
681 module_init(ssi_init);
682 
683 static void __exit ssi_exit(void) {
684 	platform_driver_unregister(&ssi_port_pdriver);
685 	platform_driver_unregister(&ssi_pdriver);
686 }
687 module_exit(ssi_exit);
688 
689 MODULE_ALIAS("platform:omap_ssi");
690 MODULE_AUTHOR("Carlos Chinea <carlos.chinea@nokia.com>");
691 MODULE_AUTHOR("Sebastian Reichel <sre@kernel.org>");
692 MODULE_DESCRIPTION("Synchronous Serial Interface Driver");
693 MODULE_LICENSE("GPL v2");
694