static void hvsi_close(struct tty_struct *tty, struct file *filp)
{
struct hvsi_struct *hp = tty->driver_data;
unsigned long flags;
pr_debug("%s\n", __func__);
if (tty_hung_up_p(filp))
return;
spin_lock_irqsave(&hp->lock, flags);
if (--hp->count == 0) {
hp->tty = NULL;
hp->inbuf_end = hp->inbuf; /* discard remaining partial packets */
/* only close down connection if it is not the console */
if (!is_console(hp)) {
h_vio_signal(hp->vtermno, VIO_IRQ_DISABLE); /* no more irqs */
__set_state(hp, HVSI_CLOSED);
/*
* any data delivered to the tty layer after this will be
* discarded (except for XON/XOFF)
*/
tty->closing = 1;
spin_unlock_irqrestore(&hp->lock, flags);
/* let any existing irq handlers finish. no more will start. */
synchronize_irq(hp->virq);
/* hvsi_write_worker will re-schedule until outbuf is empty. */
hvsi_flush_output(hp);
/* tell FSP to stop sending data */
hvsi_close_protocol(hp);
/*
* drain anything FSP is still in the middle of sending, and let
* hvsi_handshake drain the rest on the next open.
*/
hvsi_drain_input(hp);
spin_lock_irqsave(&hp->lock, flags);
}
} else if (hp->count < 0)
printk(KERN_ERR "hvsi_close %lu: oops, count is %d\n",
hp - hvsi_ports, hp->count);
spin_unlock_irqrestore(&hp->lock, flags);
}
static int hvsi_open(struct tty_struct *tty, struct file *filp)
{
struct hvsi_struct *hp;
unsigned long flags;
int line = tty->index;
int ret;
pr_debug("%s\n", __FUNCTION__);
if (line < 0 || line >= hvsi_count)
return -ENODEV;
hp = &hvsi_ports[line];
tty->driver_data = hp;
tty->low_latency = 1; /* avoid throttle/tty_flip_buffer_push race */
mb();
if (hp->state == HVSI_FSP_DIED)
return -EIO;
spin_lock_irqsave(&hp->lock, flags);
hp->tty = tty;
hp->count++;
atomic_set(&hp->seqno, 0);
h_vio_signal(hp->vtermno, VIO_IRQ_ENABLE);
spin_unlock_irqrestore(&hp->lock, flags);
if (is_console(hp))
return 0; /* this has already been handshaked as the console */
ret = hvsi_handshake(hp);
if (ret < 0) {
printk(KERN_ERR "%s: HVSI handshaking failed\n", tty->name);
return ret;
}
ret = hvsi_get_mctrl(hp);
if (ret < 0) {
printk(KERN_ERR "%s: couldn't get initial modem flags\n", tty->name);
return ret;
}
ret = hvsi_set_mctrl(hp, hp->mctrl | TIOCM_DTR);
if (ret < 0) {
printk(KERN_ERR "%s: couldn't set DTR\n", tty->name);
return ret;
}
return 0;
}
static int msm_serial_resume(struct device *dev)
{
struct uart_port *port;
struct platform_device *pdev = to_platform_device(dev);
port = get_port_from_line(pdev->id);
if (port) {
if (is_console(port))
msm_init_clock(port);
uart_resume_port(&msm_uart_driver, port);
}
return 0;
}
int winansi_fputs(const char *str, FILE *stream)
{
int rv;
if (!is_console(stream))
return fputs(str, stream);
rv = ansi_emulate(str, stream);
if (rv >= 0)
return 0;
else
return EOF;
}
static int hvsi_open(struct tty_struct *tty, struct file *filp)
{
struct hvsi_struct *hp;
unsigned long flags;
int line = tty->index;
int ret;
pr_debug("%s\n", __func__);
if (line < 0 || line >= hvsi_count)
return -ENODEV;
hp = &hvsi_ports[line];
tty->driver_data = hp;
mb();
if (hp->state == HVSI_FSP_DIED)
return -EIO;
spin_lock_irqsave(&hp->lock, flags);
hp->tty = tty;
hp->count++;
atomic_set(&hp->seqno, 0);
h_vio_signal(hp->vtermno, VIO_IRQ_ENABLE);
spin_unlock_irqrestore(&hp->lock, flags);
if (is_console(hp))
return 0; /* this has already been handshaked as the console */
ret = hvsi_handshake(hp);
if (ret < 0) {
;
return ret;
}
ret = hvsi_get_mctrl(hp);
if (ret < 0) {
;
return ret;
}
ret = hvsi_set_mctrl(hp, hp->mctrl | TIOCM_DTR);
if (ret < 0) {
;
return ret;
}
return 0;
}
static void hvsi_handshaker(void *arg)
{
struct hvsi_struct *hp = (struct hvsi_struct *)arg;
if (hvsi_handshake(hp) >= 0)
return;
printk(KERN_ERR "hvsi%i: re-handshaking failed\n", hp->index);
if (is_console(hp)) {
/*
* ttys will re-attempt the handshake via hvsi_open, but
* the console will not.
*/
printk(KERN_ERR "hvsi%i: lost console!\n", hp->index);
}
}
static void hvsi_handshaker(struct work_struct *work)
{
struct hvsi_struct *hp =
container_of(work, struct hvsi_struct, handshaker);
if (hvsi_handshake(hp) >= 0)
return;
;
if (is_console(hp)) {
/*
* ttys will re-attempt the handshake via hvsi_open, but
* the console will not.
*/
;
}
}
static void hvsi_handshaker(struct work_struct *work)
{
struct hvsi_struct *hp =
container_of(work, struct hvsi_struct, handshaker);
if (hvsi_handshake(hp) >= 0)
return;
printk(KERN_ERR "hvsi%i: re-handshaking failed\n", hp->index);
if (is_console(hp)) {
/*
* ttys will re-attempt the handshake via hvsi_open, but
* the console will not.
*/
printk(KERN_ERR "hvsi%i: lost console!\n", hp->index);
}
}
static int msm_serial_hsl_resume(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct uart_port *port;
port = get_port_from_line(pdev->id);
if (port) {
if (is_console(port))
msm_hsl_init_clock(port);
uart_resume_port(&msm_hsl_uart_driver, port);
if (device_may_wakeup(dev))
disable_irq_wake(port->irq);
}
return 0;
}
static void msm_hsl_shutdown_irda(struct uart_port *port)
{
struct msm_hsl_port *msm_hsl_port = UART_TO_MSM(port);
msm_hsl_port->imr = 0;
/* disable interrupts */
msm_hsl_write(port, 0, regmap[msm_hsl_port->ver_id][UARTDM_IMR]);
free_irq(port->irq, port);
#ifndef CONFIG_PM_RUNTIME
msm_hsl_deinit_clock(port);
#endif
pm_runtime_put_sync(port->dev);
if (!(is_console(port)) || (!port->cons) ||
(port->cons && (!(port->cons->flags & CON_ENABLED)))) {
}
}
int
main (int argc, char **argv)
{
GMainLoop *loop;
CkTtyIdleMonitor *monitor;
char *device;
#if !GLIB_CHECK_VERSION(2, 36, 0)
g_type_init ();
#endif
if (argc < 2) {
device = ttyname (0);
} else {
device = g_strdup (argv[1]);
}
if (! is_console (device)) {
g_warning ("Device is not a console");
exit (1);
}
g_message ("Testing the TTY idle monitor.\n1. Wait for idleness to be detected.\n2. Hit keys on the keyboard to see if activity is noticed.");
monitor = ck_tty_idle_monitor_new (device);
g_signal_connect (monitor,
"idle-hint-changed",
G_CALLBACK (idle_changed_cb),
NULL);
ck_tty_idle_monitor_set_threshold (monitor, 5);
ck_tty_idle_monitor_start (monitor);
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
g_object_unref (monitor);
g_main_loop_unref (loop);
return 0;
}
static int msm_serial_hsl_suspend(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct uart_port *port;
port = get_port_from_line(pdev->id);
D("%s ():port->line %d, ir\n", __func__, port->line);
if (port) {
if (irda_enable_flg == 0)
enable_irda(irda_enable_flg);
D("%s ():is_console:port->line %d, ir\n", __func__, port->line);
if (is_console(port))
msm_hsl_deinit_clock(port);
uart_suspend_port(&msm_hsl_uart_driver, port);
if (device_may_wakeup(dev))
enable_irq_wake(port->irq);
}
return 0;
}
static int msm_serial_hsl_suspend(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct msm_hsl_port *msm_cir_port = htc_cir_port;
struct uart_port *port;
port = get_port_from_line(pdev->id);
pr_info("[CIR] %s ():port->line %d, ir\n", __func__, port->line);
if (port) {
if (cir_enable_flg == 0)
enable_cir(cir_enable_flg);
pr_info("%s ():is_console:port->line %d, ir\n", __func__, port->line);
if (is_console(port))
msm_hsl_deinit_clock(port);
uart_suspend_port(&msm_hsl_uart_driver, port);
if (device_may_wakeup(dev))
enable_irq_wake(port->irq);
}
if(power_state == 1)
msm_cir_port->power(0);
return 0;
}
static int msm_serial_hsl_resume(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct msm_hsl_port *msm_cir_port = htc_cir_port;
struct uart_port *port;
port = get_port_from_line(pdev->id);
pr_info("[CIR] %s ():port->line %d, ir\n", __func__, port->line);
if(power_state == 1)
msm_cir_port->power(1);
if (port) {
pr_info("%s ():uart_resume_port:port->line %d, ir\n", __func__, port->line);
enable_cir(3);
uart_resume_port(&msm_hsl_uart_driver, port);
if (device_may_wakeup(dev))
disable_irq_wake(port->irq);
if (is_console(port))
msm_hsl_init_clock(port);
}
return 0;
}
static void msm_hsl_shutdown_cir(struct uart_port *port)
{
struct msm_hsl_port *msm_hsl_port = UART_TO_MSM(port);
clk_en(port, 1);
pr_info("%s () :port->line %d, ir\n", __func__, port->line);
msm_hsl_port->imr = 0;
msm_hsl_write(port, 0, regmap[msm_hsl_port->ver_id][UARTDM_IMR]);
clk_en(port, 0);
free_irq(port->irq, port);
#ifndef CONFIG_PM_RUNTIME
msm_hsl_deinit_clock(port);
#endif
pm_runtime_put_sync(port->dev);
if (!(is_console(port)) || (!port->cons) ||
(port->cons && (!(port->cons->flags & CON_ENABLED)))) {
pr_info("%s () is_console:port->line %d, ir\n", __func__, port->line);
}
}
static int msm_hsl_startup_irda(struct uart_port *port)
{
struct msm_hsl_port *msm_hsl_port = UART_TO_MSM(port);
unsigned int data, rfr_level;
unsigned int vid;
int ret;
unsigned long flags;
snprintf(msm_hsl_port->name, sizeof(msm_hsl_port->name),
"msm_serial_hsl%d", port->line);
D("%s () :port->line %d, ir\n", __func__, port->line);
if (!(is_console(port)) || (!port->cons) ||
(port->cons && (!(port->cons->flags & CON_ENABLED)))) {
if (msm_serial_hsl_has_gsbi(port)) {
D("%s () serial_hsl_has_gsbi:port->line %d, ir\n", __func__, port->line);
if ((ioread32(msm_hsl_port->mapped_gsbi +
GSBI_CONTROL_ADDR) & GSBI_PROTOCOL_I2C_UART)
!= GSBI_PROTOCOL_I2C_UART){
D("%s () iowrite32i:port->line %d, ir\n", __func__, port->line);
iowrite32(GSBI_PROTOCOL_I2C_UART,
msm_hsl_port->mapped_gsbi +
GSBI_CONTROL_ADDR);
}
}
}
#ifndef CONFIG_PM_RUNTIME
msm_hsl_init_clock(port);
#endif
pm_runtime_get_sync(port->dev);
/* Set RFR Level as 3/4 of UARTDM FIFO Size */
if (likely(port->fifosize > 48))
rfr_level = port->fifosize - 16;
else
rfr_level = port->fifosize;
/*
* Use rfr_level value in Words to program
* MR1 register for UARTDM Core.
*/
rfr_level = (rfr_level / 4);
spin_lock_irqsave(&port->lock, flags);
vid = msm_hsl_port->ver_id;
/* set automatic RFR level */
data = msm_hsl_read(port, regmap[vid][UARTDM_MR1]);
data &= ~UARTDM_MR1_AUTO_RFR_LEVEL1_BMSK;
data &= ~UARTDM_MR1_AUTO_RFR_LEVEL0_BMSK;
data |= UARTDM_MR1_AUTO_RFR_LEVEL1_BMSK & (rfr_level << 2);
data |= UARTDM_MR1_AUTO_RFR_LEVEL0_BMSK & rfr_level;
msm_hsl_write(port, data, regmap[vid][UARTDM_MR1]);
spin_unlock_irqrestore(&port->lock, flags);
ret = request_irq(port->irq, msm_hsl_irq, IRQF_TRIGGER_HIGH,
msm_hsl_port->name, port);
if (unlikely(ret)) {
printk(KERN_ERR "%s: failed to request_irq\n", __func__);
return ret;
}
return 0;
}
static int msm_hsl_startup(struct uart_port *port)
{
struct msm_hsl_port *msm_hsl_port = UART_TO_MSM(port);
struct platform_device *pdev = to_platform_device(port->dev);
const struct msm_serial_hslite_platform_data *pdata =
pdev->dev.platform_data;
unsigned int data, rfr_level;
int ret;
unsigned long flags;
snprintf(msm_hsl_port->name, sizeof(msm_hsl_port->name),
"msm_serial_hsl%d", port->line);
if (!(is_console(port)) || (!port->cons) ||
(port->cons && (!(port->cons->flags & CON_ENABLED)))) {
if (msm_serial_hsl_has_gsbi())
if ((ioread32(msm_hsl_port->mapped_gsbi +
GSBI_CONTROL_ADDR) & GSBI_PROTOCOL_I2C_UART)
!= GSBI_PROTOCOL_I2C_UART)
iowrite32(GSBI_PROTOCOL_I2C_UART,
msm_hsl_port->mapped_gsbi +
GSBI_CONTROL_ADDR);
if (pdata && pdata->config_gpio) {
ret = gpio_request(pdata->uart_tx_gpio,
"UART_TX_GPIO");
if (unlikely(ret)) {
pr_err("%s: gpio request failed for:%d\n",
__func__, pdata->uart_tx_gpio);
return ret;
}
ret = gpio_request(pdata->uart_rx_gpio, "UART_RX_GPIO");
if (unlikely(ret)) {
pr_err("%s: gpio request failed for:%d\n",
__func__, pdata->uart_rx_gpio);
gpio_free(pdata->uart_tx_gpio);
return ret;
}
}
}
#ifndef CONFIG_PM_RUNTIME
msm_hsl_init_clock(port);
#endif
pm_runtime_get_sync(port->dev);
if (likely(port->fifosize > 12))
rfr_level = port->fifosize - 12;
else
rfr_level = port->fifosize;
spin_lock_irqsave(&port->lock, flags);
/* set automatic RFR level */
data = msm_hsl_read(port, UARTDM_MR1_ADDR);
data &= ~UARTDM_MR1_AUTO_RFR_LEVEL1_BMSK;
data &= ~UARTDM_MR1_AUTO_RFR_LEVEL0_BMSK;
data |= UARTDM_MR1_AUTO_RFR_LEVEL1_BMSK & (rfr_level << 2);
data |= UARTDM_MR1_AUTO_RFR_LEVEL0_BMSK & rfr_level;
msm_hsl_write(port, data, UARTDM_MR1_ADDR);
spin_unlock_irqrestore(&port->lock, flags);
ret = request_irq(port->irq, msm_hsl_irq, IRQF_TRIGGER_HIGH,
msm_hsl_port->name, port);
if (unlikely(ret)) {
printk(KERN_ERR "%s: failed to request_irq\n", __func__);
return ret;
}
return 0;
}
static int msm_hsl_startup(struct uart_port *port)
{
struct msm_hsl_port *msm_hsl_port = UART_TO_MSM(port);
unsigned int data, rfr_level;
int ret;
unsigned long flags;
snprintf(msm_hsl_port->name, sizeof(msm_hsl_port->name),
"msm_serial_hsl%d", port->line);
#ifndef CONFIG_PM_RUNTIME
msm_hsl_init_clock(port);
#endif
pm_runtime_get_sync(port->dev);
if (likely(port->fifosize > 12))
rfr_level = port->fifosize - 12;
else
rfr_level = port->fifosize;
spin_lock_irqsave(&port->lock, flags);
/* set automatic RFR level */
data = msm_hsl_read(port, UARTDM_MR1_ADDR);
data &= ~UARTDM_MR1_AUTO_RFR_LEVEL1_BMSK;
data &= ~UARTDM_MR1_AUTO_RFR_LEVEL0_BMSK;
data |= UARTDM_MR1_AUTO_RFR_LEVEL1_BMSK & (rfr_level << 2);
data |= UARTDM_MR1_AUTO_RFR_LEVEL0_BMSK & rfr_level;
msm_hsl_write(port, data, UARTDM_MR1_ADDR);
/* Make sure IPR is not 0 to start with*/
msm_hsl_write(port, UARTDM_IPR_STALE_LSB_BMSK, UARTDM_IPR_ADDR);
data = 0;
if (!(is_console(port)) || (!port->cons) ||
(port->cons && (!(port->cons->flags & CON_ENABLED)))) {
msm_hsl_write(port, CR_PROTECTION_EN, UARTDM_CR_ADDR);
msm_hsl_write(port, UARTDM_MR2_BITS_PER_CHAR_8 | STOP_BIT_ONE,
UARTDM_MR2_ADDR); /* 8N1 */
msm_hsl_reset(port);
data = UARTDM_CR_TX_EN_BMSK;
}
if(b_terminal_onoff == 0 && console_uart_port && (port == console_uart_port)){
msm_hsl_write(port, data, UARTDM_CR_ADDR); /* enable TX */
}else{
data |= UARTDM_CR_RX_EN_BMSK;
msm_hsl_write(port, data, UARTDM_CR_ADDR); /* enable TX & RX */
}
/* turn on RX and CTS interrupts */
msm_hsl_port->imr = UARTDM_ISR_RXSTALE_BMSK
| UARTDM_ISR_DELTA_CTS_BMSK | UARTDM_ISR_RXLEV_BMSK;
spin_unlock_irqrestore(&port->lock, flags);
ret = request_irq(port->irq, msm_hsl_irq, IRQF_TRIGGER_HIGH,
msm_hsl_port->name, port);
if (unlikely(ret)) {
printk(KERN_ERR "%s: failed to request_irq\n", __func__);
return ret;
}
spin_lock_irqsave(&port->lock, flags);
msm_hsl_write(port, RESET_STALE_INT, UARTDM_CR_ADDR);
msm_hsl_write(port, 6500, UARTDM_DMRX_ADDR);
msm_hsl_write(port, STALE_EVENT_ENABLE, UARTDM_CR_ADDR);
msm_hsl_write(port, msm_hsl_port->imr, UARTDM_IMR_ADDR);
spin_unlock_irqrestore(&port->lock, flags);
return 0;
}
int VFPRINTF(HANDLE handle, const char *fmt, va_list argptr)
{
/////////////////////////////////////////////////////////////////
/* XXX Two streams are being used. Disabled to avoid inconsistency [flaviojs]
static COORD saveposition = {0,0};
*/
/////////////////////////////////////////////////////////////////
DWORD written;
char *p, *q;
NEWBUF(tempbuf); // temporary buffer
if(!fmt || !*fmt)
return 0;
// Print everything to the buffer
BUFVPRINTF(tempbuf,fmt,argptr);
if( !is_console(handle) && stdout_with_ansisequence )
{
WriteFile(handle, BUFVAL(tempbuf), BUFLEN(tempbuf), &written, 0);
return 0;
}
// start with processing
p = BUFVAL(tempbuf);
while ((q = strchr(p, 0x1b)) != NULL)
{ // find the escape character
if( 0==WriteConsole(handle, p, (DWORD)(q-p), &written, 0) ) // write up to the escape
WriteFile(handle, p, (DWORD)(q-p), &written, 0);
if( q[1]!='[' )
{ // write the escape char (whatever purpose it has)
if(0==WriteConsole(handle, q, 1, &written, 0) )
WriteFile(handle,q, 1, &written, 0);
p=q+1; //and start searching again
}
else
{ // from here, we will skip the '\033['
// we break at the first unprocessible position
// assuming regular text is starting there
uint8 numbers[16], numpoint=0;
CONSOLE_SCREEN_BUFFER_INFO info;
// initialize
GetConsoleScreenBufferInfo(handle, &info);
memset(numbers,0,sizeof(numbers));
// skip escape and bracket
q=q+2;
for(;;)
{
if( ISDIGIT(*q) )
{ // add number to number array, only accept 2digits, shift out the rest
// so // \033[123456789m will become \033[89m
numbers[numpoint] = (numbers[numpoint]<<4) | (*q-'0');
++q;
// and next character
continue;
}
else if( *q == ';' )
{ // delimiter
if(numpoint<sizeof(numbers)/sizeof(*numbers))
{ // go to next array position
numpoint++;
}
else
{ // array is full, so we 'forget' the first value
memmove(numbers,numbers+1,sizeof(numbers)/sizeof(*numbers)-1);
numbers[sizeof(numbers)/sizeof(*numbers)-1]=0;
}
++q;
// and next number
continue;
}
else if( *q == 'm' )
{ // \033[#;...;#m - Set Graphics Rendition (SGR)
uint8 i;
for(i=0; i<= numpoint; ++i)
{
if( 0x00 == (0xF0 & numbers[i]) )
{ // upper nibble 0
if( 0 == numbers[i] )
{ // reset
info.wAttributes = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
}
else if( 1==numbers[i] )
{ // set foreground intensity
info.wAttributes |= FOREGROUND_INTENSITY;
}
else if( 5==numbers[i] )
{ // set background intensity
info.wAttributes |= BACKGROUND_INTENSITY;
}
else if( 7==numbers[i] )
{ // reverse colors (just xor them)
info.wAttributes ^= FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE |
BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE;
}
//case '2': // not existing
//case '3': // blinking (not implemented)
//case '4': // unterline (not implemented)
//case '6': // not existing
//case '8': // concealed (not implemented)
//case '9': // not existing
}
else if( 0x20 == (0xF0 & numbers[i]) )
{ // off
if( 1==numbers[i] )
{ // set foreground intensity off
info.wAttributes &= ~FOREGROUND_INTENSITY;
}
else if( 5==numbers[i] )
{ // set background intensity off
info.wAttributes &= ~BACKGROUND_INTENSITY;
}
else if( 7==numbers[i] )
{ // reverse colors (just xor them)
info.wAttributes ^= FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE |
BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE;
}
}
else if( 0x30 == (0xF0 & numbers[i]) )
{ // foreground
uint8 num = numbers[i]&0x0F;
if(num==9) info.wAttributes |= FOREGROUND_INTENSITY;
if(num>7) num=7; // set white for 37, 38 and 39
info.wAttributes &= ~(FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);
if( (num & 0x01)>0 ) // lowest bit set = red
info.wAttributes |= FOREGROUND_RED;
if( (num & 0x02)>0 ) // second bit set = green
info.wAttributes |= FOREGROUND_GREEN;
if( (num & 0x04)>0 ) // third bit set = blue
info.wAttributes |= FOREGROUND_BLUE;
}
else if( 0x40 == (0xF0 & numbers[i]) )
{ // background
uint8 num = numbers[i]&0x0F;
if(num==9) info.wAttributes |= BACKGROUND_INTENSITY;
if(num>7) num=7; // set white for 47, 48 and 49
info.wAttributes &= ~(BACKGROUND_RED|BACKGROUND_GREEN|BACKGROUND_BLUE);
if( (num & 0x01)>0 ) // lowest bit set = red
info.wAttributes |= BACKGROUND_RED;
if( (num & 0x02)>0 ) // second bit set = green
info.wAttributes |= BACKGROUND_GREEN;
if( (num & 0x04)>0 ) // third bit set = blue
info.wAttributes |= BACKGROUND_BLUE;
}
}
// set the attributes
SetConsoleTextAttribute(handle, info.wAttributes);
}
else if( *q=='J' )
{ // \033[#J - Erase Display (ED)
// \033[0J - Clears the screen from cursor to end of display. The cursor position is unchanged.
// \033[1J - Clears the screen from start to cursor. The cursor position is unchanged.
// \033[2J - Clears the screen and moves the cursor to the home position (line 1, column 1).
uint8 num = (numbers[numpoint]>>4)*10+(numbers[numpoint]&0x0F);
int cnt;
DWORD tmp;
COORD origin = {0,0};
if(num==1)
{ // chars from start up to and including cursor
cnt = info.dwSize.X * info.dwCursorPosition.Y + info.dwCursorPosition.X + 1;
}
else if(num==2)
{ // Number of chars on screen.
cnt = info.dwSize.X * info.dwSize.Y;
SetConsoleCursorPosition(handle, origin);
}
else// 0 and default
{ // number of chars from cursor to end
origin = info.dwCursorPosition;
cnt = info.dwSize.X * (info.dwSize.Y - info.dwCursorPosition.Y) - info.dwCursorPosition.X;
}
FillConsoleOutputAttribute(handle, info.wAttributes, cnt, origin, &tmp);
FillConsoleOutputCharacter(handle, ' ', cnt, origin, &tmp);
}
else if( *q=='K' )
{ // \033[K : clear line from actual position to end of the line
// \033[0K - Clears all characters from the cursor position to the end of the line.
// \033[1K - Clears all characters from start of line to the cursor position.
// \033[2K - Clears all characters of the whole line.
uint8 num = (numbers[numpoint]>>4)*10+(numbers[numpoint]&0x0F);
COORD origin = {0,info.dwCursorPosition.Y}; //warning C4204
SHORT cnt;
DWORD tmp;
if(num==1)
{
cnt = info.dwCursorPosition.X + 1;
}
else if(num==2)
{
cnt = info.dwSize.X;
}
else// 0 and default
{
origin = info.dwCursorPosition;
cnt = info.dwSize.X - info.dwCursorPosition.X; // how many spaces until line is full
}
FillConsoleOutputAttribute(handle, info.wAttributes, cnt, origin, &tmp);
FillConsoleOutputCharacter(handle, ' ', cnt, origin, &tmp);
}
else if( *q == 'H' || *q == 'f' )
static int msm_hsl_startup(struct uart_port *port)
{
struct msm_hsl_port *msm_hsl_port = UART_TO_MSM(port);
struct platform_device *pdev = to_platform_device(port->dev);
struct msm_serial_hslite_platform_data *pdata = pdev->dev.platform_data;
unsigned int data, rfr_level;
int ret;
unsigned long flags;
snprintf(msm_hsl_port->name, sizeof(msm_hsl_port->name),
"msm_serial_hsl%d", port->line);
if (!(is_console(port)) || (!port->cons) ||
(port->cons && (!(port->cons->flags & CON_ENABLED)))) {
if (msm_serial_hsl_has_gsbi())
if ((ioread32(msm_hsl_port->mapped_gsbi +
GSBI_CONTROL_ADDR) & GSBI_PROTOCOL_I2C_UART)
!= GSBI_PROTOCOL_I2C_UART)
iowrite32(GSBI_PROTOCOL_I2C_UART,
msm_hsl_port->mapped_gsbi +
GSBI_CONTROL_ADDR);
if (pdata && pdata->config_gpio) {
ret = gpio_request(pdata->uart_tx_gpio,
"UART_TX_GPIO");
if (unlikely(ret)) {
pr_err("%s: gpio request failed for:%d\n",
__func__, pdata->uart_tx_gpio);
return ret;
}
ret = gpio_request(pdata->uart_rx_gpio, "UART_RX_GPIO");
if (unlikely(ret)) {
pr_err("%s: gpio request failed for:%d\n",
__func__, pdata->uart_rx_gpio);
gpio_free(pdata->uart_tx_gpio);
return ret;
}
}
}
#ifndef CONFIG_PM_RUNTIME
msm_hsl_init_clock(port);
#endif
pm_runtime_get_sync(port->dev);
if (likely(port->fifosize > 12))
rfr_level = port->fifosize - 12;
else
rfr_level = port->fifosize;
spin_lock_irqsave(&port->lock, flags);
/* set automatic RFR level */
data = msm_hsl_read(port, UARTDM_MR1_ADDR);
data &= ~UARTDM_MR1_AUTO_RFR_LEVEL1_BMSK;
data &= ~UARTDM_MR1_AUTO_RFR_LEVEL0_BMSK;
data |= UARTDM_MR1_AUTO_RFR_LEVEL1_BMSK & (rfr_level << 2);
data |= UARTDM_MR1_AUTO_RFR_LEVEL0_BMSK & rfr_level;
msm_hsl_write(port, data, UARTDM_MR1_ADDR);
/* Make sure IPR is not 0 to start with*/
msm_hsl_write(port, UARTDM_IPR_STALE_LSB_BMSK, UARTDM_IPR_ADDR);
data = 0;
if (!(is_console(port)) || (!port->cons) ||
(port->cons && (!(port->cons->flags & CON_ENABLED)))) {
msm_hsl_write(port, CR_PROTECTION_EN, UARTDM_CR_ADDR);
msm_hsl_write(port, UARTDM_MR2_BITS_PER_CHAR_8 | STOP_BIT_ONE,
UARTDM_MR2_ADDR); /* 8N1 */
msm_hsl_reset(port);
data = UARTDM_CR_TX_EN_BMSK;
}
data |= UARTDM_CR_RX_EN_BMSK;
msm_hsl_write(port, data, UARTDM_CR_ADDR); /* enable TX & RX */
/* turn on RX and CTS interrupts */
msm_hsl_port->imr = UARTDM_ISR_RXSTALE_BMSK
| UARTDM_ISR_DELTA_CTS_BMSK | UARTDM_ISR_RXLEV_BMSK;
spin_unlock_irqrestore(&port->lock, flags);
ret = request_irq(port->irq, msm_hsl_irq, IRQF_TRIGGER_HIGH,
msm_hsl_port->name, port);
if (unlikely(ret)) {
printk(KERN_ERR "%s: failed to request_irq\n", __func__);
return ret;
}
spin_lock_irqsave(&port->lock, flags);
msm_hsl_write(port, RESET_STALE_INT, UARTDM_CR_ADDR);
msm_hsl_write(port, 6500, UARTDM_DMRX_ADDR);
msm_hsl_write(port, STALE_EVENT_ENABLE, UARTDM_CR_ADDR);
msm_hsl_write(port, msm_hsl_port->imr, UARTDM_IMR_ADDR);
spin_unlock_irqrestore(&port->lock, flags);
return 0;
}
// TODO([email protected]): This isn't true in general, but it's true for my purposes right now. void test_stdin_is_a_console() { assert(is_console(stdin)); }