/*
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * Copyright 2005-06 Adaptec, Inc.
 * Copyright (c) 2005-06 Adaptec Inc., Achim Leubner
 * Copyright (c) 2000 Michael Smith
 * Copyright (c) 2001 Scott Long
 * Copyright (c) 2000 BSDi
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *    $FreeBSD: src/sys/dev/aac/aacvar.h,v 1.47 2005/10/08 15:55:09 scottl Exp $
 */

#ifndef _AAC_H_
#define _AAC_H_

#ifdef  __cplusplus
extern "C" {
#endif

#define AAC_ROUNDUP(x, y)               (((x) + (y) - 1) / (y) * (y))

#define AAC_TYPE_DEVO                   1
#define AAC_TYPE_ALPHA                  2
#define AAC_TYPE_BETA                   3
#define AAC_TYPE_RELEASE                4

#ifndef AAC_DRIVER_BUILD
#define AAC_DRIVER_BUILD                1
#endif

#define AAC_DRIVER_MAJOR_VERSION        2
#define AAC_DRIVER_MINOR_VERSION        2
#define AAC_DRIVER_BUGFIX_LEVEL         11
#define AAC_DRIVER_TYPE                 AAC_TYPE_RELEASE

#define STR(s)                          # s
#define AAC_VERSION(a, b, c)            STR(a.b.c)
#define AAC_DRIVER_VERSION              AAC_VERSION(AAC_DRIVER_MAJOR_VERSION, \
                                        AAC_DRIVER_MINOR_VERSION, \
                                        AAC_DRIVER_BUGFIX_LEVEL)

#define AACOK                           0
#define AACERR                          -1

#define AAC_MAX_ADAPTERS                64

/* Definitions for mode sense */
#ifndef SD_MODE_SENSE_PAGE3_CODE
#define SD_MODE_SENSE_PAGE3_CODE        0x03
#endif

#ifndef SD_MODE_SENSE_PAGE4_CODE
#define SD_MODE_SENSE_PAGE4_CODE        0x04
#endif

#ifndef SCMD_SYNCHRONIZE_CACHE
#define SCMD_SYNCHRONIZE_CACHE          0x35
#endif

/*
 * The controller reports status events in AIFs. We hang on to a number of
 * these in order to pass them out to user-space management tools.
 */
#define AAC_AIFQ_LENGTH                 64

#ifdef __x86
#define AAC_IMMEDIATE_TIMEOUT           30      /* seconds */
#else
#define AAC_IMMEDIATE_TIMEOUT           60      /* seconds */
#endif
#define AAC_FWUP_TIMEOUT                180     /* wait up to 3 minutes */
#define AAC_IOCTL_TIMEOUT               900     /* wait up to 15 minutes */
#define AAC_SYNC_TIMEOUT                900     /* wait up to 15 minutes */

/* Adapter hardware interface types */
#define AAC_HWIF_UNKNOWN                0
#define AAC_HWIF_I960RX                 1
#define AAC_HWIF_RKT                    2

#define AAC_TYPE_UNKNOWN                0
#define AAC_TYPE_SCSI                   1
#define AAC_TYPE_SATA                   2
#define AAC_TYPE_SAS                    3

#define AAC_LS32(d)                     ((uint32_t)((d) & 0xffffffffull))
#define AAC_MS32(d)                     ((uint32_t)((d) >> 32))
#define AAC_LO32(p64)                   ((uint32_t *)(p64))
#define AAC_HI32(p64)                   ((uint32_t *)(p64) + 1)

/*
 * Internal events that will be handled serially by aac_event_thread()
 */
#define AAC_EVENT_AIF                   (1 << 0)
#define AAC_EVENT_TIMEOUT               (1 << 1)
#define AAC_EVENT_SYNCTICK              (1 << 2)

/*
 * AAC_CMDQ_SYNC should be 0 and AAC_CMDQ_ASYNC be 1 for Sync FIB io
 * to be served before async FIB io, see aac_start_waiting_io().
 * So that io requests sent by interactive userland commands get
 * responded asap.
 */
