req 144 altq/altq_cbq.c cbq_request(struct ifaltq *ifq, int req, void *arg)
req 148 altq/altq_cbq.c switch (req) {
req 307 altq/altq_hfsc.c hfsc_request(struct ifaltq *ifq, int req, void *arg)
req 311 altq/altq_hfsc.c switch (req) {
req 212 altq/altq_priq.c priq_request(struct ifaltq *ifq, int req, void *arg)
req 216 altq/altq_priq.c switch (req) {
req 351 arch/i386/i386/esm.c struct esm_smb_req req;
req 356 arch/i386/i386/esm.c memset(&req, 0, sizeof(req));
req 357 arch/i386/i386/esm.c req.h_cmd = ESM2_CMD_SMB_XMIT_RECV;
req 358 arch/i386/i386/esm.c req.h_dev = es->es_dev;
req 359 arch/i386/i386/esm.c req.h_txlen = sizeof(req.req_val);
req 360 arch/i386/i386/esm.c req.h_rxlen = sizeof(resp.resp_val);
req 361 arch/i386/i386/esm.c req.req_val.v_cmd = ESM2_SMB_SENSOR_VALUE;
req 362 arch/i386/i386/esm.c req.req_val.v_sensor = es->es_id;
req 376 arch/i386/i386/esm.c if ((step = esm_smb_cmd(sc, &req, &resp, 0, sc->sc_step)) != 0) {
req 478 arch/i386/i386/esm.c struct esm_devmap_req req;
req 484 arch/i386/i386/esm.c memset(&req, 0, sizeof(req));
req 487 arch/i386/i386/esm.c req.cmd = ESM2_CMD_DEVICEMAP;
req 488 arch/i386/i386/esm.c req.action = ESM2_DEVICEMAP_READ;
req 489 arch/i386/i386/esm.c req.index = dev;
req 490 arch/i386/i386/esm.c req.ndev = 1;
req 492 arch/i386/i386/esm.c if (esm_cmd(sc, &req, sizeof(req), &resp, sizeof(resp), 1, 0) != 0)
req 821 arch/i386/i386/esm.c struct esm_smb_req req;
req 831 arch/i386/i386/esm.c memset(&req, 0, sizeof(req));
req 832 arch/i386/i386/esm.c req.h_cmd = ESM2_CMD_SMB_XMIT_RECV;
req 833 arch/i386/i386/esm.c req.h_dev = devmap->index;
req 834 arch/i386/i386/esm.c req.h_txlen = sizeof(req.req_val);
req 835 arch/i386/i386/esm.c req.h_rxlen = sizeof(resp.resp_val);
req 837 arch/i386/i386/esm.c req.req_val.v_cmd = ESM2_SMB_SENSOR_VALUE;
req 840 arch/i386/i386/esm.c req.req_val.v_sensor = i;
req 841 arch/i386/i386/esm.c if (esm_smb_cmd(sc, &req, &resp, 1, 0) != 0)
req 947 arch/i386/i386/esm.c struct esm_smb_req req;
req 951 arch/i386/i386/esm.c memset(&req, 0, sizeof(req));
req 952 arch/i386/i386/esm.c req.h_cmd = ESM2_CMD_SMB_XMIT_RECV;
req 953 arch/i386/i386/esm.c req.h_dev = devmap->index;
req 954 arch/i386/i386/esm.c req.h_txlen = sizeof(req.req_thr);
req 955 arch/i386/i386/esm.c req.h_rxlen = sizeof(resp.resp_thr);
req 957 arch/i386/i386/esm.c req.req_thr.t_cmd = ESM2_SMB_SENSOR_THRESHOLDS;
req 958 arch/i386/i386/esm.c req.req_thr.t_sensor = es->es_id;
req 960 arch/i386/i386/esm.c if (esm_smb_cmd(sc, &req, &resp, 1, 0) != 0)
req 1045 arch/i386/i386/esm.c esm_smb_cmd(struct esm_softc *sc, struct esm_smb_req *req,
req 1052 arch/i386/i386/esm.c err = esm_cmd(sc, req, sizeof(req->hdr) + req->h_txlen, resp,
req 1053 arch/i386/i386/esm.c sizeof(resp->hdr) + req->h_rxlen, wait, step);
req 1060 arch/i386/i386/esm.c __func__, req->h_dev, resp->h_status, resp->h_i2csts,
req 83 compat/freebsd/freebsd_ptrace.c switch (SCARG(uap, req)) {
req 86 compat/freebsd/freebsd_ptrace.c SCARG(&npa, req) = PT_STEP;
req 106 compat/freebsd/freebsd_ptrace.c SCARG(&npa, req) = PT_GETREGS;
req 112 compat/freebsd/freebsd_ptrace.c SCARG(&npa, req) = PT_GETFPREGS;
req 119 compat/freebsd/freebsd_ptrace.c switch (SCARG(uap, req)) {
req 131 compat/freebsd/freebsd_ptrace.c SCARG(&npa, req) = PT_SETREGS;
req 137 compat/freebsd/freebsd_ptrace.c SCARG(&npa, req) = PT_SETFPREGS;
req 86 compat/freebsd/freebsd_syscallargs.h syscallarg(int) req;
req 92 compat/hpux/hppa/hpux_syscallargs.h syscallarg(int) req;
req 567 compat/hpux/hpux_compat.c switch (SCARG(uap, req)) {
req 612 compat/hpux/hpux_compat.c if (isps && SCARG(uap, req) == PT_WRITE_U)
req 625 compat/hpux/hpux_compat.c if (isps && error == 0 && SCARG(uap, req) == PT_READ_U)
req 97 compat/hpux/m68k/hpux_syscallargs.h syscallarg(int) req;
req 73 compat/linux/linux_hdio.c struct atareq req;
req 100 compat/linux/linux_hdio.c req.flags = ATACMD_READ;
req 101 compat/linux/linux_hdio.c req.command = WDCC_IDENTIFY;
req 102 compat/linux/linux_hdio.c req.databuf = (caddr_t)atap;
req 103 compat/linux/linux_hdio.c req.datalen = DEV_BSIZE;
req 104 compat/linux/linux_hdio.c req.timeout = 1000;
req 105 compat/linux/linux_hdio.c error = ioctlf(fp, ATAIOCCOMMAND, (caddr_t)&req, p);
req 108 compat/linux/linux_hdio.c if (req.retsts != ATACMD_OK) {
req 1009 compat/sunos/sunos_misc.c int req;
req 1011 compat/sunos/sunos_misc.c req = SCARG(uap, req);
req 1013 compat/sunos/sunos_misc.c if (req < 0 || req >= nreqs)
req 1016 compat/sunos/sunos_misc.c req = sreq2breq[req];
req 1017 compat/sunos/sunos_misc.c if (req == -1)
req 1020 compat/sunos/sunos_misc.c SCARG(&pa, req) = req;
req 60 compat/sunos/sunos_syscallargs.h syscallarg(int) req;
req 2347 dev/ic/acx.c struct acx_tmplt_probe_req req;
req 2352 dev/ic/acx.c bzero(&req, sizeof(req));
req 2354 dev/ic/acx.c wh = &req.data.u_data.f;
req 2362 dev/ic/acx.c frm = req.data.u_data.var;
req 2366 dev/ic/acx.c len = frm - req.data.u_data.var;
req 2368 dev/ic/acx.c return (acx_set_tmplt(sc, ACXCMD_TMPLT_PROBE_REQ, &req,
req 900 dev/ic/elink3.c ep_media_status(ifp, req)
req 902 dev/ic/elink3.c struct ifmediareq *req;
req 915 dev/ic/elink3.c req->ifm_active = sc->sc_mii.mii_media_active;
req 916 dev/ic/elink3.c req->ifm_status = sc->sc_mii.mii_media_status;
req 921 dev/ic/elink3.c req->ifm_active = sc->sc_mii.mii_media.ifm_cur->ifm_media;
req 934 dev/ic/elink3.c req->ifm_active = ep_default_to_media[config1];
req 939 dev/ic/elink3.c req->ifm_status = IFM_AVALID; /* XXX */
req 942 dev/ic/elink3.c req->ifm_status |= IFM_ACTIVE; /* XXX automedia */
req 948 dev/ic/elink3.c req->ifm_status = 0; /* XXX */
req 114 dev/ic/ispvar.h #define ISP_DMASETUP(isp, xs, req, iptrp, optr) \
req 115 dev/ic/ispvar.h (*(isp)->isp_mdvec->dv_dmaset)((isp), (xs), (req), (iptrp), (optr))
req 900 dev/ic/lemac.c lemac_ifmedia_status(struct ifnet *const ifp, struct ifmediareq *req)
req 905 dev/ic/lemac.c req->ifm_status = IFM_AVALID;
req 907 dev/ic/lemac.c req->ifm_status |= IFM_ACTIVE;
req 911 dev/ic/lemac.c req->ifm_active = IFM_10_5;
req 913 dev/ic/lemac.c req->ifm_active = IFM_10_T;
req 921 dev/ic/lemac.c req->ifm_active = IFM_10_5;
req 923 dev/ic/lemac.c req->ifm_active = IFM_10_T;
req 927 dev/ic/lemac.c req->ifm_active |= IFM_ETHER;
req 2065 dev/ic/mpi.c struct mpi_msg_fwupload_request req;
req 2097 dev/ic/mpi.c bundle->req.function = MPI_FUNCTION_FW_UPLOAD;
req 2098 dev/ic/mpi.c bundle->req.msg_context = htole32(ccb->ccb_id);
req 2100 dev/ic/mpi.c bundle->req.image_type = MPI_FWUPLOAD_IMAGETYPE_IOC_FW;
req 2102 dev/ic/mpi.c bundle->req.tce.details_length = 12;
req 2103 dev/ic/mpi.c bundle->req.tce.image_size = htole32(sc->sc_fw_len);
req 2253 dev/ic/pgt.c pgt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t req)
req 2268 dev/ic/pgt.c ifr = (struct ifreq *)req;
req 2286 dev/ic/pgt.c na = (struct ieee80211_nodereq_all *)req;
req 2373 dev/ic/pgt.c ifa = (struct ifaddr *)req;
req 2409 dev/ic/pgt.c error = ieee80211_ioctl(ifp, cmd, req);
req 206 dev/pci/if_de.c void tulip_ifmedia_status(struct ifnet * const ifp, struct ifmediareq *req);
req 2865 dev/pci/if_de.c tulip_ifmedia_status(struct ifnet * const ifp, struct ifmediareq *req)
req 2872 dev/pci/if_de.c req->ifm_status = IFM_AVALID;
req 2874 dev/pci/if_de.c req->ifm_status |= IFM_ACTIVE;
req 2876 dev/pci/if_de.c req->ifm_active = tulip_media_to_ifmedia[sc->tulip_media];
req 1471 dev/pci/musycc.c musycc_sreq(struct musycc_group *mg, int channel, u_int32_t req, int dir,
req 1489 dev/pci/musycc.c mg->mg_gnum, channel, req, dir));
req 1492 dev/pci/musycc.c req &= ~MUSYCC_SREQ_TXDIR & ~MUSYCC_SREQ_MASK;
req 1493 dev/pci/musycc.c req |= MUSYCC_SREQ_CHSET(channel);
req 1494 dev/pci/musycc.c mg->mg_sreq[mg->mg_sreqprod].sreq = req;
req 1504 dev/pci/musycc.c req &= ~MUSYCC_SREQ_MASK;
req 1505 dev/pci/musycc.c req |= MUSYCC_SREQ_TXDIR;
req 1506 dev/pci/musycc.c req |= MUSYCC_SREQ_CHSET(channel);
req 1509 dev/pci/musycc.c mg->mg_sreq[mg->mg_sreqprod].sreq = req;
req 101 dev/raidframe/rf_cvscan.c rf_PriorityInsert(RF_DiskQueueData_t **list_ptr, RF_DiskQueueData_t *req)
req 110 dev/raidframe/rf_cvscan.c (*list_ptr)->priority > req->priority;
req 113 dev/raidframe/rf_cvscan.c req->next = (*list_ptr);
req 114 dev/raidframe/rf_cvscan.c (*list_ptr) = req;
req 119 dev/raidframe/rf_cvscan.c rf_ReqInsert(RF_DiskQueueData_t **list_ptr, RF_DiskQueueData_t *req,
req 130 dev/raidframe/rf_cvscan.c req->sectorOffset) || (order == rf_cvscan_LEFT &&
req 131 dev/raidframe/rf_cvscan.c (*list_ptr)->sectorOffset > req->sectorOffset));
req 134 dev/raidframe/rf_cvscan.c req->next = (*list_ptr);
req 135 dev/raidframe/rf_cvscan.c (*list_ptr) = req;
req 179 dev/raidframe/rf_cvscan.c rf_RealEnqueue(RF_CvscanHeader_t *hdr, RF_DiskQueueData_t *req)
req 181 dev/raidframe/rf_cvscan.c RF_ASSERT(req->priority == RF_IO_NORMAL_PRIORITY ||
req 182 dev/raidframe/rf_cvscan.c req->priority == RF_IO_LOW_PRIORITY);
req 186 dev/raidframe/rf_cvscan.c hdr->nxt_priority = req->priority;
req 188 dev/raidframe/rf_cvscan.c if (req->priority > hdr->nxt_priority) {
req 196 dev/raidframe/rf_cvscan.c hdr->nxt_priority = req->priority;
req 198 dev/raidframe/rf_cvscan.c if (req->priority < hdr->nxt_priority) {
req 202 dev/raidframe/rf_cvscan.c rf_PriorityInsert(&hdr->burner, req);
req 204 dev/raidframe/rf_cvscan.c if (req->sectorOffset < hdr->cur_block) {
req 206 dev/raidframe/rf_cvscan.c rf_ReqInsert(&hdr->left, req, rf_cvscan_LEFT);
req 210 dev/raidframe/rf_cvscan.c rf_ReqInsert(&hdr->right, req, rf_cvscan_RIGHT);
req 278 dev/raidframe/rf_dagfuncs.c RF_DiskQueueData_t *req;
req 299 dev/raidframe/rf_dagfuncs.c req = rf_CreateDiskQueueData(iotype, pda->startSector, pda->numSector,
req 304 dev/raidframe/rf_dagfuncs.c if (!req) {
req 307 dev/raidframe/rf_dagfuncs.c node->dagFuncData = (void *) req;
req 308 dev/raidframe/rf_dagfuncs.c rf_DiskIOEnqueue(&(dqs[pda->row][pda->col]), req, priority);
req 320 dev/raidframe/rf_dagfuncs.c RF_DiskQueueData_t *req;
req 341 dev/raidframe/rf_dagfuncs.c req = rf_CreateDiskQueueData(iotype, pda->startSector, pda->numSector,
req 347 dev/raidframe/rf_dagfuncs.c if (!req) {
req 350 dev/raidframe/rf_dagfuncs.c node->dagFuncData = (void *) req;
req 351 dev/raidframe/rf_dagfuncs.c rf_DiskIOEnqueue(&(dqs[pda->row][pda->col]), req, priority);
req 364 dev/raidframe/rf_dagfuncs.c RF_DiskQueueData_t *req;
req 368 dev/raidframe/rf_dagfuncs.c req = rf_CreateDiskQueueData(RF_IO_TYPE_NOP, 0L, 0, NULL, 0L, 0,
req 372 dev/raidframe/rf_dagfuncs.c if (!req)
req 375 dev/raidframe/rf_dagfuncs.c node->dagFuncData = (void *) req;
req 376 dev/raidframe/rf_dagfuncs.c rf_DiskIOEnqueue(&(dqs[pda->row][pda->col]), req,
req 389 dev/raidframe/rf_dagfuncs.c RF_DiskQueueData_t *req;
req 393 dev/raidframe/rf_dagfuncs.c req = rf_CreateDiskQueueData(RF_IO_TYPE_NOP, 0L, 0, NULL, 0L, 0,
req 397 dev/raidframe/rf_dagfuncs.c if (!req)
req 400 dev/raidframe/rf_dagfuncs.c node->dagFuncData = (void *) req;
req 401 dev/raidframe/rf_dagfuncs.c rf_DiskIOEnqueue(&(dqs[pda->row][pda->col]), req,
req 750 dev/raidframe/rf_decluster.c RF_SparetWait_t *req;
req 753 dev/raidframe/rf_decluster.c RF_Malloc(req, sizeof(*req), (RF_SparetWait_t *));
req 754 dev/raidframe/rf_decluster.c req->C = raidPtr->numCol;
req 755 dev/raidframe/rf_decluster.c req->G = raidPtr->Layout.numDataCol + raidPtr->Layout.numParityCol;
req 756 dev/raidframe/rf_decluster.c req->fcol = fcol;
req 757 dev/raidframe/rf_decluster.c req->SUsPerPU = raidPtr->Layout.SUsPerPU;
req 758 dev/raidframe/rf_decluster.c req->TablesPerSpareRegion = info->TablesPerSpareRegion;
req 759 dev/raidframe/rf_decluster.c req->BlocksPerTable = info->BlocksPerTable;
req 760 dev/raidframe/rf_decluster.c req->TableDepthInPUs = info->TableDepthInPUs;
req 761 dev/raidframe/rf_decluster.c req->SpareSpaceDepthPerRegionInSUs =
req 764 dev/raidframe/rf_decluster.c retcode = rf_GetSpareTableFromDaemon(req);
req 350 dev/raidframe/rf_diskqueue.c rf_DiskIOEnqueue(RF_DiskQueue_t *queue, RF_DiskQueueData_t *req, int pri)
req 352 dev/raidframe/rf_diskqueue.c RF_ETIMER_START(req->qtime);
req 353 dev/raidframe/rf_diskqueue.c RF_ASSERT(req->type == RF_IO_TYPE_NOP || req->numSector);
req 354 dev/raidframe/rf_diskqueue.c req->priority = pri;
req 356 dev/raidframe/rf_diskqueue.c if (rf_queueDebug && (req->numSector == 0)) {
req 364 dev/raidframe/rf_diskqueue.c if (RF_LOCKING_REQ(req)) {
req 369 dev/raidframe/rf_diskqueue.c rf_DispatchKernelIO(queue, req);
req 379 dev/raidframe/rf_diskqueue.c req->queue = (void *) queue;
req 380 dev/raidframe/rf_diskqueue.c (queue->qPtr->Enqueue) (queue->qHdr, req, pri);
req 384 dev/raidframe/rf_diskqueue.c if (RF_UNLOCKING_REQ(req)) {
req 392 dev/raidframe/rf_diskqueue.c rf_DispatchKernelIO(queue, req);
req 395 dev/raidframe/rf_diskqueue.c if (RF_OK_TO_DISPATCH(queue, req)) {
req 399 dev/raidframe/rf_diskqueue.c rf_DispatchKernelIO(queue, req);
req 409 dev/raidframe/rf_diskqueue.c req->queue = (void *) queue;
req 410 dev/raidframe/rf_diskqueue.c (queue->qPtr->Enqueue) (queue->qHdr, req, pri);
req 420 dev/raidframe/rf_diskqueue.c rf_DiskIOComplete(RF_DiskQueue_t *queue, RF_DiskQueueData_t *req, int status)
req 431 dev/raidframe/rf_diskqueue.c if (RF_UNLOCKING_REQ(req) || (RF_LOCKING_REQ(req) && status)) {
req 449 dev/raidframe/rf_diskqueue.c req = queue->nextLockingOp;
req 452 dev/raidframe/rf_diskqueue.c " pending at r %d c %d\n", req->priority,
req 455 dev/raidframe/rf_diskqueue.c req = (queue->qPtr->Dequeue) (queue->qHdr);
req 456 dev/raidframe/rf_diskqueue.c if (req != NULL) {
req 459 dev/raidframe/rf_diskqueue.c req->priority, queue->row, queue->col);
req 465 dev/raidframe/rf_diskqueue.c if (req) {
req 473 dev/raidframe/rf_diskqueue.c if (!req)
req 476 dev/raidframe/rf_diskqueue.c if (RF_LOCKING_REQ(req)) {
req 481 dev/raidframe/rf_diskqueue.c " (queue empty)\n", req->priority,
req 484 dev/raidframe/rf_diskqueue.c rf_DispatchKernelIO(queue, req);
req 493 dev/raidframe/rf_diskqueue.c " c %d\n", req->priority,
req 496 dev/raidframe/rf_diskqueue.c queue->nextLockingOp = req;
req 500 dev/raidframe/rf_diskqueue.c if (RF_UNLOCKING_REQ(req)) {
req 510 dev/raidframe/rf_diskqueue.c req->priority, queue->row,
req 512 dev/raidframe/rf_diskqueue.c rf_DispatchKernelIO(queue, req);
req 515 dev/raidframe/rf_diskqueue.c if (RF_OK_TO_DISPATCH(queue, req)) {
req 520 dev/raidframe/rf_diskqueue.c req->priority, queue->row,
req 522 dev/raidframe/rf_diskqueue.c rf_DispatchKernelIO(queue, req);
req 536 dev/raidframe/rf_diskqueue.c " c %d\n", req->priority,
req 540 dev/raidframe/rf_diskqueue.c (queue->qHdr, req,
req 541 dev/raidframe/rf_diskqueue.c req->priority);
req 193 dev/raidframe/rf_openbsdkintf.c RF_DiskQueueData_t *req; /* The request that this was part of. */
req 1677 dev/raidframe/rf_openbsdkintf.c rf_GetSpareTableFromDaemon(RF_SparetWait_t *req)
req 1682 dev/raidframe/rf_openbsdkintf.c req->next = rf_sparet_wait_queue;
req 1683 dev/raidframe/rf_openbsdkintf.c rf_sparet_wait_queue = req;
req 1691 dev/raidframe/rf_openbsdkintf.c req = rf_sparet_resp_queue;
req 1692 dev/raidframe/rf_openbsdkintf.c rf_sparet_resp_queue = req->next;
req 1695 dev/raidframe/rf_openbsdkintf.c retcode = req->fcol;
req 1697 dev/raidframe/rf_openbsdkintf.c RF_Free(req, sizeof *req);
req 1845 dev/raidframe/rf_openbsdkintf.c rf_DispatchKernelIO(RF_DiskQueue_t *queue, RF_DiskQueueData_t *req)
req 1847 dev/raidframe/rf_openbsdkintf.c int op = (req->type == RF_IO_TYPE_READ) ? B_READ : B_WRITE;
req 1858 dev/raidframe/rf_openbsdkintf.c req->queue = queue;
req 1871 dev/raidframe/rf_openbsdkintf.c bp = req->bp;
req 1897 dev/raidframe/rf_openbsdkintf.c raidbp->req = req;
req 1901 dev/raidframe/rf_openbsdkintf.c switch (req->type) {
req 1924 dev/raidframe/rf_openbsdkintf.c if (req->tracerec) {
req 1925 dev/raidframe/rf_openbsdkintf.c RF_ETIMER_START(req->tracerec->timer);
req 1930 dev/raidframe/rf_openbsdkintf.c req->sectorOffset, req->numSector,
req 1931 dev/raidframe/rf_openbsdkintf.c req->buf, rf_KernelWakeupFunc, (void *)req,
req 1932 dev/raidframe/rf_openbsdkintf.c queue->raidPtr->logBytesPerSector, req->b_proc);
req 1939 dev/raidframe/rf_openbsdkintf.c queue->last_deq_sector = req->sectorOffset;
req 1945 dev/raidframe/rf_openbsdkintf.c queue->curPriority = req->priority;
req 1948 dev/raidframe/rf_openbsdkintf.c req->type, unit, queue->row, queue->col));
req 1950 dev/raidframe/rf_openbsdkintf.c (int)req->sectorOffset, (int)req->numSector,
req 1951 dev/raidframe/rf_openbsdkintf.c (int)(req->numSector << queue->raidPtr->logBytesPerSector),
req 1975 dev/raidframe/rf_openbsdkintf.c RF_DiskQueueData_t *req = NULL;
req 1985 dev/raidframe/rf_openbsdkintf.c req = raidbp->req;
req 1989 dev/raidframe/rf_openbsdkintf.c queue = (RF_DiskQueue_t *)req->queue;
req 2002 dev/raidframe/rf_openbsdkintf.c if (req->tracerec) {
req 2003 dev/raidframe/rf_openbsdkintf.c RF_ETIMER_STOP(req->tracerec->timer);
req 2004 dev/raidframe/rf_openbsdkintf.c RF_ETIMER_EVAL(req->tracerec->timer);
req 2006 dev/raidframe/rf_openbsdkintf.c req->tracerec->diskwait_us +=
req 2007 dev/raidframe/rf_openbsdkintf.c RF_ETIMER_VAL_US(req->tracerec->timer);
req 2008 dev/raidframe/rf_openbsdkintf.c req->tracerec->phys_io_us +=
req 2009 dev/raidframe/rf_openbsdkintf.c RF_ETIMER_VAL_US(req->tracerec->timer);
req 2010 dev/raidframe/rf_openbsdkintf.c req->tracerec->num_phys_ios++;
req 2044 dev/raidframe/rf_openbsdkintf.c rf_DiskIOComplete(queue, req, (bp->b_flags & B_ERROR) ? 1 : 0);
req 2045 dev/raidframe/rf_openbsdkintf.c (req->CompleteFunc)(req->argument, (bp->b_flags & B_ERROR) ? 1 : 0);
req 2609 dev/raidframe/rf_openbsdkintf.c rf_ReconThread(struct rf_recon_req *req)
req 2615 dev/raidframe/rf_openbsdkintf.c raidPtr = (RF_Raid_t *) req->raidPtr;
req 2618 dev/raidframe/rf_openbsdkintf.c rf_FailDisk((RF_Raid_t *) req->raidPtr, req->row, req->col,
req 2619 dev/raidframe/rf_openbsdkintf.c ((req->flags & RF_FDFLAGS_RECON) ? 1 : 0));
req 2622 dev/raidframe/rf_openbsdkintf.c RF_Free(req, sizeof(*req));
req 2680 dev/raidframe/rf_openbsdkintf.c rf_ReconstructInPlaceThread(struct rf_recon_req *req)
req 2687 dev/raidframe/rf_openbsdkintf.c raidPtr = req->raidPtr;
req 2689 dev/raidframe/rf_openbsdkintf.c retcode = rf_ReconstructInPlace(raidPtr, req->row, req->col);
req 2690 dev/raidframe/rf_openbsdkintf.c RF_Free(req, sizeof(*req));
req 1193 dev/raidframe/rf_reconstruct.c RF_DiskQueueData_t *req;
req 1258 dev/raidframe/rf_reconstruct.c req = rf_CreateDiskQueueData(RF_IO_TYPE_READ, ctrl->diskOffset,
req 1263 dev/raidframe/rf_reconstruct.c RF_ASSERT(req); /* XXX -- Fix this. -- XXX */
req 1265 dev/raidframe/rf_reconstruct.c ctrl->rbuf->arg = (void *) req;
req 1266 dev/raidframe/rf_reconstruct.c rf_DiskIOEnqueue(&raidPtr->Queues[row][col], req, RF_IO_RECON_PRIORITY);
req 1460 dev/raidframe/rf_reconstruct.c RF_DiskQueueData_t *req;
req 1485 dev/raidframe/rf_reconstruct.c req = rf_CreateDiskQueueData(RF_IO_TYPE_WRITE, rbuf->spOffset,
req 1490 dev/raidframe/rf_reconstruct.c RF_ASSERT(req); /* XXX -- Fix this. -- XXX */
req 1492 dev/raidframe/rf_reconstruct.c rbuf->arg = (void *) req;
req 1493 dev/raidframe/rf_reconstruct.c rf_DiskIOEnqueue(&raidPtr->Queues[rbuf->spRow][rbuf->spCol], req,
req 1772 dev/raidframe/rf_reconstruct.c RF_DiskQueueData_t *req; /* Disk I/O req to be enqueued. */
req 1856 dev/raidframe/rf_reconstruct.c req = rf_CreateDiskQueueData(
req 1866 dev/raidframe/rf_reconstruct.c RF_ASSERT(req); /*
req 1871 dev/raidframe/rf_reconstruct.c new_rbuf->arg = req;
req 1874 dev/raidframe/rf_reconstruct.c ->Queues[row][diskno], req,
req 69 dev/raidframe/rf_sstf.c RF_DiskQueueData_t *req)
req 74 dev/raidframe/rf_sstf.c *queuep = req;
req 75 dev/raidframe/rf_sstf.c *tailp = req;
req 76 dev/raidframe/rf_sstf.c req->next = NULL;
req 77 dev/raidframe/rf_sstf.c req->prev = NULL;
req 80 dev/raidframe/rf_sstf.c if (req->sectorOffset <= (*queuep)->sectorOffset) {
req 81 dev/raidframe/rf_sstf.c req->next = *queuep;
req 82 dev/raidframe/rf_sstf.c req->prev = NULL;
req 83 dev/raidframe/rf_sstf.c (*queuep)->prev = req;
req 84 dev/raidframe/rf_sstf.c *queuep = req;
req 87 dev/raidframe/rf_sstf.c if (req->sectorOffset > (*tailp)->sectorOffset) {
req 94 dev/raidframe/rf_sstf.c if (r->sectorOffset >= req->sectorOffset) {
req 97 dev/raidframe/rf_sstf.c req->next = r;
req 98 dev/raidframe/rf_sstf.c r->prev = req;
req 99 dev/raidframe/rf_sstf.c s->next = req;
req 100 dev/raidframe/rf_sstf.c req->prev = s;
req 109 dev/raidframe/rf_sstf.c req->next = NULL;
req 110 dev/raidframe/rf_sstf.c req->prev = s;
req 111 dev/raidframe/rf_sstf.c s->next = req;
req 112 dev/raidframe/rf_sstf.c *tailp = req;
req 275 dev/raidframe/rf_sstf.c rf_SstfEnqueue(void *qptr, RF_DiskQueueData_t *req, int priority)
req 284 dev/raidframe/rf_sstf.c dq = (RF_DiskQueue_t *) req->queue;
req 286 dev/raidframe/rf_sstf.c req->raidPtr->raidid, dq->row, dq->col,
req 290 dev/raidframe/rf_sstf.c rf_do_sstf_ord_q(&sstfq->lopri.queue, &sstfq->lopri.qtail, req);
req 293 dev/raidframe/rf_sstf.c if (req->sectorOffset < sstfq->last_sector) {
req 295 dev/raidframe/rf_sstf.c &sstfq->left.qtail, req);
req 299 dev/raidframe/rf_sstf.c &sstfq->right.qtail, req);
req 306 dev/raidframe/rf_sstf.c rf_do_dequeue(RF_SstfQ_t *queue, RF_DiskQueueData_t *req)
req 311 dev/raidframe/rf_sstf.c printf("raid%d: rf_do_dequeue.\n", req->raidPtr->raidid);
req 313 dev/raidframe/rf_sstf.c if (req == queue->queue) {
req 315 dev/raidframe/rf_sstf.c RF_ASSERT(req2 == req);
req 317 dev/raidframe/rf_sstf.c if (req == queue->qtail) {
req 319 dev/raidframe/rf_sstf.c RF_ASSERT(req2 == req);
req 322 dev/raidframe/rf_sstf.c RF_ASSERT(req->next);
req 323 dev/raidframe/rf_sstf.c RF_ASSERT(req->prev);
req 325 dev/raidframe/rf_sstf.c req->next->prev = req->prev;
req 326 dev/raidframe/rf_sstf.c req->prev->next = req->next;
req 327 dev/raidframe/rf_sstf.c req->next = req->prev = NULL;
req 334 dev/raidframe/rf_sstf.c RF_DiskQueueData_t *req = NULL;
req 341 dev/raidframe/rf_sstf.c dq = (RF_DiskQueue_t *) req->queue;
req 344 dev/raidframe/rf_sstf.c req->raidPtr->raidid, dq->row, dq->col,
req 357 dev/raidframe/rf_sstf.c req->raidPtr->raidid);
req 359 dev/raidframe/rf_sstf.c req = rf_closest_to_arm(&sstfq->lopri,
req 364 dev/raidframe/rf_sstf.c " %lx.\n", req->raidPtr->raidid,
req 365 dev/raidframe/rf_sstf.c (long) req);
req 367 dev/raidframe/rf_sstf.c if (req == NULL)
req 369 dev/raidframe/rf_sstf.c rf_do_dequeue(&sstfq->lopri, req);
req 371 dev/raidframe/rf_sstf.c DO_BEST_DEQ(sstfq->last_sector, req, &sstfq->right);
req 376 dev/raidframe/rf_sstf.c DO_BEST_DEQ(sstfq->last_sector, req, &sstfq->left);
req 382 dev/raidframe/rf_sstf.c DO_HEAD_DEQ(req, &sstfq->right);
req 384 dev/raidframe/rf_sstf.c DO_TAIL_DEQ(req, &sstfq->left);
req 388 dev/raidframe/rf_sstf.c RF_ASSERT(req);
req 389 dev/raidframe/rf_sstf.c sstfq->last_sector = req->sectorOffset;
req 390 dev/raidframe/rf_sstf.c return (req);
req 396 dev/raidframe/rf_sstf.c RF_DiskQueueData_t *req = NULL;
req 403 dev/raidframe/rf_sstf.c dq = (RF_DiskQueue_t *) req->queue;
req 406 dev/raidframe/rf_sstf.c req->raidPtr->raidid, dq->row, dq->col,
req 417 dev/raidframe/rf_sstf.c req = rf_closest_to_arm(&scanq->lopri,
req 420 dev/raidframe/rf_sstf.c if (req == NULL)
req 422 dev/raidframe/rf_sstf.c rf_do_dequeue(&scanq->lopri, req);
req 425 dev/raidframe/rf_sstf.c DO_HEAD_DEQ(req, &scanq->right);
req 432 dev/raidframe/rf_sstf.c DO_TAIL_DEQ(req, &scanq->left);
req 437 dev/raidframe/rf_sstf.c DO_HEAD_DEQ(req, &scanq->right);
req 439 dev/raidframe/rf_sstf.c DO_TAIL_DEQ(req, &scanq->left);
req 442 dev/raidframe/rf_sstf.c RF_ASSERT(req);
req 443 dev/raidframe/rf_sstf.c scanq->last_sector = req->sectorOffset;
req 444 dev/raidframe/rf_sstf.c return (req);
req 450 dev/raidframe/rf_sstf.c RF_DiskQueueData_t *req = NULL;
req 458 dev/raidframe/rf_sstf.c dq = (RF_DiskQueue_t *) req->queue;
req 461 dev/raidframe/rf_sstf.c req->raidPtr->raidid, dq->row, dq->col,
req 466 dev/raidframe/rf_sstf.c DO_HEAD_DEQ(req, &cscanq->right);
req 475 dev/raidframe/rf_sstf.c req = rf_closest_to_arm(&cscanq->lopri,
req 478 dev/raidframe/rf_sstf.c if (req == NULL)
req 480 dev/raidframe/rf_sstf.c rf_do_dequeue(&cscanq->lopri, req);
req 489 dev/raidframe/rf_sstf.c DO_HEAD_DEQ(req, &cscanq->right);
req 492 dev/raidframe/rf_sstf.c RF_ASSERT(req);
req 493 dev/raidframe/rf_sstf.c cscanq->last_sector = req->sectorOffset;
req 494 dev/raidframe/rf_sstf.c return (req);
req 500 dev/raidframe/rf_sstf.c RF_DiskQueueData_t *req;
req 506 dev/raidframe/rf_sstf.c req = rf_closest_to_arm(&sstfq->lopri, sstfq->last_sector,
req 510 dev/raidframe/rf_sstf.c req = sstfq->right.queue;
req 513 dev/raidframe/rf_sstf.c req = sstfq->left.queue;
req 519 dev/raidframe/rf_sstf.c req = sstfq->right.queue;
req 521 dev/raidframe/rf_sstf.c req = sstfq->left.qtail;
req 526 dev/raidframe/rf_sstf.c if (req == NULL) {
req 529 dev/raidframe/rf_sstf.c return (req);
req 535 dev/raidframe/rf_sstf.c RF_DiskQueueData_t *req;
req 550 dev/raidframe/rf_sstf.c req = rf_closest_to_arm(&scanq->lopri,
req 553 dev/raidframe/rf_sstf.c req = scanq->right.queue;
req 559 dev/raidframe/rf_sstf.c req = scanq->left.qtail;
req 564 dev/raidframe/rf_sstf.c req = scanq->right.queue;
req 566 dev/raidframe/rf_sstf.c req = scanq->left.qtail;
req 569 dev/raidframe/rf_sstf.c if (req == NULL) {
req 572 dev/raidframe/rf_sstf.c return (req);
req 578 dev/raidframe/rf_sstf.c RF_DiskQueueData_t *req;
req 585 dev/raidframe/rf_sstf.c req = cscanq->right.queue;
req 594 dev/raidframe/rf_sstf.c req = rf_closest_to_arm(&cscanq->lopri,
req 602 dev/raidframe/rf_sstf.c req = cscanq->left.queue;
req 605 dev/raidframe/rf_sstf.c if (req == NULL) {
req 608 dev/raidframe/rf_sstf.c return (req);
req 1656 dev/usb/ehci.c usb_device_request_t *req;
req 1673 dev/usb/ehci.c req = &xfer->request;
req 1676 dev/usb/ehci.c req->bmRequestType, req->bRequest));
req 1678 dev/usb/ehci.c len = UGETW(req->wLength);
req 1679 dev/usb/ehci.c value = UGETW(req->wValue);
req 1680 dev/usb/ehci.c index = UGETW(req->wIndex);
req 1686 dev/usb/ehci.c switch(C(req->bRequest, req->bmRequestType)) {
req 2758 dev/usb/ehci.c usb_device_request_t *req = &xfer->request;
req 2769 dev/usb/ehci.c isread = req->bmRequestType & UT_READ;
req 2770 dev/usb/ehci.c len = UGETW(req->wLength);
req 2774 dev/usb/ehci.c req->bmRequestType, req->bRequest, UGETW(req->wValue),
req 2775 dev/usb/ehci.c UGETW(req->wIndex), len, addr,
req 2819 dev/usb/ehci.c memcpy(KERNADDR(&epipe->u.ctl.reqdma, 0), req, sizeof(*req));
req 2827 dev/usb/ehci.c EHCI_QTD_SET_BYTES(sizeof(*req)));
req 2833 dev/usb/ehci.c setup->len = sizeof(*req);
req 95 dev/usb/ezload.c usb_device_request_t req;
req 101 dev/usb/ezload.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 102 dev/usb/ezload.c req.bRequest = ANCHOR_LOAD_INTERNAL;
req 103 dev/usb/ezload.c USETW(req.wValue, ANCHOR_CPUCS_REG);
req 104 dev/usb/ezload.c USETW(req.wIndex, 0);
req 105 dev/usb/ezload.c USETW(req.wLength, 1);
req 106 dev/usb/ezload.c return (usbd_do_request(dev, &req, &rst));
req 113 dev/usb/ezload.c usb_device_request_t req;
req 130 dev/usb/ezload.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 131 dev/usb/ezload.c req.bRequest = ANCHOR_LOAD_INTERNAL;
req 132 dev/usb/ezload.c USETW(req.wIndex, 0);
req 137 dev/usb/ezload.c USETW(req.wValue, address + offs);
req 138 dev/usb/ezload.c USETW(req.wLength, len);
req 141 dev/usb/ezload.c err = usbd_do_request(dev, &req, (u_char *)buf);
req 287 dev/usb/if_atu.c void atu_media_status(struct ifnet *ifp, struct ifmediareq *req);
req 305 dev/usb/if_atu.c usb_device_request_t req;
req 310 dev/usb/if_atu.c req.bmRequestType = type;
req 311 dev/usb/if_atu.c req.bRequest = request;
req 312 dev/usb/if_atu.c USETW(req.wValue, value);
req 313 dev/usb/if_atu.c USETW(req.wIndex, index);
req 314 dev/usb/if_atu.c USETW(req.wLength, length);
req 333 dev/usb/if_atu.c usbd_setup_default_xfer(xfer, sc->atu_udev, 0, 500000, &req, data,
req 1151 dev/usb/if_atu.c atu_media_status(struct ifnet *ifp, struct ifmediareq *req)
req 1159 dev/usb/if_atu.c ieee80211_media_status(ifp, req);
req 277 dev/usb/if_aue.c usb_device_request_t req;
req 284 dev/usb/if_aue.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 285 dev/usb/if_aue.c req.bRequest = AUE_UR_READREG;
req 286 dev/usb/if_aue.c USETW(req.wValue, 0);
req 287 dev/usb/if_aue.c USETW(req.wIndex, reg);
req 288 dev/usb/if_aue.c USETW(req.wLength, 1);
req 290 dev/usb/if_aue.c err = usbd_do_request(sc->aue_udev, &req, &val);
req 304 dev/usb/if_aue.c usb_device_request_t req;
req 311 dev/usb/if_aue.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 312 dev/usb/if_aue.c req.bRequest = AUE_UR_READREG;
req 313 dev/usb/if_aue.c USETW(req.wValue, 0);
req 314 dev/usb/if_aue.c USETW(req.wIndex, reg);
req 315 dev/usb/if_aue.c USETW(req.wLength, 2);
req 317 dev/usb/if_aue.c err = usbd_do_request(sc->aue_udev, &req, &val);
req 331 dev/usb/if_aue.c usb_device_request_t req;
req 339 dev/usb/if_aue.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 340 dev/usb/if_aue.c req.bRequest = AUE_UR_WRITEREG;
req 341 dev/usb/if_aue.c USETW(req.wValue, val);
req 342 dev/usb/if_aue.c USETW(req.wIndex, reg);
req 343 dev/usb/if_aue.c USETW(req.wLength, 1);
req 345 dev/usb/if_aue.c err = usbd_do_request(sc->aue_udev, &req, &val);
req 359 dev/usb/if_aue.c usb_device_request_t req;
req 367 dev/usb/if_aue.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 368 dev/usb/if_aue.c req.bRequest = AUE_UR_WRITEREG;
req 369 dev/usb/if_aue.c USETW(req.wValue, aval);
req 370 dev/usb/if_aue.c USETW(req.wIndex, reg);
req 371 dev/usb/if_aue.c USETW(req.wLength, 2);
req 373 dev/usb/if_aue.c err = usbd_do_request(sc->aue_udev, &req, &val);
req 240 dev/usb/if_axe.c usb_device_request_t req;
req 247 dev/usb/if_axe.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 249 dev/usb/if_axe.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 250 dev/usb/if_axe.c req.bRequest = AXE_CMD_CMD(cmd);
req 251 dev/usb/if_axe.c USETW(req.wValue, val);
req 252 dev/usb/if_axe.c USETW(req.wIndex, index);
req 253 dev/usb/if_axe.c USETW(req.wLength, AXE_CMD_LEN(cmd));
req 255 dev/usb/if_axe.c err = usbd_do_request(sc->axe_udev, &req, buf);
req 274 dev/usb/if_cdcef.c cdcef_do_request(usbf_function_handle fun, usb_device_request_t *req,
req 166 dev/usb/if_cue.c usb_device_request_t req;
req 173 dev/usb/if_cue.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 174 dev/usb/if_cue.c req.bRequest = CUE_CMD_READREG;
req 175 dev/usb/if_cue.c USETW(req.wValue, 0);
req 176 dev/usb/if_cue.c USETW(req.wIndex, reg);
req 177 dev/usb/if_cue.c USETW(req.wLength, 1);
req 179 dev/usb/if_cue.c err = usbd_do_request(sc->cue_udev, &req, &val);
req 196 dev/usb/if_cue.c usb_device_request_t req;
req 203 dev/usb/if_cue.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 204 dev/usb/if_cue.c req.bRequest = CUE_CMD_READREG;
req 205 dev/usb/if_cue.c USETW(req.wValue, 0);
req 206 dev/usb/if_cue.c USETW(req.wIndex, reg);
req 207 dev/usb/if_cue.c USETW(req.wLength, 2);
req 209 dev/usb/if_cue.c err = usbd_do_request(sc->cue_udev, &req, &val);
req 226 dev/usb/if_cue.c usb_device_request_t req;
req 235 dev/usb/if_cue.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 236 dev/usb/if_cue.c req.bRequest = CUE_CMD_WRITEREG;
req 237 dev/usb/if_cue.c USETW(req.wValue, val);
req 238 dev/usb/if_cue.c USETW(req.wIndex, reg);
req 239 dev/usb/if_cue.c USETW(req.wLength, 0);
req 241 dev/usb/if_cue.c err = usbd_do_request(sc->cue_udev, &req, NULL);
req 259 dev/usb/if_cue.c usb_device_request_t req;
req 271 dev/usb/if_cue.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 272 dev/usb/if_cue.c req.bRequest = CUE_CMD_WRITEREG;
req 273 dev/usb/if_cue.c USETW(req.wValue, val);
req 274 dev/usb/if_cue.c USETW(req.wIndex, reg);
req 275 dev/usb/if_cue.c USETW(req.wLength, 0);
req 277 dev/usb/if_cue.c err = usbd_do_request(sc->cue_udev, &req, NULL);
req 292 dev/usb/if_cue.c usb_device_request_t req;
req 299 dev/usb/if_cue.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 301 dev/usb/if_cue.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 302 dev/usb/if_cue.c req.bRequest = cmd;
req 303 dev/usb/if_cue.c USETW(req.wValue, 0);
req 304 dev/usb/if_cue.c USETW(req.wIndex, addr);
req 305 dev/usb/if_cue.c USETW(req.wLength, len);
req 307 dev/usb/if_cue.c err = usbd_do_request(sc->cue_udev, &req, buf);
req 321 dev/usb/if_cue.c usb_device_request_t req;
req 326 dev/usb/if_cue.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 327 dev/usb/if_cue.c req.bRequest = CUE_CMD_GET_MACADDR;
req 328 dev/usb/if_cue.c USETW(req.wValue, 0);
req 329 dev/usb/if_cue.c USETW(req.wIndex, 0);
req 330 dev/usb/if_cue.c USETW(req.wLength, ETHER_ADDR_LEN);
req 332 dev/usb/if_cue.c err = usbd_do_request(sc->cue_udev, &req, buf);
req 404 dev/usb/if_cue.c usb_device_request_t req;
req 412 dev/usb/if_cue.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 413 dev/usb/if_cue.c req.bRequest = CUE_CMD_RESET;
req 414 dev/usb/if_cue.c USETW(req.wValue, 0);
req 415 dev/usb/if_cue.c USETW(req.wIndex, 0);
req 416 dev/usb/if_cue.c USETW(req.wLength, 0);
req 418 dev/usb/if_cue.c err = usbd_do_request(sc->cue_udev, &req, NULL);
req 199 dev/usb/if_kue.c usb_device_request_t req;
req 203 dev/usb/if_kue.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 204 dev/usb/if_kue.c req.bRequest = breq;
req 205 dev/usb/if_kue.c USETW(req.wValue, word);
req 206 dev/usb/if_kue.c USETW(req.wIndex, 0);
req 207 dev/usb/if_kue.c USETW(req.wLength, 0);
req 209 dev/usb/if_kue.c return (usbd_do_request(sc->kue_udev, &req, NULL));
req 216 dev/usb/if_kue.c usb_device_request_t req;
req 222 dev/usb/if_kue.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 224 dev/usb/if_kue.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 226 dev/usb/if_kue.c req.bRequest = breq;
req 227 dev/usb/if_kue.c USETW(req.wValue, val);
req 228 dev/usb/if_kue.c USETW(req.wIndex, 0);
req 229 dev/usb/if_kue.c USETW(req.wLength, len);
req 231 dev/usb/if_kue.c return (usbd_do_request(sc->kue_udev, &req, data));
req 1392 dev/usb/if_ral.c usb_device_request_t req;
req 1395 dev/usb/if_ral.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 1396 dev/usb/if_ral.c req.bRequest = RAL_READ_EEPROM;
req 1397 dev/usb/if_ral.c USETW(req.wValue, 0);
req 1398 dev/usb/if_ral.c USETW(req.wIndex, addr);
req 1399 dev/usb/if_ral.c USETW(req.wLength, len);
req 1401 dev/usb/if_ral.c error = usbd_do_request(sc->sc_udev, &req, buf);
req 1411 dev/usb/if_ral.c usb_device_request_t req;
req 1415 dev/usb/if_ral.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 1416 dev/usb/if_ral.c req.bRequest = RAL_READ_MAC;
req 1417 dev/usb/if_ral.c USETW(req.wValue, 0);
req 1418 dev/usb/if_ral.c USETW(req.wIndex, reg);
req 1419 dev/usb/if_ral.c USETW(req.wLength, sizeof (uint16_t));
req 1421 dev/usb/if_ral.c error = usbd_do_request(sc->sc_udev, &req, &val);
req 1433 dev/usb/if_ral.c usb_device_request_t req;
req 1436 dev/usb/if_ral.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 1437 dev/usb/if_ral.c req.bRequest = RAL_READ_MULTI_MAC;
req 1438 dev/usb/if_ral.c USETW(req.wValue, 0);
req 1439 dev/usb/if_ral.c USETW(req.wIndex, reg);
req 1440 dev/usb/if_ral.c USETW(req.wLength, len);
req 1442 dev/usb/if_ral.c error = usbd_do_request(sc->sc_udev, &req, buf);
req 1452 dev/usb/if_ral.c usb_device_request_t req;
req 1455 dev/usb/if_ral.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 1456 dev/usb/if_ral.c req.bRequest = RAL_WRITE_MAC;
req 1457 dev/usb/if_ral.c USETW(req.wValue, val);
req 1458 dev/usb/if_ral.c USETW(req.wIndex, reg);
req 1459 dev/usb/if_ral.c USETW(req.wLength, 0);
req 1461 dev/usb/if_ral.c error = usbd_do_request(sc->sc_udev, &req, NULL);
req 1471 dev/usb/if_ral.c usb_device_request_t req;
req 1474 dev/usb/if_ral.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 1475 dev/usb/if_ral.c req.bRequest = RAL_WRITE_MULTI_MAC;
req 1476 dev/usb/if_ral.c USETW(req.wValue, 0);
req 1477 dev/usb/if_ral.c USETW(req.wIndex, reg);
req 1478 dev/usb/if_ral.c USETW(req.wLength, len);
req 1480 dev/usb/if_ral.c error = usbd_do_request(sc->sc_udev, &req, buf);
req 2141 dev/usb/if_ral.c usb_device_request_t req;
req 2149 dev/usb/if_ral.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 2150 dev/usb/if_ral.c req.bRequest = RAL_READ_MULTI_MAC;
req 2151 dev/usb/if_ral.c USETW(req.wValue, 0);
req 2152 dev/usb/if_ral.c USETW(req.wIndex, RAL_STA_CSR0);
req 2153 dev/usb/if_ral.c USETW(req.wLength, sizeof sc->sta);
req 2156 dev/usb/if_ral.c USBD_DEFAULT_TIMEOUT, &req, sc->sta, sizeof sc->sta, 0,
req 1400 dev/usb/if_rum.c usb_device_request_t req;
req 1403 dev/usb/if_rum.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 1404 dev/usb/if_rum.c req.bRequest = RT2573_READ_EEPROM;
req 1405 dev/usb/if_rum.c USETW(req.wValue, 0);
req 1406 dev/usb/if_rum.c USETW(req.wIndex, addr);
req 1407 dev/usb/if_rum.c USETW(req.wLength, len);
req 1409 dev/usb/if_rum.c error = usbd_do_request(sc->sc_udev, &req, buf);
req 1429 dev/usb/if_rum.c usb_device_request_t req;
req 1432 dev/usb/if_rum.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 1433 dev/usb/if_rum.c req.bRequest = RT2573_READ_MULTI_MAC;
req 1434 dev/usb/if_rum.c USETW(req.wValue, 0);
req 1435 dev/usb/if_rum.c USETW(req.wIndex, reg);
req 1436 dev/usb/if_rum.c USETW(req.wLength, len);
req 1438 dev/usb/if_rum.c error = usbd_do_request(sc->sc_udev, &req, buf);
req 1456 dev/usb/if_rum.c usb_device_request_t req;
req 1459 dev/usb/if_rum.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 1460 dev/usb/if_rum.c req.bRequest = RT2573_WRITE_MULTI_MAC;
req 1461 dev/usb/if_rum.c USETW(req.wValue, 0);
req 1462 dev/usb/if_rum.c USETW(req.wIndex, reg);
req 1463 dev/usb/if_rum.c USETW(req.wLength, len);
req 1465 dev/usb/if_rum.c error = usbd_do_request(sc->sc_udev, &req, buf);
req 2127 dev/usb/if_rum.c usb_device_request_t req;
req 2135 dev/usb/if_rum.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 2136 dev/usb/if_rum.c req.bRequest = RT2573_MCU_CNTL;
req 2137 dev/usb/if_rum.c USETW(req.wValue, RT2573_MCU_RUN);
req 2138 dev/usb/if_rum.c USETW(req.wIndex, 0);
req 2139 dev/usb/if_rum.c USETW(req.wLength, 0);
req 2141 dev/usb/if_rum.c error = usbd_do_request(sc->sc_udev, &req, NULL);
req 2212 dev/usb/if_rum.c usb_device_request_t req;
req 2217 dev/usb/if_rum.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 2218 dev/usb/if_rum.c req.bRequest = RT2573_READ_MULTI_MAC;
req 2219 dev/usb/if_rum.c USETW(req.wValue, 0);
req 2220 dev/usb/if_rum.c USETW(req.wIndex, RT2573_STA_CSR0);
req 2221 dev/usb/if_rum.c USETW(req.wLength, sizeof sc->sta);
req 2224 dev/usb/if_rum.c USBD_DEFAULT_TIMEOUT, &req, sc->sta, sizeof sc->sta, 0,
req 381 dev/usb/if_udav.c usb_device_request_t req;
req 396 dev/usb/if_udav.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 397 dev/usb/if_udav.c req.bRequest = UDAV_REQ_MEM_READ;
req 398 dev/usb/if_udav.c USETW(req.wValue, 0x0000);
req 399 dev/usb/if_udav.c USETW(req.wIndex, offset);
req 400 dev/usb/if_udav.c USETW(req.wLength, len);
req 403 dev/usb/if_udav.c err = usbd_do_request(sc->sc_udev, &req, buf);
req 418 dev/usb/if_udav.c usb_device_request_t req;
req 433 dev/usb/if_udav.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 434 dev/usb/if_udav.c req.bRequest = UDAV_REQ_MEM_WRITE;
req 435 dev/usb/if_udav.c USETW(req.wValue, 0x0000);
req 436 dev/usb/if_udav.c USETW(req.wIndex, offset);
req 437 dev/usb/if_udav.c USETW(req.wLength, len);
req 440 dev/usb/if_udav.c err = usbd_do_request(sc->sc_udev, &req, buf);
req 455 dev/usb/if_udav.c usb_device_request_t req;
req 469 dev/usb/if_udav.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 470 dev/usb/if_udav.c req.bRequest = UDAV_REQ_MEM_WRITE1;
req 471 dev/usb/if_udav.c USETW(req.wValue, ch);
req 472 dev/usb/if_udav.c USETW(req.wIndex, offset);
req 473 dev/usb/if_udav.c USETW(req.wLength, 0x0000);
req 476 dev/usb/if_udav.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 492 dev/usb/if_udav.c usb_device_request_t req;
req 507 dev/usb/if_udav.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 508 dev/usb/if_udav.c req.bRequest = UDAV_REQ_REG_READ;
req 509 dev/usb/if_udav.c USETW(req.wValue, 0x0000);
req 510 dev/usb/if_udav.c USETW(req.wIndex, offset);
req 511 dev/usb/if_udav.c USETW(req.wLength, len);
req 514 dev/usb/if_udav.c err = usbd_do_request(sc->sc_udev, &req, buf);
req 529 dev/usb/if_udav.c usb_device_request_t req;
req 544 dev/usb/if_udav.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 545 dev/usb/if_udav.c req.bRequest = UDAV_REQ_REG_WRITE;
req 546 dev/usb/if_udav.c USETW(req.wValue, 0x0000);
req 547 dev/usb/if_udav.c USETW(req.wIndex, offset);
req 548 dev/usb/if_udav.c USETW(req.wLength, len);
req 551 dev/usb/if_udav.c err = usbd_do_request(sc->sc_udev, &req, buf);
req 583 dev/usb/if_udav.c usb_device_request_t req;
req 597 dev/usb/if_udav.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 598 dev/usb/if_udav.c req.bRequest = UDAV_REQ_REG_WRITE1;
req 599 dev/usb/if_udav.c USETW(req.wValue, ch);
req 600 dev/usb/if_udav.c USETW(req.wIndex, offset);
req 601 dev/usb/if_udav.c USETW(req.wLength, 0x0000);
req 604 dev/usb/if_udav.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 391 dev/usb/if_url.c usb_device_request_t req;
req 404 dev/usb/if_url.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 406 dev/usb/if_url.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 407 dev/usb/if_url.c req.bRequest = URL_REQ_MEM;
req 408 dev/usb/if_url.c USETW(req.wValue, offset);
req 409 dev/usb/if_url.c USETW(req.wIndex, 0x0000);
req 410 dev/usb/if_url.c USETW(req.wLength, len);
req 413 dev/usb/if_url.c err = usbd_do_request(sc->sc_udev, &req, buf);
req 870 dev/usb/if_zyd.c struct zyd_rfwrite req;
req 877 dev/usb/if_zyd.c req.code = htole16(2);
req 878 dev/usb/if_zyd.c req.width = htole16(rf->width);
req 880 dev/usb/if_zyd.c req.bit[i] = htole16(cr203);
req 882 dev/usb/if_zyd.c req.bit[i] |= htole16(ZYD_RF_DATA);
req 884 dev/usb/if_zyd.c return zyd_cmd(sc, ZYD_CMD_RFCFG, &req, 4 + 2 * rf->width, NULL, 0, 0);
req 2463 dev/usb/if_zyd.c usb_device_request_t req;
req 2469 dev/usb/if_zyd.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 2470 dev/usb/if_zyd.c req.bRequest = ZYD_DOWNLOADREQ;
req 2471 dev/usb/if_zyd.c USETW(req.wIndex, 0);
req 2480 dev/usb/if_zyd.c USETW(req.wValue, addr);
req 2481 dev/usb/if_zyd.c USETW(req.wLength, mlen);
req 2482 dev/usb/if_zyd.c if (usbd_do_request(sc->sc_udev, &req, fw) != 0)
req 2491 dev/usb/if_zyd.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 2492 dev/usb/if_zyd.c req.bRequest = ZYD_DOWNLOADSTS;
req 2493 dev/usb/if_zyd.c USETW(req.wValue, 0);
req 2494 dev/usb/if_zyd.c USETW(req.wIndex, 0);
req 2495 dev/usb/if_zyd.c USETW(req.wLength, sizeof stat);
req 2496 dev/usb/if_zyd.c if (usbd_do_request(sc->sc_udev, &req, &stat) != 0)
req 316 dev/usb/moscom.c usb_device_request_t req;
req 331 dev/usb/moscom.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 332 dev/usb/moscom.c req.bRequest = MOSCOM_WRITE;
req 333 dev/usb/moscom.c USETW(req.wValue, 0x08);
req 334 dev/usb/moscom.c USETW(req.wIndex, MOSCOM_INT);
req 335 dev/usb/moscom.c USETW(req.wLength, 0);
req 336 dev/usb/moscom.c if (usbd_do_request(sc->sc_udev, &req, NULL) != 0)
req 443 dev/usb/moscom.c usb_device_request_t req;
req 446 dev/usb/moscom.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 447 dev/usb/moscom.c req.bRequest = MOSCOM_WRITE;
req 448 dev/usb/moscom.c USETW(req.wValue, val + MOSCOM_UART_REG);
req 449 dev/usb/moscom.c USETW(req.wIndex, reg);
req 450 dev/usb/moscom.c USETW(req.wLength, 0);
req 451 dev/usb/moscom.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 1651 dev/usb/ohci.c usb_device_request_t *req = &xfer->request;
req 1662 dev/usb/ohci.c isread = req->bmRequestType & UT_READ;
req 1663 dev/usb/ohci.c len = UGETW(req->wLength);
req 1667 dev/usb/ohci.c req->bmRequestType, req->bRequest, UGETW(req->wValue),
req 1668 dev/usb/ohci.c UGETW(req->wIndex), len, addr,
req 1712 dev/usb/ohci.c memcpy(KERNADDR(&opipe->u.ctl.reqdma, 0), req, sizeof *req);
req 1719 dev/usb/ohci.c setup->td.td_be = htole32(letoh32(setup->td.td_cbp) + sizeof *req - 1);
req 2384 dev/usb/ohci.c usb_device_request_t *req;
req 2401 dev/usb/ohci.c req = &xfer->request;
req 2404 dev/usb/ohci.c req->bmRequestType, req->bRequest));
req 2406 dev/usb/ohci.c len = UGETW(req->wLength);
req 2407 dev/usb/ohci.c value = UGETW(req->wValue);
req 2408 dev/usb/ohci.c index = UGETW(req->wIndex);
req 2414 dev/usb/ohci.c switch(C(req->bRequest, req->bmRequestType)) {
req 358 dev/usb/uark.c usb_device_request_t req;
req 361 dev/usb/uark.c req.bmRequestType = UARK_WRITE;
req 362 dev/usb/uark.c req.bRequest = UARK_REQUEST;
req 363 dev/usb/uark.c USETW(req.wValue, value);
req 364 dev/usb/uark.c USETW(req.wIndex, index);
req 365 dev/usb/uark.c USETW(req.wLength, 0);
req 366 dev/usb/uark.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 2215 dev/usb/uaudio.c usb_device_request_t req;
req 2223 dev/usb/uaudio.c req.bmRequestType = type;
req 2224 dev/usb/uaudio.c req.bRequest = which;
req 2225 dev/usb/uaudio.c USETW(req.wValue, wValue);
req 2226 dev/usb/uaudio.c USETW(req.wIndex, wIndex);
req 2227 dev/usb/uaudio.c USETW(req.wLength, len);
req 2231 dev/usb/uaudio.c err = usbd_do_request(sc->sc_udev, &req, data);
req 2255 dev/usb/uaudio.c usb_device_request_t req;
req 2262 dev/usb/uaudio.c req.bmRequestType = type;
req 2263 dev/usb/uaudio.c req.bRequest = which;
req 2264 dev/usb/uaudio.c USETW(req.wValue, wValue);
req 2265 dev/usb/uaudio.c USETW(req.wIndex, wIndex);
req 2266 dev/usb/uaudio.c USETW(req.wLength, len);
req 2281 dev/usb/uaudio.c err = usbd_do_request(sc->sc_udev, &req, data);
req 3209 dev/usb/uaudio.c usb_device_request_t req;
req 3213 dev/usb/uaudio.c req.bmRequestType = UT_WRITE_CLASS_ENDPOINT;
req 3214 dev/usb/uaudio.c req.bRequest = SET_CUR;
req 3215 dev/usb/uaudio.c USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0);
req 3216 dev/usb/uaudio.c USETW(req.wIndex, endpt);
req 3217 dev/usb/uaudio.c USETW(req.wLength, 3);
req 3222 dev/usb/uaudio.c return (usbd_do_request(sc->sc_udev, &req, data));
req 452 dev/usb/ubsa.c usb_device_request_t req;
req 455 dev/usb/ubsa.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 456 dev/usb/ubsa.c req.bRequest = request;
req 457 dev/usb/ubsa.c USETW(req.wValue, value);
req 458 dev/usb/ubsa.c USETW(req.wIndex, sc->sc_iface_number);
req 459 dev/usb/ubsa.c USETW(req.wLength, 0);
req 461 dev/usb/ubsa.c err = usbd_do_request(sc->sc_udev, &req, 0);
req 870 dev/usb/ubt.c usb_device_request_t req;
req 893 dev/usb/ubt.c memset(&req, 0, sizeof(req));
req 894 dev/usb/ubt.c req.bmRequestType = UT_WRITE_CLASS_DEVICE;
req 895 dev/usb/ubt.c USETW(req.wLength, len);
req 901 dev/usb/ubt.c &req,
req 177 dev/usb/udcf.c usb_device_request_t req;
req 244 dev/usb/udcf.c req.bmRequestType = UDCF_CTRL_REQ;
req 245 dev/usb/udcf.c req.bRequest = 0;
req 246 dev/usb/udcf.c USETW(req.wValue, 0);
req 247 dev/usb/udcf.c USETW(req.wIndex, 0);
req 248 dev/usb/udcf.c USETW(req.wLength, 0);
req 249 dev/usb/udcf.c if ((err = usbd_do_request_flags(sc->sc_udev, &req, &result,
req 255 dev/usb/udcf.c req.bmRequestType = UDCF_CTRL_REQ;
req 256 dev/usb/udcf.c req.bRequest = 0;
req 257 dev/usb/udcf.c USETW(req.wValue, UDCF_CTRL_VAL);
req 258 dev/usb/udcf.c USETW(req.wIndex, UDCF_CTRL_IDX);
req 259 dev/usb/udcf.c USETW(req.wLength, 0);
req 260 dev/usb/udcf.c if ((err = usbd_do_request_flags(sc->sc_udev, &req, &result,
req 205 dev/usb/udsbr.c usb_device_request_t req;
req 211 dev/usb/udsbr.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 212 dev/usb/udsbr.c req.bRequest = ureq;
req 213 dev/usb/udsbr.c USETW(req.wValue, value);
req 214 dev/usb/udsbr.c USETW(req.wIndex, index);
req 215 dev/usb/udsbr.c USETW(req.wLength, 1);
req 216 dev/usb/udsbr.c err = usbd_do_request(sc->sc_udev, &req, &data);
req 396 dev/usb/ueagle.c usb_device_request_t req;
req 399 dev/usb/ueagle.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 400 dev/usb/ueagle.c req.bRequest = UEAGLE_REQUEST;
req 401 dev/usb/ueagle.c USETW(req.wValue, val);
req 402 dev/usb/ueagle.c USETW(req.wIndex, index);
req 403 dev/usb/ueagle.c USETW(req.wLength, len);
req 405 dev/usb/ueagle.c error = usbd_do_request_async(sc->sc_udev, &req, data);
req 915 dev/usb/ueagle.c struct ueagle_isoreq *req = priv;
req 916 dev/usb/ueagle.c struct ueagle_softc *sc = req->sc;
req 925 dev/usb/ueagle.c count = req->frlengths[i];
req 926 dev/usb/ueagle.c p = req->offsets[i];
req 939 dev/usb/ueagle.c req->frlengths[i] = sc->isize;
req 942 dev/usb/ueagle.c usbd_setup_isoc_xfer(req->xfer, sc->pipeh_rx, req, req->frlengths,
req 951 dev/usb/ueagle.c struct ueagle_txreq *req = priv;
req 952 dev/usb/ueagle.c struct ueagle_softc *sc = req->sc;
req 986 dev/usb/ueagle.c struct ueagle_txreq *req;
req 993 dev/usb/ueagle.c req = &sc->txreqs[0];
req 997 dev/usb/ueagle.c dst = req->buf;
req 1069 dev/usb/ueagle.c usbd_setup_xfer(req->xfer, sc->pipeh_tx, req, req->buf,
req 1070 dev/usb/ueagle.c dst + cellleft - req->buf, USBD_FORCE_SHORT_XFER | USBD_NO_COPY,
req 1073 dev/usb/ueagle.c error = usbd_transfer(req->xfer);
req 438 dev/usb/uftdi.c usb_device_request_t req;
req 448 dev/usb/uftdi.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 449 dev/usb/uftdi.c req.bRequest = FTDI_SIO_RESET;
req 450 dev/usb/uftdi.c USETW(req.wValue, FTDI_SIO_RESET_SIO);
req 451 dev/usb/uftdi.c USETW(req.wIndex, portno);
req 452 dev/usb/uftdi.c USETW(req.wLength, 0);
req 453 dev/usb/uftdi.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 463 dev/usb/uftdi.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 464 dev/usb/uftdi.c req.bRequest = FTDI_SIO_SET_FLOW_CTRL;
req 465 dev/usb/uftdi.c USETW(req.wValue, 0);
req 466 dev/usb/uftdi.c USETW2(req.wIndex, FTDI_SIO_RTS_CTS_HS, portno);
req 467 dev/usb/uftdi.c USETW(req.wLength, 0);
req 468 dev/usb/uftdi.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 528 dev/usb/uftdi.c usb_device_request_t req;
req 547 dev/usb/uftdi.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 548 dev/usb/uftdi.c req.bRequest = FTDI_SIO_MODEM_CTRL;
req 549 dev/usb/uftdi.c USETW(req.wValue, ctl);
req 550 dev/usb/uftdi.c USETW(req.wIndex, portno);
req 551 dev/usb/uftdi.c USETW(req.wLength, 0);
req 553 dev/usb/uftdi.c "index=0x%04x len=%d\n", req.bmRequestType, req.bRequest,
req 554 dev/usb/uftdi.c UGETW(req.wValue), UGETW(req.wIndex), UGETW(req.wLength)));
req 555 dev/usb/uftdi.c (void)usbd_do_request(sc->sc_udev, &req, NULL);
req 562 dev/usb/uftdi.c usb_device_request_t req;
req 594 dev/usb/uftdi.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 595 dev/usb/uftdi.c req.bRequest = FTDI_SIO_SET_BAUD_RATE;
req 596 dev/usb/uftdi.c USETW(req.wValue, rate);
req 597 dev/usb/uftdi.c USETW(req.wIndex, portno);
req 598 dev/usb/uftdi.c USETW(req.wLength, 0);
req 600 dev/usb/uftdi.c "index=0x%04x len=%d\n", req.bmRequestType, req.bRequest,
req 601 dev/usb/uftdi.c UGETW(req.wValue), UGETW(req.wIndex), UGETW(req.wLength)));
req 602 dev/usb/uftdi.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 633 dev/usb/uftdi.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 634 dev/usb/uftdi.c req.bRequest = FTDI_SIO_SET_DATA;
req 635 dev/usb/uftdi.c USETW(req.wValue, data);
req 636 dev/usb/uftdi.c USETW(req.wIndex, portno);
req 637 dev/usb/uftdi.c USETW(req.wLength, 0);
req 639 dev/usb/uftdi.c "index=0x%04x len=%d\n", req.bmRequestType, req.bRequest,
req 640 dev/usb/uftdi.c UGETW(req.wValue), UGETW(req.wIndex), UGETW(req.wLength)));
req 641 dev/usb/uftdi.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 647 dev/usb/uftdi.c USETW(req.wValue, 0);
req 650 dev/usb/uftdi.c USETW2(req.wValue, t->c_cc[VSTOP], t->c_cc[VSTART]);
req 653 dev/usb/uftdi.c USETW(req.wValue, 0);
req 655 dev/usb/uftdi.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 656 dev/usb/uftdi.c req.bRequest = FTDI_SIO_SET_FLOW_CTRL;
req 657 dev/usb/uftdi.c USETW2(req.wIndex, flow, portno);
req 658 dev/usb/uftdi.c USETW(req.wLength, 0);
req 659 dev/usb/uftdi.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 684 dev/usb/uftdi.c usb_device_request_t req;
req 696 dev/usb/uftdi.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 697 dev/usb/uftdi.c req.bRequest = FTDI_SIO_SET_DATA;
req 698 dev/usb/uftdi.c USETW(req.wValue, data);
req 699 dev/usb/uftdi.c USETW(req.wIndex, portno);
req 700 dev/usb/uftdi.c USETW(req.wLength, 0);
req 701 dev/usb/uftdi.c (void)usbd_do_request(sc->sc_udev, &req, NULL);
req 850 dev/usb/ugen.c struct isoreq *req = addr;
req 851 dev/usb/ugen.c struct ugen_endpoint *sce = req->sce;
req 860 dev/usb/ugen.c DPRINTFN(5,("ugen_isoc_rintr: xfer %d, count=%d\n", req - sce->isoreqs,
req 874 dev/usb/ugen.c u_int32_t actlen = req->sizes[i];
req 875 dev/usb/ugen.c char const *buf = (char const *)req->dmabuf + isize * i;
req 890 dev/usb/ugen.c req->sizes[i] = isize;
req 893 dev/usb/ugen.c usbd_setup_isoc_xfer(xfer, sce->pipeh, req, req->sizes, UGEN_NISORFRMS,
req 2158 dev/usb/uhci.c usb_device_request_t *req = &xfer->request;
req 2174 dev/usb/uhci.c req->bmRequestType, req->bRequest, UGETW(req->wValue),
req 2175 dev/usb/uhci.c UGETW(req->wIndex), UGETW(req->wLength),
req 2179 dev/usb/uhci.c isread = req->bmRequestType & UT_READ;
req 2180 dev/usb/uhci.c len = UGETW(req->wLength);
req 2201 dev/usb/uhci.c memcpy(KERNADDR(&upipe->u.ctl.reqdma, 0), req, sizeof *req);
req 2207 dev/usb/uhci.c setup->td.td_token = htole32(UHCI_TD_SETUP(sizeof *req, endpt, addr));
req 3095 dev/usb/uhci.c usb_device_request_t *req;
req 3109 dev/usb/uhci.c req = &xfer->request;
req 3112 dev/usb/uhci.c req->bmRequestType, req->bRequest));
req 3114 dev/usb/uhci.c len = UGETW(req->wLength);
req 3115 dev/usb/uhci.c value = UGETW(req->wValue);
req 3116 dev/usb/uhci.c index = UGETW(req->wIndex);
req 3122 dev/usb/uhci.c switch(C(req->bRequest, req->bmRequestType)) {
req 138 dev/usb/uhub.c usb_device_request_t req;
req 166 dev/usb/uhub.c req.bmRequestType = UT_READ_CLASS_DEVICE;
req 167 dev/usb/uhub.c req.bRequest = UR_GET_DESCRIPTOR;
req 168 dev/usb/uhub.c USETW2(req.wValue, UDESC_HUB, 0);
req 169 dev/usb/uhub.c USETW(req.wIndex, 0);
req 170 dev/usb/uhub.c USETW(req.wLength, USB_HUB_DESCRIPTOR_SIZE);
req 172 dev/usb/uhub.c err = usbd_do_request(dev, &req, &hubdesc);
req 175 dev/usb/uhub.c USETW(req.wLength, USB_HUB_DESCRIPTOR_SIZE + (nports+1) / 8);
req 176 dev/usb/uhub.c err = usbd_do_request(dev, &req, &hubdesc);
req 263 dev/usb/uipaq.c usb_device_request_t req;
req 276 dev/usb/uipaq.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 277 dev/usb/uipaq.c req.bRequest = UCDC_SET_CONTROL_LINE_STATE;
req 279 dev/usb/uipaq.c USETW(req.wValue, sc->sc_lcr);
req 280 dev/usb/uipaq.c USETW(req.wIndex, 0x0);
req 281 dev/usb/uipaq.c USETW(req.wLength, 0);
req 285 dev/usb/uipaq.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 296 dev/usb/uipaq.c usb_device_request_t req;
req 306 dev/usb/uipaq.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 307 dev/usb/uipaq.c req.bRequest = UCDC_SET_CONTROL_LINE_STATE;
req 309 dev/usb/uipaq.c USETW(req.wValue, sc->sc_lcr);
req 310 dev/usb/uipaq.c USETW(req.wIndex, 0x0);
req 311 dev/usb/uipaq.c USETW(req.wLength, 0);
req 314 dev/usb/uipaq.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 325 dev/usb/uipaq.c usb_device_request_t req;
req 331 dev/usb/uipaq.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 332 dev/usb/uipaq.c req.bRequest = UCDC_SEND_BREAK;
req 334 dev/usb/uipaq.c USETW(req.wValue, onoff ? UCDC_BREAK_ON : UCDC_BREAK_OFF);
req 335 dev/usb/uipaq.c USETW(req.wIndex, 0x0);
req 336 dev/usb/uipaq.c USETW(req.wLength, 0);
req 339 dev/usb/uipaq.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 284 dev/usb/ulpt.c usb_device_request_t req;
req 287 dev/usb/ulpt.c req.bmRequestType = UT_READ_CLASS_INTERFACE;
req 288 dev/usb/ulpt.c req.bRequest = UR_GET_DEVICE_ID;
req 289 dev/usb/ulpt.c USETW(req.wValue, cd->bConfigurationValue);
req 290 dev/usb/ulpt.c USETW2(req.wIndex, id->bInterfaceNumber, id->bAlternateSetting);
req 291 dev/usb/ulpt.c USETW(req.wLength, DEVINFOSIZE - 1);
req 292 dev/usb/ulpt.c err = usbd_do_request_flags(dev, &req, devinfop, USBD_SHORT_XFER_OK,
req 373 dev/usb/ulpt.c usb_device_request_t req;
req 377 dev/usb/ulpt.c req.bmRequestType = UT_READ_CLASS_INTERFACE;
req 378 dev/usb/ulpt.c req.bRequest = UR_GET_PORT_STATUS;
req 379 dev/usb/ulpt.c USETW(req.wValue, 0);
req 380 dev/usb/ulpt.c USETW(req.wIndex, sc->sc_ifaceno);
req 381 dev/usb/ulpt.c USETW(req.wLength, 1);
req 382 dev/usb/ulpt.c err = usbd_do_request(sc->sc_udev, &req, &status);
req 393 dev/usb/ulpt.c usb_device_request_t req;
req 396 dev/usb/ulpt.c req.bRequest = UR_SOFT_RESET;
req 397 dev/usb/ulpt.c USETW(req.wValue, 0);
req 398 dev/usb/ulpt.c USETW(req.wIndex, sc->sc_ifaceno);
req 399 dev/usb/ulpt.c USETW(req.wLength, 0);
req 407 dev/usb/ulpt.c req.bmRequestType = UT_WRITE_CLASS_OTHER;
req 408 dev/usb/ulpt.c if (usbd_do_request(sc->sc_udev, &req, 0)) { /* 1.0 */
req 409 dev/usb/ulpt.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 410 dev/usb/ulpt.c (void)usbd_do_request(sc->sc_udev, &req, 0); /* 1.1 */
req 215 dev/usb/umass.c usb_device_request_t *req,
req 842 dev/usb/umass.c umass_setup_ctrl_transfer(struct umass_softc *sc, usb_device_request_t *req,
req 853 dev/usb/umass.c USBD_DEFAULT_TIMEOUT, req, buffer, buflen, flags,
req 1856 dev/usb/umass.c usb_device_request_t req;
req 1864 dev/usb/umass.c req.bmRequestType = UT_READ_CLASS_INTERFACE;
req 1865 dev/usb/umass.c req.bRequest = UR_BBB_GET_MAX_LUN;
req 1866 dev/usb/umass.c USETW(req.wValue, 0);
req 1867 dev/usb/umass.c USETW(req.wIndex, sc->sc_ifaceno);
req 1868 dev/usb/umass.c USETW(req.wLength, 1);
req 1870 dev/usb/umass.c err = usbd_do_request_flags(sc->sc_udev, &req, maxlun,
req 495 dev/usb/umass_quirks.c usb_device_request_t req;
req 499 dev/usb/umass_quirks.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 500 dev/usb/umass_quirks.c req.bRequest = 1;
req 501 dev/usb/umass_quirks.c USETW(req.wValue, 0);
req 502 dev/usb/umass_quirks.c USETW(req.wIndex, sc->sc_ifaceno);
req 503 dev/usb/umass_quirks.c USETW(req.wLength, sizeof(status));
req 505 dev/usb/umass_quirks.c return (usbd_do_request(sc->sc_udev, &req, &status));
req 376 dev/usb/umct.c usb_device_request_t req;
req 385 dev/usb/umct.c req.bmRequestType = UMCT_SET_REQUEST;
req 386 dev/usb/umct.c req.bRequest = REQ_SET_MCR;
req 387 dev/usb/umct.c USETW(req.wValue, 0);
req 388 dev/usb/umct.c USETW(req.wIndex, sc->sc_iface_number);
req 389 dev/usb/umct.c USETW(req.wLength, LENGTH_SET_MCR);
req 391 dev/usb/umct.c (void)usbd_do_request(sc->sc_udev, &req, &ls);
req 451 dev/usb/umct.c usb_device_request_t req;
req 455 dev/usb/umct.c req.bmRequestType = UMCT_SET_REQUEST;
req 456 dev/usb/umct.c req.bRequest = REQ_SET_LCR;
req 457 dev/usb/umct.c USETW(req.wValue, 0);
req 458 dev/usb/umct.c USETW(req.wIndex, sc->sc_iface_number);
req 459 dev/usb/umct.c USETW(req.wLength, LENGTH_SET_LCR);
req 462 dev/usb/umct.c (void)usbd_do_request(sc->sc_udev, &req, &adata);
req 468 dev/usb/umct.c usb_device_request_t req;
req 492 dev/usb/umct.c req.bmRequestType = UMCT_SET_REQUEST;
req 493 dev/usb/umct.c req.bRequest = REQ_SET_BAUD_RATE;
req 494 dev/usb/umct.c USETW(req.wValue, 0);
req 495 dev/usb/umct.c USETW(req.wIndex, sc->sc_iface_number);
req 496 dev/usb/umct.c USETW(req.wLength, LENGTH_BAUD_RATE);
req 499 dev/usb/umct.c (void)usbd_do_request(sc->sc_udev, &req, arate);
req 617 dev/usb/umodem.c usb_device_request_t req;
req 622 dev/usb/umodem.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 623 dev/usb/umodem.c req.bRequest = UCDC_SET_CONTROL_LINE_STATE;
req 624 dev/usb/umodem.c USETW(req.wValue, ls);
req 625 dev/usb/umodem.c USETW(req.wIndex, sc->sc_ctl_iface_no);
req 626 dev/usb/umodem.c USETW(req.wLength, 0);
req 628 dev/usb/umodem.c (void)usbd_do_request(sc->sc_udev, &req, 0);
req 635 dev/usb/umodem.c usb_device_request_t req;
req 642 dev/usb/umodem.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 643 dev/usb/umodem.c req.bRequest = UCDC_SEND_BREAK;
req 644 dev/usb/umodem.c USETW(req.wValue, onoff ? UCDC_BREAK_ON : UCDC_BREAK_OFF);
req 645 dev/usb/umodem.c USETW(req.wIndex, sc->sc_ctl_iface_no);
req 646 dev/usb/umodem.c USETW(req.wLength, 0);
req 648 dev/usb/umodem.c (void)usbd_do_request(sc->sc_udev, &req, 0);
req 674 dev/usb/umodem.c usb_device_request_t req;
req 686 dev/usb/umodem.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 687 dev/usb/umodem.c req.bRequest = UCDC_SET_LINE_CODING;
req 688 dev/usb/umodem.c USETW(req.wValue, 0);
req 689 dev/usb/umodem.c USETW(req.wIndex, sc->sc_ctl_iface_no);
req 690 dev/usb/umodem.c USETW(req.wLength, UCDC_LINE_STATE_LENGTH);
req 692 dev/usb/umodem.c err = usbd_do_request(sc->sc_udev, &req, state);
req 707 dev/usb/umodem.c usb_device_request_t req;
req 714 dev/usb/umodem.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 715 dev/usb/umodem.c req.bRequest = UCDC_SET_COMM_FEATURE;
req 716 dev/usb/umodem.c USETW(req.wValue, feature);
req 717 dev/usb/umodem.c USETW(req.wIndex, sc->sc_ctl_iface_no);
req 718 dev/usb/umodem.c USETW(req.wLength, UCDC_ABSTRACT_STATE_LENGTH);
req 721 dev/usb/umodem.c err = usbd_do_request(sc->sc_udev, &req, &ast);
req 416 dev/usb/uow.c usb_device_request_t req;
req 419 dev/usb/uow.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 420 dev/usb/uow.c req.bRequest = type;
req 421 dev/usb/uow.c USETW(req.wValue, cmd);
req 422 dev/usb/uow.c USETW(req.wIndex, param);
req 423 dev/usb/uow.c USETW(req.wLength, 0);
req 424 dev/usb/uow.c if ((error = usbd_do_request(sc->sc_udev, &req, NULL)) != 0) {
req 469 dev/usb/uplcom.c usb_device_request_t req;
req 472 dev/usb/uplcom.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 473 dev/usb/uplcom.c req.bRequest = UPLCOM_SET_REQUEST;
req 474 dev/usb/uplcom.c USETW(req.wValue, 0);
req 475 dev/usb/uplcom.c USETW(req.wIndex, sc->sc_iface_number);
req 476 dev/usb/uplcom.c USETW(req.wLength, 0);
req 478 dev/usb/uplcom.c err = usbd_do_request(sc->sc_udev, &req, 0);
req 488 dev/usb/uplcom.c usb_device_request_t req;
req 500 dev/usb/uplcom.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 501 dev/usb/uplcom.c req.bRequest = UCDC_SET_CONTROL_LINE_STATE;
req 502 dev/usb/uplcom.c USETW(req.wValue, ls);
req 503 dev/usb/uplcom.c USETW(req.wIndex, sc->sc_iface_number);
req 504 dev/usb/uplcom.c USETW(req.wLength, 0);
req 506 dev/usb/uplcom.c (void)usbd_do_request(sc->sc_udev, &req, 0);
req 560 dev/usb/uplcom.c usb_device_request_t req;
req 564 dev/usb/uplcom.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 565 dev/usb/uplcom.c req.bRequest = UCDC_SEND_BREAK;
req 566 dev/usb/uplcom.c USETW(req.wValue, onoff ? UCDC_BREAK_ON : UCDC_BREAK_OFF);
req 567 dev/usb/uplcom.c USETW(req.wIndex, sc->sc_iface_number);
req 568 dev/usb/uplcom.c USETW(req.wLength, 0);
req 570 dev/usb/uplcom.c (void)usbd_do_request(sc->sc_udev, &req, 0);
req 576 dev/usb/uplcom.c usb_device_request_t req;
req 581 dev/usb/uplcom.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 582 dev/usb/uplcom.c req.bRequest = UPLCOM_SET_REQUEST;
req 583 dev/usb/uplcom.c USETW(req.wValue, 0);
req 584 dev/usb/uplcom.c USETW(req.wIndex,
req 586 dev/usb/uplcom.c USETW(req.wLength, 0);
req 588 dev/usb/uplcom.c err = usbd_do_request(sc->sc_udev, &req, 0);
req 601 dev/usb/uplcom.c usb_device_request_t req;
req 613 dev/usb/uplcom.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 614 dev/usb/uplcom.c req.bRequest = UCDC_SET_LINE_CODING;
req 615 dev/usb/uplcom.c USETW(req.wValue, 0);
req 616 dev/usb/uplcom.c USETW(req.wIndex, sc->sc_iface_number);
req 617 dev/usb/uplcom.c USETW(req.wLength, UCDC_LINE_STATE_LENGTH);
req 619 dev/usb/uplcom.c err = usbd_do_request(sc->sc_udev, &req, state);
req 691 dev/usb/uplcom.c usb_device_request_t req;
req 718 dev/usb/uplcom.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 719 dev/usb/uplcom.c req.bRequest = UPLCOM_SET_REQUEST;
req 720 dev/usb/uplcom.c USETW(req.wValue, 2);
req 721 dev/usb/uplcom.c USETW(req.wIndex, 0x44);
req 722 dev/usb/uplcom.c USETW(req.wLength, 0);
req 724 dev/usb/uplcom.c uerr = usbd_do_request(sc->sc_udev, &req, 0);
req 729 dev/usb/uplcom.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 730 dev/usb/uplcom.c req.bRequest = UPLCOM_SET_REQUEST;
req 731 dev/usb/uplcom.c USETW(req.wValue, 8);
req 732 dev/usb/uplcom.c USETW(req.wIndex, 0);
req 733 dev/usb/uplcom.c USETW(req.wLength, 0);
req 735 dev/usb/uplcom.c uerr = usbd_do_request(sc->sc_udev, &req, 0);
req 739 dev/usb/uplcom.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 740 dev/usb/uplcom.c req.bRequest = UPLCOM_SET_REQUEST;
req 741 dev/usb/uplcom.c USETW(req.wValue, 9);
req 742 dev/usb/uplcom.c USETW(req.wIndex, 0);
req 743 dev/usb/uplcom.c USETW(req.wLength, 0);
req 745 dev/usb/uplcom.c uerr = usbd_do_request(sc->sc_udev, &req, 0);
req 452 dev/usb/urio.c usb_device_request_t req;
req 490 dev/usb/urio.c req.bmRequestType = requesttype;
req 491 dev/usb/urio.c req.bRequest = rcmd->request;
req 492 dev/usb/urio.c USETW(req.wValue, rcmd->value);
req 493 dev/usb/urio.c USETW(req.wIndex, rcmd->index);
req 494 dev/usb/urio.c USETW(req.wLength, len);
req 506 dev/usb/urio.c uio.uio_rw = req.bmRequestType & UT_READ ?
req 519 dev/usb/urio.c err = usbd_do_request_flags(sc->sc_udev, &req, ptr, req_flags,
req 128 dev/usb/usb_subr.c usb_device_request_t req;
req 132 dev/usb/usb_subr.c req.bmRequestType = UT_READ_DEVICE;
req 133 dev/usb/usb_subr.c req.bRequest = UR_GET_DESCRIPTOR;
req 134 dev/usb/usb_subr.c USETW2(req.wValue, UDESC_STRING, sindex);
req 135 dev/usb/usb_subr.c USETW(req.wIndex, langid);
req 136 dev/usb/usb_subr.c USETW(req.wLength, 1); /* only size byte first */
req 137 dev/usb/usb_subr.c err = usbd_do_request_flags(dev, &req, sdesc, USBD_SHORT_XFER_OK,
req 145 dev/usb/usb_subr.c USETW(req.wLength, sdesc->bLength); /* the whole string */
req 146 dev/usb/usb_subr.c err = usbd_do_request_flags(dev, &req, sdesc, USBD_SHORT_XFER_OK,
req 360 dev/usb/usb_subr.c usb_device_request_t req;
req 364 dev/usb/usb_subr.c req.bmRequestType = UT_WRITE_CLASS_OTHER;
req 365 dev/usb/usb_subr.c req.bRequest = UR_SET_FEATURE;
req 366 dev/usb/usb_subr.c USETW(req.wValue, UHF_PORT_RESET);
req 367 dev/usb/usb_subr.c USETW(req.wIndex, port);
req 368 dev/usb/usb_subr.c USETW(req.wLength, 0);
req 369 dev/usb/usb_subr.c err = usbd_do_request(dev, &req, 0);
req 567 dev/usb/usb_subr.c usb_device_request_t req;
req 569 dev/usb/usb_subr.c req.bmRequestType = UT_WRITE_DEVICE;
req 570 dev/usb/usb_subr.c req.bRequest = UR_SET_CONFIG;
req 571 dev/usb/usb_subr.c USETW(req.wValue, conf);
req 572 dev/usb/usb_subr.c USETW(req.wIndex, 0);
req 573 dev/usb/usb_subr.c USETW(req.wLength, 0);
req 574 dev/usb/usb_subr.c return (usbd_do_request(dev, &req, 0));
req 672 dev/usb/usb_subr.c usb_device_request_t req;
req 673 dev/usb/usb_subr.c req.bmRequestType = UT_READ_CLASS_DEVICE;
req 674 dev/usb/usb_subr.c req.bRequest = UR_GET_DESCRIPTOR;
req 675 dev/usb/usb_subr.c USETW(req.wValue, 0);
req 676 dev/usb/usb_subr.c USETW(req.wIndex, 0);
req 677 dev/usb/usb_subr.c USETW(req.wLength, USB_HUB_DESCRIPTOR_SIZE);
req 678 dev/usb/usb_subr.c err = usbd_do_request(dev, &req, &hd);
req 420 dev/usb/usbdi.c usbd_private_handle priv, u_int32_t timeout, usb_device_request_t *req,
req 432 dev/usb/usbdi.c xfer->request = *req;
req 530 dev/usb/usbdi.c usb_device_request_t req;
req 541 dev/usb/usbdi.c req.bmRequestType = UT_WRITE_ENDPOINT;
req 542 dev/usb/usbdi.c req.bRequest = UR_CLEAR_FEATURE;
req 543 dev/usb/usbdi.c USETW(req.wValue, UF_ENDPOINT_HALT);
req 544 dev/usb/usbdi.c USETW(req.wIndex, pipe->endpoint->edesc->bEndpointAddress);
req 545 dev/usb/usbdi.c USETW(req.wLength, 0);
req 546 dev/usb/usbdi.c err = usbd_do_request(dev, &req, 0);
req 561 dev/usb/usbdi.c usb_device_request_t req;
req 566 dev/usb/usbdi.c req.bmRequestType = UT_WRITE_ENDPOINT;
req 567 dev/usb/usbdi.c req.bRequest = UR_CLEAR_FEATURE;
req 568 dev/usb/usbdi.c USETW(req.wValue, UF_ENDPOINT_HALT);
req 569 dev/usb/usbdi.c USETW(req.wIndex, pipe->endpoint->edesc->bEndpointAddress);
req 570 dev/usb/usbdi.c USETW(req.wLength, 0);
req 571 dev/usb/usbdi.c err = usbd_do_request_async(dev, &req, 0);
req 632 dev/usb/usbdi.c usb_device_request_t req;
req 655 dev/usb/usbdi.c req.bmRequestType = UT_WRITE_INTERFACE;
req 656 dev/usb/usbdi.c req.bRequest = UR_SET_INTERFACE;
req 657 dev/usb/usbdi.c USETW(req.wValue, iface->idesc->bAlternateSetting);
req 658 dev/usb/usbdi.c USETW(req.wIndex, iface->idesc->bInterfaceNumber);
req 659 dev/usb/usbdi.c USETW(req.wLength, 0);
req 660 dev/usb/usbdi.c return (usbd_do_request(iface->device, &req, 0));
req 690 dev/usb/usbdi.c usb_device_request_t req;
req 692 dev/usb/usbdi.c req.bmRequestType = UT_READ_INTERFACE;
req 693 dev/usb/usbdi.c req.bRequest = UR_GET_INTERFACE;
req 694 dev/usb/usbdi.c USETW(req.wValue, 0);
req 695 dev/usb/usbdi.c USETW(req.wIndex, iface->idesc->bInterfaceNumber);
req 696 dev/usb/usbdi.c USETW(req.wLength, 1);
req 697 dev/usb/usbdi.c return (usbd_do_request(iface->device, &req, aiface));
req 897 dev/usb/usbdi.c usbd_do_request(usbd_device_handle dev, usb_device_request_t *req, void *data)
req 899 dev/usb/usbdi.c return (usbd_do_request_flags(dev, req, data, 0, 0,
req 904 dev/usb/usbdi.c usbd_do_request_flags(usbd_device_handle dev, usb_device_request_t *req,
req 907 dev/usb/usbdi.c return (usbd_do_request_flags_pipe(dev, dev->default_pipe, req, data,
req 913 dev/usb/usbdi.c usb_device_request_t *req, void *data, u_int16_t flags, int *actlen,
req 929 dev/usb/usbdi.c usbd_setup_default_xfer(xfer, dev, 0, timeout, req, data,
req 930 dev/usb/usbdi.c UGETW(req->wLength), flags, 0);
req 1007 dev/usb/usbdi.c usbd_do_request_async(usbd_device_handle dev, usb_device_request_t *req,
req 1016 dev/usb/usbdi.c usbd_setup_default_xfer(xfer, dev, 0, USBD_DEFAULT_TIMEOUT, req,
req 1017 dev/usb/usbdi.c data, UGETW(req->wLength), 0, usbd_do_request_async_cb);
req 97 dev/usb/usbdi.h usbd_status usbd_transfer(usbd_xfer_handle req);
req 104 dev/usb/usbdi.h usbd_private_handle priv, u_int32_t timeout, usb_device_request_t *req,
req 128 dev/usb/usbdi.h usbd_status usbd_sync_transfer(usbd_xfer_handle req);
req 132 dev/usb/usbdi.h usbd_status usbd_do_request(usbd_device_handle pipe, usb_device_request_t *req,
req 135 dev/usb/usbdi.h usb_device_request_t *req, void *data);
req 137 dev/usb/usbdi.h usb_device_request_t *req, void *data, u_int16_t flags, int*, u_int32_t);
req 139 dev/usb/usbdi.h usbd_pipe_handle pipe, usb_device_request_t *req, void *data,
req 67 dev/usb/usbdi_util.c usb_device_request_t req;
req 72 dev/usb/usbdi_util.c req.bmRequestType = UT_READ_DEVICE;
req 73 dev/usb/usbdi_util.c req.bRequest = UR_GET_DESCRIPTOR;
req 74 dev/usb/usbdi_util.c USETW2(req.wValue, type, index);
req 75 dev/usb/usbdi_util.c USETW(req.wIndex, 0);
req 76 dev/usb/usbdi_util.c USETW(req.wLength, len);
req 77 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, desc));
req 118 dev/usb/usbdi_util.c usb_device_request_t req;
req 120 dev/usb/usbdi_util.c req.bmRequestType = UT_READ_DEVICE;
req 121 dev/usb/usbdi_util.c req.bRequest = UR_GET_STATUS;
req 122 dev/usb/usbdi_util.c USETW(req.wValue, 0);
req 123 dev/usb/usbdi_util.c USETW(req.wIndex, 0);
req 124 dev/usb/usbdi_util.c USETW(req.wLength, sizeof(usb_status_t));
req 125 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, st));
req 131 dev/usb/usbdi_util.c usb_device_request_t req;
req 133 dev/usb/usbdi_util.c req.bmRequestType = UT_READ_CLASS_DEVICE;
req 134 dev/usb/usbdi_util.c req.bRequest = UR_GET_STATUS;
req 135 dev/usb/usbdi_util.c USETW(req.wValue, 0);
req 136 dev/usb/usbdi_util.c USETW(req.wIndex, 0);
req 137 dev/usb/usbdi_util.c USETW(req.wLength, sizeof(usb_hub_status_t));
req 138 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, st));
req 144 dev/usb/usbdi_util.c usb_device_request_t req;
req 146 dev/usb/usbdi_util.c req.bmRequestType = UT_WRITE_DEVICE;
req 147 dev/usb/usbdi_util.c req.bRequest = UR_SET_ADDRESS;
req 148 dev/usb/usbdi_util.c USETW(req.wValue, addr);
req 149 dev/usb/usbdi_util.c USETW(req.wIndex, 0);
req 150 dev/usb/usbdi_util.c USETW(req.wLength, 0);
req 151 dev/usb/usbdi_util.c return usbd_do_request(dev, &req, 0);
req 157 dev/usb/usbdi_util.c usb_device_request_t req;
req 159 dev/usb/usbdi_util.c req.bmRequestType = UT_READ_CLASS_OTHER;
req 160 dev/usb/usbdi_util.c req.bRequest = UR_GET_STATUS;
req 161 dev/usb/usbdi_util.c USETW(req.wValue, 0);
req 162 dev/usb/usbdi_util.c USETW(req.wIndex, port);
req 163 dev/usb/usbdi_util.c USETW(req.wLength, sizeof *ps);
req 164 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, ps));
req 170 dev/usb/usbdi_util.c usb_device_request_t req;
req 172 dev/usb/usbdi_util.c req.bmRequestType = UT_WRITE_CLASS_DEVICE;
req 173 dev/usb/usbdi_util.c req.bRequest = UR_CLEAR_FEATURE;
req 174 dev/usb/usbdi_util.c USETW(req.wValue, sel);
req 175 dev/usb/usbdi_util.c USETW(req.wIndex, 0);
req 176 dev/usb/usbdi_util.c USETW(req.wLength, 0);
req 177 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, 0));
req 183 dev/usb/usbdi_util.c usb_device_request_t req;
req 185 dev/usb/usbdi_util.c req.bmRequestType = UT_WRITE_CLASS_DEVICE;
req 186 dev/usb/usbdi_util.c req.bRequest = UR_SET_FEATURE;
req 187 dev/usb/usbdi_util.c USETW(req.wValue, sel);
req 188 dev/usb/usbdi_util.c USETW(req.wIndex, 0);
req 189 dev/usb/usbdi_util.c USETW(req.wLength, 0);
req 190 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, 0));
req 196 dev/usb/usbdi_util.c usb_device_request_t req;
req 198 dev/usb/usbdi_util.c req.bmRequestType = UT_WRITE_CLASS_OTHER;
req 199 dev/usb/usbdi_util.c req.bRequest = UR_CLEAR_FEATURE;
req 200 dev/usb/usbdi_util.c USETW(req.wValue, sel);
req 201 dev/usb/usbdi_util.c USETW(req.wIndex, port);
req 202 dev/usb/usbdi_util.c USETW(req.wLength, 0);
req 203 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, 0));
req 209 dev/usb/usbdi_util.c usb_device_request_t req;
req 211 dev/usb/usbdi_util.c req.bmRequestType = UT_WRITE_CLASS_OTHER;
req 212 dev/usb/usbdi_util.c req.bRequest = UR_SET_FEATURE;
req 213 dev/usb/usbdi_util.c USETW(req.wValue, sel);
req 214 dev/usb/usbdi_util.c USETW(req.wIndex, port);
req 215 dev/usb/usbdi_util.c USETW(req.wLength, 0);
req 216 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, 0));
req 224 dev/usb/usbdi_util.c usb_device_request_t req;
req 231 dev/usb/usbdi_util.c req.bmRequestType = UT_READ_CLASS_INTERFACE;
req 232 dev/usb/usbdi_util.c req.bRequest = UR_GET_PROTOCOL;
req 233 dev/usb/usbdi_util.c USETW(req.wValue, 0);
req 234 dev/usb/usbdi_util.c USETW(req.wIndex, id->bInterfaceNumber);
req 235 dev/usb/usbdi_util.c USETW(req.wLength, 1);
req 236 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, report));
req 244 dev/usb/usbdi_util.c usb_device_request_t req;
req 251 dev/usb/usbdi_util.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 252 dev/usb/usbdi_util.c req.bRequest = UR_SET_PROTOCOL;
req 253 dev/usb/usbdi_util.c USETW(req.wValue, report);
req 254 dev/usb/usbdi_util.c USETW(req.wIndex, id->bInterfaceNumber);
req 255 dev/usb/usbdi_util.c USETW(req.wLength, 0);
req 256 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, 0));
req 265 dev/usb/usbdi_util.c usb_device_request_t req;
req 271 dev/usb/usbdi_util.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 272 dev/usb/usbdi_util.c req.bRequest = UR_SET_REPORT;
req 273 dev/usb/usbdi_util.c USETW2(req.wValue, type, id);
req 274 dev/usb/usbdi_util.c USETW(req.wIndex, ifd->bInterfaceNumber);
req 275 dev/usb/usbdi_util.c USETW(req.wLength, len);
req 276 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, data));
req 285 dev/usb/usbdi_util.c usb_device_request_t req;
req 291 dev/usb/usbdi_util.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 292 dev/usb/usbdi_util.c req.bRequest = UR_SET_REPORT;
req 293 dev/usb/usbdi_util.c USETW2(req.wValue, type, id);
req 294 dev/usb/usbdi_util.c USETW(req.wIndex, ifd->bInterfaceNumber);
req 295 dev/usb/usbdi_util.c USETW(req.wLength, len);
req 296 dev/usb/usbdi_util.c return (usbd_do_request_async(dev, &req, data));
req 305 dev/usb/usbdi_util.c usb_device_request_t req;
req 311 dev/usb/usbdi_util.c req.bmRequestType = UT_READ_CLASS_INTERFACE;
req 312 dev/usb/usbdi_util.c req.bRequest = UR_GET_REPORT;
req 313 dev/usb/usbdi_util.c USETW2(req.wValue, type, id);
req 314 dev/usb/usbdi_util.c USETW(req.wIndex, ifd->bInterfaceNumber);
req 315 dev/usb/usbdi_util.c USETW(req.wLength, len);
req 316 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, data));
req 324 dev/usb/usbdi_util.c usb_device_request_t req;
req 330 dev/usb/usbdi_util.c req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req 331 dev/usb/usbdi_util.c req.bRequest = UR_SET_IDLE;
req 332 dev/usb/usbdi_util.c USETW2(req.wValue, duration, id);
req 333 dev/usb/usbdi_util.c USETW(req.wIndex, ifd->bInterfaceNumber);
req 334 dev/usb/usbdi_util.c USETW(req.wLength, 0);
req 335 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, 0));
req 342 dev/usb/usbdi_util.c usb_device_request_t req;
req 344 dev/usb/usbdi_util.c req.bmRequestType = UT_READ_INTERFACE;
req 345 dev/usb/usbdi_util.c req.bRequest = UR_GET_DESCRIPTOR;
req 346 dev/usb/usbdi_util.c USETW2(req.wValue, UDESC_REPORT, 0); /* report id should be 0 */
req 347 dev/usb/usbdi_util.c USETW(req.wIndex, ifcno);
req 348 dev/usb/usbdi_util.c USETW(req.wLength, size);
req 349 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, d));
req 412 dev/usb/usbdi_util.c usb_device_request_t req;
req 414 dev/usb/usbdi_util.c req.bmRequestType = UT_READ_DEVICE;
req 415 dev/usb/usbdi_util.c req.bRequest = UR_GET_CONFIG;
req 416 dev/usb/usbdi_util.c USETW(req.wValue, 0);
req 417 dev/usb/usbdi_util.c USETW(req.wIndex, 0);
req 418 dev/usb/usbdi_util.c USETW(req.wLength, 1);
req 419 dev/usb/usbdi_util.c return (usbd_do_request(dev, &req, conf));
req 292 dev/usb/usbf.c usbf_get_descriptor(usbf_device_handle dev, usb_device_request_t *req,
req 295 dev/usb/usbf.c u_int8_t type = UGETW(req->wValue) >> 8;
req 296 dev/usb/usbf.c u_int8_t index = UGETW(req->wValue) & 0xff;
req 305 dev/usb/usbf.c USETW(req->wLength, MIN(UGETW(req->wLength), dd->bLength));;
req 322 dev/usb/usbf.c USETW(req->wLength, MIN(UGETW(req->wLength), dq.bLength));;
req 331 dev/usb/usbf.c USETW(req->wLength, MIN(UGETW(req->wLength),
req 344 dev/usb/usbf.c USETW(req->wLength, MIN(UGETW(req->wLength),
req 353 dev/usb/usbf.c USETW(req->wLength, MIN(UGETW(req->wLength), sd->bLength));
req 431 dev/usb/usbf.c usb_device_request_t *req = xfer->buffer;
req 445 dev/usb/usbf.c usbf_dump_request(dev, req);
req 449 dev/usb/usbf.c switch (C(req->bRequest, req->bmRequestType)) {
req 453 dev/usb/usbf.c usbf_set_address(dev, UGETW(req->wValue));
req 459 dev/usb/usbf.c err = usbf_set_config(dev, UGETW(req->wValue) & 0xff);
req 469 dev/usb/usbf.c USETW(req->wLength, MIN(UGETW(req->wLength), 1));;
req 474 dev/usb/usbf.c err = usbf_get_descriptor(dev, req, &data);
req 479 dev/usb/usbf.c UGETW(req->wLength)));
req 481 dev/usb/usbf.c USETW(req->wLength, MIN(UGETW(req->wLength),
req 490 dev/usb/usbf.c USETW(req->wLength, MIN(UGETW(req->wLength), sizeof status));
req 495 dev/usb/usbf.c value = UGETW(req->wValue);
req 496 dev/usb/usbf.c index = UGETW(req->wIndex);
req 504 dev/usb/usbf.c value = UGETW(req->wValue);
req 505 dev/usb/usbf.c index = UGETW(req->wIndex);
req 514 dev/usb/usbf.c if (UGETW(req->wValue) != 0)
req 520 dev/usb/usbf.c USETW(req->wLength, MIN(UGETW(req->wLength), 1));
req 532 dev/usb/usbf.c err = fun->methods->do_request(fun, req, &data);
req 538 dev/usb/usbf.c "failed, %s\n", req->bRequest, req->bmRequestType,
req 541 dev/usb/usbf.c } else if (UGETW(req->wLength) > 0) {
req 545 dev/usb/usbf.c USETW(req->wLength, 0);
req 549 dev/usb/usbf.c NULL, data, UGETW(req->wLength), 0, 0, NULL);
req 649 dev/usb/usbf.c usbf_request_code_string(usb_device_request_t *req)
req 654 dev/usb/usbf.c usb_enum_string(usb_request_str, req->bRequest));
req 659 dev/usb/usbf.c usbf_request_type_string(usb_device_request_t *req)
req 664 dev/usb/usbf.c usb_enum_string(usb_request_type_str, req->bmRequestType));
req 669 dev/usb/usbf.c usbf_request_desc_string(usb_device_request_t *req)
req 672 dev/usb/usbf.c u_int8_t type = UGETW(req->wValue) >> 8;
req 673 dev/usb/usbf.c u_int8_t index = UGETW(req->wValue) & 0xff;
req 681 dev/usb/usbf.c usbf_dump_request(usbf_device_handle dev, usb_device_request_t *req)
req 686 dev/usb/usbf.c DEVNAME(sc), usbf_request_type_string(req),
req 687 dev/usb/usbf.c usbf_request_code_string(req));
req 689 dev/usb/usbf.c if (req->bRequest == UR_GET_DESCRIPTOR)
req 691 dev/usb/usbf.c UGETW(req->wValue), usbf_request_desc_string(req));
req 694 dev/usb/usbf.c UGETW(req->wValue));
req 696 dev/usb/usbf.c printf("%s: INDEX: 0x%04x\n", DEVNAME(sc), UGETW(req->wIndex));
req 697 dev/usb/usbf.c printf("%s: LENGTH: 0x%04x\n", DEVNAME(sc), UGETW(req->wLength));
req 81 dev/usb/usbf.h usb_device_request_t *req, void **data);
req 928 dev/usb/usbf_subr.c usbf_private_handle priv, usb_device_request_t *req, u_int16_t flags,
req 933 dev/usb/usbf_subr.c xfer->buffer = req;
req 934 dev/usb/usbf_subr.c xfer->length = sizeof *req;
req 279 dev/usb/uslcom.c usb_device_request_t req;
req 285 dev/usb/uslcom.c req.bmRequestType = USLCOM_WRITE;
req 286 dev/usb/uslcom.c req.bRequest = USLCOM_UART;
req 287 dev/usb/uslcom.c USETW(req.wValue, USLCOM_UART_ENABLE);
req 288 dev/usb/uslcom.c USETW(req.wIndex, portno);
req 289 dev/usb/uslcom.c USETW(req.wLength, 0);
req 290 dev/usb/uslcom.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 301 dev/usb/uslcom.c usb_device_request_t req;
req 306 dev/usb/uslcom.c req.bmRequestType = USLCOM_WRITE;
req 307 dev/usb/uslcom.c req.bRequest = USLCOM_UART;
req 308 dev/usb/uslcom.c USETW(req.wValue, USLCOM_UART_DISABLE);
req 309 dev/usb/uslcom.c USETW(req.wIndex, portno);
req 310 dev/usb/uslcom.c USETW(req.wLength, 0);
req 311 dev/usb/uslcom.c usbd_do_request(sc->sc_udev, &req, NULL);
req 318 dev/usb/uslcom.c usb_device_request_t req;
req 336 dev/usb/uslcom.c req.bmRequestType = USLCOM_WRITE;
req 337 dev/usb/uslcom.c req.bRequest = USLCOM_CTRL;
req 338 dev/usb/uslcom.c USETW(req.wValue, ctl);
req 339 dev/usb/uslcom.c USETW(req.wIndex, portno);
req 340 dev/usb/uslcom.c USETW(req.wLength, 0);
req 341 dev/usb/uslcom.c usbd_do_request(sc->sc_udev, &req, NULL);
req 349 dev/usb/uslcom.c usb_device_request_t req;
req 365 dev/usb/uslcom.c req.bmRequestType = USLCOM_WRITE;
req 366 dev/usb/uslcom.c req.bRequest = USLCOM_BAUD_RATE;
req 367 dev/usb/uslcom.c USETW(req.wValue, USLCOM_BAUD_REF / t->c_ospeed);
req 368 dev/usb/uslcom.c USETW(req.wIndex, portno);
req 369 dev/usb/uslcom.c USETW(req.wLength, 0);
req 370 dev/usb/uslcom.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 404 dev/usb/uslcom.c req.bmRequestType = USLCOM_WRITE;
req 405 dev/usb/uslcom.c req.bRequest = USLCOM_DATA;
req 406 dev/usb/uslcom.c USETW(req.wValue, data);
req 407 dev/usb/uslcom.c USETW(req.wIndex, portno);
req 408 dev/usb/uslcom.c USETW(req.wLength, 0);
req 409 dev/usb/uslcom.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 442 dev/usb/uslcom.c usb_device_request_t req;
req 445 dev/usb/uslcom.c req.bmRequestType = USLCOM_WRITE;
req 446 dev/usb/uslcom.c req.bRequest = USLCOM_BREAK;
req 447 dev/usb/uslcom.c USETW(req.wValue, brk);
req 448 dev/usb/uslcom.c USETW(req.wIndex, portno);
req 449 dev/usb/uslcom.c USETW(req.wLength, 0);
req 450 dev/usb/uslcom.c usbd_do_request(sc->sc_udev, &req, NULL);
req 441 dev/usb/uvisor.c usb_device_request_t req;
req 447 dev/usb/uvisor.c req.bmRequestType = UT_READ_VENDOR_ENDPOINT;
req 448 dev/usb/uvisor.c req.bRequest = UVISOR_GET_PALM_INFORMATION;
req 449 dev/usb/uvisor.c USETW(req.wValue, 0);
req 450 dev/usb/uvisor.c USETW(req.wIndex, 0);
req 451 dev/usb/uvisor.c USETW(req.wLength, UVISOR_GET_PALM_INFORMATION_LEN);
req 452 dev/usb/uvisor.c err = usbd_do_request_flags(sc->sc_udev, &req, cpi,
req 469 dev/usb/uvisor.c req.bmRequestType = UT_READ_VENDOR_ENDPOINT;
req 470 dev/usb/uvisor.c req.bRequest = UVISOR_GET_CONNECTION_INFORMATION;
req 471 dev/usb/uvisor.c USETW(req.wValue, 0);
req 472 dev/usb/uvisor.c USETW(req.wIndex, 0);
req 473 dev/usb/uvisor.c USETW(req.wLength, UVISOR_CONNECTION_INFO_SIZE);
req 474 dev/usb/uvisor.c err = usbd_do_request_flags(sc->sc_udev, &req, ci,
req 484 dev/usb/uvisor.c req.bmRequestType = UT_READ_VENDOR_ENDPOINT;
req 485 dev/usb/uvisor.c req.bRequest = UVISOR_REQUEST_BYTES_AVAILABLE;
req 486 dev/usb/uvisor.c USETW(req.wValue, 0);
req 487 dev/usb/uvisor.c USETW(req.wIndex, 5);
req 488 dev/usb/uvisor.c USETW(req.wLength, sizeof avail);
req 489 dev/usb/uvisor.c err = usbd_do_request(sc->sc_udev, &req, &avail);
req 501 dev/usb/uvisor.c usb_device_request_t req;
req 508 dev/usb/uvisor.c req.bmRequestType = UT_READ_VENDOR_ENDPOINT; /* XXX read? */
req 509 dev/usb/uvisor.c req.bRequest = UVISOR_CLOSE_NOTIFICATION;
req 510 dev/usb/uvisor.c USETW(req.wValue, 0);
req 511 dev/usb/uvisor.c USETW(req.wIndex, 0);
req 512 dev/usb/uvisor.c USETW(req.wLength, UVISOR_CONNECTION_INFO_SIZE);
req 513 dev/usb/uvisor.c (void)usbd_do_request_flags(sc->sc_udev, &req, &coninfo,
req 427 dev/usb/uvscom.c usb_device_request_t req;
req 433 dev/usb/uvscom.c req.bmRequestType = UT_READ_VENDOR_DEVICE;
req 434 dev/usb/uvscom.c req.bRequest = UVSCOM_READ_STATUS;
req 435 dev/usb/uvscom.c USETW(req.wValue, 0);
req 436 dev/usb/uvscom.c USETW(req.wIndex, 0);
req 437 dev/usb/uvscom.c USETW(req.wLength, 2);
req 439 dev/usb/uvscom.c err = usbd_do_request(sc->sc_udev, &req, &r);
req 455 dev/usb/uvscom.c usb_device_request_t req;
req 460 dev/usb/uvscom.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 461 dev/usb/uvscom.c req.bRequest = UVSCOM_SHUTDOWN;
req 462 dev/usb/uvscom.c USETW(req.wValue, 0);
req 463 dev/usb/uvscom.c USETW(req.wIndex, 0);
req 464 dev/usb/uvscom.c USETW(req.wLength, 0);
req 466 dev/usb/uvscom.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 495 dev/usb/uvscom.c usb_device_request_t req;
req 501 dev/usb/uvscom.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 502 dev/usb/uvscom.c req.bRequest = UVSCOM_LINE_CTL;
req 503 dev/usb/uvscom.c USETW(req.wValue, line);
req 504 dev/usb/uvscom.c USETW(req.wIndex, 0);
req 505 dev/usb/uvscom.c USETW(req.wLength, 0);
req 507 dev/usb/uvscom.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 520 dev/usb/uvscom.c usb_device_request_t req;
req 526 dev/usb/uvscom.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 527 dev/usb/uvscom.c req.bRequest = UVSCOM_SET_SPEED;
req 528 dev/usb/uvscom.c USETW(req.wValue, lsp);
req 529 dev/usb/uvscom.c USETW(req.wIndex, 0);
req 530 dev/usb/uvscom.c USETW(req.wLength, 0);
req 532 dev/usb/uvscom.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 539 dev/usb/uvscom.c req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req 540 dev/usb/uvscom.c req.bRequest = UVSCOM_SET_PARAM;
req 541 dev/usb/uvscom.c USETW(req.wValue, ls);
req 542 dev/usb/uvscom.c USETW(req.wIndex, 0);
req 543 dev/usb/uvscom.c USETW(req.wLength, 0);
req 545 dev/usb/uvscom.c err = usbd_do_request(sc->sc_udev, &req, NULL);
req 379 dev/wscons/wsdisplay_compat_usl.c u_long req;
req 470 dev/wscons/wsdisplay_compat_usl.c req = WSDISPLAYIO_SMODE;
req 486 dev/wscons/wsdisplay_compat_usl.c req = WSKBDIO_COMPLEXBELL;
req 506 dev/wscons/wsdisplay_compat_usl.c req = WSKBDIO_SETLEDS;
req 519 dev/wscons/wsdisplay_compat_usl.c req = WSKBDIO_GETLEDS;
req 524 dev/wscons/wsdisplay_compat_usl.c req = WSKBDIO_SETMODE;
req 538 dev/wscons/wsdisplay_compat_usl.c req = WSKBDIO_GETMODE;
req 544 dev/wscons/wsdisplay_compat_usl.c res = wsdisplay_internal_ioctl(sc, scr, req, arg, flag, p);
req 100 kern/sys_process.c int req;
req 104 kern/sys_process.c if (SCARG(uap, req) == PT_TRACE_ME)
req 117 kern/sys_process.c switch (SCARG(uap, req)) {
req 231 kern/sys_process.c switch (SCARG(uap, req)) {
req 277 kern/sys_process.c req = PT_READ_I;
req 281 kern/sys_process.c req = PT_READ_D;
req 285 kern/sys_process.c req = PT_WRITE_I;
req 289 kern/sys_process.c req = PT_WRITE_D;
req 295 kern/sys_process.c error = process_domem(p, t, &uio, req);
req 334 kern/sys_process.c error = process_sstep(t, SCARG(uap, req) == PT_STEP);
req 361 kern/sys_process.c error = process_sstep(t, SCARG(uap, req) == PT_STEP);
req 574 kern/sys_process.c process_domem(struct proc *curp, struct proc *p, struct uio *uio, int req)
req 593 kern/sys_process.c (req == PT_WRITE_I) ? UVM_IO_FIXPROT : 0);
req 596 kern/sys_process.c if (error == 0 && req == PT_WRITE_I)
req 64 kern/uipc_usrreq.c uipc_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
req 72 kern/uipc_usrreq.c if (req == PRU_CONTROL)
req 74 kern/uipc_usrreq.c if (req != PRU_SEND && control && control->m_len) {
req 78 kern/uipc_usrreq.c if (unp == NULL && req != PRU_ATTACH) {
req 82 kern/uipc_usrreq.c switch (req) {
req 289 net/if_bridge.c struct ifbreq *req = (struct ifbreq *)data;
req 306 net/if_bridge.c ifs = ifunit(req->ifbr_ifsname);
req 338 net/if_bridge.c strlcpy(ifreq.ifr_name, req->ifbr_ifsname,
req 351 net/if_bridge.c strlcpy(ifreq.ifr_name, req->ifbr_ifsname,
req 399 net/if_bridge.c if (strncmp(p->ifp->if_xname, req->ifbr_ifsname,
req 417 net/if_bridge.c ifs = ifunit(req->ifbr_ifsname);
req 455 net/if_bridge.c if (strncmp(p->ifp->if_xname, req->ifbr_ifsname,
req 468 net/if_bridge.c ifs = ifunit(req->ifbr_ifsname);
req 485 net/if_bridge.c req->ifbr_ifsflags = p->bif_flags;
req 486 net/if_bridge.c req->ifbr_portno = p->ifp->if_index & 0xfff;
req 489 net/if_bridge.c req->ifbr_state = bstp_getstate(bs, bp);
req 490 net/if_bridge.c req->ifbr_priority = bp->bp_priority;
req 491 net/if_bridge.c req->ifbr_path_cost = bp->bp_path_cost;
req 492 net/if_bridge.c req->ifbr_proto = bp->bp_protover;
req 493 net/if_bridge.c req->ifbr_role = bp->bp_role;
req 494 net/if_bridge.c req->ifbr_stpflags = bp->bp_flags;
req 495 net/if_bridge.c req->ifbr_fwd_trans = bp->bp_forward_transitions;
req 496 net/if_bridge.c req->ifbr_desg_bridge = bp->bp_desg_pv.pv_dbridge_id;
req 497 net/if_bridge.c req->ifbr_desg_port = bp->bp_desg_pv.pv_dport_id;
req 498 net/if_bridge.c req->ifbr_root_bridge = bp->bp_desg_pv.pv_root_id;
req 499 net/if_bridge.c req->ifbr_root_cost = bp->bp_desg_pv.pv_cost;
req 500 net/if_bridge.c req->ifbr_root_port = bp->bp_desg_pv.pv_port_id;
req 504 net/if_bridge.c req->ifbr_ifsflags |= IFBIF_BSTP_EDGE;
req 506 net/if_bridge.c req->ifbr_ifsflags |= IFBIF_BSTP_AUTOEDGE;
req 508 net/if_bridge.c req->ifbr_ifsflags |= IFBIF_BSTP_PTP;
req 510 net/if_bridge.c req->ifbr_ifsflags |= IFBIF_BSTP_AUTOPTP;
req 516 net/if_bridge.c ifs = ifunit(req->ifbr_ifsname);
req 533 net/if_bridge.c if (req->ifbr_ifsflags & IFBIF_RO_MASK) {
req 537 net/if_bridge.c if (req->ifbr_ifsflags & IFBIF_STP) {
req 547 net/if_bridge.c bstp_ifsflags(p->bif_stp, req->ifbr_ifsflags);
req 553 net/if_bridge.c p->bif_flags = req->ifbr_ifsflags;
req 562 net/if_bridge.c error = bridge_rtflush(sc, req->ifbr_ifsflags);
req 881 net/if_bridge.c struct ifbrlreq req;
req 910 net/if_bridge.c bzero(&req, sizeof req);
req 911 net/if_bridge.c if (bc->ifbrl_len < sizeof(req))
req 913 net/if_bridge.c strlcpy(req.ifbr_name, sc->sc_if.if_xname, IFNAMSIZ);
req 914 net/if_bridge.c strlcpy(req.ifbr_ifsname, ifl->ifp->if_xname, IFNAMSIZ);
req 915 net/if_bridge.c req.ifbr_action = n->brl_action;
req 916 net/if_bridge.c req.ifbr_flags = n->brl_flags;
req 917 net/if_bridge.c req.ifbr_src = n->brl_src;
req 918 net/if_bridge.c req.ifbr_dst = n->brl_dst;
req 920 net/if_bridge.c req.ifbr_tagname[0] = '\0';
req 922 net/if_bridge.c pf_tag2tagname(n->brl_tag, req.ifbr_tagname);
req 924 net/if_bridge.c error = copyout((caddr_t)&req,
req 925 net/if_bridge.c (caddr_t)(bc->ifbrl_buf + (i * sizeof(req))), sizeof(req));
req 929 net/if_bridge.c bc->ifbrl_len -= sizeof(req);
req 933 net/if_bridge.c bzero(&req, sizeof req);
req 934 net/if_bridge.c if (bc->ifbrl_len < sizeof(req))
req 936 net/if_bridge.c strlcpy(req.ifbr_name, sc->sc_if.if_xname, IFNAMSIZ);
req 937 net/if_bridge.c strlcpy(req.ifbr_ifsname, ifl->ifp->if_xname, IFNAMSIZ);
req 938 net/if_bridge.c req.ifbr_action = n->brl_action;
req 939 net/if_bridge.c req.ifbr_flags = n->brl_flags;
req 940 net/if_bridge.c req.ifbr_src = n->brl_src;
req 941 net/if_bridge.c req.ifbr_dst = n->brl_dst;
req 943 net/if_bridge.c req.ifbr_tagname[0] = '\0';
req 945 net/if_bridge.c pf_tag2tagname(n->brl_tag, req.ifbr_tagname);
req 947 net/if_bridge.c error = copyout((caddr_t)&req,
req 948 net/if_bridge.c (caddr_t)(bc->ifbrl_buf + (i * sizeof(req))), sizeof(req));
req 952 net/if_bridge.c bc->ifbrl_len -= sizeof(req);
req 956 net/if_bridge.c bc->ifbrl_len = i * sizeof(req);
req 2159 net/if_bridge.c bridge_addrule(struct bridge_iflist *bif, struct ifbrlreq *req, int out)
req 2166 net/if_bridge.c bcopy(&req->ifbr_src, &n->brl_src, sizeof(struct ether_addr));
req 2167 net/if_bridge.c bcopy(&req->ifbr_dst, &n->brl_dst, sizeof(struct ether_addr));
req 2168 net/if_bridge.c n->brl_action = req->ifbr_action;
req 2169 net/if_bridge.c n->brl_flags = req->ifbr_flags;
req 2171 net/if_bridge.c if (req->ifbr_tagname[0])
req 2172 net/if_bridge.c n->brl_tag = pf_tagname2tag(req->ifbr_tagname);
req 94 net/pfkey.c static int pfkey_usrreq(struct socket *socket, int req, struct mbuf *mbuf,
req 246 net/pfkey.c pfkey_usrreq(struct socket *socket, int req, struct mbuf *mbuf,
req 257 net/pfkey.c switch (req) {
req 266 net/pfkey.c rval = raw_usrreq(socket, req, mbuf, nam, control);
req 150 net/raw_usrreq.c raw_usrreq(so, req, m, nam, control)
req 152 net/raw_usrreq.c int req;
req 159 net/raw_usrreq.c if (req == PRU_CONTROL)
req 169 net/raw_usrreq.c switch (req) {
req 597 net/route.c rtioctl(u_long req, caddr_t data, struct proc *p)
req 665 net/route.c rtrequest(int req, struct sockaddr *dst, struct sockaddr *gateway,
req 676 net/route.c return (rtrequest1(req, &info, ret_nrt, tableid));
req 725 net/route.c rtrequest1(int req, struct rt_addrinfo *info, struct rtentry **ret_nrt,
req 742 net/route.c switch (req) {
req 863 net/route.c if (req == RTM_RESOLVE) {
req 907 net/route.c ifa->ifa_rtrequest(req, rt, info);
req 106 net/rtsock.c route_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
req 113 net/rtsock.c if (req == PRU_ATTACH) {
req 118 net/rtsock.c if (req == PRU_DETACH && rp) {
req 132 net/rtsock.c if (req == PRU_ATTACH) {
req 138 net/rtsock.c error = raw_usrreq(so, req, m, nam, control);
req 141 net/rtsock.c if (req == PRU_ATTACH && rp) {
req 102 netatalk/ddp_usrreq.c ddp_usrreq( so, req, m, addr, rights )
req 104 netatalk/ddp_usrreq.c int req;
req 114 netatalk/ddp_usrreq.c if ( req == PRU_CONTROL ) {
req 124 netatalk/ddp_usrreq.c if ( ddp == NULL && req != PRU_ATTACH ) {
req 129 netatalk/ddp_usrreq.c switch ( req ) {
req 916 netbt/hci_link.c struct l2cap_req *req;
req 938 netbt/hci_link.c while ((req = TAILQ_FIRST(&link->hl_reqs)) != NULL)
req 939 netbt/hci_link.c l2cap_request_free(req);
req 330 netbt/hci_socket.c hci_usrreq(struct socket *up, int req, struct mbuf *m,
req 338 netbt/hci_socket.c DPRINTFN(2, "%s\n", prurequests[req]);
req 341 netbt/hci_socket.c switch(req) {
req 383 netbt/hci_socket.c switch(req) {
req 510 netbt/hci_socket.c UNKNOWN(req);
req 527 netbt/hci_socket.c hci_ctloutput(int req, struct socket *so, int level,
req 535 netbt/hci_socket.c DPRINTFN(2, "req %s\n", prcorequests[req]);
req 544 netbt/hci_socket.c switch(req) {
req 67 netbt/l2cap_lower.c struct l2cap_req *req, *n;
req 86 netbt/l2cap_lower.c req = TAILQ_FIRST(&chan->lc_link->hl_reqs);
req 87 netbt/l2cap_lower.c while (req != NULL) {
req 88 netbt/l2cap_lower.c n = TAILQ_NEXT(req, lr_next);
req 89 netbt/l2cap_lower.c if (req->lr_chan == chan)
req 90 netbt/l2cap_lower.c l2cap_request_free(req);
req 92 netbt/l2cap_lower.c req = n;
req 114 netbt/l2cap_misc.c struct l2cap_req *req;
req 126 netbt/l2cap_misc.c req = TAILQ_FIRST(&link->hl_reqs);
req 127 netbt/l2cap_misc.c if (req && req->lr_id == next_id)
req 130 netbt/l2cap_misc.c req = pool_get(&l2cap_req_pool, PR_NOWAIT);
req 131 netbt/l2cap_misc.c if (req == NULL)
req 134 netbt/l2cap_misc.c req->lr_id = link->hl_lastid = next_id;
req 136 netbt/l2cap_misc.c req->lr_code = code;
req 137 netbt/l2cap_misc.c req->lr_chan = chan;
req 138 netbt/l2cap_misc.c req->lr_link = link;
req 140 netbt/l2cap_misc.c timeout_set(&req->lr_rtx, l2cap_rtx, req);
req 141 netbt/l2cap_misc.c timeout_add(&req->lr_rtx, l2cap_response_timeout*hz);
req 143 netbt/l2cap_misc.c TAILQ_INSERT_TAIL(&link->hl_reqs, req, lr_next);
req 154 netbt/l2cap_misc.c struct l2cap_req *req;
req 156 netbt/l2cap_misc.c TAILQ_FOREACH(req, &link->hl_reqs, lr_next) {
req 157 netbt/l2cap_misc.c if (req->lr_id == id)
req 158 netbt/l2cap_misc.c return req;
req 168 netbt/l2cap_misc.c l2cap_request_free(struct l2cap_req *req)
req 170 netbt/l2cap_misc.c struct hci_link *link = req->lr_link;
req 172 netbt/l2cap_misc.c timeout_del(&req->lr_rtx);
req 173 netbt/l2cap_misc.c if (timeout_triggered(&req->lr_rtx))
req 176 netbt/l2cap_misc.c TAILQ_REMOVE(&link->hl_reqs, req, lr_next);
req 177 netbt/l2cap_misc.c pool_put(&l2cap_req_pool, req);
req 190 netbt/l2cap_misc.c struct l2cap_req *req = arg;
req 196 netbt/l2cap_misc.c chan = req->lr_chan;
req 197 netbt/l2cap_misc.c l2cap_request_free(req);
req 199 netbt/l2cap_misc.c DPRINTF("cid %d, ident %d\n", (chan ? chan->lc_lcid : 0), req->lr_id);
req 177 netbt/l2cap_signal.c struct l2cap_req *req;
req 190 netbt/l2cap_signal.c req = l2cap_request_lookup(link, cmd.ident);
req 191 netbt/l2cap_signal.c if (req == NULL)
req 199 netbt/l2cap_signal.c timeout_add(&req->lr_rtx, 0);
req 209 netbt/l2cap_signal.c timeout_add(&req->lr_rtx, 0);
req 217 netbt/l2cap_signal.c chan = req->lr_chan;
req 218 netbt/l2cap_signal.c l2cap_request_free(req);
req 349 netbt/l2cap_signal.c struct l2cap_req *req;
req 362 netbt/l2cap_signal.c req = l2cap_request_lookup(link, cmd.ident);
req 363 netbt/l2cap_signal.c if (req == NULL || req->lr_code != L2CAP_CONNECT_REQ)
req 366 netbt/l2cap_signal.c chan = req->lr_chan;
req 371 netbt/l2cap_signal.c l2cap_request_free(req);
req 385 netbt/l2cap_signal.c l2cap_request_free(req);
req 401 netbt/l2cap_signal.c l2cap_request_free(req);
req 583 netbt/l2cap_signal.c struct l2cap_req *req;
req 602 netbt/l2cap_signal.c req = l2cap_request_lookup(link, cmd.ident);
req 603 netbt/l2cap_signal.c if (req == NULL || req->lr_code != L2CAP_CONFIG_REQ)
req 606 netbt/l2cap_signal.c chan = req->lr_chan;
req 610 netbt/l2cap_signal.c l2cap_request_free(req);
req 828 netbt/l2cap_signal.c struct l2cap_req *req;
req 840 netbt/l2cap_signal.c req = l2cap_request_lookup(link, cmd.ident);
req 841 netbt/l2cap_signal.c if (req == NULL || req->lr_code != L2CAP_DISCONNECT_REQ)
req 844 netbt/l2cap_signal.c chan = req->lr_chan;
req 850 netbt/l2cap_signal.c l2cap_request_free(req);
req 106 netbt/l2cap_socket.c l2cap_usrreq(struct socket *up, int req, struct mbuf *m,
req 115 netbt/l2cap_socket.c DPRINTFN(2, "%s\n", prurequests[req]);
req 118 netbt/l2cap_socket.c switch (req) {
req 148 netbt/l2cap_socket.c switch(req) {
req 249 netbt/l2cap_socket.c UNKNOWN(req);
req 267 netbt/l2cap_socket.c l2cap_ctloutput(int req, struct socket *so, int level,
req 275 netbt/l2cap_socket.c DPRINTFN(2, "%s\n", prcorequests[req]);
req 284 netbt/l2cap_socket.c switch(req) {
req 105 netbt/rfcomm_socket.c rfcomm_usrreq(struct socket *up, int req, struct mbuf *m,
req 114 netbt/rfcomm_socket.c DPRINTFN(2, "%s\n", prurequests[req]);
req 117 netbt/rfcomm_socket.c switch (req) {
req 155 netbt/rfcomm_socket.c switch(req) {
req 250 netbt/rfcomm_socket.c UNKNOWN(req);
req 266 netbt/rfcomm_socket.c rfcomm_ctloutput(int req, struct socket *so, int level,
req 274 netbt/rfcomm_socket.c DPRINTFN(2, "%s\n", prcorequests[req]);
req 283 netbt/rfcomm_socket.c switch(req) {
req 98 netbt/sco_socket.c sco_usrreq(struct socket *up, int req, struct mbuf *m,
req 107 netbt/sco_socket.c DPRINTFN(2, "%s\n", prurequests[req]);
req 110 netbt/sco_socket.c switch(req) {
req 137 netbt/sco_socket.c switch(req) {
req 238 netbt/sco_socket.c UNKNOWN(req);
req 253 netbt/sco_socket.c sco_ctloutput(int req, struct socket *so, int level,
req 261 netbt/sco_socket.c DPRINTFN(2, "req %s\n", prcorequests[req]);
req 270 netbt/sco_socket.c switch(req) {
req 79 netinet/if_atm.c atm_rtrequest(req, rt, info)
req 80 netinet/if_atm.c int req;
req 96 netinet/if_atm.c switch (req) {
req 139 netinet/if_ether.c arp_rtrequest(req, rt, info)
req 140 netinet/if_ether.c int req;
req 167 netinet/if_ether.c if (req != RTM_ADD)
req 185 netinet/if_ether.c switch (req) {
req 510 netinet/ip_mroute.c get_sg_cnt(struct sioc_sg_req *req)
req 516 netinet/ip_mroute.c rt = mfc_find(&req->src, &req->grp);
req 519 netinet/ip_mroute.c req->pktcnt = req->bytecnt = req->wrong_if = 0xffffffff;
req 522 netinet/ip_mroute.c req->pktcnt = rt->mfc_pkt_cnt;
req 523 netinet/ip_mroute.c req->bytecnt = rt->mfc_byte_cnt;
req 524 netinet/ip_mroute.c req->wrong_if = rt->mfc_wrong_if;
req 534 netinet/ip_mroute.c get_vif_cnt(struct sioc_vif_req *req)
req 536 netinet/ip_mroute.c vifi_t vifi = req->vifi;
req 541 netinet/ip_mroute.c req->icount = viftable[vifi].v_pkt_in;
req 542 netinet/ip_mroute.c req->ocount = viftable[vifi].v_pkt_out;
req 543 netinet/ip_mroute.c req->ibytes = viftable[vifi].v_bytes_in;
req 544 netinet/ip_mroute.c req->obytes = viftable[vifi].v_bytes_out;
req 2389 netinet/ip_mroute.c compute_bw_meter_flags(struct bw_upcall *req)
req 2393 netinet/ip_mroute.c if (req->bu_flags & BW_UPCALL_UNIT_PACKETS)
req 2395 netinet/ip_mroute.c if (req->bu_flags & BW_UPCALL_UNIT_BYTES)
req 2397 netinet/ip_mroute.c if (req->bu_flags & BW_UPCALL_GEQ)
req 2399 netinet/ip_mroute.c if (req->bu_flags & BW_UPCALL_LEQ)
req 2418 netinet/ip_mroute.c struct bw_upcall *req;
req 2423 netinet/ip_mroute.c req = mtod(m, struct bw_upcall *);
req 2429 netinet/ip_mroute.c if (!(req->bu_flags & (BW_UPCALL_UNIT_PACKETS | BW_UPCALL_UNIT_BYTES)))
req 2431 netinet/ip_mroute.c if (!(req->bu_flags & (BW_UPCALL_GEQ | BW_UPCALL_LEQ)))
req 2433 netinet/ip_mroute.c if ((req->bu_flags & (BW_UPCALL_GEQ | BW_UPCALL_LEQ))
req 2438 netinet/ip_mroute.c if (BW_TIMEVALCMP(&req->bu_threshold.b_time, &delta, <))
req 2441 netinet/ip_mroute.c flags = compute_bw_meter_flags(req);
req 2445 netinet/ip_mroute.c mfc = mfc_find(&req->bu_src, &req->bu_dst);
req 2452 netinet/ip_mroute.c &req->bu_threshold.b_time, ==)) &&
req 2454 netinet/ip_mroute.c req->bu_threshold.b_packets) &&
req 2455 netinet/ip_mroute.c (x->bm_threshold.b_bytes == req->bu_threshold.b_bytes) &&
req 2470 netinet/ip_mroute.c x->bm_threshold.b_time = req->bu_threshold.b_time;
req 2473 netinet/ip_mroute.c x->bm_threshold.b_packets = req->bu_threshold.b_packets;
req 2474 netinet/ip_mroute.c x->bm_threshold.b_bytes = req->bu_threshold.b_bytes;
req 2512 netinet/ip_mroute.c struct bw_upcall *req;
req 2517 netinet/ip_mroute.c req = mtod(m, struct bw_upcall *);
req 2524 netinet/ip_mroute.c mfc = mfc_find(&req->bu_src, &req->bu_dst);
req 2528 netinet/ip_mroute.c } else if (req->bu_flags & BW_UPCALL_DELETE_ALL) {
req 2541 netinet/ip_mroute.c flags = compute_bw_meter_flags(req);
req 2547 netinet/ip_mroute.c &req->bu_threshold.b_time, ==)) &&
req 2549 netinet/ip_mroute.c req->bu_threshold.b_packets) &&
req 2551 netinet/ip_mroute.c req->bu_threshold.b_bytes) &&
req 334 netinet/raw_ip.c rip_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
req 342 netinet/raw_ip.c if (req == PRU_CONTROL)
req 346 netinet/raw_ip.c if (inp == NULL && req != PRU_ATTACH) {
req 351 netinet/raw_ip.c switch (req) {
req 119 netinet/tcp_debug.c int req, int len)
req 165 netinet/tcp_debug.c td->td_req = req;
req 204 netinet/tcp_debug.c printf("%s", prurequests[req&0xff]);
req 205 netinet/tcp_debug.c if ((req & 0xff) == PRU_SLOWTIMO)
req 206 netinet/tcp_debug.c printf("<%s>", tcptimers[req>>8]);
req 129 netinet/tcp_usrreq.c tcp6_usrreq(so, req, m, nam, control, p)
req 131 netinet/tcp_usrreq.c int req;
req 136 netinet/tcp_usrreq.c return tcp_usrreq(so, req, m, nam, control);
req 147 netinet/tcp_usrreq.c tcp_usrreq(so, req, m, nam, control)
req 149 netinet/tcp_usrreq.c int req;
req 159 netinet/tcp_usrreq.c if (req == PRU_CONTROL) {
req 183 netinet/tcp_usrreq.c if (inp == 0 && req != PRU_ATTACH) {
req 189 netinet/tcp_usrreq.c if (m && (req == PRU_SEND || req == PRU_SENDOOB))
req 197 netinet/tcp_usrreq.c tcp_acounts[tp->t_state][req]++;
req 202 netinet/tcp_usrreq.c switch (req) {
req 495 netinet/tcp_usrreq.c tcp_trace(TA_USER, ostate, tp, (caddr_t)0, req, 0);
req 991 netinet/udp_usrreq.c udp6_usrreq(so, req, m, addr, control, p)
req 993 netinet/udp_usrreq.c int req;
req 998 netinet/udp_usrreq.c return udp_usrreq(so, req, m, addr, control);
req 1004 netinet/udp_usrreq.c udp_usrreq(so, req, m, addr, control)
req 1006 netinet/udp_usrreq.c int req;
req 1013 netinet/udp_usrreq.c if (req == PRU_CONTROL) {
req 1023 netinet/udp_usrreq.c if (inp == NULL && req != PRU_ATTACH) {
req 1031 netinet/udp_usrreq.c switch (req) {
req 350 netinet6/ip6_mroute.c get_sg_cnt(req)
req 351 netinet6/ip6_mroute.c struct sioc_sg_req6 *req;
req 358 netinet6/ip6_mroute.c MF6CFIND(req->src.sin6_addr, req->grp.sin6_addr, rt);
req 361 netinet6/ip6_mroute.c req->pktcnt = rt->mf6c_pkt_cnt;
req 362 netinet6/ip6_mroute.c req->bytecnt = rt->mf6c_byte_cnt;
req 363 netinet6/ip6_mroute.c req->wrong_if = rt->mf6c_wrong_if;
req 367 netinet6/ip6_mroute.c req->pktcnt = req->bytecnt = req->wrong_if = 0xffffffff;
req 377 netinet6/ip6_mroute.c get_mif6_cnt(req)
req 378 netinet6/ip6_mroute.c struct sioc_mif_req6 *req;
req 380 netinet6/ip6_mroute.c mifi_t mifi = req->mifi;
req 385 netinet6/ip6_mroute.c req->icount = mif6table[mifi].m6_pkt_in;
req 386 netinet6/ip6_mroute.c req->ocount = mif6table[mifi].m6_pkt_out;
req 387 netinet6/ip6_mroute.c req->ibytes = mif6table[mifi].m6_bytes_in;
req 388 netinet6/ip6_mroute.c req->obytes = mif6table[mifi].m6_bytes_out;
req 988 netinet6/nd6.c nd6_rtrequest(req, rt, info)
req 989 netinet6/nd6.c int req;
req 1014 netinet6/nd6.c if (req == RTM_RESOLVE &&
req 1035 netinet6/nd6.c switch (req) {
req 1124 netinet6/nd6.c if (req == RTM_ADD) {
req 579 netinet6/raw_ip6.c rip6_usrreq(so, req, m, nam, control, p)
req 581 netinet6/raw_ip6.c int req;
req 594 netinet6/raw_ip6.c if (req == PRU_CONTROL)
req 598 netinet6/raw_ip6.c switch (req) {
req 71 netnatm/natm.c int natm_usrreq(so, req, m, nam, control)
req 73 netnatm/natm.c int natm_usrreq(so, req, m, nam, control)
req 76 netnatm/natm.c int req;
req 95 netnatm/natm.c if (npcb == NULL && req != PRU_ATTACH) {
req 101 netnatm/natm.c switch (req) {
req 319 netnatm/natm.c printf("natm: PRU #%d unsupported\n", req);
req 131 sys/syscallargs.h syscallarg(int) req;