GNU Linux-libre 4.4.289-gnu1
[releases.git] / drivers / zorro / zorro-driver.c
1 /*
2  *  Zorro Driver Services
3  *
4  *  Copyright (C) 2003 Geert Uytterhoeven
5  *
6  *  Loosely based on drivers/pci/pci-driver.c
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
13 #include <linux/init.h>
14 #include <linux/module.h>
15 #include <linux/zorro.h>
16
17
18     /**
19      *  zorro_match_device - Tell if a Zorro device structure has a matching
20      *                       Zorro device id structure
21      *  @ids: array of Zorro device id structures to search in
22      *  @dev: the Zorro device structure to match against
23      *
24      *  Used by a driver to check whether a Zorro device present in the
25      *  system is in its list of supported devices. Returns the matching
26      *  zorro_device_id structure or %NULL if there is no match.
27      */
28
29 const struct zorro_device_id *
30 zorro_match_device(const struct zorro_device_id *ids,
31                    const struct zorro_dev *z)
32 {
33         while (ids->id) {
34                 if (ids->id == ZORRO_WILDCARD || ids->id == z->id)
35                         return ids;
36                 ids++;
37         }
38         return NULL;
39 }
40 EXPORT_SYMBOL(zorro_match_device);
41
42
43 static int zorro_device_probe(struct device *dev)
44 {
45         int error = 0;
46         struct zorro_driver *drv = to_zorro_driver(dev->driver);
47         struct zorro_dev *z = to_zorro_dev(dev);
48
49         if (!z->driver && drv->probe) {
50                 const struct zorro_device_id *id;
51
52                 id = zorro_match_device(drv->id_table, z);
53                 if (id)
54                         error = drv->probe(z, id);
55                 if (error >= 0) {
56                         z->driver = drv;
57                         error = 0;
58                 }
59         }
60         return error;
61 }
62
63
64 static int zorro_device_remove(struct device *dev)
65 {
66         struct zorro_dev *z = to_zorro_dev(dev);
67         struct zorro_driver *drv = to_zorro_driver(dev->driver);
68
69         if (drv) {
70                 if (drv->remove)
71                         drv->remove(z);
72                 z->driver = NULL;
73         }
74         return 0;
75 }
76
77
78     /**
79      *  zorro_register_driver - register a new Zorro driver
80      *  @drv: the driver structure to register
81      *
82      *  Adds the driver structure to the list of registered drivers
83      *  Returns zero or a negative error value.
84      */
85
86 int zorro_register_driver(struct zorro_driver *drv)
87 {
88         /* initialize common driver fields */
89         drv->driver.name = drv->name;
90         drv->driver.bus = &zorro_bus_type;
91
92         /* register with core */
93         return driver_register(&drv->driver);
94 }
95 EXPORT_SYMBOL(zorro_register_driver);
96
97
98     /**
99      *  zorro_unregister_driver - unregister a zorro driver
100      *  @drv: the driver structure to unregister
101      *
102      *  Deletes the driver structure from the list of registered Zorro drivers,
103      *  gives it a chance to clean up by calling its remove() function for
104      *  each device it was responsible for, and marks those devices as
105      *  driverless.
106      */
107
108 void zorro_unregister_driver(struct zorro_driver *drv)
109 {
110         driver_unregister(&drv->driver);
111 }
112 EXPORT_SYMBOL(zorro_unregister_driver);
113
114
115     /**
116      *  zorro_bus_match - Tell if a Zorro device structure has a matching Zorro
117      *                    device id structure
118      *  @ids: array of Zorro device id structures to search in
119      *  @dev: the Zorro device structure to match against
120      *
121      *  Used by a driver to check whether a Zorro device present in the
122      *  system is in its list of supported devices.Returns the matching
123      *  zorro_device_id structure or %NULL if there is no match.
124      */
125
126 static int zorro_bus_match(struct device *dev, struct device_driver *drv)
127 {
128         struct zorro_dev *z = to_zorro_dev(dev);
129         struct zorro_driver *zorro_drv = to_zorro_driver(drv);
130         const struct zorro_device_id *ids = zorro_drv->id_table;
131
132         if (!ids)
133                 return 0;
134
135         while (ids->id) {
136                 if (ids->id == ZORRO_WILDCARD || ids->id == z->id)
137                         return 1;
138                 ids++;
139         }
140         return 0;
141 }
142
143 static int zorro_uevent(struct device *dev, struct kobj_uevent_env *env)
144 {
145         struct zorro_dev *z;
146
147         if (!dev)
148                 return -ENODEV;
149
150         z = to_zorro_dev(dev);
151         if (!z)
152                 return -ENODEV;
153
154         if (add_uevent_var(env, "ZORRO_ID=%08X", z->id) ||
155             add_uevent_var(env, "ZORRO_SLOT_NAME=%s", dev_name(dev)) ||
156             add_uevent_var(env, "ZORRO_SLOT_ADDR=%04X", z->slotaddr) ||
157             add_uevent_var(env, "MODALIAS=" ZORRO_DEVICE_MODALIAS_FMT, z->id))
158                 return -ENOMEM;
159
160         return 0;
161 }
162
163 struct bus_type zorro_bus_type = {
164         .name     = "zorro",
165         .dev_name = "zorro",
166         .match    = zorro_bus_match,
167         .uevent   = zorro_uevent,
168         .probe    = zorro_device_probe,
169         .remove   = zorro_device_remove,
170 };
171 EXPORT_SYMBOL(zorro_bus_type);
172
173
174 static int __init zorro_driver_init(void)
175 {
176         return bus_register(&zorro_bus_type);
177 }
178
179 postcore_initcall(zorro_driver_init);
180