static int atari_startup_irq(unsigned int irq) { m68k_irq_startup(irq); atari_turnon_irq(irq); atari_enable_irq(irq); return 0; }
static unsigned int atari_irq_startup(struct irq_data *data) { unsigned int irq = data->irq; m68k_irq_startup(data); atari_turnon_irq(irq); atari_enable_irq(irq); return 0; }
int atari_scsi_bus_reset(Scsi_Cmnd *cmd) { int rv; struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)cmd->device->host->hostdata; /* For doing the reset, SCSI interrupts must be disabled first, * since the 5380 raises its IRQ line while _RST is active and we * can't disable interrupts completely, since we need the timer. */ /* And abort a maybe active DMA transfer */ if (IS_A_TT()) { atari_turnoff_irq( IRQ_TT_MFP_SCSI ); #ifdef REAL_DMA tt_scsi_dma.dma_ctrl = 0; #endif /* REAL_DMA */ } else { atari_turnoff_irq( IRQ_MFP_FSCSI ); #ifdef REAL_DMA st_dma.dma_mode_status = 0x90; atari_dma_active = 0; atari_dma_orig_addr = NULL; #endif /* REAL_DMA */ } rv = NCR5380_bus_reset(cmd); /* Re-enable ints */ if (IS_A_TT()) { atari_turnon_irq( IRQ_TT_MFP_SCSI ); } else { atari_turnon_irq( IRQ_MFP_FSCSI ); } if ((rv & SCSI_RESET_ACTION) == SCSI_RESET_SUCCESS) falcon_release_lock_if_possible(hostdata); return( rv ); }
__initfunc(int atari_keyb_init(void)) { /* setup key map */ memcpy(key_maps[0], ataplain_map, sizeof(plain_map)); memcpy(key_maps[1], atashift_map, sizeof(plain_map)); memcpy(key_maps[4], atactrl_map, sizeof(plain_map)); memcpy(key_maps[5], atashift_ctrl_map, sizeof(plain_map)); memcpy(key_maps[8], ataalt_map, sizeof(plain_map)); /* Atari doesn't have an altgr_map, so we can reuse its memory for atashift_alt_map */ memcpy(key_maps[2], atashift_alt_map, sizeof(plain_map)); key_maps[9] = key_maps[2]; key_maps[2] = 0; /* ataaltgr_map */ memcpy(key_maps[12], atactrl_alt_map, sizeof(plain_map)); key_maps[13] = atashift_ctrl_alt_map; keymap_count = 8; /* say that we don't have an AltGr key */ keyboard_type = KB_84; kb_state.state = KEYBOARD; kb_state.len = 0; request_irq(IRQ_MFP_ACIA, keyboard_interrupt, IRQ_TYPE_SLOW, "keyboard/mouse/MIDI", keyboard_interrupt); atari_turnoff_irq(IRQ_MFP_ACIA); do { /* reset IKBD ACIA */ acia.key_ctrl = ACIA_RESET | (atari_switches & ATARI_SWITCH_IKBD) ? ACIA_RHTID : 0; (void)acia.key_ctrl; (void)acia.key_data; /* reset MIDI ACIA */ acia.mid_ctrl = ACIA_RESET | (atari_switches & ATARI_SWITCH_MIDI) ? ACIA_RHTID : 0; (void)acia.mid_ctrl; (void)acia.mid_data; /* divide 500kHz by 64 gives 7812.5 baud */ /* 8 data no parity 1 start 1 stop bit */ /* receive interrupt enabled */ /* RTS low (except if switch selected), transmit interrupt disabled */ acia.key_ctrl = (ACIA_DIV64|ACIA_D8N1S|ACIA_RIE) | ((atari_switches & ATARI_SWITCH_IKBD) ? ACIA_RHTID : ACIA_RLTID); acia.mid_ctrl = ACIA_DIV16 | ACIA_D8N1S | (atari_switches & ATARI_SWITCH_MIDI) ? ACIA_RHTID : 0; } /* make sure the interrupt line is up */ while ((mfp.par_dt_reg & 0x10) == 0); /* enable ACIA Interrupts */ mfp.active_edge &= ~0x10; atari_turnon_irq(IRQ_MFP_ACIA); ikbd_self_test = 1; ikbd_reset(); /* wait for a period of inactivity (here: 0.25s), then assume the IKBD's * self-test is finished */ self_test_last_rcv = jiffies; while (time_before(jiffies, self_test_last_rcv + HZ/4)) barrier(); /* if not incremented: no 0xf1 received */ if (ikbd_self_test == 1) printk( KERN_ERR "WARNING: keyboard self test failed!\n" ); ikbd_self_test = 0; ikbd_mouse_disable(); ikbd_joystick_disable(); atari_joystick_init(); return 0; }
int atari_add_isr(unsigned long source, isrfunc isr, int type, void *data, char *name) { int vector; source &= ~IRQ_MACHSPEC; if (type < IRQ_TYPE_SLOW || type > IRQ_TYPE_PRIO) { printk ("atari_add_isr: Bad irq type %d requested from %s\n", type, name ); return( 0 ); } if (!IS_VALID_INTNO(source)) { printk ("atari_add_isr: Unknown irq %ld requested from %s\n", source, name ); return( 0 ); } vector = IRQ_SOURCE_TO_VECTOR(source); /* * Check type/source combination: slow ints are (currently) * only possible for MFP-interrupts. */ if (type == IRQ_TYPE_SLOW && (source < STMFP_SOURCE_BASE || source >= SCC_SOURCE_BASE)) { printk ("atari_add_isr: Slow irq requested for non-MFP source %ld from %s\n", source, name ); return( 0 ); } if (vectors[vector] == bad_interrupt) { /* int has no handler yet */ irq_handler[source].isr = isr; irq_handler[source].data = data; irq_param[source].type = type; irq_param[source].name = name; vectors[vector] = (type == IRQ_TYPE_SLOW) ? slow_handlers[source-STMFP_SOURCE_BASE] : (type == IRQ_TYPE_FAST) ? atari_fast_irq_handler : atari_prio_irq_handler; /* If MFP int, also enable and umask it */ atari_turnon_irq(source); atari_enable_irq(source); return 1; } else if (irq_param[source].type == type) { /* old handler is of same type -> handlers can be chained */ isr_node_t *p; unsigned long flags; save_flags(flags); cli(); if (irq_handler[source].isr != atari_call_isr_list) { /* Only one handler yet, make a node for this first one */ p = new_isr_node(); if (p == NULL) return 0; p->isr = irq_handler[source].isr; p->data = irq_handler[source].data; p->name = irq_param[source].name; p->next = NULL; irq_handler[source].isr = atari_call_isr_list; irq_handler[source].data = p; irq_param[source].name = "chained"; } p = new_isr_node(); if (p == NULL) return 0; p->isr = isr; p->data = data; p->name = name; /* new handlers are put in front of the queue */ p->next = irq_handler[source].data; irq_handler[source].data = p; restore_flags(flags); return 1; } else { printk ("atari_add_isr: Irq %ld allocated by other type int (call from %s)\n", source, name ); return( 0 ); } }
int atari_keyb_init(void) { int error; if (atari_keyb_done) return 0; kb_state.state = KEYBOARD; kb_state.len = 0; error = request_irq(IRQ_MFP_ACIA, atari_keyboard_interrupt, IRQ_TYPE_SLOW, "keyboard,mouse,MIDI", atari_keyboard_interrupt); if (error) return error; atari_turnoff_irq(IRQ_MFP_ACIA); do { /* reset IKBD ACIA */ acia.key_ctrl = ACIA_RESET | ((atari_switches & ATARI_SWITCH_IKBD) ? ACIA_RHTID : 0); (void)acia.key_ctrl; (void)acia.key_data; /* reset MIDI ACIA */ acia.mid_ctrl = ACIA_RESET | ((atari_switches & ATARI_SWITCH_MIDI) ? ACIA_RHTID : 0); (void)acia.mid_ctrl; (void)acia.mid_data; /* divide 500kHz by 64 gives 7812.5 baud */ /* 8 data no parity 1 start 1 stop bit */ /* receive interrupt enabled */ /* RTS low (except if switch selected), transmit interrupt disabled */ acia.key_ctrl = (ACIA_DIV64|ACIA_D8N1S|ACIA_RIE) | ((atari_switches & ATARI_SWITCH_IKBD) ? ACIA_RHTID : ACIA_RLTID); acia.mid_ctrl = ACIA_DIV16 | ACIA_D8N1S | ((atari_switches & ATARI_SWITCH_MIDI) ? ACIA_RHTID : 0); /* make sure the interrupt line is up */ } while ((st_mfp.par_dt_reg & 0x10) == 0); /* enable ACIA Interrupts */ st_mfp.active_edge &= ~0x10; atari_turnon_irq(IRQ_MFP_ACIA); ikbd_self_test = 1; ikbd_reset(); /* wait for a period of inactivity (here: 0.25s), then assume the IKBD's * self-test is finished */ self_test_last_rcv = jiffies; while (time_before(jiffies, self_test_last_rcv + HZ/4)) barrier(); /* if not incremented: no 0xf1 received */ if (ikbd_self_test == 1) printk(KERN_ERR "WARNING: keyboard self test failed!\n"); ikbd_self_test = 0; ikbd_mouse_disable(); ikbd_joystick_disable(); #ifdef FIXED_ATARI_JOYSTICK atari_joystick_init(); #endif // flag init done atari_keyb_done = 1; return 0; }
int atari_request_irq(unsigned int irq, void (*handler)(int, void *, struct pt_regs *), unsigned long flags, const char *devname, void *dev_id) { int vector; unsigned long oflags = flags; /* * The following is a hack to make some PCI card drivers work, * which set the SA_SHIRQ flag. */ flags &= ~SA_SHIRQ; if (flags == SA_INTERRUPT) { printk ("%s: SA_INTERRUPT changed to IRQ_TYPE_SLOW for %s\n", __FUNCTION__, devname); flags = IRQ_TYPE_SLOW; } if (flags < IRQ_TYPE_SLOW || flags > IRQ_TYPE_PRIO) { printk ("%s: Bad irq type 0x%lx <0x%lx> requested from %s\n", __FUNCTION__, flags, oflags, devname); return -EINVAL; } if (!IS_VALID_INTNO(irq)) { printk ("%s: Unknown irq %d requested from %s\n", __FUNCTION__, irq, devname); return -ENXIO; } vector = IRQ_SOURCE_TO_VECTOR(irq); /* * Check type/source combination: slow ints are (currently) * only possible for MFP-interrupts. */ if (flags == IRQ_TYPE_SLOW && (irq < STMFP_SOURCE_BASE || irq >= SCC_SOURCE_BASE)) { printk ("%s: Slow irq requested for non-MFP source %d from %s\n", __FUNCTION__, irq, devname); return -EINVAL; } if (vectors[vector] == bad_interrupt) { /* int has no handler yet */ irq_handler[irq].handler = handler; irq_handler[irq].dev_id = dev_id; irq_param[irq].flags = flags; irq_param[irq].devname = devname; vectors[vector] = (flags == IRQ_TYPE_SLOW) ? slow_handlers[irq-STMFP_SOURCE_BASE] : (flags == IRQ_TYPE_FAST) ? atari_fast_irq_handler : atari_prio_irq_handler; /* If MFP int, also enable and umask it */ atari_turnon_irq(irq); atari_enable_irq(irq); return 0; } else if (irq_param[irq].flags == flags) { /* old handler is of same type -> handlers can be chained */ irq_node_t *node; unsigned long flags; save_flags(flags); cli(); if (irq_handler[irq].handler != atari_call_irq_list) { /* Only one handler yet, make a node for this first one */ if (!(node = new_irq_node())) return -ENOMEM; node->handler = irq_handler[irq].handler; node->dev_id = irq_handler[irq].dev_id; node->devname = irq_param[irq].devname; node->next = NULL; irq_handler[irq].handler = atari_call_irq_list; irq_handler[irq].dev_id = node; irq_param[irq].devname = "chained"; } if (!(node = new_irq_node())) return -ENOMEM; node->handler = handler; node->dev_id = dev_id; node->devname = devname; /* new handlers are put in front of the queue */ node->next = irq_handler[irq].dev_id; irq_handler[irq].dev_id = node; restore_flags(flags); return 0; } else { printk ("%s: Irq %d allocated by other type int (call from %s)\n", __FUNCTION__, irq, devname); return -EBUSY; } }
int atari_keyb_init(void) { int error; if (atari_keyb_done) return 0; kb_state.state = KEYBOARD; kb_state.len = 0; error = request_irq(IRQ_MFP_ACIA, atari_keyboard_interrupt, IRQ_TYPE_SLOW, "keyboard,mouse,MIDI", atari_keyboard_interrupt); if (error) return error; atari_turnoff_irq(IRQ_MFP_ACIA); do { acia.key_ctrl = ACIA_RESET | ((atari_switches & ATARI_SWITCH_IKBD) ? ACIA_RHTID : 0); (void)acia.key_ctrl; (void)acia.key_data; acia.mid_ctrl = ACIA_RESET | ((atari_switches & ATARI_SWITCH_MIDI) ? ACIA_RHTID : 0); (void)acia.mid_ctrl; (void)acia.mid_data; acia.key_ctrl = (ACIA_DIV64|ACIA_D8N1S|ACIA_RIE) | ((atari_switches & ATARI_SWITCH_IKBD) ? ACIA_RHTID : ACIA_RLTID); acia.mid_ctrl = ACIA_DIV16 | ACIA_D8N1S | ((atari_switches & ATARI_SWITCH_MIDI) ? ACIA_RHTID : 0); } while ((st_mfp.par_dt_reg & 0x10) == 0); st_mfp.active_edge &= ~0x10; atari_turnon_irq(IRQ_MFP_ACIA); ikbd_self_test = 1; ikbd_reset(); self_test_last_rcv = jiffies; while (time_before(jiffies, self_test_last_rcv + HZ/4)) barrier(); if (ikbd_self_test == 1) printk(KERN_ERR "WARNING: keyboard self test failed!\n"); ikbd_self_test = 0; ikbd_mouse_disable(); ikbd_joystick_disable(); #ifdef FIXED_ATARI_JOYSTICK atari_joystick_init(); #endif atari_keyb_done = 1; return 0; }