static void cmpc_accel_close(struct input_dev *input) { struct acpi_device *acpi; acpi = to_acpi_device(input->dev.parent); cmpc_stop_accel(acpi->handle); }
static ssize_t cmpc_accel_g_select_store_v4(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct acpi_device *acpi; struct input_dev *inputdev; struct cmpc_accel *accel; unsigned long g_select; int r; acpi = to_acpi_device(dev); inputdev = dev_get_drvdata(&acpi->dev); accel = dev_get_drvdata(&inputdev->dev); r = kstrtoul(buf, 0, &g_select); if (r) return r; /* 0 means 1.5g, 1 means 6g, everything else is wrong */ if (g_select != 0 && g_select != 1) return -EINVAL; accel->g_select = g_select; cmpc_accel_set_g_select_v4(acpi->handle, g_select); return strnlen(buf, count); }
static ssize_t set_trip(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count) { struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); struct acpi_device *acpi_dev = to_acpi_device(dev); struct acpi_power_meter_resource *resource = acpi_dev->driver_data; int res; unsigned long temp; res = strict_strtoul(buf, 10, &temp); if (res) return res; temp /= 1000; if (temp < 0) return -EINVAL; mutex_lock(&resource->lock); resource->trip[attr->index - 7] = temp; res = set_acpi_trip(resource); mutex_unlock(&resource->lock); if (res) return res; return count; }
static int acpi_thermal_resume(struct device *dev) { struct acpi_thermal *tz; int i, j, power_state, result; if (!dev) return -EINVAL; tz = acpi_driver_data(to_acpi_device(dev)); if (!tz) return -EINVAL; for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) { if (!(&tz->trips.active[i])) break; if (!tz->trips.active[i].flags.valid) break; tz->trips.active[i].flags.enabled = 1; for (j = 0; j < tz->trips.active[i].devices.count; j++) { result = acpi_bus_update_power( tz->trips.active[i].devices.handles[j], &power_state); if (result || (power_state != ACPI_STATE_D0)) { tz->trips.active[i].flags.enabled = 0; break; } } tz->state.active |= tz->trips.active[i].flags.enabled; } queue_work(acpi_thermal_pm_queue, &tz->thermal_check_work); return AE_OK; }
static ssize_t cmpc_accel_sensitivity_store_v4(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct acpi_device *acpi; struct input_dev *inputdev; struct cmpc_accel *accel; unsigned long sensitivity; int r; acpi = to_acpi_device(dev); inputdev = dev_get_drvdata(&acpi->dev); accel = dev_get_drvdata(&inputdev->dev); r = kstrtoul(buf, 0, &sensitivity); if (r) return r; /* sensitivity must be between 1 and 127 */ if (sensitivity < 1 || sensitivity > 127) return -EINVAL; accel->sensitivity = sensitivity; cmpc_accel_set_sensitivity_v4(acpi->handle, sensitivity); return strnlen(buf, count); }
static ssize_t als_show_ali(struct device *dev, struct device_attribute *attr, char *buf) { struct acpi_device *device = to_acpi_device(dev); return sprintf(buf, "%d\n", als_get_ali(device)); }
static int acpi_power_resume(struct device *dev) { int result = 0, state; struct acpi_device *device; struct acpi_power_resource *resource; if (!dev) return -EINVAL; device = to_acpi_device(dev); resource = acpi_driver_data(device); if (!resource) return -EINVAL; mutex_lock(&resource->resource_lock); result = acpi_power_get_state(device->handle, &state); if (result) goto unlock; if (state == ACPI_POWER_RESOURCE_STATE_OFF && resource->ref_count) result = __acpi_power_on(resource); unlock: mutex_unlock(&resource->resource_lock); return result; }
static long __init parse_acpi_path(struct efi_dev_path *node, struct device *parent, struct device **child) { struct acpi_hid_uid hid_uid = {}; struct device *phys_dev; if (node->length != 12) return -EINVAL; sprintf(hid_uid.hid[0].id, "%c%c%c%04X", 'A' + ((node->acpi.hid >> 10) & 0x1f) - 1, 'A' + ((node->acpi.hid >> 5) & 0x1f) - 1, 'A' + ((node->acpi.hid >> 0) & 0x1f) - 1, node->acpi.hid >> 16); sprintf(hid_uid.uid, "%u", node->acpi.uid); *child = bus_find_device(&acpi_bus_type, NULL, &hid_uid, match_acpi_dev); if (!*child) return -ENODEV; phys_dev = acpi_get_first_physical_node(to_acpi_device(*child)); if (phys_dev) { get_device(phys_dev); put_device(*child); *child = phys_dev; } return 0; }
static ssize_t show_str(struct device *dev, struct device_attribute *devattr, char *buf) { struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); struct acpi_device *acpi_dev = to_acpi_device(dev); struct acpi_power_meter_resource *resource = acpi_dev->driver_data; acpi_string val; switch (attr->index) { case 0: val = resource->model_number; break; case 1: val = resource->serial_number; break; case 2: val = resource->oem_info; break; default: BUG(); } return sprintf(buf, "%s\n", val); }
static int acpi_button_suspend(struct device *dev) { struct acpi_device *device = to_acpi_device(dev); struct acpi_button *button = acpi_driver_data(device); button->suspended = true; return 0; }
static int acpi_fan_suspend(struct device *dev) { if (!dev) return -EINVAL; acpi_bus_set_power(to_acpi_device(dev)->handle, ACPI_STATE_D0); return AE_OK; }
static int cmpc_accel_open(struct input_dev *input) { struct acpi_device *acpi; acpi = to_acpi_device(input->dev.parent); if (ACPI_SUCCESS(cmpc_start_accel(acpi->handle))) return 0; return -EIO; }
static int toshiba_acpi_resume(struct device *device) { struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device)); u32 result; if (dev->hotkey_dev) hci_write1(dev, HCI_HOTKEY_EVENT, HCI_HOTKEY_ENABLE, &result); return 0; }
static int __init acpi_pnp_match(struct device *dev, void *_pnp) { struct acpi_device *acpi = to_acpi_device(dev); struct pnp_dev *pnp = _pnp; /* true means it matched */ return acpi->flags.hardware_id && !acpi_get_physical_device(acpi->handle) && compare_pnp_id(pnp->id, acpi->pnp.hardware_id); }
static ssize_t show_accuracy(struct device *dev, struct device_attribute *devattr, char *buf) { struct acpi_device *acpi_dev = to_acpi_device(dev); struct acpi_power_meter_resource *resource = acpi_dev->driver_data; unsigned int acc = resource->caps.accuracy; return sprintf(buf, "%u.%u%%\n", acc / 1000, acc % 1000); }
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) acpi_lid_initialize_state(device); return 0; }
static ssize_t show_val(struct device *dev, struct device_attribute *devattr, char *buf) { struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); struct acpi_device *acpi_dev = to_acpi_device(dev); struct acpi_power_meter_resource *resource = acpi_dev->driver_data; u64 val = 0; switch (attr->index) { case 0: val = resource->caps.min_avg_interval; break; case 1: val = resource->caps.max_avg_interval; break; case 2: val = resource->caps.min_cap * 1000; break; case 3: val = resource->caps.max_cap * 1000; break; case 4: if (resource->caps.hysteresis == UNKNOWN_HYSTERESIS) return sprintf(buf, "unknown\n"); val = resource->caps.hysteresis * 1000; break; case 5: if (resource->caps.flags & POWER_METER_IS_BATTERY) val = 1; else val = 0; break; case 6: if (resource->power > resource->cap) val = 1; else val = 0; break; case 7: case 8: if (resource->trip[attr->index - 7] < 0) return sprintf(buf, "unknown\n"); val = resource->trip[attr->index - 7] * 1000; break; default: WARN(1, "Implementation error: unexpected attribute index %d\n", attr->index); break; } return sprintf(buf, "%llu\n", val); }
static int cmpc_accel_resume_v4(struct device *dev) { struct input_dev *inputdev; struct cmpc_accel *accel; inputdev = dev_get_drvdata(dev); accel = dev_get_drvdata(&inputdev->dev); if (accel->inputdev_state == CMPC_ACCEL_DEV_STATE_OPEN) { cmpc_accel_set_sensitivity_v4(to_acpi_device(dev)->handle, accel->sensitivity); cmpc_accel_set_g_select_v4(to_acpi_device(dev)->handle, accel->g_select); if (ACPI_FAILURE(cmpc_start_accel_v4(to_acpi_device(dev)->handle))) return -EIO; } return 0; }
static int rbtn_inc_count(struct device *dev, void *data) { struct acpi_device *device = to_acpi_device(dev); struct rbtn_data *rbtn_data = device->driver_data; int *count = data; if (rbtn_data->type == RBTN_SLIDER) (*count)++; return 0; }
static void cmpc_accel_close_v4(struct input_dev *input) { struct acpi_device *acpi; struct cmpc_accel *accel; acpi = to_acpi_device(input->dev.parent); accel = dev_get_drvdata(&input->dev); cmpc_stop_accel_v4(acpi->handle); accel->inputdev_state = CMPC_ACCEL_DEV_STATE_CLOSED; }
static int cmpc_tablet_resume(struct device *dev) { struct input_dev *inputdev = dev_get_drvdata(dev); unsigned long long val = 0; if (ACPI_SUCCESS(cmpc_get_tablet(to_acpi_device(dev)->handle, &val))) { input_report_switch(inputdev, SW_TABLET_MODE, !val); input_sync(inputdev); } 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 void cmpc_tablet_idev_init(struct input_dev *inputdev) { unsigned long long val = 0; struct acpi_device *acpi; set_bit(EV_SW, inputdev->evbit); set_bit(SW_TABLET_MODE, inputdev->swbit); acpi = to_acpi_device(inputdev->dev.parent); if (ACPI_SUCCESS(cmpc_get_tablet(acpi->handle, &val))) input_report_switch(inputdev, SW_TABLET_MODE, !val); }
static ssize_t show_power(struct device *dev, struct device_attribute *devattr, char *buf) { struct acpi_device *acpi_dev = to_acpi_device(dev); struct acpi_power_meter_resource *resource = acpi_dev->driver_data; mutex_lock(&resource->lock); update_meter(resource); mutex_unlock(&resource->lock); return sprintf(buf, "%llu\n", resource->power * 1000); }
static int cmpc_accel_suspend_v4(struct device *dev) { struct input_dev *inputdev; struct cmpc_accel *accel; inputdev = dev_get_drvdata(dev); accel = dev_get_drvdata(&inputdev->dev); if (accel->inputdev_state == CMPC_ACCEL_DEV_STATE_OPEN) return cmpc_stop_accel_v4(to_acpi_device(dev)->handle); return 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 acpi_fan_resume(struct device *dev) { int result; if (!dev) return -EINVAL; result = acpi_bus_update_power(to_acpi_device(dev)->handle, NULL); if (result) printk(KERN_ERR PREFIX "Error updating fan power state\n"); return result; }
static int __init match_acpi_dev(struct device *dev, void *data) { struct acpi_hid_uid hid_uid = *(struct acpi_hid_uid *)data; struct acpi_device *adev = to_acpi_device(dev); if (acpi_match_device_ids(adev, hid_uid.hid)) return 0; if (adev->pnp.unique_id) return !strcmp(adev->pnp.unique_id, hid_uid.uid); else return !strcmp("0", hid_uid.uid); }
static ssize_t cmpc_accel_sensitivity_show(struct device *dev, struct device_attribute *attr, char *buf) { struct acpi_device *acpi; struct input_dev *inputdev; struct cmpc_accel *accel; acpi = to_acpi_device(dev); inputdev = dev_get_drvdata(&acpi->dev); accel = dev_get_drvdata(&inputdev->dev); return sprintf(buf, "%d\n", accel->sensitivity); }
static int __init acpi_pnp_find_device(struct device *dev, acpi_handle * handle) { struct device *adev; struct acpi_device *acpi; adev = bus_find_device(&acpi_bus_type, NULL, to_pnp_dev(dev), acpi_pnp_match); if (!adev) return -ENODEV; acpi = to_acpi_device(adev); *handle = acpi->handle; put_device(adev); return 0; }