static void
skip_limbo(void)
#line 1481 "ctangle.w"
{
char c;
while(1){
if(loc> limit&&get_line()==0)return;
*(limit+1)= '@';
while(*loc!='@')loc++;
if(loc++<=limit){
c= *loc++;
if(ccode[(eight_bits)c]==new_section)break;
switch(ccode[(eight_bits)c]){
case translit_code:/*93:*/
#line 1507 "ctangle.w"
while(xisspace(*loc)&&loc<limit)loc++;
loc+= 3;
if(loc> limit||!xisxdigit(*(loc-3))||!xisxdigit(*(loc-2))
||(*(loc-3)>='0'&&*(loc-3)<='7')||!xisspace(*(loc-1)))
err_print("! Improper hex number following @l");
else{
unsigned i;
char*beg;
sscanf(loc-3,"%x",&i);
while(xisspace(*loc)&&loc<limit)loc++;
beg= loc;
while(loc<limit&&(xisalpha(*loc)||xisdigit(*loc)||*loc=='_'))loc++;
if(loc-beg>=translit_length)
err_print("! Replacement string in @l too long");
else{
strncpy(translit[i-0200],beg,loc-beg);
translit[i-0200][loc-beg]= '\0';
}
}
/*:93*/
#line 1491 "ctangle.w"
;break;
case format_code:case'@':break;
case control_text:if(c=='q'||c=='Q'){
while((c= skip_ahead())=='@');
if(*(loc-1)!='>')
err_print("! Double @ should be used in control text");
break;
}
default:err_print("! Double @ should be used in limbo");
}
}
}
}
int vtq_imageconv_init(struct vtq_imageconv_state **vtq_imageconv_out,
struct vtq_vce *vtq_vce,
struct module *module,
struct device *device,
struct proc_dir_entry *proc_vcedir)
{
struct vtq_imageconv_state *out;
int s;
(void) proc_vcedir;
out = kmalloc(sizeof(*out), GFP_KERNEL);
if (out == NULL) {
err_print("kmalloc failure\n");
goto err_kmalloc_vtq_imageconv_state;
}
out->vtq = vtq_create_context(vtq_vce);
if (out->vtq == NULL) {
err_print("failed to create VTQ context\n");
goto err_vtq_create_context;
}
/* Mark that we haven't received the blob (via
* request_firmware) yet */
out->image = NULL;
out->want_image_via_vtqinit = 0;
atomic_set(&out->task_get_count, 0);
out->device = device;
s = request_firmware_nowait(module, 1,
"bcmvtq_imageconv", out->device,
GFP_KERNEL, out, _fw_cont);
if (s != 0) {
err_print("request firmware failed\n");
goto err_request_firmware;
}
/* success */
*vtq_imageconv_out = out;
return 0;
/* error exit paths follow */
err_request_firmware:
vtq_destroy_context(out->vtq);
err_vtq_create_context:
kfree(out);
err_kmalloc_vtq_imageconv_state:
return -ENOENT;
}
void
#line 87 "./cwebdir/comm-w2c.ch"
prime_the_change_buffer P1H(void)
#line 254 "./cwebdir/common.w"
{
change_limit= change_buffer;
/*13:*/
#line 265 "./cwebdir/common.w"
while(1){
change_line++;
if(!input_ln(change_file))return;
if(limit<buffer+2)continue;
if(buffer[0]!='@')continue;
if(xisupper(buffer[1]))buffer[1]= tolower(buffer[1]);
if(buffer[1]=='x')break;
if(buffer[1]=='y'||buffer[1]=='z'||buffer[1]=='i'){
loc= buffer+2;
err_print("! Missing @x in change file");
}
}
/*:13*/
#line 256 "./cwebdir/common.w"
;
/*14:*/
#line 282 "./cwebdir/common.w"
do{
change_line++;
if(!input_ln(change_file)){
err_print("! Change file ended after @x");
return;
}
}while(limit==buffer);
/*:14*/
#line 257 "./cwebdir/common.w"
;
/*15:*/
#line 292 "./cwebdir/common.w"
{
change_limit= change_buffer+(limit-buffer);
strncpy(change_buffer,buffer,limit-buffer+1);
}
/*:15*/
#line 258 "./cwebdir/common.w"
;
}
DMPAPI(void) uart_Close(void *vport)
{
unsigned char lcr;
SerialPort *port = (SerialPort *)vport;
if (port == NULL) { err_print((char*)"%s: port is null.\n", __FUNCTION__); return; }
if (port->InUse != 0)
{
// restore old IER & MCR
uart_IntDisable(vport);
io_DisableINT();
{
io_outpb(port->MCR, port->old_mcr);
}
io_RestoreINT();
irq_Close();
// restore old LSB & MSB
#ifdef _VORTEX86EXC_UART_WORKAROUND
/* To avoid Vortex86EX(D) write sync. issue. */
io_DisableINT();
{
lcr = io_inpb(port->LCR);
io_outpb(port->LCR, 0x80);
do {
io_outpb(port->DLLSB, port->old_lsb);
} while (io_inpb(port->DLLSB) != port->old_lsb);
do {
io_outpb(port->DLMSB, port->old_msb);
} while (io_inpb(port->DLMSB) != port->old_msb);
io_inpb(0x80); // do IO delay
io_outpb(port->LCR, lcr);
}
io_RestoreINT();
#else
_16550_DLAB_Out(port, port->DLLSB, port->old_lsb);
_16550_DLAB_Out(port, port->DLMSB, port->old_msb);
#endif
// restore old LCR & timeout
uart_SetFormat(vport, port->old_lcr);
uart_SetTimeOut(vport, port->old_TimeOut);
vx86_uart_Close(port->com);
if (io_Close() == false) err_print((char*)"Close IO lib error!!\n");
}
uart_Free(port);
}
boolean get_control_text(void)
{ char c,* k=id_first=&mod_text[1]; /* points after last recorded character */
do
if ((*k++=*loc++)=='@')
if ((c=*loc++)!='@')
{ if (c!='>')
err_print("! Control codes are forbidden in control text");
return (id_loc=k-1)==id_first;
}
while(loc<=limit);
err_print("! Control text didn't end");
return (id_loc=k)==id_first;
}
static inline void block_all_sigs(void)
{
sigset_t set;
if( sigfillset(&set) == -1 ) {
err_print("sigfillset");
return;
}
if( sigprocmask(SIG_BLOCK,&set,NULL) == -1) {
err_print("sigprocmask");
return;
}
}
static bool i2csw_Write(int dev, unsigned char val) {
int i, databit;
// send data byte
for(i=0; i<8; i++)
{
databit = ((val & 0x80) == 0)? 0 : 1;
set_pins(dev, 0, databit); timer_DelayMicroseconds(I2CSW_delay[dev]); // set data bit
set_pins(dev, 1, databit); timer_DelayMicroseconds(I2CSW_delay[dev]); // send a clock
set_pins(dev, 0, databit);
val = val << 1;
}
// read ACK
set_pins(dev, 0, 1); timer_DelayMicroseconds(I2CSW_delay[dev]); // set SDA as input
set_pins(dev, 1, 1); timer_DelayMicroseconds(I2CSW_delay[dev]); // send a clock
if (read_sda(dev) == 1)
{
err_print("receive no ACK after transmitting");
return false;
}
set_pins(dev, 0, 1);
return true;
}
static int isp_open(struct inode *inode, struct file *filp)
{
int ret = 0;
isp_t *dev = kmalloc(sizeof(isp_t), GFP_KERNEL);
if (!dev)
return -ENOMEM;
filp->private_data = dev;
dev->lock = __SPIN_LOCK_UNLOCKED();
dev->isp_status.status = 0;
sema_init(&dev->irq_sem, 0);
enable_isp_clock();
ret =
request_irq(IRQ_ISP, isp_isr, IRQF_DISABLED | IRQF_SHARED,
ISP_DEV_NAME, dev);
if (ret) {
err_print("request_irq failed ret = %d\n", ret);
goto err;
}
disable_irq(IRQ_ISP);
return 0;
err:
if (dev)
kfree(dev);
return ret;
}
void _imageconv_flush(vce_t *user,
struct vce *vce)
{
int s;
if (user->need_to_wait_for_imageconv) {
dbg_print("Flushing unfinished imageconversions\n");
s = vtq_imageconv_await(vce->vtq_imageconv,
user->last_imageconv_job_id);
if (s == -ERESTARTSYS) {
int retried;
dbg_print("Wait was interrupted by signal, will poll\n")
;
/* TODO: might be good to make blocking version of API
*/
retried = 0;
while (s == -ERESTARTSYS && retried++ < 1000) {
usleep_range(1000, 20000);
s = vtq_imageconv_await(vce->vtq_imageconv,
user->last_imageconv_job_id);
}
dbg_print("After %d tries, s = %d\n", retried, s);
}
if (s != 0)
err_print("Failed to flush imageconv -- likely FATAL\n")
;
}
}
DMPAPI(bool) usb_SetUSBPins(void *vusb, char port1, char pin1, char port2, char pin2)
{
USB_Device *usb = (USB_Device *)vusb;
if (usb == NULL) { err_print((char*)"%s: USB device is null.\n", __FUNCTION__); return false; }
if (set_gpio_config_addr(GPIO_CONFIG_ADDR) == false)
{
err_print((char*)"%s: init USB-DEV DETECT and ONOFF pins fail.\n", __FUNCTION__);
return false;
}
set_pin_in(port1, pin1);
set_pin_out(port2, pin2);
USB_Connect();
return true;
}
DMPAPI(void) usb_FlushWFIFO(void *vusb)
{
USB_Device *usb = (USB_Device *)vusb;
if (usb == NULL) { err_print((char*)"%s: USB device is null.\n", __FUNCTION__); return; }
while (usb->xmit->count > 0);
while (io_inpdw(usb->EP[2].InDLR) & 0x80000000L);
}
DMPAPI(Line_Coding *) usb_GetLineCoding(void *vusb)
{
USB_Device *usb = (USB_Device *)vusb;
if (usb == NULL) { err_print((char*)"%s: USB device is null.\n", __FUNCTION__); return NULL; }
return (Line_Coding*)&(usb->ling_coding);
}
int
p_expand()
{
uint64_t delta;
uint_t nparts;
struct dk_gpt *efi_label = cur_parts->etoc;
if (cur_parts->etoc->efi_altern_lba == 1 ||
(cur_parts->etoc->efi_altern_lba >=
cur_parts->etoc->efi_last_lba)) {
err_print("Warning: No expanded capacity is found.\n");
return (0);
}
delta = efi_label->efi_last_lba - efi_label->efi_altern_lba;
nparts = efi_label->efi_nparts;
enter_critical();
efi_label->efi_parts[nparts - 1].p_start += delta;
efi_label->efi_last_u_lba += delta;
efi_label->efi_altern_lba = cur_parts->etoc->efi_last_lba;
exit_critical();
fmt_print("The expanded capacity is added to the unallocated space.\n");
return (0);
}
/*
* Name: init_loging_semaphore
* Zweck: Initialisieren der Logging Semaphore
* In-Parameter: -
* Out-Parameter: -
* Globale Variablen: sem_t* log_sem
* Rückgabewert: -
*/
void init_logging_semaphore(void) {
if ((log_sem = sem_open(SEM_NAME, O_CREAT, S_IRUSR | S_IWUSR, 1))
== SEM_FAILED) {
err_print("cannot create named semaphore");
exit(EXIT_FAILURE); //WARNING / TODO Does not free used memory!
} /* end if */
} /* end of init_logging_semaphore */
static int _send_int(SerialPort *port, unsigned char* buf, int bsize)
{
int i;
unsigned long pretime;
for (i = 0; i < bsize; i++)
{
if (port->TxTimeOut < 0) {
while (QueueFull(port->xmit));
} else {
pretime = timer_NowTime();
while (QueueFull(port->xmit) && (timer_NowTime() - pretime) < port->TxTimeOut);
if (QueueFull(port->xmit)) {
if (UART_TIMEOUT_DEBUG)
err_print((char*)"%s: COM%d transmit timeout.\n", __FUNCTION__, port->com + 1);
if (!(port->ier & THREI)) io_outpb(port->IER, port->ier |= THREI);
return i;
}
}
io_DisableINT();
{
PushQueue(port->xmit, buf[i]);
if (!(port->ier & THREI) && (i == (bsize - 1) || QueueFull(port->xmit)))
{
switch (port->control)
{
case NO_CONTROL:
{
io_outpb(port->IER, port->ier |= THREI);
}
break;
case RTS_CTS:
{
if (port->cts == CTS_ON) {
io_outpb(port->IER, port->ier |= THREI);
}
}
break;
case XON_XOFF:
{
if (port->xonxoff_rcvd != XOFF_RCVD) {
io_outpb(port->IER, port->ier |= THREI);
}
}
break;
default: break;
};
}
}
io_RestoreINT();
}
return i;
}
/*
* This routine implements the 'verify' command. It writes the disk
* by writing unique data for each block; after the write pass, it
* reads the data and verifies for correctness. Note that the entire
* disk (or the range of disk) is fully written first and then read.
* This should eliminate any caching effect on the drives.
* It is not ok to run this command on any data you want to keep.
*/
int
a_verify()
{
/*
* The current disk must be formatted before disk analysis.
*/
if (!(cur_flags & DISK_FORMATTED)) {
err_print("Current Disk is unformatted.\n");
return (-1);
}
if (scan_random) {
fmt_print("The verify command does not write random data\n");
scan_random = 0;
}
if (scan_passes < 2 && !scan_loop) {
scan_passes = 2;
fmt_print("The verify command runs minimum of 2 passes, one"
" for writing and \nanother for reading and verfying."
" Resetting the number of passes to 2.\n");
}
if (check("Ready to verify (will corrupt data). This takes a long time,"
"\nbut is interruptable with CTRL-C. Continue")) {
return (-1);
}
return (do_scan(SCAN_WRITE | SCAN_VERIFY, F_NORMAL));
}
DMPAPI(bool) i2cmaster_Start(int dev, unsigned char addr, unsigned char rwbit) {
bool result = true;
if (I2C_action[dev] != I2CACT_IDLE)
{
err_print("can't start a transaction because I2C%d isn't idle", dev);
return false;
}
I2C_rsInfo[dev].restart = false;
if (I2C_swMode[dev] != I2CSW_DISABLE)
result = i2csw_Start(dev, addr, rwbit, false);
else
{
if (I2C_speedMode[dev] == I2CMODE_HIGHSPEED)
result = i2cmaster_Start1(dev, 0x07, I2C_WRITE); //send high-speed master code
if (result == true) result = i2cmaster_Start1(dev, addr, rwbit);
}
if (result == true)
{
I2C_action[dev] = (rwbit == I2C_WRITE)? I2CACT_MASTERWRITE : I2CACT_MASTERREAD;
I2C_curAddr[dev] = addr;
}
return result;
}
/*
* This routine deletes a partition map from the list of maps for
* the given disk type.
*/
void
delete_partition(struct partition_info *parts)
{
struct partition_info *pptr;
/*
* If there isn't a current map, it's an error.
*/
if (cur_dtype->dtype_plist == NULL) {
err_print("Error: unexpected null partition list.\n");
fullabort();
}
/*
* Remove the map from the list.
*/
if (cur_dtype->dtype_plist == parts)
cur_dtype->dtype_plist = parts->pinfo_next;
else {
for (pptr = cur_dtype->dtype_plist; pptr->pinfo_next != parts;
pptr = pptr->pinfo_next)
;
pptr->pinfo_next = parts->pinfo_next;
}
/*
* Free the space it was using.
*/
destroy_data((char *)parts);
}
void Epoll::remove(int fd) {
if (epoll_ctl(epfd_, EPOLL_CTL_DEL, fd, NULL) < 0) {
err_print("could not remove fd[%d] from epoll\n", fd);
}
return;
}
DMP_INLINE(void) uart_Free(SerialPort *port)
{
if (port == NULL) { err_print((char*)"%s: port is null.\n", __FUNCTION__); return; }
DestoryQueue(port->rcvd);
DestoryQueue(port->xmit);
ker_Mfree((void*)port);
}
/* load binary code and data from file to memory image */
int load_binfile(mem_t *m, FILE *f)
{
int flen;
clearerr(f);
flen = fread(m->data, sizeof(byte_t), m->len, f);
if (ferror(f)) {
err_print("fread() failed (0x%x)", flen);
return -1;
}
if (!feof(f)) {
err_print("too large memory footprint (0x%x)", flen);
return -1;
}
return 0;
}
static bool init_vx86(void) {
int i;
for (i=0; i<(int)(sizeof(VX86_pciDev)/sizeof(VX86_pciDev[0])); i++) VX86_pciDev[i] = NULL;
// get North Bridge fun0 & South Bridge fun0 & IDE PCI-CFG
if ((VX86_pciDev[VX86_NB] = pci_Alloc(0x00, 0x00, 0x00)) == NULL) goto FAIL_INITVX86;
if ((VX86_pciDev[VX86_SB] = pci_Alloc(0x00, 0x07, 0x00)) == NULL) goto FAIL_INITVX86;
if ((VX86_pciDev[VX86_IDE] = pci_Alloc(0x00, 0x0c, 0x00)) == NULL) goto FAIL_INITVX86;
// now we are allowed to call get_cpuid()
if ((VX86_cpuID = get_cpuid()) == CPU_UNSUPPORTED) goto FAIL_INITVX86;
if (vx86_CpuID() != CPU_VORTEX86SX)
{
// North Bridge fun1 exists (note NB fun1 isn't a normal PCI device -- its vid & did are 0xffff)
if ((VX86_pciDev[VX86_NB1] = pci_Alloc(0x00, 0x00, 0x01)) == NULL) goto FAIL_INITVX86;
}
if (vx86_CpuID() == CPU_VORTEX86EX || vx86_CpuID() == CPU_VORTEX86DX2 || vx86_CpuID() == CPU_VORTEX86DX3)
{
// South Bridge fun1 exists (note SB fun1 isn't a normal PCI device -- its vid & did are 0xffff)
if ((VX86_pciDev[VX86_SB1] = pci_Alloc(0x00, 0x07, 0x01)) == NULL) goto FAIL_INITVX86;
}
return true;
FAIL_INITVX86:
for (i=0; i<(int)(sizeof(VX86_pciDev)/sizeof(VX86_pciDev[0])); i++)
{
pci_Free(VX86_pciDev[i]);
VX86_pciDev[i] = NULL;
}
err_print((char*)"%s: fail to setup system PCI devices!\n", __FUNCTION__);
return false;
}
DMPAPI(bool) io_Free(void* handle) {
bool result = true;
IO_BASE_t* base;
if ((base = (IO_BASE_t*)handle) == NULL) return false;
switch (base->iotype)
{
case IO_USE_PORTIO:
// TODO: for WinXP or Linux Kernel Mode, free Port-I/O region here
break;
case IO_USE_MMIO:
#if defined DMP_DOS_DJGPP
dpmi_LinMapFree(base->addr);
dpmi_SelFree(base->mmio_selector);
#elif defined USE_WINIO3
UnmapPhysicalMemory(base->mmio_info);
#elif defined USE_PHYMEM
UnmapPhyMem((void*)base->addr, base->size);
#else
// TODO: for WinXP or Linux Kernel Mode, free MMIO region here
#endif
break;
default:
err_print((char*)"%s: unknown io-type!\n", __FUNCTION__);
result = false;
break;
}
free_io_base(base);
return result;
}
/* processing overhead in offset by malloc*/
unsigned int offset_to_buffer(unsigned int *mgmt_area, int i)
{
void *mgmt_blk;
struct ti81xx_mgmt_area mgmt_area_info;
unsigned int off_st;
int j;
memcpy(&mgmt_area_info, mgmt_area, GENERAL_INFO_SIZE);
debug_print("mgmt blocks are %u\n", mgmt_area_info.no_blk);
mgmt_blk = (mgmt_area + 6 + 2 * mgmt_area_info.no_blk);
mgmt_area_info.mgmt_blk = (struct ti81xx_mgmt_blk *)
malloc(MGMT_BLKS_SIZE(mgmt_area_info.no_blk));
if (mgmt_area_info.mgmt_blk == NULL) {
err_print("mgmt_blk malloc failed\n");
return 0;
}
memcpy(mgmt_area_info.mgmt_blk, mgmt_blk,
MGMT_BLKS_SIZE(mgmt_area_info.no_blk));
off_st = mgmt_area_info.size + PAGE_SIZE_EP -
(mgmt_area_info.size) % PAGE_SIZE_EP ;
for (j = 0 ; j < i; j++)
off_st += mgmt_area_info.mgmt_blk[j].size;
return off_st;
}
/*
* Function to handle non-fatal errors not from system calls.
*/
void
warn_msg(const char *fmt,...) {
va_list ap;
va_start(ap, fmt);
err_print(0, fmt, ap);
va_end(ap);
}
local mod_pointer mod_name_lookup (char* name, int l)
/* finds complete module name */
{ mod_pointer p; /* current node of the search tree */
mod_pointer* loc=&root; /* |p| will come from this location */
while ((p=*loc)!=NULL)
{ int l0=p->key_length; char* key=name_begin(p);
switch (mod_name_cmp(name,l,key,l0))
{ case less: loc=&p->llink; break;
case greater: loc=&p->rlink; break;
case equal: case extension:
{ enum mod_comparison cmp=
mod_name_cmp(name+l0,l-l0,key+l0,(int)strlen(key+l0));
switch(cmp)
{ case less: case greater:
err_print("! Incompatible module name");
print("\nName inconsistently extends <%.*s...>.\n",l0,key);
return NULL;
case extension: case equal:
if (complete_name(p))
if (cmp==equal) return p;
else
{ err_print("! Incompatible module name");
print("\nPrefix exists: <%s>.\n",key); return NULL;
}
name_begin(p)=store_string(name,l);
/* install |name| in place of |key| */
free(key-1);
return p;
}
}
case prefix:
err_print("! Incompatible module name");
print("\nName is a prefix of <%s%s>.\n"
,key, complete_name(p) ? "" : "...");
return NULL; /* dummy module name */
}
}
{ (p=make_mod_node(store_string(name,l)))->key_length=l; /* prepare new node */
return *loc=p; /* install new node into tree */
}
}
/*
* Function to handle informational syslog messages
*/
void info_syslog(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
err_print(0, LOG_INFO, fmt, ap);
va_end(ap);
}
__attribute__ ((noreturn)) void rexec(void)
{
dbg_print("execv(path:\'%s\')",cmd.path);
execv(cmd.path, cmd.args);
err_print("execv");
terminate();
};
static bool init_iosystem(void) {
int i;
for (i=0; i<IO_NUM_BASEPOOL; i++)
IO_basePool[i].iotype = IO_USE_NULLIO;
// TODO: IO_defaultBase shouldn't be used in WinXP or Linux Kernel Modes
// #if defined(DMP_OS_KERNEL)
// IO_defaultBase.iotype = IO_USE_NULLIO;
// #else
IO_defaultBase.iotype = IO_USE_PORTIO;
IO_defaultBase.addr = 0L;
IO_defaultBase.size = 0x10000L;
#if defined(DMP_DOS_DJGPP) || defined(DMP_DOS_WATCOM) || defined(DMP_DOS_BC)
return true;
#elif defined(USE_WINIO2) || defined(USE_WINIO3)
if (!InitializeWinIo())
{
err_print((char*)"%s: fail to initialize WinIO!\n", __FUNCTION__);
return false;
}
return true;
#elif defined(USE_PCIDEBUG)
if (getdllstatus() != DLLSTATUS_NOERROR)
{
err_print((char*)"%s: fail to initialize PCIDEBUG!\n", __FUNCTION__);
return false;
}
return true;
#elif defined(USE_PHYMEM)
if (LoadPhyMemDriver() == FALSE)
{
err_print((char*)"%s: fail to initialize PHYMEM!\n", __FUNCTION__);
return false;
}
return true;
#elif defined(DMP_LINUX)
if (iopl(3) != 0)
{
err_print((char*)"%s: fail to set iopl(3)!\n", __FUNCTION__);
return false;
}
return true;
#endif
}
void fork_exec(char *cmd)
{
int ret;
switch(fork()) {
case -1:
err_print("fork");
return;
case 0:
ret = system(cmd);
if(ret == -1) {
err_print("system");
terminate();
}
exit(EXIT_SUCCESS);
}
}
