static void int2_unmask(struct irq_data *d) { u32 intmr2; intmr2 = clps_readl(INTMR2); intmr2 |= 1 << (d->irq - 16); clps_writel(intmr2, INTMR2); }
static void __init clps711x_timer_init(void) { struct timespec tv; unsigned int syscon; syscon = clps_readl(SYSCON1); syscon |= SYSCON1_TC2S | SYSCON1_TC2M; clps_writel(syscon, SYSCON1); clps_writel(LATCH-1, TC2D); /* 512kHz / 100Hz - 1 */ setup_irq(IRQ_TC2OI, &clps711x_timer_irq); tv.tv_nsec = 0; tv.tv_sec = clps_readl(RTCDR); do_settimeofday(&tv); }
static void clps711xuart_change_speed(struct uart_port *port, u_int cflag, u_int iflag, u_int quot) { u_int ubrlcr; unsigned long flags; #if DEBUG printk("clps711xuart_change_speed(cflag=0x%x, iflag=0x%x, quot=%d) called\n", cflag, iflag, quot); #endif /* byte size and parity */ switch (cflag & CSIZE) { case CS5: ubrlcr = UBRLCR_WRDLEN5; break; case CS6: ubrlcr = UBRLCR_WRDLEN6; break; case CS7: ubrlcr = UBRLCR_WRDLEN7; break; default: ubrlcr = UBRLCR_WRDLEN8; break; // CS8 } if (cflag & CSTOPB) ubrlcr |= UBRLCR_XSTOP; if (cflag & PARENB) { ubrlcr |= UBRLCR_PRTEN; if (!(cflag & PARODD)) ubrlcr |= UBRLCR_EVENPRT; } if (port->fifosize > 1) ubrlcr |= UBRLCR_FIFOEN; port->read_status_mask = UARTDR_OVERR; if (iflag & INPCK) port->read_status_mask |= UARTDR_PARERR | UARTDR_FRMERR; // if (iflag & (BRKINT | PARMRK)) // port->read_status_mask |= AMBA_UARTRSR_BE; /* * Characters to ignore */ port->ignore_status_mask = 0; if (iflag & IGNPAR) port->ignore_status_mask |= UARTDR_FRMERR | UARTDR_PARERR; if (iflag & IGNBRK) { // port->ignore_status_mask |= AMBA_UARTRSR_BE; /* * If we're ignoring parity and break indicators, * ignore overruns to (for real raw support). */ if (iflag & IGNPAR) port->ignore_status_mask |= UARTDR_OVERR; } quot -= 1; /* first, disable everything */ save_flags(flags); cli(); clps_writel(ubrlcr | quot, UBRLCR(port)); restore_flags(flags); }
static void uart_clps711x_shutdown(struct uart_port *port) { /* Free the interrupts */ devm_free_irq(port->dev, TX_IRQ(port), port); devm_free_irq(port->dev, RX_IRQ(port), port); /* Disable the port */ clps_writel(clps_readl(SYSCON(port)) & ~SYSCON_UARTEN, SYSCON(port)); }
void __init clps711x_init_irq(void) { unsigned int i; for (i = 0; i < NR_IRQS; i++) { if (INT1_IRQS & (1 << i)) { irq_desc[i].valid = 1; irq_desc[i].probe_ok = 1; irq_desc[i].mask_ack = (INT1_ACK_IRQS & (1 << i)) ? mask_ack_irq_int1 : mask_irq_int1; irq_desc[i].mask = mask_irq_int1; irq_desc[i].unmask = unmask_irq_int1; } if (INT2_IRQS & (1 << i)) { irq_desc[i].valid = 1; irq_desc[i].probe_ok = 1; irq_desc[i].mask_ack = (INT2_ACK_IRQS & (1 << i)) ? mask_ack_irq_int2 : mask_irq_int2; irq_desc[i].mask = mask_irq_int2; irq_desc[i].unmask = unmask_irq_int2; } } /* * Disable interrupts */ clps_writel(0, INTMR1); clps_writel(0, INTMR2); /* * Clear down any pending interrupts */ clps_writel(0, COEOI); clps_writel(0, TC1EOI); clps_writel(0, TC2EOI); clps_writel(0, RTCEOI); clps_writel(0, TEOI); clps_writel(0, UMSEOI); clps_writel(0, SYNCIO); clps_writel(0, KBDEOI); }
MACHINE_END static int guide_a07_hw_init(void) { /* in cs[1] (the FPGA), set zero wait states, clkenb, and sqaen */ u32 memcfg1 = 0xfc << 8; memcfg1 |= clps_readl(MEMCFG1); clps_writel(memcfg1, MEMCFG1); return 0; }
static void uart_clps711x_console_write(struct console *co, const char *c, unsigned n) { struct clps711x_port *s = (struct clps711x_port *)co->data; struct uart_port *port = &s->port[co->index]; u32 syscon; /* Ensure that the port is enabled */ syscon = clps_readl(SYSCON(port)); clps_writel(syscon | SYSCON_UARTEN, SYSCON(port)); uart_console_write(port, c, n, uart_clps711x_console_putchar); /* Wait for transmitter to become empty */ while (clps_readl(SYSFLG(port)) & SYSFLG_UBUSY) barrier(); /* Restore the uart state */ clps_writel(syscon, SYSCON(port)); }
static void clps711xuart_break_ctl(struct uart_port *port, int break_state) { unsigned int ubrlcr; ubrlcr = clps_readl(UBRLCR(port)); if (break_state == -1) ubrlcr |= UBRLCR_BREAK; else ubrlcr &= ~UBRLCR_BREAK; clps_writel(ubrlcr, UBRLCR(port)); }
static int ep7211_close(struct sir_dev *dev) { unsigned int syscon; /* Turn off the SIR encoder. */ syscon = clps_readl(SYSCON1); syscon &= ~SYSCON1_SIREN; clps_writel(syscon, SYSCON1); return 0; }
/* * Print a string to the serial port trying not to disturb * any possible real use of the port... * * The console_lock must be held when we get here. * * Note that this is called with interrupts already disabled */ static void clps711xuart_console_write(struct console *co, const char *s, unsigned int count) { struct uart_port *port = clps711x_ports + co->index; unsigned int status, syscon; int i; /* * Ensure that the port is enabled. */ syscon = clps_readl(SYSCON(port)); clps_writel(syscon | SYSCON_UARTEN, SYSCON(port)); /* * Now, do each character */ for (i = 0; i < count; i++) { do { status = clps_readl(SYSFLG(port)); } while (status & SYSFLG_UTXFF); clps_writel(s[i], UARTDR(port)); if (s[i] == '\n') { do { status = clps_readl(SYSFLG(port)); } while (status & SYSFLG_UTXFF); clps_writel('\r', UARTDR(port)); } } /* * Finally, wait for transmitter to become empty * and restore the uart state. */ do { status = clps_readl(SYSFLG(port)); } while (status & SYSFLG_UBUSY); clps_writel(syscon, SYSCON(port)); }
static void clps711xuart_break_ctl(struct uart_port *port, int break_state) { unsigned long flags; unsigned int ubrlcr; spin_lock_irqsave(&port->lock, flags); ubrlcr = clps_readl(UBRLCR(port)); if (break_state == -1) ubrlcr |= UBRLCR_BREAK; else ubrlcr &= ~UBRLCR_BREAK; clps_writel(ubrlcr, UBRLCR(port)); spin_unlock_irqrestore(&port->lock, flags); }
static void clps711xuart_int_tx(int irq, void *dev_id, struct pt_regs *regs) { struct uart_info *info = dev_id; struct uart_port *port = info->port; int count; if (port->x_char) { clps_writel(port->x_char, UARTDR(port)); port->icount.tx++; port->x_char = 0; return; } if (info->xmit.head == info->xmit.tail || info->tty->stopped || info->tty->hw_stopped) { clps711xuart_stop_tx(info->port, 0); return; } count = port->fifosize >> 1; do { clps_writel(info->xmit.buf[info->xmit.tail], UARTDR(port)); info->xmit.tail = (info->xmit.tail + 1) & (UART_XMIT_SIZE - 1); port->icount.tx++; if (info->xmit.head == info->xmit.tail) break; } while (--count > 0); if (CIRC_CNT(info->xmit.head, info->xmit.tail, UART_XMIT_SIZE) < WAKEUP_CHARS) uart_event(info, EVT_WRITE_WAKEUP); if (info->xmit.head == info->xmit.tail) clps711xuart_stop_tx(info->port, 0); }
static void clps711xuart_shutdown(struct uart_port *port) { unsigned int ubrlcr, syscon; /* * Free the interrupt */ free_irq(TX_IRQ(port), port); /* TX interrupt */ free_irq(RX_IRQ(port), port); /* RX interrupt */ /* * disable the port */ syscon = clps_readl(SYSCON(port)); syscon &= ~SYSCON_UARTEN; clps_writel(syscon, SYSCON(port)); /* * disable break condition and fifos */ ubrlcr = clps_readl(UBRLCR(port)); ubrlcr &= ~(UBRLCR_FIFOEN | UBRLCR_BREAK); clps_writel(ubrlcr, UBRLCR(port)); }
static irqreturn_t clps711xuart_int_tx(int irq, void *dev_id) { struct uart_port *port = dev_id; struct circ_buf *xmit = &port->state->xmit; int count; if (port->x_char) { clps_writel(port->x_char, UARTDR(port)); port->icount.tx++; port->x_char = 0; return IRQ_HANDLED; } if (uart_circ_empty(xmit) || uart_tx_stopped(port)) goto disable_tx_irq; count = port->fifosize >> 1; do { clps_writel(xmit->buf[xmit->tail], UARTDR(port)); xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); port->icount.tx++; if (uart_circ_empty(xmit)) break; } while (--count > 0); if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) uart_write_wakeup(port); if (uart_circ_empty(xmit)) { disable_tx_irq: disable_irq_nosync(TX_IRQ(port)); tx_enabled(port) = 0; } return IRQ_HANDLED; }
static void ep7211_ir_open(dongle_t *self, struct qos_info *qos) { unsigned int syscon1, flags; spin_lock_irqsave(&ep7211_lock, flags); /* Turn on the SIR encoder. */ syscon1 = clps_readl(SYSCON1); syscon1 |= SYSCON1_SIREN; clps_writel(syscon1, SYSCON1); /* XXX: We should disable modem status interrupts on the first UART (interrupt #14). */ spin_unlock_irqrestore(&ep7211_lock, flags); }
static void ep7211_ir_close(dongle_t *self) { unsigned int syscon1, flags; spin_lock_irqsave(&ep7211_lock, flags); /* Turn off the SIR encoder. */ syscon1 = clps_readl(SYSCON1); syscon1 &= ~SYSCON1_SIREN; clps_writel(syscon1, SYSCON1); /* XXX: If we've disabled the modem status interrupts, we should reset them back to their original state. */ spin_unlock_irqrestore(&ep7211_lock, flags); }
static void int1_eoi(struct irq_data *d) { switch (d->irq) { case IRQ_CSINT: clps_writel(0, COEOI); break; case IRQ_TC1OI: clps_writel(0, TC1EOI); break; case IRQ_TC2OI: clps_writel(0, TC2EOI); break; case IRQ_RTCMI: clps_writel(0, RTCEOI); break; case IRQ_TINT: clps_writel(0, TEOI); break; case IRQ_UMSINT: clps_writel(0, UMSEOI); break; } }
static void ep7211_ir_close(dongle_t *self) { unsigned int syscon1, flags; save_flags(flags); cli(); /* Turn off the SIR encoder. */ syscon1 = clps_readl(SYSCON1); syscon1 &= ~SYSCON1_SIREN; clps_writel(syscon1, SYSCON1); /* XXX: If we've disabled the modem status interrupts, we should reset them back to their original state. */ restore_flags(flags); MOD_DEC_USE_COUNT; }
static void ep7211_ir_open(dongle_t *self, struct qos_info *qos) { unsigned int syscon1, flags; save_flags(flags); cli(); /* Turn on the SIR encoder. */ syscon1 = clps_readl(SYSCON1); syscon1 |= SYSCON1_SIREN; clps_writel(syscon1, SYSCON1); /* XXX: We should disable modem status interrupts on the first UART (interrupt #14). */ restore_flags(flags); MOD_INC_USE_COUNT; }
static void int1_ack(unsigned int irq) { u32 intmr1; intmr1 = clps_readl(INTMR1); intmr1 &= ~(1 << irq); clps_writel(intmr1, INTMR1); switch (irq) { case IRQ_CSINT: clps_writel(0, COEOI); break; case IRQ_TC1OI: clps_writel(0, TC1EOI); break; case IRQ_TC2OI: clps_writel(0, TC2EOI); break; case IRQ_RTCMI: clps_writel(0, RTCEOI); break; case IRQ_TINT: clps_writel(0, TEOI); break; case IRQ_UMSINT: clps_writel(0, UMSEOI); break; } }
static void clps711xuart_console_putchar(struct uart_port *port, int ch) { while (clps_readl(SYSFLG(port)) & SYSFLG_UTXFF) barrier(); clps_writel(ch, UARTDR(port)); }
static void clps711xuart_set_termios(struct uart_port *port, struct ktermios *termios, struct ktermios *old) { unsigned int ubrlcr, baud, quot; unsigned long flags; /* * We don't implement CREAD. */ termios->c_cflag |= CREAD; /* * Ask the core to calculate the divisor for us. */ baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16); quot = uart_get_divisor(port, baud); switch (termios->c_cflag & CSIZE) { case CS5: ubrlcr = UBRLCR_WRDLEN5; break; case CS6: ubrlcr = UBRLCR_WRDLEN6; break; case CS7: ubrlcr = UBRLCR_WRDLEN7; break; default: // CS8 ubrlcr = UBRLCR_WRDLEN8; break; } if (termios->c_cflag & CSTOPB) ubrlcr |= UBRLCR_XSTOP; if (termios->c_cflag & PARENB) { ubrlcr |= UBRLCR_PRTEN; if (!(termios->c_cflag & PARODD)) ubrlcr |= UBRLCR_EVENPRT; } if (port->fifosize > 1) ubrlcr |= UBRLCR_FIFOEN; spin_lock_irqsave(&port->lock, flags); /* * Update the per-port timeout. */ uart_update_timeout(port, termios->c_cflag, baud); port->read_status_mask = UARTDR_OVERR; if (termios->c_iflag & INPCK) port->read_status_mask |= UARTDR_PARERR | UARTDR_FRMERR; /* * Characters to ignore */ port->ignore_status_mask = 0; if (termios->c_iflag & IGNPAR) port->ignore_status_mask |= UARTDR_FRMERR | UARTDR_PARERR; if (termios->c_iflag & IGNBRK) { /* * If we're ignoring parity and break indicators, * ignore overruns to (for real raw support). */ if (termios->c_iflag & IGNPAR) port->ignore_status_mask |= UARTDR_OVERR; } quot -= 1; clps_writel(ubrlcr | quot, UBRLCR(port)); spin_unlock_irqrestore(&port->lock, flags); }
static void edb7211_lcd_backlight_set_intensity(int intensity) { gpio_set_value(EDB7211_LCDBL, !!intensity); clps_writel((clps_readl(PMPCON) & 0xf0ff) | (intensity << 8), PMPCON); }
static void uart_clps711x_set_termios(struct uart_port *port, struct ktermios *termios, struct ktermios *old) { unsigned int ubrlcr, baud, quot; unsigned long flags; /* Mask termios capabilities we don't support */ termios->c_cflag &= ~CMSPAR; termios->c_iflag &= ~(BRKINT | IGNBRK); /* Ask the core to calculate the divisor for us */ baud = uart_get_baud_rate(port, termios, old, port->uartclk / 4096, port->uartclk / 16); quot = uart_get_divisor(port, baud); switch (termios->c_cflag & CSIZE) { case CS5: ubrlcr = UBRLCR_WRDLEN5; break; case CS6: ubrlcr = UBRLCR_WRDLEN6; break; case CS7: ubrlcr = UBRLCR_WRDLEN7; break; case CS8: default: ubrlcr = UBRLCR_WRDLEN8; break; } if (termios->c_cflag & CSTOPB) ubrlcr |= UBRLCR_XSTOP; if (termios->c_cflag & PARENB) { ubrlcr |= UBRLCR_PRTEN; if (!(termios->c_cflag & PARODD)) ubrlcr |= UBRLCR_EVENPRT; } /* Enable FIFO */ ubrlcr |= UBRLCR_FIFOEN; spin_lock_irqsave(&port->lock, flags); /* Set read status mask */ port->read_status_mask = UARTDR_OVERR; if (termios->c_iflag & INPCK) port->read_status_mask |= UARTDR_PARERR | UARTDR_FRMERR; /* Set status ignore mask */ port->ignore_status_mask = 0; if (!(termios->c_cflag & CREAD)) port->ignore_status_mask |= UARTDR_OVERR | UARTDR_PARERR | UARTDR_FRMERR; uart_update_timeout(port, termios->c_cflag, baud); clps_writel(ubrlcr | (quot - 1), UBRLCR(port)); spin_unlock_irqrestore(&port->lock, flags); }
static void int2_eoi(struct irq_data *d) { switch (d->irq) { case IRQ_KBDINT: clps_writel(0, KBDEOI); break; } }