//---------------------------------------------------------------------------------------------- static int ata_pass_thru(int fd,struct cam_pass_thru *pcpt) { int icnt; int status; iov_t iov[3]; struct cam_pass_thru cpt; cpt=*pcpt; icnt=1; SETIOV(&iov[0],&cpt,sizeof(cpt)); cpt.cam_timeout=cpt.cam_timeout?cpt.cam_timeout:CAM_TIME_DEFAULT; if(cpt.cam_sense_len) { SETIOV(&iov[1],(void *)cpt.cam_sense_ptr,cpt.cam_sense_len); cpt.cam_sense_ptr=sizeof(cpt); icnt++; } if(cpt.cam_dxfer_len) { SETIOV(&iov[2],(void *)cpt.cam_data_ptr,cpt.cam_dxfer_len); cpt.cam_data_ptr=(paddr_t)sizeof(cpt)+cpt.cam_sense_len; icnt++; } if((status=devctlv(fd,DCMD_CAM_PASS_THRU,icnt,icnt,iov,iov,NULL))) pout("ata_pass_thru devctl: %s\n",strerror(status)); pcpt->cam_status=cpt.cam_status; pcpt->cam_scsi_status=cpt.cam_scsi_status; return(status); }
static int ds3232_i2c_write(unsigned char reg, unsigned char val[], unsigned char num) { iov_t siov[3]; i2c_send_t hdr; hdr.slave.addr = DS3232_I2C_ADDRESS; hdr.slave.fmt = I2C_ADDRFMT_7BIT; hdr.len = num + 1; hdr.stop = 1; SETIOV(&siov[0], &hdr, sizeof(hdr)); SETIOV(&siov[1], ®, sizeof(reg)); SETIOV(&siov[2], val, num); return devctlv(fd, DCMD_I2C_SEND, 3, 0, siov, NULL, NULL); }
static int mc9s08dz60_i2c_write(uint8_t reg, uint8_t *val, int num) { iov_t siov[3]; i2c_send_t hdr; hdr.slave.addr = MC9S08DZ60_I2C_ADDRESS; hdr.slave.fmt = I2C_ADDRFMT_7BIT; hdr.len = num + 1; hdr.stop = 1; SETIOV(&siov[0], &hdr, sizeof(hdr)); SETIOV(&siov[1], ®, 1); SETIOV(&siov[2], val, num); return devctlv(fd, DCMD_I2C_SEND, 3, 0, siov, NULL, NULL); }
static int ds3232_i2c_read(unsigned char reg, unsigned char val[], unsigned char num) { iov_t siov[2], riov[2]; i2c_sendrecv_t hdr; hdr.slave.addr = DS3232_I2C_ADDRESS; hdr.slave.fmt = I2C_ADDRFMT_7BIT; hdr.send_len = 1; hdr.recv_len = num; hdr.stop = 1; SETIOV(&siov[0], &hdr, sizeof(hdr)); SETIOV(&siov[1], ®, sizeof(reg)); SETIOV(&riov[0], &hdr, sizeof(hdr)); SETIOV(&riov[1], val, num); return devctlv(fd, DCMD_I2C_SENDRECV, 2, 2, siov, riov, NULL); }
static int mc9s08dz60_i2c_read(uint8_t reg, uint8_t *val, int num) { iov_t siov[2], riov[2]; i2c_sendrecv_t hdr; hdr.slave.addr = MC9S08DZ60_I2C_ADDRESS; hdr.slave.fmt = I2C_ADDRFMT_7BIT; hdr.send_len = 1; hdr.recv_len = num; hdr.stop = 1; SETIOV(&siov[0], &hdr, sizeof(hdr)); SETIOV(&siov[1], ®, 1); SETIOV(&riov[0], &hdr, sizeof(hdr)); SETIOV(&riov[1], val, num); return devctlv(fd, DCMD_I2C_SENDRECV, 2, 2, siov, riov, NULL); }
/* * TWL4030 function definitions */ static int twl4030_i2c_write (disp_adapter_t *adapter, uint8_t addr, uint8_t reg, uint8_t val) { iov_t siov[3]; i2c_send_t hdr; hdr.slave.addr = addr; hdr.slave.fmt = I2C_ADDRFMT_7BIT; hdr.len = 2; hdr.stop = 1; SETIOV(&siov[0], &hdr, sizeof(hdr)); SETIOV(&siov[1], ®, sizeof(reg)); SETIOV(&siov[2], &val, 1); if (devctlv(fd, DCMD_I2C_SEND, 3, 0, siov, NULL, NULL) != EOK) { disp_printf(adapter, "twl4030_i2c_write fail"); return -1; } return 0; }
static int twl4030_i2c_write(int fd, uint8_t addr, uint8_t reg, uint8_t val) { iov_t siov[3]; i2c_send_t hdr; hdr.slave.addr = addr; hdr.slave.fmt = I2C_ADDRFMT_7BIT; hdr.len = 2; hdr.stop = 1; SETIOV(&siov[0], &hdr, sizeof(hdr)); SETIOV(&siov[1], ®, sizeof(reg)); SETIOV(&siov[2], &val, 1); if (devctlv(fd, DCMD_I2C_SEND, 3, 0, siov, NULL, NULL) != EOK) { slogf(_SLOGC_SIM_MMC, _SLOG_ERROR, "BEAGLE MMCSD: twl4030_i2c_write fail"); return -1; } return 0; }
/*! * @brief Function to invoke the APIs through ioctl. * * @param cmd Command for driver ioctl * @param args Arguments for the ioctl command * * @sa */ Int IpcDrv_ioctl (UInt32 cmd, Ptr args) { Int status = Ipc_S_SUCCESS; int osStatus = -1; GT_2trace (curTrace, GT_ENTER, "IpcDrv_ioctl", cmd, args); GT_assert (curTrace, (IpcDrv_refCount > 0)); switch (cmd) { case CMD_IPC_CONTROL: { osStatus = devctl( IpcDrv_handle, DCMD_IPC_CONTROL, args, sizeof(IpcDrv_CmdArgs), NULL); } break; case CMD_IPC_READCONFIG: { IpcDrv_CmdArgs *cargs = (IpcDrv_CmdArgs *)args; iov_t read_iov[2]; SETIOV( &read_iov[0], cargs, sizeof(IpcDrv_CmdArgs) ); SETIOV( &read_iov[1], cargs->args.readConfig.cfg, cargs->args.readConfig.size ); osStatus = devctlv( IpcDrv_handle, DCMD_IPC_READCONFIG, 2, 2, read_iov, read_iov, NULL); } break; case CMD_IPC_WRITECONFIG: { IpcDrv_CmdArgs *cargs = (IpcDrv_CmdArgs *)args; iov_t write_iov[2]; SETIOV( &write_iov[0], cargs, sizeof(IpcDrv_CmdArgs) ); SETIOV( &write_iov[1], cargs->args.writeConfig.cfg, cargs->args.writeConfig.size ); osStatus = devctlv( IpcDrv_handle, DCMD_IPC_WRITECONFIG, 2, 1, write_iov, write_iov, NULL); } break; default: { /* This does not impact return status of this function, so retVal * comment is not used. */ status = Ipc_E_INVALIDARG; GT_setFailureReason (curTrace, GT_4CLASS, "IpcDrv_ioctl", status, "Driver ioctl failed!"); } break; } if (osStatus != 0) { /*! @retval Ipc_E_OSFAILURE Driver ioctl failed */ status = Ipc_E_OSFAILURE; GT_setFailureReason (curTrace, GT_4CLASS, "IpcDrv_ioctl", status, "Driver ioctl failed!"); } else { /* First field in the structure is the API status. */ status = ((IpcDrv_CmdArgs *) args)->apiStatus; } GT_1trace(curTrace, GT_LEAVE, "IpcDrv_ioctl", status); return (status); }
/*! * @brief Function to invoke the APIs through ioctl. * * @param cmd Command for driver ioctl * @param args Arguments for the ioctl command * * @sa */ Int NotifyDrvUsr_ioctl (UInt32 cmd, Ptr args) { Int status = Notify_S_SUCCESS; int osStatus = -1; GT_2trace (curTrace, GT_ENTER, "NotifyDrvUsr_ioctl", cmd, args); GT_assert (curTrace, (NotifyDrvUsr_refCount > 0)); switch (cmd) { case CMD_NOTIFY_SENDEVENT: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_SENDEVENT, args, sizeof(Notify_CmdArgsSendEvent), NULL); } break; case CMD_NOTIFY_DISABLE: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_DISABLE, args, sizeof(Notify_CmdArgsDisable), NULL); } break; case CMD_NOTIFY_RESTORE: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_RESTORE, args, sizeof(Notify_CmdArgsRestore), NULL); } break; case CMD_NOTIFY_DISABLEEVENT: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_DISABLEEVENT, args, sizeof(Notify_CmdArgsDisableEvent), NULL); } break; case CMD_NOTIFY_ENABLEEVENT: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_ENABLEEVENT, args, sizeof(Notify_CmdArgsEnableEvent), NULL); } break; case CMD_NOTIFY_REGISTEREVENTSINGLE: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_REGISTEREVENTSINGLE, args, sizeof(Notify_CmdArgsRegisterEvent), NULL); } break; case CMD_NOTIFY_REGISTEREVENT: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_REGISTEREVENT, args, sizeof(Notify_CmdArgsRegisterEvent), NULL); } break; case CMD_NOTIFY_UNREGISTEREVENTSINGLE: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_UNREGISTEREVENTSINGLE, args, sizeof(Notify_CmdArgsUnregisterEvent), NULL); } break; case CMD_NOTIFY_UNREGISTEREVENT: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_UNREGISTEREVENT, args, sizeof(Notify_CmdArgsUnregisterEvent), NULL); } break; case CMD_NOTIFY_GETCONFIG: { Notify_CmdArgsGetConfig *cargs = (Notify_CmdArgsGetConfig *)args; iov_t notify_getconfig_iov[2]; SETIOV( ¬ify_getconfig_iov[0], cargs, sizeof(Notify_CmdArgsGetConfig) ); SETIOV( ¬ify_getconfig_iov[1], cargs->cfg, sizeof(Notify_Config) ); /* the osal_drv handle is used instead of ipcdrv_handle as the ipcdrc_handle is not yet initialized */ osStatus = devctlv( OsalDrv_handle, DCMD_NOTIFY_GETCONFIG, 2, 2, notify_getconfig_iov, notify_getconfig_iov, NULL); } break; case CMD_NOTIFY_SETUP: { Notify_CmdArgsSetup *cargs = (Notify_CmdArgsSetup *)args; iov_t notify_setup_iov[2]; SETIOV( ¬ify_setup_iov[0], cargs, sizeof(Notify_CmdArgsSetup) ); SETIOV( ¬ify_setup_iov[1], cargs->cfg, sizeof(Notify_Config) ); osStatus = devctlv( IpcDrv_handle, DCMD_NOTIFY_SETUP, 2, 2, notify_setup_iov, notify_setup_iov, NULL); } break; case CMD_NOTIFY_DESTROY: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_DESTROY, args, sizeof(Notify_CmdArgsDestroy), NULL); } break; case CMD_NOTIFY_ATTACH: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_ATTACH, args, sizeof(Notify_CmdArgsAttach), NULL); } break; case CMD_NOTIFY_DETACH: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_DETACH, args, sizeof(Notify_CmdArgsDetach), NULL); } break; case CMD_NOTIFY_SHAREDMEMREQ: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_SHAREDMEMREQ, args, sizeof(Notify_CmdArgsSharedMemReq), NULL); } break; case CMD_NOTIFY_INTLINEREGISTERED: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_INTLINEREGISTERED, args, sizeof(Notify_CmdArgsIntLineRegistered), NULL); } break; case CMD_NOTIFY_EVENTAVAILABLE: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_EVENTAVAILABLE, args, sizeof(Notify_CmdArgsEventAvailable), NULL); } break; case CMD_NOTIFY_THREADATTACH: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_THREADATTACH, args, sizeof(Notify_CmdArgsThreadAttach), NULL); } break; case CMD_NOTIFY_THREADDETACH: { osStatus = devctl( IpcDrv_handle, DCMD_NOTIFY_THREADDETACH, args, sizeof(Notify_CmdArgsThreadDetach), NULL); } break; default: { /* This does not impact return status of this function, so retVal * comment is not used. */ status = Notify_E_INVALIDARG; GT_setFailureReason (curTrace, GT_4CLASS, "NotifyDrv_ioctl", status, "Unsupported ioctl command specified"); } break; } if (osStatus != 0) { /*! @retval Notify_E_OSFAILURE Driver ioctl failed */ status = Notify_E_OSFAILURE; GT_setFailureReason (curTrace, GT_4CLASS, "NotifyDrvUsr_ioctl", status, "Driver ioctl failed!"); } else { /* First field in the structure is the API status. */ status = ((Notify_CmdArgs *) args)->apiStatus; // TODO: THIS WILL NEED TO BE MODIFIED FOR IOCTL THAT DO NOT USE COMMOM CMD ARGS } GT_1trace(curTrace, GT_LEAVE, "NotifyDrvUsr_ioctl", status); return status; }
/*! * @brief Function to invoke the APIs through ioctl. * * @param cmd Command for driver ioctl * @param args Arguments for the ioctl command * * @sa */ Int SharedRegionDrv_ioctl (UInt32 cmd, Ptr args) { Int status = SharedRegion_S_SUCCESS; int osStatus = -1; SharedRegionDrv_CmdArgs * cargs = (SharedRegionDrv_CmdArgs *) args; SharedRegion_Region * regions = NULL; SharedRegion_Config * config; Memory_MapInfo mapInfo; UInt16 i; GT_2trace (curTrace, GT_ENTER, "SharedRegionDrv_ioctl", cmd, args); /* TODO: SharedRegionDrv_refCount not defined in QNX build * GT_assert (curTrace, (SharedRegionDrv_refCount > 0)); */ switch (cmd) { case CMD_SHAREDREGION_GETCONFIG: { SharedRegionDrv_CmdArgs *cargs = (SharedRegionDrv_CmdArgs *)args; iov_t sharedregion_getconfig_iov[2]; SharedRegion_Config * shreg_config = cargs->args.getConfig.config; SETIOV( &sharedregion_getconfig_iov[0], cargs, sizeof(SharedRegionDrv_CmdArgs) ); SETIOV( &sharedregion_getconfig_iov[1], cargs->args.getConfig.config, sizeof(SharedRegion_Config) ); /* the osal_drv handle is used instead of ipcdrv_handle as the ipcdrc_handle is not yet initialized */ osStatus = devctlv( OsalDrv_handle, DCMD_SHAREDREGION_GETCONFIG, 1, 2, sharedregion_getconfig_iov, sharedregion_getconfig_iov, NULL); if ( osStatus == 0 ){ cargs->args.getConfig.config = shreg_config; } } break; case CMD_SHAREDREGION_SETUP: { SharedRegionDrv_CmdArgs *cargs = (SharedRegionDrv_CmdArgs *)args; iov_t sharedregion_setup_iov[3]; SETIOV( &sharedregion_setup_iov[0], cargs, sizeof(SharedRegionDrv_CmdArgs) ); SETIOV( &sharedregion_setup_iov[1], cargs->args.setup.config, sizeof(SharedRegion_Config) ); SETIOV( &sharedregion_setup_iov[2], cargs->args.setup.regions, cargs->args.setup.config->numEntries * sizeof(SharedRegion_Region) ); osStatus = devctlv( IpcDrv_handle, DCMD_SHAREDREGION_SETUP, 2, 3, sharedregion_setup_iov, sharedregion_setup_iov, NULL); } break; case CMD_SHAREDREGION_GETREGIONINFO: { SharedRegionDrv_CmdArgs *cargs = (SharedRegionDrv_CmdArgs *)args; iov_t sharedregion_getregconfig_iov[2]; /* no of max shared region entries + 1 */ //UInt16 i=0; SharedRegion_Config config; SharedRegion_getConfig (&config); SETIOV( &sharedregion_getregconfig_iov[0], cargs, sizeof(SharedRegionDrv_CmdArgs) ); SETIOV( &sharedregion_getregconfig_iov[1], cargs->args.getRegionInfo.regions, (sizeof(SharedRegion_Region) * config.numEntries)); //for (i = 1; i< cargs->args.getConfig.config->numEntries+1;i++) { // SETIOV( &sharedregion_getregconfig_iov[i], &cargs->args.setup.regions[i-1], sizeof(SharedRegion_Region) ); //} // SETIOV( &sharedregion_getregconfig_iov[1], cargs->args.setup.regions, (sizeof(SharedRegion_Region) * cargs->args.getConfig.config->numEntries)); //osStatus = devctlv( IpcDrv_handle, DCMD_SHAREDREGION_GETREGIONINFO, 1, cargs->args.getConfig.config->numEntries + 1, sharedregion_getregconfig_iov, sharedregion_getregconfig_iov, NULL); osStatus = devctlv( IpcDrv_handle, DCMD_SHAREDREGION_GETREGIONINFO, 2, 2, sharedregion_getregconfig_iov, sharedregion_getregconfig_iov, NULL); } break; case CMD_SHAREDREGION_DESTROY: { osStatus = devctl( IpcDrv_handle, DCMD_SHAREDREGION_DESTROY, cargs, sizeof(SharedRegionDrv_CmdArgs), NULL); } break; case CMD_SHAREDREGION_START: { osStatus = devctl( IpcDrv_handle, DCMD_SHAREDREGION_START, cargs, sizeof(SharedRegionDrv_CmdArgs), NULL); } break; case CMD_SHAREDREGION_STOP: { osStatus = devctl( IpcDrv_handle, DCMD_SHAREDREGION_STOP, cargs, sizeof(SharedRegionDrv_CmdArgs), NULL); } break; case CMD_SHAREDREGION_ATTACH: { osStatus = devctl( IpcDrv_handle, DCMD_SHAREDREGION_ATTACH, cargs, sizeof(SharedRegionDrv_CmdArgs), NULL); } break; case CMD_SHAREDREGION_DETACH: { osStatus = devctl( IpcDrv_handle, DCMD_SHAREDREGION_DETACH, cargs, sizeof(SharedRegionDrv_CmdArgs), NULL); } break; case CMD_SHAREDREGION_SETENTRY: { SharedRegionDrv_CmdArgs *cargs = (SharedRegionDrv_CmdArgs *)args; iov_t sharedregion_getregsetentry_iov[2]; SETIOV( &sharedregion_getregsetentry_iov[0], cargs, sizeof(SharedRegionDrv_CmdArgs) ); SETIOV( &sharedregion_getregsetentry_iov[1], &cargs->args.setEntry.entry, sizeof(SharedRegion_Entry) ); osStatus = devctlv( IpcDrv_handle, DCMD_SHAREDREGION_SETENTRY, 2, 1, sharedregion_getregsetentry_iov, sharedregion_getregsetentry_iov, NULL); } break; case CMD_SHAREDREGION_CLEARENTRY: { osStatus = devctl( IpcDrv_handle, DCMD_SHAREDREGION_CLEARENTRY, cargs, sizeof(SharedRegionDrv_CmdArgs), NULL); } break; case CMD_SHAREDREGION_GETHEAP: { osStatus = devctl( IpcDrv_handle, DCMD_SHAREDREGION_GETHEAP, cargs, sizeof(SharedRegionDrv_CmdArgs), NULL); } break; case CMD_SHAREDREGION_RESERVEMEMORY: { osStatus = devctl( IpcDrv_handle, DCMD_SHAREDREGION_RESERVEMEMORY, cargs, sizeof(SharedRegionDrv_CmdArgs), NULL); } break; case CMD_SHAREDREGION_CLEARRESERVEDMEMORY: { osStatus = devctl( IpcDrv_handle, DCMD_SHAREDREGION_CLEARRESERVEDMEMORY, cargs, sizeof(SharedRegionDrv_CmdArgs), NULL); } break; default: { /* This does not impact return status of this function, so retVal * comment is not used. */ status = SharedRegion_E_INVALIDARG; GT_setFailureReason (curTrace, GT_4CLASS, "SharedRegionDrv_ioctl", status, "Unsupported ioctl command specified"); } break; } if (osStatus != 0) { /*! @retval SharedRegion_E_OSFAILURE Driver ioctl failed */ status = SharedRegion_E_OSFAILURE; GT_setFailureReason (curTrace, GT_4CLASS, "SharedRegionDrv_ioctl", status, "Driver ioctl failed!"); } else { /* First field in the structure is the API status. */ status = ((SharedRegionDrv_CmdArgs *) cargs)->apiStatus; /* Convert the base address to user virtual address */ if (cmd == CMD_SHAREDREGION_SETUP) { config = cargs->args.setup.config; for (i = 0u; ( (i < config->numEntries) && (status >= 0)); i++) { regions = &(cargs->args.setup.regions [i]); if (regions->entry.isValid == TRUE) { mapInfo.src = (UInt32) regions->entry.base; mapInfo.size = regions->entry.len; status = Memory_map (&mapInfo); if (status < 0) { GT_setFailureReason (curTrace, GT_4CLASS, "SharedRegionDrv_ioctl", status, "Memory_map failed!"); } else { regions->entry.base = (Ptr) mapInfo.dst; } } } } else { /* TBD: Need to do Memory_unmap in destroy. */ } } GT_1trace (curTrace, GT_LEAVE, "SharedRegionDrv_ioctl", status); /*! @retval SharedRegion_S_SUCCESS Operation successfully completed. */ return status; }
/*! * @brief Function to invoke the APIs through devctl. * * @param cmd Command for driver ioctl * @param args Arguments for the ioctl command * * @sa */ Int MultiProcDrv_ioctl (UInt32 cmd, Ptr args) { Int status = MultiProc_S_SUCCESS; int osStatus = 0; MultiProcDrv_CmdArgs * cargs = (MultiProcDrv_CmdArgs *) args; GT_2trace (curTrace, GT_ENTER, "MultiProcDrv_ioctl", cmd, args); switch (cmd) { case CMD_MULTIPROC_SETUP: { iov_t setup_iov[2]; SETIOV( &setup_iov[0], cargs, sizeof(MultiProcDrv_CmdArgs) ); SETIOV( &setup_iov[1], cargs->args.setup.config, sizeof(MultiProc_Config) ); osStatus = devctlv( IpcDrv_handle, DCMD_MULTIPROC_SETUP, 2, 2, setup_iov, setup_iov, NULL); if ( osStatus != 0 ){ status = MultiProc_E_OSFAILURE; } } break; case CMD_MULTIPROC_DESTROY: { osStatus = devctl( IpcDrv_handle, DCMD_MULTIPROC_DESTROY, cargs, sizeof(MultiProcDrv_CmdArgs), NULL); if ( osStatus != 0 ){ status = MultiProc_E_OSFAILURE; } } break; case CMD_MULTIPROC_GETCONFIG: { iov_t multiproc_getconfig_iov[2]; MultiProc_Config * save_multiprocconfig = (MultiProc_Config *)cargs->args.getConfig.config; SETIOV( &multiproc_getconfig_iov[0], cargs, sizeof(MultiProcDrv_CmdArgs) ); SETIOV( &multiproc_getconfig_iov[1], cargs->args.getConfig.config, sizeof(MultiProc_Config) ); /* the osal_drv handle is used instead of ipcdrv_handle as the ipcdrc_handle is not yet initialized */ osStatus = devctlv( OsalDrv_handle, DCMD_MULTIPROC_GETCONFIG, 2, 2, multiproc_getconfig_iov, multiproc_getconfig_iov, NULL); if ( osStatus != 0 ){ status = MultiProc_E_OSFAILURE; } else{ cargs->args.getConfig.config= (MultiProc_Config *) (save_multiprocconfig); } } break; case CMD_MULTIPROC_SETLOCALID: osStatus = devctl( IpcDrv_handle, DCMD_MULTIPROC_SETLOCALID, cargs, sizeof(MultiProcDrv_CmdArgs), NULL); if ( osStatus != 0 ){ status = MultiProc_E_OSFAILURE; } break; default: { /* This does not impact return status of this function, so retVal * comment is not used. */ status = MultiProc_E_FAIL; GT_setFailureReason (curTrace, GT_4CLASS, "MultiProcDrv_ioctl", status, "Unsupported ioctl command specified"); } break; } if ( osStatus != 0 ){ status = MultiProc_E_OSFAILURE; } else { /* First field in the structure is the API status. */ status = ((MultiProcDrv_CmdArgs *) cargs)->apiStatus; } GT_1trace (curTrace, GT_LEAVE, "MultiProcDrv_ioctl", status); /*! @retval MultiProc_S_SUCCESS Operation successfully completed. */ return status; }
/*! * @brief Function to invoke the APIs through ioctl. * * @param cmd Command for driver ioctl * @param args Arguments for the ioctl command * * @sa */ Int HeapBufMPDrv_ioctl (UInt32 cmd, Ptr args) { Int status = HeapBufMP_S_SUCCESS; int osStatus = -1; GT_2trace (curTrace, GT_ENTER, "HeapBufMPDrv_ioctl", cmd, args); switch (cmd) { case CMD_HEAPBUFMP_ALLOC: osStatus = devctl(IpcDrv_handle, DCMD_HEAPBUFMP_ALLOC, args, sizeof(HeapBufMPDrv_CmdArgs), NULL); break; case CMD_HEAPBUFMP_FREE: osStatus = devctl( IpcDrv_handle, DCMD_HEAPBUFMP_FREE, args, sizeof(HeapBufMPDrv_CmdArgs), NULL); break; case CMD_HEAPBUFMP_PARAMS_INIT: { HeapBufMPDrv_CmdArgs *cargs = (HeapBufMPDrv_CmdArgs *)args; iov_t hbmpparamsinit_iov[2]; SETIOV( &hbmpparamsinit_iov[0], cargs, sizeof(HeapBufMPDrv_CmdArgs) ); SETIOV( &hbmpparamsinit_iov[1], cargs->args.ParamsInit.params, sizeof(HeapBufMP_Params) ); osStatus = devctlv( IpcDrv_handle, DCMD_HEAPBUFMP_PARAMS_INIT, 1, 2, hbmpparamsinit_iov, hbmpparamsinit_iov, NULL); } break; case CMD_HEAPBUFMP_CREATE: { HeapBufMPDrv_CmdArgs *cargs; iov_t iov[3]; cargs = (HeapBufMPDrv_CmdArgs *)args; SETIOV(&iov[0], cargs, sizeof(HeapBufMPDrv_CmdArgs)); SETIOV(&iov[1], cargs->args.create.params, sizeof(HeapBufMP_Params)); SETIOV(&iov[2], cargs->args.create.params->name, cargs->args.create.nameLen * sizeof(Char)); osStatus = devctlv(IpcDrv_handle, DCMD_HEAPBUFMP_CREATE, 3, 1, iov, iov, NULL); } break; case CMD_HEAPBUFMP_DELETE: { osStatus = devctl(IpcDrv_handle, DCMD_HEAPBUFMP_DELETE, args, sizeof(HeapBufMPDrv_CmdArgs), NULL); } break; case CMD_HEAPBUFMP_OPEN: { HeapBufMPDrv_CmdArgs *cargs = (HeapBufMPDrv_CmdArgs *)args; iov_t hbmpopen_iov[2]; SETIOV( &hbmpopen_iov[0], cargs, sizeof(HeapBufMPDrv_CmdArgs) ); SETIOV( &hbmpopen_iov[1], cargs->args.open.name, sizeof(char) * cargs->args.open.nameLen ); osStatus = devctlv( IpcDrv_handle, DCMD_HEAPBUFMP_OPEN, 2, 1, hbmpopen_iov, hbmpopen_iov, NULL); } break; case CMD_HEAPBUFMP_OPENBYADDR: { osStatus = devctl( IpcDrv_handle, DCMD_HEAPBUFMP_OPENBYADDR, args, sizeof(HeapBufMPDrv_CmdArgs), NULL); } break; case CMD_HEAPBUFMP_CLOSE: { osStatus = devctl( IpcDrv_handle, DCMD_HEAPBUFMP_CLOSE, args, sizeof(HeapBufMPDrv_CmdArgs), NULL); } break; case CMD_HEAPBUFMP_SHAREDMEMREQ: { HeapBufMPDrv_CmdArgs *cargs = (HeapBufMPDrv_CmdArgs *)args; iov_t hbmpshm_iov[2]; SETIOV( &hbmpshm_iov[0], cargs, sizeof(HeapBufMPDrv_CmdArgs) ); SETIOV( &hbmpshm_iov[1], cargs->args.sharedMemReq.params, sizeof(HeapBufMP_Params) ); osStatus = devctlv( IpcDrv_handle, DCMD_HEAPBUFMP_SHAREDMEMREQ, 2, 1, hbmpshm_iov, hbmpshm_iov, NULL); } break; case CMD_HEAPBUFMP_GETCONFIG: { HeapBufMPDrv_CmdArgs *cargs = (HeapBufMPDrv_CmdArgs *)args; iov_t hbmpgconfig_iov[2]; SETIOV( &hbmpgconfig_iov[0], cargs, sizeof(HeapBufMPDrv_CmdArgs) ); SETIOV( &hbmpgconfig_iov[1], cargs->args.getConfig.config, sizeof(HeapBufMP_Config) ); osStatus = devctlv( OsalDrv_handle, DCMD_HEAPBUFMP_GETCONFIG, 1, 2, hbmpgconfig_iov, hbmpgconfig_iov, NULL); } break; case CMD_HEAPBUFMP_SETUP: { HeapBufMPDrv_CmdArgs *cargs = (HeapBufMPDrv_CmdArgs *)args; iov_t hbmpsetup_iov[2]; SETIOV( &hbmpsetup_iov[0], cargs, sizeof(HeapBufMPDrv_CmdArgs) ); SETIOV( &hbmpsetup_iov[1], cargs->args.setup.config, sizeof(HeapBufMP_Config) ); osStatus = devctlv( IpcDrv_handle, DCMD_HEAPBUFMP_SETUP, 2, 1, hbmpsetup_iov, hbmpsetup_iov, NULL); } break; case CMD_HEAPBUFMP_DESTROY: { osStatus = devctl( IpcDrv_handle, DCMD_HEAPBUFMP_DESTROY, args, sizeof(HeapBufMPDrv_CmdArgs), NULL); } break; case CMD_HEAPBUFMP_GETSTATS: { HeapBufMPDrv_CmdArgs *cargs = (HeapBufMPDrv_CmdArgs *)args; iov_t hbmpstats_iov[2]; SETIOV( &hbmpstats_iov[0], cargs, sizeof(HeapBufMPDrv_CmdArgs) ); SETIOV( &hbmpstats_iov[1], cargs->args.getStats.stats, sizeof(Memory_Stats) ); osStatus = devctlv( IpcDrv_handle, DCMD_HEAPBUFMP_GETSTATS, 1, 2, hbmpstats_iov, hbmpstats_iov, NULL); } break; case CMD_HEAPBUFMP_GETEXTENDEDSTATS: { HeapBufMPDrv_CmdArgs *cargs = (HeapBufMPDrv_CmdArgs *)args; iov_t hbmpstats_iov[2]; SETIOV( &hbmpstats_iov[0], cargs, sizeof(HeapBufMPDrv_CmdArgs) ); SETIOV( &hbmpstats_iov[1], cargs->args.getExtendedStats.stats, sizeof(HeapBufMP_ExtendedStats) ); osStatus = devctlv( IpcDrv_handle, DCMD_HEAPBUFMP_GETEXTENDEDSTATS, 1, 2, hbmpstats_iov, hbmpstats_iov, NULL); } break; default : { /* This does not impact return status of this function, so retVal * comment is not used. */ status = HeapBufMP_E_INVALIDARG; GT_setFailureReason (curTrace, GT_4CLASS, "HeapBufMPDrv_ioctl", status, "Unsupported ioctl command specified"); } break; } if (osStatus != 0) { /*! @retval HeapBufMP_E_OSFAILURE Driver ioctl failed */ status = HeapBufMP_E_OSFAILURE; GT_setFailureReason (curTrace, GT_4CLASS, "HeapBufMPDrv_ioctl", status, "Driver ioctl failed!"); } else { /* First field in the structure is the API status. */ status = ((HeapBufMPDrv_CmdArgs *) args)->apiStatus; } GT_1trace (curTrace, GT_LEAVE, "HeapBufMPDrv_ioctl", status); return status; }
/*! * @brief Function to invoke the APIs through ioctl. * * @param cmd Command for driver ioctl * @param args Arguments for the ioctl command * * @sa */ Int ListMPDrv_ioctl (UInt32 cmd, Ptr args) { Int status = ListMP_S_SUCCESS; Int osStatus = -1; GT_2trace (curTrace, GT_ENTER, "ListMPDrv_ioctl", cmd, args); switch (cmd) { case CMD_LISTMP_CREATE: { ListMPDrv_CmdArgs * cargs; iov_t iov[3]; cargs = (ListMPDrv_CmdArgs *)args; SETIOV(&iov[0], cargs, sizeof(ListMPDrv_CmdArgs)); SETIOV(&iov[1], cargs->args.create.params, sizeof(ListMP_Params)); SETIOV(&iov[2], cargs->args.create.params->name, cargs->args.create.nameLen * sizeof(Char)); osStatus = devctlv(IpcDrv_handle, DCMD_LISTMP_CREATE, 3, 1, iov, iov, NULL); } break; case CMD_LISTMP_DELETE: { osStatus = devctl(IpcDrv_handle, DCMD_LISTMP_DELETE, args, sizeof(ListMPDrv_CmdArgs), NULL); } break; case CMD_LISTMP_OPEN: { ListMPDrv_CmdArgs *cargs = (ListMPDrv_CmdArgs *)args; iov_t open_iov[2]; SETIOV( &open_iov[0], cargs, sizeof(ListMPDrv_CmdArgs) ); SETIOV( &open_iov[1], cargs->args.open.name, sizeof(char) * cargs->args.open.nameLen ); osStatus = devctlv( IpcDrv_handle, DCMD_LISTMP_OPEN, 2, 1, open_iov, open_iov, NULL); } break; case CMD_LISTMP_OPENBYADDR: { osStatus = devctl( IpcDrv_handle, DCMD_LISTMP_OPENBYADDR, args, sizeof(ListMPDrv_CmdArgs), NULL); } break; case CMD_LISTMP_CLOSE: { osStatus = devctl( IpcDrv_handle, DCMD_LISTMP_CLOSE, args, sizeof(ListMPDrv_CmdArgs), NULL); } break; case CMD_LISTMP_SHAREDMEMREQ: { ListMPDrv_CmdArgs *cargs = (ListMPDrv_CmdArgs *)args; iov_t shm_iov[2]; SETIOV( &shm_iov[0], cargs, sizeof(ListMPDrv_CmdArgs) ); SETIOV( &shm_iov[1], cargs->args.sharedMemReq.params, sizeof(ListMP_Params) ); osStatus = devctlv( IpcDrv_handle, DCMD_LISTMP_SHAREDMEMREQ, 2, 1, shm_iov, shm_iov, NULL); } break; case CMD_LISTMP_ISEMPTY: { osStatus = devctl( IpcDrv_handle, DCMD_LISTMP_ISEMPTY, args, sizeof(ListMPDrv_CmdArgs), NULL); } break; case CMD_LISTMP_PUTTAIL: { osStatus = devctl( IpcDrv_handle, DCMD_LISTMP_PUTTAIL, args, sizeof(ListMPDrv_CmdArgs), NULL); } break; case CMD_LISTMP_GETHEAD: { osStatus = devctl( IpcDrv_handle, DCMD_LISTMP_GETHEAD, args, sizeof(ListMPDrv_CmdArgs), NULL); } break; case CMD_LISTMP_NEXT: { osStatus = devctl( IpcDrv_handle, DCMD_LISTMP_NEXT, args, sizeof(ListMPDrv_CmdArgs), NULL); } break; case CMD_LISTMP_PREV: { osStatus = devctl( IpcDrv_handle, DCMD_LISTMP_PREV, args, sizeof(ListMPDrv_CmdArgs), NULL); } break; case CMD_LISTMP_INSERT: { osStatus = devctl( IpcDrv_handle, DCMD_LISTMP_INSERT, args, sizeof(ListMPDrv_CmdArgs), NULL); } break; case CMD_LISTMP_REMOVE: { osStatus = devctl( IpcDrv_handle, DCMD_LISTMP_REMOVE, args, sizeof(ListMPDrv_CmdArgs), NULL); } break; case CMD_LISTMP_GETTAIL: { osStatus = devctl( IpcDrv_handle, DCMD_LISTMP_GETTAIL, args, sizeof(ListMPDrv_CmdArgs), NULL); } break; case CMD_LISTMP_PUTHEAD: { osStatus = devctl( IpcDrv_handle, DCMD_LISTMP_PUTHEAD, args, sizeof(ListMPDrv_CmdArgs), NULL); } break; case CMD_LISTMP_GETCONFIG: { ListMPDrv_CmdArgs *cargs = (ListMPDrv_CmdArgs *)args; iov_t config_iov[2]; SETIOV( &config_iov[0], cargs, sizeof(ListMPDrv_CmdArgs) ); SETIOV( &config_iov[1], cargs->args.getConfig.config, sizeof(ListMP_Config) ); /* the osal_drv handle is used instead of ipcdrv_handle as the ipcdrc_handle is not yet initialized */ osStatus = devctlv( OsalDrv_handle, DCMD_LISTMP_GETCONFIG, 2, 2, config_iov, config_iov, NULL); } break; case CMD_LISTMP_SETUP: { ListMPDrv_CmdArgs *cargs = (ListMPDrv_CmdArgs *)args; iov_t setup_iov[2]; SETIOV( &setup_iov[0], cargs, sizeof(ListMPDrv_CmdArgs) ); SETIOV( &setup_iov[1], cargs->args.setup.config, sizeof(ListMP_Config) ); osStatus = devctlv( IpcDrv_handle, DCMD_LISTMP_SETUP, 2, 1, setup_iov, setup_iov, NULL); } break; case CMD_LISTMP_DESTROY: { osStatus = devctl( IpcDrv_handle, DCMD_LISTMP_DESTROY, args, sizeof(ListMPDrv_CmdArgs), NULL); } break; case CMD_LISTMP_PARAMS_INIT: { ListMPDrv_CmdArgs *cargs = (ListMPDrv_CmdArgs *)args; iov_t params_iov[2]; SETIOV( ¶ms_iov[0], cargs, sizeof(ListMPDrv_CmdArgs) ); SETIOV( ¶ms_iov[1], cargs->args.ParamsInit.params, sizeof(ListMP_Params) ); osStatus = devctlv( IpcDrv_handle, DCMD_LISTMP_PARAMS_INIT, 1, 2, params_iov, params_iov, NULL); } break; default: { /* This does not impact return status of this function, so retVal * comment is not used. */ status = ListMP_E_INVALIDARG; GT_setFailureReason (curTrace, GT_4CLASS, "ListMPDrv_ioctl", status, "Unsupported ioctl command specified"); } break; } if (osStatus != 0) { /*! @retval ListMP_E_OSFAILURE Driver ioctl failed */ status = ListMP_E_OSFAILURE; GT_setFailureReason (curTrace, GT_4CLASS, "ListMPDrv_ioctl", status, "Driver ioctl failed!"); } else { /* First field in the structure is the API status. */ status = ((ListMPDrv_CmdArgs *) args)->apiStatus; } GT_1trace (curTrace, GT_LEAVE, "ListMPDrv_ioctl", status); return status; }
/*! * @brief Function to invoke the APIs through ioctl. * * @param cmd Command for driver ioctl * @param args Arguments for the ioctl command * * @sa */ Int MessageQDrv_ioctl (UInt32 cmd, Ptr args) { Int status = MessageQ_S_SUCCESS; int osStatus = -1; GT_2trace (curTrace, GT_ENTER, "MessageQDrv_ioctl", cmd, args); switch (cmd) { case CMD_MESSAGEQ_CREATE: { MessageQDrv_CmdArgs *cargs = (MessageQDrv_CmdArgs *)args; iov_t mqcreate_iov[3]; int i = 0; SETIOV(&mqcreate_iov[i], cargs, sizeof(MessageQDrv_CmdArgs)); i++; if (cargs->args.create.params) { SETIOV(&mqcreate_iov[i], cargs->args.create.params, sizeof(MessageQ_Params) ); i++; } if (cargs->args.create.name) { SETIOV(&mqcreate_iov[i], cargs->args.create.name, sizeof(char) * cargs->args.create.nameLen ); i++; } // send i iov, return 1 iov osStatus = devctlv(IpcDrv_handle, DCMD_MESSAGEQ_CREATE, i, 1, mqcreate_iov, mqcreate_iov, NULL); } break; case CMD_MESSAGEQ_DELETE: { osStatus = devctl(IpcDrv_handle, DCMD_MESSAGEQ_DELETE, args, sizeof(MessageQDrv_CmdArgs), NULL); } break; case CMD_MESSAGEQ_GETCONFIG: { MessageQDrv_CmdArgs *cargs = (MessageQDrv_CmdArgs *)args; iov_t mqgetconfig_iov[2]; SETIOV(&mqgetconfig_iov[0], cargs, sizeof(MessageQDrv_CmdArgs)); SETIOV(&mqgetconfig_iov[1], cargs->args.getConfig.config, sizeof(MessageQ_Config)); osStatus = devctlv(IpcDrv_handle, DCMD_MESSAGEQ_GETCONFIG, 1, 2, mqgetconfig_iov, mqgetconfig_iov, NULL); } break; case CMD_MESSAGEQ_SETUP: { MessageQDrv_CmdArgs *cargs = (MessageQDrv_CmdArgs *)args; iov_t mqsetup_iov[2]; SETIOV(&mqsetup_iov[0], cargs, sizeof(MessageQDrv_CmdArgs)); SETIOV(&mqsetup_iov[1], cargs->args.setup.config, sizeof(MessageQ_Config) ); // send 2 iov, get back 1 iov osStatus = devctlv(IpcDrv_handle, DCMD_MESSAGEQ_SETUP, 2, 1, mqsetup_iov, mqsetup_iov, NULL); } break; case CMD_MESSAGEQ_DESTROY: { osStatus = devctl(IpcDrv_handle, DCMD_MESSAGEQ_DESTROY, args, sizeof(MessageQDrv_CmdArgs), NULL); } break; default: { /* This does not impact return status of this function, so retVal * comment is not used. */ status = MessageQ_E_INVALIDARG; GT_setFailureReason (curTrace, GT_4CLASS, "MessageQDrv_ioctl", status, "Unsupported ioctl command specified"); } break; } if (osStatus != 0) { /*! @retval MessageQ_E_OSFAILURE Driver ioctl failed */ status = MessageQ_E_OSFAILURE; GT_setFailureReason (curTrace, GT_4CLASS, "MessageQDrv_ioctl", status, "Driver ioctl failed!"); } else { /* First field in the structure is the API status. */ status = ((MessageQDrv_CmdArgs *) args)->apiStatus; } GT_1trace (curTrace, GT_LEAVE, "MessageQDrv_ioctl", status); return status; }