← Back to branch summary

~ubuntu-branches/ubuntu/saucy/linux-n900/saucy

« back to all changes in this revision

Viewing changes to drivers/sh/superhyway/superhyway.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathieu Poirier
  • Date: 2011-02-18 09:43:31 UTC
  • Revision ID: james.westby@ubuntu.com-20110218094331-eyubsja4f9k0yhmq
Tags: 2.6.35-1.1
Initial release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/sh/superhyway/superhyway.c
 
1
/*
 
2
 * drivers/sh/superhyway/superhyway.c
 
3
 *
 
4
 * SuperHyway Bus Driver
 
5
 *
 
6
 * Copyright (C) 2004, 2005  Paul Mundt <lethal@linux-sh.org>
 
7
 *
 
8
 * This file is subject to the terms and conditions of the GNU General Public
 
9
 * License.  See the file "COPYING" in the main directory of this archive
 
10
 * for more details.
 
11
 */
 
12
#include <linux/kernel.h>
 
13
#include <linux/device.h>
 
14
#include <linux/init.h>
 
15
#include <linux/module.h>
 
16
#include <linux/types.h>
 
17
#include <linux/list.h>
 
18
#include <linux/superhyway.h>
 
19
#include <linux/string.h>
 
20
#include <linux/slab.h>
 
21
 
 
22
static int superhyway_devices;
 
23
 
 
24
static struct device superhyway_bus_device = {
 
25
        .init_name = "superhyway",
 
26
};
 
27
 
 
28
static void superhyway_device_release(struct device *dev)
 
29
{
 
30
        struct superhyway_device *sdev = to_superhyway_device(dev);
 
31
 
 
32
        kfree(sdev->resource);
 
33
        kfree(sdev);
 
34
}
 
35
 
 
36
/**
 
37
 * superhyway_add_device - Add a SuperHyway module
 
38
 * @base: Physical address where module is mapped.
 
39
 * @sdev: SuperHyway device to add, or NULL to allocate a new one.
 
40
 * @bus: Bus where SuperHyway module resides.
 
41
 *
 
42
 * This is responsible for adding a new SuperHyway module. This sets up a new
 
43
 * struct superhyway_device for the module being added if @sdev == NULL.
 
44
 *
 
45
 * Devices are initially added in the order that they are scanned (from the
 
46
 * top-down of the memory map), and are assigned an ID based on the order that
 
47
 * they are added. Any manual addition of a module will thus get the ID after
 
48
 * the devices already discovered regardless of where it resides in memory.
 
49
 *
 
50
 * Further work can and should be done in superhyway_scan_bus(), to be sure
 
51
 * that any new modules are properly discovered and subsequently registered.
 
52
 */
 
53
int superhyway_add_device(unsigned long base, struct superhyway_device *sdev,
 
54
                          struct superhyway_bus *bus)
 
55
{
 
56
        struct superhyway_device *dev = sdev;
 
57
 
 
58
        if (!dev) {
 
59
                dev = kzalloc(sizeof(struct superhyway_device), GFP_KERNEL);
 
60
                if (!dev)
 
61
                        return -ENOMEM;
 
62
 
 
63
        }
 
64
 
 
65
        dev->bus = bus;
 
66
        superhyway_read_vcr(dev, base, &dev->vcr);
 
67
 
 
68
        if (!dev->resource) {
 
69
                dev->resource = kmalloc(sizeof(struct resource), GFP_KERNEL);
 
70
                if (!dev->resource) {
 
71
                        kfree(dev);
 
72
                        return -ENOMEM;
 
73
                }
 
74
 
 
75
                dev->resource->name     = dev->name;
 
76
                dev->resource->start    = base;
 
77
                dev->resource->end      = dev->resource->start + 0x01000000;
 
78
        }
 
79
 
 
80
        dev->dev.parent         = &superhyway_bus_device;
 
81
        dev->dev.bus            = &superhyway_bus_type;
 
82
        dev->dev.release        = superhyway_device_release;
 
83
        dev->id.id              = dev->vcr.mod_id;
 
84
 
 
85
        sprintf(dev->name, "SuperHyway device %04x", dev->id.id);
 
86
        dev_set_name(&dev->dev, "%02x", superhyway_devices);
 
87
 
 
88
        superhyway_devices++;
 
89
 
 
90
        return device_register(&dev->dev);
 
91
}
 
92
 
 
93
int superhyway_add_devices(struct superhyway_bus *bus,
 
94
                           struct superhyway_device **devices,
 
95
                           int nr_devices)
 
96
{
 
97
        int i, ret = 0;
 
98
 
 
99
        for (i = 0; i < nr_devices; i++) {
 
100
                struct superhyway_device *dev = devices[i];
 
101
                ret |= superhyway_add_device(dev->resource[0].start, dev, bus);
 
102
        }
 
103
 
 
104
        return ret;
 
105
}
 
106
 
 
107
static int __init superhyway_init(void)
 
