static int mma7660_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct mma7660_data *mma7660;
int err;
Xaverage = Yaverage = Zaverage = RawDataNum = 0;
mma7660 = kzalloc(sizeof(struct mma7660_data), GFP_KERNEL);
if (!mma7660) {
mmaprintk("[mma7660]:alloc data failed.\n");
err = -ENOMEM;
goto exit_alloc_data_failed;
}
INIT_WORK(&mma7660->work, mma7660_work_func);
INIT_DELAYED_WORK(&mma7660->delaywork, mma7660_delaywork_func);
mma7660->client = client;
//mma7660->swap_xy =
i2c_set_clientdata(client, mma7660);
this_client = client;
err = mma7660_init_client(client);
if (err < 0) {
mmaprintk(KERN_ERR
"mma7660_probe: mma7660_init_client failed\n");
goto exit_request_gpio_irq_failed;
}
mma7660->input_dev = input_allocate_device();
if (!mma7660->input_dev) {
err = -ENOMEM;
mmaprintk(KERN_ERR
"mma7660_probe: Failed to allocate input device\n");
goto exit_input_allocate_device_failed;
}
set_bit(EV_ABS, mma7660->input_dev->evbit);
/* x-axis acceleration */
input_set_abs_params(mma7660->input_dev, ABS_X, -MMA7660_RANGE, MMA7660_RANGE, 0, 0);
/* y-axis acceleration */
input_set_abs_params(mma7660->input_dev, ABS_Y, -MMA7660_RANGE, MMA7660_RANGE, 0, 0);
/* z-axis acceleration */
input_set_abs_params(mma7660->input_dev, ABS_Z, -MMA7660_RANGE, MMA7660_RANGE, 0, 0);
mma7660->input_dev->name = "gsensor";
mma7660->input_dev->dev.parent = &client->dev;
err = input_register_device(mma7660->input_dev);
if (err < 0) {
mmaprintk(KERN_ERR
"mma7660_probe: Unable to register input device: %s\n",
mma7660->input_dev->name);
goto exit_input_register_device_failed;
}
mma7660_device.parent = &client->dev;
err = misc_register(&mma7660_device);
if (err < 0) {
mmaprintk(KERN_ERR
"mma7660_probe: mmad_device register failed\n");
goto exit_misc_device_register_mma7660_device_failed;
}
err = gsensor_sysfs_init();
if (err < 0) {
mmaprintk(KERN_ERR
"mma7660_probe: gsensor sysfs init failed\n");
goto exit_gsensor_sysfs_init_failed;
}
#ifdef CONFIG_ANDROID_POWER
mma7660_early_suspend.suspend = mma7660_suspend;
mma7660_early_suspend.resume = mma7660_resume;
mma7660_early_suspend.level = 0x2;
android_register_early_suspend(&mma7660_early_suspend);
#endif
mmaprintk(KERN_INFO "mma7660 probe ok\n");
mma7660->status = -1;
#if 0
mma7660_start(client, MMA7660_RATE_32);
#endif
return 0;
exit_gsensor_sysfs_init_failed:
misc_deregister(&mma7660_device);
exit_misc_device_register_mma7660_device_failed:
input_unregister_device(mma7660->input_dev);
exit_input_register_device_failed:
input_free_device(mma7660->input_dev);
exit_input_allocate_device_failed:
free_irq(client->irq, mma7660);
exit_request_gpio_irq_failed:
kfree(mma7660);
exit_alloc_data_failed:
;
return err;
}
void tun_cleanup(void)
{
misc_deregister(&tun_miscdev);
}
void snfc_uart_control_remove(void)
{
/* deregister the device file */
misc_deregister(&snfc_uart_control_device);
}
int __init ath_simple_config_init(void)
{
#ifdef CONFIG_CUS100
u32 mask = 0;
#endif
#ifdef JUMPSTART_GPIO
int req;
#endif
int ret;
#ifdef AP_RESET_GPIO
int req2;
#endif
ret = misc_register(&athfr_miscdev);
if (ret < 0) {
printk("*** ath misc_register failed %d *** \n", ret);
return -1;
}
#ifdef AP_RESET_GPIO
ath_gpio_config_input(AP_RESET_GPIO);
ath_gpio_config_int(AP_RESET_GPIO, INT_TYPE_LEVEL, INT_POL_ACTIVE_LOW);
printk("%s (%s) AP_RESET_GPIO: %d\n", __FILE__, __func__, AP_RESET_GPIO);
#endif
#ifdef JUMPSTART_GPIO
#ifdef CONFIG_CUS100
mask = ath_reg_rd(ATH_MISC_INT_MASK);
ath_reg_wr(ATH_MISC_INT_MASK, mask | (1 << 2));
ath_gpio_config_int(JUMPSTART_GPIO, INT_TYPE_LEVEL,
INT_POL_ACTIVE_HIGH);
ath_gpio_intr_enable(JUMPSTART_GPIO);
ath_gpio_config_input(JUMPSTART_GPIO);
#else
ath_gpio_config_input(JUMPSTART_GPIO);
/* configure Jumpstart GPIO as level triggered interrupt */
ath_gpio_config_int(JUMPSTART_GPIO, INT_TYPE_LEVEL,
INT_POL_ACTIVE_LOW);
printk("%s (%s) JUMPSTART_GPIO: %d\n", __FILE__, __func__,
JUMPSTART_GPIO);
#ifndef CONFIG_MACH_AR934x
ath_reg_rmw_clear(ATH_GPIO_FUNCTIONS, (1 << 2));
ath_reg_rmw_clear(ATH_GPIO_FUNCTIONS, (1 << 16));
ath_reg_rmw_clear(ATH_GPIO_FUNCTIONS, (1 << 20));
#endif
#endif
req = request_irq(ATH_GPIO_IRQn(JUMPSTART_GPIO), jumpstart_irq, 0,
#ifdef AP_RESET_GPIO
"SW JUMPSTART", NULL);
#else
"SW JUMPSTART/FACTORY RESET", NULL);
#endif
if (req != 0) {
printk("request_irq for jumpstart failed (error %d)\n", req);
misc_deregister(&athfr_miscdev);
ath_gpio_intr_shutdown(ATH_GPIO_IRQn(JUMPSTART_GPIO));
return -1;
}
#endif /* #ifdef JUMPSTART_GPIO */
#ifdef AP_RESET_GPIO
req2 = request_irq(ATH_GPIO_IRQn(AP_RESET_GPIO), ath_reset_irq, 0,
"FACTORY RESET", NULL);
if (req2 != 0) {
printk("request_irq for factory reset failed (error %d)\n", req);
misc_deregister(&athfr_miscdev);
free_irq(req, NULL);
return -1;
}
#endif
#ifdef ATH_S17INT_GPIO
ath_gpio_config_input(ATH_S17INT_GPIO);
/* configure S17 interrupt GPIO as level triggered interrupt */
ath_gpio_config_int(ATH_S17INT_GPIO, INT_TYPE_LEVEL,
INT_POL_ACTIVE_LOW);
printk("%s (%s) ATH_S17INT_GPIO: %d\n", __FILE__, __func__,
ATH_S17INT_GPIO);
#endif
#if !defined(CONFIG_I2S) && defined(AP_USB_LED_GPIO)
ath_gpio_config_output(AP_USB_LED_GPIO);
#endif
init_waitqueue_head(&ath_fr_wq);
#ifdef WPS_LED_GPIO
create_simple_config_led_proc_entry();
#endif
#ifdef POWER_ON_GLED_GPIO
printk("%s (%s) POWER_ON_GLED_GPIO: %d\n", __FILE__, __func__, POWER_ON_GLED_GPIO);
ath_gpio_config_output(POWER_ON_GLED_GPIO);
ath_gpio_out_val(POWER_ON_GLED_GPIO, POWER_LED_ON);
#endif
#ifdef POWER_ON_RLED_GPIO
printk("%s (%s) POWER_ON_RLED_GPIO: %d\n", __FILE__, __func__, POWER_ON_RLED_GPIO);
ath_gpio_config_output(POWER_ON_RLED_GPIO);
ath_gpio_out_val(POWER_ON_RLED_GPIO, POWER_LED_OFF);
OS_INIT_TIMER(NULL, &power_on_timer, power_led_blink, NULL);
OS_SET_TIMER(&power_on_timer, POWER_LED_BLINK_INTERVAL);
#endif
return 0;
}
static long iTCO_wdt_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
int new_options, retval = -EINVAL;
int new_heartbeat;
void __user *argp = (void __user *)arg;
int __user *p = argp;
static struct watchdog_info ident = {
.options = WDIOF_SETTIMEOUT |
WDIOF_KEEPALIVEPING |
WDIOF_MAGICCLOSE,
.firmware_version = 0,
.identity = DRV_NAME,
};
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:
{
if (get_user(new_options, p))
return -EFAULT;
if (new_options & WDIOS_DISABLECARD) {
iTCO_wdt_stop();
retval = 0;
}
if (new_options & WDIOS_ENABLECARD) {
iTCO_wdt_keepalive();
iTCO_wdt_start();
retval = 0;
}
return retval;
}
case WDIOC_KEEPALIVE:
iTCO_wdt_keepalive();
return 0;
case WDIOC_SETTIMEOUT:
{
if (get_user(new_heartbeat, p))
return -EFAULT;
if (iTCO_wdt_set_heartbeat(new_heartbeat))
return -EINVAL;
iTCO_wdt_keepalive();
/* Fall */
}
case WDIOC_GETTIMEOUT:
return put_user(heartbeat, p);
case WDIOC_GETTIMELEFT:
{
int time_left;
if (iTCO_wdt_get_timeleft(&time_left))
return -EINVAL;
return put_user(time_left, p);
}
default:
return -ENOTTY;
}
}
/*
* Kernel Interfaces
*/
static const struct file_operations iTCO_wdt_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.write = iTCO_wdt_write,
.unlocked_ioctl = iTCO_wdt_ioctl,
.open = iTCO_wdt_open,
.release = iTCO_wdt_release,
};
static struct miscdevice iTCO_wdt_miscdev = {
.minor = WATCHDOG_MINOR,
.name = "watchdog",
.fops = &iTCO_wdt_fops,
};
/*
* Init & exit routines
*/
static void __devexit iTCO_wdt_cleanup(void)
{
/* Stop the timer before we leave */
if (!nowayout)
iTCO_wdt_stop();
/* Deregister */
misc_deregister(&iTCO_wdt_miscdev);
/* release resources */
release_region(iTCO_wdt_private.tco_res->start,
resource_size(iTCO_wdt_private.tco_res));
release_region(iTCO_wdt_private.smi_res->start,
resource_size(iTCO_wdt_private.smi_res));
if (iTCO_wdt_private.iTCO_version == 2) {
iounmap(iTCO_wdt_private.gcs);
release_mem_region(iTCO_wdt_private.gcs_res->start,
resource_size(iTCO_wdt_private.gcs_res));
}
iTCO_wdt_private.tco_res = NULL;
iTCO_wdt_private.smi_res = NULL;
iTCO_wdt_private.gcs_res = NULL;
iTCO_wdt_private.gcs = NULL;
}
static int __devinit iTCO_wdt_probe(struct platform_device *dev)
{
int ret = -ENODEV;
unsigned long val32;
struct lpc_ich_info *ich_info = dev->dev.platform_data;
if (!ich_info)
goto out;
spin_lock_init(&iTCO_wdt_private.io_lock);
iTCO_wdt_private.tco_res =
platform_get_resource(dev, IORESOURCE_IO, ICH_RES_IO_TCO);
if (!iTCO_wdt_private.tco_res)
goto out;
iTCO_wdt_private.smi_res =
platform_get_resource(dev, IORESOURCE_IO, ICH_RES_IO_SMI);
if (!iTCO_wdt_private.smi_res)
goto out;
iTCO_wdt_private.iTCO_version = ich_info->iTCO_version;
iTCO_wdt_private.dev = dev;
iTCO_wdt_private.pdev = to_pci_dev(dev->dev.parent);
/*
* Get the Memory-Mapped GCS register, we need it for the
* NO_REBOOT flag (TCO v2).
*/
if (iTCO_wdt_private.iTCO_version == 2) {
iTCO_wdt_private.gcs_res = platform_get_resource(dev,
IORESOURCE_MEM,
ICH_RES_MEM_GCS);
if (!iTCO_wdt_private.gcs_res)
goto out;
if (!request_mem_region(iTCO_wdt_private.gcs_res->start,
resource_size(iTCO_wdt_private.gcs_res), dev->name)) {
ret = -EBUSY;
goto out;
}
iTCO_wdt_private.gcs = ioremap(iTCO_wdt_private.gcs_res->start,
resource_size(iTCO_wdt_private.gcs_res));
if (!iTCO_wdt_private.gcs) {
ret = -EIO;
goto unreg_gcs;
}
}
/* Check chipset's NO_REBOOT bit */
if (iTCO_wdt_unset_NO_REBOOT_bit() && iTCO_vendor_check_noreboot_on()) {
pr_info("unable to reset NO_REBOOT flag, device disabled by hardware/BIOS\n");
ret = -ENODEV; /* Cannot reset NO_REBOOT bit */
goto unmap_gcs;
}
/* Set the NO_REBOOT bit to prevent later reboots, just for sure */
iTCO_wdt_set_NO_REBOOT_bit();
/* The TCO logic uses the TCO_EN bit in the SMI_EN register */
if (!request_region(iTCO_wdt_private.smi_res->start,
resource_size(iTCO_wdt_private.smi_res), dev->name)) {
pr_err("I/O address 0x%04llx already in use, device disabled\n",
SMI_EN);
ret = -EBUSY;
goto unmap_gcs;
}
if (turn_SMI_watchdog_clear_off >= iTCO_wdt_private.iTCO_version) {
/*
* Bit 13: TCO_EN -> 0
* Disables TCO logic generating an SMI#
*/
val32 = inl(SMI_EN);
val32 &= 0xffffdfff; /* Turn off SMI clearing watchdog */
outl(val32, SMI_EN);
}
if (!request_region(iTCO_wdt_private.tco_res->start,
resource_size(iTCO_wdt_private.tco_res), dev->name)) {
pr_err("I/O address 0x%04llx already in use, device disabled\n",
TCOBASE);
ret = -EBUSY;
goto unreg_smi;
}
pr_info("Found a %s TCO device (Version=%d, TCOBASE=0x%04llx)\n",
ich_info->name, ich_info->iTCO_version, TCOBASE);
/* Clear out the (probably old) status */
outw(0x0008, TCO1_STS); /* Clear the Time Out Status bit */
outw(0x0002, TCO2_STS); /* Clear SECOND_TO_STS bit */
outw(0x0004, TCO2_STS); /* Clear BOOT_STS bit */
/* Make sure the watchdog is not running */
iTCO_wdt_stop();
/* Check that the heartbeat value is within it's range;
if not reset to the default */
if (iTCO_wdt_set_heartbeat(heartbeat)) {
iTCO_wdt_set_heartbeat(WATCHDOG_HEARTBEAT);
pr_info("timeout value out of range, using %d\n", heartbeat);
}
ret = misc_register(&iTCO_wdt_miscdev);
if (ret != 0) {
pr_err("cannot register miscdev on minor=%d (err=%d)\n",
WATCHDOG_MINOR, ret);
goto unreg_tco;
}
pr_info("initialized. heartbeat=%d sec (nowayout=%d)\n",
heartbeat, nowayout);
return 0;
unreg_tco:
release_region(iTCO_wdt_private.tco_res->start,
resource_size(iTCO_wdt_private.tco_res));
unreg_smi:
release_region(iTCO_wdt_private.smi_res->start,
resource_size(iTCO_wdt_private.smi_res));
unmap_gcs:
if (iTCO_wdt_private.iTCO_version == 2)
iounmap(iTCO_wdt_private.gcs);
unreg_gcs:
if (iTCO_wdt_private.iTCO_version == 2)
release_mem_region(iTCO_wdt_private.gcs_res->start,
resource_size(iTCO_wdt_private.gcs_res));
out:
iTCO_wdt_private.tco_res = NULL;
iTCO_wdt_private.smi_res = NULL;
iTCO_wdt_private.gcs_res = NULL;
iTCO_wdt_private.gcs = NULL;
return ret;
}
static int __devexit iTCO_wdt_remove(struct platform_device *dev)
{
if (iTCO_wdt_private.tco_res || iTCO_wdt_private.smi_res)
iTCO_wdt_cleanup();
return 0;
}
static void iTCO_wdt_shutdown(struct platform_device *dev)
{
iTCO_wdt_stop();
}
#define iTCO_wdt_suspend NULL
#define iTCO_wdt_resume NULL
static struct platform_driver iTCO_wdt_driver = {
.probe = iTCO_wdt_probe,
.remove = __devexit_p(iTCO_wdt_remove),
.shutdown = iTCO_wdt_shutdown,
.suspend = iTCO_wdt_suspend,
.resume = iTCO_wdt_resume,
.driver = {
.owner = THIS_MODULE,
.name = DRV_NAME,
},
};
static int __init iTCO_wdt_init_module(void)
{
int err;
pr_info("Intel TCO WatchDog Timer Driver v%s\n", DRV_VERSION);
err = platform_driver_register(&iTCO_wdt_driver);
if (err)
return err;
return 0;
}
void gpio_i2c_exit(void)
{
misc_deregister(&gi2c_dev);
}
static int pn544_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret;
struct pn544_i2c_platform_data *platform_data;
struct pn544_dev *pn544_dev;
platform_data = client->dev.platform_data;
if (platform_data == NULL) {
pr_err("%s : nfc probe fail\n", __func__);
return -ENODEV;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s : need I2C_FUNC_I2C\n", __func__);
return -ENODEV;
}
#if !defined(CONFIG_MACH_C1_KDDI_REV00)
ret = gpio_request(platform_data->irq_gpio, "nfc_int");
if (ret)
return -ENODEV;
ret = gpio_request(platform_data->ven_gpio, "nfc_ven");
if (ret)
goto err_ven;
ret = gpio_request(platform_data->firm_gpio, "nfc_firm");
if (ret)
goto err_firm;
#endif
pn544_dev = kzalloc(sizeof(*pn544_dev), GFP_KERNEL);
if (pn544_dev == NULL) {
dev_err(&client->dev,
"failed to allocate memory for module data\n");
ret = -ENOMEM;
goto err_exit;
}
pr_info("%s : IRQ num %d\n", __func__, client->irq);
pn544_dev->irq_gpio = platform_data->irq_gpio;
pn544_dev->ven_gpio = platform_data->ven_gpio;
pn544_dev->firm_gpio = platform_data->firm_gpio;
pn544_dev->client = client;
/* init mutex and queues */
init_waitqueue_head(&pn544_dev->read_wq);
mutex_init(&pn544_dev->read_mutex);
spin_lock_init(&pn544_dev->irq_enabled_lock);
pn544_dev->pn544_device.minor = MISC_DYNAMIC_MINOR;
pn544_dev->pn544_device.name = "pn544";
pn544_dev->pn544_device.fops = &pn544_dev_fops;
ret = misc_register(&pn544_dev->pn544_device);
if (ret) {
pr_err("%s : misc_register failed\n", __FILE__);
goto err_misc_register;
}
/* request irq. the irq is set whenever the chip has data available
* for reading. it is cleared when all data has been read.
*/
pr_info("%s : requesting IRQ %d\n", __func__, client->irq);
pn544_dev->irq_enabled = true;
#if !defined(CONFIG_MACH_C1_KDDI_REV00)
gpio_direction_input(pn544_dev->irq_gpio);
#endif
ret = request_irq(client->irq, pn544_dev_irq_handler,
IRQF_TRIGGER_RISING, "pn544", pn544_dev);
if (ret) {
dev_err(&client->dev, "request_irq failed\n");
goto err_request_irq_failed;
}
pn544_disable_irq(pn544_dev);
#if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_MACH_C1_KDDI_REV00)
enable_irq_wake(client->irq);
#endif
i2c_set_clientdata(client, pn544_dev);
#if defined(CONFIG_MACH_C1_KDDI_REV00)
extern int sec_isLpmMode(void);
//for power supply charging mode
if (sec_isLpmMode())
{
gpio_set_value(pn544_dev->firm_gpio, 0);
msleep(10);
gpio_set_value(pn544_dev->ven_gpio, 1);
msleep(10);
}
#endif
return 0;
err_request_irq_failed:
misc_deregister(&pn544_dev->pn544_device);
err_misc_register:
mutex_destroy(&pn544_dev->read_mutex);
kfree(pn544_dev);
err_exit:
gpio_free(platform_data->firm_gpio);
err_firm:
gpio_free(platform_data->ven_gpio);
err_ven:
gpio_free(platform_data->irq_gpio);
return ret;
}
static long wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
void __user *argp = (void __user *)arg;
int __user *p = argp;
int new_timeout;
static const struct watchdog_info ident = {
.options = WDIOF_KEEPALIVEPING |
WDIOF_SETTIMEOUT |
WDIOF_MAGICCLOSE,
.firmware_version = 1,
.identity = "W83697UG 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_SETOPTIONS:
{
int options, retval = -EINVAL;
if (get_user(options, p))
return -EFAULT;
if (options & WDIOS_DISABLECARD) {
wdt_disable();
retval = 0;
}
if (options & WDIOS_ENABLECARD) {
wdt_ping();
retval = 0;
}
return retval;
}
case WDIOC_KEEPALIVE:
wdt_ping();
break;
case WDIOC_SETTIMEOUT:
if (get_user(new_timeout, p))
return -EFAULT;
if (wdt_set_heartbeat(new_timeout))
return -EINVAL;
wdt_ping();
/* Fall */
case WDIOC_GETTIMEOUT:
return put_user(timeout, p);
default:
return -ENOTTY;
}
return 0;
}
static int wdt_open(struct inode *inode, struct file *file)
{
if (test_and_set_bit(0, &wdt_is_open))
return -EBUSY;
/*
* Activate
*/
wdt_ping();
return nonseekable_open(inode, file);
}
static int wdt_close(struct inode *inode, struct file *file)
{
if (expect_close == 42)
wdt_disable();
else {
pr_crit("Unexpected close, not stopping watchdog!\n");
wdt_ping();
}
expect_close = 0;
clear_bit(0, &wdt_is_open);
return 0;
}
/*
* 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_disable(); /* Turn the WDT off */
return NOTIFY_DONE;
}
/*
* Kernel Interfaces
*/
static const struct file_operations wdt_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.write = wdt_write,
.unlocked_ioctl = wdt_ioctl,
.open = wdt_open,
.release = wdt_close,
};
static struct miscdevice wdt_miscdev = {
.minor = WATCHDOG_MINOR,
.name = "watchdog",
.fops = &wdt_fops,
};
/*
* 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 int __init wdt_init(void)
{
int ret;
pr_info("WDT driver for the Winbond(TM) W83697UG/UF Super I/O chip initialising\n");
if (wdt_set_heartbeat(timeout)) {
wdt_set_heartbeat(WATCHDOG_TIMEOUT);
pr_info("timeout value must be 1<=timeout<=255, using %d\n",
WATCHDOG_TIMEOUT);
}
if (!request_region(wdt_io, 1, WATCHDOG_NAME)) {
pr_err("I/O address 0x%04x already in use\n", wdt_io);
ret = -EIO;
goto out;
}
ret = w83697ug_init();
if (ret != 0)
goto unreg_regions;
ret = register_reboot_notifier(&wdt_notifier);
if (ret != 0) {
pr_err("cannot register reboot notifier (err=%d)\n", ret);
goto unreg_regions;
}
ret = misc_register(&wdt_miscdev);
if (ret != 0) {
pr_err("cannot register miscdev on minor=%d (err=%d)\n",
WATCHDOG_MINOR, ret);
goto unreg_reboot;
}
pr_info("initialized. timeout=%d sec (nowayout=%d)\n",
timeout, nowayout);
out:
return ret;
unreg_reboot:
unregister_reboot_notifier(&wdt_notifier);
unreg_regions:
release_region(wdt_io, 1);
goto out;
}
static void __exit wdt_exit(void)
{
misc_deregister(&wdt_miscdev);
unregister_reboot_notifier(&wdt_notifier);
release_region(wdt_io, 1);
}
static __exit void conf_exit(void)
{
misc_deregister(&conf_misc);
i2c_del_driver(&conf_driver);
}
static int __exit iodev_remove(struct device *dev)
{
return misc_deregister(&miscdev);
}
/*
* Description:
* Input:
* Output:
*/
static void felica_test_exit(void)
{
/* deregister the device file */
misc_deregister(&felica_test_device);
}
static void __exit patel_exit(void) {
misc_deregister(&patel_dev);
}
static int config_nfc_download_gpio_pin(void)
{
int ret;
struct pm_gpio gpio43_param = {
.direction = PM_GPIO_DIR_OUT,
.output_buffer = PM_GPIO_OUT_BUF_CMOS,
.output_value = 0,
.pull = PM_GPIO_PULL_NO,
.vin_sel = PM_GPIO_VIN_S4,
.out_strength = PM_GPIO_STRENGTH_MED,
.function = PM_GPIO_FUNC_NORMAL,
};
gpio43 = PM8921_GPIO_PM_TO_SYS(NFC_GPIO_DOWNLOAD);
ret = gpio_request(gpio43, "NFC_DOWNLOAD");
if (ret) {
pr_err("%s: unable to request pmic's gpio 43 (NFC_DOWNLOAD)\n",__func__);
return ret;
}
ret = pm8xxx_gpio_config(gpio43, &gpio43_param);
if (ret)
pr_err("%s: Failed to configure gpio\n", __func__);
return 0;
}
static int pn544_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int ret;
struct pn544_i2c_platform_data *platform_data;
platform_data = client->dev.platform_data;
g_slave_addr=client->addr;
printk("Alpha:%s\n", __func__);
if (platform_data == NULL) {
pr_err("%s : nfc probe fail\n", __func__);
return -ENODEV;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s : need I2C_FUNC_I2C\n", __func__);
return -ENODEV;
}
ret = gpio_request(platform_data->irq_gpio, "nfc_int");
if (ret)
return -ENODEV;
ret = gpio_request(platform_data->ven_gpio, "nfc_ven");
if (ret)
goto err_ven;
/*if (platform_data->firm_gpio) {
ret = gpio_request(platform_data->firm_gpio, "nfc_firm");
if (ret)
goto err_firm;
}
*/
config_nfc_download_gpio_pin();
pn544_dev = kzalloc(sizeof(struct pn544_dev), GFP_KERNEL);
if (pn544_dev == NULL) {
dev_err(&client->dev, "failed to allocate memory for module data\n");
ret = -ENOMEM;
goto err_exit;
}
pn544_dev->irq_gpio = platform_data->irq_gpio;
pn544_dev->ven_gpio = platform_data->ven_gpio;
//pn544_dev->firm_gpio = platform_data->firm_gpio;
pn544_dev->client = client;
ret = gpio_direction_input(pn544_dev->irq_gpio);
if (ret < 0) {
pr_err("%s :not able to set irq_gpio as input\n", __func__);
goto err_ven;
}
ret = gpio_direction_output(pn544_dev->ven_gpio, 0);
if (ret < 0) {
pr_err("%s : not able to set ven_gpio as output\n", __func__);
goto err_firm;
}
/*if (platform_data->firm_gpio) {
ret = gpio_direction_output(pn544_dev->firm_gpio, 0);
if (ret < 0) {
pr_err("%s : not able to set firm_gpio as output\n",
__func__);
goto err_exit;
}
}*/
gpio_direction_output(gpio43, 0);
if (ret < 0) {
pr_err("%s : not able to set nfc_download as output\n",__func__);
goto err_exit;
}
/* init mutex and queues */
init_waitqueue_head(&pn544_dev->read_wq);
mutex_init(&pn544_dev->read_mutex);
spin_lock_init(&pn544_dev->irq_enabled_lock);
pn544_dev->pn544_device.minor = MISC_DYNAMIC_MINOR;
pn544_dev->pn544_device.name = "pn544";
pn544_dev->pn544_device.fops = &pn544_dev_fops;
ret = misc_register(&pn544_dev->pn544_device);
if (ret) {
pr_err("%s : misc_register failed\n", __FILE__);
goto err_misc_register;
}
//- dev_dbg(&client->dev, "%s: info: %p, pdata %p, client %p\n",
//- __func__, info, pdata, client);
/* request irq. the irq is set whenever the chip has data available
* for reading. it is cleared when all data has been read.
*/
pr_info("%s : requesting IRQ %d\n", __func__, client->irq);
pn544_dev->irq_enabled = true;
ret = request_irq(client->irq, pn544_dev_irq_handler,
IRQF_TRIGGER_HIGH, client->name, pn544_dev);
if (ret) {
dev_err(&client->dev, "request_irq failed\n");
goto err_request_irq_failed;
}
pn544_disable_irq(pn544_dev);
i2c_set_clientdata(client, pn544_dev);
return 0;
err_request_irq_failed:
misc_deregister(&pn544_dev->pn544_device);
err_misc_register:
mutex_destroy(&pn544_dev->read_mutex);
kfree(pn544_dev);
err_exit:
//if (pn544_dev->firm_gpio) gpio_free(platform_data->firm_gpio);
gpio_free(gpio43);
err_firm:
gpio_free(platform_data->ven_gpio);
err_ven:
gpio_free(platform_data->irq_gpio);
return ret;
}
static void __exit mtv250_module_exit(void)
{
mtv250_deinit_device();
misc_deregister(&mtv250_misc_device);
}
static int
ar2315_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
unsigned long arg)
{
void __user *argp = (void __user *)arg;
int __user *p = argp;
int new_heartbeat;
int status = 0;
static struct watchdog_info ident = {
.options = WDIOF_SETTIMEOUT |
WDIOF_MAGICCLOSE |
WDIOF_KEEPALIVEPING,
.firmware_version = 1,
.identity = "ar2315",
};
switch(cmd)
{
default:
return -ENOIOCTLCMD;
case WDIOC_GETSUPPORT:
return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
case WDIOC_GETSTATUS:
//wdt_get_status(&status);
return put_user(status, p);
case WDIOC_GETBOOTSTATUS:
return put_user(0, p);
case WDIOC_KEEPALIVE:
ar2315_wdt_ping();
return 0;
case WDIOC_SETTIMEOUT:
if (get_user(new_heartbeat, p))
return -EFAULT;
if (ar2315_wdt_set_heartbeat(new_heartbeat))
return -EINVAL;
ar2315_wdt_ping();
/* fallthrough */
case WDIOC_GETTIMEOUT:
return put_user(heartbeat, p);
}
}
static struct file_operations ar2315_wdt_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.write = ar2315_wdt_write,
.ioctl = ar2315_wdt_ioctl,
.open = ar2315_wdt_open,
.release = ar2315_wdt_release,
};
static struct miscdevice ar2315_wdt_miscdev = {
.minor = WATCHDOG_MINOR,
.name = "watchdog",
.fops = &ar2315_wdt_fops,
};
static int __init
ar2315_wdt_init(void)
{
int ret = 0;
if (ar2315_wdt_set_heartbeat(heartbeat)) {
ar2315_wdt_set_heartbeat(5);
printk(KERN_INFO "%s: heartbeat value must be 0<heartbeat<90, using %d\n",
__func__, 5);
}
ar2315_wdt_print_info();
ar2315_wdt_ping();
printk("%s using heartbeat %d s cycles %u\n", __func__, heartbeat, S_TO_CYCLES(heartbeat));
ret = request_irq(AR531X_MISC_IRQ_WATCHDOG, ar2315_wdt_interrupt, SA_INTERRUPT, "ar2315_wdt", NULL);
ar2315_wdt_print_info();
if (ret) {
printk(KERN_ERR "wdt: IRQ %d is not free.\n", AR531X_MISC_IRQ_WATCHDOG);
goto out;
}
ret = misc_register(&ar2315_wdt_miscdev);
if (ret) {
printk(KERN_ERR "%s: cannot register miscdev on minor=%d (err=%d)\n",
__func__, WATCHDOG_MINOR, ret);
goto out1;
}
out:
return ret;
out1:
misc_deregister(&ar2315_wdt_miscdev);
return ret;
}
static void __exit
ar2315_wdt_exit(void)
{
printk("%s\n", __func__);
misc_deregister(&ar2315_wdt_miscdev);
free_irq(AR531X_MISC_IRQ_WATCHDOG, NULL);
}
static int mpc83xx_wdt_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
void __user *argp = (void __user *)arg;
int __user *p = argp;
static struct watchdog_info ident = {
.options = WDIOF_KEEPALIVEPING,
.firmware_version = 1,
.identity = "MPC83xx",
};
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_KEEPALIVE:
mpc83xx_wdt_keepalive();
return 0;
case WDIOC_GETTIMEOUT:
return put_user(timeout_sec, p);
default:
return -ENOTTY;
}
}
static const struct file_operations mpc83xx_wdt_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.write = mpc83xx_wdt_write,
.ioctl = mpc83xx_wdt_ioctl,
.open = mpc83xx_wdt_open,
.release = mpc83xx_wdt_release,
};
static struct miscdevice mpc83xx_wdt_miscdev = {
.minor = WATCHDOG_MINOR,
.name = "watchdog",
.fops = &mpc83xx_wdt_fops,
};
static int __devinit mpc83xx_wdt_probe(struct platform_device *dev)
{
struct resource *r;
int ret;
unsigned int *freq = dev->dev.platform_data;
/* get a pointer to the register memory */
r = platform_get_resource(dev, IORESOURCE_MEM, 0);
if (!r) {
ret = -ENODEV;
goto err_out;
}
wd_base = ioremap(r->start, sizeof (struct mpc83xx_wdt));
if (wd_base == NULL) {
ret = -ENOMEM;
goto err_out;
}
ret = misc_register(&mpc83xx_wdt_miscdev);
if (ret) {
printk(KERN_ERR "cannot register miscdev on minor=%d "
"(err=%d)\n",
WATCHDOG_MINOR, ret);
goto err_unmap;
}
/* Calculate the timeout in seconds */
if (prescale)
timeout_sec = (timeout * 0x10000) / (*freq);
else
timeout_sec = timeout / (*freq);
printk(KERN_INFO "WDT driver for MPC83xx initialized. "
"mode:%s timeout=%d (%d seconds)\n",
reset ? "reset":"interrupt", timeout, timeout_sec);
spin_lock_init(&wdt_spinlock);
return 0;
err_unmap:
iounmap(wd_base);
err_out:
return ret;
}
static int __devexit mpc83xx_wdt_remove(struct platform_device *dev)
{
misc_deregister(&mpc83xx_wdt_miscdev);
iounmap(wd_base);
return 0;
}
static struct platform_driver mpc83xx_wdt_driver = {
.probe = mpc83xx_wdt_probe,
.remove = __devexit_p(mpc83xx_wdt_remove),
.driver = {
.name = "mpc83xx_wdt",
},
};
static int __init mpc83xx_wdt_init(void)
{
return platform_driver_register(&mpc83xx_wdt_driver);
}
static void __exit mpc83xx_wdt_exit(void)
{
platform_driver_unregister(&mpc83xx_wdt_driver);
}
static long indydog_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
int options, retval = -EINVAL;
static const struct watchdog_info ident = {
.options = WDIOF_KEEPALIVEPING,
.firmware_version = 0,
.identity = "Hardware Watchdog for SGI IP22",
};
switch (cmd) {
case WDIOC_GETSUPPORT:
if (copy_to_user((struct watchdog_info *)arg,
&ident, sizeof(ident)))
return -EFAULT;
return 0;
case WDIOC_GETSTATUS:
case WDIOC_GETBOOTSTATUS:
return put_user(0, (int *)arg);
case WDIOC_SETOPTIONS:
{
if (get_user(options, (int *)arg))
return -EFAULT;
if (options & WDIOS_DISABLECARD) {
indydog_stop();
retval = 0;
}
if (options & WDIOS_ENABLECARD) {
indydog_start();
retval = 0;
}
return retval;
}
case WDIOC_KEEPALIVE:
indydog_ping();
return 0;
case WDIOC_GETTIMEOUT:
return put_user(WATCHDOG_TIMEOUT, (int *)arg);
default:
return -ENOTTY;
}
}
static int indydog_notify_sys(struct notifier_block *this,
unsigned long code, void *unused)
{
if (code == SYS_DOWN || code == SYS_HALT)
indydog_stop(); /* Turn the WDT off */
return NOTIFY_DONE;
}
static const struct file_operations indydog_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.write = indydog_write,
.unlocked_ioctl = indydog_ioctl,
.open = indydog_open,
.release = indydog_release,
};
static struct miscdevice indydog_miscdev = {
.minor = WATCHDOG_MINOR,
.name = "watchdog",
.fops = &indydog_fops,
};
static struct notifier_block indydog_notifier = {
.notifier_call = indydog_notify_sys,
};
static int __init watchdog_init(void)
{
int ret;
ret = register_reboot_notifier(&indydog_notifier);
if (ret) {
pr_err("cannot register reboot notifier (err=%d)\n", ret);
return ret;
}
ret = misc_register(&indydog_miscdev);
if (ret) {
pr_err("cannot register miscdev on minor=%d (err=%d)\n",
WATCHDOG_MINOR, ret);
unregister_reboot_notifier(&indydog_notifier);
return ret;
}
pr_info("Hardware Watchdog Timer for SGI IP22: 0.3\n");
return 0;
}
static void __exit watchdog_exit(void)
{
misc_deregister(&indydog_miscdev);
unregister_reboot_notifier(&indydog_notifier);
}
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 = "SBC60xx",
};
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 sbc60xxwdt_unload(void)
{
wdt_turnoff();
/* Deregister */
misc_deregister(&wdt_miscdev);
unregister_reboot_notifier(&wdt_notifier);
if ((wdt_stop != 0x45) && (wdt_stop != wdt_start))
release_region(wdt_stop, 1);
release_region(wdt_start, 1);
}
static int __init sbc60xxwdt_init(void)
{
int rc = -EBUSY;
if (timeout < 1 || timeout > 3600) { /* arbitrary upper limit */
timeout = WATCHDOG_TIMEOUT;
pr_info("timeout value must be 1 <= x <= 3600, using %d\n",
timeout);
}
if (!request_region(wdt_start, 1, "SBC 60XX WDT")) {
pr_err("I/O address 0x%04x already in use\n", wdt_start);
rc = -EIO;
goto err_out;
}
/* We cannot reserve 0x45 - the kernel already has! */
if (wdt_stop != 0x45 && wdt_stop != wdt_start) {
if (!request_region(wdt_stop, 1, "SBC 60XX WDT")) {
pr_err("I/O address 0x%04x already in use\n", wdt_stop);
rc = -EIO;
goto err_out_region1;
}
}
rc = register_reboot_notifier(&wdt_notifier);
if (rc) {
pr_err("cannot register reboot notifier (err=%d)\n", rc);
goto err_out_region2;
}
rc = misc_register(&wdt_miscdev);
if (rc) {
pr_err("cannot register miscdev on minor=%d (err=%d)\n",
wdt_miscdev.minor, rc);
goto err_out_reboot;
}
pr_info("WDT driver for 60XX single board computer initialised. timeout=%d sec (nowayout=%d)\n",
timeout, nowayout);
return 0;
err_out_reboot:
unregister_reboot_notifier(&wdt_notifier);
err_out_region2:
if (wdt_stop != 0x45 && wdt_stop != wdt_start)
release_region(wdt_stop, 1);
err_out_region1:
release_region(wdt_start, 1);
err_out:
return rc;
}
static void __exit alarm_dev_exit(void)
{
misc_deregister(&alarm_device);
wakeup_source_trash(&alarm_wake_lock);
}
static void __exit alarm_dev_exit(void)
{
misc_deregister(&alarm_device);
wake_lock_destroy(&alarm_wake_lock);
}
// call in driver remove function
void touch_fops_exit(void) {
misc_deregister(&touch_fops_dev);
}
static void __exit mod_exit(void)
{
int ret = misc_deregister(&vuln_device);
if(ret)
printk("There was an error unregistering device");
}
/**
* Does the PCI detection and init of the device.
*
* Return: 0 on success, negated errno on failure.
*/
static int vbg_pci_probe(struct pci_dev *pci, const struct pci_device_id *id)
{
struct device *dev = &pci->dev;
resource_size_t io, io_len, mmio, mmio_len;
struct vmmdev_memory *vmmdev;
struct vbg_dev *gdev;
int ret;
gdev = devm_kzalloc(dev, sizeof(*gdev), GFP_KERNEL);
if (!gdev)
return -ENOMEM;
ret = pci_enable_device(pci);
if (ret != 0) {
vbg_err("vboxguest: Error enabling device: %d\n", ret);
return ret;
}
ret = -ENODEV;
io = pci_resource_start(pci, 0);
io_len = pci_resource_len(pci, 0);
if (!io || !io_len) {
vbg_err("vboxguest: Error IO-port resource (0) is missing\n");
goto err_disable_pcidev;
}
if (devm_request_region(dev, io, io_len, DEVICE_NAME) == NULL) {
vbg_err("vboxguest: Error could not claim IO resource\n");
ret = -EBUSY;
goto err_disable_pcidev;
}
mmio = pci_resource_start(pci, 1);
mmio_len = pci_resource_len(pci, 1);
if (!mmio || !mmio_len) {
vbg_err("vboxguest: Error MMIO resource (1) is missing\n");
goto err_disable_pcidev;
}
if (devm_request_mem_region(dev, mmio, mmio_len, DEVICE_NAME) == NULL) {
vbg_err("vboxguest: Error could not claim MMIO resource\n");
ret = -EBUSY;
goto err_disable_pcidev;
}
vmmdev = devm_ioremap(dev, mmio, mmio_len);
if (!vmmdev) {
vbg_err("vboxguest: Error ioremap failed; MMIO addr=%pap size=%pap\n",
&mmio, &mmio_len);
goto err_disable_pcidev;
}
/* Validate MMIO region version and size. */
if (vmmdev->version != VMMDEV_MEMORY_VERSION ||
vmmdev->size < 32 || vmmdev->size > mmio_len) {
vbg_err("vboxguest: Bogus VMMDev memory; version=%08x (expected %08x) size=%d (expected <= %d)\n",
vmmdev->version, VMMDEV_MEMORY_VERSION,
vmmdev->size, (int)mmio_len);
goto err_disable_pcidev;
}
gdev->io_port = io;
gdev->mmio = vmmdev;
gdev->dev = dev;
gdev->misc_device.minor = MISC_DYNAMIC_MINOR;
gdev->misc_device.name = DEVICE_NAME;
gdev->misc_device.fops = &vbg_misc_device_fops;
gdev->misc_device_user.minor = MISC_DYNAMIC_MINOR;
gdev->misc_device_user.name = DEVICE_NAME_USER;
gdev->misc_device_user.fops = &vbg_misc_device_user_fops;
ret = vbg_core_init(gdev, VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
if (ret)
goto err_disable_pcidev;
ret = vbg_create_input_device(gdev);
if (ret) {
vbg_err("vboxguest: Error creating input device: %d\n", ret);
goto err_vbg_core_exit;
}
ret = devm_request_irq(dev, pci->irq, vbg_core_isr, IRQF_SHARED,
DEVICE_NAME, gdev);
if (ret) {
vbg_err("vboxguest: Error requesting irq: %d\n", ret);
goto err_vbg_core_exit;
}
ret = misc_register(&gdev->misc_device);
if (ret) {
vbg_err("vboxguest: Error misc_register %s failed: %d\n",
DEVICE_NAME, ret);
goto err_vbg_core_exit;
}
ret = misc_register(&gdev->misc_device_user);
if (ret) {
vbg_err("vboxguest: Error misc_register %s failed: %d\n",
DEVICE_NAME_USER, ret);
goto err_unregister_misc_device;
}
mutex_lock(&vbg_gdev_mutex);
if (!vbg_gdev)
vbg_gdev = gdev;
else
ret = -EBUSY;
mutex_unlock(&vbg_gdev_mutex);
if (ret) {
vbg_err("vboxguest: Error more then 1 vbox guest pci device\n");
goto err_unregister_misc_device_user;
}
pci_set_drvdata(pci, gdev);
device_create_file(dev, &dev_attr_host_version);
device_create_file(dev, &dev_attr_host_features);
vbg_info("vboxguest: misc device minor %d, IRQ %d, I/O port %x, MMIO at %pap (size %pap)\n",
gdev->misc_device.minor, pci->irq, gdev->io_port,
&mmio, &mmio_len);
return 0;
err_unregister_misc_device_user:
misc_deregister(&gdev->misc_device_user);
err_unregister_misc_device:
misc_deregister(&gdev->misc_device);
err_vbg_core_exit:
vbg_core_exit(gdev);
err_disable_pcidev:
pci_disable_device(pci);
return ret;
}
static long epx_c3_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
int options, retval = -EINVAL;
int __user *argp = (void __user *)arg;
static const struct watchdog_info ident = {
.options = WDIOF_KEEPALIVEPING,
.firmware_version = 0,
.identity = "Winsystems EPX-C3 H/W Watchdog",
};
switch (cmd) {
case WDIOC_GETSUPPORT:
if (copy_to_user(argp, &ident, sizeof(ident)))
return -EFAULT;
return 0;
case WDIOC_GETSTATUS:
case WDIOC_GETBOOTSTATUS:
return put_user(0, argp);
case WDIOC_SETOPTIONS:
if (get_user(options, argp))
return -EFAULT;
if (options & WDIOS_DISABLECARD) {
epx_c3_stop();
retval = 0;
}
if (options & WDIOS_ENABLECARD) {
epx_c3_start();
retval = 0;
}
return retval;
case WDIOC_KEEPALIVE:
epx_c3_pet();
return 0;
case WDIOC_GETTIMEOUT:
return put_user(WATCHDOG_TIMEOUT, argp);
default:
return -ENOTTY;
}
}
static int epx_c3_notify_sys(struct notifier_block *this, unsigned long code,
void *unused)
{
if (code == SYS_DOWN || code == SYS_HALT)
epx_c3_stop(); /* Turn the WDT off */
return NOTIFY_DONE;
}
static const struct file_operations epx_c3_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.write = epx_c3_write,
.unlocked_ioctl = epx_c3_ioctl,
.open = epx_c3_open,
.release = epx_c3_release,
};
static struct miscdevice epx_c3_miscdev = {
.minor = WATCHDOG_MINOR,
.name = "watchdog",
.fops = &epx_c3_fops,
};
static struct notifier_block epx_c3_notifier = {
.notifier_call = epx_c3_notify_sys,
};
static const char banner[] __initdata = KERN_INFO PFX
"Hardware Watchdog Timer for Winsystems EPX-C3 SBC: 0.1\n";
static int __init watchdog_init(void)
{
int ret;
if (!request_region(EPXC3_WATCHDOG_CTL_REG, 2, "epxc3_watchdog"))
return -EBUSY;
ret = register_reboot_notifier(&epx_c3_notifier);
if (ret) {
// printk(KERN_ERR PFX "cannot register reboot notifier "
;
goto out;
}
ret = misc_register(&epx_c3_miscdev);
if (ret) {
// printk(KERN_ERR PFX "cannot register miscdev on minor=%d "
;
unregister_reboot_notifier(&epx_c3_notifier);
goto out;
}
;
return 0;
out:
release_region(EPXC3_WATCHDOG_CTL_REG, 2);
return ret;
}
static void __exit watchdog_exit(void)
{
misc_deregister(&epx_c3_miscdev);
unregister_reboot_notifier(&epx_c3_notifier);
release_region(EPXC3_WATCHDOG_CTL_REG, 2);
}
/*
* Deregister sclp_ctl misc device
*/
static void __exit sclp_ctl_exit(void)
{
misc_deregister(&sclp_ctl_device);
}
static void __exit uinput_exit(void)
{
misc_deregister(&uinput_misc);
}
static int etm_probe(struct platform_device *pdev)
{
static int first_device = 0;
struct etm_driver_data *data = dev_get_platdata(&pdev->dev);
int ret = 0;
void __iomem **new_regs;
struct etm_info *new_info;
int new_count;
u32 id, config_code, config_code_extension, system_config;
mutex_lock(&tracer.mutex);
new_count = tracer.nr_etm_regs + 1;
new_regs = krealloc(tracer.etm_regs,
sizeof(tracer.etm_regs[0]) * new_count, GFP_KERNEL);
if (!new_regs) {
pr_err("Failed to allocate ETM register array\n");
ret = -ENOMEM;
goto out;
}
tracer.etm_regs = new_regs;
new_info = krealloc(tracer.etm_info,
sizeof(tracer.etm_info[0]) * new_count, GFP_KERNEL);
if (!new_info) {
pr_err("Failed to allocate ETM info array\n");
ret = -ENOMEM;
goto out;
}
tracer.etm_info = new_info;
tracer.etm_regs[tracer.nr_etm_regs] = data->etm_regs;
if (!first_device) {
first_device = 1;
if (unlikely((ret = misc_register(&etm_device)) != 0)) {
pr_err("Fail to register etm device\n");
goto out;
}
if (unlikely((ret = create_files()) != 0)) {
pr_err("Fail to create device files\n");
goto deregister;
}
}
memset(&(tracer.etm_info[tracer.nr_etm_regs]), 0, sizeof(struct etm_info));
tracer.etm_info[tracer.nr_etm_regs].enable = 1;
tracer.etm_info[tracer.nr_etm_regs].is_ptm = data->is_ptm;
tracer.etm_info[tracer.nr_etm_regs].pwr_down = data->pwr_down;
id = etm_readl(&tracer, tracer.nr_etm_regs, ETMIDR);
config_code = etm_readl(&tracer, tracer.nr_etm_regs, ETMCCR);
config_code_extension = etm_readl(&tracer, tracer.nr_etm_regs, ETMCCER);
system_config = etm_readl(&tracer, tracer.nr_etm_regs, ETMSCR);
tracer.nr_etm_regs = new_count;
out:
mutex_unlock(&tracer.mutex);
return ret;
deregister:
misc_deregister(&etm_device);
mutex_unlock(&tracer.mutex);
return ret;
}
static int __init ecompass_init(void)
{
int res = 0;
pr_info("ecompass driver: init\n");
ecs_data_device = input_allocate_device();
if (!ecs_data_device) {
res = -ENOMEM;
pr_err("%s: failed to allocate input device\n", __FUNCTION__);
goto out;
}
set_bit(EV_ABS, ecs_data_device->evbit);
/* 32768 == 1g, range -4g ~ +4g */
/* acceleration x-axis */
input_set_abs_params(ecs_data_device, ABS_X,
-32768*4, 32768*4, 0, 0);
/* acceleration y-axis */
input_set_abs_params(ecs_data_device, ABS_Y,
-32768*4, 32768*4, 0, 0);
/* acceleration z-axis */
input_set_abs_params(ecs_data_device, ABS_Z,
-32768*4, 32768*4, 0, 0);
/* 32768 == 1gauss, range -4gauss ~ +4gauss */
/* magnetic raw x-axis */
input_set_abs_params(ecs_data_device, ABS_HAT0X,
-32768*4, 32768*4, 0, 0);
/* magnetic raw y-axis */
input_set_abs_params(ecs_data_device, ABS_HAT0Y,
-32768*4, 32768*4, 0, 0);
/* magnetic raw z-axis */
input_set_abs_params(ecs_data_device, ABS_BRAKE,
-32768*4, 32768*4, 0, 0);
/* 65536 == 360degree */
/* orientation yaw, 0 ~ 360 */
input_set_abs_params(ecs_data_device, ABS_RX,
0, 65536, 0, 0);
/* orientation pitch, -180 ~ 180 */
input_set_abs_params(ecs_data_device, ABS_RY,
-65536/2, 65536/2, 0, 0);
/* orientation roll, -90 ~ 90 */
input_set_abs_params(ecs_data_device, ABS_RZ,
-65536/4, 65536/4, 0, 0);
ecs_data_device->name = ECS_DATA_DEV_NAME;
res = input_register_device(ecs_data_device);
if (res) {
pr_err("%s: unable to register input device: %s\n",
__FUNCTION__, ecs_data_device->name);
goto out_free_input;
}
res = misc_register(&ecs_ctrl_device);
if (res) {
pr_err("%s: ecs_ctrl_device register failed\n", __FUNCTION__);
goto out_free_input;
}
res = device_create_file(ecs_ctrl_device.this_device, &dev_attr_ecs_ctrl);
if (res) {
pr_err("%s: device_create_file failed\n", __FUNCTION__);
goto out_deregister_misc;
}
return 0;
out_deregister_misc:
misc_deregister(&ecs_ctrl_device);
out_free_input:
input_free_device(ecs_data_device);
out:
return res;
}
void autofs_dev_ioctl_exit(void)
{
misc_deregister(&_autofs_dev_ioctl_misc);
return;
}
int init_module(void)
{
int nRet, i; /* initialized below */
nRet = 0;
if (system_rev < 0x5){
pr_notice("%s : Vibrator not support HW Rev =[%d] !!!\n",__func__,system_rev);
return 0;
}
DbgOut((KERN_INFO "tspdrv: init_module.\n"));
#ifdef IMPLEMENT_AS_CHAR_DRIVER
printk(KERN_ERR
"[VIBRATOR]IMPLEMENT_AS_CHAR_DRIVER\n");
g_nMajor = register_chrdev(0, MODULE_NAME, &fops);
if (g_nMajor < 0) {
printk(KERN_ERR"[VIBRATOR]tspdrv: can't get major number.\n");
return g_nMajor;
}
#else
nRet = misc_register(&miscdev);
if (nRet) {
printk(KERN_ERR "[VIBRATOR]tspdrv: misc_register failed.\n");
return nRet;
}
#endif
nRet = platform_device_register(&platdev);
if (nRet) {
printk(KERN_ERR "tspdrv: platform_device_register failed.\n");
goto err_platform_dev_reg;
}
nRet = platform_driver_register(&platdrv);
if (nRet) {
printk(KERN_ERR "tspdrv: platform_driver_register failed.\n");
goto err_platform_drv_reg;
}
DbgRecorderInit(());
vibetonz_clk_on(&platdev.dev);
ImmVibeSPI_ForceOut_Initialize();
VibeOSKernelLinuxInitTimer();
/* Get and concatenate device name and initialize data buffer */
g_cchDeviceName = 0;
for (i = 0; i < NUM_ACTUATORS; i++) {
char *szName = g_szDeviceName + g_cchDeviceName;
ImmVibeSPI_Device_GetName(i, szName,
VIBE_MAX_DEVICE_NAME_LENGTH);
/* Append version information and get buffer length */
strcat(szName, VERSION_STR);
g_cchDeviceName += strlen(szName);
g_SamplesBuffer[i].nIndexPlayingBuffer = -1; /* Not playing */
g_SamplesBuffer[i].actuatorSamples[0].nBufferSize = 0;
g_SamplesBuffer[i].actuatorSamples[1].nBufferSize = 0;
}
return 0;
err_platform_drv_reg:
platform_device_unregister(&platdev);
err_platform_dev_reg:
#ifdef IMPLEMENT_AS_CHAR_DRIVER
unregister_chrdev(g_nMajor, MODULE_NAME);
#else
misc_deregister(&miscdev);
#endif
return nRet;
}