enum aac_cmdq {
        AAC_CMDQ_SYNC,  /* sync FIB queue */
        AAC_CMDQ_ASYNC, /* async FIB queue */
        AAC_CMDQ_NUM
};

/*
 * IO command flags
 */
#define AAC_IOCMD_SYNC          (1 << AAC_CMDQ_SYNC)
#define AAC_IOCMD_ASYNC         (1 << AAC_CMDQ_ASYNC)
#define AAC_IOCMD_OUTSTANDING   (1 << AAC_CMDQ_NUM)
#define AAC_IOCMD_ALL           (AAC_IOCMD_SYNC | AAC_IOCMD_ASYNC | \
                                AAC_IOCMD_OUTSTANDING)

struct aac_cmd_queue {
        struct aac_cmd *q_head; /* also as the header of aac_cmd */
        struct aac_cmd *q_tail;
};

struct aac_card_type {
        uint16_t vendor;        /* PCI Vendor ID */
        uint16_t device;        /* PCI Device ID */
        uint16_t subvendor;     /* PCI Subsystem Vendor ID */
        uint16_t subsys;        /* PCI Subsystem ID */
        uint16_t hwif;          /* card chip type: i960 or Rocket */
        uint16_t quirks;        /* card odd limits */
        uint16_t type;          /* hard drive type */
        char *vid;              /* ASCII data for INQUIRY command vendor id */
        char *desc;             /* ASCII data for INQUIRY command product id */
};

/* Device types */
#define AAC_DEV_LD              0       /* logical device */
#define AAC_DEV_PD              1       /* physical device */

/* Device flags */
#define AAC_DFLAG_VALID         (1 << 0)
#define AAC_DFLAG_CONFIGURING   (1 << 1)

#define AAC_DEV_IS_VALID(dvp)   ((dvp)->flags & AAC_DFLAG_VALID)
#define AAC_P2VTGT(softs, bus, tgt) \
                ((softs)->tgt_max * (bus) + (tgt) + AAC_MAX_LD)

/*
 * Device config change events
 */
enum aac_cfg_event {
        AAC_CFG_NULL_NOEXIST = 0,       /* No change with no device */
        AAC_CFG_NULL_EXIST,             /* No change but have device */
        AAC_CFG_ADD,                    /* Device added */
        AAC_CFG_DELETE,                 /* Device deleted */
        AAC_CFG_CHANGE                  /* Device changed */
};

struct aac_device {
        int flags;

        uint8_t type;
        dev_info_t *dip;
        int ncmds[AAC_CMDQ_NUM];        /* outstanding cmds of the device */
        int throttle[AAC_CMDQ_NUM];     /* hold IO cmds for the device */
};

/* Array description */
struct aac_container {
        struct aac_device dev;

        uint32_t cid;           /* container id */
        uint32_t uid;           /* container uid */
        uint64_t size;          /* in block */
        uint8_t locked;
        uint8_t deleted;
        uint8_t reset;          /* container is being reseted */
};

/* Non-DASD phys. device descrption, eg. CDROM or tape */
struct aac_nondasd {
        struct aac_device dev;

        uint32_t bus;
        uint32_t tid;
};

/*
 * The firmware can support a lot of outstanding commands. Each aac_slot
 * is corresponding to one of such commands. It records the command and
 * associated DMA resource for FIB command.
 */
struct aac_slot {
        struct aac_slot *next;  /* next slot in the free slot list */
        int index;              /* index of this slot */
        ddi_acc_handle_t fib_acc_handle;
        ddi_dma_handle_t fib_dma_handle;
        uint64_t fib_phyaddr;   /* physical address of FIB memory */
        struct aac_cmd *acp;    /* command using this slot */
        struct aac_fib *fibp;   /* virtual address of FIB memory */
};

/*
 * Scatter-gather list structure defined by HBA hardware
 */
struct aac_sge {
        uint32_t bcount;        /* byte count */
        union {
                uint32_t ad32;  /* 32 bit address */
                struct {
                        uint32_t lo;
                        uint32_t hi;
                } ad64;         /* 64 bit address */
        } addr;
};

