async
async_t async;
async_t *cmd = &pp->ipdu.async;
nvme_async_cmd_t async;
nvme_async_res_t async;
if (tag->async)
tag->async = 0;
static void xa_start(xa_tag_t *tag, kdmsg_msg_t *msg, int async);
xa_start(xa_tag_t *tag, kdmsg_msg_t *msg, int async)
tag->async = async;
int async;
bool async;
adev->mode_info.funcs->page_flip(adev, work->crtc_id, work->base, work->async);
work->async = (page_flip_flags & DRM_MODE_PAGE_FLIP_ASYNC) != 0;
#define amdgpu_display_page_flip(adev, crtc, base, async) (adev)->mode_info.funcs->page_flip((adev), (crtc), (base), (async))
int crtc_id, u64 crtc_base, bool async);
int crtc_id, u64 crtc_base, bool async)
GRPH_SURFACE_UPDATE_H_RETRACE_EN, async ? 1 : 0);
int crtc_id, u64 crtc_base, bool async)
GRPH_SURFACE_UPDATE_IMMEDIATE_EN, async ? 1 : 0);
int crtc_id, u64 crtc_base, bool async)
WREG32(mmGRPH_FLIP_CONTROL + amdgpu_crtc->crtc_offset, async ?
int crtc_id, u64 crtc_base, bool async)
bool async)
async ? EVERGREEN_GRPH_SURFACE_UPDATE_H_RETRACE_EN : 0);
void r100_page_flip(struct radeon_device *rdev, int crtc_id, u64 crtc_base, bool async)
void (*page_flip)(struct radeon_device *rdev, int crtc, u64 crtc_base, bool async);
#define radeon_page_flip(rdev, crtc, base, async) (rdev)->asic->pflip.page_flip((rdev), (crtc), (base), (async))
bool async;
u64 crtc_base, bool async);
u64 crtc_base, bool async);
bool async);
u64 crtc_base, bool async);
radeon_page_flip(rdev, radeon_crtc->crtc_id, work->base, work->async);
work->async = (page_flip_flags & DRM_MODE_PAGE_FLIP_ASYNC) != 0;
void rs600_page_flip(struct radeon_device *rdev, int crtc_id, u64 crtc_base, bool async)
async ? AVIVO_D1GRPH_SURFACE_UPDATE_H_RETRACE_EN : 0);
void rv770_page_flip(struct radeon_device *rdev, int crtc_id, u64 crtc_base, bool async)
async ? AVIVO_D1GRPH_SURFACE_UPDATE_H_RETRACE_EN : 0);
int async, wantresp;
async = hcmd->flags & IWM_CMD_ASYNC;
KASSERT(!async, ("invalid async parameter"));
async ? " (async)" : "");
if (!async) {
iwn_cmd(struct iwn_softc *sc, int code, const void *buf, int size, int async)
if (async == 0)
return async ? 0 : lksleep(desc, &sc->sc_lk, PCATCH, "iwncmd", hz);
return async ? 0 : msleep(desc, &sc->sc_mtx, PCATCH, "iwncmd", hz);
iwn4965_add_node(struct iwn_softc *sc, struct iwn_node_info *node, int async)
return iwn_cmd(sc, IWN_CMD_ADD_NODE, &hnode, sizeof hnode, async);
iwn5000_add_node(struct iwn_softc *sc, struct iwn_node_info *node, int async)
return iwn_cmd(sc, IWN_CMD_ADD_NODE, node, sizeof (*node), async);
iwn_add_broadcast_node(struct iwn_softc *sc, int async)
if ((error = ops->add_node(sc, &node, async)) != 0)
return iwn_cmd(sc, IWN_CMD_LINK_QUALITY, &linkq, sizeof linkq, async);
int async)
return iwn_cmd(sc, IWN_CMD_TXPOWER, &cmd, sizeof cmd, async);
int async)
return iwn_cmd(sc, cmdid, &cmd, sizeof cmd, async);
iwn_set_pslevel(struct iwn_softc *sc, int dtim, int level, int async)
async);
return iwn_cmd(sc, IWN_CMD_SET_POWER_MODE, &cmd, sizeof cmd, async);
int async)
if (async == 0)
__func__, wpi_cmd_str(code), size, async);
return async ? 0 : lksleep(cmd, &sc->sc_mtx, PCATCH, "wpicmd", hz);
return async ? 0 : mtx_sleep(cmd, &sc->sc_mtx, PCATCH, "wpicmd", hz);
wpi_add_broadcast_node(struct wpi_softc *sc, int async)
return wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, async);
wpi_set_txpower(struct wpi_softc *sc, int async)
return wpi_cmd(sc, WPI_CMD_TXPOWER, &cmd, sizeof cmd, async);
wpi_set_pslevel(struct wpi_softc *sc, uint8_t dtim, int level, int async)
__func__, dtim, level, async);
return wpi_cmd(sc, WPI_CMD_SET_POWER_MODE, &cmd, sizeof cmd, async);
wpi_send_rxon(struct wpi_softc *sc, int assoc, int async)
if (async)
sizeof (struct wpi_assoc), async);
if (async) {
sizeof (struct wpi_rxon), async);
sizeof (struct wpi_rxon), async);
error = wpi_add_broadcast_node(sc, async);
if ((error = wpi_set_txpower(sc, async)) != 0) {
gdt->sc_dvr.eu.async.ionode = gdt->sc_hanum;
gdt->sc_dvr.eu.async.status = gdt->sc_status;
gdt->sc_dvr.size = sizeof(gdt->sc_dvr.eu.async);
gdt->sc_dvr.eu.async.ionode = gdt->sc_hanum;
gdt->sc_dvr.eu.async.service = service;
gdt->sc_dvr.eu.async.status = gdt->sc_status;
gdt->sc_dvr.eu.async.info = gdt->sc_info;
*(u_int32_t *)gdt->sc_dvr.eu.async.scsi_coord = gdt->sc_info2;
} async;
p->dvr.event_data.size = sizeof(p->dvr.event_data.eu.async);
struct proc *async;
if (m->async) {
PHOLD(m->async);
ksignal(m->async, SIGIO);
PRELE(m->async);
if (m->async) {
PHOLD(m->async);
ksignal(m->async, SIGIO);
PRELE(m->async);
m->async = 0;
int cnt = 0, async = 0;
async = 1;
async = 0;
async = 1;
async = 0;
if (!async) {
int async;
async = vp->v_mount->mnt_flag & MNT_ASYNC;
async = 0;
if (!async && seqcount > 0) {
if (!async && cc->v_clen == 0) { /* I/O not contiguous */
NETGRAPH_INIT(async, &typestruct);
hookp = &sc->async;
if (hook == sc->async)
if (hook == sc->async)
hookp = &sc->async;
NG_SEND_DATA(error, sc->async, m, meta);
NG_SEND_DATA(error, sc->async, m, meta);
hook_p async; /* Asynchronous side */
if (async && highest_dlci) {
NETGRAPH_INIT(async, &typestruct);
hookp = &sc->async;
if (hook == sc->async)
if (hook == sc->async)
hookp = &sc->async;
NG_FWD_ITEM_HOOK(error, item, sc->async );
NG_FWD_NEW_DATA(error, item, sc->async, m);
hook_p async; /* Asynchronous side */
if (async && highest_dlci) {
SYSCTL_INT(_vfs_nfs, OID_AUTO, async, CTLFLAG_RW, &nfs_async, 0,
cp = p->async.xbuff;
async_Encode(&p->async, &cp, *sp++, *proto);
cnt = cp - p->async.xbuff;
memcpy(MBUF_CTOP(bp), p->async.xbuff, cnt);
async_Decode(struct async *async, u_char c)
if ((async->mode & MODE_HUNT) && c != HDLC_SYN)
async->mode &= ~MODE_HUNT;
if (async->length) { /* packet is ready. */
bp = m_get(async->length, MB_ASYNCIN);
mbuf_Write(bp, async->hbuff, async->length);
async->length = 0;
if (!(async->mode & MODE_ESC)) {
async->mode |= MODE_ESC;
if (async->length >= HDLCSIZE) {
async->length);
async->length = 0;
async->mode = MODE_HUNT;
if (async->mode & MODE_ESC) {
async->mode &= ~MODE_ESC;
async->hbuff[async->length++] = c;
*last = async_Decode(&p->async, *ch++);
async_Init(struct async *async)
async_Setup(async);
memset(async->cfg.EscMap, '\0', sizeof async->cfg.EscMap);
async_Setup(struct async *async)
async->mode = MODE_HUNT;
async->length = 0;
async->my_accmap = async->his_accmap = 0xffffffff;
async_SetLinkParams(struct async *async, u_int32_t mymap, u_int32_t hismap)
async->my_accmap = mymap;
async->his_accmap = hismap | mymap;
async_Encode(struct async *async, u_char **cp, u_char c, int proto)
if ((c < 0x20 && (proto == PROTO_LCP || (async->his_accmap & (1 << c))))
if (async->cfg.EscMap[32] && async->cfg.EscMap[c >> 3] & (1 << (c & 7))) {
extern void async_Init(struct async *);
extern void async_Setup(struct async *);
extern void async_SetLinkParams(struct async *, u_int32_t, u_int32_t);
arg->cx->physical->async.cfg.EscMap[code] = 0;
arg->cx->physical->async.cfg.EscMap[code >> 3] |= (1 << (code & 7));
arg->cx->physical->async.cfg.EscMap[32] = 1;
if (arg->cx->physical->async.cfg.EscMap[32]) {
if (arg->cx->physical->async.cfg.EscMap[code])
if (arg->cx->physical->async.cfg.EscMap[code] & (1 << bit)) {
async_Setup(&dl->physical->async);
memcpy(&dl->physical->async.cfg, &odl->physical->async.cfg,
sizeof dl->physical->async.cfg);
async_SetLinkParams(&p->async, mymap, hismap);
async_Init(&p->async);
struct async async; /* Our async state */
async_SetLinkParams(&p->async, mymap, hismap);
int async;
async = TRUE;
clnt_control(clnt, CLSET_ASYNC, (char *)&async);