1
2
3
4
5
6
7
8
9
10#include <linux/module.h>
11#include <linux/init.h>
12#include <linux/device.h>
13#include <linux/string.h>
14#include <linux/slab.h>
15#include <linux/io.h>
16#include <linux/pm.h>
17#include <linux/pm_runtime.h>
18#include <linux/amba/bus.h>
19#include <linux/sizes.h>
20
21#include <asm/irq.h>
22
23#define to_amba_driver(d) container_of(d, struct amba_driver, drv)
24
25static const struct amba_id *
26amba_lookup(const struct amba_id *table, struct amba_device *dev)
27{
28 int ret = 0;
29
30 while (table->mask) {
31 ret = (dev->periphid & table->mask) == table->id;
32 if (ret)
33 break;
34 table++;
35 }
36
37 return ret ? table : NULL;
38}
39
40static int amba_match(struct device *dev, struct device_driver *drv)
41{
42 struct amba_device *pcdev = to_amba_device(dev);
43 struct amba_driver *pcdrv = to_amba_driver(drv);
44
45 return amba_lookup(pcdrv->id_table, pcdev) != NULL;
46}
47
48static int amba_uevent(struct device *dev, struct kobj_uevent_env *env)
49{
50 struct amba_device *pcdev = to_amba_device(dev);
51 int retval = 0;
52
53 retval = add_uevent_var(env, "AMBA_ID=%08x", pcdev->periphid);
54 if (retval)
55 return retval;
56
57 retval = add_uevent_var(env, "MODALIAS=amba:d%08X", pcdev->periphid);
58 return retval;
59}
60
61#define amba_attr_func(name,fmt,arg...) \
62static ssize_t name##_show(struct device *_dev, \
63 struct device_attribute *attr, char *buf) \
64{ \
65 struct amba_device *dev = to_amba_device(_dev); \
66 return sprintf(buf, fmt, arg); \
67}
68
69#define amba_attr(name,fmt,arg...) \
70amba_attr_func(name,fmt,arg) \
71static DEVICE_ATTR(name, S_IRUGO, name##_show, NULL)
72
73amba_attr_func(id, "%08x\n", dev->periphid);
74amba_attr(irq0, "%u\n", dev->irq[0]);
75amba_attr(irq1, "%u\n", dev->irq[1]);
76amba_attr_func(resource, "\t%016llx\t%016llx\t%016lx\n",
77 (unsigned long long)dev->res.start, (unsigned long long)dev->res.end,
78 dev->res.flags);
79
80static struct device_attribute amba_dev_attrs[] = {
81 __ATTR_RO(id),
82 __ATTR_RO(resource),
83 __ATTR_NULL,
84};
85
86#ifdef CONFIG_PM
87
88
89
90
91
92static int amba_pm_runtime_suspend(struct device *dev)
93{
94 struct amba_device *pcdev = to_amba_device(dev);
95 int ret = pm_generic_runtime_suspend(dev);
96
97 if (ret == 0 && dev->driver)
98 clk_disable_unprepare(pcdev->pclk);
99
100 return ret;
101}
102
103static int amba_pm_runtime_resume(struct device *dev)
104{
105 struct amba_device *pcdev = to_amba_device(dev);
106 int ret;
107
108 if (dev->driver) {
109 ret = clk_prepare_enable(pcdev->pclk);
110
111 if (ret)
112 return ret;
113 }
114
115 return pm_generic_runtime_resume(dev);
116}
117#endif
118
119static const struct dev_pm_ops amba_pm = {
120 .suspend = pm_generic_suspend,
121 .resume = pm_generic_resume,
122 .freeze = pm_generic_freeze,
123 .thaw = pm_generic_thaw,
124 .poweroff = pm_generic_poweroff,
125 .restore = pm_generic_restore,
126 SET_PM_RUNTIME_PM_OPS(
127 amba_pm_runtime_suspend,
128 amba_pm_runtime_resume,
129 NULL
130 )
131};
132
133
134
135
136
137struct bus_type amba_bustype = {
138 .name = "amba",
139 .dev_attrs = amba_dev_attrs,
140 .match = amba_match,
141 .uevent = amba_uevent,
142 .pm = &amba_pm,
143};
144
145static int __init amba_init(void)
146{
147 return bus_register(&amba_bustype);
148}
149
150postcore_initcall(amba_init);
151
152static int amba_get_enable_pclk(struct amba_device *pcdev)
153{
154 int ret;
155
156 pcdev->pclk = clk_get(&pcdev->dev, "apb_pclk");
157 if (IS_ERR(pcdev->pclk))
158 return PTR_ERR(pcdev->pclk);
159
160 ret = clk_prepare_enable(pcdev->pclk);
161 if (ret)
162 clk_put(pcdev->pclk);
163
164 return ret;
165}
166
167static void amba_put_disable_pclk(struct amba_device *pcdev)
168{
169 clk_disable_unprepare(pcdev->pclk);
170 clk_put(pcdev->pclk);
171}
172
173
174
175
176
177static int amba_probe(struct device *dev)
178{
179 struct amba_device *pcdev = to_amba_device(dev);
180 struct amba_driver *pcdrv = to_amba_driver(dev->driver);
181 const struct amba_id *id = amba_lookup(pcdrv->id_table, pcdev);
182 int ret;
183
184 do {
185 ret = amba_get_enable_pclk(pcdev);
186 if (ret)
187 break;
188
189 pm_runtime_get_noresume(dev);
190 pm_runtime_set_active(dev);
191 pm_runtime_enable(dev);
192
193 ret = pcdrv->probe(pcdev, id);
194 if (ret == 0)
195 break;
196
197 pm_runtime_disable(dev);
198 pm_runtime_set_suspended(dev);
199 pm_runtime_put_noidle(dev);
200
201 amba_put_disable_pclk(pcdev);
202 } while (0);
203
204 return ret;
205}
206
207static int amba_remove(struct device *dev)
208{
209 struct amba_device *pcdev = to_amba_device(dev);
210 struct amba_driver *drv = to_amba_driver(dev->driver);
211 int ret;
212
213 pm_runtime_get_sync(dev);
214 ret = drv->remove(pcdev);
215 pm_runtime_put_noidle(dev);
216
217
218 pm_runtime_disable(dev);
219 pm_runtime_set_suspended(dev);
220 pm_runtime_put_noidle(dev);
221
222 amba_put_disable_pclk(pcdev);
223
224 return ret;
225}
226
227static void amba_shutdown(struct device *dev)
228{
229 struct amba_driver *drv = to_amba_driver(dev->driver);
230 drv->shutdown(to_amba_device(dev));
231}
232
233
234
235
236
237
238
239
240
241int amba_driver_register(struct amba_driver *drv)
242{
243 drv->drv.bus = &amba_bustype;
244
245#define SETFN(fn) if (drv->fn) drv->drv.fn = amba_##fn
246 SETFN(probe);
247 SETFN(remove);
248 SETFN(shutdown);
249
250 return driver_register(&drv->drv);
251}
252
253
254
255
256
257
258
259
260
261void amba_driver_unregister(struct amba_driver *drv)
262{
263 driver_unregister(&drv->drv);
264}
265
266
267static void amba_device_release(struct device *dev)
268{
269 struct amba_device *d = to_amba_device(dev);
270
271 if (d->res.parent)
272 release_resource(&d->res);
273 kfree(d);
274}
275
276
277
278
279
280
281
282
283
284
285int amba_device_add(struct amba_device *dev, struct resource *parent)
286{
287 u32 size;
288 void __iomem *tmp;
289 int i, ret;
290
291 WARN_ON(dev->irq[0] == (unsigned int)-1);
292 WARN_ON(dev->irq[1] == (unsigned int)-1);
293
294 ret = request_resource(parent, &dev->res);
295 if (ret)
296 goto err_out;
297
298
299 if (dev->periphid != 0)
300 goto skip_probe;
301
302
303
304
305
306 size = resource_size(&dev->res);
307 tmp = ioremap(dev->res.start, size);
308 if (!tmp) {
309 ret = -ENOMEM;
310 goto err_release;
311 }
312
313 ret = amba_get_enable_pclk(dev);
314 if (ret == 0) {
315 u32 pid, cid;
316
317
318
319
320
321 for (pid = 0, i = 0; i < 4; i++)
322 pid |= (readl(tmp + size - 0x20 + 4 * i) & 255) <<
323 (i * 8);
324 for (cid = 0, i = 0; i < 4; i++)
325 cid |= (readl(tmp + size - 0x10 + 4 * i) & 255) <<
326 (i * 8);
327
328 amba_put_disable_pclk(dev);
329
330 if (cid == AMBA_CID)
331 dev->periphid = pid;
332
333 if (!dev->periphid)
334 ret = -ENODEV;
335 }
336
337 iounmap(tmp);
338
339 if (ret)
340 goto err_release;
341
342 skip_probe:
343 ret = device_add(&dev->dev);
344 if (ret)
345 goto err_release;
346
347 if (dev->irq[0])
348 ret = device_create_file(&dev->dev, &dev_attr_irq0);
349 if (ret == 0 && dev->irq[1])
350 ret = device_create_file(&dev->dev, &dev_attr_irq1);
351 if (ret == 0)
352 return ret;
353
354 device_unregister(&dev->dev);
355
356 err_release:
357 release_resource(&dev->res);
358 err_out:
359 return ret;
360}
361EXPORT_SYMBOL_GPL(amba_device_add);
362
363static struct amba_device *
364amba_aphb_device_add(struct device *parent, const char *name,
365 resource_size_t base, size_t size, int irq1, int irq2,
366 void *pdata, unsigned int periphid, u64 dma_mask,
367 struct resource *resbase)
368{
369 struct amba_device *dev;
370 int ret;
371
372 dev = amba_device_alloc(name, base, size);
373 if (!dev)
374 return ERR_PTR(-ENOMEM);
375
376 dev->dev.coherent_dma_mask = dma_mask;
377 dev->irq[0] = irq1;
378 dev->irq[1] = irq2;
379 dev->periphid = periphid;
380 dev->dev.platform_data = pdata;
381 dev->dev.parent = parent;
382
383 ret = amba_device_add(dev, resbase);
384 if (ret) {
385 amba_device_put(dev);
386 return ERR_PTR(ret);
387 }
388
389 return dev;
390}
391
392struct amba_device *
393amba_apb_device_add(struct device *parent, const char *name,
394 resource_size_t base, size_t size, int irq1, int irq2,
395 void *pdata, unsigned int periphid)
396{
397 return amba_aphb_device_add(parent, name, base, size, irq1, irq2, pdata,
398 periphid, 0, &iomem_resource);
399}
400EXPORT_SYMBOL_GPL(amba_apb_device_add);
401
402struct amba_device *
403amba_ahb_device_add(struct device *parent, const char *name,
404 resource_size_t base, size_t size, int irq1, int irq2,
405 void *pdata, unsigned int periphid)
406{
407 return amba_aphb_device_add(parent, name, base, size, irq1, irq2, pdata,
408 periphid, ~0ULL, &iomem_resource);
409}
410EXPORT_SYMBOL_GPL(amba_ahb_device_add);
411
412struct amba_device *
413amba_apb_device_add_res(struct device *parent, const char *name,
414 resource_size_t base, size_t size, int irq1,
415 int irq2, void *pdata, unsigned int periphid,
416 struct resource *resbase)
417{
418 return amba_aphb_device_add(parent, name, base, size, irq1, irq2, pdata,
419 periphid, 0, resbase);
420}
421EXPORT_SYMBOL_GPL(amba_apb_device_add_res);
422
423struct amba_device *
424amba_ahb_device_add_res(struct device *parent, const char *name,
425 resource_size_t base, size_t size, int irq1,
426 int irq2, void *pdata, unsigned int periphid,
427 struct resource *resbase)
428{
429 return amba_aphb_device_add(parent, name, base, size, irq1, irq2, pdata,
430 periphid, ~0ULL, resbase);
431}
432EXPORT_SYMBOL_GPL(amba_ahb_device_add_res);
433
434
435static void amba_device_initialize(struct amba_device *dev, const char *name)
436{
437 device_initialize(&dev->dev);
438 if (name)
439 dev_set_name(&dev->dev, "%s", name);
440 dev->dev.release = amba_device_release;
441 dev->dev.bus = &amba_bustype;
442 dev->dev.dma_mask = &dev->dev.coherent_dma_mask;
443 dev->res.name = dev_name(&dev->dev);
444}
445
446
447
448
449
450
451
452
453
454
455struct amba_device *amba_device_alloc(const char *name, resource_size_t base,
456 size_t size)
457{
458 struct amba_device *dev;
459
460 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
461 if (dev) {
462 amba_device_initialize(dev, name);
463 dev->res.start = base;
464 dev->res.end = base + size - 1;
465 dev->res.flags = IORESOURCE_MEM;
466 }
467
468 return dev;
469}
470EXPORT_SYMBOL_GPL(amba_device_alloc);
471
472
473
474
475
476
477
478
479
480
481int amba_device_register(struct amba_device *dev, struct resource *parent)
482{
483 amba_device_initialize(dev, dev->dev.init_name);
484 dev->dev.init_name = NULL;
485
486 return amba_device_add(dev, parent);
487}
488
489
490
491
492
493void amba_device_put(struct amba_device *dev)
494{
495 put_device(&dev->dev);
496}
497EXPORT_SYMBOL_GPL(amba_device_put);
498
499
500
501
502
503
504
505
506
507
508
509
510void amba_device_unregister(struct amba_device *dev)
511{
512 device_unregister(&dev->dev);
513}
514
515
516struct find_data {
517 struct amba_device *dev;
518 struct device *parent;
519 const char *busid;
520 unsigned int id;
521 unsigned int mask;
522};
523
524static int amba_find_match(struct device *dev, void *data)
525{
526 struct find_data *d = data;
527 struct amba_device *pcdev = to_amba_device(dev);
528 int r;
529
530 r = (pcdev->periphid & d->mask) == d->id;
531 if (d->parent)
532 r &= d->parent == dev->parent;
533 if (d->busid)
534 r &= strcmp(dev_name(dev), d->busid) == 0;
535
536 if (r) {
537 get_device(dev);
538 d->dev = pcdev;
539 }
540
541 return r;
542}
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558struct amba_device *
559amba_find_device(const char *busid, struct device *parent, unsigned int id,
560 unsigned int mask)
561{
562 struct find_data data;
563
564 data.dev = NULL;
565 data.parent = parent;
566 data.busid = busid;
567 data.id = id;
568 data.mask = mask;
569
570 bus_for_each_dev(&amba_bustype, NULL, &data, amba_find_match);
571
572 return data.dev;
573}
574
575
576
577
578
579
580int amba_request_regions(struct amba_device *dev, const char *name)
581{
582 int ret = 0;
583 u32 size;
584
585 if (!name)
586 name = dev->dev.driver->name;
587
588 size = resource_size(&dev->res);
589
590 if (!request_mem_region(dev->res.start, size, name))
591 ret = -EBUSY;
592
593 return ret;
594}
595
596
597
598
599
600
601
602void amba_release_regions(struct amba_device *dev)
603{
604 u32 size;
605
606 size = resource_size(&dev->res);
607 release_mem_region(dev->res.start, size);
608}
609
610EXPORT_SYMBOL(amba_driver_register);
611EXPORT_SYMBOL(amba_driver_unregister);
612EXPORT_SYMBOL(amba_device_register);
613EXPORT_SYMBOL(amba_device_unregister);
614EXPORT_SYMBOL(amba_find_device);
615EXPORT_SYMBOL(amba_request_regions);
616EXPORT_SYMBOL(amba_release_regions);
617