/* aac_cmd flags */
#define AAC_CMD_CONSISTENT              (1 << 0)
#define AAC_CMD_DMA_PARTIAL             (1 << 1)
#define AAC_CMD_DMA_VALID               (1 << 2)
#define AAC_CMD_BUF_READ                (1 << 3)
#define AAC_CMD_BUF_WRITE               (1 << 4)
#define AAC_CMD_SYNC                    (1 << 5) /* use sync FIB */
#define AAC_CMD_NO_INTR                 (1 << 6) /* poll IO, no intr */
#define AAC_CMD_NO_CB                   (1 << 7) /* sync IO, no callback */
#define AAC_CMD_NTAG                    (1 << 8)
#define AAC_CMD_CMPLT                   (1 << 9) /* cmd exec'ed by driver/fw */
#define AAC_CMD_ABORT                   (1 << 10)
#define AAC_CMD_TIMEOUT                 (1 << 11)
#define AAC_CMD_ERR                     (1 << 12)
#define AAC_CMD_IN_SYNC_SLOT            (1 << 13)

struct aac_softstate;
typedef void (*aac_cmd_fib_t)(struct aac_softstate *, struct aac_cmd *);

struct aac_cmd {
        /*
         * Note: should be the first member for aac_cmd_queue to work
         * correctly.
         */
        struct aac_cmd *next;
        struct aac_cmd *prev;

        struct scsi_pkt *pkt;
        int cmdlen;
        int flags;
        uint32_t timeout; /* time when the cmd should have completed */
        struct buf *bp;
        ddi_dma_handle_t buf_dma_handle;

        /* For non-aligned buffer and SRB */
        caddr_t abp;
        ddi_acc_handle_t abh;

        /* Data transfer state */
        ddi_dma_cookie_t cookie;
        uint_t left_cookien;
        uint_t cur_win;
        uint_t total_nwin;
        size_t total_xfer;
        uint64_t blkno;
        uint32_t bcount;        /* buffer size in byte */
        struct aac_sge *sgt;    /* sg table */

        /* FIB construct function */
        aac_cmd_fib_t aac_cmd_fib;
        /* Call back function for completed command */
        void (*ac_comp)(struct aac_softstate *, struct aac_cmd *);

        struct aac_slot *slotp; /* slot used by this command */
        struct aac_device *dvp; /* target device */

        /* FIB for this IO command */
        int fib_size; /* size of the FIB xferred to/from the card */
        struct aac_fib *fibp;

#ifdef DEBUG
        uint32_t fib_flags;
#endif
};

/* Flags for attach tracking */
#define AAC_ATTACH_SOFTSTATE_ALLOCED    (1 << 0)
#define AAC_ATTACH_CARD_DETECTED        (1 << 1)
#define AAC_ATTACH_PCI_MEM_MAPPED       (1 << 2)
#define AAC_ATTACH_KMUTEX_INITED        (1 << 3)
#define AAC_ATTACH_SCSI_TRAN_SETUP      (1 << 4)
#define AAC_ATTACH_COMM_SPACE_SETUP     (1 << 5)
#define AAC_ATTACH_CREATE_DEVCTL        (1 << 6)
#define AAC_ATTACH_CREATE_SCSI          (1 << 7)

/* Driver running states */
#define AAC_STATE_STOPPED       0
#define AAC_STATE_RUN           (1 << 0)
#define AAC_STATE_RESET         (1 << 1)
#define AAC_STATE_QUIESCED      (1 << 2)
#define AAC_STATE_DEAD          (1 << 3)
#define AAC_STATE_INTR          (1 << 4)

/*
 * Flags for aac firmware
 * Note: Quirks are only valid for the older cards. These cards only supported
 * old comm. Thus they are not valid for any cards that support new comm.
 */
#define AAC_FLAGS_SG_64BIT      (1 << 0) /* Use 64-bit S/G addresses */
#define AAC_FLAGS_4GB_WINDOW    (1 << 1) /* Can access host mem 2-4GB range */
#define AAC_FLAGS_NO4GB (1 << 2)        /* quirk: FIB addresses must reside */
                                        /*        between 0x2000 & 0x7FFFFFFF */
