自学教程：C++ to_acpi_device函数代码示例

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 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 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 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 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;}