108
{
 
109
        struct superhyway_bus *bus;
 
110
        int ret;
 
111
 
 
112
        ret = device_register(&superhyway_bus_device);
 
113
        if (unlikely(ret))
 
114
                return ret;
 
115
 
 
116
        for (bus = superhyway_channels; bus->ops; bus++)
 
117
                ret |= superhyway_scan_bus(bus);
 
118
 
 
119
        return ret;
 
120
}
 
121
postcore_initcall(superhyway_init);
 
122
 
 
123
static const struct superhyway_device_id *
 
124
superhyway_match_id(const struct superhyway_device_id *ids,
 
125
                    struct superhyway_device *dev)
 
126
{
 
127
        while (ids->id) {
 
128
                if (ids->id == dev->id.id)
 
129
                        return ids;
 
130
 
 
131
                ids++;
 
132
        }
 
133
 
 
134
        return NULL;
 
135
}
 
136
 
 
137
static int superhyway_device_probe(struct device *dev)
 
138
{
 
139
        struct superhyway_device *shyway_dev = to_superhyway_device(dev);
 
140
        struct superhyway_driver *shyway_drv = to_superhyway_driver(dev->driver);
 
141
 
 
142
        if (shyway_drv && shyway_drv->probe) {
 
143
                const struct superhyway_device_id *id;
 
144
 
 
145
                id = superhyway_match_id(shyway_drv->id_table, shyway_dev);
 
146
                if (id)
 
147
                        return shyway_drv->probe(shyway_dev, id);
 
148
        }
 
149
 
 
150
        return -ENODEV;
 
151
}
 
152
 
 
153
static int superhyway_device_remove(struct device *dev)
 
154
{
 
155
        struct superhyway_device *shyway_dev = to_superhyway_device(dev);
 
156
        struct superhyway_driver *shyway_drv = to_superhyway_driver(dev->driver);
 
157
 
 
158
        if (shyway_drv && shyway_drv->remove) {
 
159
                shyway_drv->remove(shyway_dev);
 
160
                return 0;
 
161
        }
 
162
 
 
163
        return -ENODEV;
 
164
}
 
165
 
 
166
/**
 
167
 * superhyway_register_driver - Register a new SuperHyway driver
 
168
 * @drv: SuperHyway driver to register.
 
169
 *
 
170
 * This registers the passed in @drv. Any devices matching the id table will
 
171
 * automatically be populated and handed off to the driver's specified probe
 
172
 * routine.
 
173
 */
 
174
int superhyway_register_driver(struct superhyway_driver *drv)
 
175
{
 
176
        drv->drv.name   = drv->name;
 
177
        drv->drv.bus    = &superhyway_bus_type;
 
178
 
 
179
        return driver_register(&drv->drv);
 
180
}
 
181
 
 
182
/**
 
183
 * superhyway_unregister_driver - Unregister a SuperHyway driver
 
184
 * @drv: SuperHyway driver to unregister.
 
185
 *
 
186
 * This cleans up after superhyway_register_driver(), and should be invoked in
 
187
 * the exit path of any module drivers.
 
188
 */
 
189
void superhyway_unregister_driver(struct superhyway_driver *drv)
 
190
{
 
191
        driver_unregister(&drv->drv);
 
192
}
 
193
 
 
194
static int superhyway_bus_match(struct device *dev, struct device_driver *drv)
 
195
{
 
196
        struct superhyway_device *shyway_dev = to_superhyway_device(dev);
 
197
        struct superhyway_driver *shyway_drv = to_superhyway_driver(drv);
 
198
        const struct superhyway_device_id *ids = shyway_drv->id_table;
 
199
 
 
200
        if (!ids)
 
201
                return -EINVAL;
 
202
        if (superhyway_match_id(ids, shyway_dev))
 
203
                return 1;
 
204
 
 
205
        return -ENODEV;
 
206
}
 
207
 
 
208
struct bus_type superhyway_bus_type = {
 
209
        .name           = "superhyway",
 
210
        .match          = superhyway_bus_match,
 
211
#ifdef CONFIG_SYSFS
 
212
        .dev_attrs      = superhyway_dev_attrs,
 
213
#endif
 
214
        .probe          = superhyway_device_probe,
 
215
        .remove         = superhyway_device_remove,
 
216
};
 
217
 
 
218
static int __init superhyway_bus_init(void)
 
219
{
 
220
        return bus_register(&superhyway_bus_type);
 
221
}
 
222
 
 
223
static void __exit superhyway_bus_exit(void)
 
224
{
 
225
        device_unregister(&superhyway_bus_device);
 
226
        bus_unregister(&superhyway_bus_type);
 
227
}
 
228
 
 
229
core_initcall(superhyway_bus_init);
 
230
module_exit(superhyway_bus_exit);
 
231
 
 
232
EXPORT_SYMBOL(superhyway_bus_type);
 
233
EXPORT_SYMBOL(superhyway_add_device);
 
234
EXPORT_SYMBOL(superhyway_add_devices);
 
235
EXPORT_SYMBOL(superhyway_register_driver);
 
236
EXPORT_SYMBOL(superhyway_unregister_driver);
 
237
 
 
238
MODULE_LICENSE("GPL");