#define AAC_FLAGS_256FIBS       (1 << 3) /* quirk: Can only do 256 commands */
#define AAC_FLAGS_NEW_COMM      (1 << 4) /* New comm. interface supported */
#define AAC_FLAGS_RAW_IO        (1 << 5) /* Raw I/O interface */
#define AAC_FLAGS_ARRAY_64BIT   (1 << 6) /* 64-bit array size */
#define AAC_FLAGS_LBA_64BIT     (1 << 7) /* 64-bit LBA supported */
#define AAC_FLAGS_17SG          (1 << 8) /* quirk: 17 scatter gather maximum */
#define AAC_FLAGS_34SG          (1 << 9) /* quirk: 34 scatter gather maximum */
#define AAC_FLAGS_NONDASD       (1 << 10) /* non-DASD device supported */
#define AAC_FLAGS_BRKUP         (1 << 11) /* pkt breakup support */
#define AAC_FLAGS_JBOD          (1 << 12) /* JBOD mode support */

struct aac_softstate;
struct aac_interface {
        int (*aif_get_fwstatus)(struct aac_softstate *);
        int (*aif_get_mailbox)(struct aac_softstate *, int);
        void (*aif_set_mailbox)(struct aac_softstate *, uint32_t,
            uint32_t, uint32_t, uint32_t, uint32_t);
};

#define AAC_CTXFLAG_FILLED      0x01    /* aifq's full for this ctx */
#define AAC_CTXFLAG_RESETED     0x02

struct aac_fib_context {
        uint32_t unique;
        int ctx_idx;
        int ctx_filled;         /* aifq is full for this fib context */
        int ctx_flags;
        int ctx_overrun;
        struct aac_fib_context *next, *prev;
};

#define AAC_VENDOR_LEN          8
#define AAC_PRODUCT_LEN         16

struct aac_softstate {
        int card;               /* index to aac_cards */
        uint16_t hwif;          /* card chip type: i960 or Rocket */
        uint16_t vendid;        /* vendor id */
        uint16_t subvendid;     /* sub vendor id */
        uint16_t devid;         /* device id */
        uint16_t subsysid;      /* sub system id */
        char vendor_name[AAC_VENDOR_LEN + 1];
        char product_name[AAC_PRODUCT_LEN + 1];
        uint32_t support_opt;   /* firmware features */
        uint32_t support_opt2;
        uint32_t feature_bits;
        uint32_t atu_size;      /* actual size of PCI mem space */
        uint32_t map_size;      /* mapped PCI mem space size */
        uint32_t map_size_min;  /* minimum size of PCI mem that must be */
                                /* mapped to address the card */
        int flags;              /* firmware features enabled */
        int instance;
        dev_info_t *devinfo_p;
        scsi_hba_tran_t *hba_tran;
        int slen;
        int legacy;             /* legacy device naming */
        uint32_t dma_max;       /* for buf breakup */

        /* DMA attributes */
        ddi_dma_attr_t buf_dma_attr;
        ddi_dma_attr_t addr_dma_attr;

        /* PCI spaces */
        ddi_device_acc_attr_t acc_attr;
        ddi_device_acc_attr_t reg_attr;
        ddi_acc_handle_t pci_mem_handle;
        uint8_t *pci_mem_base_vaddr;
        uint32_t pci_mem_base_paddr;

        struct aac_interface aac_if;    /* adapter hardware interface */

        struct aac_cmd sync_ac;         /* sync FIB */

        /* Communication space */
        struct aac_comm_space *comm_space;
        ddi_acc_handle_t comm_space_acc_handle;
        ddi_dma_handle_t comm_space_dma_handle;
        uint32_t comm_space_phyaddr;

        /* Old Comm. interface: message queues */
        struct aac_queue_table *qtablep;
        struct aac_queue_entry *qentries[AAC_QUEUE_COUNT];

