Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/zorro.h -- Amiga AutoConfig (Zorro) Bus Definitions | |
3 | * | |
4 | * Copyright (C) 1995--2003 Geert Uytterhoeven | |
5 | * | |
6 | * This file is subject to the terms and conditions of the GNU General Public | |
7 | * License. See the file COPYING in the main directory of this archive | |
8 | * for more details. | |
9 | */ | |
10 | ||
11 | #ifndef _LINUX_ZORRO_H | |
12 | #define _LINUX_ZORRO_H | |
13 | ||
14 | #ifndef __ASSEMBLY__ | |
15 | ||
16 | #include <linux/device.h> | |
17 | ||
18 | ||
19 | /* | |
20 | * Each Zorro board has a 32-bit ID of the form | |
21 | * | |
22 | * mmmmmmmmmmmmmmmmppppppppeeeeeeee | |
23 | * | |
24 | * with | |
25 | * | |
26 | * mmmmmmmmmmmmmmmm 16-bit Manufacturer ID (assigned by CBM (sigh)) | |
27 | * pppppppp 8-bit Product ID (assigned by manufacturer) | |
28 | * eeeeeeee 8-bit Extended Product ID (currently only used | |
29 | * for some GVP boards) | |
30 | */ | |
31 | ||
32 | ||
33 | #define ZORRO_MANUF(id) ((id) >> 16) | |
34 | #define ZORRO_PROD(id) (((id) >> 8) & 0xff) | |
35 | #define ZORRO_EPC(id) ((id) & 0xff) | |
36 | ||
37 | #define ZORRO_ID(manuf, prod, epc) \ | |
38 | ((ZORRO_MANUF_##manuf << 16) | ((prod) << 8) | (epc)) | |
39 | ||
40 | typedef __u32 zorro_id; | |
41 | ||
42 | ||
43 | #define ZORRO_WILDCARD (0xffffffff) /* not official */ | |
44 | ||
45 | /* Include the ID list */ | |
46 | #include <linux/zorro_ids.h> | |
47 | ||
48 | ||
49 | /* | |
50 | * GVP identifies most of its products through the 'extended product code' | |
51 | * (epc). The epc has to be ANDed with the GVP_PRODMASK before the | |
52 | * identification. | |
53 | */ | |
54 | ||
55 | #define GVP_PRODMASK (0xf8) | |
56 | #define GVP_SCSICLKMASK (0x01) | |
57 | ||
58 | enum GVP_flags { | |
59 | GVP_IO = 0x01, | |
60 | GVP_ACCEL = 0x02, | |
61 | GVP_SCSI = 0x04, | |
62 | GVP_24BITDMA = 0x08, | |
63 | GVP_25BITDMA = 0x10, | |
64 | GVP_NOBANK = 0x20, | |
65 | GVP_14MHZ = 0x40, | |
66 | }; | |
67 | ||
68 | ||
69 | struct Node { | |
70 | struct Node *ln_Succ; /* Pointer to next (successor) */ | |
71 | struct Node *ln_Pred; /* Pointer to previous (predecessor) */ | |
72 | __u8 ln_Type; | |
73 | __s8 ln_Pri; /* Priority, for sorting */ | |
74 | __s8 *ln_Name; /* ID string, null terminated */ | |
75 | } __attribute__ ((packed)); | |
76 | ||
77 | struct ExpansionRom { | |
78 | /* -First 16 bytes of the expansion ROM */ | |
79 | __u8 er_Type; /* Board type, size and flags */ | |
80 | __u8 er_Product; /* Product number, assigned by manufacturer */ | |
81 | __u8 er_Flags; /* Flags */ | |
82 | __u8 er_Reserved03; /* Must be zero ($ff inverted) */ | |
83 | __u16 er_Manufacturer; /* Unique ID, ASSIGNED BY COMMODORE-AMIGA! */ | |
84 | __u32 er_SerialNumber; /* Available for use by manufacturer */ | |
85 | __u16 er_InitDiagVec; /* Offset to optional "DiagArea" structure */ | |
86 | __u8 er_Reserved0c; | |
87 | __u8 er_Reserved0d; | |
88 | __u8 er_Reserved0e; | |
89 | __u8 er_Reserved0f; | |
90 | } __attribute__ ((packed)); | |
91 | ||
92 | /* er_Type board type bits */ | |
93 | #define ERT_TYPEMASK 0xc0 | |
94 | #define ERT_ZORROII 0xc0 | |
95 | #define ERT_ZORROIII 0x80 | |
96 | ||
97 | /* other bits defined in er_Type */ | |
98 | #define ERTB_MEMLIST 5 /* Link RAM into free memory list */ | |
99 | #define ERTF_MEMLIST (1<<5) | |
100 | ||
101 | struct ConfigDev { | |
102 | struct Node cd_Node; | |
103 | __u8 cd_Flags; /* (read/write) */ | |
104 | __u8 cd_Pad; /* reserved */ | |
105 | struct ExpansionRom cd_Rom; /* copy of board's expansion ROM */ | |
106 | void *cd_BoardAddr; /* where in memory the board was placed */ | |
107 | __u32 cd_BoardSize; /* size of board in bytes */ | |
108 | __u16 cd_SlotAddr; /* which slot number (PRIVATE) */ | |
109 | __u16 cd_SlotSize; /* number of slots (PRIVATE) */ | |
110 | void *cd_Driver; /* pointer to node of driver */ | |
111 | struct ConfigDev *cd_NextCD; /* linked list of drivers to config */ | |
112 | __u32 cd_Unused[4]; /* for whatever the driver wants */ | |
113 | } __attribute__ ((packed)); | |
114 | ||
115 | #else /* __ASSEMBLY__ */ | |
116 | ||
117 | LN_Succ = 0 | |
118 | LN_Pred = LN_Succ+4 | |
119 | LN_Type = LN_Pred+4 | |
120 | LN_Pri = LN_Type+1 | |
121 | LN_Name = LN_Pri+1 | |
122 | LN_sizeof = LN_Name+4 | |
123 | ||
124 | ER_Type = 0 | |
125 | ER_Product = ER_Type+1 | |
126 | ER_Flags = ER_Product+1 | |
127 | ER_Reserved03 = ER_Flags+1 | |
128 | ER_Manufacturer = ER_Reserved03+1 | |
129 | ER_SerialNumber = ER_Manufacturer+2 | |
130 | ER_InitDiagVec = ER_SerialNumber+4 | |
131 | ER_Reserved0c = ER_InitDiagVec+2 | |
132 | ER_Reserved0d = ER_Reserved0c+1 | |
133 | ER_Reserved0e = ER_Reserved0d+1 | |
134 | ER_Reserved0f = ER_Reserved0e+1 | |
135 | ER_sizeof = ER_Reserved0f+1 | |
136 | ||
137 | CD_Node = 0 | |
138 | CD_Flags = CD_Node+LN_sizeof | |
139 | CD_Pad = CD_Flags+1 | |
140 | CD_Rom = CD_Pad+1 | |
141 | CD_BoardAddr = CD_Rom+ER_sizeof | |
142 | CD_BoardSize = CD_BoardAddr+4 | |
143 | CD_SlotAddr = CD_BoardSize+4 | |
144 | CD_SlotSize = CD_SlotAddr+2 | |
145 | CD_Driver = CD_SlotSize+2 | |
146 | CD_NextCD = CD_Driver+4 | |
147 | CD_Unused = CD_NextCD+4 | |
148 | CD_sizeof = CD_Unused+(4*4) | |
149 | ||
150 | #endif /* __ASSEMBLY__ */ | |
151 | ||
152 | #ifndef __ASSEMBLY__ | |
153 | ||
154 | #define ZORRO_NUM_AUTO 16 | |
155 | ||
156 | #ifdef __KERNEL__ | |
157 | ||
158 | #include <linux/init.h> | |
159 | #include <linux/ioport.h> | |
160 | ||
161 | #include <asm/zorro.h> | |
162 | ||
163 | ||
164 | /* | |
165 | * Zorro devices | |
166 | */ | |
167 | ||
168 | struct zorro_dev { | |
169 | struct ExpansionRom rom; | |
170 | zorro_id id; | |
171 | struct zorro_driver *driver; /* which driver has allocated this device */ | |
172 | struct device dev; /* Generic device interface */ | |
173 | u16 slotaddr; | |
174 | u16 slotsize; | |
175 | char name[64]; | |
176 | struct resource resource; | |
177 | }; | |
178 | ||
179 | #define to_zorro_dev(n) container_of(n, struct zorro_dev, dev) | |
180 | ||
181 | ||
182 | /* | |
183 | * Zorro bus | |
184 | */ | |
185 | ||
186 | struct zorro_bus { | |
187 | struct list_head devices; /* list of devices on this bus */ | |
188 | unsigned int num_resources; /* number of resources */ | |
189 | struct resource resources[4]; /* address space routed to this bus */ | |
190 | struct device dev; | |
191 | char name[10]; | |
192 | }; | |
193 | ||
194 | extern struct zorro_bus zorro_bus; /* single Zorro bus */ | |
195 | extern struct bus_type zorro_bus_type; | |
196 | ||
197 | ||
198 | /* | |
199 | * Zorro device IDs | |
200 | */ | |
201 | ||
202 | struct zorro_device_id { | |
203 | zorro_id id; /* Device ID or ZORRO_WILDCARD */ | |
204 | unsigned long driver_data; /* Data private to the driver */ | |
205 | }; | |
206 | ||
207 | ||
208 | /* | |
209 | * Zorro device drivers | |
210 | */ | |
211 | ||
212 | struct zorro_driver { | |
213 | struct list_head node; | |
214 | char *name; | |
215 | const struct zorro_device_id *id_table; /* NULL if wants all devices */ | |
216 | int (*probe)(struct zorro_dev *z, const struct zorro_device_id *id); /* New device inserted */ | |
217 | void (*remove)(struct zorro_dev *z); /* Device removed (NULL if not a hot-plug capable driver) */ | |
218 | struct device_driver driver; | |
219 | }; | |
220 | ||
221 | #define to_zorro_driver(drv) container_of(drv, struct zorro_driver, driver) | |
222 | ||
223 | ||
224 | #define zorro_for_each_dev(dev) \ | |
225 | for (dev = &zorro_autocon[0]; dev < zorro_autocon+zorro_num_autocon; dev++) | |
226 | ||
227 | ||
228 | /* New-style probing */ | |
229 | extern int zorro_register_driver(struct zorro_driver *); | |
230 | extern void zorro_unregister_driver(struct zorro_driver *); | |
231 | extern const struct zorro_device_id *zorro_match_device(const struct zorro_device_id *ids, const struct zorro_dev *z); | |
232 | static inline struct zorro_driver *zorro_dev_driver(const struct zorro_dev *z) | |
233 | { | |
234 | return z->driver; | |
235 | } | |
236 | ||
237 | ||
238 | extern unsigned int zorro_num_autocon; /* # of autoconfig devices found */ | |
239 | extern struct zorro_dev zorro_autocon[ZORRO_NUM_AUTO]; | |
240 | ||
241 | ||
242 | /* | |
243 | * Zorro Functions | |
244 | */ | |
245 | ||
246 | extern struct zorro_dev *zorro_find_device(zorro_id id, | |
247 | struct zorro_dev *from); | |
248 | ||
249 | #define zorro_resource_start(z) ((z)->resource.start) | |
250 | #define zorro_resource_end(z) ((z)->resource.end) | |
251 | #define zorro_resource_len(z) ((z)->resource.end-(z)->resource.start+1) | |
252 | #define zorro_resource_flags(z) ((z)->resource.flags) | |
253 | ||
254 | #define zorro_request_device(z, name) \ | |
255 | request_mem_region(zorro_resource_start(z), zorro_resource_len(z), name) | |
256 | #define zorro_release_device(z) \ | |
257 | release_mem_region(zorro_resource_start(z), zorro_resource_len(z)) | |
258 | ||
259 | /* Similar to the helpers above, these manipulate per-zorro_dev | |
260 | * driver-specific data. They are really just a wrapper around | |
261 | * the generic device structure functions of these calls. | |
262 | */ | |
263 | static inline void *zorro_get_drvdata (struct zorro_dev *z) | |
264 | { | |
265 | return dev_get_drvdata(&z->dev); | |
266 | } | |
267 | ||
268 | static inline void zorro_set_drvdata (struct zorro_dev *z, void *data) | |
269 | { | |
270 | dev_set_drvdata(&z->dev, data); | |
271 | } | |
272 | ||
273 | ||
274 | /* | |
275 | * A helper function which helps ensure correct zorro_driver | |
276 | * setup and cleanup for commonly-encountered hotplug/modular cases | |
277 | * | |
278 | * This MUST stay in a header, as it checks for -DMODULE | |
279 | */ | |
280 | static inline int zorro_module_init(struct zorro_driver *drv) | |
281 | { | |
282 | int rc = zorro_register_driver(drv); | |
283 | ||
284 | if (rc > 0) | |
285 | return 0; | |
286 | ||
287 | /* iff CONFIG_HOTPLUG and built into kernel, we should | |
288 | * leave the driver around for future hotplug events. | |
289 | * For the module case, a hotplug daemon of some sort | |
290 | * should load a module in response to an insert event. */ | |
291 | #if defined(CONFIG_HOTPLUG) && !defined(MODULE) | |
292 | if (rc == 0) | |
293 | return 0; | |
294 | #else | |
295 | if (rc == 0) | |
296 | rc = -ENODEV; | |
297 | #endif | |
298 | ||
299 | /* if we get here, we need to clean up Zorro driver instance | |
300 | * and return some sort of error */ | |
301 | zorro_unregister_driver(drv); | |
302 | ||
303 | return rc; | |
304 | } | |
305 | ||
306 | ||
307 | /* | |
308 | * Bitmask indicating portions of available Zorro II RAM that are unused | |
309 | * by the system. Every bit represents a 64K chunk, for a maximum of 8MB | |
310 | * (128 chunks, physical 0x00200000-0x009fffff). | |
311 | * | |
312 | * If you want to use (= allocate) portions of this RAM, you should clear | |
313 | * the corresponding bits. | |
314 | */ | |
315 | ||
316 | extern DECLARE_BITMAP(zorro_unused_z2ram, 128); | |
317 | ||
318 | #define Z2RAM_START (0x00200000) | |
319 | #define Z2RAM_END (0x00a00000) | |
320 | #define Z2RAM_SIZE (0x00800000) | |
321 | #define Z2RAM_CHUNKSIZE (0x00010000) | |
322 | #define Z2RAM_CHUNKMASK (0x0000ffff) | |
323 | #define Z2RAM_CHUNKSHIFT (16) | |
324 | ||
325 | ||
326 | #endif /* !__ASSEMBLY__ */ | |
327 | #endif /* __KERNEL__ */ | |
328 | ||
329 | #endif /* _LINUX_ZORRO_H */ |