bcma: connect the bcma bus suspend/resume to the bcma driver suspend/resume
[linux-3.10.git] / drivers / bcma / main.c
1 /*
2  * Broadcom specific AMBA
3  * Bus subsystem
4  *
5  * Licensed under the GNU/GPL. See COPYING for details.
6  */
7
8 #include "bcma_private.h"
9 #include <linux/module.h>
10 #include <linux/bcma/bcma.h>
11 #include <linux/slab.h>
12
13 MODULE_DESCRIPTION("Broadcom's specific AMBA driver");
14 MODULE_LICENSE("GPL");
15
16 static int bcma_bus_match(struct device *dev, struct device_driver *drv);
17 static int bcma_device_probe(struct device *dev);
18 static int bcma_device_remove(struct device *dev);
19 static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env);
20
21 static ssize_t manuf_show(struct device *dev, struct device_attribute *attr, char *buf)
22 {
23         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
24         return sprintf(buf, "0x%03X\n", core->id.manuf);
25 }
26 static ssize_t id_show(struct device *dev, struct device_attribute *attr, char *buf)
27 {
28         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
29         return sprintf(buf, "0x%03X\n", core->id.id);
30 }
31 static ssize_t rev_show(struct device *dev, struct device_attribute *attr, char *buf)
32 {
33         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
34         return sprintf(buf, "0x%02X\n", core->id.rev);
35 }
36 static ssize_t class_show(struct device *dev, struct device_attribute *attr, char *buf)
37 {
38         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
39         return sprintf(buf, "0x%X\n", core->id.class);
40 }
41 static struct device_attribute bcma_device_attrs[] = {
42         __ATTR_RO(manuf),
43         __ATTR_RO(id),
44         __ATTR_RO(rev),
45         __ATTR_RO(class),
46         __ATTR_NULL,
47 };
48
49 static struct bus_type bcma_bus_type = {
50         .name           = "bcma",
51         .match          = bcma_bus_match,
52         .probe          = bcma_device_probe,
53         .remove         = bcma_device_remove,
54         .uevent         = bcma_device_uevent,
55         .dev_attrs      = bcma_device_attrs,
56 };
57
58 static struct bcma_device *bcma_find_core(struct bcma_bus *bus, u16 coreid)
59 {
60         struct bcma_device *core;
61
62         list_for_each_entry(core, &bus->cores, list) {
63                 if (core->id.id == coreid)
64                         return core;
65         }
66         return NULL;
67 }
68
69 static void bcma_release_core_dev(struct device *dev)
70 {
71         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
72         if (core->io_addr)
73                 iounmap(core->io_addr);
74         if (core->io_wrap)
75                 iounmap(core->io_wrap);
76         kfree(core);
77 }
78
79 static int bcma_register_cores(struct bcma_bus *bus)
80 {
81         struct bcma_device *core;
82         int err, dev_id = 0;
83
84         list_for_each_entry(core, &bus->cores, list) {
85                 /* We support that cores ourself */
86                 switch (core->id.id) {
87                 case BCMA_CORE_CHIPCOMMON:
88                 case BCMA_CORE_PCI:
89                 case BCMA_CORE_PCIE:
90                 case BCMA_CORE_MIPS_74K:
91                         continue;
92                 }
93
94                 core->dev.release = bcma_release_core_dev;
95                 core->dev.bus = &bcma_bus_type;
96                 dev_set_name(&core->dev, "bcma%d:%d", 0/*bus->num*/, dev_id);
97
98                 switch (bus->hosttype) {
99                 case BCMA_HOSTTYPE_PCI:
100                         core->dev.parent = &bus->host_pci->dev;
101                         core->dma_dev = &bus->host_pci->dev;
102                         core->irq = bus->host_pci->irq;
103                         break;
104                 case BCMA_HOSTTYPE_SOC:
105                         core->dev.dma_mask = &core->dev.coherent_dma_mask;
106                         core->dma_dev = &core->dev;
107                         break;
108                 case BCMA_HOSTTYPE_SDIO:
109                         break;
110                 }
111
112                 err = device_register(&core->dev);
113                 if (err) {
114                         pr_err("Could not register dev for core 0x%03X\n",
115                                core->id.id);
116                         continue;
117                 }
118                 core->dev_registered = true;
119                 dev_id++;
120         }
121
122         return 0;
123 }
124
125 static void bcma_unregister_cores(struct bcma_bus *bus)
126 {
127         struct bcma_device *core;
128
129         list_for_each_entry(core, &bus->cores, list) {
130                 if (core->dev_registered)
131                         device_unregister(&core->dev);
132         }
133 }
134
135 int bcma_bus_register(struct bcma_bus *bus)
136 {
137         int err;
138         struct bcma_device *core;
139
140         /* Scan for devices (cores) */
141         err = bcma_bus_scan(bus);
142         if (err) {
143                 pr_err("Failed to scan: %d\n", err);
144                 return -1;
145         }
146
147         /* Init CC core */
148         core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
149         if (core) {
150                 bus->drv_cc.core = core;
151                 bcma_core_chipcommon_init(&bus->drv_cc);
152         }
153
154         /* Init MIPS core */
155         core = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
156         if (core) {
157                 bus->drv_mips.core = core;
158                 bcma_core_mips_init(&bus->drv_mips);
159         }
160
161         /* Init PCIE core */
162         core = bcma_find_core(bus, BCMA_CORE_PCIE);
163         if (core) {
164                 bus->drv_pci.core = core;
165                 bcma_core_pci_init(&bus->drv_pci);
166         }
167
168         /* Try to get SPROM */
169         err = bcma_sprom_get(bus);
170         if (err == -ENOENT) {
171                 pr_err("No SPROM available\n");
172         } else if (err) {
173                 pr_err("Failed to get SPROM: %d\n", err);
174                 return -ENOENT;
175         }
176
177         /* Register found cores */
178         bcma_register_cores(bus);
179
180         pr_info("Bus registered\n");
181
182         return 0;
183 }
184
185 void bcma_bus_unregister(struct bcma_bus *bus)
186 {
187         bcma_unregister_cores(bus);
188 }
189
190 int __init bcma_bus_early_register(struct bcma_bus *bus,
191                                    struct bcma_device *core_cc,
192                                    struct bcma_device *core_mips)
193 {
194         int err;
195         struct bcma_device *core;
196         struct bcma_device_id match;
197
198         bcma_init_bus(bus);
199
200         match.manuf = BCMA_MANUF_BCM;
201         match.id = BCMA_CORE_CHIPCOMMON;
202         match.class = BCMA_CL_SIM;
203         match.rev = BCMA_ANY_REV;
204
205         /* Scan for chip common core */
206         err = bcma_bus_scan_early(bus, &match, core_cc);
207         if (err) {
208                 pr_err("Failed to scan for common core: %d\n", err);
209                 return -1;
210         }
211
212         match.manuf = BCMA_MANUF_MIPS;
213         match.id = BCMA_CORE_MIPS_74K;
214         match.class = BCMA_CL_SIM;
215         match.rev = BCMA_ANY_REV;
216
217         /* Scan for mips core */
218         err = bcma_bus_scan_early(bus, &match, core_mips);
219         if (err) {
220                 pr_err("Failed to scan for mips core: %d\n", err);
221                 return -1;
222         }
223
224         /* Init CC core */
225         core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
226         if (core) {
227                 bus->drv_cc.core = core;
228                 bcma_core_chipcommon_init(&bus->drv_cc);
229         }
230
231         /* Init MIPS core */
232         core = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
233         if (core) {
234                 bus->drv_mips.core = core;
235                 bcma_core_mips_init(&bus->drv_mips);
236         }
237
238         pr_info("Early bus registered\n");
239
240         return 0;
241 }
242
243 #ifdef CONFIG_PM
244 int bcma_bus_suspend(struct bcma_bus *bus)
245 {
246         struct bcma_device *core;
247
248         list_for_each_entry(core, &bus->cores, list) {
249                 struct device_driver *drv = core->dev.driver;
250                 if (drv) {
251                         struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv);
252                         if (adrv->suspend)
253                                 adrv->suspend(core);
254                 }
255         }
256         return 0;
257 }
258
259 int bcma_bus_resume(struct bcma_bus *bus)
260 {
261         struct bcma_device *core;
262
263         /* Init CC core */
264         core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
265         if (core) {
266                 bus->drv_cc.setup_done = false;
267                 bcma_core_chipcommon_init(&bus->drv_cc);
268         }
269
270         list_for_each_entry(core, &bus->cores, list) {
271                 struct device_driver *drv = core->dev.driver;
272                 if (drv) {
273                         struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv);
274                         if (adrv->resume)
275                                 adrv->resume(core);
276                 }
277         }
278
279         return 0;
280 }
281 #endif
282
283 int __bcma_driver_register(struct bcma_driver *drv, struct module *owner)
284 {
285         drv->drv.name = drv->name;
286         drv->drv.bus = &bcma_bus_type;
287         drv->drv.owner = owner;
288
289         return driver_register(&drv->drv);
290 }
291 EXPORT_SYMBOL_GPL(__bcma_driver_register);
292
293 void bcma_driver_unregister(struct bcma_driver *drv)
294 {
295         driver_unregister(&drv->drv);
296 }
297 EXPORT_SYMBOL_GPL(bcma_driver_unregister);
298
299 static int bcma_bus_match(struct device *dev, struct device_driver *drv)
300 {
301         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
302         struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv);
303         const struct bcma_device_id *cid = &core->id;
304         const struct bcma_device_id *did;
305
306         for (did = adrv->id_table; did->manuf || did->id || did->rev; did++) {
307             if ((did->manuf == cid->manuf || did->manuf == BCMA_ANY_MANUF) &&
308                 (did->id == cid->id || did->id == BCMA_ANY_ID) &&
309                 (did->rev == cid->rev || did->rev == BCMA_ANY_REV) &&
310                 (did->class == cid->class || did->class == BCMA_ANY_CLASS))
311                         return 1;
312         }
313         return 0;
314 }
315
316 static int bcma_device_probe(struct device *dev)
317 {
318         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
319         struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver,
320                                                drv);
321         int err = 0;
322
323         if (adrv->probe)
324                 err = adrv->probe(core);
325
326         return err;
327 }
328
329 static int bcma_device_remove(struct device *dev)
330 {
331         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
332         struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver,
333                                                drv);
334
335         if (adrv->remove)
336                 adrv->remove(core);
337
338         return 0;
339 }
340
341 static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env)
342 {
343         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
344
345         return add_uevent_var(env,
346                               "MODALIAS=bcma:m%04Xid%04Xrev%02Xcl%02X",
347                               core->id.manuf, core->id.id,
348                               core->id.rev, core->id.class);
349 }
350
351 static int __init bcma_modinit(void)
352 {
353         int err;
354
355         err = bus_register(&bcma_bus_type);
356         if (err)
357                 return err;
358
359 #ifdef CONFIG_BCMA_HOST_PCI
360         err = bcma_host_pci_init();
361         if (err) {
362                 pr_err("PCI host initialization failed\n");
363                 err = 0;
364         }
365 #endif
366
367         return err;
368 }
369 fs_initcall(bcma_modinit);
370
371 static void __exit bcma_modexit(void)
372 {
373 #ifdef CONFIG_BCMA_HOST_PCI
374         bcma_host_pci_exit();
375 #endif
376         bus_unregister(&bcma_bus_type);
377 }
378 module_exit(bcma_modexit)