        /* New Comm. interface */
        uint32_t aac_max_fibs;          /* max. FIB count */
        uint32_t aac_max_fib_size;      /* max. FIB size */
        uint32_t aac_sg_tablesize;      /* max. sg count from host */
        uint32_t aac_max_sectors;       /* max. I/O size from host (blocks) */

        aac_cmd_fib_t aac_cmd_fib;      /* IO cmd FIB construct function */
        aac_cmd_fib_t aac_cmd_fib_scsi; /* SRB construct function */

        ddi_softintr_t softint_id;      /* soft intr */

        kmutex_t io_lock;
        int state;                      /* driver state */

        struct aac_container containers[AAC_MAX_LD];
        int container_count;            /* max container id + 1 */
        struct aac_nondasd *nondasds;
        uint32_t bus_max;               /* max FW buses exposed */
        uint32_t tgt_max;               /* max FW target per bus */

        /*
         * Command queues
         * Each aac command flows through wait(or wait_sync) queue,
         * busy queue, and complete queue sequentially.
         */
        struct aac_cmd_queue q_wait[AAC_CMDQ_NUM];
        struct aac_cmd_queue q_busy;    /* outstanding cmd queue */
        kmutex_t q_comp_mutex;
        struct aac_cmd_queue q_comp;    /* completed io requests */

        /* I/O slots and FIBs */
        int total_slots;                /* total slots allocated */
        int total_fibs;                 /* total FIBs allocated */
        struct aac_slot *io_slot;       /* static list for allocated slots */
        struct aac_slot *free_io_slot_head;

        kcondvar_t event;               /* for ioctl_send_fib() and sync IO */
        kcondvar_t sync_fib_cv;         /* for sync_fib_slot_bind/release */

        int bus_ncmds[AAC_CMDQ_NUM];    /* total outstanding async cmds */
        int bus_throttle[AAC_CMDQ_NUM]; /* hold IO cmds for the bus */
        int ndrains;                    /* number of draining threads */
        timeout_id_t drain_timeid;      /* for outstanding cmd drain */
        kcondvar_t drain_cv;            /* for quiesce drain */

        /* Internal timer */
        kmutex_t time_mutex;
        timeout_id_t timeout_id;        /* for timeout daemon */
        uint32_t timebase;              /* internal timer in seconds */
        uint32_t time_sync;             /* next time to sync with firmware */
        uint32_t time_out;              /* next time to check timeout */
        uint32_t time_throttle;         /* next time to restore throttle */

        /* Internal events handling */
        kmutex_t ev_lock;
        int events;
        kthread_t *event_thread;        /* for AIF & timeout */
        kcondvar_t event_wait_cv;
        kcondvar_t event_disp_cv;

        /* AIF */
        kmutex_t aifq_mutex;            /* for AIF queue aifq */
        kcondvar_t aifq_cv;
        union aac_fib_align aifq[AAC_AIFQ_LENGTH];
        int aifq_idx;                   /* slot for next new AIF */
        int aifq_wrap;                  /* AIF queue has ever been wrapped */
        struct aac_fib_context aifctx;  /* sys aif ctx */
        struct aac_fib_context *fibctx_p;
        int devcfg_wait_on;             /* AIF event waited for rescan */

        int fm_capabilities;

        /* MSI specific fields */
        ddi_intr_handle_t *htable;      /* For array of interrupts */
        int intr_type;                  /* What type of interrupt */
        int intr_cnt;                   /* # of intrs count returned */
        int intr_size;
        uint_t intr_pri;                /* Interrupt priority   */
        int intr_cap;                   /* Interrupt capabilities */

#ifdef DEBUG
        /* UART trace printf variables */
        uint32_t debug_flags;           /* debug print flags bitmap */
        uint32_t debug_fib_flags;       /* debug FIB print flags bitmap */
        uint32_t debug_fw_flags;        /* FW debug flags */
        uint32_t debug_buf_offset;      /* offset from DPMEM start */
        uint32_t debug_buf_size;        /* FW debug buffer size in bytes */
        uint32_t debug_header_size;     /* size of debug header */
#endif
};

