static int ftinit(Serialport *p) { Serial *ser; uint timerval; int res; ser = p->s; if(p->isjtag){ res = ftdiwrite(p, FTSETFLOWCTRL, 0, FTDISABLEFLOWCTRL); if(res < 0) return -1; res = ftdiread(p, FTSETLATENCYTIMER, 0, (uchar *)&timerval, FTLATENCYTIMERSZ); if(res < 0) return -1; dsprint(2, "serial: jtag latency timer is %d\n", timerval); timerval = 2; ftdiwrite(p, FTLATENCYDEFAULT, 0, FTSETLATENCYTIMER); res = ftdiread(p, FTSETLATENCYTIMER, 0, (uchar *)&timerval, FTLATENCYTIMERSZ); if(res < 0) return -1; dsprint(2, "serial: jtag latency timer set to %d\n", timerval); /* may be unnecessary */ devctl(p->epin, "timeout 5000"); devctl(p->epout, "timeout 5000"); /* 0xb is the mask for lines. plug dependant? */ ftdiwrite(p, BMMPSSE|0x0b, 0, FTSETBITMODE); } incref(ser->dev); threadcreate(statusreader, p, 8*1024); return 0; }
static int plseteps(Serialport *p) { devctl(p->epin, "maxpkt 256"); devctl(p->epout, "maxpkt 256"); return 0; }
static pid_t do_attach (pid_t pid) { procfs_status status; struct sigevent event; if (nto_inferior.ctl_fd != -1) { close (nto_inferior.ctl_fd); init_nto_inferior (&nto_inferior); } xsnprintf (nto_inferior.nto_procfs_path, PATH_MAX - 1, "/proc/%d/as", pid); nto_inferior.ctl_fd = open (nto_inferior.nto_procfs_path, O_RDWR); if (nto_inferior.ctl_fd == -1) { TRACE ("Failed to open %s\n", nto_inferior.nto_procfs_path); init_nto_inferior (&nto_inferior); return -1; } if (devctl (nto_inferior.ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK) { do_detach (); return -1; } nto_inferior.pid = pid; /* Define a sigevent for process stopped notification. */ event.sigev_notify = SIGEV_SIGNAL_THREAD; event.sigev_signo = SIGUSR1; event.sigev_code = 0; event.sigev_value.sival_ptr = NULL; event.sigev_priority = -1; devctl (nto_inferior.ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0); if (devctl (nto_inferior.ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK && (status.flags & _DEBUG_FLAG_STOPPED)) { ptid_t ptid; struct process_info *proc; kill (pid, SIGCONT); ptid = ptid_build (status.pid, status.tid, 0); the_low_target.arch_setup (); proc = add_process (status.pid, 1); proc->tdesc = nto_tdesc; TRACE ("Adding thread: pid=%d tid=%ld\n", status.pid, ptid_get_lwp (ptid)); nto_find_new_threads (&nto_inferior); } else { do_detach (); return -1; } return pid; }
static void portreset(Hub *h, int p) { int sts; Dev *d, *nd; Port *pp; d = h->dev; pp = &h->port[p]; nd = pp->dev; dprint(2, "%s: %s: port %d: resetting\n", argv0, d->dir, p); if(hubfeature(h, p, Fportreset, 1) < 0){ dprint(2, "%s: %s: port %d: reset: %r\n", argv0, d->dir, p); goto Fail; } sleep(Resetdelay); sts = portstatus(h, p); if(sts < 0) goto Fail; if((sts & PSenable) == 0){ dprint(2, "%s: %s: port %d: not enabled?\n", argv0, d->dir, p); hubfeature(h, p, Fportenable, 1); sts = portstatus(h, p); if((sts & PSenable) == 0) goto Fail; } nd = pp->dev; opendevdata(nd, ORDWR); if(usbcmd(nd, Rh2d|Rstd|Rdev, Rsetaddress, nd->id, 0, nil, 0) < 0){ dprint(2, "%s: %s: port %d: setaddress: %r\n", argv0, d->dir, p); goto Fail; } if(devctl(nd, "address") < 0){ dprint(2, "%s: %s: port %d: set address: %r\n", argv0, d->dir, p); goto Fail; } if(usbcmd(nd, Rh2d|Rstd|Rdev, Rsetconf, 1, 0, nil, 0) < 0){ dprint(2, "%s: %s: port %d: setconf: %r\n", argv0, d->dir, p); unstall(nd, nd, Eout); if(usbcmd(nd, Rh2d|Rstd|Rdev, Rsetconf, 1, 0, nil, 0) < 0) goto Fail; } if(nd->dfd >= 0) close(nd->dfd); return; Fail: pp->state = Pdisabled; pp->sts = 0; if(pp->hub != nil) pp->hub = nil; /* hub closed by enumhub */ hubfeature(h, p, Fportenable, 0); if(nd != nil) devctl(nd, "detach"); closedev(nd); }
static void writeinfo(Dev *d) { char buf[128]; char *s; char *se; Usbdev *ud; Conf *c; Iface *ifc; int i, j; ud = d->usb; s = buf; se = buf+sizeof(buf); s = seprint(s, se, "info %s csp %#08ux", classname(ud->class), ud->csp); for(i = 0; i < ud->nconf; i++){ c = ud->conf[i]; if(c == nil) break; for(j = 0; j < nelem(c->iface); j++){ ifc = c->iface[j]; if(ifc == nil) break; if(ifc->csp != ud->csp) s = seprint(s, se, " csp %#08ulx", ifc->csp); } } s = seprint(s, se, " vid %06#x did %06#x", ud->vid, ud->did); seprint(s, se, " %q %q", ud->vendor, ud->product); devctl(d, "%s", buf); }
static int twl4030_i2c_read(int fd, uint8_t addr, uint8_t reg, uint8_t * val) { struct send_recv { i2c_sendrecv_t hdr; uint8_t buf[2]; } twl4030_rd_data; /*Read the Registers Current Value */ twl4030_rd_data.buf[0] = reg; twl4030_rd_data.hdr.send_len = 1; twl4030_rd_data.hdr.recv_len = 1; twl4030_rd_data.hdr.slave.addr = addr; twl4030_rd_data.hdr.slave.fmt = I2C_ADDRFMT_7BIT; twl4030_rd_data.hdr.stop = 1; if (devctl(fd, DCMD_I2C_SENDRECV, &twl4030_rd_data, sizeof(twl4030_rd_data), NULL)) { slogf(_SLOGC_SIM_MMC, _SLOG_ERROR, "BEAGLE MMCSD: twl4030_i2c_read fail"); return -1; } *val = twl4030_rd_data.buf[0]; return 0; }
void PMAPI PM_saveConsoleState(void *stateBuf,int console_id) { #ifdef __QNXNTO__ int fd; int flags; if ((fd = open("/dev/con1", O_RDWR)) == -1) return; flags = _CONCTL_INVISIBLE_CHG | _CONCTL_INVISIBLE; devctl(fd, DCMD_CHR_SERCTL, &flags, sizeof flags, 0); close(fd); #else uchar *buf = &((uchar*)stateBuf)[PM_getVGAStateSize()]; /* Save QNX 4 console state */ console_read(cc, -1, 0, NULL, 0, (int *)buf+1, (int *)buf+2, NULL); *(int *)buf = console_ctrl(cc, -1, CONSOLE_NORESIZE | CONSOLE_NOSWITCH | CONSOLE_INVISIBLE, CONSOLE_NORESIZE | CONSOLE_NOSWITCH | CONSOLE_INVISIBLE); /* Save state of VGA registers */ PM_saveVGAState(stateBuf); #endif }
static void* shared_memory_open(const IPC_str *name, int size) { DEBUG_PRINT("%s( %s, 0x%x )\n", __FUNCTION__, name, size); int fd = ipc_driver_handle(); if(fd < 0) { DEBUG_PRINT("%s(): IPC driver was not opened\n", __FUNCTION__); return NULL; } struct ipc_create_t ipc_create_param; memset(&ipc_create_param,0,sizeof(ipc_create_param)); ipc_create_param.handle = NULL; ipc_create_param.value = size; snprintf(ipc_create_param.name, sizeof(ipc_create_param.name), "%s", name); int res = devctl(fd,IOCTL_IPC_SHM_OPEN,&ipc_create_param, sizeof(ipc_create_param), NULL); if(res < 0) { DEBUG_PRINT("%s(): Error register shared memory", __FUNCTION__ ); return NULL; } return ipc_create_param.handle; }
static int nto_stopped_by_watchpoint (void) { int ret = 0; TRACE ("%s\n", __func__); if (nto_inferior.ctl_fd != -1 && current_inferior != NULL) { ptid_t ptid; ptid = thread_to_gdb_id (current_inferior); if (nto_set_thread (ptid)) { const int watchmask = _DEBUG_FLAG_TRACE_RD | _DEBUG_FLAG_TRACE_WR | _DEBUG_FLAG_TRACE_MODIFY; procfs_status status; int err; err = devctl (nto_inferior.ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0); if (err == EOK && (status.flags & watchmask)) ret = 1; } } TRACE ("%s: %s\n", __func__, ret ? "yes" : "no"); return ret; }
/*! * @brief Function to map a memory region specific to the driver. * * @sa OsalDrv_close,OsalDrv_open */ UInt32 OsalDrv_map (UInt32 addr, UInt32 size, Bool isCached) { UInt32 userAddr = (UInt32) NULL; OsalMemMap_CmdArgs args; GT_0trace (curTrace, GT_ENTER, "OsalDrv_map"); if (OsalDrv_refCount == 1) { args.len = size; args.paddr = (off_t)addr; args.isCached = isCached; devctl(OsalDrv_handle, DCMD_OSALMEM_MMAP, &args, sizeof(args), NULL); userAddr = (UInt32)(args.vaddr); #if !defined(SYSLINK_BUILD_OPTIMIZE) if (userAddr == (UInt32) MAP_FAILED) { userAddr = (UInt32)NULL; GT_setFailureReason (curTrace, GT_4CLASS, "OsalDrv_map", OSALDRV_E_MAP, "Failed to map memory to user space!"); } #endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */ } GT_1trace (curTrace, GT_LEAVE, "OsalDrv_map", userAddr); /*! @retval NULL Operation was successful. */ /*! @retval valid-address Operation successfully completed. */ return userAddr; }
/*! * @brief Function to invoke the APIs through ioctl. * * @param cmd Command for driver ioctl * @param args Arguments for the ioctl command * * @sa */ Int OsalDrv_ioctl (UInt32 cmd, Ptr args) { Int status = OSALDRV_SUCCESS; int osStatus = 0; TraceDrv_CmdArgs * cmdArgs = (TraceDrv_CmdArgs *) args; GT_2trace (curTrace, GT_ENTER, "OsalDrv_ioctl", cmd, args); GT_assert (curTrace, (OsalDrv_refCount > 0)); // osStatus = ioctl (OsalDrv_handle, cmd, args); osStatus = devctl( OsalDrv_handle, DCMD_TRACEDRV_SETTRACE, cmdArgs, sizeof(TraceDrv_CmdArgs), NULL); if (osStatus < 0) { /*! @retval OSALDRV_E_OSFAILURE Driver ioctl failed */ status = OSALDRV_E_OSFAILURE; GT_setFailureReason (curTrace, GT_4CLASS, "OsalDrv_ioctl", status, "Driver ioctl failed!"); } else { /* First field in the structure is the API status. */ status = ((TraceDrv_CmdArgs *) args)->apiStatus; } GT_1trace (curTrace, GT_LEAVE, "OsalDrv_ioctl", status); /*! @retval OSALDRV_SUCCESS Operation successfully completed. */ return status; }
static void portdetach(Hub *h, int p) { Dev *d; Port *pp; extern void usbfsgone(char*); d = h->dev; pp = &h->port[p]; /* * Clear present, so that we detect an attach on reconnects. */ pp->sts &= ~(PSpresent|PSenable); if(pp->state == Pdisabled) return; pp->state = Pdisabled; dprint(2, "%s: %s: port %d: detached\n", argv0, d->dir, p); if(pp->hub != nil){ closehub(pp->hub); pp->hub = nil; } if(pp->devmaskp != nil) putdevnb(pp->devmaskp, pp->devnb); pp->devmaskp = nil; if(pp->dev != nil){ devctl(pp->dev, "detach"); usbfsgone(pp->dev->dir); closedev(pp->dev); pp->dev = nil; } }
static void nto_store_registers (struct regcache *regcache, int regno) { procfs_greg greg; int err; ptid_t ptid; TRACE ("%s (regno:%d)\n", __func__, regno); if (current_inferior == NULL) { TRACE ("current_inferior is NULL\n"); return; } ptid = thread_to_gdb_id (current_inferior); if (!nto_set_thread (ptid)) return; memset (&greg, 0, sizeof (greg)); for (regno = 0; regno != the_low_target.num_regs; ++regno) { const unsigned int regoffset = the_low_target.register_offset (regno); collect_register (regcache, regno, ((char *)&greg) + regoffset); } err = devctl (nto_inferior.ctl_fd, DCMD_PROC_SETGREG, &greg, sizeof (greg), 0); if (err != EOK) TRACE ("Error: setting registers.\n"); }
int main(void) { int data, fd, toggle = 1; /* Open the device we wish to manipulate. */ if((fd = open ("/dev/kbd", O_RDONLY)) == -1) { fprintf(stderr, "Error with open() on /dev/kbd. Make sure exists.\n"); perror (NULL); exit(EXIT_FAILURE); } while(1) { switch(toggle) { case 1: { /* Lets now turn on Num Lock and make sure that Caps and Scroll lock are turned off. */ data = (_CONCTL_NUM_CHG | _CONCTL_NUM) | _CONCTL_CAPS_CHG | _CONCTL_SCROLL_CHG; break; } case 2: { /* Turn off Num Lock and now turn on Caps Lock (Scroll lock is already off). */ data = _CONCTL_NUM_CHG | (_CONCTL_CAPS_CHG | _CONCTL_CAPS); break; } case 3: { /* Turn off Caps lock and turn on Scroll lock (Num lock is already off). */ data = _CONCTL_CAPS_CHG | (_CONCTL_SCROLL_CHG | _CONCTL_SCROLL); toggle = 0; break; } } /* Explanation below. */ if (devctl (fd, DCMD_CHR_SERCTL, &data, sizeof(data), NULL)) { fprintf(stderr, "Error setting KBD.\n"); perror (NULL); exit(EXIT_FAILURE); } sleep(1); toggle++; } return (1); }
static void etherfree(Ether *e) { int i; Buf *bp; if(e->free != nil) e->free(e); closedev(e->epin); closedev(e->epout); if(e->rc == nil){ /* not really started */ free(e); return; } for(i = 0; i < e->nconns; i++) if(e->conns[i] != nil){ while((bp = nbrecvp(e->conns[i]->rc)) != nil) free(bp); chanfree(e->conns[i]->rc); free(e->conns[i]); } shutdownchan(e->bc); shutdownchan(e->rc); shutdownchan(e->wc); e->epin = e->epout = nil; devctl(e->dev, "detach"); free(e); }
static int ftseteps(Serialport *p) { char *s; Serial *ser; ser = p->s; s = smprint("maxpkt %d", ser->maxrtrans); devctl(p->epin, s); free(s); s = smprint("maxpkt %d", ser->maxwtrans); devctl(p->epout, s); free(s); return 0; }
static void nto_request_interrupt (void) { TRACE ("%s\n", __func__); nto_set_thread (ptid_build (nto_inferior.pid, 1, 0)); if (EOK != devctl (nto_inferior.ctl_fd, DCMD_PROC_STOP, NULL, 0, 0)) TRACE ("Error stopping inferior.\n"); }
/*! * Алгоритм работы: * 1. Получение дескриптора файла жесткого диска * 2. Получение серийного номера при помощи @c devctl и его запись в @p serial * 3. Если интерфейс найден - копирование MAC-адреса в @p mac */ int pll_get_hdserial(char* serial, size_t serial_len, const char* hd_name) { int file = open(hd_name, O_RDONLY); if (!file) return -1; int err = devctl(file, DCMD_CAM_DEV_SERIAL_NUMBER, serial, serial_len, NULL); if (err != EOK) return -1; return 0; }
static int seteps(Serialport *p) { if(devctl(p->epin, "timeout 0") < 0){ fprint(2, "can't set timeout on %s: %r\n", p->epin->dir); return -1; } return 0; }
FridaHostProcessInfo * frida_system_enumerate_processes (int * result_length) { GArray * processes; FridaImageData no_icon; GDir * proc_dir; const gchar * proc_name; static struct { procfs_debuginfo info; char buff [PATH_MAX]; } procfs_name; processes = g_array_new (FALSE, FALSE, sizeof (FridaHostProcessInfo)); frida_image_data_init (&no_icon, 0, 0, 0, ""); proc_dir = g_dir_open ("/proc", 0, NULL); g_assert (proc_dir != NULL); while ((proc_name = g_dir_read_name (proc_dir)) != NULL) { guint pid; gchar * tmp = NULL, * name; gint fd; FridaHostProcessInfo * process_info; pid = strtoul (proc_name, &tmp, 10); if (*tmp != '\0') continue; tmp = g_build_filename ("/proc", proc_name, "as", NULL); fd = open(tmp, O_RDONLY); g_free (tmp); g_assert (fd != -1); g_assert (devctl (fd, DCMD_PROC_MAPDEBUG_BASE, &procfs_name, sizeof (procfs_name), 0) == EOK); name = g_path_get_basename (procfs_name.info.path); g_array_set_size (processes, processes->len + 1); process_info = &g_array_index (processes, FridaHostProcessInfo, processes->len - 1); frida_host_process_info_init (process_info, pid, name, &no_icon, &no_icon); g_free (name); } g_dir_close (proc_dir); frida_image_data_destroy (&no_icon); *result_length = processes->len; return (FridaHostProcessInfo *) g_array_free (processes, FALSE); }
static int openeps(Ether *e, int epin, int epout) { e->epin = openep(e->dev, epin); if(e->epin == nil){ fprint(2, "ether: in: openep %d: %r\n", epin); return -1; } if(epout == epin){ incref(e->epin); e->epout = e->epin; }else e->epout = openep(e->dev, epout); if(e->epout == nil){ fprint(2, "ether: out: openep %d: %r\n", epout); closedev(e->epin); return -1; } if(e->epin == e->epout) opendevdata(e->epin, ORDWR); else{ opendevdata(e->epin, OREAD); opendevdata(e->epout, OWRITE); } if(e->epin->dfd < 0 || e->epout->dfd < 0){ fprint(2, "ether: open i/o ep data: %r\n"); closedev(e->epin); closedev(e->epout); return -1; } dprint(2, "ether: ep in %s maxpkt %d; ep out %s maxpkt %d\n", e->epin->dir, e->epin->maxpkt, e->epout->dir, e->epout->maxpkt); /* time outs are not activated for I/O endpoints */ if(usbdebug > 2 || etherdebug > 2){ devctl(e->epin, "debug 1"); devctl(e->epout, "debug 1"); devctl(e->dev, "debug 1"); } return 0; }
int read_boardid(int address, BDIDENT *bdident, int showerr) { AM335X_BOARDID bdid; int r; sprintf(bdid.devname, BOARDID_I2C_DEVICE); bdid.fd = open(bdid.devname, O_RDWR); if (bdid.fd == -1) { printf("Unable to open %s (errno=%d)\n", bdid.devname, errno); return -1; } r=devctl(bdid.fd, DCMD_I2C_LOCK, NULL, 0, NULL); if (r) { printf("Unable to lock %s (errno=%d)\n", bdid.devname, errno); close(bdid.fd); return -1; } bdid.i2c_address = address; r = bdid_read(&bdid, bdident, showerr); if (r<0) { if (showerr) printf("Unable to read %s (errno=%d)\n", bdid.devname, errno); close(bdid.fd); return -1; } r=devctl(bdid.fd, DCMD_I2C_UNLOCK, NULL, 0, NULL); if (r) { printf("Unable to unlock %s (errno=%d)\n", bdid.devname, errno); close(bdid.fd); return -1; } close(bdid.fd); return 0; }
static void etherexiting(Ether *e) { devctl(e->dev, "detach"); e->exiting = 1; close(e->epin->dfd); e->epin->dfd = -1; close(e->epout->dfd); e->epout->dfd = -1; nbsend(e->wc, nil); }
/* Resume play */ static int SDL_SYS_CDResume(SDL_CD *cdrom) { if (devctl(cdrom->id, DCMD_CAM_CDROMRESUME, NULL, 0, NULL)!=0) { return -1; } else { return 0; } }
/* Pause play */ static int SDL_SYS_CDPause(SDL_CD *cdrom) { if (devctl(cdrom->id, DCMD_CAM_CDROMPAUSE, NULL, 0, NULL)!=0) { return -1; } else { return 0; } }
/* Stop play */ static int SDL_SYS_CDStop(SDL_CD *cdrom) { if (devctl(cdrom->id, DCMD_CAM_CDROMSTOP, NULL, 0, NULL)!=0) { return -1; } else { return 0; } }
/* Eject the CD-ROM */ static int SDL_SYS_CDEject(SDL_CD *cdrom) { if (devctl(cdrom->id, DCMD_CAM_EJECT_MEDIA, NULL, 0, NULL)!=0) { return -1; } else { return 0; } }
static int nto_breakpoint (CORE_ADDR addr, int type, int size) { procfs_break brk; brk.type = type; brk.addr = addr; brk.size = size; if (devctl (nto_inferior.ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0) != EOK) return 1; return 0; }
int RTCFUNC(get,net)(struct tm *tm, int cent_reg) { uint64_t nsecs; int secs, retval, scratch; union { struct syspage_entry ent; char padding[8192]; } sp, tmpsp; do { devctl(fd, DCMD_PROC_SYSINFO, &tmpsp, sizeof tmpsp, &scratch); retval = devctl(fd, DCMD_PROC_SYSINFO, &sp, sizeof sp, &scratch); } while(retval == EOK && (_SYSPAGE_ENTRY(&sp.ent, qtime)->nsec - _SYSPAGE_ENTRY(&tmpsp.ent, qtime)->nsec > 1e+9) ); if(retval != EOK) return -1; nsecs = _SYSPAGE_ENTRY(&sp.ent, qtime)->nsec + _SYSPAGE_ENTRY(&sp.ent, qtime)->nsec_tod_adjust ; secs = nsecs / 1e+9; *tm = *gmtime((time_t *)&secs); return 0; }
static void nto_find_new_threads (struct nto_inferior *nto_inferior) { pthread_t tid; TRACE ("%s pid:%d\n", __func__, nto_inferior->pid); if (nto_inferior->ctl_fd == -1) return; for (tid = 1;; ++tid) { procfs_status status; ptid_t ptid; int err; status.tid = tid; err = devctl (nto_inferior->ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0); if (err != EOK || status.tid == 0) break; /* All threads in between are gone. */ while (tid != status.tid || status.state == STATE_DEAD) { struct thread_info *ti; ptid = ptid_build (nto_inferior->pid, tid, 0); ti = find_thread_ptid (ptid); if (ti != NULL) { TRACE ("Removing thread %d\n", tid); remove_thread (ti); } if (tid == status.tid) break; ++tid; } if (status.state != STATE_DEAD) { TRACE ("Adding thread %d\n", tid); ptid = ptid_build (nto_inferior->pid, tid, 0); if (!find_thread_ptid (ptid)) add_thread (ptid, NULL); } } }