static void xmbrs_flush_chars(struct tty_struct *tty) { volatile unsigned int *uartp; struct xmb_serial *info = (struct xmb_serial *)tty->driver_data; unsigned long flags; if (serial_paranoia_check(info, tty->device, "xmbrs_flush_chars")) return; uartp = (volatile unsigned int *) info->addr; EnableInterrupts(uartp); /* If there are chars waiting in RX buffer then enable interrupt to permit receiving them */ save_flags_cli(flags); if ( (uartp[XUL_STATUS_REG_OFFSET/4] & XUL_SR_RX_FIFO_VALID_DATA) && (info->flags & ASYNC_INITIALIZED) ) { EnableInterrupts(uartp); } /* Any chars pending to go out (and tty not stopped etc)? */ if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped || !info->xmit_buf) return; /* Force remaining chars out */ save_flags_cli(flags); EnableInterrupts(uartp); force_tx_fifo_fill(info); restore_flags(flags); }
static ssize_t fsl_read(struct file *f, char *buf, size_t count, loff_t *pos) { struct fsl_fifo_t *fsl_fifo=(struct fsl_fifo_t *)f->private_data; unsigned flags; int total=0; if(!fsl_fifo->exists) return -ENODEV; save_flags_cli(flags); /* Block until there's some data in the buffer */ while(!fsl_fifo->rx_cnt) { restore_flags(flags); tasklet_schedule(&fsl_read_tasklet); interruptible_sleep_on(&fsl_read_queue); if(current->sigpending) { return -EINTR; } save_flags_cli(flags); } while(1) { int c; cli(); c = MIN(count, MIN(fsl_fifo->rx_cnt, FSLFIFO_BUF_SIZE - fsl_fifo->rx_tail)); if(c<=0) { restore_flags(flags); break; } copy_to_user(buf, fsl_fifo->rx_buf+fsl_fifo->rx_tail,c); /* Update the buffer data structure */ fsl_fifo->rx_cnt-=c; fsl_fifo->rx_tail+=c; fsl_fifo->rx_tail &= FSLFIFO_BUF_SIZE-1; restore_flags(flags); buf += c; count -= c; total += c; } if(count) tasklet_schedule(&fsl_read_tasklet); return total; }
static int h3600_stowaway_startup(struct skbd_state *skbd) { unsigned long flags; int retval = 0; SFDEBUG(1,"\n"); save_flags_cli(flags); h3600_stowaway_reset_comm(); /* Direction registers */ GPDR |= GPIO_H3600_COM_RTS; GPDR &= ~GPIO_H3600_COM_DCD; set_GPIO_IRQ_edge( GPIO_H3600_COM_DCD, GPIO_RISING_EDGE ); /* Timer structure */ init_timer(&skbd->timer); skbd->timer.function = h3600_stowaway_timer_callback; skbd->timer.data = (unsigned long) skbd; retval = request_irq(IRQ_GPIO_H3600_COM_DCD, h3600_stowaway_handshake_interrupt, SA_SHIRQ | SA_INTERRUPT | SA_SAMPLE_RANDOM, "Stowaway DCD", (void *)skbd); if ( !retval ) retval = request_irq( IRQ_Ser3UART, h3600_stowaway_data_interrupt, SA_SHIRQ | SA_INTERRUPT | SA_SAMPLE_RANDOM, "Stowaway data", (void *)skbd); restore_flags(flags); return retval; }
/* * hacked from linux/include/asm-arm/arch-sa1100/time.h * static void sa1100_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs) */ static void linux_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs) { #ifdef CONFIG_RTAI_ARM_OLD long flags; int next_match; do { //do_leds(); save_flags_cli(flags); do_timer(regs); OSSR = OSSR_M0; next_match = (OSMR0 += LATCH); rthal.timer_match = next_match; restore_flags(flags); } while((signed long)(next_match - OSCR) <= 0); #else int next_match; do { do_timer(regs); OSSR = OSSR_M0; next_match = (OSMR0 += LATCH); } while((signed long) (next_match - OSCR) <= 0); #endif }
static void ether3_timeout(struct net_device *dev) { struct dev_priv *priv = (struct dev_priv *)dev->priv; unsigned long flags; del_timer(&priv->timer); save_flags_cli(flags); printk(KERN_ERR "%s: transmit timed out, network cable problem?\n", dev->name); printk(KERN_ERR "%s: state: { status=%04X cfg1=%04X cfg2=%04X }\n", dev->name, ether3_inw(REG_STATUS), ether3_inw(REG_CONFIG1), ether3_inw(REG_CONFIG2)); printk(KERN_ERR "%s: { rpr=%04X rea=%04X tpr=%04X }\n", dev->name, ether3_inw(REG_RECVPTR), ether3_inw(REG_RECVEND), ether3_inw(REG_TRANSMITPTR)); printk(KERN_ERR "%s: tx head=%X tx tail=%X\n", dev->name, priv->tx_head, priv->tx_tail); ether3_setbuffer(dev, buffer_read, priv->tx_tail); printk(KERN_ERR "%s: packet status = %08X\n", dev->name, ether3_readlong(dev)); restore_flags(flags); priv->regs.config2 |= CFG2_CTRLO; priv->stats.tx_errors += 1; ether3_outw(priv->regs.config2, REG_CONFIG2); priv->tx_head = priv->tx_tail = 0; netif_wake_queue(dev); }
static ssize_t state_write(struct file *filp, const char *source, size_t count, loff_t *ppos) { struct state_dev *dev = filp->private_data; unsigned long flags; unsigned char *temp; if (count > STATE_BLOCK_SIZE || count <= 0) return -EINVAL; copy_from_user_ret(dev->write_buffer, source, count, -EFAULT); if (hijack_force_pause_player) { dev->write_buffer[0x0c] &= ~0x02; } /* Now we've written, switch the buffers and copy */ save_flags_cli(flags); temp = dev->read_buffer; dev->read_buffer = dev->write_buffer; dev->write_buffer = temp; /* Mark as dirty */ dirty=1; restore_flags(flags); memcpy(dev->write_buffer, dev->read_buffer, count); return count; }
/* * Transmit a packet */ static int ether3_sendpacket(struct sk_buff *skb, struct net_device *dev) { struct dev_priv *priv = (struct dev_priv *)dev->priv; unsigned long flags; unsigned int length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN; unsigned int ptr, next_ptr; length = (length + 1) & ~1; if (priv->broken) { dev_kfree_skb(skb); priv->stats.tx_dropped ++; netif_start_queue(dev); return 0; } next_ptr = (priv->tx_head + 1) & 15; save_flags_cli(flags); if (priv->tx_tail == next_ptr) { restore_flags(flags); return 1; /* unable to queue */ } dev->trans_start = jiffies; ptr = 0x600 * priv->tx_head; priv->tx_head = next_ptr; next_ptr *= 0x600; #define TXHDR_FLAGS (TXHDR_TRANSMIT|TXHDR_CHAINCONTINUE|TXHDR_DATAFOLLOWS|TXHDR_ENSUCCESS) ether3_setbuffer(dev, buffer_write, next_ptr); ether3_writelong(dev, 0); ether3_setbuffer(dev, buffer_write, ptr); ether3_writelong(dev, 0); ether3_writebuffer(dev, skb->data, length); ether3_writeword(dev, htons(next_ptr)); ether3_writeword(dev, TXHDR_CHAINCONTINUE >> 16); ether3_setbuffer(dev, buffer_write, ptr); ether3_writeword(dev, htons((ptr + length + 4))); ether3_writeword(dev, TXHDR_FLAGS >> 16); ether3_ledon(dev, priv); if (!(ether3_inw(REG_STATUS) & STAT_TXON)) { ether3_outw(ptr, REG_TRANSMITPTR); ether3_outw(priv->regs.command | CMD_TXON, REG_COMMAND); } next_ptr = (priv->tx_head + 1) & 15; restore_flags(flags); dev_kfree_skb(skb); if (priv->tx_tail == next_ptr) netif_stop_queue(dev); return 0; }
void xmbrs_put_char(char ch) { volatile unsigned int *uartp, out_word=ch; unsigned long flags; int i; uartp = (volatile unsigned int *) CONFIG_XILINX_UARTLITE_0_BASEADDR; save_flags_cli(flags); /* wait for tx buffer not full */ for (i = 0; (i < 0x10000); i++) { if (!(uartp[XUL_STATUS_REG_OFFSET/4] & XUL_SR_TX_FIFO_FULL)) break; } /* Did it drain? */ if (i < 0x10000) { /* Send the char */ uartp[XUL_TX_FIFO_OFFSET/4]=out_word; /* Wait for it to go */ for (i = 0; (i < 0x10000); i++) if (!(uartp[XUL_STATUS_REG_OFFSET/4] & XUL_SR_TX_FIFO_FULL)) break; } /* Was it sent? */ if (i >= 0x10000) xmbrs_init_console(); /* try and get it back */ restore_flags(flags); return; }
/* * This routine will shutdown a serial port; interrupts are disabled, and * DTR is dropped if the hangup on close termio flag is on. */ static void shutdown(struct xmb_serial * info) { volatile unsigned int *uartp; unsigned long flags; if (!(info->flags & ASYNC_INITIALIZED)) return; #ifdef SERIAL_DEBUG_OPEN printk("Shutting down serial port %d (irq %d)....\n", info->line, info->irq); #endif uartp = (volatile unsigned int *) info->addr; save_flags_cli(flags); /* Disable interrupts */ /* Disable interrupts and clear RX FIFO */ DisableInterrupts(uartp); Reset_RX_FIFO(uartp); if (info->xmit_buf) { free_page((unsigned long) info->xmit_buf); info->xmit_buf = 0; } if (info->tty) set_bit(TTY_IO_ERROR, &info->tty->flags); info->flags &= ~ASYNC_INITIALIZED; restore_flags(flags); }
static void powerfail_reenabled_timeout(unsigned long unused) { /* If we get here then the power returned a while ago and we reenabled * stuff. */ struct state_dev *dev = state_devices; unsigned long dis; save_flags_cli(dis); if (erroneous_interrupts) { #if DEBUG printk("The power interrupt is happening too often. Can't enable it.\n"); #endif if (timer_pending(&dev->powerfail_timer)) del_timer(&dev->powerfail_timer); dev->powerfail_timer.expires = jiffies + POWERFAIL_TIMEOUT * HZ; dev->powerfail_timer.function = powerfail_reenabled_timeout; add_timer(&dev->powerfail_timer); erroneous_interrupts = 0; } else { #if DEBUG printk("The power hasn't failed for a while - reenabling actions.\n"); #endif if (timer_pending(&dev->powerfail_timer)) del_timer(&dev->powerfail_timer); enable_powerfail(TRUE); } restore_flags(dis); }
static int h3600_single_sleeve_pcmcia_configure_socket( const struct pcmcia_configure *configure ) { unsigned long flags; int sock = configure->sock; if(sock>1) return -1; if (0) printk(__FUNCTION__ ": socket=%d vcc=%d vpp=%d reset=%d\n", sock, configure->vcc, configure->vpp, configure->reset); save_flags_cli(flags); switch (configure->vcc) { case 0: break; case 50: case 33: break; default: printk(KERN_ERR "%s(): unrecognized Vcc %u\n", __FUNCTION__, configure->vcc); restore_flags(flags); return -1; } assign_h3600_egpio( IPAQ_EGPIO_CARD_RESET, configure->reset ); restore_flags(flags); return 0; }
static void xmbrs_unthrottle(struct tty_struct * tty) { struct xmb_serial *info = (struct xmb_serial *)tty->driver_data; #ifdef SERIAL_DEBUG_THROTTLE char buf[64]; printk("unthrottle %s: %d....\n", _tty_name(tty, buf), tty->ldisc.chars_in_buffer(tty)); #endif if (serial_paranoia_check(info, tty->device, "xmbrs_unthrottle")) return; if (I_IXOFF(tty)) { if (info->x_char) info->x_char = 0; else { /* Force START_CHAR (xon) out */ volatile unsigned int *uartp; unsigned long flags; info->x_char = START_CHAR(tty); uartp = (volatile unsigned int *) info->addr; save_flags_cli(flags); EnableInterrupts(uartp); force_tx_fifo_fill(info); restore_flags(flags); } } }
UINT32 intLock( void ) { // Disables ARM IRQ interrupt UINT32 irqlevel; save_flags_cli(irqlevel); return irqlevel; }
void kfree(void *ptr) { uint32_t flags; save_flags_cli(flags); tlsf_free(g_kheap, ptr); restore_flags(flags); }
static void powerfail_disabled_timeout(unsigned long unused) { /* If we get here then a powerfail interrupt happened but the * power didn't actually go away within a sensible amount of * time. So, if the voltage has gone back up above the * threshold we reenable the interrupt and wait for a bit * longer. If the voltage hasn't gone back up enough we just * reschedule ourselves to take a look at it again in a little * while. */ struct state_dev *dev = state_devices; unsigned long dis; #if DEBUG printk("The power doesn't seem to have gone away after all.\n"); #endif #ifdef CONFIG_EMPEG_DISPLAY /* Re-enable powerfail processing */ display_powerreturn_action(); #endif save_flags_cli(dis); /* Reenable DACs */ GPSR=EMPEG_DSPPOM; if (timer_pending(&dev->powerfail_timer)) del_timer(&dev->powerfail_timer); if (GPLR & EMPEG_POWERFAIL) { /* It's high, so we're lower than 10 volts. Just * reschedule ourselves to take another look at it * later. */ dev->powerfail_timer.expires = jiffies + POWERFAIL_TIMEOUT * HZ; dev->powerfail_timer.function = powerfail_disabled_timeout; add_timer(&dev->powerfail_timer); #if DEBUG printk("The voltage is still too low, not reenabling powerfail.\n"); #endif } else { #if DEBUG printk("The voltage has gone high enough, reenabling powerfail tentatitively.\n"); #endif /* It's low, so we've gone back to above 10 volts. Reenable the * interrupt and schedule the reenable function so that it can check * we haven't had any spurious interrupts too often. */ dev->powerfail_timer.expires = jiffies + REENABLE_TIMEOUT * HZ; dev->powerfail_timer.function = powerfail_reenabled_timeout; add_timer(&dev->powerfail_timer); erroneous_interrupts = 0; } restore_flags(dis); }
/* Forced cleanse routine, usually called just before a software-initiated powerdown */ extern void state_cleanse(void) { /* Is the state dirty? Flush it if it is */ if (dirty) { unsigned long flags; save_flags_cli(flags); state_store(); restore_flags(flags); } }
static void anakin_stop_rx(struct uart_port *port) { unsigned long flags; save_flags_cli(flags); while (anakin_in(port, 0x10) & RXRELEASE) anakin_in(port, 0x14); anakin_out(port, 0x18, anakin_in(port, 0x18) | BLOCKRX); restore_flags(flags); }
static void update_clk (int set, int mask) { unsigned long flags; int val; save_flags_cli (flags); val = __raw_readl (S3C2410_CLKCON); val = (val & ~mask) ^ set; restore_flags (flags); }
void *kmalloc(size_t bytes) { uint32_t flags; void *ptr; save_flags_cli(flags); ptr = tlsf_malloc(g_kheap, bytes); restore_flags(flags); return ptr; }
void *krealloc(void *oldptr, size_t bytes) { uint32_t flags; void *ptr; save_flags_cli(flags); ptr = tlsf_realloc(g_kheap, oldptr, bytes); restore_flags(flags); return ptr; }
void *kmemalign(size_t align, size_t bytes) { uint32_t flags; void *ptr; save_flags_cli(flags); ptr = tlsf_memalign(g_kheap, align, bytes); restore_flags(flags); return ptr; }
static void h3600_stowaway_shutdown(struct skbd_state * skbd) { unsigned long flags; SFDEBUG(1,"\n"); del_timer(&skbd->timer); save_flags_cli(flags); free_irq(IRQ_GPIO_H3600_COM_DCD, (void *)skbd); free_irq(IRQ_Ser3UART, (void *)skbd); restore_flags(flags); }
static int cerf_pcmcia_configure_socket(const struct pcmcia_configure *configure) { unsigned long flags; if(configure->sock>1) return -1; #ifdef CONFIG_SA1100_CERF_CPLD if(configure->sock==1) #else if(configure->sock==0) #endif return 0; save_flags_cli(flags); switch(configure->vcc){ case 0: break; case 50: case 33: #ifdef CONFIG_SA1100_CERF_CPLD GPCR = GPIO_PWR_SHUTDOWN; #endif break; default: printk(KERN_ERR "%s(): unrecognized Vcc %u\n", __FUNCTION__, configure->vcc); restore_flags(flags); return -1; } if(configure->reset) { #ifdef CONFIG_SA1100_CERF_CPLD GPSR = GPIO_CF_RESET; #endif } else { #ifdef CONFIG_SA1100_CERF_CPLD GPCR = GPIO_CF_RESET; #endif } restore_flags(flags); return 0; }
static void xmbrs_start(struct tty_struct *tty) { volatile unsigned int *uartp; struct xmb_serial *info = (struct xmb_serial *)tty->driver_data; unsigned long flags; if (serial_paranoia_check(info, tty->device, "xmbrs_start")) return; uartp = (volatile unsigned int *) info->addr; save_flags_cli(flags); EnableInterrupts(uartp); restore_flags(flags); }
static int pangolin_pcmcia_configure_socket(const struct pcmcia_configure *configure) { unsigned long value, flags; if(configure->sock>1) return -1; #ifndef CONFIG_SA1100_PANGOLIN_PCMCIA_IDE if(configure->sock==0) return 0; #endif save_flags_cli(flags); /* Murphy: BUS_ON different from POWER ? */ switch(configure->vcc){ case 0: break; #ifndef CONFIG_SA1100_PANGOLIN_PCMCIA_IDE case 50: printk(KERN_WARNING "%s(): CS asked for 5V, applying 3.3V...\n", __FUNCTION__); case 33: /* Can only apply 3.3V to the CF slot. */ break; #else case 50: printk(KERN_WARNING "%s(): CS asked for 5V, determinded by jumper setting...\n", __FUNCTION__); break; case 33: printk(KERN_WARNING "%s(): CS asked for 3.3V, determined by jumper setting...\n", __FUNCTION__); break; #endif default: printk(KERN_ERR "%s(): unrecognized Vcc %u\n", __FUNCTION__, configure->vcc); restore_flags(flags); return -1; } #ifdef CONFIG_SA1100_PANGOLIN_PCMCIA_IDE /* reset & unreset request */ if(configure->sock==0) { if(configure->reset) { GPSR |= GPIO_PCMCIA_RESET; } else { GPCR |= GPIO_PCMCIA_RESET; } } #endif /* Silently ignore Vpp, output enable, speaker enable. */ restore_flags(flags); return 0; }
static void anakin_change_speed(struct uart_port *port, u_int cflag, u_int iflag, u_int quot) { unsigned int flags; save_flags_cli(flags); while (!(anakin_in(port, 0x10) & TXEMPTY)); anakin_out(port, 0x10, (anakin_in(port, 0x10) & ~PRESCALER) | (quot << 3)); //parity always set to none anakin_out(port, 0x18, anakin_in(port, 0x18) & ~PARITY); restore_flags(flags); }
static int h3600_dual_sleeve_pcmcia_configure_socket( const struct pcmcia_configure *configure ) { unsigned long flags; unsigned int prc; int sock = configure->sock; if(sock>1) return -1; if (0) printk(__FUNCTION__ ": socket=%d vcc=%d vpp=%d reset=%d\n", sock, configure->vcc, configure->vpp, configure->reset); prc = (LINKUP_PRC_APOE | LINKUP_PRC_SOE | LINKUP_PRC_S1 | LINKUP_PRC_S2 | (sock * LINKUP_PRC_SSP)); save_flags_cli(flags); /* Linkup Systems L1110 with TI TPS2205 PCMCIA Power Switch */ /* S1 is VCC5#, S2 is VCC3# */ /* S3 is VPP_VCC, S4 is VPP_PGM */ /* PWR_ON is wired to #SHDN */ switch (configure->vcc) { case 0: break; case 50: prc &= ~LINKUP_PRC_S1; break; case 33: prc &= ~LINKUP_PRC_S2; break; default: printk(KERN_ERR "%s(): unrecognized Vcc %u\n", __FUNCTION__, configure->vcc); restore_flags(flags); return -1; } if (configure->vpp == 12) { prc |= LINKUP_PRC_S4; } else if (configure->vpp == configure->vcc) { prc |= LINKUP_PRC_S3; } if (configure->reset) prc |= LINKUP_PRC_RESET; writel(prc, &dual_pcmcia_sleeve[sock]->prc); restore_flags(flags); return 0; }
/* Prototype: void eesoxscsi_terminator_ctl(*host, on_off) * Purpose : Turn the EESOX SCSI terminators on or off * Params : host - card to turn on/off * : on_off - !0 to turn on, 0 to turn off */ static void eesoxscsi_terminator_ctl(struct Scsi_Host *host, int on_off) { EESOXScsi_Info *info = (EESOXScsi_Info *)host->hostdata; unsigned long flags; save_flags_cli(flags); if (on_off) info->control.control |= EESOX_TERM_ENABLE; else info->control.control &= ~EESOX_TERM_ENABLE; restore_flags(flags); outb(info->control.control, info->control.io_port); }
/* * get_lsr_info - get line status register info * * Purpose: Let user call ioctl() to get info when the UART physically * is emptied. On bus types like RS485, the transmitter must * release the bus after transmitting. This must be done when * the transmit shift register is empty, not be done when the * transmit holding register is empty. This functionality * allows an RS485 driver to be written in user space. */ static int get_lsr_info(struct xmb_serial * info, unsigned int *value) { volatile unsigned int *uartp; unsigned long flags; unsigned char status; uartp = (volatile unsigned int *) info->addr; save_flags_cli(flags); /* FIXME */ status = (uartp[XUL_STATUS_REG_OFFSET/4] & XUL_SR_TX_FIFO_EMPTY) ? TIOCSER_TEMT : 0; restore_flags(flags); put_user(status,value); return 0; }
static void console_printf(const char *fmt,...) { static char buffer[2048]; /* Arbitary! */ extern void console_print(const char *); unsigned long flags; va_list ap; save_flags_cli(flags); va_start(ap, fmt); vsprintf(buffer, fmt, ap); console_print(buffer); va_end(fmt); restore_flags(flags); }; /* console_printf */