1 | /*- |
---|
2 | * Copyright (c) 1997,1998,2003 Doug Rabson |
---|
3 | * All rights reserved. |
---|
4 | * |
---|
5 | * Redistribution and use in source and binary forms, with or without |
---|
6 | * modification, are permitted provided that the following conditions |
---|
7 | * are met: |
---|
8 | * 1. Redistributions of source code must retain the above copyright |
---|
9 | * notice, this list of conditions and the following disclaimer. |
---|
10 | * 2. Redistributions in binary form must reproduce the above copyright |
---|
11 | * notice, this list of conditions and the following disclaimer in the |
---|
12 | * documentation and/or other materials provided with the distribution. |
---|
13 | * |
---|
14 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND |
---|
15 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
---|
16 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
---|
17 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
---|
18 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
---|
19 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
---|
20 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
---|
21 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
---|
22 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
---|
23 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
---|
24 | * SUCH DAMAGE. |
---|
25 | * |
---|
26 | * $FreeBSD$ |
---|
27 | */ |
---|
28 | |
---|
29 | #ifndef _SYS_BUS_H_ |
---|
30 | #define _SYS_BUS_H_ |
---|
31 | |
---|
32 | #include <machine/_limits.h> |
---|
33 | #include <machine/_bus.h> |
---|
34 | #include <sys/_bus_dma.h> |
---|
35 | #include <sys/ioccom.h> |
---|
36 | |
---|
37 | /** |
---|
38 | * @defgroup NEWBUS newbus - a generic framework for managing devices |
---|
39 | * @{ |
---|
40 | */ |
---|
41 | |
---|
42 | /** |
---|
43 | * @brief Interface information structure. |
---|
44 | */ |
---|
45 | struct u_businfo { |
---|
46 | int ub_version; /**< @brief interface version */ |
---|
47 | #define BUS_USER_VERSION 1 |
---|
48 | int ub_generation; /**< @brief generation count */ |
---|
49 | }; |
---|
50 | |
---|
51 | /** |
---|
52 | * @brief State of the device. |
---|
53 | */ |
---|
54 | typedef enum device_state { |
---|
55 | DS_NOTPRESENT = 10, /**< @brief not probed or probe failed */ |
---|
56 | DS_ALIVE = 20, /**< @brief probe succeeded */ |
---|
57 | DS_ATTACHING = 25, /**< @brief currently attaching */ |
---|
58 | DS_ATTACHED = 30, /**< @brief attach method called */ |
---|
59 | DS_BUSY = 40 /**< @brief device is open */ |
---|
60 | } device_state_t; |
---|
61 | |
---|
62 | /** |
---|
63 | * @brief Device information exported to userspace. |
---|
64 | */ |
---|
65 | struct u_device { |
---|
66 | uintptr_t dv_handle; |
---|
67 | uintptr_t dv_parent; |
---|
68 | |
---|
69 | char dv_name[32]; /**< @brief Name of device in tree. */ |
---|
70 | char dv_desc[32]; /**< @brief Driver description */ |
---|
71 | char dv_drivername[32]; /**< @brief Driver name */ |
---|
72 | char dv_pnpinfo[128]; /**< @brief Plug and play info */ |
---|
73 | char dv_location[128]; /**< @brief Where is the device? */ |
---|
74 | uint32_t dv_devflags; /**< @brief API Flags for device */ |
---|
75 | uint16_t dv_flags; /**< @brief flags for dev state */ |
---|
76 | device_state_t dv_state; /**< @brief State of attachment */ |
---|
77 | /* XXX more driver info? */ |
---|
78 | }; |
---|
79 | |
---|
80 | /* Flags exported via dv_flags. */ |
---|
81 | #define DF_ENABLED 0x01 /* device should be probed/attached */ |
---|
82 | #define DF_FIXEDCLASS 0x02 /* devclass specified at create time */ |
---|
83 | #define DF_WILDCARD 0x04 /* unit was originally wildcard */ |
---|
84 | #define DF_DESCMALLOCED 0x08 /* description was malloced */ |
---|
85 | #define DF_QUIET 0x10 /* don't print verbose attach message */ |
---|
86 | #define DF_DONENOMATCH 0x20 /* don't execute DEVICE_NOMATCH again */ |
---|
87 | #define DF_EXTERNALSOFTC 0x40 /* softc not allocated by us */ |
---|
88 | #define DF_REBID 0x80 /* Can rebid after attach */ |
---|
89 | #define DF_SUSPENDED 0x100 /* Device is suspended. */ |
---|
90 | |
---|
91 | /** |
---|
92 | * @brief Device request structure used for ioctl's. |
---|
93 | * |
---|
94 | * Used for ioctl's on /dev/devctl2. All device ioctl's |
---|
95 | * must have parameter definitions which begin with dr_name. |
---|
96 | */ |
---|
97 | struct devreq_buffer { |
---|
98 | void *buffer; |
---|
99 | size_t length; |
---|
100 | }; |
---|
101 | |
---|
102 | struct devreq { |
---|
103 | char dr_name[128]; |
---|
104 | int dr_flags; /* request-specific flags */ |
---|
105 | union { |
---|
106 | struct devreq_buffer dru_buffer; |
---|
107 | void *dru_data; |
---|
108 | } dr_dru; |
---|
109 | #define dr_buffer dr_dru.dru_buffer /* variable-sized buffer */ |
---|
110 | #define dr_data dr_dru.dru_data /* fixed-size buffer */ |
---|
111 | }; |
---|
112 | |
---|
113 | #define DEV_ATTACH _IOW('D', 1, struct devreq) |
---|
114 | #define DEV_DETACH _IOW('D', 2, struct devreq) |
---|
115 | #define DEV_ENABLE _IOW('D', 3, struct devreq) |
---|
116 | #define DEV_DISABLE _IOW('D', 4, struct devreq) |
---|
117 | #define DEV_SUSPEND _IOW('D', 5, struct devreq) |
---|
118 | #define DEV_RESUME _IOW('D', 6, struct devreq) |
---|
119 | #define DEV_SET_DRIVER _IOW('D', 7, struct devreq) |
---|
120 | #define DEV_CLEAR_DRIVER _IOW('D', 8, struct devreq) |
---|
121 | #define DEV_RESCAN _IOW('D', 9, struct devreq) |
---|
122 | #define DEV_DELETE _IOW('D', 10, struct devreq) |
---|
123 | |
---|
124 | /* Flags for DEV_DETACH and DEV_DISABLE. */ |
---|
125 | #define DEVF_FORCE_DETACH 0x0000001 |
---|
126 | |
---|
127 | /* Flags for DEV_SET_DRIVER. */ |
---|
128 | #define DEVF_SET_DRIVER_DETACH 0x0000001 /* Detach existing driver. */ |
---|
129 | |
---|
130 | /* Flags for DEV_CLEAR_DRIVER. */ |
---|
131 | #define DEVF_CLEAR_DRIVER_DETACH 0x0000001 /* Detach existing driver. */ |
---|
132 | |
---|
133 | /* Flags for DEV_DELETE. */ |
---|
134 | #define DEVF_FORCE_DELETE 0x0000001 |
---|
135 | |
---|
136 | #ifdef _KERNEL |
---|
137 | |
---|
138 | #include <sys/eventhandler.h> |
---|
139 | #include <sys/kobj.h> |
---|
140 | |
---|
141 | /** |
---|
142 | * devctl hooks. Typically one should use the devctl_notify |
---|
143 | * hook to send the message. However, devctl_queue_data is also |
---|
144 | * included in case devctl_notify isn't sufficiently general. |
---|
145 | */ |
---|
146 | boolean_t devctl_process_running(void); |
---|
147 | void devctl_notify_f(const char *__system, const char *__subsystem, |
---|
148 | const char *__type, const char *__data, int __flags); |
---|
149 | void devctl_notify(const char *__system, const char *__subsystem, |
---|
150 | const char *__type, const char *__data); |
---|
151 | void devctl_queue_data_f(char *__data, int __flags); |
---|
152 | void devctl_queue_data(char *__data); |
---|
153 | void devctl_safe_quote(char *__dst, const char *__src, size_t len); |
---|
154 | |
---|
155 | /** |
---|
156 | * Device name parsers. Hook to allow device enumerators to map |
---|
157 | * scheme-specific names to a device. |
---|
158 | */ |
---|
159 | typedef void (*dev_lookup_fn)(void *arg, const char *name, |
---|
160 | device_t *result); |
---|
161 | EVENTHANDLER_DECLARE(dev_lookup, dev_lookup_fn); |
---|
162 | |
---|
163 | /** |
---|
164 | * @brief A device driver (included mainly for compatibility with |
---|
165 | * FreeBSD 4.x). |
---|
166 | */ |
---|
167 | typedef struct kobj_class driver_t; |
---|
168 | |
---|
169 | /** |
---|
170 | * @brief A device class |
---|
171 | * |
---|
172 | * The devclass object has two main functions in the system. The first |
---|
173 | * is to manage the allocation of unit numbers for device instances |
---|
174 | * and the second is to hold the list of device drivers for a |
---|
175 | * particular bus type. Each devclass has a name and there cannot be |
---|
176 | * two devclasses with the same name. This ensures that unique unit |
---|
177 | * numbers are allocated to device instances. |
---|
178 | * |
---|
179 | * Drivers that support several different bus attachments (e.g. isa, |
---|
180 | * pci, pccard) should all use the same devclass to ensure that unit |
---|
181 | * numbers do not conflict. |
---|
182 | * |
---|
183 | * Each devclass may also have a parent devclass. This is used when |
---|
184 | * searching for device drivers to allow a form of inheritance. When |
---|
185 | * matching drivers with devices, first the driver list of the parent |
---|
186 | * device's devclass is searched. If no driver is found in that list, |
---|
187 | * the search continues in the parent devclass (if any). |
---|
188 | */ |
---|
189 | typedef struct devclass *devclass_t; |
---|
190 | |
---|
191 | /** |
---|
192 | * @brief A device method |
---|
193 | */ |
---|
194 | #define device_method_t kobj_method_t |
---|
195 | |
---|
196 | /** |
---|
197 | * @brief Driver interrupt filter return values |
---|
198 | * |
---|
199 | * If a driver provides an interrupt filter routine it must return an |
---|
200 | * integer consisting of oring together zero or more of the following |
---|
201 | * flags: |
---|
202 | * |
---|
203 | * FILTER_STRAY - this device did not trigger the interrupt |
---|
204 | * FILTER_HANDLED - the interrupt has been fully handled and can be EOId |
---|
205 | * FILTER_SCHEDULE_THREAD - the threaded interrupt handler should be |
---|
206 | * scheduled to execute |
---|
207 | * |
---|
208 | * If the driver does not provide a filter, then the interrupt code will |
---|
209 | * act is if the filter had returned FILTER_SCHEDULE_THREAD. Note that it |
---|
210 | * is illegal to specify any other flag with FILTER_STRAY and that it is |
---|
211 | * illegal to not specify either of FILTER_HANDLED or FILTER_SCHEDULE_THREAD |
---|
212 | * if FILTER_STRAY is not specified. |
---|
213 | */ |
---|
214 | #define FILTER_STRAY 0x01 |
---|
215 | #define FILTER_HANDLED 0x02 |
---|
216 | #define FILTER_SCHEDULE_THREAD 0x04 |
---|
217 | |
---|
218 | /** |
---|
219 | * @brief Driver interrupt service routines |
---|
220 | * |
---|
221 | * The filter routine is run in primary interrupt context and may not |
---|
222 | * block or use regular mutexes. It may only use spin mutexes for |
---|
223 | * synchronization. The filter may either completely handle the |
---|
224 | * interrupt or it may perform some of the work and defer more |
---|
225 | * expensive work to the regular interrupt handler. If a filter |
---|
226 | * routine is not registered by the driver, then the regular interrupt |
---|
227 | * handler is always used to handle interrupts from this device. |
---|
228 | * |
---|
229 | * The regular interrupt handler executes in its own thread context |
---|
230 | * and may use regular mutexes. However, it is prohibited from |
---|
231 | * sleeping on a sleep queue. |
---|
232 | */ |
---|
233 | typedef int driver_filter_t(void*); |
---|
234 | typedef void driver_intr_t(void*); |
---|
235 | |
---|
236 | /** |
---|
237 | * @brief Interrupt type bits. |
---|
238 | * |
---|
239 | * These flags are used both by newbus interrupt |
---|
240 | * registration (nexus.c) and also in struct intrec, which defines |
---|
241 | * interrupt properties. |
---|
242 | * |
---|
243 | * XXX We should probably revisit this and remove the vestiges of the |
---|
244 | * spls implicit in names like INTR_TYPE_TTY. In the meantime, don't |
---|
245 | * confuse things by renaming them (Grog, 18 July 2000). |
---|
246 | * |
---|
247 | * Buses which do interrupt remapping will want to change their type |
---|
248 | * to reflect what sort of devices are underneath. |
---|
249 | */ |
---|
250 | enum intr_type { |
---|
251 | INTR_TYPE_TTY = 1, |
---|
252 | INTR_TYPE_BIO = 2, |
---|
253 | INTR_TYPE_NET = 4, |
---|
254 | INTR_TYPE_CAM = 8, |
---|
255 | INTR_TYPE_MISC = 16, |
---|
256 | INTR_TYPE_CLK = 32, |
---|
257 | INTR_TYPE_AV = 64, |
---|
258 | INTR_EXCL = 256, /* exclusive interrupt */ |
---|
259 | INTR_MPSAFE = 512, /* this interrupt is SMP safe */ |
---|
260 | INTR_ENTROPY = 1024, /* this interrupt provides entropy */ |
---|
261 | INTR_MD1 = 4096, /* flag reserved for MD use */ |
---|
262 | INTR_MD2 = 8192, /* flag reserved for MD use */ |
---|
263 | INTR_MD3 = 16384, /* flag reserved for MD use */ |
---|
264 | INTR_MD4 = 32768 /* flag reserved for MD use */ |
---|
265 | }; |
---|
266 | |
---|
267 | enum intr_trigger { |
---|
268 | INTR_TRIGGER_INVALID = -1, |
---|
269 | INTR_TRIGGER_CONFORM = 0, |
---|
270 | INTR_TRIGGER_EDGE = 1, |
---|
271 | INTR_TRIGGER_LEVEL = 2 |
---|
272 | }; |
---|
273 | |
---|
274 | enum intr_polarity { |
---|
275 | INTR_POLARITY_CONFORM = 0, |
---|
276 | INTR_POLARITY_HIGH = 1, |
---|
277 | INTR_POLARITY_LOW = 2 |
---|
278 | }; |
---|
279 | |
---|
280 | /** |
---|
281 | * CPU sets supported by bus_get_cpus(). Note that not all sets may be |
---|
282 | * supported for a given device. If a request is not supported by a |
---|
283 | * device (or its parents), then bus_get_cpus() will fail with EINVAL. |
---|
284 | */ |
---|
285 | enum cpu_sets { |
---|
286 | LOCAL_CPUS = 0, |
---|
287 | INTR_CPUS |
---|
288 | }; |
---|
289 | |
---|
290 | typedef int (*devop_t)(void); |
---|
291 | |
---|
292 | /** |
---|
293 | * @brief This structure is deprecated. |
---|
294 | * |
---|
295 | * Use the kobj(9) macro DEFINE_CLASS to |
---|
296 | * declare classes which implement device drivers. |
---|
297 | */ |
---|
298 | struct driver { |
---|
299 | KOBJ_CLASS_FIELDS; |
---|
300 | }; |
---|
301 | |
---|
302 | /** |
---|
303 | * @brief A resource mapping. |
---|
304 | */ |
---|
305 | struct resource_map { |
---|
306 | bus_space_tag_t r_bustag; |
---|
307 | bus_space_handle_t r_bushandle; |
---|
308 | bus_size_t r_size; |
---|
309 | void *r_vaddr; |
---|
310 | }; |
---|
311 | |
---|
312 | /** |
---|
313 | * @brief Optional properties of a resource mapping request. |
---|
314 | */ |
---|
315 | struct resource_map_request { |
---|
316 | size_t size; |
---|
317 | rman_res_t offset; |
---|
318 | rman_res_t length; |
---|
319 | vm_memattr_t memattr; |
---|
320 | }; |
---|
321 | |
---|
322 | void resource_init_map_request_impl(struct resource_map_request *_args, |
---|
323 | size_t _sz); |
---|
324 | #define resource_init_map_request(rmr) \ |
---|
325 | resource_init_map_request_impl((rmr), sizeof(*(rmr))) |
---|
326 | |
---|
327 | /* |
---|
328 | * Definitions for drivers which need to keep simple lists of resources |
---|
329 | * for their child devices. |
---|
330 | */ |
---|
331 | struct resource; |
---|
332 | |
---|
333 | /** |
---|
334 | * @brief An entry for a single resource in a resource list. |
---|
335 | */ |
---|
336 | struct resource_list_entry { |
---|
337 | STAILQ_ENTRY(resource_list_entry) link; |
---|
338 | int type; /**< @brief type argument to alloc_resource */ |
---|
339 | int rid; /**< @brief resource identifier */ |
---|
340 | int flags; /**< @brief resource flags */ |
---|
341 | struct resource *res; /**< @brief the real resource when allocated */ |
---|
342 | rman_res_t start; /**< @brief start of resource range */ |
---|
343 | rman_res_t end; /**< @brief end of resource range */ |
---|
344 | rman_res_t count; /**< @brief count within range */ |
---|
345 | }; |
---|
346 | STAILQ_HEAD(resource_list, resource_list_entry); |
---|
347 | |
---|
348 | #define RLE_RESERVED 0x0001 /* Reserved by the parent bus. */ |
---|
349 | #define RLE_ALLOCATED 0x0002 /* Reserved resource is allocated. */ |
---|
350 | #define RLE_PREFETCH 0x0004 /* Resource is a prefetch range. */ |
---|
351 | |
---|
352 | void resource_list_init(struct resource_list *rl); |
---|
353 | void resource_list_free(struct resource_list *rl); |
---|
354 | struct resource_list_entry * |
---|
355 | resource_list_add(struct resource_list *rl, |
---|
356 | int type, int rid, |
---|
357 | rman_res_t start, rman_res_t end, rman_res_t count); |
---|
358 | int resource_list_add_next(struct resource_list *rl, |
---|
359 | int type, |
---|
360 | rman_res_t start, rman_res_t end, rman_res_t count); |
---|
361 | int resource_list_busy(struct resource_list *rl, |
---|
362 | int type, int rid); |
---|
363 | int resource_list_reserved(struct resource_list *rl, int type, int rid); |
---|
364 | struct resource_list_entry* |
---|
365 | resource_list_find(struct resource_list *rl, |
---|
366 | int type, int rid); |
---|
367 | void resource_list_delete(struct resource_list *rl, |
---|
368 | int type, int rid); |
---|
369 | struct resource * |
---|
370 | resource_list_alloc(struct resource_list *rl, |
---|
371 | device_t bus, device_t child, |
---|
372 | int type, int *rid, |
---|
373 | rman_res_t start, rman_res_t end, |
---|
374 | rman_res_t count, u_int flags); |
---|
375 | int resource_list_release(struct resource_list *rl, |
---|
376 | device_t bus, device_t child, |
---|
377 | int type, int rid, struct resource *res); |
---|
378 | int resource_list_release_active(struct resource_list *rl, |
---|
379 | device_t bus, device_t child, |
---|
380 | int type); |
---|
381 | struct resource * |
---|
382 | resource_list_reserve(struct resource_list *rl, |
---|
383 | device_t bus, device_t child, |
---|
384 | int type, int *rid, |
---|
385 | rman_res_t start, rman_res_t end, |
---|
386 | rman_res_t count, u_int flags); |
---|
387 | int resource_list_unreserve(struct resource_list *rl, |
---|
388 | device_t bus, device_t child, |
---|
389 | int type, int rid); |
---|
390 | void resource_list_purge(struct resource_list *rl); |
---|
391 | int resource_list_print_type(struct resource_list *rl, |
---|
392 | const char *name, int type, |
---|
393 | const char *format); |
---|
394 | |
---|
395 | /* |
---|
396 | * The root bus, to which all top-level buses are attached. |
---|
397 | */ |
---|
398 | extern device_t root_bus; |
---|
399 | extern devclass_t root_devclass; |
---|
400 | void root_bus_configure(void); |
---|
401 | |
---|
402 | /* |
---|
403 | * Useful functions for implementing buses. |
---|
404 | */ |
---|
405 | |
---|
406 | int bus_generic_activate_resource(device_t dev, device_t child, int type, |
---|
407 | int rid, struct resource *r); |
---|
408 | device_t |
---|
409 | bus_generic_add_child(device_t dev, u_int order, const char *name, |
---|
410 | int unit); |
---|
411 | int bus_generic_adjust_resource(device_t bus, device_t child, int type, |
---|
412 | struct resource *r, rman_res_t start, |
---|
413 | rman_res_t end); |
---|
414 | struct resource * |
---|
415 | bus_generic_alloc_resource(device_t bus, device_t child, int type, |
---|
416 | int *rid, rman_res_t start, rman_res_t end, |
---|
417 | rman_res_t count, u_int flags); |
---|
418 | int bus_generic_attach(device_t dev); |
---|
419 | int bus_generic_bind_intr(device_t dev, device_t child, |
---|
420 | struct resource *irq, int cpu); |
---|
421 | int bus_generic_child_present(device_t dev, device_t child); |
---|
422 | int bus_generic_config_intr(device_t, int, enum intr_trigger, |
---|
423 | enum intr_polarity); |
---|
424 | int bus_generic_describe_intr(device_t dev, device_t child, |
---|
425 | struct resource *irq, void *cookie, |
---|
426 | const char *descr); |
---|
427 | int bus_generic_deactivate_resource(device_t dev, device_t child, int type, |
---|
428 | int rid, struct resource *r); |
---|
429 | int bus_generic_detach(device_t dev); |
---|
430 | void bus_generic_driver_added(device_t dev, driver_t *driver); |
---|
431 | int bus_generic_get_cpus(device_t dev, device_t child, enum cpu_sets op, |
---|
432 | size_t setsize, struct _cpuset *cpuset); |
---|
433 | bus_dma_tag_t |
---|
434 | bus_generic_get_dma_tag(device_t dev, device_t child); |
---|
435 | bus_space_tag_t |
---|
436 | bus_generic_get_bus_tag(device_t dev, device_t child); |
---|
437 | int bus_generic_get_domain(device_t dev, device_t child, int *domain); |
---|
438 | struct resource_list * |
---|
439 | bus_generic_get_resource_list (device_t, device_t); |
---|
440 | int bus_generic_map_resource(device_t dev, device_t child, int type, |
---|
441 | struct resource *r, |
---|
442 | struct resource_map_request *args, |
---|
443 | struct resource_map *map); |
---|
444 | void bus_generic_new_pass(device_t dev); |
---|
445 | int bus_print_child_header(device_t dev, device_t child); |
---|
446 | int bus_print_child_domain(device_t dev, device_t child); |
---|
447 | int bus_print_child_footer(device_t dev, device_t child); |
---|
448 | int bus_generic_print_child(device_t dev, device_t child); |
---|
449 | int bus_generic_probe(device_t dev); |
---|
450 | int bus_generic_read_ivar(device_t dev, device_t child, int which, |
---|
451 | uintptr_t *result); |
---|
452 | int bus_generic_release_resource(device_t bus, device_t child, |
---|
453 | int type, int rid, struct resource *r); |
---|
454 | int bus_generic_resume(device_t dev); |
---|
455 | int bus_generic_resume_child(device_t dev, device_t child); |
---|
456 | int bus_generic_setup_intr(device_t dev, device_t child, |
---|
457 | struct resource *irq, int flags, |
---|
458 | driver_filter_t *filter, driver_intr_t *intr, |
---|
459 | void *arg, void **cookiep); |
---|
460 | |
---|
461 | struct resource * |
---|
462 | bus_generic_rl_alloc_resource (device_t, device_t, int, int *, |
---|
463 | rman_res_t, rman_res_t, rman_res_t, u_int); |
---|
464 | void bus_generic_rl_delete_resource (device_t, device_t, int, int); |
---|
465 | int bus_generic_rl_get_resource (device_t, device_t, int, int, rman_res_t *, |
---|
466 | rman_res_t *); |
---|
467 | int bus_generic_rl_set_resource (device_t, device_t, int, int, rman_res_t, |
---|
468 | rman_res_t); |
---|
469 | int bus_generic_rl_release_resource (device_t, device_t, int, int, |
---|
470 | struct resource *); |
---|
471 | |
---|
472 | int bus_generic_shutdown(device_t dev); |
---|
473 | int bus_generic_suspend(device_t dev); |
---|
474 | int bus_generic_suspend_child(device_t dev, device_t child); |
---|
475 | int bus_generic_teardown_intr(device_t dev, device_t child, |
---|
476 | struct resource *irq, void *cookie); |
---|
477 | int bus_generic_unmap_resource(device_t dev, device_t child, int type, |
---|
478 | struct resource *r, |
---|
479 | struct resource_map *map); |
---|
480 | int bus_generic_write_ivar(device_t dev, device_t child, int which, |
---|
481 | uintptr_t value); |
---|
482 | int bus_null_rescan(device_t dev); |
---|
483 | |
---|
484 | /* |
---|
485 | * Wrapper functions for the BUS_*_RESOURCE methods to make client code |
---|
486 | * a little simpler. |
---|
487 | */ |
---|
488 | |
---|
489 | struct resource_spec { |
---|
490 | int type; |
---|
491 | int rid; |
---|
492 | int flags; |
---|
493 | }; |
---|
494 | |
---|
495 | int bus_alloc_resources(device_t dev, struct resource_spec *rs, |
---|
496 | struct resource **res); |
---|
497 | void bus_release_resources(device_t dev, const struct resource_spec *rs, |
---|
498 | struct resource **res); |
---|
499 | |
---|
500 | int bus_adjust_resource(device_t child, int type, struct resource *r, |
---|
501 | rman_res_t start, rman_res_t end); |
---|
502 | struct resource *bus_alloc_resource(device_t dev, int type, int *rid, |
---|
503 | rman_res_t start, rman_res_t end, |
---|
504 | rman_res_t count, u_int flags); |
---|
505 | int bus_activate_resource(device_t dev, int type, int rid, |
---|
506 | struct resource *r); |
---|
507 | int bus_deactivate_resource(device_t dev, int type, int rid, |
---|
508 | struct resource *r); |
---|
509 | int bus_map_resource(device_t dev, int type, struct resource *r, |
---|
510 | struct resource_map_request *args, |
---|
511 | struct resource_map *map); |
---|
512 | int bus_unmap_resource(device_t dev, int type, struct resource *r, |
---|
513 | struct resource_map *map); |
---|
514 | int bus_get_cpus(device_t dev, enum cpu_sets op, size_t setsize, |
---|
515 | struct _cpuset *cpuset); |
---|
516 | bus_dma_tag_t bus_get_dma_tag(device_t dev); |
---|
517 | bus_space_tag_t bus_get_bus_tag(device_t dev); |
---|
518 | int bus_get_domain(device_t dev, int *domain); |
---|
519 | int bus_release_resource(device_t dev, int type, int rid, |
---|
520 | struct resource *r); |
---|
521 | int bus_free_resource(device_t dev, int type, struct resource *r); |
---|
522 | int bus_setup_intr(device_t dev, struct resource *r, int flags, |
---|
523 | driver_filter_t filter, driver_intr_t handler, |
---|
524 | void *arg, void **cookiep); |
---|
525 | int bus_teardown_intr(device_t dev, struct resource *r, void *cookie); |
---|
526 | int bus_bind_intr(device_t dev, struct resource *r, int cpu); |
---|
527 | int bus_describe_intr(device_t dev, struct resource *irq, void *cookie, |
---|
528 | const char *fmt, ...) __printflike(4, 5); |
---|
529 | int bus_set_resource(device_t dev, int type, int rid, |
---|
530 | rman_res_t start, rman_res_t count); |
---|
531 | int bus_get_resource(device_t dev, int type, int rid, |
---|
532 | rman_res_t *startp, rman_res_t *countp); |
---|
533 | rman_res_t bus_get_resource_start(device_t dev, int type, int rid); |
---|
534 | rman_res_t bus_get_resource_count(device_t dev, int type, int rid); |
---|
535 | void bus_delete_resource(device_t dev, int type, int rid); |
---|
536 | int bus_child_present(device_t child); |
---|
537 | int bus_child_pnpinfo_str(device_t child, char *buf, size_t buflen); |
---|
538 | int bus_child_location_str(device_t child, char *buf, size_t buflen); |
---|
539 | void bus_enumerate_hinted_children(device_t bus); |
---|
540 | |
---|
541 | static __inline struct resource * |
---|
542 | bus_alloc_resource_any(device_t dev, int type, int *rid, u_int flags) |
---|
543 | { |
---|
544 | return (bus_alloc_resource(dev, type, rid, 0, ~0, 1, flags)); |
---|
545 | } |
---|
546 | |
---|
547 | static __inline struct resource * |
---|
548 | bus_alloc_resource_anywhere(device_t dev, int type, int *rid, |
---|
549 | rman_res_t count, u_int flags) |
---|
550 | { |
---|
551 | return (bus_alloc_resource(dev, type, rid, 0, ~0, count, flags)); |
---|
552 | } |
---|
553 | |
---|
554 | /* |
---|
555 | * Access functions for device. |
---|
556 | */ |
---|
557 | device_t device_add_child(device_t dev, const char *name, int unit); |
---|
558 | device_t device_add_child_ordered(device_t dev, u_int order, |
---|
559 | const char *name, int unit); |
---|
560 | void device_busy(device_t dev); |
---|
561 | int device_delete_child(device_t dev, device_t child); |
---|
562 | int device_delete_children(device_t dev); |
---|
563 | int device_attach(device_t dev); |
---|
564 | int device_detach(device_t dev); |
---|
565 | void device_disable(device_t dev); |
---|
566 | void device_enable(device_t dev); |
---|
567 | device_t device_find_child(device_t dev, const char *classname, |
---|
568 | int unit); |
---|
569 | const char *device_get_desc(device_t dev); |
---|
570 | devclass_t device_get_devclass(device_t dev); |
---|
571 | driver_t *device_get_driver(device_t dev); |
---|
572 | u_int32_t device_get_flags(device_t dev); |
---|
573 | device_t device_get_parent(device_t dev); |
---|
574 | int device_get_children(device_t dev, device_t **listp, int *countp); |
---|
575 | void *device_get_ivars(device_t dev); |
---|
576 | void device_set_ivars(device_t dev, void *ivars); |
---|
577 | const char *device_get_name(device_t dev); |
---|
578 | const char *device_get_nameunit(device_t dev); |
---|
579 | void *device_get_softc(device_t dev); |
---|
580 | device_state_t device_get_state(device_t dev); |
---|
581 | int device_get_unit(device_t dev); |
---|
582 | struct sysctl_ctx_list *device_get_sysctl_ctx(device_t dev); |
---|
583 | struct sysctl_oid *device_get_sysctl_tree(device_t dev); |
---|
584 | int device_is_alive(device_t dev); /* did probe succeed? */ |
---|
585 | int device_is_attached(device_t dev); /* did attach succeed? */ |
---|
586 | int device_is_enabled(device_t dev); |
---|
587 | int device_is_suspended(device_t dev); |
---|
588 | int device_is_quiet(device_t dev); |
---|
589 | device_t device_lookup_by_name(const char *name); |
---|
590 | int device_print_prettyname(device_t dev); |
---|
591 | int device_printf(device_t dev, const char *, ...) __printflike(2, 3); |
---|
592 | int device_probe(device_t dev); |
---|
593 | int device_probe_and_attach(device_t dev); |
---|
594 | int device_probe_child(device_t bus, device_t dev); |
---|
595 | int device_quiesce(device_t dev); |
---|
596 | void device_quiet(device_t dev); |
---|
597 | void device_set_desc(device_t dev, const char* desc); |
---|
598 | void device_set_desc_copy(device_t dev, const char* desc); |
---|
599 | int device_set_devclass(device_t dev, const char *classname); |
---|
600 | int device_set_devclass_fixed(device_t dev, const char *classname); |
---|
601 | int device_set_driver(device_t dev, driver_t *driver); |
---|
602 | void device_set_flags(device_t dev, u_int32_t flags); |
---|
603 | void device_set_softc(device_t dev, void *softc); |
---|
604 | void device_free_softc(void *softc); |
---|
605 | void device_claim_softc(device_t dev); |
---|
606 | int device_set_unit(device_t dev, int unit); /* XXX DONT USE XXX */ |
---|
607 | int device_shutdown(device_t dev); |
---|
608 | void device_unbusy(device_t dev); |
---|
609 | void device_verbose(device_t dev); |
---|
610 | |
---|
611 | /* |
---|
612 | * Access functions for devclass. |
---|
613 | */ |
---|
614 | int devclass_add_driver(devclass_t dc, driver_t *driver, |
---|
615 | int pass, devclass_t *dcp); |
---|
616 | devclass_t devclass_create(const char *classname); |
---|
617 | int devclass_delete_driver(devclass_t busclass, driver_t *driver); |
---|
618 | devclass_t devclass_find(const char *classname); |
---|
619 | const char *devclass_get_name(devclass_t dc); |
---|
620 | device_t devclass_get_device(devclass_t dc, int unit); |
---|
621 | void *devclass_get_softc(devclass_t dc, int unit); |
---|
622 | int devclass_get_devices(devclass_t dc, device_t **listp, int *countp); |
---|
623 | int devclass_get_drivers(devclass_t dc, driver_t ***listp, int *countp); |
---|
624 | int devclass_get_count(devclass_t dc); |
---|
625 | int devclass_get_maxunit(devclass_t dc); |
---|
626 | int devclass_find_free_unit(devclass_t dc, int unit); |
---|
627 | void devclass_set_parent(devclass_t dc, devclass_t pdc); |
---|
628 | devclass_t devclass_get_parent(devclass_t dc); |
---|
629 | struct sysctl_ctx_list *devclass_get_sysctl_ctx(devclass_t dc); |
---|
630 | struct sysctl_oid *devclass_get_sysctl_tree(devclass_t dc); |
---|
631 | |
---|
632 | /* |
---|
633 | * Access functions for device resources. |
---|
634 | */ |
---|
635 | |
---|
636 | int resource_int_value(const char *name, int unit, const char *resname, |
---|
637 | int *result); |
---|
638 | int resource_long_value(const char *name, int unit, const char *resname, |
---|
639 | long *result); |
---|
640 | int resource_string_value(const char *name, int unit, const char *resname, |
---|
641 | const char **result); |
---|
642 | int resource_disabled(const char *name, int unit); |
---|
643 | int resource_find_match(int *anchor, const char **name, int *unit, |
---|
644 | const char *resname, const char *value); |
---|
645 | int resource_find_dev(int *anchor, const char *name, int *unit, |
---|
646 | const char *resname, const char *value); |
---|
647 | int resource_set_int(const char *name, int unit, const char *resname, |
---|
648 | int value); |
---|
649 | int resource_set_long(const char *name, int unit, const char *resname, |
---|
650 | long value); |
---|
651 | int resource_set_string(const char *name, int unit, const char *resname, |
---|
652 | const char *value); |
---|
653 | int resource_unset_value(const char *name, int unit, const char *resname); |
---|
654 | |
---|
655 | /* |
---|
656 | * Functions for maintaining and checking consistency of |
---|
657 | * bus information exported to userspace. |
---|
658 | */ |
---|
659 | int bus_data_generation_check(int generation); |
---|
660 | void bus_data_generation_update(void); |
---|
661 | |
---|
662 | /** |
---|
663 | * Some convenience defines for probe routines to return. These are just |
---|
664 | * suggested values, and there's nothing magical about them. |
---|
665 | * BUS_PROBE_SPECIFIC is for devices that cannot be reprobed, and that no |
---|
666 | * possible other driver may exist (typically legacy drivers who don't follow |
---|
667 | * all the rules, or special needs drivers). BUS_PROBE_VENDOR is the |
---|
668 | * suggested value that vendor supplied drivers use. This is for source or |
---|
669 | * binary drivers that are not yet integrated into the FreeBSD tree. Its use |
---|
670 | * in the base OS is prohibited. BUS_PROBE_DEFAULT is the normal return value |
---|
671 | * for drivers to use. It is intended that nearly all of the drivers in the |
---|
672 | * tree should return this value. BUS_PROBE_LOW_PRIORITY are for drivers that |
---|
673 | * have special requirements like when there are two drivers that support |
---|
674 | * overlapping series of hardware devices. In this case the one that supports |
---|
675 | * the older part of the line would return this value, while the one that |
---|
676 | * supports the newer ones would return BUS_PROBE_DEFAULT. BUS_PROBE_GENERIC |
---|
677 | * is for drivers that wish to have a generic form and a specialized form, |
---|
678 | * like is done with the pci bus and the acpi pci bus. BUS_PROBE_HOOVER is |
---|
679 | * for those buses that implement a generic device placeholder for devices on |
---|
680 | * the bus that have no more specific driver for them (aka ugen). |
---|
681 | * BUS_PROBE_NOWILDCARD or lower means that the device isn't really bidding |
---|
682 | * for a device node, but accepts only devices that its parent has told it |
---|
683 | * use this driver. |
---|
684 | */ |
---|
685 | #define BUS_PROBE_SPECIFIC 0 /* Only I can use this device */ |
---|
686 | #define BUS_PROBE_VENDOR (-10) /* Vendor supplied driver */ |
---|
687 | #define BUS_PROBE_DEFAULT (-20) /* Base OS default driver */ |
---|
688 | #define BUS_PROBE_LOW_PRIORITY (-40) /* Older, less desirable drivers */ |
---|
689 | #define BUS_PROBE_GENERIC (-100) /* generic driver for dev */ |
---|
690 | #define BUS_PROBE_HOOVER (-1000000) /* Driver for any dev on bus */ |
---|
691 | #define BUS_PROBE_NOWILDCARD (-2000000000) /* No wildcard device matches */ |
---|
692 | |
---|
693 | /** |
---|
694 | * During boot, the device tree is scanned multiple times. Each scan, |
---|
695 | * or pass, drivers may be attached to devices. Each driver |
---|
696 | * attachment is assigned a pass number. Drivers may only probe and |
---|
697 | * attach to devices if their pass number is less than or equal to the |
---|
698 | * current system-wide pass number. The default pass is the last pass |
---|
699 | * and is used by most drivers. Drivers needed by the scheduler are |
---|
700 | * probed in earlier passes. |
---|
701 | */ |
---|
702 | #define BUS_PASS_ROOT 0 /* Used to attach root0. */ |
---|
703 | #define BUS_PASS_BUS 10 /* Buses and bridges. */ |
---|
704 | #define BUS_PASS_CPU 20 /* CPU devices. */ |
---|
705 | #define BUS_PASS_RESOURCE 30 /* Resource discovery. */ |
---|
706 | #define BUS_PASS_INTERRUPT 40 /* Interrupt controllers. */ |
---|
707 | #define BUS_PASS_TIMER 50 /* Timers and clocks. */ |
---|
708 | #define BUS_PASS_SCHEDULER 60 /* Start scheduler. */ |
---|
709 | #define BUS_PASS_DEFAULT __INT_MAX /* Everything else. */ |
---|
710 | |
---|
711 | #define BUS_PASS_ORDER_FIRST 0 |
---|
712 | #define BUS_PASS_ORDER_EARLY 2 |
---|
713 | #define BUS_PASS_ORDER_MIDDLE 5 |
---|
714 | #define BUS_PASS_ORDER_LATE 7 |
---|
715 | #define BUS_PASS_ORDER_LAST 9 |
---|
716 | |
---|
717 | extern int bus_current_pass; |
---|
718 | |
---|
719 | void bus_set_pass(int pass); |
---|
720 | |
---|
721 | /** |
---|
722 | * Shorthands for constructing method tables. |
---|
723 | */ |
---|
724 | #define DEVMETHOD KOBJMETHOD |
---|
725 | #define DEVMETHOD_END KOBJMETHOD_END |
---|
726 | |
---|
727 | /* |
---|
728 | * Some common device interfaces. |
---|
729 | */ |
---|
730 | #include <rtems/bsd/local/device_if.h> |
---|
731 | #include <rtems/bsd/local/bus_if.h> |
---|
732 | |
---|
733 | struct module; |
---|
734 | |
---|
735 | int driver_module_handler(struct module *, int, void *); |
---|
736 | |
---|
737 | /** |
---|
738 | * Module support for automatically adding drivers to buses. |
---|
739 | */ |
---|
740 | struct driver_module_data { |
---|
741 | int (*dmd_chainevh)(struct module *, int, void *); |
---|
742 | void *dmd_chainarg; |
---|
743 | const char *dmd_busname; |
---|
744 | kobj_class_t dmd_driver; |
---|
745 | devclass_t *dmd_devclass; |
---|
746 | int dmd_pass; |
---|
747 | }; |
---|
748 | |
---|
749 | #define EARLY_DRIVER_MODULE_ORDERED(name, busname, driver, devclass, \ |
---|
750 | evh, arg, order, pass) \ |
---|
751 | \ |
---|
752 | static struct driver_module_data name##_##busname##_driver_mod = { \ |
---|
753 | evh, arg, \ |
---|
754 | #busname, \ |
---|
755 | (kobj_class_t) &driver, \ |
---|
756 | &devclass, \ |
---|
757 | pass \ |
---|
758 | }; \ |
---|
759 | \ |
---|
760 | static moduledata_t name##_##busname##_mod = { \ |
---|
761 | #busname "/" #name, \ |
---|
762 | driver_module_handler, \ |
---|
763 | &name##_##busname##_driver_mod \ |
---|
764 | }; \ |
---|
765 | DECLARE_MODULE(name##_##busname, name##_##busname##_mod, \ |
---|
766 | SI_SUB_DRIVERS, order) |
---|
767 | |
---|
768 | #define EARLY_DRIVER_MODULE(name, busname, driver, devclass, evh, arg, pass) \ |
---|
769 | EARLY_DRIVER_MODULE_ORDERED(name, busname, driver, devclass, \ |
---|
770 | evh, arg, SI_ORDER_MIDDLE, pass) |
---|
771 | |
---|
772 | #define DRIVER_MODULE_ORDERED(name, busname, driver, devclass, evh, arg,\ |
---|
773 | order) \ |
---|
774 | EARLY_DRIVER_MODULE_ORDERED(name, busname, driver, devclass, \ |
---|
775 | evh, arg, order, BUS_PASS_DEFAULT) |
---|
776 | |
---|
777 | #define DRIVER_MODULE(name, busname, driver, devclass, evh, arg) \ |
---|
778 | EARLY_DRIVER_MODULE(name, busname, driver, devclass, evh, arg, \ |
---|
779 | BUS_PASS_DEFAULT) |
---|
780 | |
---|
781 | /** |
---|
782 | * Generic ivar accessor generation macros for bus drivers |
---|
783 | */ |
---|
784 | #ifndef __rtems__ |
---|
785 | #define __BUS_ACCESSOR(varp, var, ivarp, ivar, type) \ |
---|
786 | \ |
---|
787 | static __inline type varp ## _get_ ## var(device_t dev) \ |
---|
788 | { \ |
---|
789 | uintptr_t v; \ |
---|
790 | BUS_READ_IVAR(device_get_parent(dev), dev, \ |
---|
791 | ivarp ## _IVAR_ ## ivar, &v); \ |
---|
792 | return ((type) v); \ |
---|
793 | } \ |
---|
794 | \ |
---|
795 | static __inline void varp ## _set_ ## var(device_t dev, type t) \ |
---|
796 | { \ |
---|
797 | uintptr_t v = (uintptr_t) t; \ |
---|
798 | BUS_WRITE_IVAR(device_get_parent(dev), dev, \ |
---|
799 | ivarp ## _IVAR_ ## ivar, v); \ |
---|
800 | } |
---|
801 | #else /* __rtems__ */ |
---|
802 | #define __BUS_ACCESSOR(varp, var, ivarp, ivar, type) \ |
---|
803 | \ |
---|
804 | static __inline type varp ## _get_ ## var(device_t dev) \ |
---|
805 | { \ |
---|
806 | uintptr_t v; \ |
---|
807 | int err; \ |
---|
808 | err = BUS_READ_IVAR(device_get_parent(dev), dev, \ |
---|
809 | ivarp ## _IVAR_ ## ivar, &v); \ |
---|
810 | BSD_ASSERT(err == 0); \ |
---|
811 | return ((type) v); \ |
---|
812 | } \ |
---|
813 | \ |
---|
814 | static __inline void varp ## _set_ ## var(device_t dev, type t) \ |
---|
815 | { \ |
---|
816 | uintptr_t v = (uintptr_t) t; \ |
---|
817 | BUS_WRITE_IVAR(device_get_parent(dev), dev, \ |
---|
818 | ivarp ## _IVAR_ ## ivar, v); \ |
---|
819 | } |
---|
820 | #endif /* __rtems__ */ |
---|
821 | |
---|
822 | /** |
---|
823 | * Shorthand macros, taking resource argument |
---|
824 | * Generated with sys/tools/bus_macro.sh |
---|
825 | */ |
---|
826 | |
---|
827 | #define bus_barrier(r, o, l, f) \ |
---|
828 | bus_space_barrier((r)->r_bustag, (r)->r_bushandle, (o), (l), (f)) |
---|
829 | #define bus_read_1(r, o) \ |
---|
830 | bus_space_read_1((r)->r_bustag, (r)->r_bushandle, (o)) |
---|
831 | #define bus_read_multi_1(r, o, d, c) \ |
---|
832 | bus_space_read_multi_1((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
833 | #define bus_read_region_1(r, o, d, c) \ |
---|
834 | bus_space_read_region_1((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
835 | #define bus_set_multi_1(r, o, v, c) \ |
---|
836 | bus_space_set_multi_1((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
837 | #define bus_set_region_1(r, o, v, c) \ |
---|
838 | bus_space_set_region_1((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
839 | #define bus_write_1(r, o, v) \ |
---|
840 | bus_space_write_1((r)->r_bustag, (r)->r_bushandle, (o), (v)) |
---|
841 | #define bus_write_multi_1(r, o, d, c) \ |
---|
842 | bus_space_write_multi_1((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
843 | #define bus_write_region_1(r, o, d, c) \ |
---|
844 | bus_space_write_region_1((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
845 | #define bus_read_stream_1(r, o) \ |
---|
846 | bus_space_read_stream_1((r)->r_bustag, (r)->r_bushandle, (o)) |
---|
847 | #define bus_read_multi_stream_1(r, o, d, c) \ |
---|
848 | bus_space_read_multi_stream_1((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
849 | #define bus_read_region_stream_1(r, o, d, c) \ |
---|
850 | bus_space_read_region_stream_1((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
851 | #define bus_set_multi_stream_1(r, o, v, c) \ |
---|
852 | bus_space_set_multi_stream_1((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
853 | #define bus_set_region_stream_1(r, o, v, c) \ |
---|
854 | bus_space_set_region_stream_1((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
855 | #define bus_write_stream_1(r, o, v) \ |
---|
856 | bus_space_write_stream_1((r)->r_bustag, (r)->r_bushandle, (o), (v)) |
---|
857 | #define bus_write_multi_stream_1(r, o, d, c) \ |
---|
858 | bus_space_write_multi_stream_1((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
859 | #define bus_write_region_stream_1(r, o, d, c) \ |
---|
860 | bus_space_write_region_stream_1((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
861 | #define bus_read_2(r, o) \ |
---|
862 | bus_space_read_2((r)->r_bustag, (r)->r_bushandle, (o)) |
---|
863 | #define bus_read_multi_2(r, o, d, c) \ |
---|
864 | bus_space_read_multi_2((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
865 | #define bus_read_region_2(r, o, d, c) \ |
---|
866 | bus_space_read_region_2((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
867 | #define bus_set_multi_2(r, o, v, c) \ |
---|
868 | bus_space_set_multi_2((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
869 | #define bus_set_region_2(r, o, v, c) \ |
---|
870 | bus_space_set_region_2((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
871 | #define bus_write_2(r, o, v) \ |
---|
872 | bus_space_write_2((r)->r_bustag, (r)->r_bushandle, (o), (v)) |
---|
873 | #define bus_write_multi_2(r, o, d, c) \ |
---|
874 | bus_space_write_multi_2((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
875 | #define bus_write_region_2(r, o, d, c) \ |
---|
876 | bus_space_write_region_2((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
877 | #define bus_read_stream_2(r, o) \ |
---|
878 | bus_space_read_stream_2((r)->r_bustag, (r)->r_bushandle, (o)) |
---|
879 | #define bus_read_multi_stream_2(r, o, d, c) \ |
---|
880 | bus_space_read_multi_stream_2((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
881 | #define bus_read_region_stream_2(r, o, d, c) \ |
---|
882 | bus_space_read_region_stream_2((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
883 | #define bus_set_multi_stream_2(r, o, v, c) \ |
---|
884 | bus_space_set_multi_stream_2((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
885 | #define bus_set_region_stream_2(r, o, v, c) \ |
---|
886 | bus_space_set_region_stream_2((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
887 | #define bus_write_stream_2(r, o, v) \ |
---|
888 | bus_space_write_stream_2((r)->r_bustag, (r)->r_bushandle, (o), (v)) |
---|
889 | #define bus_write_multi_stream_2(r, o, d, c) \ |
---|
890 | bus_space_write_multi_stream_2((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
891 | #define bus_write_region_stream_2(r, o, d, c) \ |
---|
892 | bus_space_write_region_stream_2((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
893 | #define bus_read_4(r, o) \ |
---|
894 | bus_space_read_4((r)->r_bustag, (r)->r_bushandle, (o)) |
---|
895 | #define bus_read_multi_4(r, o, d, c) \ |
---|
896 | bus_space_read_multi_4((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
897 | #define bus_read_region_4(r, o, d, c) \ |
---|
898 | bus_space_read_region_4((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
899 | #define bus_set_multi_4(r, o, v, c) \ |
---|
900 | bus_space_set_multi_4((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
901 | #define bus_set_region_4(r, o, v, c) \ |
---|
902 | bus_space_set_region_4((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
903 | #define bus_write_4(r, o, v) \ |
---|
904 | bus_space_write_4((r)->r_bustag, (r)->r_bushandle, (o), (v)) |
---|
905 | #define bus_write_multi_4(r, o, d, c) \ |
---|
906 | bus_space_write_multi_4((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
907 | #define bus_write_region_4(r, o, d, c) \ |
---|
908 | bus_space_write_region_4((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
909 | #define bus_read_stream_4(r, o) \ |
---|
910 | bus_space_read_stream_4((r)->r_bustag, (r)->r_bushandle, (o)) |
---|
911 | #define bus_read_multi_stream_4(r, o, d, c) \ |
---|
912 | bus_space_read_multi_stream_4((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
913 | #define bus_read_region_stream_4(r, o, d, c) \ |
---|
914 | bus_space_read_region_stream_4((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
915 | #define bus_set_multi_stream_4(r, o, v, c) \ |
---|
916 | bus_space_set_multi_stream_4((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
917 | #define bus_set_region_stream_4(r, o, v, c) \ |
---|
918 | bus_space_set_region_stream_4((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
919 | #define bus_write_stream_4(r, o, v) \ |
---|
920 | bus_space_write_stream_4((r)->r_bustag, (r)->r_bushandle, (o), (v)) |
---|
921 | #define bus_write_multi_stream_4(r, o, d, c) \ |
---|
922 | bus_space_write_multi_stream_4((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
923 | #define bus_write_region_stream_4(r, o, d, c) \ |
---|
924 | bus_space_write_region_stream_4((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
925 | #define bus_read_8(r, o) \ |
---|
926 | bus_space_read_8((r)->r_bustag, (r)->r_bushandle, (o)) |
---|
927 | #define bus_read_multi_8(r, o, d, c) \ |
---|
928 | bus_space_read_multi_8((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
929 | #define bus_read_region_8(r, o, d, c) \ |
---|
930 | bus_space_read_region_8((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
931 | #define bus_set_multi_8(r, o, v, c) \ |
---|
932 | bus_space_set_multi_8((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
933 | #define bus_set_region_8(r, o, v, c) \ |
---|
934 | bus_space_set_region_8((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
935 | #define bus_write_8(r, o, v) \ |
---|
936 | bus_space_write_8((r)->r_bustag, (r)->r_bushandle, (o), (v)) |
---|
937 | #define bus_write_multi_8(r, o, d, c) \ |
---|
938 | bus_space_write_multi_8((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
939 | #define bus_write_region_8(r, o, d, c) \ |
---|
940 | bus_space_write_region_8((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
941 | #define bus_read_stream_8(r, o) \ |
---|
942 | bus_space_read_stream_8((r)->r_bustag, (r)->r_bushandle, (o)) |
---|
943 | #define bus_read_multi_stream_8(r, o, d, c) \ |
---|
944 | bus_space_read_multi_stream_8((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
945 | #define bus_read_region_stream_8(r, o, d, c) \ |
---|
946 | bus_space_read_region_stream_8((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
947 | #define bus_set_multi_stream_8(r, o, v, c) \ |
---|
948 | bus_space_set_multi_stream_8((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
949 | #define bus_set_region_stream_8(r, o, v, c) \ |
---|
950 | bus_space_set_region_stream_8((r)->r_bustag, (r)->r_bushandle, (o), (v), (c)) |
---|
951 | #define bus_write_stream_8(r, o, v) \ |
---|
952 | bus_space_write_stream_8((r)->r_bustag, (r)->r_bushandle, (o), (v)) |
---|
953 | #define bus_write_multi_stream_8(r, o, d, c) \ |
---|
954 | bus_space_write_multi_stream_8((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
955 | #define bus_write_region_stream_8(r, o, d, c) \ |
---|
956 | bus_space_write_region_stream_8((r)->r_bustag, (r)->r_bushandle, (o), (d), (c)) |
---|
957 | #endif /* _KERNEL */ |
---|
958 | |
---|
959 | #endif /* !_SYS_BUS_H_ */ |
---|