static int watchdog_probe(struct platform_device *pdev) { int ret; struct watchdog_platform_data *pdata; unsigned long feeddog_pin; unsigned long wathdog_enable_pin; printk("watchdog: watchdog_probe\n"); pdata = pdev->dev.platform_data; wathdog_enable_pin= pdata->enable_pin; feeddog_pin= pdata->feeddog_pin; watchdog = kmalloc(sizeof(struct watchdog_dev), GFP_KERNEL); if(!watchdog) { printk("watchdog: no memory to malloc\n"); ret = -ENOMEM; goto exit; } watchdog->enable_pin = wathdog_enable_pin; watchdog->feeddog_pin = feeddog_pin; watchdog->state = WATCHDOG_FEED_PIN_INIT; ret = gpio_request(watchdog->enable_pin, "watchdog_enable"); if (ret < 0) { printk("watchdog: ERROR can not open GPIO %ld\n", wathdog_enable_pin); goto exit_kfree; } ret = gpio_request(watchdog->feeddog_pin, "watchdog_feeddog"); if (ret < 0) { printk("watchdog: ERROR can not open GPIO %ld\n", feeddog_pin); goto exit_kfree; } gpio_direction_output(watchdog->enable_pin,0); gpio_direction_output(watchdog->feeddog_pin,0); gpio_set_value(watchdog->feeddog_pin,watchdog->state); /* disable wathdog */ watchdog_disable(); ret = misc_register(&miscwatchdog); printk(" watchdog: misc register successed: \n"); if(ret < 0) { printk("watchdog: misc register error\n"); goto exit_kfree; } return ret; exit_kfree: kfree(watchdog); exit: return ret; }
static int __devinit d7s_probe(struct of_device *op, const struct of_device_id *match) { struct device_node *opts; int err = -EINVAL; struct d7s *p; u8 regs; if (d7s_device) goto out; p = kzalloc(sizeof(*p), GFP_KERNEL); err = -ENOMEM; if (!p) goto out; p->regs = of_ioremap(&op->resource[0], 0, sizeof(u8), "d7s"); if (!p->regs) { printk(KERN_ERR PFX "Cannot map chip registers\n"); goto out_free; } err = misc_register(&d7s_miscdev); if (err) { printk(KERN_ERR PFX "Unable to acquire miscdevice minor %i\n", D7S_MINOR); goto out_iounmap; } /* OBP option "d7s-flipped?" is honored as default for the * device, and reset default when detached */ regs = readb(p->regs); opts = of_find_node_by_path("/options"); if (opts && of_get_property(opts, "d7s-flipped?", NULL)) p->flipped = true; if (p->flipped) regs |= D7S_FLIP; else regs &= ~D7S_FLIP; writeb(regs, p->regs); printk(KERN_INFO PFX "7-Segment Display%s at [%s:0x%llx] %s\n", op->dev.of_node->full_name, (regs & D7S_FLIP) ? " (FLIPPED)" : "", op->resource[0].start, sol_compat ? "in sol_compat mode" : ""); dev_set_drvdata(&op->dev, p); d7s_device = p; err = 0; out: return err; out_iounmap: of_iounmap(&op->resource[0], p->regs, sizeof(u8)); out_free: kfree(p); goto out; }
static int __init at32_wdt_probe(struct platform_device *pdev) { struct resource *regs; int ret; if (wdt) { dev_dbg(&pdev->dev, "only 1 wdt instance supported.\n"); return -EBUSY; } regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!regs) { dev_dbg(&pdev->dev, "missing mmio resource\n"); return -ENXIO; } wdt = kzalloc(sizeof(struct wdt_at32ap700x), GFP_KERNEL); if (!wdt) { dev_dbg(&pdev->dev, "no memory for wdt structure\n"); return -ENOMEM; } wdt->regs = ioremap(regs->start, resource_size(regs)); if (!wdt->regs) { ret = -ENOMEM; dev_dbg(&pdev->dev, "could not map I/O memory\n"); goto err_free; } spin_lock_init(&wdt->io_lock); wdt->boot_status = at32_wdt_get_status(); /* Work-around for watchdog silicon errata. */ if (wdt->boot_status & WDIOF_CARDRESET) { dev_info(&pdev->dev, "CPU must be reset with external " "reset or POR due to silicon errata.\n"); ret = -EIO; goto err_iounmap; } else { wdt->users = 0; } wdt->miscdev.minor = WATCHDOG_MINOR; wdt->miscdev.name = "watchdog"; wdt->miscdev.fops = &at32_wdt_fops; wdt->miscdev.parent = &pdev->dev; platform_set_drvdata(pdev, wdt); if (at32_wdt_settimeout(timeout)) { at32_wdt_settimeout(TIMEOUT_DEFAULT); dev_dbg(&pdev->dev, "default timeout invalid, set to %d sec.\n", TIMEOUT_DEFAULT); } ret = misc_register(&wdt->miscdev); if (ret) { dev_dbg(&pdev->dev, "failed to register wdt miscdev\n"); goto err_register; } dev_info(&pdev->dev, "AT32AP700X WDT at 0x%p, timeout %d sec (nowayout=%d)\n", wdt->regs, wdt->timeout, nowayout); return 0; err_register: platform_set_drvdata(pdev, NULL); err_iounmap: iounmap(wdt->regs); err_free: kfree(wdt); wdt = NULL; return ret; }
static int __init tfa98xx_init(void) { pr_info("%s\n", __func__); misc_register(&tfa98xx_misc); return platform_driver_register(&tfa98xx_codec_driver); }
static int __init pikawdt_init(void) { struct device_node *np; void __iomem *fpga; static u32 post1; int ret; np = of_find_compatible_node(NULL, NULL, "pika,fpga"); if (np == NULL) { printk(KERN_ERR PFX "Unable to find fpga.\n"); return -ENOENT; } pikawdt_private.fpga = of_iomap(np, 0); of_node_put(np); if (pikawdt_private.fpga == NULL) { printk(KERN_ERR PFX "Unable to map fpga.\n"); return -ENOMEM; } ident.firmware_version = in_be32(pikawdt_private.fpga + 0x1c) & 0xffff; /* POST information is in the sd area. */ np = of_find_compatible_node(NULL, NULL, "pika,fpga-sd"); if (np == NULL) { printk(KERN_ERR PFX "Unable to find fpga-sd.\n"); ret = -ENOENT; goto out; } fpga = of_iomap(np, 0); of_node_put(np); if (fpga == NULL) { printk(KERN_ERR PFX "Unable to map fpga-sd.\n"); ret = -ENOMEM; goto out; } /* -- FPGA: POST Test Results Register 1 (32bit R/W) (Offset: 0x4040) -- * Bit 31, WDOG: Set to 1 when the last reset was caused by a watchdog * timeout. */ post1 = in_be32(fpga + 0x40); if (post1 & 0x80000000) pikawdt_private.bootstatus = WDIOF_CARDRESET; iounmap(fpga); setup_timer(&pikawdt_private.timer, pikawdt_ping, 0); ret = misc_register(&pikawdt_miscdev); if (ret) { printk(KERN_ERR PFX "Unable to register miscdev.\n"); goto out; } printk(KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n", heartbeat, nowayout); return 0; out: iounmap(pikawdt_private.fpga); return ret; }
static int lcd_misc_probe(struct platform_device *pdev) { return misc_register(&lcd_misc_dev); }
static int __devinit rk29_wdt_probe(struct platform_device *pdev) { struct resource *res; struct device *dev; int started = 0; int ret; int size; dev = &pdev->dev; wdt_dev = &pdev->dev; /* get the memory region for the watchdog timer */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (res == NULL) { dev_err(dev, "no memory resource specified\n"); return -ENOENT; } size = (res->end - res->start) + 1; wdt_mem = request_mem_region(res->start, size, pdev->name); if (wdt_mem == NULL) { dev_err(dev, "failed to get memory region\n"); ret = -ENOENT; goto err_req; } wdt_base = ioremap(res->start, size); if (wdt_base == NULL) { dev_err(dev, "failed to ioremap() region\n"); ret = -EINVAL; goto err_req; } DBG("probe: mapped wdt_base=%p\n", wdt_base); #ifdef CONFIG_RK29_FEED_DOG_BY_INTE wdt_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (wdt_irq == NULL) { dev_err(dev, "no irq resource specified\n"); ret = -ENOENT; goto err_map; } ret = request_irq(wdt_irq->start, rk29_wdt_irq_handler, 0, pdev->name, pdev); if (ret != 0) { dev_err(dev, "failed to install irq (%d)\n", ret); goto err_map; } #endif wdt_clock = clk_get(&pdev->dev, "wdt"); if (IS_ERR(wdt_clock)) { dev_err(dev, "failed to find watchdog clock source\n"); ret = PTR_ERR(wdt_clock); goto err_irq; } ret = misc_register(&rk29_wdt_miscdev); if (ret) { dev_err(dev, "cannot register miscdev on minor=%d (%d)\n", WATCHDOG_MINOR, ret); goto err_clk; } if (tmr_atboot && started == 0) { dev_info(dev, "starting watchdog timer\n"); rk29_wdt_start(); } else if (!tmr_atboot) { /* if we're not enabling the watchdog, then ensure it is * disabled if it has been left running from the bootloader * or other source */ rk29_wdt_stop(); } return 0; err_clk: clk_disable(wdt_clock); clk_put(wdt_clock); err_irq: free_irq(wdt_irq->start, pdev); err_map: iounmap(wdt_base); err_req: release_resource(wdt_mem); kfree(wdt_mem); return ret; }
static int __devinit pcwd_isa_probe(struct device *dev, unsigned int id) { int ret; if (debug >= DEBUG) printk(KERN_DEBUG PFX "pcwd_isa_probe id=%d\n", id); cards_found++; if (cards_found == 1) printk(KERN_INFO PFX "v%s Ken Hollis ([email protected])\n", WATCHDOG_VERSION); if (cards_found > 1) { printk(KERN_ERR PFX "This driver only supports 1 device\n"); return -ENODEV; } if (pcwd_ioports[id] == 0x0000) { printk(KERN_ERR PFX "No I/O-Address for card detected\n"); return -ENODEV; } pcwd_private.io_addr = pcwd_ioports[id]; spin_lock_init(&pcwd_private.io_lock); /* Check card's revision */ pcwd_private.revision = get_revision(); if (!request_region(pcwd_private.io_addr, (pcwd_private.revision == PCWD_REVISION_A) ? 2 : 4, "PCWD")) { printk(KERN_ERR PFX "I/O address 0x%04x already in use\n", pcwd_private.io_addr); ret = -EIO; goto error_request_region; } /* Initial variables */ pcwd_private.supports_temp = 0; temp_panic = 0; pcwd_private.boot_status = 0x0000; /* get the boot_status */ pcwd_get_status(&pcwd_private.boot_status); /* clear the "card caused reboot" flag */ pcwd_clear_status(); setup_timer(&pcwd_private.timer, pcwd_timer_ping, 0); /* Disable the board */ pcwd_stop(); /* Check whether or not the card supports the temperature device */ pcwd_check_temperature_support(); /* Show info about the card itself */ pcwd_show_card_info(); /* If heartbeat = 0 then we use the heartbeat from the dip-switches */ if (heartbeat == 0) heartbeat = heartbeat_tbl[(pcwd_get_option_switches() & 0x07)]; /* Check that the heartbeat value is within it's range; if not reset to the default */ if (pcwd_set_heartbeat(heartbeat)) { pcwd_set_heartbeat(WATCHDOG_HEARTBEAT); printk(KERN_INFO PFX "heartbeat value must be 2 <= heartbeat <= 7200, using %d\n", WATCHDOG_HEARTBEAT); } if (pcwd_private.supports_temp) { ret = misc_register(&temp_miscdev); if (ret) { printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n", TEMP_MINOR, ret); goto error_misc_register_temp; } } ret = misc_register(&pcwd_miscdev); if (ret) { printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n", WATCHDOG_MINOR, ret); goto error_misc_register_watchdog; } printk(KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n", heartbeat, nowayout); return 0; error_misc_register_watchdog: if (pcwd_private.supports_temp) misc_deregister(&temp_miscdev); error_misc_register_temp: release_region(pcwd_private.io_addr, (pcwd_private.revision == PCWD_REVISION_A) ? 2 : 4); error_request_region: pcwd_private.io_addr = 0x0000; cards_found--; return ret; }
static int __init q6_amrnb_in_init(void) { return misc_register(&q6_amrnb_in_misc); }
static int __init audio_wmapro_init(void) { return misc_register(&audio_wmapro_misc); }
static long wdog_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { void __user *argp = (void __user *)arg; int __user *p = argp; int new_heartbeat; int status; int options; uint32_t remaining; struct watchdog_info ident = { .options = WDIOF_SETTIMEOUT| WDIOF_MAGICCLOSE| WDIOF_KEEPALIVEPING, .firmware_version = 1, .identity = "BCM2708", }; switch (cmd) { case WDIOC_GETSUPPORT: return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0; case WDIOC_GETSTATUS: status = wdog_get_status(); return put_user(status, p); case WDIOC_GETBOOTSTATUS: return put_user(0, p); case WDIOC_KEEPALIVE: wdog_ping(); return 0; case WDIOC_SETTIMEOUT: if (get_user(new_heartbeat, p)) return -EFAULT; if (wdog_set_heartbeat(new_heartbeat)) return -EINVAL; wdog_ping(); /* Fall */ case WDIOC_GETTIMEOUT: return put_user(heartbeat, p); case WDIOC_GETTIMELEFT: remaining = WDOG_TICKS_TO_SECS(wdog_get_remaining()); return put_user(remaining, p); case WDIOC_SETOPTIONS: if (get_user(options, p)) return -EFAULT; if (options & WDIOS_DISABLECARD) wdog_stop(); if (options & WDIOS_ENABLECARD) wdog_start(wdog_ticks); return 0; default: return -ENOTTY; } } /** * @inode: inode of device * @file: file handle to device * * The watchdog device has been opened. The watchdog device is single * open and on opening we load the counters. */ static int wdog_open(struct inode *inode, struct file *file) { if (test_and_set_bit(0, &wdog_is_open)) return -EBUSY; /* * Activate */ wdog_start(wdog_ticks); return nonseekable_open(inode, file); } /** * @inode: inode to board * @file: file handle to board * * The watchdog has a configurable API. There is a religious dispute * between people who want their watchdog to be able to shut down and * those who want to be sure if the watchdog manager dies the machine * reboots. In the former case we disable the counters, in the latter * case you have to open it again very soon. */ static int wdog_release(struct inode *inode, struct file *file) { if (expect_close == 42) { wdog_stop(); } else { printk(KERN_CRIT "wdt: WDT device closed unexpectedly. WDT will not stop!\n"); wdog_ping(); } clear_bit(0, &wdog_is_open); expect_close = 0; return 0; } /** * @this: our notifier block * @code: the event being reported * @unused: unused * * Our notifier is called on system shutdowns. Turn the watchdog * off so that it does not fire during the next reboot. */ static int wdog_notify_sys(struct notifier_block *this, unsigned long code, void *unused) { if (code == SYS_DOWN || code == SYS_HALT) wdog_stop(); return NOTIFY_DONE; } /* * Kernel Interfaces */ static const struct file_operations wdog_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .write = wdog_write, .unlocked_ioctl = wdog_ioctl, .open = wdog_open, .release = wdog_release, }; static struct miscdevice wdog_miscdev = { .minor = WATCHDOG_MINOR, .name = "watchdog", .fops = &wdog_fops, }; /* * The WDT card needs to learn about soft shutdowns in order to * turn the timebomb registers off. */ static struct notifier_block wdog_notifier = { .notifier_call = wdog_notify_sys, }; /** * cleanup_module: * * Unload the watchdog. You cannot do this with any file handles open. * If your watchdog is set to continue ticking on close and you unload * it, well it keeps ticking. We won't get the interrupt but the board * will not touch PC memory so all is fine. You just have to load a new * module in 60 seconds or reboot. */ static void __exit wdog_exit(void) { misc_deregister(&wdog_miscdev); unregister_reboot_notifier(&wdog_notifier); } static int __init wdog_init(void) { int ret; /* Check that the heartbeat value is within it's range; if not reset to the default */ if (wdog_set_heartbeat(heartbeat)) { wdog_set_heartbeat(WD_TIMO); printk(KERN_INFO "bcm2708_wdog: heartbeat value must be " "0 < heartbeat < %d, using %d\n", WDOG_TICKS_TO_SECS(PM_WDOG_TIME_SET), WD_TIMO); } ret = register_reboot_notifier(&wdog_notifier); if (ret) { printk(KERN_ERR "wdt: cannot register reboot notifier (err=%d)\n", ret); goto out_reboot; } ret = misc_register(&wdog_miscdev); if (ret) { printk(KERN_ERR "wdt: cannot register miscdev on minor=%d (err=%d)\n", WATCHDOG_MINOR, ret); goto out_misc; } printk(KERN_INFO "bcm2708 watchdog, heartbeat=%d sec (nowayout=%d)\n", heartbeat, nowayout); return 0; out_misc: unregister_reboot_notifier(&wdog_notifier); out_reboot: return ret; }
static int __devinit p61_probe(struct spi_device *spi) { int ret = 0; struct p61_dev *p61_dev=NULL; unsigned int irq_flags; printk("P61 with irq without log Entry : %s\n", __FUNCTION__); NFC_DBG_MSG("chip select : %d , bus number = %d \n", spi->chip_select, spi->master->bus_num); p61_dev = kzalloc(sizeof(*p61_dev), GFP_KERNEL); if (p61_dev == NULL) { NFC_ERR_MSG("failed to allocate memory for module data\n"); ret = -ENOMEM; goto err_exit; } ret = gpio_request( P61_RST, "p61 reset"); if (ret < 0) { NFC_ERR_MSG("p61 gpio reset request failed = 0x%x\n", P61_RST); goto fail_gpio; } NFC_ERR_MSG("gpio_request returned = 0x%x\n", ret); ret = gpio_direction_output(P61_RST,0); if (ret < 0) { NFC_ERR_MSG("p61 gpio rst request failed gpio = 0x%x\n", P61_RST); goto fail_gpio; } NFC_ERR_MSG("gpio_direction_output returned = 0x%x\n", ret); #ifdef IRQ_ENABLE ret = gpio_request( P61_IRQ, "p61 irq"); if (ret < 0) { NFC_ERR_MSG("p61 gpio request failed gpio = 0x%x\n", P61_IRQ); goto err_exit0; } ret = gpio_direction_input(P61_IRQ); if (ret < 0) { NFC_ERR_MSG("p61 gpio request failed gpio = 0x%x\n", P61_IRQ); goto err_exit0; } #endif spi->bits_per_word = 8; spi->mode = SPI_MODE_0; spi->max_speed_hz = 7000000;//1000000; //spi->chip_select = SPI_NO_CS; ret = spi_setup(spi); if (ret < 0) { NFC_ERR_MSG("failed to do spi_setup()\n"); goto err_exit0; } p61_dev -> spi = spi; p61_dev -> p61_device.minor = MISC_DYNAMIC_MINOR; p61_dev -> p61_device.name = "p61"; p61_dev -> p61_device.fops = &p61_dev_fops; p61_dev -> p61_device.parent = &spi->dev; p61_dev -> ven_gpio = P61_RST; gpio_set_value(P61_RST, 1); msleep(20); printk("p61_dev->rst_gpio = %d\n ",P61_RST); #ifdef IRQ_ENABLE p61_dev->irq_gpio = P61_IRQ; #endif p61_set_data(spi, p61_dev); /* init mutex and queues */ init_waitqueue_head(&p61_dev->read_wq); mutex_init(&p61_dev->read_mutex); //spin_lock_init(&p61_dev->irq_enabled_lock); #ifdef IRQ_ENABLE spin_lock_init(&p61_dev->irq_enabled_lock); #endif ret = misc_register(&p61_dev->p61_device); if (ret < 0) { NFC_ERR_MSG("misc_register failed! %d\n", ret); goto err_exit0; } #ifdef IRQ_ENABLE p61_dev->spi->irq = gpio_to_irq(P61_IRQ); if ( p61_dev->spi->irq < 0) { NFC_ERR_MSG("gpio_to_irq request failed gpio = 0x%x\n", P61_IRQ); goto err_exit0; } /* request irq. the irq is set whenever the chip has data available * for reading. it is cleared when all data has been read. */ p61_dev->irq_enabled = true; irq_flags = IRQF_TRIGGER_RISING | IRQF_ONESHOT; ret = request_irq(p61_dev->spi->irq, p61_dev_irq_handler, irq_flags, p61_dev -> p61_device.name, p61_dev); if (ret) { NFC_ERR_MSG("request_irq failed\n"); goto err_exit0; } p61_disable_irq(p61_dev); #endif NFC_DBG_MSG("Exit : %s\n", __FUNCTION__); return ret; // err_exit1: // misc_deregister(&p61_dev->p61_device); err_exit0: mutex_destroy(&p61_dev->read_mutex); if(p61_dev != NULL) kfree(p61_dev); fail_gpio: gpio_free(P61_RST); err_exit: return ret; }
static int wafwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { int new_timeout; void __user *argp = (void __user *)arg; int __user *p = argp; static struct watchdog_info ident = { .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE, .firmware_version = 1, .identity = "Wafer 5823 WDT", }; switch (cmd) { case WDIOC_GETSUPPORT: if (copy_to_user(argp, &ident, sizeof (ident))) return -EFAULT; break; case WDIOC_GETSTATUS: case WDIOC_GETBOOTSTATUS: return put_user(0, p); case WDIOC_KEEPALIVE: wafwdt_ping(); break; case WDIOC_SETTIMEOUT: if (get_user(new_timeout, p)) return -EFAULT; if ((new_timeout < 1) || (new_timeout > 255)) return -EINVAL; timeout = new_timeout; wafwdt_stop(); wafwdt_start(); /* Fall */ case WDIOC_GETTIMEOUT: return put_user(timeout, p); case WDIOC_SETOPTIONS: { int options, retval = -EINVAL; if (get_user(options, p)) return -EFAULT; if (options & WDIOS_DISABLECARD) { wafwdt_start(); retval = 0; } if (options & WDIOS_ENABLECARD) { wafwdt_stop(); retval = 0; } return retval; } default: return -ENOIOCTLCMD; } return 0; } static int wafwdt_open(struct inode *inode, struct file *file) { if (test_and_set_bit(0, &wafwdt_is_open)) return -EBUSY; /* * Activate */ wafwdt_start(); return nonseekable_open(inode, file); } static int wafwdt_close(struct inode *inode, struct file *file) { if (expect_close == 42) { wafwdt_stop(); } else { printk(KERN_CRIT PFX "WDT device closed unexpectedly. WDT will not stop!\n"); wafwdt_ping(); } clear_bit(0, &wafwdt_is_open); expect_close = 0; return 0; } /* * Notifier for system down */ static int wafwdt_notify_sys(struct notifier_block *this, unsigned long code, void *unused) { if (code == SYS_DOWN || code == SYS_HALT) { /* Turn the WDT off */ wafwdt_stop(); } return NOTIFY_DONE; } /* * Kernel Interfaces */ static struct file_operations wafwdt_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .write = wafwdt_write, .ioctl = wafwdt_ioctl, .open = wafwdt_open, .release = wafwdt_close, }; static struct miscdevice wafwdt_miscdev = { .minor = WATCHDOG_MINOR, .name = "watchdog", .fops = &wafwdt_fops, }; /* * The WDT needs to learn about soft shutdowns in order to * turn the timebomb registers off. */ static struct notifier_block wafwdt_notifier = { .notifier_call = wafwdt_notify_sys, }; static int __init wafwdt_init(void) { int ret; printk(KERN_INFO "WDT driver for Wafer 5823 single board computer initialising.\n"); spin_lock_init(&wafwdt_lock); if (timeout < 1 || timeout > 255) { timeout = WD_TIMO; printk (KERN_INFO PFX "timeout value must be 1<=x<=255, using %d\n", timeout); } if (wdt_stop != wdt_start) { if(!request_region(wdt_stop, 1, "Wafer 5823 WDT")) { printk (KERN_ERR PFX "I/O address 0x%04x already in use\n", wdt_stop); ret = -EIO; goto error; } } if(!request_region(wdt_start, 1, "Wafer 5823 WDT")) { printk (KERN_ERR PFX "I/O address 0x%04x already in use\n", wdt_start); ret = -EIO; goto error2; } ret = register_reboot_notifier(&wafwdt_notifier); if (ret != 0) { printk (KERN_ERR PFX "cannot register reboot notifier (err=%d)\n", ret); goto error3; } ret = misc_register(&wafwdt_miscdev); if (ret != 0) { printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n", WATCHDOG_MINOR, ret); goto error4; } printk (KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d)\n", timeout, nowayout); return ret; error4: unregister_reboot_notifier(&wafwdt_notifier); error3: release_region(wdt_start, 1); error2: if (wdt_stop != wdt_start) release_region(wdt_stop, 1); error: return ret; } static void __exit wafwdt_exit(void) { misc_deregister(&wafwdt_miscdev); unregister_reboot_notifier(&wafwdt_notifier); if(wdt_stop != wdt_start) release_region(wdt_stop, 1); release_region(wdt_start, 1); }
static int __init touchkey_init(void) { int ret = 0; u8 updated = 0; if ((ret = gpio_request(_3_GPIO_TOUCH_EN, "_3_GPIO_TOUCH_EN"))) printk(KERN_ERR "Failed to request gpio %s:%d\n", __func__, __LINE__); // if (ret = gpio_request(_3_GPIO_TOUCH_INT, "_3_GPIO_TOUCH_INT")) // printk(KERN_ERR "Failed to request gpio %s:%d\n", __func__, __LINE__); ret = misc_register(&touchkey_update_device); if (ret) { printk(KERN_ERR "%s misc_register fail\n",__FUNCTION__); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_touchkey_activation) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touchkey_activation\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touchkey_activation.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_touchkey_version) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touchkey_version\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touchkey_version.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_touchkey_recommend) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touchkey_recommend\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touchkey_recommend.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_touchkey_firmup) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touchkey_firmup\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touchkey_firmup.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_touchkey_init) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touchkey_init\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touchkey_init.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_touchkey_menu) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touchkey_menu\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touchkey_menu.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_touchkey_back) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touchkey_back\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touchkey_back.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_brightness) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_brightness\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_brightness.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_enable_disable) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touch_update\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_enable_disable.attr.name); } init_hw(); get_touchkey_data(version_info, 3); printk(TCHKEY_KERN_DEBUG "%s F/W version: 0x%x, Module version:0x%x\n",__FUNCTION__, version_info[1], version_info[2]); //------------------- Auto Firmware Update Routine Start -------------------// if(HWREV>=8) { if(version_info[1]==0xff) //unknown firmware state { if(!mcsdl_download_binary_data(MCS5000_CHIP)) //try MCS-5000 download mcsdl_download_binary_data(MCS5080_CHIP); // if first try is fail, MCS-5080 download updated = 1; } else { if(version_info[2]>=MCS5000_CHIP) //MCS-5000 { if(version_info[1]!=MCS5000_last_ver) //not latest version { mcsdl_download_binary_data(MCS5000_CHIP); updated = 1; } } else if(version_info[2]==MCS5080_CHIP)//MCS-5080 { if(version_info[1]!=MCS5080_last_ver) //not latest version { mcsdl_download_binary_data(MCS5080_CHIP); updated = 1; } } else printk("Touchkey IC module is old, can't update!"); } if(updated) { get_touchkey_data(version_info, 3); printk(TCHKEY_KERN_DEBUG "Updated F/W version: 0x%x, Module version:0x%x\n", version_info[1], version_info[2]); } } //------------------- Auto Firmware Update Routine End -------------------// ret = i2c_add_driver(&touchkey_i2c_driver); if(ret||(touchkey_driver==NULL)) { touchkey_dead = 1; printk("ret = %d, touch_driver= %p:", ret, touchkey_driver); printk(KERN_ERR "melfas touch keypad registration failed, module not inserted.ret= %d\n", ret); } return ret; }
static ssize_t lpa_if_write(struct file *file, const char __user *buf, size_t count, loff_t *pos) { struct lpa_if *lpa_if = file->private_data; struct audio_buffer *ab; const char __user *start = buf; int xfer, rc; struct sched_param s = { .sched_priority = 1 }; int old_prio = current->rt_priority; int old_policy = current->policy; int cap_nice = cap_raised(current_cap(), CAP_SYS_NICE); if (!task_has_rt_policy(current)) { struct cred *new = prepare_creds(); cap_raise(new->cap_effective, CAP_SYS_NICE); commit_creds(new); if ((sched_setscheduler(current, SCHED_RR, &s)) < 0) pr_err("sched_setscheduler failed\n"); } mutex_lock(&lpa_if->lock); if (dma_buf_index < 2) { ab = lpa_if->audio_buf + dma_buf_index; if (copy_from_user(ab->data, buf, count)) { pr_err("copy from user failed\n"); rc = 0; goto end; } mb(); pr_debug("prefill: count %u audio_buf[%u].size %u\n", count, dma_buf_index, ab->size); ab->used = 1; dma_buf_index++; rc = count; goto end; } if (lpa_if->config != 1) { pr_err("AUDIO_START did not happen\n"); rc = 0; goto end; } while (count > 0) { ab = lpa_if->audio_buf + lpa_if->cpu_buf; rc = wait_event_timeout(lpa_if->wait, (ab->used == 0), 10 * HZ); if (!rc) { pr_err("wait_event_timeout failed\n"); rc = buf - start; goto end; } xfer = count; if (xfer > lpa_if->dma_period_sz) xfer = lpa_if->dma_period_sz; if (copy_from_user(ab->data, buf, xfer)) { pr_err("copy from user failed\n"); rc = buf - start; goto end; } mb(); buf += xfer; count -= xfer; ab->used = 1; pr_debug("xfer %d, size %d, used %d cpu_buf %d\n", xfer, ab->size, ab->used, lpa_if->cpu_buf); lpa_if->cpu_buf++; lpa_if->cpu_buf = lpa_if->cpu_buf % lpa_if->cfg.buffer_count; } rc = buf - start; end: mutex_unlock(&lpa_if->lock); if (!rt_policy(old_policy)) { struct sched_param v = { .sched_priority = old_prio }; if ((sched_setscheduler(current, old_policy, &v)) < 0) pr_err("sched_setscheduler failed\n"); if (likely(!cap_nice)) { struct cred *new = prepare_creds(); cap_lower(new->cap_effective, CAP_SYS_NICE); commit_creds(new); } } return rc; } static int lpa_if_release(struct inode *inode, struct file *file) { struct lpa_if *lpa_if = file->private_data; hdmi_audio_packet_enable(0); wait_for_dma_cnt_stop(lpa_if->dma_ch); hdmi_audio_enable(0, HDMI_AUDIO_FIFO_WATER_MARK); if (lpa_if->config) { unregister_dma_irq_handler(lpa_if->dma_ch); dai_stop_hdmi(lpa_if->dma_ch); lpa_if->config = 0; } core_req_bus_bandwith(AUDIO_IF_BUS_ID, 0, 0); if (hdmi_msm_audio_get_sample_rate() != HDMI_SAMPLE_RATE_48KHZ) hdmi_msm_audio_sample_rate_reset(HDMI_SAMPLE_RATE_48KHZ); return 0; } static const struct file_operations lpa_if_fops = { .owner = THIS_MODULE, .open = lpa_if_open, .write = lpa_if_write, .release = lpa_if_release, .unlocked_ioctl = lpa_if_ioctl, }; struct miscdevice lpa_if_misc = { .minor = MISC_DYNAMIC_MINOR, .name = "msm_lpa_if_out", .fops = &lpa_if_fops, }; static int __init lpa_if_init(void) { int rc; lpa_if_ptr = kzalloc(sizeof(struct lpa_if), GFP_KERNEL); if (!lpa_if_ptr) { pr_info("No mem for lpa-if\n"); return -ENOMEM; } mutex_init(&lpa_if_ptr->lock); init_waitqueue_head(&lpa_if_ptr->wait); lpa_if_ptr->buffer = dma_alloc_coherent(NULL, DMA_ALLOC_BUF_SZ, &(lpa_if_ptr->buffer_phys), GFP_KERNEL); if (!lpa_if_ptr->buffer) { pr_err("dma_alloc_coherent failed\n"); kfree(lpa_if_ptr); return -ENOMEM; } pr_info("lpa_if_ptr 0x%08x buf_vir 0x%08x buf_phy 0x%08x " " buf_zise %u\n", (u32)lpa_if_ptr, (u32)(lpa_if_ptr->buffer), lpa_if_ptr->buffer_phys, DMA_ALLOC_BUF_SZ); rc = misc_register(&lpa_if_misc); if (rc < 0) { pr_err("misc_register failed\n"); dma_free_coherent(NULL, DMA_ALLOC_BUF_SZ, lpa_if_ptr->buffer, lpa_if_ptr->buffer_phys); kfree(lpa_if_ptr); } return rc; } device_initcall(lpa_if_init);
static int tegra_camera_probe(struct platform_device *pdev) { int err; struct tegra_camera_dev *dev; dev_info(&pdev->dev, "%s\n", __func__); dev = devm_kzalloc(&pdev->dev, sizeof(struct tegra_camera_dev), GFP_KERNEL); if (!dev) { err = -ENOMEM; dev_err(&pdev->dev, "%s: unable to allocate memory\n", __func__); goto alloc_err; } mutex_init(&dev->tegra_camera_lock); /* Powergate VE when boot */ mutex_lock(&dev->tegra_camera_lock); #ifndef CONFIG_ARCH_TEGRA_2x_SOC err = tegra_powergate_partition(TEGRA_POWERGATE_VENC); if (err) dev_err(&pdev->dev, "%s: powergate failed.\n", __func__); #endif mutex_unlock(&dev->tegra_camera_lock); dev->dev = &pdev->dev; /* Get regulator pointer */ #ifdef CONFIG_ARCH_TEGRA_2x_SOC dev->reg = regulator_get(&pdev->dev, "vcsi"); #else dev->reg = regulator_get(&pdev->dev, "avdd_dsi_csi"); #endif if (IS_ERR_OR_NULL(dev->reg)) { if (dev->reg == ERR_PTR(-ENODEV)) { dev->reg = NULL; dev_info(&pdev->dev, "%s: no regulator device, overriding\n", __func__); } else { dev_err(&pdev->dev, "%s: couldn't get regulator\n", __func__); return PTR_ERR(dev->reg); } } dev->misc_dev.minor = MISC_DYNAMIC_MINOR; dev->misc_dev.name = TEGRA_CAMERA_NAME; dev->misc_dev.fops = &tegra_camera_fops; dev->misc_dev.parent = &pdev->dev; err = misc_register(&dev->misc_dev); if (err) { dev_err(&pdev->dev, "%s: Unable to register misc device!\n", TEGRA_CAMERA_NAME); goto misc_register_err; } err = tegra_camera_clk_get(pdev, "isp", &dev->isp_clk); if (err) goto misc_register_err; err = tegra_camera_clk_get(pdev, "vi", &dev->vi_clk); if (err) goto vi_clk_get_err; err = tegra_camera_clk_get(pdev, "vi_sensor", &dev->vi_sensor_clk); if (err) goto vi_sensor_clk_get_err; err = tegra_camera_clk_get(pdev, "csus", &dev->csus_clk); if (err) goto csus_clk_get_err; err = tegra_camera_clk_get(pdev, "csi", &dev->csi_clk); if (err) goto csi_clk_get_err; err = tegra_camera_clk_get(pdev, "emc", &dev->emc_clk); if (err) goto emc_clk_get_err; /* dev is set in order to restore in _remove */ platform_set_drvdata(pdev, dev); tegra_camera_dev = dev;//shanying added for read sensor id return 0; emc_clk_get_err: clk_put(dev->emc_clk); csi_clk_get_err: clk_put(dev->csus_clk); csus_clk_get_err: clk_put(dev->vi_sensor_clk); vi_sensor_clk_get_err: clk_put(dev->vi_clk); vi_clk_get_err: clk_put(dev->isp_clk); misc_register_err: regulator_put(dev->reg); alloc_err: return err; }
static long asr_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { static const struct watchdog_info ident = { .options = WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, .identity = "IBM ASR", }; void __user *argp = (void __user *)arg; int __user *p = argp; int heartbeat; switch (cmd) { case WDIOC_GETSUPPORT: return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0; case WDIOC_GETSTATUS: case WDIOC_GETBOOTSTATUS: return put_user(0, p); case WDIOC_SETOPTIONS: { int new_options, retval = -EINVAL; if (get_user(new_options, p)) return -EFAULT; if (new_options & WDIOS_DISABLECARD) { asr_disable(); retval = 0; } if (new_options & WDIOS_ENABLECARD) { asr_enable(); asr_toggle(); retval = 0; } return retval; } case WDIOC_KEEPALIVE: asr_toggle(); return 0; /* */ case WDIOC_GETTIMEOUT: heartbeat = 256; return put_user(heartbeat, p); default: return -ENOTTY; } } static int asr_open(struct inode *inode, struct file *file) { if (test_and_set_bit(0, &asr_is_open)) return -EBUSY; asr_toggle(); asr_enable(); return nonseekable_open(inode, file); } static int asr_release(struct inode *inode, struct file *file) { if (asr_expect_close == 42) asr_disable(); else { pr_crit("unexpected close, not stopping watchdog!\n"); asr_toggle(); } clear_bit(0, &asr_is_open); asr_expect_close = 0; return 0; } static const struct file_operations asr_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .write = asr_write, .unlocked_ioctl = asr_ioctl, .open = asr_open, .release = asr_release, }; static struct miscdevice asr_miscdev = { .minor = WATCHDOG_MINOR, .name = "watchdog", .fops = &asr_fops, }; struct ibmasr_id { const char *desc; int type; }; static struct ibmasr_id __initdata ibmasr_id_table[] = { { "IBM Automatic Server Restart - eserver xSeries 220", ASMTYPE_TOPAZ }, { "IBM Automatic Server Restart - Machine Type 8673", ASMTYPE_PEARL }, { "IBM Automatic Server Restart - Machine Type 8480", ASMTYPE_JASPER }, { "IBM Automatic Server Restart - Machine Type 8482", ASMTYPE_JUNIPER }, { "IBM Automatic Server Restart - Machine Type 8648", ASMTYPE_SPRUCE }, { NULL } }; static int __init ibmasr_init(void) { struct ibmasr_id *id; int rc; for (id = ibmasr_id_table; id->desc; id++) { if (dmi_find_device(DMI_DEV_TYPE_OTHER, id->desc, NULL)) { asr_type = id->type; break; } } if (!asr_type) return -ENODEV; rc = asr_get_base_address(); if (rc) return rc; rc = misc_register(&asr_miscdev); if (rc < 0) { release_region(asr_base, asr_length); pr_err("failed to register misc device\n"); return rc; } return 0; } static void __exit ibmasr_exit(void) { if (!nowayout) asr_disable(); misc_deregister(&asr_miscdev); release_region(asr_base, asr_length); } module_init(ibmasr_init); module_exit(ibmasr_exit); module_param(nowayout, bool, 0); MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); MODULE_DESCRIPTION("IBM Automatic Server Restart driver"); MODULE_AUTHOR("Andrey Panin"); MODULE_LICENSE("GPL"); MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
static int ksb_usb_probe(struct usb_interface *ifc, const struct usb_device_id *id) { __u8 ifc_num; struct usb_host_interface *ifc_desc; struct usb_endpoint_descriptor *ep_desc; int i; struct ks_bridge *ksb; ifc_num = ifc->cur_altsetting->desc.bInterfaceNumber; switch (id->idProduct) { case 0x9008: if (ifc_num != 0) return -ENODEV; ksb = __ksb[BOOT_BRIDGE_INDEX]; break; case 0x9048: case 0x904C: if (ifc_num != 2) return -ENODEV; ksb = __ksb[EFS_BRIDGE_INDEX]; break; default: return -ENODEV; } if (!ksb) { pr_err("ksb is not initialized"); return -ENODEV; } ksb->udev = usb_get_dev(interface_to_usbdev(ifc)); ksb->ifc = ifc; ifc_desc = ifc->cur_altsetting; for (i = 0; i < ifc_desc->desc.bNumEndpoints; i++) { ep_desc = &ifc_desc->endpoint[i].desc; if (!ksb->in_epAddr && usb_endpoint_is_bulk_in(ep_desc)) ksb->in_epAddr = ep_desc->bEndpointAddress; if (!ksb->out_epAddr && usb_endpoint_is_bulk_out(ep_desc)) ksb->out_epAddr = ep_desc->bEndpointAddress; } if (!(ksb->in_epAddr && ksb->out_epAddr)) { pr_err("could not find bulk in and bulk out endpoints"); usb_put_dev(ksb->udev); ksb->ifc = NULL; return -ENODEV; } ksb->in_pipe = usb_rcvbulkpipe(ksb->udev, ksb->in_epAddr); ksb->out_pipe = usb_sndbulkpipe(ksb->udev, ksb->out_epAddr); usb_set_intfdata(ifc, ksb); set_bit(USB_DEV_CONNECTED, &ksb->flags); dbg_log_event(ksb, "PID-ATT", id->idProduct, 0); ksb->fs_dev = (struct miscdevice *)id->driver_info; misc_register(ksb->fs_dev); usb_enable_autosuspend(ksb->udev); pr_debug("usb dev connected"); return 0; }
static int __init test_module_init(void) { test_dbg("test_module_init ...\n"); return misc_register(&test_module_miscdev); }
static void ipmi_register_watchdog(int ipmi_intf) { int rv = -EBUSY; if (watchdog_user) goto out; if ((ifnum_to_use >= 0) && (ifnum_to_use != ipmi_intf)) goto out; watchdog_ifnum = ipmi_intf; rv = ipmi_create_user(ipmi_intf, &ipmi_hndlrs, NULL, &watchdog_user); if (rv < 0) { printk(KERN_CRIT PFX "Unable to register with ipmi\n"); goto out; } rv = ipmi_get_version(watchdog_user, &ipmi_version_major, &ipmi_version_minor); if (rv) { pr_warn(PFX "Unable to get IPMI version, assuming 1.0\n"); ipmi_version_major = 1; ipmi_version_minor = 0; } rv = misc_register(&ipmi_wdog_miscdev); if (rv < 0) { ipmi_destroy_user(watchdog_user); watchdog_user = NULL; printk(KERN_CRIT PFX "Unable to register misc device\n"); } #ifdef HAVE_DIE_NMI if (nmi_handler_registered) { int old_pretimeout = pretimeout; int old_timeout = timeout; int old_preop_val = preop_val; /* * Set the pretimeout to go off in a second and give * ourselves plenty of time to stop the timer. */ ipmi_watchdog_state = WDOG_TIMEOUT_RESET; preop_val = WDOG_PREOP_NONE; /* Make sure nothing happens */ pretimeout = 99; timeout = 100; testing_nmi = 1; rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB); if (rv) { printk(KERN_WARNING PFX "Error starting timer to" " test NMI: 0x%x. The NMI pretimeout will" " likely not work\n", rv); rv = 0; goto out_restore; } msleep(1500); if (testing_nmi != 2) { printk(KERN_WARNING PFX "IPMI NMI didn't seem to" " occur. The NMI pretimeout will" " likely not work\n"); } out_restore: testing_nmi = 0; preop_val = old_preop_val; pretimeout = old_pretimeout; timeout = old_timeout; } #endif out: if ((start_now) && (rv == 0)) { /* Run from startup, so start the timer now. */ start_now = 0; /* Disable this function after first startup. */ ipmi_watchdog_state = action_val; ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB); printk(KERN_INFO PFX "Starting now!\n"); } else { /* Stop the timer now. */ ipmi_watchdog_state = WDOG_TIMEOUT_NONE; ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB); } }
static int __init exemple_init (void) { return misc_register(& exemple_misc_driver); }
static int __devinit stm_probe(struct platform_device *pdev) { int ret; struct device *dev = &pdev->dev; struct coresight_platform_data *pdata; struct stm_drvdata *drvdata; struct resource *res; size_t res_size, bitmap_size; struct coresight_desc *desc; if (pdev->dev.of_node) { pdata = of_get_coresight_platform_data(dev, pdev->dev.of_node); if (IS_ERR(pdata)) return PTR_ERR(pdata); pdev->dev.platform_data = pdata; } drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL); if (!drvdata) return -ENOMEM; /* Store the driver data pointer for use in exported functions */ stmdrvdata = drvdata; drvdata->dev = &pdev->dev; platform_set_drvdata(pdev, drvdata); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -ENODEV; drvdata->base = devm_ioremap(dev, res->start, resource_size(res)); if (!drvdata->base) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 1); if (!res) return -ENODEV; if (boot_nr_channel) { res_size = min((resource_size_t)(boot_nr_channel * BYTES_PER_CHANNEL), resource_size(res)); bitmap_size = boot_nr_channel * sizeof(long); } else { res_size = min((resource_size_t)(NR_STM_CHANNEL * BYTES_PER_CHANNEL), resource_size(res)); bitmap_size = NR_STM_CHANNEL * sizeof(long); } drvdata->chs.base = devm_ioremap(dev, res->start, res_size); if (!drvdata->chs.base) return -ENOMEM; drvdata->chs.bitmap = devm_kzalloc(dev, bitmap_size, GFP_KERNEL); if (!drvdata->chs.bitmap) return -ENOMEM; spin_lock_init(&drvdata->spinlock); drvdata->clk = devm_clk_get(dev, "core_clk"); if (IS_ERR(drvdata->clk)) return PTR_ERR(drvdata->clk); ret = clk_set_rate(drvdata->clk, CORESIGHT_CLK_RATE_TRACE); if (ret) return ret; drvdata->entity = OST_ENTITY_ALL; desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL); if (!desc) return -ENOMEM; desc->type = CORESIGHT_DEV_TYPE_SOURCE; desc->subtype.source_subtype = CORESIGHT_DEV_SUBTYPE_SOURCE_SOFTWARE; desc->ops = &stm_cs_ops; desc->pdata = pdev->dev.platform_data; desc->dev = &pdev->dev; desc->groups = stm_attr_grps; desc->owner = THIS_MODULE; drvdata->csdev = coresight_register(desc); if (IS_ERR(drvdata->csdev)) return PTR_ERR(drvdata->csdev); drvdata->miscdev.name = ((struct coresight_platform_data *) (pdev->dev.platform_data))->name; drvdata->miscdev.minor = MISC_DYNAMIC_MINOR; drvdata->miscdev.fops = &stm_fops; ret = misc_register(&drvdata->miscdev); if (ret) goto err; dev_info(drvdata->dev, "STM initialized\n"); if (boot_enable) coresight_enable(drvdata->csdev); return 0; err: coresight_unregister(drvdata->csdev); return ret; }
static long rc32434_wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { void __user *argp = (void __user *)arg; int new_timeout; unsigned int value; static struct watchdog_info ident = { .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, .identity = "RC32434_WDT Watchdog", }; switch (cmd) { case WDIOC_GETSUPPORT: if (copy_to_user(argp, &ident, sizeof(ident))) return -EFAULT; break; case WDIOC_GETSTATUS: case WDIOC_GETBOOTSTATUS: value = 0; if (copy_to_user(argp, &value, sizeof(int))) return -EFAULT; break; case WDIOC_SETOPTIONS: if (copy_from_user(&value, argp, sizeof(int))) return -EFAULT; switch (value) { case WDIOS_ENABLECARD: rc32434_wdt_start(); break; case WDIOS_DISABLECARD: rc32434_wdt_stop(); break; default: return -EINVAL; } break; case WDIOC_KEEPALIVE: rc32434_wdt_ping(); break; case WDIOC_SETTIMEOUT: if (copy_from_user(&new_timeout, argp, sizeof(int))) return -EFAULT; if (rc32434_wdt_set(new_timeout)) return -EINVAL; /* Fall through */ case WDIOC_GETTIMEOUT: return copy_to_user(argp, &timeout, sizeof(int)); default: return -ENOTTY; } return 0; } static const struct file_operations rc32434_wdt_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .write = rc32434_wdt_write, .unlocked_ioctl = rc32434_wdt_ioctl, .open = rc32434_wdt_open, .release = rc32434_wdt_release, }; static struct miscdevice rc32434_wdt_miscdev = { .minor = WATCHDOG_MINOR, .name = "watchdog", .fops = &rc32434_wdt_fops, }; static char banner[] __devinitdata = KERN_INFO PFX "Watchdog Timer version " VERSION ", timer margin: %d sec\n"; static int __devinit rc32434_wdt_probe(struct platform_device *pdev) { int ret; struct resource *r; r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rb532_wdt_res"); if (!r) { printk(KERN_ERR PFX "failed to retrieve resources\n"); return -ENODEV; } wdt_reg = ioremap_nocache(r->start, r->end - r->start); if (!wdt_reg) { printk(KERN_ERR PFX "failed to remap I/O resources\n"); return -ENXIO; } spin_lock_init(&rc32434_wdt_device.io_lock); /* Make sure the watchdog is not running */ rc32434_wdt_stop(); /* Check that the heartbeat value is within it's range; * if not reset to the default */ if (rc32434_wdt_set(timeout)) { rc32434_wdt_set(WATCHDOG_TIMEOUT); printk(KERN_INFO PFX "timeout value must be between 0 and %d\n", WTCOMP2SEC((u32)-1)); } ret = misc_register(&rc32434_wdt_miscdev); if (ret < 0) { printk(KERN_ERR PFX "failed to register watchdog device\n"); goto unmap; } printk(banner, timeout); return 0; unmap: iounmap(wdt_reg); return ret; } static int __devexit rc32434_wdt_remove(struct platform_device *pdev) { misc_deregister(&rc32434_wdt_miscdev); iounmap(wdt_reg); return 0; }
static long fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { void __user *argp = (void __user *)arg; int __user *p = argp; static const struct watchdog_info ident = { .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE, .firmware_version = 1, .identity = "W83877F", }; switch (cmd) { case WDIOC_GETSUPPORT: return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0; case WDIOC_GETSTATUS: case WDIOC_GETBOOTSTATUS: return put_user(0, p); case WDIOC_SETOPTIONS: { int new_options, retval = -EINVAL; if (get_user(new_options, p)) return -EFAULT; if (new_options & WDIOS_DISABLECARD) { wdt_turnoff(); retval = 0; } if (new_options & WDIOS_ENABLECARD) { wdt_startup(); retval = 0; } return retval; } case WDIOC_KEEPALIVE: wdt_keepalive(); return 0; case WDIOC_SETTIMEOUT: { int new_timeout; if (get_user(new_timeout, p)) return -EFAULT; /* arbitrary upper limit */ if (new_timeout < 1 || new_timeout > 3600) return -EINVAL; timeout = new_timeout; wdt_keepalive(); /* Fall through */ } case WDIOC_GETTIMEOUT: return put_user(timeout, p); default: return -ENOTTY; } } static const struct file_operations wdt_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .write = fop_write, .open = fop_open, .release = fop_close, .unlocked_ioctl = fop_ioctl, }; static struct miscdevice wdt_miscdev = { .minor = WATCHDOG_MINOR, .name = "watchdog", .fops = &wdt_fops, }; /* * Notifier for system down */ static int wdt_notify_sys(struct notifier_block *this, unsigned long code, void *unused) { if (code == SYS_DOWN || code == SYS_HALT) wdt_turnoff(); return NOTIFY_DONE; } /* * The WDT needs to learn about soft shutdowns in order to * turn the timebomb registers off. */ static struct notifier_block wdt_notifier = { .notifier_call = wdt_notify_sys, }; static void __exit w83877f_wdt_unload(void) { wdt_turnoff(); /* Deregister */ misc_deregister(&wdt_miscdev); unregister_reboot_notifier(&wdt_notifier); release_region(WDT_PING, 1); release_region(ENABLE_W83877F_PORT, 2); } static int __init w83877f_wdt_init(void) { int rc = -EBUSY; if (timeout < 1 || timeout > 3600) { /* arbitrary upper limit */ timeout = WATCHDOG_TIMEOUT; #ifdef CONFIG_DEBUG_PRINTK printk(KERN_INFO PFX "timeout value must be 1 <= x <= 3600, using %d\n", timeout); #else ; #endif } if (!request_region(ENABLE_W83877F_PORT, 2, "W83877F WDT")) { printk(KERN_ERR PFX "I/O address 0x%04x already in use\n", ENABLE_W83877F_PORT); rc = -EIO; goto err_out; } if (!request_region(WDT_PING, 1, "W8387FF WDT")) { printk(KERN_ERR PFX "I/O address 0x%04x already in use\n", WDT_PING); rc = -EIO; goto err_out_region1; } rc = register_reboot_notifier(&wdt_notifier); if (rc) { printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n", rc); goto err_out_region2; } rc = misc_register(&wdt_miscdev); if (rc) { printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n", wdt_miscdev.minor, rc); goto err_out_reboot; } #ifdef CONFIG_DEBUG_PRINTK printk(KERN_INFO PFX "WDT driver for W83877F initialised. timeout=%d sec (nowayout=%d)\n", timeout, nowayout); #else ; #endif return 0; err_out_reboot: unregister_reboot_notifier(&wdt_notifier); err_out_region2: release_region(WDT_PING, 1); err_out_region1: release_region(ENABLE_W83877F_PORT, 2); err_out: return rc; }
static int __devinit ami306_probe(struct i2c_client *client, const struct i2c_device_id * devid) { int err = 0; struct ami306_i2c_data *data; struct ecom_platform_data* ecom_pdata; if (AMI306_DEBUG_FUNC_TRACE & ami306_debug_mask) AMID("motion start....!\n"); if(!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { AMIE("adapter can NOT support I2C_FUNC_I2C.\n"); return -ENODEV; } if (!(data = kmalloc(sizeof(struct ami306_i2c_data), GFP_KERNEL))) { err = -ENOMEM; goto exit; } memset(data, 0, sizeof(struct ami306_i2c_data)); data->client = client; i2c_set_clientdata(client, data); ami306_i2c_client = client; ecom_pdata = ami306_i2c_client->dev.platform_data; ecom_pdata->power(1); #if defined(CONFIG_HAS_EARLYSUSPEND) ami306_sensor_early_suspend.suspend = ami306_early_suspend; ami306_sensor_early_suspend.resume = ami306_late_resume; register_early_suspend(&ami306_sensor_early_suspend); atomic_set(&ami306_report_enabled, 1); #endif err=Identify_AMI_Chipset(); if (err != 0) { //get ami306_data.chipset printk(KERN_INFO "Failed to identify AMI_Chipset!\n"); goto exit_kfree; } AMI306_Chipset_Init(AMI306_FORCE_MODE, ami306_data.chipset); // default is Force State dev_info(&client->dev, "%s operating mode\n", ami306_data.mode? "force" : "normal"); printk(KERN_INFO "Register input device!\n"); err = ami306_input_init(data); if(err) goto exit_kfree; //register misc device:ami306 err = misc_register(&ami306_device); if (err) { AMIE("ami306_device register failed\n"); goto exit_misc_ami306_device_register_failed; } //register misc device:ami306daemon err = misc_register(&ami306daemon_device); if (err) { AMIE("ami306daemon_device register failed\n"); goto exit_misc_ami306daemon_device_register_failed; } //register misc device:ami306hal err = misc_register(&ami306hal_device); if (err) { AMIE("ami306hal_device register failed\n"); goto exit_misc_ami306hal_device_register_failed; } /* Register sysfs hooks */ err = sysfs_create_group(&client->dev.kobj, &ami306_attribute_group); if (err) { AMIE("ami306 sysfs register failed\n"); goto exit_sysfs_create_group_failed; } printk(KERN_INFO "[jaekyung83.lee] ami306 probe"); return 0; exit_sysfs_create_group_failed: sysfs_remove_group(&client->dev.kobj, &ami306_attribute_group); exit_misc_ami306hal_device_register_failed: misc_deregister(&ami306daemon_device); exit_misc_ami306daemon_device_register_failed: misc_deregister(&ami306_device); exit_misc_ami306_device_register_failed: input_unregister_device(data->input_dev); input_free_device(data->input_dev); exit_kfree: kfree(data); exit: return err; }
static int spt_modem_probe(struct platform_device *pdev) { int ret; struct spt_modem_ctl *mc; struct spt_modem_platform_data *pdata; pdata = pdev->dev.platform_data; if(pdata == NULL){ dev_err(&pdev->dev, "no platform data\n"); return -ENOMEM; } mc = kzalloc(sizeof(struct spt_modem_ctl), GFP_KERNEL); if(mc == NULL){ dev_err(&pdev->dev, "kmalloc fail\n"); return -ENOMEM; } init_completion(&mc->done); init_waitqueue_head(&mc->read_wq); spt_modem_wake_lock_initial(mc); mc->power_on = pdata->pwr_on; mc->modem_alive = pdata->salive; mc->power_status = pdata->s2m1; mc->usb_download = pdata->m2s1; mc->cp_user_reset = 0; mc->cp_usb_download = 0; /*reset irq*/ mc->modem_crash_irq = gpio_to_irq(mc->modem_alive); ret = request_threaded_irq(mc->modem_crash_irq, NULL, spt_modem_cpcrash_irq, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, "CP_CRASH_INT", mc); if (ret) { pr_err("Failed register gpio_cp_reset_int irq(%d)!\n", mc->modem_crash_irq); goto err1; } ret = enable_irq_wake(mc->modem_crash_irq); if (ret) { pr_err("failed to enable_irq_wake of modem reset:%d\n", ret); goto err2; } ret = misc_register(&spt_modem_miscdev); if(ret) { pr_err("Failed to register modem control device\n"); goto err3; } ret = device_create_file(spt_modem_miscdev.this_device, &attr_spt_modem_debug); if (ret) { pr_err("failed to create sysfs file:attr_modem_debug!\n"); goto err4; } ret = device_create_file(spt_modem_miscdev.this_device, &attr_spt_usb_download); if (ret) { pr_err("failed to create sysfs file:attr_spt_usb_download!\n"); goto err4; } platform_set_drvdata(pdev, mc); spt_modem_global_mc = mc; /*power on modem*/ spt_sc8803g_on(mc); return 0; err4: misc_deregister(&spt_modem_miscdev); err3: disable_irq_wake(mc->modem_crash_irq); err2: free_irq(mc->modem_crash_irq, NULL); err1: kfree(mc); return ret; }
static int vhost_net_init(void) { if (experimental_zcopytx) vhost_net_enable_zcopy(VHOST_NET_VQ_TX); return misc_register(&vhost_net_misc); }
static int my_init(void) { return misc_register(&my_misc); }
int mpu_probe(struct i2c_client *client, const struct i2c_device_id *devid) { struct mpu_platform_data *pdata; struct mpu_private_data *mpu; struct mldl_cfg *mldl_cfg; int res = 0; int ii = 0; dev_info(&client->adapter->dev, "%s: %d\n", __func__, ii++); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { res = -ENODEV; goto out_check_functionality_failed; } mpu = kzalloc(sizeof(struct mpu_private_data), GFP_KERNEL); if (!mpu) { res = -ENOMEM; goto out_alloc_data_failed; } mldl_cfg = &mpu->mldl_cfg; mldl_cfg->mpu_ram = &mpu->mpu_ram; mldl_cfg->mpu_gyro_cfg = &mpu->mpu_gyro_cfg; mldl_cfg->mpu_offsets = &mpu->mpu_offsets; mldl_cfg->mpu_chip_info = &mpu->mpu_chip_info; mldl_cfg->inv_mpu_cfg = &mpu->inv_mpu_cfg; mldl_cfg->inv_mpu_state = &mpu->inv_mpu_state; mldl_cfg->mpu_ram->length = MPU_MEM_NUM_RAM_BANKS * MPU_MEM_BANK_SIZE; mldl_cfg->mpu_ram->ram = kzalloc(mldl_cfg->mpu_ram->length, GFP_KERNEL); if (!mldl_cfg->mpu_ram->ram) { res = -ENOMEM; goto out_alloc_ram_failed; } mpu_private_data = mpu; i2c_set_clientdata(client, mpu); mpu->client = client; init_waitqueue_head(&mpu->mpu_event_wait); mutex_init(&mpu->mutex); init_completion(&mpu->completion); mpu->response_timeout = 60; /* Seconds */ mpu->timeout.function = mpu_pm_timeout; mpu->timeout.data = (u_long) mpu; init_timer(&mpu->timeout); mpu->nb.notifier_call = mpu_pm_notifier_callback; mpu->nb.priority = 0; res = register_pm_notifier(&mpu->nb); if (res) { dev_err(&client->adapter->dev, "Unable to register pm_notifier %d\n", res); goto out_register_pm_notifier_failed; } pdata = (struct mpu_platform_data *)client->dev.platform_data; if (!pdata) { dev_WARN(&client->adapter->dev, "Missing platform data for mpu\n"); } mldl_cfg->pdata = pdata; mldl_cfg->mpu_chip_info->addr = client->addr; res = inv_mpu_open(&mpu->mldl_cfg, client->adapter, NULL, NULL, NULL); if (res) { dev_err(&client->adapter->dev, "Unable to open %s %d\n", MPU_NAME, res); res = -ENODEV; goto out_whoami_failed; } mpu->dev.minor = MISC_DYNAMIC_MINOR; mpu->dev.name = "mpu"; mpu->dev.fops = &mpu_fops; res = misc_register(&mpu->dev); if (res < 0) { dev_err(&client->adapter->dev, "ERROR: misc_register returned %d\n", res); goto out_misc_register_failed; } if (client->irq) { dev_info(&client->adapter->dev, "Installing irq using %d\n", client->irq); res = mpuirq_init(client, mldl_cfg); if (res) goto out_mpuirq_failed; } else { dev_WARN(&client->adapter->dev, "Missing %s IRQ\n", MPU_NAME); } return res; out_mpuirq_failed: misc_deregister(&mpu->dev); out_misc_register_failed: inv_mpu_close(&mpu->mldl_cfg, client->adapter, NULL, NULL, NULL); out_whoami_failed: unregister_pm_notifier(&mpu->nb); out_register_pm_notifier_failed: kfree(mldl_cfg->mpu_ram->ram); mpu_private_data = NULL; out_alloc_ram_failed: kfree(mpu); out_alloc_data_failed: out_check_functionality_failed: dev_err(&client->adapter->dev, "%s failed %d\n", __func__, res); return res; }
static int __devinit modemctl_probe(struct platform_device *pdev) { int r = -ENOMEM; struct modemctl *mc; struct modemctl_data *pdata; struct resource *res; pdata = pdev->dev.platform_data; mc = kzalloc(sizeof(*mc), GFP_KERNEL); if (!mc) return -ENOMEM; init_waitqueue_head(&mc->wq); spin_lock_init(&mc->lock); mutex_init(&mc->ctl_lock); mc->irq_bp = platform_get_irq_byname(pdev, "active"); mc->irq_mbox = platform_get_irq_byname(pdev, "onedram"); mc->gpio_phone_active = pdata->gpio_phone_active; mc->gpio_pda_active = pdata->gpio_pda_active; mc->gpio_cp_reset = pdata->gpio_cp_reset; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) goto err_free; mc->mmbase = res->start; mc->mmsize = resource_size(res); mc->mmio = ioremap_nocache(mc->mmbase, mc->mmsize); if (!mc->mmio) goto err_free; platform_set_drvdata(pdev, mc); mc->dev.name = "modem_ctl"; mc->dev.minor = MISC_DYNAMIC_MINOR; mc->dev.fops = &modemctl_fops; r = misc_register(&mc->dev); if (r) goto err_ioremap; /* hide control registers from userspace */ mc->mmsize -= 0x800; mc->status = MODEM_OFF; wake_lock_init(&mc->ip_tx_wakelock, WAKE_LOCK_SUSPEND, "modem_ip_tx"); wake_lock_init(&mc->ip_rx_wakelock, WAKE_LOCK_SUSPEND, "modem_ip_rx"); modem_io_init(mc, mc->mmio); r = request_irq(mc->irq_bp, modemctl_bp_irq_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "modemctl_bp", mc); if (r) goto err_ioremap; r = request_irq(mc->irq_mbox, modemctl_mbox_irq_handler, IRQF_TRIGGER_LOW, "modemctl_mbox", mc); if (r) goto err_irq_bp; enable_irq_wake(mc->irq_bp); enable_irq_wake(mc->irq_mbox); modem_debugfs_init(mc); return 0; err_irq_mbox: free_irq(mc->irq_mbox, mc); err_irq_bp: free_irq(mc->irq_bp, mc); err_ioremap: iounmap(mc->mmio); err_free: kfree(mc); return r; }