static int __devinit msm_serial_hsl_probe_irda(struct platform_device *pdev)
{
struct msm_hsl_port *msm_hsl_port;
struct resource *uart_resource;
struct resource *gsbi_resource;
struct uart_port *port;
const struct of_device_id *match;
struct irda_platform_data *pdata;
int ret;
if (pdev->id == -1)
pdev->id = atomic_inc_return(&msm_serial_hsl_next_id) - 1;
if (unlikely(pdev->id < 0 || pdev->id >= UART_NR))
return -ENXIO;
printk(KERN_INFO "msm_serial_irda: detected port #%d\n", pdev->id);
port = get_port_from_line(pdev->id);
port->dev = &pdev->dev;
pdata = pdev->dev.platform_data;
if (!pdata) {
E("[irdaerror]%s: Assign platform_data error!!\n",
__func__);
return -ENXIO;
}
msm_hsl_port = UART_TO_MSM(port);
msm_hsl_port->irda_enable= pdata->irda_enable;
htc_irda_port = msm_hsl_port;
match = of_match_device(msm_hsl_match_table, &pdev->dev);
if (!match)
msm_hsl_port->ver_id = UARTDM_VERSION_11_13;
else {
D("%s () match:port->line %d, ir\n", __func__, port->line);
msm_hsl_port->ver_id = (unsigned int)match->data;
}
gsbi_resource = platform_get_resource_byname(pdev,
IORESOURCE_MEM,
"gsbi_resource");
if (!gsbi_resource) {
gsbi_resource = platform_get_resource(pdev, IORESOURCE_MEM, 1);
D("%s () gsbi_resourc:port->line %d, ir\n", __func__, port->line);
}
msm_hsl_port->clk = clk_get(&pdev->dev, "core_clk");
if (gsbi_resource) {
printk(KERN_INFO "msm_serial_irda: get gsbi_uart_clk and gsbi_pclk\n");
msm_hsl_port->is_uartdm = 1;
msm_hsl_port->pclk = clk_get(&pdev->dev, "iface_clk");
} else {
printk(KERN_INFO "msm_serial_irda: get uartdm_clk\n");
msm_hsl_port->is_uartdm = 0;
msm_hsl_port->pclk = NULL;
}
if (unlikely(IS_ERR(msm_hsl_port->clk))) {
printk(KERN_ERR "%s: Error getting clk\n", __func__);
return PTR_ERR(msm_hsl_port->clk);
}
if (unlikely(IS_ERR(msm_hsl_port->pclk))) {
printk(KERN_ERR "%s: Error getting pclk\n", __func__);
return PTR_ERR(msm_hsl_port->pclk);
}
uart_resource = platform_get_resource_byname(pdev,
IORESOURCE_MEM,
"uartdm_resource");
if (!uart_resource)
uart_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (unlikely(!uart_resource)) {
printk(KERN_ERR "getting uartdm_resource failed\n");
return -ENXIO;
}
port->mapbase = uart_resource->start;
printk(KERN_INFO "msm_serial_hsl: port[%d] mapbase:%x\n", port->line, port->mapbase);
port->irq = platform_get_irq(pdev, 0);
if (unlikely((int)port->irq < 0)) {
printk(KERN_ERR "%s: getting irq failed\n", __func__);
return -ENXIO;
}
device_set_wakeup_capable(&pdev->dev, 1);
platform_set_drvdata(pdev, port);
pm_runtime_enable(port->dev);
#ifdef CONFIG_SERIAL_MSM_HSL_CONSOLE
ret = device_create_file(&pdev->dev, &dev_attr_console);
D("%s () device_create_file, port->line %d, ir\n", __func__, port->line);
if (unlikely(ret))
E("%s():Can't create console attribute\n", __func__);
#endif
msm_hsl_debugfs_init(msm_hsl_port, pdev->id);
/* Temporarily increase the refcount on the GSBI clock to avoid a race
* condition with the earlyprintk handover mechanism.
*/
if (msm_hsl_port->pclk) {
clk_prepare_enable(msm_hsl_port->pclk);
D("%s () clk_enable, port->line %d, ir\n", __func__, port->line);
}
ret = uart_add_one_port(&msm_hsl_uart_driver, port);
if (msm_hsl_port->pclk) {
D("%s () clk_disabl, port->line %d, ir\n", __func__, port->line);
clk_disable_unprepare(msm_hsl_port->pclk);
}
D("%s ():port->line %d, ir\n", __func__, port->line);
msm_hsl_port->irda_class = class_create(THIS_MODULE, "htc_irda");
if (IS_ERR(msm_hsl_port->irda_class)) {
ret = PTR_ERR(msm_hsl_port->irda_class);
msm_hsl_port->irda_class = NULL;
return -ENXIO;
}
msm_hsl_port->irda_dev = device_create(msm_hsl_port->irda_class,
NULL, 0, "%s", "irda");
if (unlikely(IS_ERR(msm_hsl_port->irda_dev))) {
ret = PTR_ERR(msm_hsl_port->irda_dev);
msm_hsl_port->irda_dev = NULL;
goto err_create_ls_device;
}
/* register the attributes */
ret = device_create_file(msm_hsl_port->irda_dev, &dev_attr_enable_irda);
if (ret)
goto err_create_ls_device_file;
msm_hsl_write(port, 3, UARTDM_IRDA_ADDR);
enable_irda(0);/*0 disable, 3=enable, 9=loopback*/
return ret;
err_create_ls_device_file:
device_unregister(msm_hsl_port->irda_dev);
err_create_ls_device:
class_destroy(msm_hsl_port->irda_class);
return ret;
return ret;
}
static int __devinit msm_serial_hsl_probe(struct platform_device *pdev)
{
struct msm_hsl_port *msm_hsl_port;
struct resource *uart_resource;
struct resource *gsbi_resource;
struct uart_port *port;
int ret;
if (unlikely(pdev->id < 0 || pdev->id >= UART_NR))
return -ENXIO;
printk(KERN_INFO "msm_serial_hsl: detected port #%d\n", pdev->id);
port = get_port_from_line(pdev->id);
port->dev = &pdev->dev;
msm_hsl_port = UART_TO_MSM(port);
if (msm_serial_hsl_has_gsbi()) {
gsbi_resource =
platform_get_resource_byname(pdev,
IORESOURCE_MEM,
"gsbi_resource");
if (unlikely(!gsbi_resource))
return -ENXIO;
msm_hsl_port->clk = clk_get(&pdev->dev, "gsbi_uart_clk");
msm_hsl_port->pclk = clk_get(&pdev->dev, "gsbi_pclk");
} else {
msm_hsl_port->clk = clk_get(&pdev->dev, "uartdm_clk");
msm_hsl_port->pclk = NULL;
}
if (unlikely(IS_ERR(msm_hsl_port->clk))) {
printk(KERN_ERR "%s: Error getting clk\n", __func__);
return PTR_ERR(msm_hsl_port->clk);
}
if (unlikely(IS_ERR(msm_hsl_port->pclk))) {
printk(KERN_ERR "%s: Error getting pclk\n", __func__);
return PTR_ERR(msm_hsl_port->pclk);
}
uart_resource = platform_get_resource_byname(pdev,
IORESOURCE_MEM,
"uartdm_resource");
if (unlikely(!uart_resource)) {
printk(KERN_ERR "getting uartdm_resource failed\n");
return -ENXIO;
}
port->mapbase = uart_resource->start;
port->irq = platform_get_irq(pdev, 0);
if (unlikely(port->irq < 0)) {
printk(KERN_ERR "%s: getting irq failed\n", __func__);
return -ENXIO;
}
device_set_wakeup_capable(&pdev->dev, 1);
platform_set_drvdata(pdev, port);
pm_runtime_enable(port->dev);
msm_hsl_debugfs_init(msm_hsl_port, pdev->id);
ret = uart_add_one_port(&msm_hsl_uart_driver, port);
return ret;
}
static int __devinit msm_serial_hsl_probe_cir(struct platform_device *pdev)
{
struct msm_hsl_port *msm_hsl_port;
struct resource *uart_resource;
struct resource *gsbi_resource;
struct uart_port *port;
const struct of_device_id *match;
struct cir_platform_data *pdata;
int ret;
printk(KERN_INFO "[CIR] probe start.\n");
if (pdev->id == -1)
pdev->id = atomic_inc_return(&msm_serial_hsl_next_id) - 1;
if (unlikely(pdev->id < 0 || pdev->id >= UART_NR))
return -ENXIO;
printk(KERN_INFO "msm_serial_cir: detected port #%d\n", pdev->id);
port = get_port_from_line(pdev->id);
port->dev = &pdev->dev;
pdata = pdev->dev.platform_data;
if (!pdata) {
pr_err("[irdaerror]%s: Assign platform_data error!!\n",
__func__);
return -ENXIO;
}
printk(KERN_INFO "msm_serial_cir: cir_ls_en_gpio #%d, cir_reset_gpio #%d\n", pdata->cir_ls_en_gpio, pdata->cir_reset_gpio);
msm_hsl_port = UART_TO_MSM(port);
msm_hsl_port->cir_ls_en_gpio = pdata->cir_ls_en_gpio;
msm_hsl_port->cir_reset_gpio = pdata->cir_reset_gpio;
msm_hsl_port->cir_rx = pdata->cir_rx;
msm_hsl_port->power = pdata->power;
msm_hsl_port->power(1);
power_state = 1;
htc_cir_port = msm_hsl_port;
match = of_match_device(msm_hsl_match_table, &pdev->dev);
if (!match)
msm_hsl_port->ver_id = UARTDM_VERSION_11_13;
else {
pr_info("%s () match:port->line %d, ir\n", __func__, port->line);
msm_hsl_port->ver_id = (unsigned int)match->data;
}
gsbi_resource = platform_get_resource_byname(pdev,
IORESOURCE_MEM,
"gsbi_resource");
if (!gsbi_resource) {
gsbi_resource = platform_get_resource(pdev, IORESOURCE_MEM, 1);
pr_info("%s () gsbi_resourc:port->line %d, ir\n", __func__, port->line);
}
msm_hsl_port->clk = clk_get(&pdev->dev, "core_clk");
if (gsbi_resource) {
printk(KERN_INFO "msm_serial_cir: get gsbi_uart_clk and gsbi_pclk\n");
msm_hsl_port->is_uartdm = 1;
msm_hsl_port->pclk = clk_get(&pdev->dev, "iface_clk");
} else {
printk(KERN_INFO "msm_serial_cir: get uartdm_clk\n");
msm_hsl_port->is_uartdm = 0;
msm_hsl_port->pclk = NULL;
}
if (unlikely(IS_ERR(msm_hsl_port->clk))) {
printk(KERN_ERR "%s: Error getting clk\n", __func__);
return PTR_ERR(msm_hsl_port->clk);
}
if (unlikely(IS_ERR(msm_hsl_port->pclk))) {
printk(KERN_ERR "%s: Error getting pclk\n", __func__);
return PTR_ERR(msm_hsl_port->pclk);
}
uart_resource = platform_get_resource_byname(pdev,
IORESOURCE_MEM,
"uartdm_resource");
if (!uart_resource)
uart_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (unlikely(!uart_resource)) {
printk(KERN_ERR "getting uartdm_resource failed\n");
return -ENXIO;
}
port->mapbase = uart_resource->start;
printk(KERN_INFO "msm_serial_hsl: port[%d] mapbase:%x\n", port->line, port->mapbase);
port->irq = platform_get_irq(pdev, 0);
if (unlikely((int)port->irq < 0)) {
printk(KERN_ERR "%s: getting irq failed\n", __func__);
return -ENXIO;
}
device_set_wakeup_capable(&pdev->dev, 1);
platform_set_drvdata(pdev, port);
pm_runtime_enable(port->dev);
#ifdef CONFIG_SERIAL_MSM_HSL_CONSOLE
ret = device_create_file(&pdev->dev, &dev_attr_console);
pr_info("%s () device_create_file, port->line %d, ir\n", __func__, port->line);
if (unlikely(ret))
pr_err("%s():Can't create console attribute\n", __func__);
#endif
msm_hsl_debugfs_init(msm_hsl_port, pdev->id);
if (msm_hsl_port->pclk) {
clk_prepare_enable(msm_hsl_port->pclk);
pr_info("%s () clk_enable, port->line %d, ir\n", __func__, port->line);
}
ret = uart_add_one_port(&msm_hsl_uart_driver, port);
if (msm_hsl_port->pclk) {
pr_info("%s () clk_disabl, port->line %d, ir\n", __func__, port->line);
clk_disable(msm_hsl_port->pclk);
}
pr_info("%s ():port->line %d, ir\n", __func__, port->line);
msm_hsl_port->cir_class = class_create(THIS_MODULE, "htc_cir");
if (IS_ERR(msm_hsl_port->cir_class)) {
ret = PTR_ERR(msm_hsl_port->cir_class);
msm_hsl_port->cir_class = NULL;
return -ENXIO;
}
msm_hsl_port->cir_dev = device_create(msm_hsl_port->cir_class,
NULL, 0, "%s", "cir");
if (unlikely(IS_ERR(msm_hsl_port->cir_dev))) {
ret = PTR_ERR(msm_hsl_port->cir_dev);
msm_hsl_port->cir_dev = NULL;
goto err_create_ls_device;
}
ret = device_create_file(msm_hsl_port->cir_dev, &dev_attr_enable_cir);
if (ret)
goto err_create_ls_device_file;
ret = device_create_file(msm_hsl_port->cir_dev, &dev_attr_reset_cir);
if (ret)
goto err_create_ls_device_file;
enable_cir(0);
printk(KERN_INFO "[CIR] probe end.\n");
return ret;
err_create_ls_device_file:
device_unregister(msm_hsl_port->cir_dev);
err_create_ls_device:
class_destroy(msm_hsl_port->cir_class);
return ret;
return ret;
}
