The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/ieee1394/fw_port.h

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    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


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.