int uart_suspend_port(struct uart_driver *drv, struct uart_port *uport)
{
struct uart_state *state = drv->state + uport->line;
struct tty_port *port = &state->port;
struct device *tty_dev;
struct uart_match match = {uport, drv};
mutex_lock(&port->mutex);
tty_dev = device_find_child(uport->dev, &match, serial_match_port);
if (device_may_wakeup(tty_dev)) {
if (!enable_irq_wake(uport->irq))
uport->irq_wake = 1;
put_device(tty_dev);
mutex_unlock(&port->mutex);
return 0;
}
if (console_suspend_enabled || !uart_console(uport))
uport->suspended = 1;
if (port->flags & ASYNC_INITIALIZED) {
const struct uart_ops *ops = uport->ops;
int tries;
if (console_suspend_enabled || !uart_console(uport)) {
set_bit(ASYNCB_SUSPENDED, &port->flags);
clear_bit(ASYNCB_INITIALIZED, &port->flags);
spin_lock_irq(&uport->lock);
ops->stop_tx(uport);
ops->set_mctrl(uport, 0);
ops->stop_rx(uport);
spin_unlock_irq(&uport->lock);
}
for (tries = 3; !ops->tx_empty(uport) && tries; tries--)
msleep(10);
if (!tries)
printk(KERN_ERR "%s%s%s%d: Unable to drain "
"transmitter\n",
uport->dev ? dev_name(uport->dev) : "",
uport->dev ? ": " : "",
drv->dev_name,
drv->tty_driver->name_base + uport->line);
if (console_suspend_enabled || !uart_console(uport))
ops->shutdown(uport);
}
if (console_suspend_enabled && uart_console(uport))
console_stop(uport->cons);
if (console_suspend_enabled || !uart_console(uport))
uart_change_pm(state, 3);
mutex_unlock(&port->mutex);
return 0;
}
static void gsm_on_off(struct device *dev, int on)
{
if (!on) {
s3c2410_gpio_cfgpin(S3C2410_GPH1, S3C2410_GPIO_INPUT);
s3c2410_gpio_cfgpin(S3C2410_GPH2, S3C2410_GPIO_INPUT);
pcf50633_gpio_set(gta02_pcf, PCF50633_GPIO2, 0);
if (gta02_gsm.con) {
s3c24xx_serial_console_set_silence(0);
console_start(gta02_gsm.con);
dev_dbg(dev, "powered down gta02 GSM, enabling "
"serial console\n");
}
return;
}
if (gta02_gsm.con) {
dev_dbg(dev, "powering up GSM, thus "
"disconnecting serial console\n");
console_stop(gta02_gsm.con);
s3c24xx_serial_console_set_silence(1);
}
/* allow UART to talk to GSM side now we will power it */
s3c2410_gpio_cfgpin(S3C2410_GPH1, S3C2410_GPH1_nRTS0);
s3c2410_gpio_cfgpin(S3C2410_GPH2, S3C2410_GPH2_TXD0);
pcf50633_gpio_set(gta02_pcf, PCF50633_GPIO2, 7);
msleep(100);
s3c2410_gpio_setpin(GTA02_GPIO_MODEM_ON, 1);
msleep(500);
s3c2410_gpio_setpin(GTA02_GPIO_MODEM_ON, 0);
/*
* workaround for calypso firmware moko10 and earlier,
* without this it will leave IRQ line high after
* booting
*/
s3c2410_gpio_setpin(S3C2410_GPH1, 1);
s3c2410_gpio_cfgpin(S3C2410_GPH1, S3C2410_GPH1_OUTP);
msleep(1000);
s3c2410_gpio_cfgpin(S3C2410_GPH1, S3C2410_GPH1_nRTS0);
}
static int gta02_gsm_resume(struct platform_device *pdev)
{
/* GPIO state is saved/restored by S3C2410 core GPIO driver, so we
* don't need to do much here. */
/* Make sure that the kernel console on the serial port is still
* disabled. FIXME: resume ordering race with serial driver! */
if (gta02_gsm.con && s3c2410_gpio_getpin(GTA02_GPIO_MODEM_ON))
console_stop(gta02_gsm.con);
s3c2410_gpio_setpin(GTA02_GPIO_nDL_GSM, gta02_gsm.gpio_ndl_gsm);
return 0;
}
/*
* set_msm_console - allow to enable/disable serial console on port.
*
* writing 1 enables serial console on UART port.
* writing 0 disables serial console on UART port.
*/
static ssize_t set_msm_console(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int enable, cur_state;
struct uart_port *port;
struct platform_device *pdev = to_platform_device(dev);
port = get_port_from_line(pdev->id);
cur_state = get_console_state(port);
enable = buf[0] - '0';
D("%s ():port->line %d,enable %d, cur_state %d ir\n", __func__, port->line, enable, cur_state);
if (enable == cur_state)
return count;
switch (enable) {
case 0:
D("%s(): Calling stop_console\n", __func__);
console_stop(port->cons);
D("%s(): Calling unregister_console\n", __func__);
unregister_console(port->cons);
pm_runtime_put_sync(&pdev->dev);
pm_runtime_disable(&pdev->dev);
/*
* Disable UART Core clk
* 3 - to disable the UART clock
* Thid parameter is not used here, but used in serial core.
*/
msm_hsl_power_irda(port, 3, 1);
break;
case 1:
D("%s(): Calling register_console\n", __func__);
/*
* Disable UART Core clk
* 0 - to enable the UART clock
* Thid parameter is not used here, but used in serial core.
*/
msm_hsl_power_irda(port, 0, 1);
pm_runtime_enable(&pdev->dev);
register_console(port->cons);
break;
default:
return -EINVAL;
}
return count;
}
static ssize_t set_msm_console(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int enable, cur_state;
struct uart_port *port;
struct platform_device *pdev = to_platform_device(dev);
port = get_port_from_line(pdev->id);
cur_state = get_console_state(port);
enable = buf[0] - '0';
pr_info("%s ():port->line %d,enable %d, cur_state %d ir\n", __func__, port->line, enable, cur_state);
if (enable == cur_state)
return count;
switch (enable) {
case 0:
pr_info("%s(): Calling stop_console\n", __func__);
console_stop(port->cons);
pr_debug("%s(): Calling unregister_console\n", __func__);
unregister_console(port->cons);
pm_runtime_put_sync(&pdev->dev);
pm_runtime_disable(&pdev->dev);
msm_hsl_power_cir(port, 3, 1);
break;
case 1:
pr_info("%s(): Calling register_console\n", __func__);
msm_hsl_power_cir(port, 0, 1);
pm_runtime_enable(&pdev->dev);
register_console(port->cons);
break;
default:
return -EINVAL;
}
return count;
}
