aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/nsp32_io.h
blob: e3f3c27b01efb1e67ebf93faab1658b61aea821b (plain) (blame) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259

/*
 * Workbit NinjaSCSI-32Bi/UDE PCI/CardBus SCSI Host Bus Adapter driver
 * I/O routine
 *
 * This software may be used and distributed according to the terms of
 * the GNU General Public License.
 */

#ifndef _NSP32_IO_H
#define _NSP32_IO_H

static inline void nsp32_write1(unsigned int  base,
				unsigned int  index,
				unsigned char val)
{
	outb(val, (base + index));
}

static inline unsigned char nsp32_read1(unsigned int base,
					unsigned int index)
{
	return inb(base + index);
}

static inline void nsp32_write2(unsigned int   base,
				unsigned int   index,
				unsigned short val)
{
	outw(val, (base + index));
}

static inline unsigned short nsp32_read2(unsigned int base,
					 unsigned int index)
{
	return inw(base + index);
}

static inline void nsp32_write4(unsigned int  base,
				unsigned int  index,
				unsigned long val)
{
	outl(val, (base + index));
}

static inline unsigned long nsp32_read4(unsigned int base,
					unsigned int index)
{
	return inl(base + index);
}

/*==============================================*/

static inline void nsp32_mmio_write1(unsigned long base,
				     unsigned int  index,
				     unsigned char val)
{
	volatile unsigned char *ptr;

	ptr = (unsigned char *)(base + NSP32_MMIO_OFFSET + index);

	writeb(val, ptr);
}

static inline unsigned char nsp32_mmio_read1(unsigned long base,
					     unsigned int  index)
{
	volatile unsigned char *ptr;

	ptr = (unsigned char *)(base + NSP32_MMIO_OFFSET + index);

	return readb(ptr);
}

static inline void nsp32_mmio_write2(unsigned long  base,
				     unsigned int   index,
				     unsigned short val)
{
	volatile unsigned short *ptr;

	ptr = (unsigned short *)(base + NSP32_MMIO_OFFSET + index);

	writew(cpu_to_le16(val), ptr);
}

static inline unsigned short nsp32_mmio_read2(unsigned long base,
					      unsigned int  index)
{
	volatile unsigned short *ptr;

	ptr = (unsigned short *)(base + NSP32_MMIO_OFFSET + index);

	return le16_to_cpu(readw(ptr));
}

static inline void nsp32_mmio_write4(unsigned long base,
				     unsigned int  index,
				     unsigned long val)
{
	volatile unsigned long *ptr;

	ptr = (unsigned long *)(base + NSP32_MMIO_OFFSET + index);

	writel(cpu_to_le32(val), ptr);
}

static inline unsigned long nsp32_mmio_read4(unsigned long base,
					     unsigned int  index)
{
	volatile unsigned long *ptr;

	ptr = (unsigned long *)(base + NSP32_MMIO_OFFSET + index);

	return le32_to_cpu(readl(ptr));
}

/*==============================================*/

static inline unsigned char nsp32_index_read1(unsigned int base,
					      unsigned int reg)
{
	outb(reg, base + INDEX_REG);
	return inb(base + DATA_REG_LOW);
}

static inline void nsp32_index_write1(unsigned int  base,
				      unsigned int  reg,
				      unsigned char val)
{
	outb(reg, base + INDEX_REG   );
	outb(val, base + DATA_REG_LOW);
}

static inline unsigned short nsp32_index_read2(unsigned int base,
					       unsigned int reg)
{
	outb(reg, base + INDEX_REG);
	return inw(base + DATA_REG_LOW);
}

static inline void nsp32_index_write2(unsigned int   base,
				      unsigned int   reg,
				      unsigned short val)
{
	outb(reg, base + INDEX_REG   );
	outw(val, base + DATA_REG_LOW);
}

static inline unsigned long nsp32_index_read4(unsigned int base,
					      unsigned int reg)
{
	unsigned long h,l;

	outb(reg, base + INDEX_REG);
	l = inw(base + DATA_REG_LOW);
	h = inw(base + DATA_REG_HI );

	return ((h << 16) | l);
}

static inline void nsp32_index_write4(unsigned int  base,
				      unsigned int  reg,
				      unsigned long val)
{
	unsigned long h,l;

	h = (val & 0xffff0000) >> 16;
	l = (val & 0x0000ffff) >>  0;

	outb(reg, base + INDEX_REG   );
	outw(l,   base + DATA_REG_LOW);
	outw(h,   base + DATA_REG_HI );
}

/*==============================================*/

