//subscribe mouse interrupts
int mouse_subscribe_int(void)
{
int returnvalue = BIT(mouse_hook_id);
int irqpolicy = IRQ_EXCLUSIVE | IRQ_REENABLE;
if(sys_irqsetpolicy(MOUSE_IRQ, irqpolicy, &mouse_hook_id)!= OK){
printf("mouse_subscribe_int(): sys_irqsetpolicy() failed\n");
return -1;
}
if(sys_irqenable(&mouse_hook_id)!=OK){
printf("mouse_subscribe_int(): sys_irqenable() failed\n");
return -1;
}
return returnvalue;//return value with bit number (original hook_id) set to 1
}
int timer_subscribe_int(void) {
// atualiza hook_id, passando a ser 0
hook_id = TIMER_HOOK_BIT;
int bitmask = BIT(hook_id);
/*The policy you should specify in sys_irqsetpolicy() is IRQ_REENABLE, so
that the generic interrupt handler will acknowledge the interrupt. */
if (sys_irqsetpolicy(TIMER0_IRQ, IRQ_REENABLE, &hook_id) != 0
|| sys_irqenable(&hook_id) != 0) {
printf("\ntimer_subscribe_int() failed \n");
return -1;
} else {
return bitmask;
}
}
int keyboard_subscribe_int()
{
if(sys_irqsetpolicy(IRQ_KBD,(IRQ_REENABLE|IRQ_EXCLUSIVE),&hook_id_kbd)!=OK)
{
printf("IRQ_SETPOLICY failure /n");
return -1;
}
if(sys_irqenable(&hook_id_kbd)!=OK)
{
printf("IRQENABLE failure /n");
return -1;
}
return hook_id_kbd;
}
int kbd_subscribe_int(void ){
//para nao perder o valor original de khook_id (vai ser preciso para depois reconhecer a notificacao)
int hook_temp = khook_id;
if (OK == sys_irqsetpolicy(KBC_IRQ, IRQ_REENABLE | IRQ_EXCLUSIVE, &khook_id))
{
if (OK == sys_irqenable(&khook_id))
{
return BIT(hook_temp);
}
}
return -1;
}
PRIVATE void handle_hw_intr(void)
{
dpeth_t *dep;
dep = &de_state;
/* If device is enabled and interrupt pending */
if (dep->de_mode == DEM_ENABLED) {
dep->de_int_pending = TRUE;
(*dep->de_interruptf) (dep);
if (dep->de_flags & (DEF_ACK_SEND | DEF_ACK_RECV))
reply(dep);
dep->de_int_pending = FALSE;
sys_irqenable(&dep->de_hook);
}
}
int MOUSE_subscribe_int(void) {
int hook;
hook = hook_id2;
if (sys_irqsetpolicy(MOUSE_IRQ, IRQ_REENABLE | IRQ_EXCLUSIVE,
&hook_id2) == OK)
if (sys_irqenable(&hook_id2) == OK)
return BIT(hook);
return -1;
}
int subscribeKeyboard()
{
// IRQ_EXCLUSIVE is needed to prevent minix from printing the character in the terminal
if (sys_irqsetpolicy(KB_IRQ, IRQ_REENABLE | IRQ_EXCLUSIVE, &kb_id) != OK)
{
printf("\tsubscribeKeyboard() in Keyboard.c: sys_irqsetpolicy failed");
return -1;
}
if (sys_irqenable(&kb_id) != OK)
{
printf("\tsubscribeKeyboard() in Keyboard.c: sys_irqenable failed");
return -1;
}
return BIT(0);
}
PRIVATE int get_started(sub_dev_t *sub_dev_ptr) {
u32_t i;char c;
/* enable interrupt messages from MINIX */
if ((i=sys_irqenable(&irq_hook_id)) != OK) {
error("%s: Couldn't enable IRQs",drv.DriverName);
return EIO;
}
/* let the lower part of the driver start the device */
if (drv_start(sub_dev_ptr->Nr, sub_dev_ptr->DmaMode) != OK) {
error("%s: Could not start device %d\n", drv.DriverName, sub_dev_ptr->Nr);
}
sub_dev_ptr->DmaBusy = TRUE; /* Dma is busy from now on */
sub_dev_ptr->DmaReadNext = 0;
return OK;
}
static int
intr_enable(void)
{
int r;
uint8_t val;
static int policy_set = 0;
static int irq_enabled = 0;
/* Enable IRQ */
if (!policy_set) {
r = sys_irqsetpolicy(irq, 0, &irq_hook_kernel_id);
if (r == OK) {
policy_set = 1;
} else {
log_warn(&log, "Couldn't set irq policy\n");
return -1;
}
}
if (policy_set && !irq_enabled) {
r = sys_irqenable(&irq_hook_kernel_id);
if (r == OK) {
irq_enabled = 1;
} else {
log_warn(&log, "Couldn't enable irq %d (hooked)\n",
irq);
return -1;
}
}
/* Enable/Disable interrupts in the TPS65217 */
r = reg_write(INT_REG, DEFAULT_INT_MASK);
if (r != OK) {
log_warn(&log, "Failed to set interrupt mask.\n");
return -1;
}
/* Read from the interrupt register to clear any pending interrupts */
r = reg_read(INT_REG, &val);
if (r != OK) {
log_warn(&log, "Failed to read interrupt register.\n");
return -1;
}
return OK;
}
/*===========================================================================*
* do_initialize *
*===========================================================================*/
static void do_initialize()
{
/* Set global variables and initialize the printer. */
if(sys_outb(port_base + 2, INIT_PRINTER) != OK) {
printf("printer: sys_outb of %x failed\n", port_base+2);
panic("do_initialize: sys_outb init failed");
}
micro_delay(1000000/20); /* easily satisfies Centronics minimum */
if(sys_outb(port_base + 2, PR_SELECT) != OK) {
printf("printer: sys_outb of %x failed\n", port_base+2);
panic("do_initialize: sys_outb select failed");
}
irq_hook_id = 0;
if(sys_irqsetpolicy(PRINTER_IRQ, 0, &irq_hook_id) != OK ||
sys_irqenable(&irq_hook_id) != OK) {
panic("do_initialize: irq enabling failed");
}
}
int sp2_subscribe_int()
{
int hook_temp = hook_id_sp2;
if (sys_irqsetpolicy(COM2_IRQ, IRQ_REENABLE | IRQ_EXCLUSIVE, &hook_id_sp2) != OK)
{
printf("SET POlicy\n");
return -1;
}
if (sys_irqenable(&hook_id_sp2) != OK)
{
printf("irq enable\n");
return -1;
}
return BIT(hook_temp);
}
/*===========================================================================*
* dsp_init
*===========================================================================*/
PRIVATE int dsp_init()
{
int i, s;
if(dsp_reset () != OK) {
dprint("sb16: No SoundBlaster card detected\n");
return -1;
}
DspVersion[0] = DspVersion[1] = 0;
dsp_command(DSP_GET_VERSION); /* Get DSP version bytes */
for(i = 1000; i; i--) {
if(sb16_inb(DSP_DATA_AVL) & 0x80) {
if(DspVersion[0] == 0) {
DspVersion[0] = sb16_inb(DSP_READ);
} else {
DspVersion[1] = sb16_inb(DSP_READ);
break;
}
}
}
if(DspVersion[0] < 4) {
dprint("sb16: No SoundBlaster 16 compatible card detected\n");
return -1;
}
dprint("sb16: SoundBlaster DSP version %d.%d detected\n", DspVersion[0], DspVersion[1]);
/* set SB to use our IRQ and DMA channels */
mixer_set(MIXER_SET_IRQ, (1 << (SB_IRQ / 2 - 1)));
mixer_set(MIXER_SET_DMA, (1 << SB_DMA_8 | 1 << SB_DMA_16));
/* register interrupt vector and enable irq */
if ((s=sys_irqsetpolicy(SB_IRQ, IRQ_REENABLE, &irq_hook_id )) != OK)
panic("Couldn't set IRQ policy: %d", s);
if ((s=sys_irqenable(&irq_hook_id)) != OK)
panic("Couldn't enable IRQ: %d", s);
DspAvail = 1;
return OK;
}
/*===========================================================================*
* atl2_init *
*===========================================================================*/
static void atl2_init(int devind)
{
/* Initialize the device.
*/
u32_t bar;
int r, flag;
/* Initialize global state. */
state.devind = devind;
state.mode = DL_NOMODE;
state.flags = 0;
state.recv_count = 0;
memset(&state.stat, 0, sizeof(state.stat));
if ((r = pci_get_bar(devind, PCI_BAR, &bar, &state.size, &flag)) != OK)
panic("unable to retrieve bar: %d", r);
if (state.size < ATL2_MIN_MMAP_SIZE || flag)
panic("invalid register bar");
state.base = vm_map_phys(SELF, (void *) bar, state.size);
if (state.base == MAP_FAILED)
panic("unable to map in registers");
if ((r = atl2_alloc_dma()) != OK)
panic("unable to allocate DMA buffers: %d", r);
state.irq = pci_attr_r8(devind, PCI_ILR);
if ((r = sys_irqsetpolicy(state.irq, 0, &state.hook_id)) != OK)
panic("unable to register IRQ: %d", r);
if (!atl2_reset())
panic("unable to reset hardware");
if ((r = sys_irqenable(&state.hook_id)) != OK)
panic("unable to enable IRQ: %d", r);
atl2_get_hwaddr();
atl2_setup();
}
/* handle interrupt for specified sub device; DmaMode == DEV_READ */
PRIVATE void handle_int_read(int sub_dev_nr)
{
sub_dev_t *sub_dev_ptr; int r,i;
sub_dev_ptr = &sub_dev[sub_dev_nr];
dprint("Device filled dma[%d]\n", sub_dev_ptr->DmaFillNext);
sub_dev_ptr->DmaLength += 1;
sub_dev_ptr->DmaFillNext = (sub_dev_ptr->DmaFillNext + 1) % sub_dev_ptr->NrOfDmaFragments;
/* possibly copy data to user (if it is waiting for us) */
data_to_user(sub_dev_ptr);
if (sub_dev_ptr->DmaLength == sub_dev_ptr->NrOfDmaFragments) { /* if dma buffer full */
if (sub_dev_ptr->BufLength == sub_dev_ptr->NrOfExtraBuffers) {
error("All buffers full, we have a problem.\n");
drv_stop(sub_dev_nr); /* stop the sub device */
sub_dev_ptr->DmaBusy = FALSE;
sub_dev_ptr->ReviveStatus = 0; /* no data for user, this is a sad story */
sub_dev_ptr->ReadyToRevive = TRUE; /* wake user up */
return;
}
else { /* dma full, still room in extra buf; copy from dma to extra buf */
dprint("dma full: going to copy buf[%d] <- dma[%d]\n", sub_dev_ptr->BufFillNext,
sub_dev_ptr->DmaReadNext);
memcpy(sub_dev_ptr->ExtraBuf + sub_dev_ptr->BufFillNext * sub_dev_ptr->FragSize,
sub_dev_ptr->DmaPtr + sub_dev_ptr->DmaReadNext * sub_dev_ptr->FragSize,
sub_dev_ptr->FragSize);
sub_dev_ptr->DmaLength -= 1;
sub_dev_ptr->DmaReadNext = (sub_dev_ptr->DmaReadNext + 1) % sub_dev_ptr->NrOfDmaFragments;
sub_dev_ptr->BufFillNext = (sub_dev_ptr->BufFillNext + 1) % sub_dev_ptr->NrOfExtraBuffers;
}
}
/* confirm interrupt, and reenable interrupt from this sub dev*/
drv_reenable_int(sub_dev_ptr->Nr);
/* reenable irq_hook*/
if ((r=sys_irqenable(&irq_hook_id)) != OK) {
error("%s: Couldn't reenable IRQ", drv.DriverName);
}
}
/*
** Name: void do_first_init(dpeth_t *dep, dp_conf_t *dcp);
** Function: Init action to setup task
*/
static void do_first_init(dpeth_t *dep, const dp_conf_t *dcp)
{
dep->de_linmem = 0xFFFF0000;
/* Make sure statisics are cleared */
memset((void *) &(dep->de_stat), 0, sizeof(eth_stat_t));
/* Device specific initialization */
(*dep->de_initf) (dep);
/* Set the interrupt handler policy. Request interrupts not to be reenabled
* automatically. Return the IRQ line number when an interrupt occurs.
*/
dep->de_hook = dep->de_irq;
sys_irqsetpolicy(dep->de_irq, 0 /*IRQ_REENABLE*/, &dep->de_hook);
dep->de_int_pending = FALSE;
sys_irqenable(&dep->de_hook);
return;
}
int subscribe_int(int irq_vec, int policy, int *hook_id)
{
int status, tmp = *hook_id;
// IRQ_EXCLUSIVE is needed to prevent minix from printing the character in the terminal
status = sys_irqsetpolicy(irq_vec, policy, hook_id);
if (status != OK)
{
printf("sys_irqsetpolicy failed with: %d", status);
return -1;
}
status = sys_irqenable(hook_id);
if (status != OK)
{
printf("sys_irqenable failed with: %d", status);
return -1;
}
return BIT(tmp);
}
int keyboard_subscribe_int()
{
int status, tmp = kb_id;
// IRQ_EXCLUSIVE is needed to prevent minix from printing the character in the terminal
status = sys_irqsetpolicy(KB_IRQ, IRQ_REENABLE | IRQ_EXCLUSIVE, &kb_id);
if (status != OK)
{
printf("sys_irqsetpolicy failed with: %d", status);
return -1;
}
status = sys_irqenable(&kb_id);
if (status != OK)
{
printf("sys_irqenable failed with: %d", status);
return -1;
}
return BIT(tmp);
}
static void handle_hw_intr(void)
{
int r, irq;
dpeth_t *dep;
dep = &de_state;
if (dep->de_mode != DEM_ENABLED)
return;
assert(dep->de_flags & DEF_ENABLED);
irq= dep->de_irq;
assert(irq >= 0 && irq < NR_IRQ_VECTORS);
if (dep->de_int_pending || 1)
{
dep->de_int_pending= 0;
dp_check_ints(dep);
do_int(dep);
r= sys_irqenable(&dep->de_hook);
if (r != OK) {
panic("unable enable interrupts: %d", r);
}
}
}
/*===========================================================================*
* w_intr_wait *
*===========================================================================*/
static int
intr_wait(int mask)
{
long v;
#ifdef USE_INTR
if (sys_irqenable(&hook_id) != OK)
printf("Failed to enable irqenable irq\n");
/* Wait for a task completion interrupt. */
message m;
int ipc_status;
int ticks = SANE_TIMEOUT * sys_hz() / 1000000;
if (ticks <= 0)
ticks = 1;
while (1) {
int rr;
sys_setalarm(ticks, 0);
if ((rr = driver_receive(ANY, &m, &ipc_status)) != OK) {
panic("driver_receive failed: %d", rr);
};
if (is_ipc_notify(ipc_status)) {
switch (_ENDPOINT_P(m.m_source)) {
case CLOCK:
/* Timeout. */
// w_timeout(); /* a.o. set w_status */
mmc_log_warn(&log, "TIMEOUT\n");
return 1;
break;
case HARDWARE:
v = read32(base_address + MMCHS_SD_STAT);
if (v & mask) {
sys_setalarm(0, 0);
return 0;
} else if (v & (1 << 15)) {
return 1; /* error */
} else {
mmc_log_debug(&log,
"unexpected HW interrupt 0x%08x mask 0X%08x\n",
v, mask);
if (sys_irqenable(&hook_id) != OK)
printf
("Failed to re-enable irqenable irq\n");
continue;
// return 1;
}
default:
/*
* unhandled message. queue it and
* handle it in the blockdriver loop.
*/
blockdriver_mq_queue(&m, ipc_status);
}
} else {
mmc_log_debug(&log, "Other\n");
/*
* unhandled message. queue it and handle it in the
* blockdriver loop.
*/
blockdriver_mq_queue(&m, ipc_status);
}
}
sys_setalarm(0, 0); /* cancel the alarm */
#else
spin_t spin;
spin_init(&spin, SANE_TIMEOUT);
/* Wait for completion */
int counter = 0;
while (1 == 1) {
counter++;
v = read32(base_address + MMCHS_SD_STAT);
if (spin_check(&spin) == FALSE) {
mmc_log_warn(&log,
"Timeout waiting for interrupt (%d) value 0x%08x mask 0x%08x\n",
counter, v, mask);
return 1;
}
if (v & mask) {
return 0;
} else if (v & 0xFF00) {
mmc_log_debug(&log,
"unexpected HW interrupt (%d) 0x%08x mask 0x%08x\n",
v, mask);
return 1;
}
}
return 1; /* unreached */
#endif /* USE_INTR */
}
/*===========================================================================*
* hw_init *
*===========================================================================*/
static void hw_init(struct port *pp, int devind)
{
u8_t v8;
u16_t v16;
u32_t v32;
#if USE_INTS
int r, irq;
#endif
pp->p_devind= devind;
if (debug)
printf("hw_init: devind = %d\n", devind);
if (debug)
{
v16= pci_attr_r16(devind, PCI_CR);
printf("ti1225: command register 0x%x\n", v16);
}
v32= pci_attr_r32(devind, TI_CB_BASEADDR);
if (debug)
printf("ti1225: Cardbus/ExCA base address 0x%x\n", v32);
v32 &= PCI_BAR_MEM_MASK; /* Clear low order bits in base */
pp->csr_ptr=
(struct csr *) vm_map_phys(SELF, (void *) v32, I386_PAGE_SIZE);
if (pp->csr_ptr == MAP_FAILED)
panic("hw_init: vm_map_phys failed");
if (debug)
{
v8= pci_attr_r8(devind, TI_PCI_BUS_NR);
printf("ti1225: PCI bus number %d\n", v8);
}
v8= pci_attr_r8(devind, TI_CB_BUS_NR);
pp->p_cb_busnr= v8;
if (debug)
{
printf("ti1225: CardBus bus number %d\n", v8);
v8= pci_attr_r8(devind, TI_SO_BUS_NR);
printf("ti1225: Subordinate bus number %d\n", v8);
}
#if USE_INTS
irq= pci_attr_r8(devind, PCI_ILR);
pp->p_irq= irq;
printf("ti1225 using IRQ %d\n", irq);
#endif
v32= pci_attr_r32(devind, TI_LEGACY_BA);
v32 &= ~1;
if (debug)
{
printf("ti1225: PC Card 16-bit legacy-mode base address 0x%x\n",
v32);
}
if (v32 == 0)
panic("bad legacy-mode base address: %d", v32);
pp->p_exca_port= v32;
if (debug)
{
v32= pci_attr_r32(devind, TI_MF_ROUTE);
printf("ti1225: Multifunction routing 0x%08x\n", v32);
}
#if USE_INTS
pp->p_hook = pp->p_irq;
r= sys_irqsetpolicy(pp->p_irq, 0, &pp->p_hook);
if (r != OK)
panic("sys_irqsetpolicy failed: %d", r);
#endif
/* Clear CBB_BC_INTEXCA */
v16= pci_attr_r16(devind, CBB_BRIDGECTRL);
if (debug)
printf("ti1225: Bridge control 0x%04x\n", v16);
v16 &= ~CBB_BC_INTEXCA;
pci_attr_w16(devind, CBB_BRIDGECTRL, v16);
if (debug)
{
v32= pci_attr_r32(devind, TI_SYSCTRL);
printf("ti1225: System Control Register 0x%08x\n", v32);
v8= pci_attr_r8(devind, TI_CARD_CTRL);
printf("ti1225: Card Control 0x%02x\n", v8);
v8= pci_attr_r8(devind, TI_DEV_CTRL);
printf("ti1225: Device Control 0x%02x\n", v8);
}
/* Enable socket interrupts */
pp->csr_ptr->csr_mask |= CM_PWRMASK | CM_CDMASK | CM_CSTSMASK;
do_int(pp);
#if USE_INTS
r= sys_irqenable(&pp->p_hook);
if (r != OK)
panic("unable enable interrupts: %d", r);
#endif
}
/*===========================================================================*
* do_int *
*===========================================================================*/
static void do_int(struct port *pp)
{
int devind, vcc_5v, vcc_3v, vcc_Xv, vcc_Yv,
socket_5v, socket_3v, socket_Xv, socket_Yv;
spin_t spin;
u32_t csr_event, csr_present, csr_control;
u8_t v8;
u16_t v16;
#if USE_INTS
int r;
#endif
devind= pp->p_devind;
v8= pci_attr_r8(devind, TI_CARD_CTRL);
if (v8 & TI_CCR_IFG)
{
printf("ti1225: got functional interrupt\n");
pci_attr_w8(devind, TI_CARD_CTRL, v8);
}
if (debug)
{
printf("Socket event: 0x%x\n", pp->csr_ptr->csr_event);
printf("Socket mask: 0x%x\n", pp->csr_ptr->csr_mask);
}
csr_present= pp->csr_ptr->csr_present;
csr_control= pp->csr_ptr->csr_control;
if ((csr_present & (CP_CDETECT1|CP_CDETECT2)) != 0)
{
if (debug)
printf("do_int: no card present\n");
return;
}
if (csr_present & CP_BADVCCREQ)
{
printf("do_int: Bad Vcc request\n");
/* return; */
}
if (csr_present & CP_DATALOST)
{
/* Do we care? */
if (debug)
printf("do_int: Data lost\n");
/* return; */
}
if (csr_present & CP_NOTACARD)
{
printf("do_int: Not a card\n");
return;
}
if (debug)
{
if (csr_present & CP_CBCARD)
printf("do_int: Cardbus card detected\n");
if (csr_present & CP_16BITCARD)
printf("do_int: 16-bit card detected\n");
}
if (csr_present & CP_PWRCYCLE)
{
if (debug)
printf("do_int: powered up\n");
return;
}
vcc_5v= !!(csr_present & CP_5VCARD);
vcc_3v= !!(csr_present & CP_3VCARD);
vcc_Xv= !!(csr_present & CP_XVCARD);
vcc_Yv= !!(csr_present & CP_YVCARD);
if (debug)
{
printf("do_int: card supports:%s%s%s%s\n",
vcc_5v ? " 5V" : "", vcc_3v ? " 3V" : "",
vcc_Xv ? " X.X V" : "", vcc_Yv ? " Y.Y V" : "");
}
socket_5v= !!(csr_present & CP_5VSOCKET);
socket_3v= !!(csr_present & CP_3VSOCKET);
socket_Xv= !!(csr_present & CP_XVSOCKET);
socket_Yv= !!(csr_present & CP_YVSOCKET);
if (debug)
{
printf("do_int: socket supports:%s%s%s%s\n",
socket_5v ? " 5V" : "", socket_3v ? " 3V" : "",
socket_Xv ? " X.X V" : "", socket_Yv ? " Y.Y V" : "");
}
if (vcc_5v && socket_5v)
{
csr_control= (csr_control & ~CC_VCCCTRL) | CC_VCC_5V;
pp->csr_ptr->csr_control= csr_control;
if (debug)
printf("do_int: applying 5V\n");
}
else if (vcc_3v && socket_3v)
{
csr_control= (csr_control & ~CC_VCCCTRL) | CC_VCC_3V;
pp->csr_ptr->csr_control= csr_control;
if (debug)
printf("do_int: applying 3V\n");
}
else if (vcc_Xv && socket_Xv)
{
csr_control= (csr_control & ~CC_VCCCTRL) | CC_VCC_XV;
pp->csr_ptr->csr_control= csr_control;
printf("do_int: applying X.X V\n");
}
else if (vcc_Yv && socket_Yv)
{
csr_control= (csr_control & ~CC_VCCCTRL) | CC_VCC_YV;
pp->csr_ptr->csr_control= csr_control;
printf("do_int: applying Y.Y V\n");
}
else
{
printf("do_int: socket and card are not compatible\n");
return;
}
csr_event= pp->csr_ptr->csr_event;
if (csr_event)
{
if (debug)
printf("clearing socket event\n");
pp->csr_ptr->csr_event= csr_event;
if (debug)
{
printf("Socket event (cleared): 0x%x\n",
pp->csr_ptr->csr_event);
}
}
devind= pp->p_devind;
v8= pci_attr_r8(devind, TI_CARD_CTRL);
if (v8 & TI_CCR_IFG)
{
printf("ti1225: got functional interrupt\n");
pci_attr_w8(devind, TI_CARD_CTRL, v8);
}
if (debug)
{
v8= pci_attr_r8(devind, TI_CARD_CTRL);
printf("TI_CARD_CTRL: 0x%02x\n", v8);
}
spin_init(&spin, 100000);
do {
csr_present= pp->csr_ptr->csr_present;
if (csr_present & CP_PWRCYCLE)
break;
} while (spin_check(&spin));
if (!(csr_present & CP_PWRCYCLE))
{
printf("do_int: not powered up?\n");
return;
}
/* Reset device */
v16= pci_attr_r16(devind, CBB_BRIDGECTRL);
v16 |= CBB_BC_CRST;
pci_attr_w16(devind, CBB_BRIDGECTRL, v16);
/* Wait one microsecond. Is this correct? What are the specs? */
micro_delay(1);
/* Clear CBB_BC_CRST */
v16= pci_attr_r16(devind, CBB_BRIDGECTRL);
v16 &= ~CBB_BC_CRST;
pci_attr_w16(devind, CBB_BRIDGECTRL, v16);
/* Wait one microsecond after clearing the reset line. Is this
* correct? What are the specs?
*/
micro_delay(1);
pci_rescan_bus(pp->p_cb_busnr);
#if USE_INTS
r= sys_irqenable(&pp->p_hook);
if (r != OK)
panic("unable enable interrupts: %d", r);
#endif
}
int kbd_subscribe_int(void) { //
int value = KBD_HOOK_ID;
sys_irqsetpolicy(IRQ1, IRQ_REENABLE | IRQ_EXCLUSIVE, &value);
sys_irqenable(&value);
return BIT(KBD_HOOK_ID);
}
/*===========================================================================*
* dpeth_task *
*===========================================================================*/
int main(int argc, char *argv[])
{
message m;
int i, irq, r;
dpeth_t *dep;
long v;
env_setargs(argc, argv);
for (i= 0, dep= de_table; i<DE_PORT_NR; i++, dep++)
{
strcpy(dep->de_name, "dp8390#0");
dep->de_name[7] += i;
}
v= 0;
(void) env_parse("ETH_IGN_PROTO", "x", 0, &v, 0x0000L, 0xFFFFL);
eth_ign_proto= htons((u16_t) v);
while (TRUE)
{
if ((r= receive(ANY, &m)) != OK)
panic("", "dp8390: receive failed", r);
switch (m.m_type)
{
case DL_WRITE: do_vwrite(&m, FALSE, FALSE); break;
case DL_WRITEV: do_vwrite(&m, FALSE, TRUE); break;
case DL_READ: do_vread(&m, FALSE); break;
case DL_READV: do_vread(&m, TRUE); break;
case DL_INIT: do_init(&m); break;
case DL_GETSTAT: do_getstat(&m); break;
case DL_STOP: do_stop(&m); break;
case HARD_INT:
for (i= 0, dep= &de_table[0]; i<DE_PORT_NR; i++, dep++)
{
if (dep->de_mode != DEM_ENABLED)
continue;
assert(dep->de_flags & DEF_ENABLED);
irq= dep->de_irq;
assert(irq >= 0 && irq < NR_IRQ_VECTORS);
if (dep->de_int_pending || 1)
{
dep->de_int_pending= 0;
dp_check_ints(dep);
do_int(dep);
r= sys_irqenable(&dep->de_hook);
if (r != OK)
{
panic("DP8390",
"unable enable interrupts", r);
}
}
}
break;
case SYS_SIG: {
sigset_t sigset = m.NOTIFY_ARG;
if (sigismember(&sigset, SIGKSTOP)) dp8390_stop();
break;
}
case SYN_ALARM:
printf("dp8390: strange, got SYN_ALARM\n");
break;
default:
panic("", "dp8390: illegal message", m.m_type);
}
}
}
/*===========================================================================*
* printer_intr *
*===========================================================================*/
static void printer_intr(unsigned int UNUSED(mask))
{
/* This function does the actual output to the printer. This is called on an
* interrupt message sent from the generic interrupt handler that 'forwards'
* interrupts to this driver. The generic handler did not reenable the printer
* IRQ yet!
*/
u32_t status;
pvb_pair_t char_out[3];
if (oleft == 0) {
/* Nothing more to print. Turn off printer interrupts in case they
* are level-sensitive as on the PS/2. This should be safe even
* when the printer is busy with a previous character, because the
* interrupt status does not affect the printer.
*/
if(sys_outb(port_base + 2, PR_SELECT) != OK) {
printf("printer: sys_outb of %x failed\n", port_base+2);
panic("sys_outb failed");
}
if(sys_irqenable(&irq_hook_id) != OK) {
panic("sys_irqenable failed");
}
return;
}
do {
/* Loop to handle fast (buffered) printers. It is important that
* processor interrupts are not disabled here, just printer interrupts.
*/
if(sys_inb(port_base + 1, &status) != OK) {
printf("printer: sys_inb of %x failed\n", port_base+1);
panic("sys_inb failed");
}
if ((status & STATUS_MASK) == BUSY_STATUS) {
/* Still busy with last output. This normally happens
* immediately after doing output to an unbuffered or slow
* printer. It may happen after a call from prepare_output or
* pr_restart, since they are not synchronized with printer
* interrupts. It may happen after a spurious interrupt.
*/
if(sys_irqenable(&irq_hook_id) != OK) {
panic("sys_irqenable failed");
}
return;
}
if ((status & STATUS_MASK) == NORMAL_STATUS) {
/* Everything is all right. Output another character. */
pv_set(char_out[0], port_base, *optr);
optr++;
pv_set(char_out[1], port_base+2, ASSERT_STROBE);
pv_set(char_out[2], port_base+2, NEGATE_STROBE);
if(sys_voutb(char_out, 3) != OK) {
/* request series of port outb */
panic("sys_voutb failed");
}
user_vir_d++;
user_left--;
} else {
/* Error. This would be better ignored (treat as busy). */
done_status = status;
output_done();
if(sys_irqenable(&irq_hook_id) != OK) {
panic("sys_irqenable failed");
}
return;
}
}
while (--oleft != 0);
/* Finished printing chunk OK. */
done_status = OK;
output_done();
if(sys_irqenable(&irq_hook_id) != OK) {
panic("sys_irqenable failed");
}
}
int rtc_subscribe_int(void ) {
sys_irqsetpolicy(8, IRQ_REENABLE|IRQ_EXCLUSIVE, &hook);
sys_irqenable(&hook);
return 1;
}
PRIVATE void data_from_user(sub_dev_t *subdev)
{
int r;
message m;
if (subdev->DmaLength == subdev->NrOfDmaFragments &&
subdev->BufLength == subdev->NrOfExtraBuffers) return;/* no space */
if (!subdev->RevivePending) return; /* no new data waiting to be copied */
if (subdev->RevivePending &&
subdev->ReadyToRevive) return; /* we already got this data */
if (subdev->DmaLength < subdev->NrOfDmaFragments) { /* room in dma buf */
sys_safecopyfrom(subdev->ReviveProcNr,
(vir_bytes)subdev->ReviveGrant, 0,
(vir_bytes)subdev->DmaPtr +
subdev->DmaFillNext * subdev->FragSize,
(phys_bytes)subdev->FragSize, D);
dprint(" user -> dma[%d]\n", subdev->DmaFillNext);
subdev->DmaLength += 1;
subdev->DmaFillNext =
(subdev->DmaFillNext + 1) % subdev->NrOfDmaFragments;
} else { /* room in extra buf */
sys_safecopyfrom(subdev->ReviveProcNr,
(vir_bytes)subdev->ReviveGrant, 0,
(vir_bytes)subdev->ExtraBuf +
subdev->BufFillNext * subdev->FragSize,
(phys_bytes)subdev->FragSize, D);
dprint(" user -> buf[%d]\n", subdev->BufFillNext);
subdev->BufLength += 1;
subdev->BufFillNext =
(subdev->BufFillNext + 1) % subdev->NrOfExtraBuffers;
}
if(subdev->OutOfData) { /* if device paused (because of lack of data) */
subdev->OutOfData = FALSE;
drv_reenable_int(subdev->Nr);
/* reenable irq_hook*/
if ((sys_irqenable(&irq_hook_id)) != OK) {
error("%s: Couldn't enable IRQ", drv.DriverName);
}
drv_resume(subdev->Nr); /* resume resume the sub device */
}
subdev->ReviveStatus = subdev->FragSize;
subdev->ReadyToRevive = TRUE;
m.m_type = DEV_REVIVE; /* build message */
m.REP_ENDPT = subdev->ReviveProcNr;
m.REP_IO_GRANT = subdev->ReviveGrant;
m.REP_STATUS = subdev->ReviveStatus;
r= send(subdev->NotifyProcNr, &m); /* send the message */
if (r != OK)
{
printf("audio_fw: send to %d failed: %d\n",
subdev->NotifyProcNr, r);
}
/* reset variables */
subdev->ReadyToRevive = FALSE;
subdev->RevivePending = 0;
}
int timer_subscribe_int(void) {
hook_id = HOOK_ID;
sys_irqsetpolicy(TIMER0_IRQ, IRQ_REENABLE, &hook_id); //used to subscribe a notification on every interrupt in the input TIMER0_IRQ
sys_irqenable(&hook_id); //enables interrupts on the IRQ line associated with the specified hook_id
return BIT(HOOK_ID);
}
/*===========================================================================*
* main *
*===========================================================================*/
int main( int argc, char **argv )
{
message m;
int ipc_status;
int r;
ether_card_t *ec;
/* SEF local startup. */
env_setargs(argc, argv);
sef_local_startup();
ec= &ec_state;
while (TRUE)
{
if (ec->ec_irq != 0)
sys_irqenable(&ec->ec_hook);
if ((r= netdriver_receive(ANY, &m, &ipc_status)) != OK)
panic("netdriver_receive failed: %d", r);
if (ec->ec_irq != 0)
sys_irqdisable(&ec->ec_hook);
if (is_ipc_notify(ipc_status)) {
switch(_ENDPOINT_P(m.m_source)) {
case TTY_PROC_NR:
lance_dump();
break;
case HARDWARE:
if (ec->mode == EC_ENABLED)
{
ec->ec_int_pending = 0;
ec_check_ints(ec);
do_int(ec);
}
break;
default:
panic("illegal notify source: %d", m.m_source);
}
/* get next message */
continue;
}
switch (m.m_type)
{
case DL_WRITEV_S:
do_vwrite_s(&m, FALSE);
break;
case DL_READV_S:
do_vread_s(&m);
break;
case DL_CONF:
do_init(&m);
break;
case DL_GETSTAT_S:
do_getstat_s(&m);
break;
default:
panic("illegal message: %d", m.m_type);
}
}
return 0;
}
int kbd_subscribe_int(void )
{
if( sys_irqsetpolicy(KBD_IRQ, IRQ_REENABLE | IRQ_EXCLUSIVE, &hook) == OK && sys_irqenable(&hook) == OK)
return 1 << 0;
return -1;
}
int timer_subscribe_int(void ) {
timer_hook = 0;
if(sys_irqsetpolicy(TIMER0_IRQ, IRQ_REENABLE,&timer_hook) == OK && sys_irqenable(&timer_hook) == OK)
return 1 << 0;
return -1;
}