/*
 * The following data are kept stable because they are only written at driver
 * initialization, and we do not allow them changed otherwise even at driver
 * re-initialization.
 */
_NOTE(SCHEME_PROTECTS_DATA("stable data", aac_softstate::{flags slen \
    buf_dma_attr pci_mem_handle pci_mem_base_vaddr \
    comm_space_acc_handle comm_space_dma_handle aac_max_fib_size \
    aac_sg_tablesize aac_cmd_fib aac_cmd_fib_scsi debug_flags bus_max tgt_max}))

#ifdef DEBUG

#define AACDB_FLAGS_MASK                0x0000ffff
#define AACDB_FLAGS_KERNEL_PRINT        0x00000001
#define AACDB_FLAGS_FW_PRINT            0x00000002
#define AACDB_FLAGS_NO_HEADERS          0x00000004

#define AACDB_FLAGS_MISC                0x00000010
#define AACDB_FLAGS_FUNC1               0x00000020
#define AACDB_FLAGS_FUNC2               0x00000040
#define AACDB_FLAGS_SCMD                0x00000080
#define AACDB_FLAGS_AIF                 0x00000100
#define AACDB_FLAGS_FIB                 0x00000200
#define AACDB_FLAGS_IOCTL               0x00000400

/*
 * Flags for FIB print
 */
/* FIB sources */
#define AACDB_FLAGS_FIB_SCMD            0x00000001
#define AACDB_FLAGS_FIB_IOCTL           0x00000002
#define AACDB_FLAGS_FIB_SRB             0x00000004
#define AACDB_FLAGS_FIB_SYNC            0x00000008
/* FIB components */
#define AACDB_FLAGS_FIB_HEADER          0x00000010
/* FIB states */
#define AACDB_FLAGS_FIB_TIMEOUT         0x00000100

extern uint32_t aac_debug_flags;
extern int aac_dbflag_on(struct aac_softstate *, int);
extern void aac_printf(struct aac_softstate *, uint_t, const char *, ...);
extern void aac_print_fib(struct aac_softstate *, struct aac_slot *);

#define AACDB_PRINT(s, lev, ...) { \
        if (aac_dbflag_on((s), AACDB_FLAGS_MISC)) \
                aac_printf((s), (lev), __VA_ARGS__); }

#define AACDB_PRINT_IOCTL(s, ...) { \
        if (aac_dbflag_on((s), AACDB_FLAGS_IOCTL)) \
                aac_printf((s), CE_NOTE, __VA_ARGS__); }

#define AACDB_PRINT_TRAN(s, ...) { \
        if (aac_dbflag_on((s), AACDB_FLAGS_SCMD)) \
                aac_printf((s), CE_NOTE, __VA_ARGS__); }

#define DBCALLED(s, n) { \
        if (aac_dbflag_on((s), AACDB_FLAGS_FUNC ## n)) \
                aac_printf((s), CE_NOTE, "--- %s() called ---", __func__); }

#define AACDB_PRINT_SCMD(s, x) { \
        if (aac_dbflag_on((s), AACDB_FLAGS_SCMD)) aac_print_scmd((s), (x)); }

#define AACDB_PRINT_AIF(s, x) { \
        if (aac_dbflag_on((s), AACDB_FLAGS_AIF)) aac_print_aif((s), (x)); }

#define AACDB_PRINT_FIB(s, x) { \
        if (aac_dbflag_on((s), AACDB_FLAGS_FIB)) aac_print_fib((s), (x)); }

#else /* DEBUG */

#define AACDB_PRINT(s, lev, ...)
#define AACDB_PRINT_IOCTL(s, ...)
#define AACDB_PRINT_TRAN(s, ...)
#define AACDB_PRINT_FIB(s, x)
#define AACDB_PRINT_SCMD(s, x)
#define AACDB_PRINT_AIF(s, x)
#define DBCALLED(s, n)

#endif /* DEBUG */

#ifdef  __cplusplus
}
#endif

#endif /* _AAC_H_ */