bcma: add stub for bcma_bus_suspend()
[linux-2.6.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         return 0;
247 }
248
249 int bcma_bus_resume(struct bcma_bus *bus)
250 {
251         struct bcma_device *core;
252
253         /* Init CC core */
254         core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
255         if (core) {
256                 bus->drv_cc.setup_done = false;
257                 bcma_core_chipcommon_init(&bus->drv_cc);
258         }
259
260         return 0;
261 }
262 #endif
263
264 int __bcma_driver_register(struct bcma_driver *drv, struct module *owner)
265 {
266         drv->drv.name = drv->name;
267         drv->drv.bus = &bcma_bus_type;
268         drv->drv.owner = owner;
269
270         return driver_register(&drv->drv);
271 }
272 EXPORT_SYMBOL_GPL(__bcma_driver_register);
273
274 void bcma_driver_unregister(struct bcma_driver *drv)
275 {
276         driver_unregister(&drv->drv);
277 }
278 EXPORT_SYMBOL_GPL(bcma_driver_unregister);
279
280 static int bcma_bus_match(struct device *dev, struct device_driver *drv)
281 {
282         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
283         struct bcma_driver *adrv = container_of(drv, struct bcma_driver, drv);
284         const struct bcma_device_id *cid = &core->id;
285         const struct bcma_device_id *did;
286
287         for (did = adrv->id_table; did->manuf || did->id || did->rev; did++) {
288             if ((did->manuf == cid->manuf || did->manuf == BCMA_ANY_MANUF) &&
289                 (did->id == cid->id || did->id == BCMA_ANY_ID) &&
290                 (did->rev == cid->rev || did->rev == BCMA_ANY_REV) &&
291                 (did->class == cid->class || did->class == BCMA_ANY_CLASS))
292                         return 1;
293         }
294         return 0;
295 }
296
297 static int bcma_device_probe(struct device *dev)
298 {
299         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
300         struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver,
301                                                drv);
302         int err = 0;
303
304         if (adrv->probe)
305                 err = adrv->probe(core);
306
307         return err;
308 }
309
310 static int bcma_device_remove(struct device *dev)
311 {
312         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
313         struct bcma_driver *adrv = container_of(dev->driver, struct bcma_driver,
314                                                drv);
315
316         if (adrv->remove)
317                 adrv->remove(core);
318
319         return 0;
320 }
321
322 static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env)
323 {
324         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
325
326         return add_uevent_var(env,
327                               "MODALIAS=bcma:m%04Xid%04Xrev%02Xcl%02X",
328                               core->id.manuf, core->id.id,
329                               core->id.rev, core->id.class);
330 }
331
332 static int __init bcma_modinit(void)
333 {
334         int err;
335
336         err = bus_register(&bcma_bus_type);
337         if (err)
338                 return err;
339
340 #ifdef CONFIG_BCMA_HOST_PCI
341         err = bcma_host_pci_init();
342         if (err) {
343                 pr_err("PCI host initialization failed\n");
344                 err = 0;
345         }
346 #endif
347
348         return err;
349 }
350 fs_initcall(bcma_modinit);
351
352 static void __exit bcma_modexit(void)
353 {
354 #ifdef CONFIG_BCMA_HOST_PCI
355         bcma_host_pci_exit();
356 #endif
357         bus_unregister(&bcma_bus_type);
358 }
359 module_exit(bcma_modexit)