static inline unsigned char nsp32_mmio_index_read1(unsigned long base,
						   unsigned int reg)
{
	volatile unsigned short *index_ptr, *data_ptr;

	index_ptr = (unsigned short *)(base + NSP32_MMIO_OFFSET + INDEX_REG);
	data_ptr  = (unsigned short *)(base + NSP32_MMIO_OFFSET + DATA_REG_LOW);

	writeb(reg, index_ptr);
	return readb(data_ptr);
}

static inline void nsp32_mmio_index_write1(unsigned long base,
					   unsigned int  reg,
					   unsigned char val)
{
	volatile unsigned short *index_ptr, *data_ptr;

	index_ptr = (unsigned short *)(base + NSP32_MMIO_OFFSET + INDEX_REG);
	data_ptr  = (unsigned short *)(base + NSP32_MMIO_OFFSET + DATA_REG_LOW);

	writeb(reg, index_ptr);
	writeb(val, data_ptr );
}

static inline unsigned short nsp32_mmio_index_read2(unsigned long base,
						    unsigned int  reg)
{
	volatile unsigned short *index_ptr, *data_ptr;

	index_ptr = (unsigned short *)(base + NSP32_MMIO_OFFSET + INDEX_REG);
	data_ptr  = (unsigned short *)(base + NSP32_MMIO_OFFSET + DATA_REG_LOW);

	writeb(reg, index_ptr);
	return le16_to_cpu(readw(data_ptr));
}

static inline void nsp32_mmio_index_write2(unsigned long  base,
					   unsigned int   reg,
					   unsigned short val)
{
	volatile unsigned short *index_ptr, *data_ptr;

	index_ptr = (unsigned short *)(base + NSP32_MMIO_OFFSET + INDEX_REG);
	data_ptr  = (unsigned short *)(base + NSP32_MMIO_OFFSET + DATA_REG_LOW);

	writeb(reg,              index_ptr);
	writew(cpu_to_le16(val), data_ptr );
}

/*==============================================*/

static inline void nsp32_multi_read4(unsigned int   base,
				     unsigned int   reg,
				     void          *buf,
				     unsigned long  count)
{
	insl(base + reg, buf, count);
}

static inline void nsp32_fifo_read(unsigned int   base,
				   void          *buf,
				   unsigned long  count)
{
	nsp32_multi_read4(base, FIFO_DATA_LOW, buf, count);
}

static inline void nsp32_multi_write4(unsigned int   base,
				      unsigned int   reg,
				      void          *buf,
				      unsigned long  count)
{
	outsl(base + reg, buf, count);
}

static inline void nsp32_fifo_write(unsigned int   base,
				    void          *buf,
				    unsigned long  count)
{
	nsp32_multi_write4(base, FIFO_DATA_LOW, buf, count);
}

