[PATCH] fix u32 vs. pm_message_t in driver/video
[linux-2.6.git] / arch / sh / kernel / cpu / bus.c
1 /*
2  * arch/sh/kernel/cpu/bus.c
3  *
4  * Virtual bus for SuperH.
5  *
6  * Copyright (C) 2004 Paul Mundt
7  *
8  * Shamelessly cloned from arch/arm/mach-omap/bus.c, which was written
9  * by:
10  *
11  *      Copyright (C) 2003 - 2004 Nokia Corporation
12  *      Written by Tony Lindgren <tony@atomide.com>
13  *      Portions of code based on sa1111.c.
14  *
15  * This program is free software; you can redistribute it and/or modify it
16  * under the terms of the GNU General Public License as published by the
17  * Free Software Foundation; either version 2 of the License, or (at your
18  * option) any later version.
19  */
20 #include <linux/kernel.h>
21 #include <linux/device.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <asm/bus-sh.h>
25
26 static int sh_bus_match(struct device *dev, struct device_driver *drv)
27 {
28         struct sh_driver *shdrv = to_sh_driver(drv);
29         struct sh_dev *shdev = to_sh_dev(dev);
30
31         return shdev->dev_id == shdrv->dev_id;
32 }
33
34 static int sh_bus_suspend(struct device *dev, u32 state)
35 {
36         struct sh_dev *shdev = to_sh_dev(dev);
37         struct sh_driver *shdrv = to_sh_driver(dev->driver);
38
39         if (shdrv && shdrv->suspend)
40                 return shdrv->suspend(shdev, state);
41
42         return 0;
43 }
44
45 static int sh_bus_resume(struct device *dev)
46 {
47         struct sh_dev *shdev = to_sh_dev(dev);
48         struct sh_driver *shdrv = to_sh_driver(dev->driver);
49
50         if (shdrv && shdrv->resume)
51                 return shdrv->resume(shdev);
52
53         return 0;
54 }
55
56 static struct device sh_bus_devices[SH_NR_BUSES] = {
57         {
58                 .bus_id         = SH_BUS_NAME_VIRT,
59         },
60 };
61
62 struct bus_type sh_bus_types[SH_NR_BUSES] = {
63         {
64                 .name           = SH_BUS_NAME_VIRT,
65                 .match          = sh_bus_match,
66                 .suspend        = sh_bus_suspend,
67                 .resume         = sh_bus_resume,
68         },
69 };
70
71 static int sh_device_probe(struct device *dev)
72 {
73         struct sh_dev *shdev = to_sh_dev(dev);
74         struct sh_driver *shdrv = to_sh_driver(dev->driver);
75
76         if (shdrv && shdrv->probe)
77                 return shdrv->probe(shdev);
78
79         return -ENODEV;
80 }
81
82 static int sh_device_remove(struct device *dev)
83 {
84         struct sh_dev *shdev = to_sh_dev(dev);
85         struct sh_driver *shdrv = to_sh_driver(dev->driver);
86
87         if (shdrv && shdrv->remove)
88                 return shdrv->remove(shdev);
89
90         return 0;
91 }
92
93 int sh_device_register(struct sh_dev *dev)
94 {
95         if (!dev)
96                 return -EINVAL;
97
98         if (dev->bus_id < 0 || dev->bus_id >= SH_NR_BUSES) {
99                 printk(KERN_ERR "%s: bus_id invalid: %s bus: %d\n",
100                        __FUNCTION__, dev->name, dev->bus_id);
101                 return -EINVAL;
102         }
103
104         dev->dev.parent = &sh_bus_devices[dev->bus_id];
105         dev->dev.bus    = &sh_bus_types[dev->bus_id];
106
107         /* This is needed for USB OHCI to work */
108         if (dev->dma_mask)
109                 dev->dev.dma_mask = dev->dma_mask;
110
111         snprintf(dev->dev.bus_id, BUS_ID_SIZE, "%s%u",
112                  dev->name, dev->dev_id);
113
114         printk(KERN_INFO "Registering SH device '%s'. Parent at %s\n",
115                dev->dev.bus_id, dev->dev.parent->bus_id);
116
117         return device_register(&dev->dev);
118 }
119
120 void sh_device_unregister(struct sh_dev *dev)
121 {
122         device_unregister(&dev->dev);
123 }
124
125 int sh_driver_register(struct sh_driver *drv)
126 {
127         if (!drv)
128                 return -EINVAL;
129
130         if (drv->bus_id < 0 || drv->bus_id >= SH_NR_BUSES) {
131                 printk(KERN_ERR "%s: bus_id invalid: bus: %d device %d\n",
132                        __FUNCTION__, drv->bus_id, drv->dev_id);
133                 return -EINVAL;
134         }
135
136         drv->drv.probe  = sh_device_probe;
137         drv->drv.remove = sh_device_remove;
138         drv->drv.bus    = &sh_bus_types[drv->bus_id];
139
140         return driver_register(&drv->drv);
141 }
142
143 void sh_driver_unregister(struct sh_driver *drv)
144 {
145         driver_unregister(&drv->drv);
146 }
147
148 static int __init sh_bus_init(void)
149 {
150         int i, ret = 0;
151
152         for (i = 0; i < SH_NR_BUSES; i++) {
153                 ret = device_register(&sh_bus_devices[i]);
154                 if (ret != 0) {
155                         printk(KERN_ERR "Unable to register bus device %s\n",
156                                sh_bus_devices[i].bus_id);
157                         continue;
158                 }
159
160                 ret = bus_register(&sh_bus_types[i]);
161                 if (ret != 0) {
162                         printk(KERN_ERR "Unable to register bus %s\n",
163                                sh_bus_types[i].name);
164                         device_unregister(&sh_bus_devices[i]);
165                 }
166         }
167
168         printk(KERN_INFO "SH Virtual Bus initialized\n");
169
170         return ret;
171 }
172
173 static void __exit sh_bus_exit(void)
174 {
175         int i;
176
177         for (i = 0; i < SH_NR_BUSES; i++) {
178                 bus_unregister(&sh_bus_types[i]);
179                 device_unregister(&sh_bus_devices[i]);
180         }
181 }
182
183 module_init(sh_bus_init);
184 module_exit(sh_bus_exit);
185
186 MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>");
187 MODULE_DESCRIPTION("SH Virtual Bus");
188 MODULE_LICENSE("GPL");
189
190 EXPORT_SYMBOL(sh_bus_types);
191 EXPORT_SYMBOL(sh_device_register);
192 EXPORT_SYMBOL(sh_device_unregister);
193 EXPORT_SYMBOL(sh_driver_register);
194 EXPORT_SYMBOL(sh_driver_unregister);
195