| /* |
| * linux/drivers/mmc/host/ambarella_sd.c |
| * |
| * Copyright (C) 2006-2007, Ambarella, Inc. |
| * Anthony Ginger, <hfjiang@ambarella.com> |
| * |
| * Ambarella Media Processor Watch Dog Timer |
| * |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/moduleparam.h> |
| #include <linux/types.h> |
| #include <linux/timer.h> |
| #include <linux/miscdevice.h> |
| #include <linux/watchdog.h> |
| #include <linux/fs.h> |
| #include <linux/init.h> |
| #include <linux/platform_device.h> |
| #include <linux/interrupt.h> |
| #include <linux/clk.h> |
| #include <linux/slab.h> |
| |
| #include <asm/uaccess.h> |
| #include <asm/io.h> |
| |
| #include <plat/wdt.h> |
| |
| #define CONFIG_WDT_AMBARELLA_TIMEOUT (30) |
| |
| static int init_tmo = CONFIG_WDT_AMBARELLA_TIMEOUT; |
| module_param(init_tmo, int, S_IRUGO | S_IWUSR); |
| MODULE_PARM_DESC(init_tmo, "Watchdog timeout in seconds. default=" \ |
| __MODULE_STRING(CONFIG_WDT_AMBARELLA_TIMEOUT) ")"); |
| |
| static int init_mode = WDOG_CTR_RST_EN; //WDOG_CTR_INT_EN | WDOG_CTR_RST_EN |
| module_param(init_mode, int, S_IRUGO | S_IWUSR); |
| MODULE_PARM_DESC(init_mode, "Watchdog mode: 0x2=reset, 0x4=irq"); |
| |
| enum ambarella_wdt_state { |
| AMBA_WDT_CLOSE_STATE_DISABLE, |
| AMBA_WDT_CLOSE_STATE_ALLOW, |
| }; |
| struct ambarella_wdt_info { |
| unsigned char __iomem *regbase; |
| |
| struct device *dev; |
| struct resource *mem; |
| unsigned int irq; |
| |
| struct semaphore wdt_mutex; |
| |
| enum ambarella_wdt_state state; |
| |
| u32 tmo; |
| u32 boot_tmo; |
| |
| struct miscdevice wdt_dev; |
| struct ambarella_wdt_controller *pcontroller; |
| |
| u32 ctl_reg; |
| u32 init_mode; |
| u32 act_timeout; |
| }; |
| static struct ambarella_wdt_info *pwdtinfo = NULL; |
| |
| static void ambarella_wdt_keepalive(struct ambarella_wdt_info *pinfo) |
| { |
| amba_writel(pinfo->regbase + WDOG_RELOAD_OFFSET, pinfo->tmo); |
| amba_writel(pinfo->regbase + WDOG_RESTART_OFFSET, WDT_RESTART_VAL); |
| } |
| |
| static void ambarella_wdt_stop(struct ambarella_wdt_info *pinfo) |
| { |
| amba_writel(pinfo->regbase + WDOG_CONTROL_OFFSET, 0); |
| while(amba_readl(pinfo->regbase + WDOG_CONTROL_OFFSET) != 0); |
| } |
| |
| static void ambarella_wdt_start(struct ambarella_wdt_info *pinfo, u32 ctl_reg) |
| { |
| if (!ctl_reg) |
| ctl_reg = pinfo->init_mode | WDOG_CTR_EN; |
| pinfo->pcontroller->start(ctl_reg); |
| } |
| |
| static int ambarella_wdt_set_heartbeat(struct ambarella_wdt_info *pinfo, |
| u32 timeout) |
| { |
| int errorCode = 0; |
| u32 freq; |
| u32 max_tmo; |
| |
| freq = pinfo->pcontroller->get_pll(); |
| if (freq) |
| max_tmo = 0xFFFFFFFF / freq; |
| else { |
| dev_err(pinfo->dev, "freq == 0 !\n"); |
| errorCode = -EPERM; |
| goto ambarella_wdt_set_heartbeat_exit; |
| } |
| |
| if (timeout > max_tmo) { |
| dev_err(pinfo->dev, "max_tmo is %d, not %d.\n", |
| max_tmo, timeout); |
| errorCode = -EINVAL; |
| goto ambarella_wdt_set_heartbeat_exit; |
| } |
| |
| pinfo->tmo = timeout * freq; |
| pinfo->act_timeout = timeout; |
| ambarella_wdt_keepalive(pinfo); |
| |
| ambarella_wdt_set_heartbeat_exit: |
| return errorCode; |
| } |
| |
| static int ambarella_wdt_open(struct inode *inode, struct file *file) |
| { |
| int errorCode = -EBUSY; |
| struct ambarella_wdt_info *pinfo; |
| |
| pinfo = pwdtinfo; |
| |
| if (pinfo) { |
| file->private_data = pinfo; |
| |
| if(down_trylock(&pinfo->wdt_mutex)) { |
| errorCode = -EBUSY; |
| goto ambarella_wdt_open_exit; |
| } |
| |
| pinfo->state = AMBA_WDT_CLOSE_STATE_DISABLE; |
| |
| ambarella_wdt_stop(pinfo); |
| ambarella_wdt_keepalive(pinfo); |
| ambarella_wdt_start(pinfo, 0); |
| errorCode = nonseekable_open(inode, file); |
| } |
| |
| ambarella_wdt_open_exit: |
| return errorCode; |
| } |
| |
| static int ambarella_wdt_release(struct inode *inode, struct file *file) |
| { |
| int errorCode = -EBUSY; |
| struct ambarella_wdt_info *pinfo; |
| |
| pinfo = (struct ambarella_wdt_info *)file->private_data; |
| |
| if (pinfo) { |
| if (pinfo->state == AMBA_WDT_CLOSE_STATE_ALLOW) { |
| ambarella_wdt_stop(pinfo); |
| } else { |
| dev_notice(pinfo->dev, |
| "Not stopping watchdog, V first!\n"); |
| ambarella_wdt_keepalive(pinfo); |
| } |
| |
| pinfo->state = AMBA_WDT_CLOSE_STATE_DISABLE; |
| up(&pinfo->wdt_mutex); |
| errorCode = 0; |
| } |
| |
| return errorCode; |
| } |
| |
| static ssize_t ambarella_wdt_write(struct file *file, const char __user *data, |
| size_t len, loff_t *ppos) |
| { |
| int errorCode = -EBUSY; |
| struct ambarella_wdt_info *pinfo; |
| size_t i; |
| char c; |
| |
| pinfo = (struct ambarella_wdt_info *)file->private_data; |
| |
| if (pinfo && len) { |
| for (i = 0; i < len; i++) { |
| if (get_user(c, data + i)) { |
| errorCode = -EFAULT; |
| goto ambarella_wdt_write_exit; |
| } |
| |
| if (c == 'V') |
| pinfo->state = AMBA_WDT_CLOSE_STATE_ALLOW; |
| } |
| |
| ambarella_wdt_keepalive(pinfo); |
| errorCode = len; |
| } |
| |
| ambarella_wdt_write_exit: |
| return errorCode; |
| } |
| |
| static const struct watchdog_info ambarella_wdt_ident = { |
| .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, |
| .firmware_version = 0, |
| .identity = "ambarella-wdt", |
| }; |
| |
| static long ambarella_wdt_ioctl(struct file *file, |
| unsigned int cmd, unsigned long arg) |
| { |
| int errorCode = -EBUSY; |
| struct ambarella_wdt_info *pinfo; |
| void __user *argp = (void __user *)arg; |
| u32 __user *p = argp; |
| u32 new_tmo; |
| int options; |
| |
| pinfo = (struct ambarella_wdt_info *)file->private_data; |
| |
| if (pinfo) { |
| switch (cmd) { |
| case WDIOC_GETSUPPORT: |
| errorCode = copy_to_user(argp, &ambarella_wdt_ident, |
| sizeof(ambarella_wdt_ident)) ? -EFAULT : 0; |
| break; |
| |
| case WDIOC_GETSTATUS: |
| errorCode = put_user(0, p); |
| break; |
| |
| case WDIOC_GETBOOTSTATUS: |
| errorCode = put_user(pinfo->boot_tmo, p); |
| break; |
| |
| case WDIOC_KEEPALIVE: |
| ambarella_wdt_keepalive(pinfo); |
| errorCode = 0; |
| break; |
| |
| case WDIOC_SETTIMEOUT: |
| if (get_user(new_tmo, p)) { |
| errorCode = -EFAULT; |
| break; |
| } |
| errorCode = ambarella_wdt_set_heartbeat(pinfo, new_tmo); |
| if (errorCode) |
| break; |
| ambarella_wdt_keepalive(pinfo); |
| errorCode = put_user(pinfo->tmo, p); |
| break; |
| |
| case WDIOC_GETTIMEOUT: |
| errorCode = put_user(pinfo->tmo, p); |
| break; |
| |
| case WDIOC_SETOPTIONS: |
| if (get_user(options, p)) { |
| errorCode = -EFAULT; |
| break; |
| } |
| if (options & WDIOS_DISABLECARD) { |
| ambarella_wdt_stop(pinfo); |
| errorCode = 0; |
| } |
| if (options & WDIOS_ENABLECARD) { |
| ambarella_wdt_keepalive(pinfo); |
| errorCode = 0; |
| } |
| break; |
| |
| default: |
| errorCode = -ENOTTY; |
| break; |
| } |
| } |
| |
| return errorCode; |
| } |
| |
| static const struct file_operations ambarella_wdt_fops = { |
| .owner = THIS_MODULE, |
| .llseek = no_llseek, |
| .write = ambarella_wdt_write, |
| .unlocked_ioctl = ambarella_wdt_ioctl, |
| .open = ambarella_wdt_open, |
| .release = ambarella_wdt_release, |
| }; |
| |
| static irqreturn_t ambarella_wdt_irq(int irq, void *devid) |
| { |
| struct ambarella_wdt_info *pinfo; |
| |
| pinfo = (struct ambarella_wdt_info *)devid; |
| |
| amba_writel(pinfo->regbase + WDOG_CLR_TMO_OFFSET, 0x01); |
| |
| dev_info(pinfo->dev, "Watchdog timer expired!\n"); |
| |
| return IRQ_HANDLED; |
| } |
| |
| static int __devinit ambarella_wdt_probe(struct platform_device *pdev) |
| { |
| int errorCode = 0; |
| struct resource *irq; |
| struct resource *mem; |
| struct resource *ioarea; |
| struct ambarella_wdt_info *pinfo; |
| |
| mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| if (mem == NULL) { |
| dev_err(&pdev->dev, "Get WDT mem resource failed!\n"); |
| errorCode = -ENXIO; |
| goto ambarella_wdt_na; |
| } |
| |
| irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); |
| if (irq == NULL) { |
| dev_err(&pdev->dev, "Get WDT irq resource failed!\n"); |
| errorCode = -ENXIO; |
| goto ambarella_wdt_na; |
| } |
| |
| ioarea = request_mem_region(mem->start, |
| (mem->end - mem->start) + 1, pdev->name); |
| if (ioarea == NULL) { |
| dev_err(&pdev->dev, "Request WDT ioarea failed!\n"); |
| errorCode = -EBUSY; |
| goto ambarella_wdt_na; |
| } |
| |
| pinfo = kzalloc(sizeof(struct ambarella_wdt_info), |
| GFP_KERNEL); |
| if (pinfo == NULL) { |
| dev_err(&pdev->dev, "Out of memory!\n"); |
| errorCode = -ENOMEM; |
| goto ambarella_wdt_ioarea; |
| } |
| |
| pinfo->pcontroller = |
| (struct ambarella_wdt_controller *)pdev->dev.platform_data; |
| if ((pinfo->pcontroller == NULL) || |
| (pinfo->pcontroller->get_pll == NULL) || |
| (pinfo->pcontroller->start == NULL)) { |
| dev_err(&pdev->dev, "Need WDT controller info!\n"); |
| errorCode = -EPERM; |
| goto ambarella_wdt_free_pinfo; |
| } |
| |
| pinfo->regbase = (unsigned char __iomem *)mem->start; |
| pinfo->mem = mem; |
| pinfo->dev = &pdev->dev; |
| pinfo->irq = irq->start; |
| sema_init(&pinfo->wdt_mutex, 1); |
| pinfo->state = AMBA_WDT_CLOSE_STATE_DISABLE; |
| pinfo->wdt_dev.minor = WATCHDOG_MINOR, |
| pinfo->wdt_dev.name = "watchdog", |
| pinfo->wdt_dev.fops = &ambarella_wdt_fops, |
| pinfo->boot_tmo = amba_readl(pinfo->regbase + WDOG_TIMEOUT_OFFSET); |
| pinfo->init_mode = (init_mode & (WDOG_CTR_INT_EN | WDOG_CTR_RST_EN)); |
| platform_set_drvdata(pdev, pinfo); |
| pwdtinfo = pinfo; |
| |
| errorCode = ambarella_wdt_set_heartbeat(pinfo, init_tmo); |
| if (errorCode) |
| ambarella_wdt_set_heartbeat(pinfo, |
| CONFIG_WDT_AMBARELLA_TIMEOUT); |
| |
| errorCode = misc_register(&pinfo->wdt_dev); |
| if (errorCode) { |
| dev_err(&pdev->dev, "cannot register miscdev minor=%d (%d)\n", |
| WATCHDOG_MINOR, errorCode); |
| goto ambarella_wdt_free_pinfo; |
| } |
| |
| ambarella_wdt_stop(pinfo); |
| |
| errorCode = request_irq(pinfo->irq, ambarella_wdt_irq, |
| IRQF_TRIGGER_RISING, dev_name(&pdev->dev), pinfo); |
| if (errorCode) { |
| dev_err(&pdev->dev, "Request IRQ failed!\n"); |
| goto ambarella_wdt_deregister; |
| } |
| |
| dev_notice(&pdev->dev, |
| "Ambarella Media Processor Watch Dog Timer[%s].\n", |
| dev_name(&pdev->dev)); |
| |
| goto ambarella_wdt_na; |
| |
| ambarella_wdt_deregister: |
| errorCode = misc_deregister(&pinfo->wdt_dev); |
| |
| ambarella_wdt_free_pinfo: |
| kfree(pinfo); |
| |
| ambarella_wdt_ioarea: |
| release_mem_region(mem->start, (mem->end - mem->start) + 1); |
| |
| ambarella_wdt_na: |
| return errorCode; |
| } |
| |
| static int __devexit ambarella_wdt_remove(struct platform_device *pdev) |
| { |
| struct ambarella_wdt_info *pinfo; |
| int errorCode = 0; |
| |
| pinfo = platform_get_drvdata(pdev); |
| |
| if (pinfo) { |
| down(&pinfo->wdt_mutex); |
| errorCode = misc_deregister(&pinfo->wdt_dev); |
| ambarella_wdt_stop(pinfo); |
| free_irq(pinfo->irq, pinfo); |
| platform_set_drvdata(pdev, NULL); |
| pwdtinfo = NULL; |
| release_mem_region(pinfo->mem->start, |
| (pinfo->mem->end - pinfo->mem->start) + 1); |
| kfree(pinfo); |
| } |
| |
| dev_notice(&pdev->dev, |
| "Remove Ambarella Media Processor Watch Dog Timer[%s] [%d].\n", |
| dev_name(&pdev->dev), errorCode); |
| |
| return errorCode; |
| } |
| |
| static void ambarella_wdt_shutdown(struct platform_device *pdev) |
| { |
| struct ambarella_wdt_info *pinfo; |
| |
| pinfo = platform_get_drvdata(pdev); |
| |
| if (pinfo) |
| ambarella_wdt_stop(pinfo); |
| else |
| dev_err(&pdev->dev, "Cannot find valid pinfo\n"); |
| |
| dev_dbg(&pdev->dev, "%s exit.\n", __func__); |
| } |
| |
| #ifdef CONFIG_PM |
| static int ambarella_wdt_suspend(struct platform_device *pdev, |
| pm_message_t state) |
| { |
| struct ambarella_wdt_info *pinfo; |
| int errorCode = 0; |
| |
| pinfo = platform_get_drvdata(pdev); |
| |
| if (pinfo) { |
| disable_irq(pinfo->irq); |
| pinfo->ctl_reg = amba_readl(pinfo->regbase + |
| WDOG_CONTROL_OFFSET); |
| ambarella_wdt_stop(pinfo); |
| } else { |
| dev_err(&pdev->dev, "Cannot find valid pinfo\n"); |
| errorCode = -ENXIO; |
| } |
| |
| dev_dbg(&pdev->dev, "%s exit with %d @ %d\n", |
| __func__, errorCode, state.event); |
| |
| return errorCode; |
| } |
| |
| static int ambarella_wdt_resume(struct platform_device *pdev) |
| { |
| struct ambarella_wdt_info *pinfo; |
| int errorCode = 0; |
| |
| pinfo = platform_get_drvdata(pdev); |
| |
| if (pinfo) { |
| if (pinfo->ctl_reg) { |
| ambarella_wdt_set_heartbeat(pinfo, pinfo->act_timeout); |
| ambarella_wdt_start(pinfo, pinfo->ctl_reg); |
| } |
| enable_irq(pinfo->irq); |
| } else { |
| dev_err(&pdev->dev, "Cannot find valid pinfo\n"); |
| errorCode = -ENXIO; |
| } |
| |
| dev_dbg(&pdev->dev, "%s exit with %d\n", __func__, errorCode); |
| |
| return errorCode; |
| } |
| #endif |
| |
| static struct platform_driver ambarella_wdt_driver = { |
| .probe = ambarella_wdt_probe, |
| .remove = __devexit_p(ambarella_wdt_remove), |
| .shutdown = ambarella_wdt_shutdown, |
| #ifdef CONFIG_PM |
| .suspend = ambarella_wdt_suspend, |
| .resume = ambarella_wdt_resume, |
| #endif |
| .driver = { |
| .owner = THIS_MODULE, |
| .name = "ambarella-wdt", |
| }, |
| }; |
| |
| static int __init ambarella_wdt_init(void) |
| { |
| return platform_driver_register(&ambarella_wdt_driver); |
| } |
| |
| static void __exit ambarella_wdt_exit(void) |
| { |
| platform_driver_unregister(&ambarella_wdt_driver); |
| } |
| |
| module_init(ambarella_wdt_init); |
| module_exit(ambarella_wdt_exit); |
| |
| MODULE_DESCRIPTION("Ambarella Media Processor Watch Dog Timer"); |
| MODULE_AUTHOR("Anthony Ginger, <hfjiang@ambarella.com>"); |
| MODULE_LICENSE("GPL"); |
| |