#endif /* _NSP32_IO_H */
/* end */
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-10 13:15:53 -0400
", .class = ACPI_POWER_CLASS, .ids = power_device_ids, .ops = { .add = acpi_power_add, .remove = acpi_power_remove, }, .drv.pm = &acpi_power_pm, }; /* * A power managed device * A device may rely on multiple power resources. * */ struct acpi_power_managed_device { struct device *dev; /* The physical device */ acpi_handle *handle; }; struct acpi_power_resource_device { struct acpi_power_managed_device *device; struct acpi_power_resource_device *next; }; struct acpi_power_resource { struct acpi_device * device; acpi_bus_id name; u32 system_level; u32 order; unsigned int ref_count; struct mutex resource_lock; /* List of devices relying on this power resource */ struct acpi_power_resource_device *devices; }; static struct list_head acpi_power_resource_list; /* -------------------------------------------------------------------------- Power Resource Management -------------------------------------------------------------------------- */ static int acpi_power_get_context(acpi_handle handle, struct acpi_power_resource **resource) { int result = 0; struct acpi_device *device = NULL; if (!resource) return -ENODEV; result = acpi_bus_get_device(handle, &device); if (result) { printk(KERN_WARNING PREFIX "Getting context [%p]\n", handle); return result; } *resource = acpi_driver_data(device); if (!*resource) return -ENODEV; return 0; } static int acpi_power_get_state(acpi_handle handle, int *state) { acpi_status status = AE_OK; unsigned long long sta = 0; char node_name[5]; struct acpi_buffer buffer = { sizeof(node_name), node_name }; if (!handle || !state) return -EINVAL; status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); if (ACPI_FAILURE(status)) return -ENODEV; *state = (sta & 0x01)?ACPI_POWER_RESOURCE_STATE_ON: ACPI_POWER_RESOURCE_STATE_OFF; acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer); ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n", node_name, *state ? "on" : "off")); return 0; } static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state) { int cur_state; int i = 0; if (!list || !state) return -EINVAL; /* The state of the list is 'on' IFF all resources are 'on'. */ for (i = 0; i < list->count; i++) { struct acpi_power_resource *resource; acpi_handle handle = list->handles[i]; int result; result = acpi_power_get_context(handle, &resource); if (result) return result; mutex_lock(&resource->resource_lock); result = acpi_power_get_state(handle, &cur_state); mutex_unlock(&resource->resource_lock); if (result) return result; if (cur_state != ACPI_POWER_RESOURCE_STATE_ON) break; } ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n", cur_state ? "on" : "off")); *state = cur_state; return 0; } /* Resume the device when all power resources in _PR0 are on */ static void acpi_power_on_device(struct acpi_power_managed_device *device) { struct acpi_device *acpi_dev; acpi_handle handle = device->handle; int state; if (acpi_bus_get_device(handle, &acpi_dev)) return; if(acpi_power_get_inferred_state(acpi_dev, &state)) return; if (state == ACPI_STATE_D0 && pm_runtime_suspended(device->dev)) pm_request_resume(device->dev); } static int __acpi_power_on(struct acpi_power_resource *resource) { struct acpi_power_resource_device *device_list = resource->devices; acpi_status status = AE_OK; status = acpi_evaluate_object(resource->device->handle, "_ON", NULL, NULL); if (ACPI_FAILURE(status)) return -ENODEV; /* Update the power resource's _device_ power state */ resource->device->power.state = ACPI_STATE_D0; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] turned on\n", resource->name)); while (device_list) { acpi_power_on_device(device_list->device); device_list = device_list->next; } return 0; } static int acpi_power_on(acpi_handle handle) { int result = 0; struct acpi_power_resource *resource = NULL; result = acpi_power_get_context(handle, &resource); if (result) return result; mutex_lock(&resource->resource_lock); if (resource->ref_count++) { ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] already on", resource->name)); } else { result = __acpi_power_on(resource); if (result) resource->ref_count--; } mutex_unlock(&resource->resource_lock); return result; } static int acpi_power_off(acpi_handle handle) { int result = 0; acpi_status status = AE_OK; struct acpi_power_resource *resource = NULL; result = acpi_power_get_context(handle, &resource); if (result) return result; mutex_lock(&resource->resource_lock); if (!resource->ref_count) { ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] already off", resource->name)); goto unlock; } if (--resource->ref_count) { ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] still in use\n", resource->name)); goto unlock; } status = acpi_evaluate_object(resource->device->handle, "_OFF", NULL, NULL); if (ACPI_FAILURE(status)) { result = -ENODEV; } else { /* Update the power resource's _device_ power state */ resource->device->power.state = ACPI_STATE_D3; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] turned off\n", resource->name)); } unlock: mutex_unlock(&resource->resource_lock); return result; } static void __acpi_power_off_list(struct acpi_handle_list *list, int num_res) { int i; for (i = num_res - 1; i >= 0 ; i--) acpi_power_off(list->handles[i]); } static void acpi_power_off_list(struct acpi_handle_list *list) { __acpi_power_off_list(list, list->count); } static int acpi_power_on_list(struct acpi_handle_list *list) { int result = 0; int i; for (i = 0; i < list->count; i++) { result = acpi_power_on(list->handles[i]); if (result) { __acpi_power_off_list(list, i); break; } } return result; } static void __acpi_power_resource_unregister_device(struct device *dev, acpi_handle res_handle) { struct acpi_power_resource *resource = NULL; struct acpi_power_resource_device *prev, *curr; if (acpi_power_get_context(res_handle, &resource)) return; mutex_lock(&resource->resource_lock); prev = NULL; curr = resource->devices; while (curr) { if (curr->device->dev == dev) { if (!prev) resource->devices = curr->next; else prev->next = curr->next; kfree(curr); break; } prev = curr; curr = curr->next; } mutex_unlock(&resource->resource_lock); } /* Unlink dev from all power resources in _PR0 */ void acpi_power_resource_unregister_device(struct device *dev, acpi_handle handle) { struct acpi_device *acpi_dev; struct acpi_handle_list *list; int i; if (!dev || !handle) return; if (acpi_bus_get_device(handle, &acpi_dev)) return; list = &acpi_dev->power.states[ACPI_STATE_D0].resources; for (i = 0; i < list->count; i++) __acpi_power_resource_unregister_device(dev, list->handles[i]); } EXPORT_SYMBOL_GPL(acpi_power_resource_unregister_device); static int __acpi_power_resource_register_device( struct acpi_power_managed_device *powered_device, acpi_handle handle) { struct acpi_power_resource *resource = NULL; struct acpi_power_resource_device *power_resource_device; int result; result = acpi_power_get_context(handle, &resource); if (result) return result; power_resource_device = kzalloc( sizeof(*power_resource_device), GFP_KERNEL); if (!power_resource_device) return -ENOMEM; power_resource_device->device = powered_device; mutex_lock(&resource->resource_lock); power_resource_device->next = resource->devices; resource->devices = power_resource_device; mutex_unlock(&resource->resource_lock); return 0; } /* Link dev to all power resources in _PR0 */ int acpi_power_resource_register_device(struct device *dev, acpi_handle handle) { struct acpi_device *acpi_dev; struct acpi_handle_list *list; struct acpi_power_managed_device *powered_device; int i, ret; if (!dev || !handle) return -ENODEV; ret = acpi_bus_get_device(handle, &acpi_dev); if (ret) goto no_power_resource; if (!acpi_dev->power.flags.power_resources) goto no_power_resource; powered_device = kzalloc(sizeof(*powered_device), GFP_KERNEL); if (!powered_device) return -ENOMEM; powered_device->dev = dev; powered_device->handle = handle; list = &acpi_dev->power.states[ACPI_STATE_D0].resources; for (i = 0; i < list->count; i++) { ret = __acpi_power_resource_register_device(powered_device, list->handles[i]); if (ret) { acpi_power_resource_unregister_device(dev, handle); break; } } return ret; no_power_resource: printk(KERN_WARNING PREFIX "Invalid Power Resource to register!"); return -ENODEV; } EXPORT_SYMBOL_GPL(acpi_power_resource_register_device); /** * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in * ACPI 3.0) _PSW (Power State Wake) * @dev: Device to handle. * @enable: 0 - disable, 1 - enable the wake capabilities of the device. * @sleep_state: Target sleep state of the system. * @dev_state: Target power state of the device. * * Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power * State Wake) for the device, if present. On failure reset the device's * wakeup.flags.valid flag. * * RETURN VALUE: * 0 if either _DSW or _PSW has been successfully executed * 0 if neither _DSW nor _PSW has been found * -ENODEV if the execution of either _DSW or _PSW has failed */ int acpi_device_sleep_wake(struct acpi_device *dev, int enable, int sleep_state, int dev_state) { union acpi_object in_arg[3]; struct acpi_object_list arg_list = { 3, in_arg }; acpi_status status = AE_OK; /* * Try to execute _DSW first. * * Three agruments are needed for the _DSW object: * Argument 0: enable/disable the wake capabilities * Argument 1: target system state * Argument 2: target device state * When _DSW object is called to disable the wake capabilities, maybe * the first argument is filled. The values of the other two agruments * are meaningless. */ in_arg[0].type = ACPI_TYPE_INTEGER; in_arg[0].integer.value = enable; in_arg[1].type = ACPI_TYPE_INTEGER; in_arg[1].integer.value = sleep_state; in_arg[2].type = ACPI_TYPE_INTEGER; in_arg[2].integer.value = dev_state; status = acpi_evaluate_object(dev->handle, "_DSW", &arg_list, NULL); if (ACPI_SUCCESS(status)) { return 0; } else if (status != AE_NOT_FOUND) { printk(KERN_ERR PREFIX "_DSW execution failed\n"); dev->wakeup.flags.valid = 0; return -ENODEV; } /* Execute _PSW */ arg_list.count = 1; in_arg[0].integer.value = enable; status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL); if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) { printk(KERN_ERR PREFIX "_PSW execution failed\n"); dev->wakeup.flags.valid = 0; return -ENODEV; } return 0; } /* * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229): * 1. Power on the power resources required for the wakeup device * 2. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power * State Wake) for the device, if present */ int acpi_enable_wakeup_device_power(struct acpi_device *dev, int sleep_state) { int i, err = 0; if (!dev || !dev->wakeup.flags.valid) return -EINVAL; mutex_lock(&acpi_device_lock); if (dev->wakeup.prepare_count++) goto out; /* Open power resource */ for (i = 0; i < dev->wakeup.resources.count; i++) { int ret = acpi_power_on(dev->wakeup.resources.handles[i]); if (ret) { printk(KERN_ERR PREFIX "Transition power state\n"); dev->wakeup.flags.valid = 0; err = -ENODEV; goto err_out; } } /* * Passing 3 as the third argument below means the device may be placed * in arbitrary power state afterwards. */ err = acpi_device_sleep_wake(dev, 1, sleep_state, 3); err_out: if (err) dev->wakeup.prepare_count = 0; out: mutex_unlock(&acpi_device_lock); return err; } /* * Shutdown a wakeup device, counterpart of above method * 1. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power * State Wake) for the device, if present * 2. Shutdown down the power resources */ int acpi_disable_wakeup_device_power(struct acpi_device *dev) { int i, err = 0; if (!dev || !dev->wakeup.flags.valid) return -EINVAL; mutex_lock(&acpi_device_lock); if (--dev->wakeup.prepare_count > 0) goto out; /* * Executing the code below even if prepare_count is already zero when * the function is called may be useful, for example for initialisation. */ if (dev->wakeup.prepare_count < 0) dev->wakeup.prepare_count = 0; err = acpi_device_sleep_wake(dev, 0, 0, 0); if (err) goto out; /* Close power resource */ for (i = 0; i < dev->wakeup.resources.count; i++) { int ret = acpi_power_off(dev->wakeup.resources.handles[i]); if (ret) { printk(KERN_ERR PREFIX "Transition power state\n"); dev->wakeup.flags.valid = 0; err = -ENODEV; goto out; } } out: mutex_unlock(&acpi_device_lock); return err; } /* -------------------------------------------------------------------------- Device Power Management -------------------------------------------------------------------------- */ int acpi_power_get_inferred_state(struct acpi_device *device, int *state) { int result = 0; struct acpi_handle_list *list = NULL; int list_state = 0; int i = 0; if (!device || !state) return -EINVAL; /* * We know a device's inferred power state when all the resources * required for a given D-state are 'on'. */ for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) { list = &device->power.states[i].resources; if (list->count < 1) continue; result = acpi_power_get_list_state(list, &list_state); if (result) return result; if (list_state == ACPI_POWER_RESOURCE_STATE_ON) { *state = i; return 0; } } *state = ACPI_STATE_D3; return 0; } int acpi_power_on_resources(struct acpi_device *device, int state) { if (!device || state < ACPI_STATE_D0 || state > ACPI_STATE_D3) return -EINVAL; return acpi_power_on_list(&device->power.states[state].resources); } int acpi_power_transition(struct acpi_device *device, int state) { int result = 0; if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD)) return -EINVAL; if (device->power.state == state) return 0; if ((device->power.state < ACPI_STATE_D0) || (device->power.state > ACPI_STATE_D3_COLD)) return -ENODEV; /* TBD: Resources must be ordered. */ /* * First we reference all power resources required in the target list * (e.g. so the device doesn't lose power while transitioning). Then, * we dereference all power resources used in the current list. */ if (state < ACPI_STATE_D3_COLD) result = acpi_power_on_list( &device->power.states[state].resources); if (!result && device->power.state < ACPI_STATE_D3_COLD) acpi_power_off_list( &device->power.states[device->power.state].resources); /* We shouldn't change the state unless the above operations succeed. */ device->power.state = result ? ACPI_STATE_UNKNOWN : state; return result; } /* -------------------------------------------------------------------------- Driver Interface -------------------------------------------------------------------------- */ static int acpi_power_add(struct acpi_device *device) { int result = 0, state; acpi_status status = AE_OK; struct acpi_power_resource *resource = NULL; union acpi_object acpi_object; struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object }; if (!device) return -EINVAL; resource = kzalloc(sizeof(struct acpi_power_resource), GFP_KERNEL); if (!resource) return -ENOMEM; resource->device = device; mutex_init(&resource->resource_lock); strcpy(resource->name, device->pnp.bus_id); strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME); strcpy(acpi_device_class(device), ACPI_POWER_CLASS); device->driver_data = resource; /* Evalute the object to get the system level and resource order. */ status = acpi_evaluate_object(device->handle, NULL, NULL, &buffer); if (ACPI_FAILURE(status)) { result = -ENODEV; goto end; } resource->system_level = acpi_object.power_resource.system_level; resource->order = acpi_object.power_resource.resource_order; result = acpi_power_get_state(device->handle, &state); if (result) goto end; switch (state) { case ACPI_POWER_RESOURCE_STATE_ON: device->power.state = ACPI_STATE_D0; break; case ACPI_POWER_RESOURCE_STATE_OFF: device->power.state = ACPI_STATE_D3; break; default: device->power.state = ACPI_STATE_UNKNOWN; break; } printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device), acpi_device_bid(device), state ? "on" : "off"); end: if (result) kfree(resource); return result; } 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 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; } int __init acpi_power_init(void) { INIT_LIST_HEAD(&acpi_power_resource_list); return acpi_bus_register_driver(&acpi_power_driver); }
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-10 13:15:53 -0400