static void acpi_processor_remove(struct acpi_device *device) { struct acpi_processor *pr; if (!device || !acpi_driver_data(device)) return; pr = acpi_driver_data(device); if (pr->id >= nr_cpu_ids) goto out; /* * The only reason why we ever get here is CPU hot-removal. The CPU is * already offline and the ACPI device removal locking prevents it from * being put back online at this point. * * Unbind the driver from the processor device and detach it from the * ACPI companion object. */ device_release_driver(pr->dev); acpi_unbind_one(pr->dev); /* Clean up. */ per_cpu(processor_device_array, pr->id) = NULL; per_cpu(processors, pr->id) = NULL; cpu_maps_update_begin(); cpu_hotplug_begin(); /* Remove the CPU. */ arch_unregister_cpu(pr->id); acpi_unmap_lsapic(pr->id); cpu_hotplug_done(); cpu_maps_update_done(); try_offline_node(cpu_to_node(pr->id)); out: free_cpumask_var(pr->throttling.shared_cpu_map); kfree(pr); }
static int toshiba_acpi_suspend(struct acpi_device *acpi_dev, pm_message_t state) { struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev); u32 result; if (dev->hotkey_dev) hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_DISABLE, &result); return 0; }
static int acpi_lid_input_open(struct input_dev *input) { struct acpi_device *device = input_get_drvdata(input); struct acpi_button *button = acpi_driver_data(device); button->last_state = !!acpi_lid_evaluate_state(device); button->last_time = ktime_get(); acpi_lid_initialize_state(device); return 0; }
int acpi_power_remove ( struct acpi_device *device, int type) { struct acpi_power_resource *resource = NULL; ACPI_FUNCTION_TRACE("acpi_power_remove"); if (!device || !acpi_driver_data(device)) return_VALUE(-EINVAL); resource = (struct acpi_power_resource *) acpi_driver_data(device); acpi_power_remove_fs(device); kfree(resource); return_VALUE(0); }
static int acpi_container_remove(struct acpi_device *device, int type) { acpi_status status = AE_OK; struct acpi_container *pc = NULL; pc = (struct acpi_container *)acpi_driver_data(device); if (pc) kfree(pc); return status; }
int acpi_fan_remove ( struct acpi_device *device, int type) { struct acpi_fan *fan = NULL; ACPI_FUNCTION_TRACE("acpi_fan_remove"); if (!device || !acpi_driver_data(device)) return_VALUE(-EINVAL); fan = (struct acpi_fan *) acpi_driver_data(device); acpi_fan_remove_fs(device); kfree(fan); return_VALUE(0); }
static int acpi_serial_add(struct acpi_device *device) { struct serial_private *priv; acpi_status status; struct serial_struct serial_req; int result; memset(&serial_req, 0, sizeof(serial_req)); priv = kmalloc(sizeof(struct serial_private), GFP_KERNEL); if (!priv) { result = -ENOMEM; goto fail; } memset(priv, 0, sizeof(*priv)); status = acpi_walk_resources(device->handle, METHOD_NAME__CRS, acpi_serial_resource, &serial_req); if (ACPI_FAILURE(status)) { result = -ENODEV; goto fail; } if (serial_req.iomem_base) priv->iomem_base = serial_req.iomem_base; else if (!serial_req.port) { printk(KERN_ERR "%s: no iomem or port address in %s _CRS\n", __FUNCTION__, device->pnp.bus_id); result = -ENODEV; goto fail; } serial_req.baud_base = BASE_BAUD; serial_req.flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF | UPF_RESOURCES; priv->line = register_serial(&serial_req); if (priv->line < 0) { printk(KERN_WARNING "Couldn't register serial port %s: %d\n", device->pnp.bus_id, priv->line); result = -ENODEV; goto fail; } acpi_driver_data(device) = priv; return 0; fail: if (serial_req.iomem_base) iounmap(serial_req.iomem_base); kfree(priv); return result; }
static int acpi_battery_remove(struct acpi_device *device, int type) { acpi_status status = 0; struct acpi_battery *battery = NULL; if (!device || !acpi_driver_data(device)) return -EINVAL; battery = (struct acpi_battery *)acpi_driver_data(device); status = acpi_remove_notify_handler(device->handle, ACPI_ALL_NOTIFY, acpi_battery_notify); acpi_battery_remove_fs(device); kfree(battery); return 0; }
static int toshiba_haps_suspend(struct device *device) { struct toshiba_haps_dev *haps; int ret; haps = acpi_driver_data(to_acpi_device(device)); /* Deactivate the protection on suspend */ ret = toshiba_haps_protection_level(haps->acpi_dev->handle, 0); return ret; }
static int acpi_thermal_remove ( struct acpi_device *device, int type) { acpi_status status = AE_OK; struct acpi_thermal *tz = NULL; ACPI_FUNCTION_TRACE("acpi_thermal_remove"); if (!device || !acpi_driver_data(device)) return_VALUE(-EINVAL); tz = (struct acpi_thermal *) acpi_driver_data(device); if (timer_pending(&(tz->timer))) del_timer(&(tz->timer)); status = acpi_remove_notify_handler(tz->handle, ACPI_DEVICE_NOTIFY, acpi_thermal_notify); if (ACPI_FAILURE(status)) ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error removing notify handler\n")); /* Terminate policy */ if (tz->trips.passive.flags.valid && tz->trips.passive.flags.enabled) { tz->trips.passive.flags.enabled = 0; acpi_thermal_passive(tz); } if (tz->trips.active[0].flags.valid && tz->trips.active[0].flags.enabled) { tz->trips.active[0].flags.enabled = 0; acpi_thermal_active(tz); } acpi_thermal_remove_fs(device); return_VALUE(0); }
static int acpi_processor_add_fs(struct acpi_device *device) { struct proc_dir_entry *entry = NULL; if (!acpi_device_dir(device)) { acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), acpi_processor_dir); if (!acpi_device_dir(device)) return -ENODEV; } acpi_device_dir(device)->owner = THIS_MODULE; /* 'info' [R] */ entry = proc_create_data(ACPI_PROCESSOR_FILE_INFO, S_IRUGO, acpi_device_dir(device), &acpi_processor_info_fops, acpi_driver_data(device)); if (!entry) return -EIO; /* 'throttling' [R/W] */ entry = proc_create_data(ACPI_PROCESSOR_FILE_THROTTLING, S_IFREG | S_IRUGO | S_IWUSR, acpi_device_dir(device), &acpi_processor_throttling_fops, acpi_driver_data(device)); if (!entry) return -EIO; /* 'limit' [R/W] */ entry = proc_create_data(ACPI_PROCESSOR_FILE_LIMIT, S_IFREG | S_IRUGO | S_IWUSR, acpi_device_dir(device), &acpi_processor_limit_fops, acpi_driver_data(device)); if (!entry) return -EIO; return 0; }
static int acpi_processor_remove(struct acpi_device *device, int type) { struct acpi_processor *pr = NULL; if (!device || !acpi_driver_data(device)) return -EINVAL; pr = acpi_driver_data(device); if (pr->id >= nr_cpu_ids) goto free; if (type == ACPI_BUS_REMOVAL_EJECT) { if (acpi_processor_handle_eject(pr)) return -EINVAL; } acpi_processor_power_exit(pr, device); sysfs_remove_link(&device->dev.kobj, "sysdev"); acpi_processor_remove_fs(device); if (pr->cdev) { sysfs_remove_link(&device->dev.kobj, "thermal_cooling"); sysfs_remove_link(&pr->cdev->device.kobj, "device"); thermal_cooling_device_unregister(pr->cdev); pr->cdev = NULL; } per_cpu(processors, pr->id) = NULL; per_cpu(processor_device_array, pr->id) = NULL; free: free_cpumask_var(pr->throttling.shared_cpu_map); kfree(pr); return 0; }
static int acpi_battery_add ( struct acpi_device *device) { int result = 0; acpi_status status = 0; struct acpi_battery *battery = NULL; ACPI_FUNCTION_TRACE("acpi_battery_add"); if (!device) return_VALUE(-EINVAL); battery = kmalloc(sizeof(struct acpi_battery), GFP_KERNEL); if (!battery) return_VALUE(-ENOMEM); memset(battery, 0, sizeof(struct acpi_battery)); battery->handle = device->handle; strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME); strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS); acpi_driver_data(device) = battery; result = acpi_battery_check(battery); if (result) goto end; result = acpi_battery_add_fs(device); if (result) goto end; status = acpi_install_notify_handler(battery->handle, ACPI_DEVICE_NOTIFY, acpi_battery_notify, battery); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error installing notify handler\n")); result = -ENODEV; goto end; } printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n", ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device), device->status.battery_present?"present":"absent"); end: if (result) { acpi_battery_remove_fs(device); kfree(battery); } return_VALUE(result); }
int acpi_ac_add ( struct acpi_device *device) { int result = 0; acpi_status status = AE_OK; struct acpi_ac *ac = NULL; ACPI_FUNCTION_TRACE("acpi_ac_add"); if (!device) return_VALUE(-EINVAL); ac = kmalloc(sizeof(struct acpi_ac), GFP_KERNEL); if (!ac) return_VALUE(-ENOMEM); memset(ac, 0, sizeof(struct acpi_ac)); ac->handle = device->handle; sprintf(acpi_device_name(device), "%s", ACPI_AC_DEVICE_NAME); sprintf(acpi_device_class(device), "%s", ACPI_AC_CLASS); acpi_driver_data(device) = ac; result = acpi_ac_get_state(ac); if (result) goto end; result = acpi_ac_add_fs(device); if (result) goto end; status = acpi_install_notify_handler(ac->handle, ACPI_DEVICE_NOTIFY, acpi_ac_notify, ac); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error installing notify handler\n")); result = -ENODEV; goto end; } printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device), acpi_device_bid(device), ac->state?"on-line":"off-line"); end: if (result) { acpi_ac_remove_fs(device); kfree(ac); } return_VALUE(result); }
static int acpi_thermal_add ( struct acpi_device *device) { int result = 0; acpi_status status = AE_OK; struct acpi_thermal *tz = NULL; ACPI_FUNCTION_TRACE("acpi_thermal_add"); if (!device) return_VALUE(-EINVAL); tz = kmalloc(sizeof(struct acpi_thermal), MEMF_KERNEL); if (!tz) return_VALUE(-ENOMEM); memset(tz, 0, sizeof(struct acpi_thermal)); tz->handle = device->handle; strcpy(tz->name, device->pnp.bus_id); strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME); strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS); acpi_driver_data(device) = tz; result = acpi_thermal_get_info(tz); if (result) goto end; tz->timer = create_timer(); acpi_thermal_check(tz); status = acpi_install_notify_handler(tz->handle, ACPI_DEVICE_NOTIFY, acpi_thermal_notify, tz); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error installing notify handler\n")); result = -ENODEV; goto end; } printk("ACPI: %s [%s] (%ld C)\n", acpi_device_name(device), acpi_device_bid(device), KELVIN_TO_CELSIUS(tz->temperature)); end: if (result) { kfree(tz); } return_VALUE(result); }
static int acpi_fan_remove(struct acpi_device *device, int type) { struct thermal_cooling_device *cdev = acpi_driver_data(device); if (!device || !cdev) return -EINVAL; sysfs_remove_link(&device->dev.kobj, "thermal_cooling"); sysfs_remove_link(&cdev->device.kobj, "device"); thermal_cooling_device_unregister(cdev); return 0; }
static void asus_wireless_notify(struct acpi_device *adev, u32 event) { struct asus_wireless_data *data = acpi_driver_data(adev); dev_dbg(&adev->dev, "event=%#x\n", event); if (event != 0x88) { dev_notice(&adev->dev, "Unknown ASHS event: %#x\n", event); return; } input_report_key(data->idev, KEY_RFKILL, 1); input_report_key(data->idev, KEY_RFKILL, 0); input_sync(data->idev); }
static int acpi_button_remove (struct acpi_device *device, int type) { acpi_status status = 0; struct acpi_button *button = NULL; ACPI_FUNCTION_TRACE("acpi_button_remove"); if (!device || !acpi_driver_data(device)) return_VALUE(-EINVAL); button = acpi_driver_data(device); /* Unregister for device notifications. */ switch (button->type) { case ACPI_BUTTON_TYPE_POWERF: status = acpi_remove_fixed_event_handler( ACPI_EVENT_POWER_BUTTON, acpi_button_notify_fixed); break; case ACPI_BUTTON_TYPE_SLEEPF: status = acpi_remove_fixed_event_handler( ACPI_EVENT_SLEEP_BUTTON, acpi_button_notify_fixed); break; default: status = acpi_remove_notify_handler(button->handle, ACPI_DEVICE_NOTIFY, acpi_button_notify); break; } if (ACPI_FAILURE(status)) ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error removing notify handler\n")); acpi_button_remove_fs(device); kfree(button); return_VALUE(0); }
static int acpi_button_resume(struct device *dev) { struct acpi_device *device = to_acpi_device(dev); struct acpi_button *button = acpi_driver_data(device); button->suspended = false; if (button->type == ACPI_BUTTON_TYPE_LID && button->input->users) { button->last_state = !!acpi_lid_evaluate_state(device); button->last_time = ktime_get(); acpi_lid_initialize_state(device); } return 0; }
static int processor_get_max_state(struct thermal_cooling_device *cdev, unsigned long *state) { struct acpi_device *device = cdev->devdata; struct acpi_processor *pr = acpi_driver_data(device); if (!device || !pr) return -EINVAL; *state = acpi_processor_max_state(pr); return 0; }
struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle) { struct acpi_pci_root *root; struct acpi_device *device; if (acpi_bus_get_device(handle, &device) || acpi_match_device_ids(device, root_device_ids)) return NULL; root = acpi_driver_data(device); return root; }
static int acpi_processor_remove(struct acpi_device *device, int type) { acpi_status status = AE_OK; struct acpi_processor *pr = NULL; ACPI_FUNCTION_TRACE("acpi_processor_remove"); if (!device || !acpi_driver_data(device)) return_VALUE(-EINVAL); pr = (struct acpi_processor *)acpi_driver_data(device); if (pr->id >= NR_CPUS) { kfree(pr); return_VALUE(0); } if (type == ACPI_BUS_REMOVAL_EJECT) { if (acpi_processor_handle_eject(pr)) return_VALUE(-EINVAL); } acpi_processor_power_exit(pr, device); status = acpi_remove_notify_handler(pr->handle, ACPI_DEVICE_NOTIFY, acpi_processor_notify); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error removing notify handler\n")); } acpi_processor_remove_fs(device); processors[pr->id] = NULL; kfree(pr); return_VALUE(0); }
static void __ref acpi_processor_hotplug_notify(acpi_handle handle, u32 event, void *data) { struct acpi_processor *pr; struct acpi_device *device = NULL; int result; switch (event) { case ACPI_NOTIFY_BUS_CHECK: case ACPI_NOTIFY_DEVICE_CHECK: ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor driver received %s event\n", (event == ACPI_NOTIFY_BUS_CHECK) ? "ACPI_NOTIFY_BUS_CHECK" : "ACPI_NOTIFY_DEVICE_CHECK")); if (!is_processor_present(handle)) break; if (acpi_bus_get_device(handle, &device)) { result = acpi_processor_device_add(handle, &device); if (result) printk(KERN_ERR PREFIX "Unable to add the device\n"); break; } break; case ACPI_NOTIFY_EJECT_REQUEST: ACPI_DEBUG_PRINT((ACPI_DB_INFO, "received ACPI_NOTIFY_EJECT_REQUEST\n")); if (acpi_bus_get_device(handle, &device)) { printk(KERN_ERR PREFIX "Device don't exist, dropping EJECT\n"); break; } pr = acpi_driver_data(device); if (!pr) { printk(KERN_ERR PREFIX "Driver data is NULL, dropping EJECT\n"); return; } break; default: ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Unsupported event [0x%x]\n", event)); break; } return; }
static int xen_acpi_processor_remove(struct acpi_device *device) { struct acpi_processor *pr; if (!device) return -EINVAL; pr = acpi_driver_data(device); if (!pr) return -EINVAL; kfree(pr); return 0; }
int ec_write(u8 addr, u8 val) { struct acpi_ec *ec; int err; if (!first_ec) return -ENODEV; ec = acpi_driver_data(first_ec); err = acpi_ec_write(ec, addr, val); return err; }
int ec_transaction(u8 command, const u8 * wdata, unsigned wdata_len, u8 * rdata, unsigned rdata_len) { struct acpi_ec *ec; if (!first_ec) return -ENODEV; ec = acpi_driver_data(first_ec); return acpi_ec_transaction(ec, command, wdata, wdata_len, rdata, rdata_len); }
static int asus_acpi_remove(struct acpi_device *device, int type) { struct asus_laptop *asus = acpi_driver_data(device); asus_backlight_exit(asus); asus_rfkill_exit(asus); asus_led_exit(asus); asus_input_exit(asus); asus_platform_exit(asus); kfree(asus->name); kfree(asus); return 0; }
static void acpi_cpufreq_add_file(struct acpi_processor *pr) { struct acpi_device *device = NULL; if (acpi_bus_get_device(pr->handle, &device)) return; /* add file 'performance' [R/W] */ proc_create_data(ACPI_PROCESSOR_FILE_PERFORMANCE, S_IFREG | S_IRUGO, acpi_device_dir(device), &acpi_processor_perf_fops, acpi_driver_data(device)); return; }
static int acpi_power_remove(struct acpi_device *device, int type) { struct acpi_power_resource *resource; if (!device) return -EINVAL; resource = acpi_driver_data(device); if (!resource) return -EINVAL; kfree(resource); return 0; }
static int processor_get_cur_state(struct thermal_cooling_device *cdev, unsigned long *cur_state) { struct acpi_device *device = cdev->devdata; struct acpi_processor *pr = acpi_driver_data(device); if (!device || !pr) return -EINVAL; *cur_state = cpufreq_get_cur_state(pr->id); if (pr->flags.throttling) *cur_state += pr->throttling.state; return 0; }