1 /* $NetBSD: fw_port.h,v 1.30 2008/06/24 10:12:42 gmcgarry Exp $ */
2 /*
3 * Copyright (c) 2004 KIYOHARA Takashi
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
19 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
21 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
23 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
24 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25 * POSSIBILITY OF SUCH DAMAGE.
26 *
27 */
28
29 #ifndef _FW_PORT_H
30 #define _FW_PORT_H
31
32 #ifdef _KERNEL
33
34 #if defined(__FreeBSD__)
35 #ifdef __DragonFly__
36 #define OS_STR "DragonFly"
37 #define OS_VER __DragonFly_cc_version
38 #define OS_VER_STR "DragonFly-1"
39 #define PROJECT_STR "DragonFly Project"
40 #else
41 #define OS_STR "FreeBSD"
42 #define OS_VER __FreeBSD_version
43 #define OS_VER_STR "FreeBSD-5"
44 #define PROJECT_STR "FreeBSD Project"
45 #endif
46
47 #if defined(__DragonFly__) || __FreeBSD_version < 500000
48 #define fw_dev_t dev_t
49 #else
50 #define fw_dev_t struct cdev *
51 #endif
52
53 #if defined(__DragonFly__) || __FreeBSD_version < 500000
54 #define fw_dev2unit(x) ((minor(x) & 0xff) | (minor(x) >> 8))
55 #define fw_unit2minor(x) (((x) & 0xff) | (((x) << 8) & ~0xffff))
56 #else
57 #define fw_dev2unit(x) dev2unit(x)
58 #define fw_unit2minor(x) unit2minor(x)
59 #endif
60
61 #define fw_timevalcmp(tv1, tv2, op) timevalcmp((tv1), (tv2), op)
62 #define fw_timevalsub(tv1, tv2) timevalsub((tv1), (tv2))
63
64 #define fw_get_nameunit(dev) device_get_nameunit((dev))
65 #define fw_get_unit(dev) device_get_unit((dev))
66
67 #define fw_printf(dev, ...) device_printf((dev), __VA_ARGS__)
68
69 /* atomic macros */
70 #define fw_atomic_set_int(P, V) atomic_set_int((P), (V))
71 #define fw_atomic_readandclear_int(p) atomic_readandclear_int((p))
72
73 /* mutex macros */
74 #include <sys/mutex.h>
75 typedef struct mtx fw_mtx_t;
76 #define fw_mtx_init(mutex, name, type, opts) \
77 mtx_init(mutex, name, type, opts)
78 #define fw_mtx_lock(mutex) mtx_lock(mutex)
79 #define fw_mtx_unlock(mutex) mtx_unlock(mutex)
80 #define fw_mtx_destroy(mutex) mtx_destroy(mutex)
81 #define fw_mtx_assert(mutex, what) \
82 mtx_assert(mutex, what)
83
84 #define fw_msleep(ident, mtx, priority, wmesg, timo) \
85 msleep(ident, mtx, priority, wmesg, timo);
86
87 /* taskqueue macros */
88 #include <sys/taskqueue.h>
89 typedef struct task fw_task_t;
90 #define FW_TASK_INIT(task, priority, func, context) \
91 TASK_INIT((task), (priority), (func), (context))
92 #define fw_taskqueue_enqueue(queue, task) \
93 taskqueue_enqueue((queue), (task))
94 #define fw_taskqueue_create_fast(name, mflags, enqueue, taskqueue) \
95 taskqueue_create_fast((name), (mflags), (enqueue), (taskqueue))
96 #define fw_taskqueue_start_threads(taskqueue, n, x, fmt, ...) \
97 taskqueue_start_threads((taskqueue), (n), (x), (fmt), ...)
98
99 /* kthread macros */
100 #ifdef __DragonFly__
101 typedef d_thread_t fw_thread_t;
102 typedef d_thread_t fw_proc_t;
103 #define fw_kthread_create(func, arg, newpp, fmt, ...) \
104 kthread_create(func, arg, newpp, fmt, __VA_ARGS__)
105 #define fw_kthread_exit(x) kthread_exit()
106 #elif __FreeBSD_version >= 500000
107 typedef struct thread fw_thread_t;
108 typedef struct thread fw_proc_t;
109 #define fw_kthread_create(func, arg, newpp, fmt, ...) \
110 kthread_create(func, arg, newpp, 0, 0, fmt, __VA_ARGS__)
111 #define fw_kthread_exit(ecode) kthread_exit((ecode))
112 #else
113 typedef struct proc fw_thread_t;
114 typedef struct proc fw_proc_t;
115 #define fw_kthread_create(func, arg, newpp, fmt, ...) \
116 kproc_create(func, arg, newpp, fmt, __VA_ARGS__)
117 #define fw_kthread_exit(ecode) kproc_exit((ecode))
118 #endif
119
120 /* callout macros */
121 #if defined(__DragonFly__) || __FreeBSD_version < 500000
122 #define fw_callout_init(c) callout_init((c), 0)
123 #else
124 #define fw_callout_init(c) callout_init(c, 1 /* mpsafe */)
125 #endif
126 #define fw_callout_reset(c, ticks, func, arg) \
127 callout_reset((c), (ticks), (func), (arg))
128 #define fw_callout_stop(c) callout_stop((c))
129
130 /* bus_dma macros */
131 typedef bus_dma_tag_t fw_bus_dma_tag_t;
132 #if defined(__FreeBSD__) && __FreeBSD_version >= 501102
133 #define fw_bus_dma_tag_create(t, \
134 a, b, laddr, haddr, ffunc, farg, s, ns, mxss, f, lfunc, larg, tp)\
135 bus_dma_tag_create((t), (a), (b), (laddr), (haddr), \
136 (ffunc), (farg), (s), (ns), (mxss), (f), (lfunc), (larg), (tp))
137 #else
138 #define fw_bus_dma_tag_create(t, a, b, \
139 laddr, haddr, ffunc, farg, s, ns, mxss, f, lfunc, larg, tp) \
140 bus_dma_tag_create((t), (a), (b), (laddr), (haddr), \
141 (ffunc), (farg), (s), (ns), (mxss), (f), (tp))
142 #endif
143 #define fw_bus_dma_tag_destroy(t) \
144 bus_dma_tag_destroy((t))
145 #define fw_bus_dmamap_create(t, f, mp) \
146 bus_dmamap_create((t), 0, (mp))
147 #define fw_bus_dmamap_destroy((t), (m)) \
148 bus_dmamap_destroy((t), (m))
149 #define fw_bus_dmamap_load(t, m, b, l, func, a, f) \
150 bus_dmamap_load((t), (m), (b), (l), (func), (a), 0)
151 #define fw_bus_dmamap_load_mbuf(t, m, b, func, a, f) \
152 bus_dmamap_load((t), (m), (b), (func), (a), 0)
153 #define fw_bus_dmamap_unload(t, m) \
154 bus_dmamap_unload((t), (m))
155 #if __FreeBSD_version < 500000
156 #define fw_bus_dmamap_sync(t, m, op) \
157 do { \
158 switch ((op)) { \
159 (BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE): \
160 bus_dmamap_sync((t), (m), BUS_DMASYNC_PREWRITE);\
161 bus_dmamap_sync((t), (m), BUS_DMASYNC_PREREAD); \
162 break; \
163 (BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE): \
164 /* BUS_DMASYNC_POSTWRITE is probably a no-op. */\
165 bus_dmamap_sync((t), (m), BUS_DMASYNC_POSTREAD);\
166 break; \
167 default: \
168 bus_dmamap_sync((t), (m), (op)); \
169 } \
170 } while (/*CONSTCOND*/0)
171 #else
172 #define fw_bus_dmamap_sync(t, m, op) \
173 bus_dmamap_sync((t), (m), (op))
174 #endif
175 #define fw_bus_dmamem_alloc(t, vp, f, mp) \
176 bus_dmamem_alloc((t), (vp), (f), (mp))
177 #define fw_bus_dmamem_free(t, v, m) \
178 bus_dmamem_free((t), (v), (m))
179
180
181 #define fw_config_pending_incr()
182 #define fw_config_pending_decr()
183
184 #define splfw() splimp()
185 #define splfwnet() splimp()
186 #define splfwsbp() splcam()
187
188 #ifdef __DragonFly__
189 #include <sys/select.h>
190 #elif __FreeBSD_version >= 500000
191 #include <sys/selinfo.h>
192 #else
193 #include <sys/select.h>
194 #endif
195
196 #define FW_KASSERT(expression, str) \
197 KASSERT(expression, str)
198
199
200 #ifdef __DragonFly__
201 #define M_DONTWAIT MB_DONTWAIT
202 #endif
203
204
205 /*
206 * fw attach macro for FreeBSD
207 */
208 #define FW_ATTACH(dname) \
209 static int \
210 __CONCAT(dname,_attach)(device_t dev)
211 #define FW_ATTACH_START(dname, sc, fwa) \
212 struct __CONCAT(dname,_softc) *sc = \
213 ((struct __CONCAT(dname,_softc) *)device_get_softc(dev)); \
214 __unused struct fw_attach_args *fwa = \
215 device_get_ivars(dev)
216 #define FW_ATTACH_RETURN(r) return (r)
217
218 /*
219 * fw detach macro for FreeBSD
220 */
221 #define FW_DETACH(dname) \
222 static int \
223 __CONCAT(dname,_detach)(device_t dev)
224 #define FW_DETACH_START(dname, sc) \
225 struct __CONCAT(dname,_softc) *sc = \
226 ((struct __CONCAT(dname,_softc) *)device_get_softc(dev))
227
228 /*
229 * fw open macro for FreeBSD
230 */
231 #define FW_OPEN(dname) \
232 int \
233 __CONCAT(dname,_open)(fw_dev_t dev, int flags, int fmt, fw_proc_t td)
234 #define FW_OPEN_START \
235 int unit = DEV2UNIT(dev); \
236 __unused struct firewire_softc *sc = \
237 devclass_get_softc(firewire_devclass, unit)
238
239 /*
240 * fw close macro for FreeBSD
241 */
242 #define FW_CLOSE(dname) \
243 int \
244 __CONCAT(dname,_close)(fw_dev_t dev, int flags, \
245 int fmt, fw_proc_t td)
246 #define FW_CLOSE_START
247
248 /*
249 * fw read macro for FreeBSD
250 */
251 #define FW_READ(dname) \
252 int \
253 __CONCAT(dname,_read)(fw_dev_t dev, struct uio *uio, int ioflag)
254 #define FW_READ_START
255
256 /*
257 * fw write macro for FreeBSD
258 */
259 #define FW_WRITE(dname) \
260 int \
261 __CONCAT(dname,_write)(fw_dev_t dev, struct uio *uio, int ioflag)
262 #define FW_WRITE_START
263
264 /*
265 * fw ioctl macro for FreeBSD
266 */
267 #define FW_IOCTL(dname) \
268 int \
269 __CONCAT(dname,_ioctl) \
270 (fw_dev_t dev, u_long cmd, void *data, int flag, fw_proc_t td)
271 #define FW_IOCTL_START \
272 int unit = DEV2UNIT(dev); \
273 __unused struct firewire_softc *sc = \
274 devclass_get_softc(firewire_devclass, unit)
275
276 /*
277 * fw poll macro for FreeBSD
278 */
279 #define FW_POLL(dname) \
280 int \
281 __CONCAT(dname,_poll)(fw_dev_t dev, int events, fw_proc_t td)
282 #define FW_POLL_START
283
284 /*
285 * fw mmap macro for FreeBSD
286 */
287 #if defined(__DragonFly__) || __FreeBSD_version < 500102
288 #define FW_MMAP(dname) \
289 int \
290 __CONCAT(dname,_mmap)(fw_dev_t dev, vm_offset_t offset, int nproto)
291 #else
292 #define FW_MMAP(dname) \
293 int \
294 __CONCAT(dname,_mmap) \
295 (fw_dev_t dev, vm_offset_t offset, vm_paddr_t *paddr, int nproto)
296 #endif
297 #define FW_MMAP_START
298
299 /*
300 * fw strategy macro for FreeBSD
301 */
302 #define FW_STRATEGY_START \
303 fw_dev_t dev = bp->bio_dev; \
304 int unit = DEV2UNIT(dev); \
305 __unused struct firewire_softc *sc = \
306 devclass_get_softc(firewire_devclass, unit)
307
308 /*
309 * if macro for FreeBSD
310 */
311 #define IF_DETACH_START(dname, sc) \
312 struct __CONCAT(dname,_softc) *sc = \
313 (struct __CONCAT(dname,_softc) *)device_get_softc(dev)
314 #define IF_IOCTL_START(dname, sc) \
315 struct __CONCAT(dname,_softc) *sc = \
316 ((struct fwip_eth_softc *)ifp->if_softc)->fwip
317 #define IF_INIT(dname) \
318 static void \
319 __CONCAT(dname,_init)(void *arg)
320 #define IF_INIT_START(dname, sc, ifp) \
321 struct __CONCAT(dname,_softc) *sc = \
322 ((struct fwip_eth_softc *)arg)->fwip; \
323 struct ifnet *ifp = (sc)->fw_softc.fwip_ifp
324 #define IF_INIT_RETURN(r) return
325 #define IF_STOP(dname) \
326 static void \
327 __CONCAT(dname,_stop)(struct __CONCAT(dname,_softc) *fwip)
328 #define IF_STOP_START(dname, ifp, sc) \
329 struct ifnet *ifp = (sc)->fw_softc.fwip_ifp;
330
331 /*
332 * fwohci macro for FreeBSD
333 */
334 #define FWOHCI_DETACH() \
335 int \
336 fwohci_detach(struct fwohci_softc *sc, device_t dev)
337 #define FWOHCI_DETACH_START
338 #define FWOHCI_DETACH_END
339 #define FWOHCI_INIT_END
340
341 /*
342 * firewire macro for FreeBSD
343 */
344 #define FIREWIRE_ATTACH_START \
345 device_t pa = device_get_parent(dev); \
346 struct firewire_comm *fc = (struct firewire_comm *)device_get_softc(pa)
347 #define FWDEV_DESTROYDEV(sc) \
348 do { \
349 int err; \
350 if ((err = fwdev_destroydev((sc))) != 0) \
351 return err; \
352 } while (/*CONSTCOND*/0)
353 #define FIREWIRE_GENERIC_ATTACH \
354 do { \
355 /* Locate our children */ \
356 bus_generic_probe(dev); \
357 \
358 /* launch attachement of the added children */ \
359 bus_generic_attach(dev); \
360 } while (/*CONSTCOND*/0)
361 #define FIREWIRE_GENERIC_DETACH \
362 do { \
363 int err; \
364 if ((err = bus_generic_detach(dev)) != 0) \
365 return err; \
366 } while (/*CONSTCOND*/0)
367 #define FIREWIRE_SBP_ATTACH \
368 do { \
369 fwa.fwdev = fwdev; \
370 fwdev->sbp = device_add_child(fc->bdev, fwa.name, -1); \
371 if (fwdev->sbp) { \
372 device_set_ivars(fwdev->sbp, &fwa); \
373 device_probe_and_attach(fwdev->sbp); \
374 } \
375 } while (/*CONSTCOND*/0)
376 #define FIREWIRE_SBP_DETACH \
377 do { \
378 if (device_detach(fwdev->sbp) != 0) \
379 return; \
380 } while (/*CONSTCOND*/0)
381 #define FIREWIRE_CHILDREN_FOREACH_FUNC(func, fdc) \
382 do { \
383 device_t *devlistp; \
384 int i, devcnt; \
385 \
386 if (device_get_children(fc->bdev, &devlistp, &devcnt) == 0) { \
387 for( i = 0 ; i < devcnt ; i++) \
388 if (device_get_state(devlistp[i]) >= \
389 DS_ATTACHED) { \
390 (fdc) = device_get_softc(devlistp[i]);\
391 if ((fdc)->func != NULL) \
392 (fdc)->func((fdc)); \
393 } \
394 free(devlistp, M_TEMP); \
395 } \
396 } while (/*CONSTCOND*/0)
397
398 /*
399 * sbp macro for FreeBSD
400 */
401 #define SBP_ATTACH_START \
402 struct cam_devq *devq; \
403 \
404 bzero(sbp, sizeof(struct sbp_softc)); \
405 sbp->fd.dev = dev
406 #define SBP_SCSIBUS_ATTACH \
407 do { \
408 sbp->sim = cam_sim_alloc(sbp_action, sbp_poll, "sbp", sbp, \
409 device_get_unit(dev), \
410 &sbp->mtx, \
411 /*untagged*/ 1, \
412 /*tagged*/ SBP_QUEUE_LEN - 1, \
413 devq); \
414 \
415 if (sbp->sim == NULL) { \
416 cam_simq_free(devq); \
417 return ENXIO; \
418 } \
419 \
420 SBP_LOCK(sbp); \
421 if (xpt_bus_register(sbp->sim, /*bus*/0) != CAM_SUCCESS) \
422 goto fail; \
423 \
424 if (xpt_create_path( \
425 &sbp->path, xpt_periph, cam_sim_path(sbp->sim), \
426 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {\
427 xpt_bus_deregister(cam_sim_path(sbp->sim)); \
428 goto fail; \
429 } \
430 xpt_async(AC_BUS_RESET, sbp->path, /*arg*/ NULL); \
431 SBP_UNLOCK(sbp); \
432 } while (/*CONSTCOND*/0)
433 #define SBP_DEVICE(d) ((d)->path)
434 #define SBP_DEVICE_FREEZE(d, x) xpt_freeze_devq((d)->path, (x))
435 #define SBP_DEVICE_THAW(d, x) xpt_release_devq((d)->path, (x), TRUE)
436 #define SBP_BUS_FREEZE(b) \
437 do { \
438 if (((b)->sim->flags & SIMQ_FREEZED) == 0) { \
439 xpt_freeze_simq((b)->sim, /*count*/1); \
440 (b)->sim->flags |= SIMQ_FREEZED; \
441 } \
442 } while (/*CONSTCOND*/0)
443 #define SBP_BUS_THAW(b) \
444 do { \
445 xpt_release_simq((b)->sim, /*run queue*/TRUE); \
446 (b)->sim->flags &= ~SIMQ_FREEZED; \
447 } while (/*CONSTCOND*/0)
448 #define SBP_DEVICE_PREATTACH()
449
450 /*
451 * fwip macro for FreeBSD
452 */
453 #define FWIP_ATTACH_START \
454 int unit = device_get_unit(dev);\
455 struct fw_hwaddr *hwaddr;
456 #define FWIP_ATTACH_SETUP \
457 do { \
458 fwip->fw_softc.fwip_ifp = if_alloc(IFT_IEEE1394); \
459 hwaddr = &IFP2FWC(fwip->fw_softc.fwip_ifp)->fc_hwaddr; \
460 } while (/*CONSTCOND*/0)
461
462 #define FWDEV_MAKEDEV(sc) fwdev_makedev(sc)
463
464 #define FIREWIRE_IFATTACH(ifp, ha) \
465 firewire_ifattach((ifp), (ha))
466 #define FIREWIRE_IFDETACH(ifp) \
467 do { \
468 firewire_ifdetach(ifp); \
469 if_free(ifp); \
470 } while (/*CONSTCOND*/0)
471 #define FIREWIRE_BUSRESET(ifp) firewire_busreset((ifp))
472 #define FIREWIRE_INPUT(ifp, m, src) \
473 firewire_input((ifp), (m), (src))
474 #define FWIP_INIT(sc) fwip_init(&(sc)->fw_softc)
475 #define FWIP_STOP(sc) fwip_stop((sc))
476 #define FIREWIRE_IOCTL(ifp, cmd, data) \
477 firewire_ioctl((ifp), (cmd), (data))
478 #define IF_INITNAME(ifp, dev, unit) \
479 if_initname((ifp), device_get_name((dev)), (unit));
480 #define SET_IFFUNC(ifp, start, ioctl, init, stop) \
481 do { \
482 (ifp)->if_start = (start); \
483 (ifp)->if_ioctl = (ioctl); \
484 (ifp)->if_init = (init); \
485 } while (/*CONSTCOND*/0)
486
487 /*
488 * fwdev macro for FreeBSD
489 */
490 #define FWDEV_OPEN_START \
491 if (DEV_FWMEM(dev)) \
492 return fwmem_open(dev, flags, fmt, td)
493 #define FWDEV_CLOSE_START \
494 if (DEV_FWMEM(dev)) \
495 return fwmem_close(dev, flags, fmt, td)
496 #define FWDEV_READ_START \
497 if (DEV_FWMEM(dev)) \
498 return (physio(dev, uio, ioflag))
499 #define FWDEV_WRITE_START \
500 if (DEV_FWMEM(dev)) \
501 return (physio(dev, uio, ioflag))
502 #define FWDEV_IOCTL_START \
503 if (DEV_FWMEM(dev)) \
504 return fwmem_ioctl(dev, cmd, data, flag, td)
505 #define FWDEV_IOCTL_REDIRECT fc->ioctl(dev, cmd, data, flag, td)
506 #define FWDEV_POLL_START \
507 if (DEV_FWMEM(dev)) \
508 return fwmem_poll(dev, events, td)
509 #if defined(__DragonFly__) || __FreeBSD_version < 500102
510 #define FWDEV_MMAP_START \
511 if (DEV_FWMEM(dev)) \
512 return fwmem_mmap(dev, offset, nproto)
513 #else
514 #define FWDEV_MMAP_START \
515 if (DEV_FWMEM(dev)) \
516 return fwmem_mmap(dev, offset, paddr, nproto)
517 #endif
518 #define FWDEV_STRATEGY_START \
519 if (DEV_FWMEM(dev)) { \
520 fwmem_strategy(bp); \
521 return; \
522 }
523
524 #define XS_REQ_INVALID CAM_REQ_INVALID
525 #define XS_SCSI_BUS_RESET CAM_SCSI_BUS_RESET
526 #define XS_BDR_SENT CAM_BDR_SENT
527 #define XS_DEV_NOT_THERE CAM_DEV_NOT_THERE
528 #define XS_CMD_TIMEOUT CAM_CMD_TIMEOUT
529 #define XS_REQUEUE_REQ CAM_REQUEUE_REQ
530 #define XS_REQ_CMP CAM_REQ_CMP
531 #define XS_REQ_CMP_ERR CAM_REQ_CMP_ERR
532 #define XS_UA_ABORT CAM_UA_ABORT
533 #define XS_SENSE (CAM_SCSI_STATUS_ERROR | CAM_AUTOSNS_VALID)
534
535 typedef union ccb sbp_scsi_xfer;
536 typedef struct scsi_inquiry_data sbp_scsi_inquiry_data;
537
538 #define SCSI_XFER_TARGET(x) ((x)->ccb_h.target_id)
539 #define SCSI_XFER_LUN(x) ((x)->ccb_h.target_lun)
540 #define SCSI_XFER_ERROR(x) ((x)->ccb_h.status)
541 #define SCSI_XFER_DIR(x) ((x)->ccb_h.flags & CAM_DIR_MASK)
542 #define SCSI_XFER_DATA_IN CAM_DIR_IN
543 #define SCSI_XFER_CALLOUT(x) ((x)->ccb_h.timeout_ch)
544 #define SCSI_XFER_TIMEOUT(x) ((x)->ccb_h.timeout)
545 #define SCSI_XFER_OPECODE(x) ((x)->csio.cdb_io.cdb_bytes[0])
546 #define SCSI_XFER_STATUS(x) ((x)->csio.scsi_status)
547 #define SCSI_XFER_EVPD(x) ((x)->csio.cdb_io.cdb_bytes[1] & SI_EVPD)
548 #define SCSI_XFER_CMDLEN(x) ((x)->csio.cdb_len)
549 #define SCSI_XFER_CMD(x) \
550 (((x)->csio.ccb_h.flags & CAM_CDB_POINTER) ?\
551 (void *)(x)->csio.cdb_io.cdb_ptr : \
552 (void *)&(x)->csio.cdb_io.cdb_bytes)
553 #define SCSI_XFER_DATALEN(x) ((x)->csio.dxfer_len)
554 #define SCSI_XFER_DATA(x) ((x)->csio.data_ptr)
555 #define SCSI_XFER_SENSELEN(x) ((x)->csio.sense_len)
556 #define SCSI_SENSE_DATA(x) (&(x)->csio.sense_data)
557 #define SCSI_INQUIRY_DATA(x) ((x)->csio.data_ptr)
558 #define SCSI_XFER_FUNCCODE(x) ((x)->ccb_h.func_code)
559 #define SCSI_XFER_10BCMD_DUMP(x) \
560 ((x)->csio.cdb_io.cdb_bytes[0]), \
561 ((x)->csio.cdb_io.cdb_bytes[1]), \
562 ((x)->csio.cdb_io.cdb_bytes[2]), \
563 ((x)->csio.cdb_io.cdb_bytes[3]), \
564 ((x)->csio.cdb_io.cdb_bytes[4]), \
565 ((x)->csio.cdb_io.cdb_bytes[5]), \
566 ((x)->csio.cdb_io.cdb_bytes[6]), \
567 ((x)->csio.cdb_io.cdb_bytes[7]), \
568 ((x)->csio.cdb_io.cdb_bytes[8]), \
569 ((x)->csio.cdb_io.cdb_bytes[9])
570 #define SCSI_XFER_REQUEST_COMPLETE(x)
571 #define SCSI_TRANSFER_DONE(x) xpt_done((x))
572 #ifdef SID_TYPE
573 #undef SID_TYPE
574 #define SID_TYPE 0x1f
575 #endif
576
577 #define NOT_LUN_WILDCARD(l) ((l) != CAM_LUN_WILDCARD)
578 #define CAM_XFER_FLAGS(x) ((x)->csio.ccb_h.flags)
579
580 #define mstohz(ms) \
581 (__predict_false((ms) >= 0x20000) ? \
582 (((ms) + 0u) / 1000u) * hz : \
583 (((ms) + 0u) * hz) / 1000u)
584
585
586 #elif defined(__NetBSD__)
587 #define OS_STR "NetBSD"
588 #define OS_VER __NetBSD_Version__
589 #define OS_VER_STR "NetBSD-2"
590 #define PROJECT_STR "NetBSD Project"
591
592 #define fw_dev_t dev_t
593
594 struct fwbus_attach_args {
595 const char *name;
596 };
597
598 struct fw_hwaddr {
599 uint32_t sender_unique_ID_hi;
600 uint32_t sender_unique_ID_lo;
601 uint8_t sender_max_rec;
602 uint8_t sspd;
603 uint16_t sender_unicast_FIFO_hi;
604 uint32_t sender_unicast_FIFO_lo;
605 };
606
607
608 #define fw_dev2unit(x) minor(x)
609 #define fw_unit2minor(x) (((x) & 0xff) | (((x) << 12) & ~0xfffff))
610
611 #define fw_timevalcmp(tv1, tv2, op) timercmp((tv1), (tv2), op)
612 #define fw_timevalsub(tv1, tv2) timersub((tv1), (tv2), (tv1))
613
614 #define fw_get_nameunit(dev) device_xname(dev)
615 #define fw_get_unit(dev) device_unit((dev))
616
617 #define fw_printf(dev, ...) aprint_normal_dev((dev), __VA_ARGS__)
618
619 /* atomic macros */
620 /* XXXX: unsafe... */
621 #define fw_atomic_set_int(P, V) (*(u_int *)(P) |= (V))
622 static __inline int
623 fw_atomic_readandclear_int(int *p)
624 {
625 int _p = *p;
626
627 *p = 0;
628 return _p;
629 }
630
631 /* mutex macros */
632 /* XXXX: unsafe... */
633 typedef void *fw_mtx_t;
634 #define fw_mtx_init(mutex, name, type, opts)
635 #define fw_mtx_lock(mutex) (void)(mutex) /* XXXX */
636 #define fw_mtx_unlock(mutex) (void)(mutex) /* XXXX */
637 #define fw_mtx_destroy(mutex)
638 #define fw_mtx_assert(mutex, what)
639
640 #define fw_msleep(ident, mtx, priority, wmesg, timo) \
641 tsleep((ident), (priority), (wmesg), (timo))
642
643 /* taskqueue macros */
644 /* XXXX: unsafe... */
645 typedef void (*task_fn_t)(void *context, int pending);
646 typedef struct {
647 STAILQ_ENTRY(task) ta_link; /* link for queue */
648 u_short ta_pending; /* count times queued */
649 u_short ta_priority; /* priority of task in queue */
650 task_fn_t ta_func; /* task handler */
651 void *ta_context; /* argument for handler */
652 } fw_task_t;
653 #define fw_taskqueue_enqueue(queue, task) \
654 (task)->ta_func((task)->ta_context, 0)
655 #define FW_TASK_INIT(task, priority, func, context) \
656 do { \
657 (task)->ta_priority = (priority); \
658 (task)->ta_func = (func); \
659 (task)->ta_context = (context); \
660 } while (/*CONSTCOND*/0)
661 #define fw_taskqueue_create_fast(name, mflags, enqueue, taskqueue) \
662 NULL
663 #define fw_taskqueue_start_threads(taskqueue, n, x, fmt, ...)
664
665 /* kthread macros */
666 typedef struct proc fw_thread_t;
667 typedef struct lwp *fw_proc_t;
668 #define fw_kthread_create(func, arg, newpp, fmt, ...) \
669 kthread_create(PRI_NONE, 0, NULL, \
670 (func), (arg), (newpp), (fmt), __VA_ARGS__)
671 #define fw_kthread_exit(ecode) kthread_exit((ecode))
672
673 /* callout macros */
674 #define fw_callout_init(c) callout_init((c), 0)
675 #define fw_callout_reset(c, ticks, func, arg) \
676 callout_reset((c), (ticks), (func), (arg))
677 #define fw_callout_stop(c) callout_stop((c))
678
679 /* bus_dma macros */
680 #include <sys/malloc.h>
681 #include <sys/bus.h>
682 struct fw_bus_dma_tag {
683 bus_dma_tag_t tag;
684 bus_size_t alignment;
685 bus_size_t boundary;
686 bus_size_t size;
687 int nsegments;
688 bus_size_t maxsegsz;
689 int flags;
690 };
691 typedef struct fw_bus_dma_tag *fw_bus_dma_tag_t;
692 typedef int bus_dmasync_op_t;
693 typedef void bus_dmamap_callback_t(void *, bus_dma_segment_t *, int, int);
694 typedef void
695 bus_dmamap_callback2_t(void *, bus_dma_segment_t *, int, bus_size_t, int);
696
697 #define fw_bus_dma_tag_create( \
698 p, a, b, la, ha, ffunc, farg, maxsz, \
699 nseg, maxsegsz, f, lfunc, larg, dmat) \
700 \
701 _fw_bus_dma_tag_create((p), (a), (b), (la), (ha), \
702 (ffunc), (farg), (maxsz), (nseg), (maxsegsz), (f), (dmat))
703
704 static __inline int
705 _fw_bus_dma_tag_create(bus_dma_tag_t parent,
706 bus_size_t alignment, bus_size_t boundary,
707 bus_addr_t lowaddr, bus_addr_t highaddr,
708 void *filtfunc, void *filtfuncarg,
709 bus_size_t maxsize, int nsegments, bus_size_t maxsegsz,
710 int flags, fw_bus_dma_tag_t *fwdmat)
711 {
712 fw_bus_dma_tag_t tag;
713
714 tag = malloc(sizeof(struct fw_bus_dma_tag), M_DEVBUF, M_NOWAIT);
715 if (tag == NULL)
716 return ENOMEM;
717
718 /* XXXX */
719 #define BUS_SPACE_MAXADDR_32BIT 0
720 #define BUS_SPACE_MAXADDR 0
721
722 tag->tag = parent;
723 tag->alignment = alignment;
724 tag->boundary = boundary;
725 tag->size = maxsize;
726 tag->nsegments = nsegments;
727 tag->maxsegsz = maxsegsz;
728 tag->flags = flags;
729
730 *fwdmat = tag;
731
732 return 0;
733 }
734 #define fw_bus_dma_tag_destroy(ft) \
735 free(ft, M_DEVBUF)
736 #define fw_bus_dmamap_create(ft, f, mp) \
737 bus_dmamap_create((ft)->tag, (ft)->size,\
738 (ft)->nsegments, (ft)->maxsegsz, (ft)->boundary, (f), (mp))
739 #define fw_bus_dmamap_destroy(ft, m) \
740 bus_dmamap_destroy((ft)->tag, (m))
741 static __inline int
742 fw_bus_dmamap_load(fw_bus_dma_tag_t ft, bus_dmamap_t m,
743 void *b, bus_size_t l, bus_dmamap_callback_t *func, void *a, int f)
744 {
745 int lf = f & (BUS_DMA_WAITOK | BUS_DMA_NOWAIT | BUS_DMA_STREAMING |
746 BUS_DMA_READ | BUS_DMA_WRITE |
747 BUS_DMA_BUS1 | BUS_DMA_BUS2 | BUS_DMA_BUS3 | BUS_DMA_BUS4);
748 int err = bus_dmamap_load(ft->tag, m, b, l, NULL, lf);
749 (func)(a, m->dm_segs, m->dm_nsegs, err);
750 return err;
751 }
752 static __inline int
753 fw_bus_dmamap_load_mbuf(fw_bus_dma_tag_t ft, bus_dmamap_t m,
754 struct mbuf *b, bus_dmamap_callback2_t *func, void *a, int f)
755 {
756 int lf = f & (BUS_DMA_WAITOK | BUS_DMA_NOWAIT | BUS_DMA_STREAMING |
757 BUS_DMA_READ | BUS_DMA_WRITE |
758 BUS_DMA_BUS1 | BUS_DMA_BUS2 | BUS_DMA_BUS3 | BUS_DMA_BUS4);
759 int err = bus_dmamap_load_mbuf(ft->tag, m, b, lf);
760 (func)(a, m->dm_segs, m->dm_nsegs, m->dm_mapsize, err);
761 return err;
762 }
763 #define fw_bus_dmamap_unload(ft, m) \
764 bus_dmamap_unload((ft)->tag, (m))
765 #define fw_bus_dmamap_sync(ft, m, op) \
766 bus_dmamap_sync((ft)->tag, (m), 0, (m)->dm_mapsize, (op))
767 static __inline int
768 fw_bus_dmamem_alloc(fw_bus_dma_tag_t ft, void **vp, int f, bus_dmamap_t *mp)
769 {
770 bus_dma_segment_t segs;
771 int nsegs, err;
772 int af, mf, cf;
773
774 af = f & (BUS_DMA_WAITOK | BUS_DMA_NOWAIT | BUS_DMA_STREAMING |
775 BUS_DMA_BUS1 | BUS_DMA_BUS2 | BUS_DMA_BUS3 | BUS_DMA_BUS4);
776 err = bus_dmamem_alloc(ft->tag, ft->size,
777 ft->alignment, ft->boundary, &segs, ft->nsegments, &nsegs, af);
778 if (err) {
779 printf("fw_bus_dmamem_alloc: failed(1)\n");
780 return err;
781 }
782
783 mf = f & (BUS_DMA_WAITOK | BUS_DMA_NOWAIT |
784 BUS_DMA_BUS1 | BUS_DMA_BUS2 | BUS_DMA_BUS3 | BUS_DMA_BUS4 |
785 BUS_DMA_COHERENT | BUS_DMA_NOCACHE);
786 err = bus_dmamem_map(ft->tag,
787 &segs, nsegs, ft->size, (void **)vp, mf);
788 if (err) {
789 printf("fw_bus_dmamem_alloc: failed(2)\n");
790 bus_dmamem_free(ft->tag, &segs, nsegs);
791 return err;
792 }
793
794 if (*mp != NULL)
795 return err;
796
797 cf = f & (BUS_DMA_WAITOK | BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW |
798 BUS_DMA_BUS1 | BUS_DMA_BUS2 | BUS_DMA_BUS3 | BUS_DMA_BUS4);
799 err = bus_dmamap_create(ft->tag,
800 ft->size, nsegs, ft->maxsegsz, ft->boundary, cf, mp);
801 if (err) {
802 printf("fw_bus_dmamem_alloc: failed(3)\n");
803 bus_dmamem_unmap(ft->tag, (void *)*vp, ft->size);
804 bus_dmamem_free(ft->tag, &segs, nsegs);\
805 }
806
807 return err;
808 }
809 #define fw_bus_dmamem_free(ft, v, m) \
810 do { \
811 bus_dmamem_unmap((ft)->tag, (v), (ft)->size); \
812 bus_dmamem_free((ft)->tag, (m)->dm_segs, (m)->dm_nsegs);\
813 bus_dmamap_destroy((ft)->tag, (m)); \
814 } while (/*CONSTCOND*/0)
815
816 #define fw_config_pending_incr() config_pending_incr()
817 #define fw_config_pending_decr() config_pending_decr()
818
819 #define splfw() splvm()
820 #define splfwnet() splnet()
821 #define splfwsbp() splbio()
822 #define splsoftvm() splbio()
823
824 #include <sys/select.h>
825
826 #define FW_KASSERT(expression, str) \
827 KASSERT(expression)
828
829 /*
830 * fw attach macro for NetBSD
831 */
832 #define FW_ATTACH(dname) \
833 void \
834 __CONCAT(dname,attach) \
835 (device_t parent, device_t self, void *aux)
836 #define FW_ATTACH_START(dname, sc, fwa) \
837 struct __CONCAT(dname,_softc) *sc = device_private(self); \
838 __unused struct fw_attach_args *fwa = (struct fw_attach_args *)aux
839 #define FW_ATTACH_RETURN(r) return
840
841 /*
842 * fw detach macro for NetBSD
843 */
844 #define FW_DETACH(dname) \
845 int \
846 __CONCAT(dname,detach)(device_t self, int flags)
847 #define FW_DETACH_START(dname, sc) \
848 struct __CONCAT(dname,_softc) *sc = device_private(self)
849
850 /*
851 * fw open macro for NetBSD
852 */
853 #define FW_OPEN(dname) \
854 int \
855 __CONCAT(dname,_open)(dev_t _dev, int flags, int fmt, fw_proc_t td)
856 #define FW_OPEN_START \
857 struct firewire_softc *sc, *dev; \
858 \
859 sc = dev = device_lookup_private(&ieee1394if_cd, DEV2UNIT(_dev));\
860 if (dev == NULL) \
861 return ENXIO
862
863 /*
864 * fw close macro for NetBSD
865 */
866 #define FW_CLOSE(dname) \
867 int \
868 __CONCAT(dname,_close)(dev_t _dev, int flags, int fmt, fw_proc_t td)
869 #define FW_CLOSE_START \
870 int unit = DEV2UNIT(_dev); \
871 struct firewire_softc *dev; \
872 \
873 dev = device_lookup_private(&ieee1394if_cd, unit); \
874 if (dev == NULL) \
875 return ENXIO
876
877 /*
878 * fw read macro for NetBSD
879 */
880 #define FW_READ(dname) \
881 int \
882 __CONCAT(dname,_read)(dev_t _dev, struct uio *uio, int ioflag)
883 #define FW_READ_START \
884 int unit = DEV2UNIT(_dev); \
885 struct firewire_softc *dev; \
886 \
887 dev = device_lookup_private(&ieee1394if_cd, unit); \
888 if (dev == NULL) \
889 return ENXIO
890
891 /*
892 * fw write macro for NetBSD
893 */
894 #define FW_WRITE(dname) \
895 int \
896 __CONCAT(dname,_write)(dev_t _dev, struct uio *uio, int ioflag)
897 #define FW_WRITE_START \
898 int unit = DEV2UNIT(_dev); \
899 struct firewire_softc *dev; \
900 \
901 dev = device_lookup_private(&ieee1394if_cd, unit); \
902 if (dev == NULL) \
903 return ENXIO
904
905 /*
906 * fw ioctl macro for NetBSD
907 */
908 #define FW_IOCTL(dname) \
909 int \
910 __CONCAT(dname,_ioctl) \
911 (dev_t _dev, u_long cmd, void *data, int flag, fw_proc_t td)
912 #define FW_IOCTL_START \
913 int unit = DEV2UNIT(_dev); \
914 struct firewire_softc *sc, *dev; \
915 \
916 sc = dev = device_lookup_private(&ieee1394if_cd, unit); \
917 if (dev == NULL) \
918 return ENXIO
919
920 /*
921 * fw poll macro for NetBSD
922 */
923 #define FW_POLL(dname) \
924 int \
925 __CONCAT(dname,_poll)(dev_t _dev, int events, fw_proc_t td)
926 #define FW_POLL_START \
927 int unit = DEV2UNIT(_dev); \
928 struct firewire_softc *dev; \
929 \
930 dev = device_lookup_private(&ieee1394if_cd, unit); \
931 if (dev == NULL) \
932 return ENXIO
933
934 /*
935 * fw mmap macro for NetBSD
936 */
937 #define FW_MMAP(dname) \
938 paddr_t \
939 __CONCAT(dname,_mmap)(dev_t _dev, off_t offset, int nproto)
940 #define FW_MMAP_START \
941 int unit = DEV2UNIT(_dev); \
942 struct firewire_softc *dev; \
943 \
944 dev = device_lookup_private(&ieee1394if_cd, unit); \
945 if (dev == NULL) \
946 return ENXIO
947
948 /*
949 * fw strategy macro for NetBSD
950 */
951 #define FW_STRATEGY_START \
952 dev_t _dev = bp->bio_dev; \
953 int unit = DEV2UNIT(_dev); \
954 struct firewire_softc *sc, *dev; \
955 \
956 sc = dev = device_lookup_private(&ieee1394if_cd, unit); \
957 if (dev == NULL) \
958 return
959
960 /*
961 * if macro for NetBSD
962 */
963 #define IF_DETACH_START(dname, sc) \
964 struct __CONCAT(dname,_softc) *sc = device_private(self)
965 #define IF_IOCTL_START(dname, sc) \
966 struct __CONCAT(dname,_softc) *sc = \
967 ((struct fwip_eth_softc *)ifp->if_softc)->fwip
968 #define IF_INIT(dname) \
969 int \
970 __CONCAT(dname,_init)(struct ifnet *ifp)
971 #define IF_INIT_START(dname, sc, ifp) \
972 struct __CONCAT(dname,_softc) *sc = \
973 ((struct fwip_eth_softc *)(ifp)->if_softc)->fwip
974 #define IF_INIT_RETURN(r) return (r)
975 #define IF_STOP(dname) \
976 void \
977 __CONCAT(dname,_stop)(struct ifnet *ifp, int disable)
978 #define IF_STOP_START(dname, ifp, sc) \
979 struct __CONCAT(dname,_softc) *sc = \
980 ((struct fwip_eth_softc *)(ifp)->if_softc)->fwip
981
982 /*
983 * fwohci macro for NetBSD
984 */
985 #define FWOHCI_DETACH() \
986 int \
987 fwohci_detach(struct fwohci_softc *sc, int flags)
988 #define FWOHCI_DETACH_START \
989 if (sc->fc.bdev != NULL) \
990 config_detach(sc->fc.bdev, flags)
991 #define FWOHCI_DETACH_END
992 #define FWOHCI_INIT_END \
993 do { \
994 struct fwbus_attach_args faa; \
995 faa.name = "ieee1394if"; \
996 sc->fc.bdev = config_found(sc->fc.dev, &faa, fwohci_print); \
997 } while (/*CONSTCOND*/0)
998
999 /*
1000 * firewire macro for NetBSD
1001 */
1002 #define FIREWIRE_ATTACH_START \
1003 struct firewire_comm *fc = device_private(parent); \
1004 \
1005 aprint_normal(": IEEE1394 bus\n"); \
1006 \
1007 fc->bdev = sc->dev = self; \
1008 SLIST_INIT(&sc->devlist)
1009 #define FWDEV_DESTROYDEV(sc)
1010 #define FIREWIRE_GENERIC_ATTACH \
1011 do { \
1012 struct fw_attach_args faa; \
1013 struct firewire_dev_list *devlist, *elm; \
1014 \
1015 devlist = malloc( \
1016 sizeof(struct firewire_dev_list), M_DEVBUF, M_NOWAIT); \
1017 if (devlist == NULL) \
1018 break; \
1019 \
1020 faa.name = "fwip"; \
1021 faa.fc = fc; \
1022 faa.fwdev = NULL; \
1023 devlist->dev = config_found(sc->dev, &faa, firewire_print); \
1024 if (devlist->dev == NULL) { \
1025 free(devlist, M_DEVBUF); \
1026 break; \
1027 } \
1028 \
1029 if (SLIST_EMPTY(&sc->devlist)) \
1030 SLIST_INSERT_HEAD(&sc->devlist, devlist, link); \
1031 else { \
1032 for (elm = SLIST_FIRST(&sc->devlist); \
1033 SLIST_NEXT(elm, link) != NULL; \
1034 elm = SLIST_NEXT(elm, link)); \
1035 SLIST_INSERT_AFTER(elm, devlist, link); \
1036 } \
1037 } while (/*CONSTCOND*/0)
1038 #define FIREWIRE_GENERIC_DETACH \
1039 do { \
1040 struct firewire_dev_list *devlist; \
1041 int err; \
1042 \
1043 while ((devlist = SLIST_FIRST(&sc->devlist)) != NULL) { \
1044 if ((err = config_detach(devlist->dev, flags)) != 0) \
1045 return err; \
1046 SLIST_REMOVE( \
1047 &sc->devlist, devlist, firewire_dev_list, link); \
1048 free(devlist, M_DEVBUF); \
1049 } \
1050 } while (/*CONSTCOND*/0)
1051 #define FIREWIRE_SBP_ATTACH \
1052 do { \
1053 struct firewire_softc *sc = device_private(fc->bdev); \
1054 struct firewire_dev_list *devlist, *elm; \
1055 int locs[IEEE1394IFCF_NLOCS]; \
1056 \
1057 devlist = malloc( \
1058 sizeof(struct firewire_dev_list), M_DEVBUF, M_NOWAIT); \
1059 if (devlist == NULL) { \
1060 printf("memory allocation failed\n"); \
1061 break; \
1062 } \
1063 \
1064 locs[IEEE1394IFCF_EUIHI] = fwdev->eui.hi; \
1065 locs[IEEE1394IFCF_EUILO] = fwdev->eui.lo; \
1066 \
1067 fwa.fwdev = fwdev; \
1068 fwdev->sbp = config_found_sm_loc(sc->dev, "ieee1394if", \
1069 locs, &fwa, firewire_print, config_stdsubmatch); \
1070 if (fwdev->sbp == NULL) { \
1071 free(devlist, M_DEVBUF); \
1072 break; \
1073 } \
1074 \
1075 devlist->fwdev = fwdev; \
1076 devlist->dev = fwdev->sbp; \
1077 \
1078 if (SLIST_EMPTY(&sc->devlist)) \
1079 SLIST_INSERT_HEAD(&sc->devlist, devlist, link); \
1080 else { \
1081 for (elm = SLIST_FIRST(&sc->devlist); \
1082 SLIST_NEXT(elm, link) != NULL; \
1083 elm = SLIST_NEXT(elm, link)); \
1084 SLIST_INSERT_AFTER(elm, devlist, link); \
1085 } \
1086 } while (/*CONSTCOND*/0)
1087 #define FIREWIRE_SBP_DETACH \
1088 do { \
1089 struct firewire_softc *sc = device_private(fc->bdev); \
1090 struct firewire_dev_list *devlist; \
1091 \
1092 SLIST_FOREACH(devlist, &sc->devlist, link) { \
1093 if (devlist->fwdev != fwdev) \
1094 continue; \
1095 SLIST_REMOVE( \
1096 &sc->devlist, devlist, firewire_dev_list, link); \
1097 free(devlist, M_DEVBUF); \
1098 \
1099 if (config_detach(fwdev->sbp, DETACH_FORCE) != 0) \
1100 return; \
1101 } \
1102 } while (/*CONSTCOND*/0)
1103 #define FIREWIRE_CHILDREN_FOREACH_FUNC(func, fdc) \
1104 do { \
1105 struct firewire_dev_list *devlist; \
1106 struct firewire_softc *sc = device_private(fc->bdev); \
1107 \
1108 if (!SLIST_EMPTY(&sc->devlist)) { \
1109 SLIST_FOREACH(devlist, &sc->devlist, link) { \
1110 (fdc) = device_private(devlist->dev); \
1111 if ((fdc)->func != NULL) \
1112 (fdc)->func((fdc)); \
1113 } \
1114 } \
1115 } while (/*CONSTCOND*/0)
1116
1117 /*
1118 * sbp macro for NetBSD
1119 */
1120 #define SBP_ATTACH_START \
1121 do { \
1122 aprint_normal(": SBP-2/SCSI over IEEE1394\n"); \
1123 \
1124 sbp->fd.dev = self; \
1125 } while (/*CONSTCOND*/0)
1126 #define SBP_SCSIBUS_ATTACH \
1127 do { \
1128 struct scsipi_adapter *sc_adapter = &sbp->sc_adapter; \
1129 struct scsipi_channel *sc_channel = &sbp->sc_channel; \
1130 struct sbp_target *target = &sbp->target; \
1131 \
1132 sc_adapter->adapt_dev = sbp->fd.dev; \
1133 sc_adapter->adapt_nchannels = 1; \
1134 sc_adapter->adapt_max_periph = 1; \
1135 sc_adapter->adapt_request = sbp_scsipi_request; \
1136 sc_adapter->adapt_minphys = sbp_minphys; \
1137 sc_adapter->adapt_openings = 8; \
1138 /*Start with some. Grow as needed.*/\
1139 \
1140 sc_channel->chan_adapter = sc_adapter; \
1141 sc_channel->chan_bustype = &scsi_bustype; \
1142 sc_channel->chan_defquirks = PQUIRK_ONLYBIG; \
1143 sc_channel->chan_channel = 0; \
1144 sc_channel->chan_flags = \
1145 SCSIPI_CHAN_CANGROW | SCSIPI_CHAN_NOSETTLE; \
1146 \
1147 /* We set nluns 0 now */ \
1148 sc_channel->chan_ntargets = 1; \
1149 sc_channel->chan_nluns = target->num_lun; \
1150 sc_channel->chan_id = 1; \
1151 \
1152 if ((sbp->sc_bus = \
1153 config_found(sbp->fd.dev, sc_channel, scsiprint)) == \
1154 NULL) { \
1155 fw_printf(sbp->fd.dev, "attach failed\n"); \
1156 return; \
1157 } \
1158 } while (/*CONSTCOND*/0)
1159 #define SBP_DEVICE(d) ((d)->periph)
1160 #define SBP_DEVICE_FREEZE(d, x) scsipi_periph_freeze((d)->periph, (x));
1161 #define SBP_DEVICE_THAW(d, x) \
1162 do { \
1163 if ((d)->periph) \
1164 scsipi_periph_thaw((d)->periph, (x)); \
1165 /* XXXX */ \
1166 scsipi_channel_thaw(&(d)->target->sbp->sc_channel, 0); \
1167 } while (/*CONSTCOND*/0)
1168 #define SBP_BUS_FREEZE(b) scsipi_channel_freeze(&(b)->sc_channel, 1)
1169 #define SBP_BUS_THAW(b) scsipi_channel_thaw(&(b)->sc_channel, 1)
1170 #define SBP_DEVICE_PREATTACH() \
1171 do { \
1172 if (!sbp->lwp) { \
1173 /* create thread */ \
1174 if (kthread_create(PRI_NONE, 0, NULL, \
1175 sbp_scsipi_scan_target, &sbp->target, \
1176 &sbp->lwp, "sbp%d_attach", \
1177 device_unit(sbp->fd.dev))) { \
1178 fw_printf(sbp->fd.dev, \
1179 "unable to create thread"); \
1180 panic("fw_kthread_create"); \
1181 } \
1182 } \
1183 } while (/*CONSTCOND*/0)
1184
1185 /*
1186 * fwip macro for NetBSD
1187 */
1188 #define FWIP_ATTACH_START \
1189 device_t dev = self; \
1190 struct fw_hwaddr *hwaddr;
1191 #define FWIP_ATTACH_SETUP \
1192 do { \
1193 aprint_normal(": IP over IEEE1394\n"); \
1194 fwip->fd.dev = self; \
1195 fwip->fw_softc.fwip_ifp = &fwip->fw_softc.fwcom.fc_if; \
1196 hwaddr = (struct fw_hwaddr *)&fwip->fw_softc.fwcom.ic_hwaddr; \
1197 } while (/*CONSTCOND*/0)
1198
1199 #define FWDEV_MAKEDEV(sc)
1200 #define FIREWIRE_IFATTACH(ifp, ha) \
1201 do { \
1202 if_attach((ifp)); \
1203 ieee1394_ifattach((ifp), (const struct ieee1394_hwaddr *)(ha));\
1204 } while (/*CONSTCOND*/0)
1205 #define FIREWIRE_IFDETACH(ifp) \
1206 do { \
1207 ieee1394_ifdetach(ifp); \
1208 if_detach(ifp); \
1209 } while (/*CONSTCOND*/0)
1210 #define FIREWIRE_BUSRESET(ifp) ieee1394_drain((ifp))
1211 #define FIREWIRE_INPUT(ifp, m, src) \
1212 ieee1394_input((ifp), (m), (src))
1213 #define FWIP_INIT(sc) fwip_init((sc)->fw_softc.fwip_ifp)
1214 #define FWIP_STOP(sc) fwip_stop((sc)->fw_softc.fwip_ifp, 1)
1215 #define FIREWIRE_IOCTL(ifp, cmd, data) \
1216 ieee1394_ioctl((ifp), (cmd), (data))
1217 #define IF_INITNAME(ifp, dev, unit) \
1218 strlcpy((ifp)->if_xname, device_xname(dev), IFNAMSIZ);
1219 #define SET_IFFUNC(ifp, start, ioctl, init, stop) \
1220 do { \
1221 (ifp)->if_start = (start); \
1222 (ifp)->if_ioctl = (ioctl); \
1223 (ifp)->if_init = (init); \
1224 (ifp)->if_stop = (stop); \
1225 } while (/*CONSTCOND*/0)
1226
1227 /*
1228 * fwdev macro for NetBSD
1229 */
1230 #define FWDEV_OPEN_START \
1231 if (DEV_FWMEM(_dev)) \
1232 return fwmem_open(_dev, flags, fmt, td)
1233 #define FWDEV_CLOSE_START \
1234 if (DEV_FWMEM(_dev)) \
1235 return fwmem_close(_dev, flags, fmt, td)
1236 #define FWDEV_READ_START \
1237 if (DEV_FWMEM(_dev)) \
1238 return physio(fw_strategy, NULL, _dev, ioflag, minphys, uio)
1239 #define FWDEV_WRITE_START \
1240 if (DEV_FWMEM(_dev)) \
1241 return physio(fw_strategy, NULL, _dev, ioflag, minphys, uio)
1242 #define FWDEV_IOCTL_START \
1243 if (DEV_FWMEM(_dev)) \
1244 return fwmem_ioctl(_dev, cmd, data, flag, td)
1245 #define FWDEV_IOCTL_REDIRECT fc->ioctl(_dev, cmd, data, flag, td)
1246 #define FWDEV_POLL_START \
1247 if (DEV_FWMEM(_dev)) \
1248 return fwmem_poll(_dev, events, td)
1249 #define FWDEV_MMAP_START \
1250 if (DEV_FWMEM(_dev)) \
1251 return fwmem_mmap(_dev, offset, nproto)
1252 #define FWDEV_STRATEGY_START \
1253 if (DEV_FWMEM(_dev)) { \
1254 fwmem_strategy(bp); \
1255 return; \
1256 }
1257
1258 #define XS_REQ_INVALID XS_DRIVER_STUFFUP
1259 #define XS_SCSI_BUS_RESET XS_RESET
1260 #define XS_BDR_SENT XS_RESET
1261 #define XS_DEV_NOT_THERE XS_DRIVER_STUFFUP
1262 #define XS_CMD_TIMEOUT XS_TIMEOUT
1263 #define XS_REQUEUE_REQ XS_REQUEUE
1264 #define XS_REQ_CMP XS_NOERROR
1265 #define XS_REQ_CMP_ERR XS_DRIVER_STUFFUP
1266 #define XS_UA_ABORT XS_DRIVER_STUFFUP
1267
1268 typedef struct scsipi_xfer sbp_scsi_xfer;
1269 typedef struct scsipi_inquiry_data sbp_scsi_inquiry_data;
1270
1271 #define SCSI_XFER_TARGET(x) ((x)->xs_periph->periph_target)
1272 #define SCSI_XFER_LUN(x) ((x)->xs_periph->periph_lun)
1273 #define SCSI_XFER_ERROR(x) ((x)->error)
1274 #define SCSI_XFER_DIR(x) \
1275 ((x)->xs_control & (XS_CTL_DATA_IN | XS_CTL_DATA_OUT))
1276 #define SCSI_XFER_DATA_IN XS_CTL_DATA_IN
1277 #define SCSI_XFER_CALLOUT(x) ((x)->xs_callout)
1278 #define SCSI_XFER_TIMEOUT(x) ((x)->timeout)
1279 #define SCSI_XFER_OPECODE(x) ((x)->cmd->opcode)
1280 #define SCSI_XFER_STATUS(x) ((x)->xs_status)
1281 #define SCSI_XFER_EVPD(x) ((x)->cmd->bytes[0] & SI_EVPD)
1282 #define SI_EVPD 0x01
1283 #define SCSI_XFER_CMDLEN(x) ((x)->cmdlen)
1284 #define SCSI_XFER_CMD(x) ((x)->cmd)
1285 #define SCSI_XFER_DATALEN(x) ((x)->datalen)
1286 #define SCSI_XFER_DATA(x) ((x)->data)
1287 #define SCSI_XFER_SENSELEN(x) (0 /* XXXXX */)
1288 #define SCSI_SENSE_DATA(x) (&(x)->sense.scsi_sense)
1289 #define SCSI_INQUIRY_DATA(x) ((x)->data)
1290 #define SCSI_XFER_FUNCCODE(x) XPT_SCSI_IO
1291 #define SCSI_XFER_10BCMD_DUMP(x)\
1292 ((x)->cmd->opcode), \
1293 ((x)->cmd->bytes[0]), \
1294 ((x)->cmd->bytes[1]), \
1295 ((x)->cmd->bytes[2]), \
1296 ((x)->cmd->bytes[3]), \
1297 ((x)->cmd->bytes[4]), \
1298 ((x)->cmd->bytes[5]), \
1299 ((x)->cmd->bytes[6]), \
1300 ((x)->cmd->bytes[7]), \
1301 ((x)->cmd->bytes[8])
1302 #define SCSI_XFER_REQUEST_COMPLETE(x) \
1303 ((x)->resid = 0)
1304 #define SCSI_TRANSFER_DONE(x) scsipi_done((x))
1305
1306 #define NOT_LUN_WILDCARD(l) (1)
1307 #define CAM_XFER_FLAGS(x) (0) /* XXX */
1308 #define CAM_SCATTER_VALID (0) /* XXX */
1309 #define CAM_DATA_PHYS (0) /* XXX */
1310 #define XPT_SCSI_IO (1) /* XXX */
1311
1312 #ifndef rounddown
1313 #define rounddown(x, y) ((x) / (y) * (y))
1314 #endif
1315
1316
1317 /*
1318 * additional queue macros for NetBSD
1319 */
1320 #define STAILQ_LAST(head, type, field) \
1321 (STAILQ_EMPTY((head)) ? (struct type *)NULL : \
1322 (struct type *) \
1323 ((char *)(head)->stqh_last - (size_t)&((struct type *)0)->field))
1324 #define STAILQ_FOREACH_SAFE(var, head, field, _var) \
1325 (void)(_var); \
1326 STAILQ_FOREACH(var, head, field)
1327
1328
1329 /*
1330 * additional mbuf macros for NetBSD
1331 */
1332 #include <sys/mbuf.h>
1333 #define M_TRYWAIT M_WAITOK
1334
1335 #define MTAG_FIREWIRE 1394
1336 #define MTAG_FIREWIRE_HWADDR 0
1337 #define MTAG_FIREWIRE_SENDER_EUID 1
1338
1339 #define m_tag_alloc(cookie, type, len, wait) \
1340 m_tag_get((type), (len), (wait))
1341 #define m_tag_locate(m, cookie, type, t) \
1342 m_tag_find((m), (type), (t))
1343
1344 /* additional bpf macros */
1345 #define bpf_peers_present(if_bpf) (if_bpf)
1346
1347
1348 #define CTR0(m, format)
1349 #define CTR1(m, format, p1)
1350
1351 #define OHCI_CSR_WRITE(sc, reg, val) \
1352 bus_space_write_4((sc)->bst, (sc)->bsh, reg, val)
1353
1354 #define FILTER_STRAY 0
1355 #define FILTER_HANDLED 1
1356
1357 #define SSD_CURRENT_ERROR 0x70
1358 #define SSD_DEFERRED_ERROR 0x71
1359
1360 #define T_RBC T_SIMPLE_DIRECT
1361
1362 #define SCSI_STATUS_CHECK_COND SCSI_CHECK
1363 #define SCSI_STATUS_BUSY SCSI_BUSY
1364 #define SCSI_STATUS_CMD_TERMINATED SCSI_TERMINATED
1365
1366 #define BUS_SPACE_MAXSIZE_32BIT 0xFFFFFFFF
1367
1368 #define DFLTPHYS (64 * 1024) /* fake */
1369
1370 #define kdb_backtrace()
1371 #define kdb_active 0
1372
1373 #endif
1374 #endif
1375 #if defined(__NetBSD__)
1376 #define vm_offset_t void *
1377 #endif
1378 #endif
Cache object: 19a722b3ef6059ee8f96d67c3dc0363c
|