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#include <linux/module.h>
28#include <linux/moduleparam.h>
29#include <linux/kernel.h>
30#include <linux/types.h>
31#include <linux/pci.h>
32#include <linux/pci_hotplug.h>
33#include <linux/acpi.h>
34#include <linux/pci-acpi.h>
35
36#define MY_NAME "acpi_pcihp"
37
38#define dbg(fmt, arg...) do { if (debug_acpi) printk(KERN_DEBUG "%s: %s: " fmt , MY_NAME , __func__ , ## arg); } while (0)
39#define err(format, arg...) printk(KERN_ERR "%s: " format , MY_NAME , ## arg)
40#define info(format, arg...) printk(KERN_INFO "%s: " format , MY_NAME , ## arg)
41#define warn(format, arg...) printk(KERN_WARNING "%s: " format , MY_NAME , ## arg)
42
43#define METHOD_NAME__SUN "_SUN"
44#define METHOD_NAME_OSHP "OSHP"
45
46static int debug_acpi;
47
48static acpi_status
49decode_type0_hpx_record(union acpi_object *record, struct hotplug_params *hpx)
50{
51 int i;
52 union acpi_object *fields = record->package.elements;
53 u32 revision = fields[1].integer.value;
54
55 switch (revision) {
56 case 1:
57 if (record->package.count != 6)
58 return AE_ERROR;
59 for (i = 2; i < 6; i++)
60 if (fields[i].type != ACPI_TYPE_INTEGER)
61 return AE_ERROR;
62 hpx->t0 = &hpx->type0_data;
63 hpx->t0->revision = revision;
64 hpx->t0->cache_line_size = fields[2].integer.value;
65 hpx->t0->latency_timer = fields[3].integer.value;
66 hpx->t0->enable_serr = fields[4].integer.value;
67 hpx->t0->enable_perr = fields[5].integer.value;
68 break;
69 default:
70 printk(KERN_WARNING
71 "%s: Type 0 Revision %d record not supported\n",
72 __func__, revision);
73 return AE_ERROR;
74 }
75 return AE_OK;
76}
77
78static acpi_status
79decode_type1_hpx_record(union acpi_object *record, struct hotplug_params *hpx)
80{
81 int i;
82 union acpi_object *fields = record->package.elements;
83 u32 revision = fields[1].integer.value;
84
85 switch (revision) {
86 case 1:
87 if (record->package.count != 5)
88 return AE_ERROR;
89 for (i = 2; i < 5; i++)
90 if (fields[i].type != ACPI_TYPE_INTEGER)
91 return AE_ERROR;
92 hpx->t1 = &hpx->type1_data;
93 hpx->t1->revision = revision;
94 hpx->t1->max_mem_read = fields[2].integer.value;
95 hpx->t1->avg_max_split = fields[3].integer.value;
96 hpx->t1->tot_max_split = fields[4].integer.value;
97 break;
98 default:
99 printk(KERN_WARNING
100 "%s: Type 1 Revision %d record not supported\n",
101 __func__, revision);
102 return AE_ERROR;
103 }
104 return AE_OK;
105}
106
107static acpi_status
108decode_type2_hpx_record(union acpi_object *record, struct hotplug_params *hpx)
109{
110 int i;
111 union acpi_object *fields = record->package.elements;
112 u32 revision = fields[1].integer.value;
113
114 switch (revision) {
115 case 1:
116 if (record->package.count != 18)
117 return AE_ERROR;
118 for (i = 2; i < 18; i++)
119 if (fields[i].type != ACPI_TYPE_INTEGER)
120 return AE_ERROR;
121 hpx->t2 = &hpx->type2_data;
122 hpx->t2->revision = revision;
123 hpx->t2->unc_err_mask_and = fields[2].integer.value;
124 hpx->t2->unc_err_mask_or = fields[3].integer.value;
125 hpx->t2->unc_err_sever_and = fields[4].integer.value;
126 hpx->t2->unc_err_sever_or = fields[5].integer.value;
127 hpx->t2->cor_err_mask_and = fields[6].integer.value;
128 hpx->t2->cor_err_mask_or = fields[7].integer.value;
129 hpx->t2->adv_err_cap_and = fields[8].integer.value;
130 hpx->t2->adv_err_cap_or = fields[9].integer.value;
131 hpx->t2->pci_exp_devctl_and = fields[10].integer.value;
132 hpx->t2->pci_exp_devctl_or = fields[11].integer.value;
133 hpx->t2->pci_exp_lnkctl_and = fields[12].integer.value;
134 hpx->t2->pci_exp_lnkctl_or = fields[13].integer.value;
135 hpx->t2->sec_unc_err_sever_and = fields[14].integer.value;
136 hpx->t2->sec_unc_err_sever_or = fields[15].integer.value;
137 hpx->t2->sec_unc_err_mask_and = fields[16].integer.value;
138 hpx->t2->sec_unc_err_mask_or = fields[17].integer.value;
139 break;
140 default:
141 printk(KERN_WARNING
142 "%s: Type 2 Revision %d record not supported\n",
143 __func__, revision);
144 return AE_ERROR;
145 }
146 return AE_OK;
147}
148
149static acpi_status
150acpi_run_hpx(acpi_handle handle, struct hotplug_params *hpx)
151{
152 acpi_status status;
153 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
154 union acpi_object *package, *record, *fields;
155 u32 type;
156 int i;
157
158
159 memset(hpx, 0, sizeof(struct hotplug_params));
160
161 status = acpi_evaluate_object(handle, "_HPX", NULL, &buffer);
162 if (ACPI_FAILURE(status))
163 return status;
164
165 package = (union acpi_object *)buffer.pointer;
166 if (package->type != ACPI_TYPE_PACKAGE) {
167 status = AE_ERROR;
168 goto exit;
169 }
170
171 for (i = 0; i < package->package.count; i++) {
172 record = &package->package.elements[i];
173 if (record->type != ACPI_TYPE_PACKAGE) {
174 status = AE_ERROR;
175 goto exit;
176 }
177
178 fields = record->package.elements;
179 if (fields[0].type != ACPI_TYPE_INTEGER ||
180 fields[1].type != ACPI_TYPE_INTEGER) {
181 status = AE_ERROR;
182 goto exit;
183 }
184
185 type = fields[0].integer.value;
186 switch (type) {
187 case 0:
188 status = decode_type0_hpx_record(record, hpx);
189 if (ACPI_FAILURE(status))
190 goto exit;
191 break;
192 case 1:
193 status = decode_type1_hpx_record(record, hpx);
194 if (ACPI_FAILURE(status))
195 goto exit;
196 break;
197 case 2:
198 status = decode_type2_hpx_record(record, hpx);
199 if (ACPI_FAILURE(status))
200 goto exit;
201 break;
202 default:
203 printk(KERN_ERR "%s: Type %d record not supported\n",
204 __func__, type);
205 status = AE_ERROR;
206 goto exit;
207 }
208 }
209 exit:
210 kfree(buffer.pointer);
211 return status;
212}
213
214static acpi_status
215acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp)
216{
217 acpi_status status;
218 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
219 union acpi_object *package, *fields;
220 int i;
221
222 memset(hpp, 0, sizeof(struct hotplug_params));
223
224 status = acpi_evaluate_object(handle, "_HPP", NULL, &buffer);
225 if (ACPI_FAILURE(status))
226 return status;
227
228 package = (union acpi_object *) buffer.pointer;
229 if (package->type != ACPI_TYPE_PACKAGE ||
230 package->package.count != 4) {
231 status = AE_ERROR;
232 goto exit;
233 }
234
235 fields = package->package.elements;
236 for (i = 0; i < 4; i++) {
237 if (fields[i].type != ACPI_TYPE_INTEGER) {
238 status = AE_ERROR;
239 goto exit;
240 }
241 }
242
243 hpp->t0 = &hpp->type0_data;
244 hpp->t0->revision = 1;
245 hpp->t0->cache_line_size = fields[0].integer.value;
246 hpp->t0->latency_timer = fields[1].integer.value;
247 hpp->t0->enable_serr = fields[2].integer.value;
248 hpp->t0->enable_perr = fields[3].integer.value;
249
250exit:
251 kfree(buffer.pointer);
252 return status;
253}
254
255
256
257
258
259
260
261static acpi_status acpi_run_oshp(acpi_handle handle)
262{
263 acpi_status status;
264 struct acpi_buffer string = { ACPI_ALLOCATE_BUFFER, NULL };
265
266 acpi_get_name(handle, ACPI_FULL_PATHNAME, &string);
267
268
269 status = acpi_evaluate_object(handle, METHOD_NAME_OSHP, NULL, NULL);
270 if (ACPI_FAILURE(status))
271 if (status != AE_NOT_FOUND)
272 printk(KERN_ERR "%s:%s OSHP fails=0x%x\n",
273 __func__, (char *)string.pointer, status);
274 else
275 dbg("%s:%s OSHP not found\n",
276 __func__, (char *)string.pointer);
277 else
278 pr_debug("%s:%s OSHP passes\n", __func__,
279 (char *)string.pointer);
280
281 kfree(string.pointer);
282 return status;
283}
284
285
286
287
288
289
290int pci_get_hp_params(struct pci_dev *dev, struct hotplug_params *hpp)
291{
292 acpi_status status;
293 acpi_handle handle, phandle;
294 struct pci_bus *pbus;
295
296 handle = NULL;
297 for (pbus = dev->bus; pbus; pbus = pbus->parent) {
298 handle = acpi_pci_get_bridge_handle(pbus);
299 if (handle)
300 break;
301 }
302
303
304
305
306
307
308
309 while (handle) {
310 status = acpi_run_hpx(handle, hpp);
311 if (ACPI_SUCCESS(status))
312 return 0;
313 status = acpi_run_hpp(handle, hpp);
314 if (ACPI_SUCCESS(status))
315 return 0;
316 if (acpi_is_root_bridge(handle))
317 break;
318 status = acpi_get_parent(handle, &phandle);
319 if (ACPI_FAILURE(status))
320 break;
321 handle = phandle;
322 }
323 return -ENODEV;
324}
325EXPORT_SYMBOL_GPL(pci_get_hp_params);
326
327
328
329
330
331
332
333
334int acpi_get_hp_hw_control_from_firmware(struct pci_dev *pdev, u32 flags)
335{
336 acpi_status status;
337 acpi_handle chandle, handle;
338 struct acpi_buffer string = { ACPI_ALLOCATE_BUFFER, NULL };
339
340 flags &= (OSC_PCI_EXPRESS_NATIVE_HP_CONTROL |
341 OSC_SHPC_NATIVE_HP_CONTROL |
342 OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL);
343 if (!flags) {
344 err("Invalid flags %u specified!\n", flags);
345 return -EINVAL;
346 }
347
348
349
350
351
352
353
354
355
356
357 handle = acpi_find_root_bridge_handle(pdev);
358 if (handle) {
359 acpi_get_name(handle, ACPI_FULL_PATHNAME, &string);
360 dbg("Trying to get hotplug control for %s\n",
361 (char *)string.pointer);
362 status = acpi_pci_osc_control_set(handle, flags);
363 if (ACPI_SUCCESS(status))
364 goto got_one;
365 kfree(string.pointer);
366 string = (struct acpi_buffer){ ACPI_ALLOCATE_BUFFER, NULL };
367 }
368
369 handle = DEVICE_ACPI_HANDLE(&pdev->dev);
370 if (!handle) {
371
372
373
374
375 struct pci_bus *pbus;
376 for (pbus = pdev->bus; pbus; pbus = pbus->parent) {
377 handle = acpi_pci_get_bridge_handle(pbus);
378 if (handle)
379 break;
380 }
381 }
382
383 while (handle) {
384 acpi_get_name(handle, ACPI_FULL_PATHNAME, &string);
385 dbg("Trying to get hotplug control for %s \n",
386 (char *)string.pointer);
387 status = acpi_run_oshp(handle);
388 if (ACPI_SUCCESS(status))
389 goto got_one;
390 if (acpi_is_root_bridge(handle))
391 break;
392 chandle = handle;
393 status = acpi_get_parent(chandle, &handle);
394 if (ACPI_FAILURE(status))
395 break;
396 }
397
398 dbg("Cannot get control of hotplug hardware for pci %s\n",
399 pci_name(pdev));
400
401 kfree(string.pointer);
402 return -ENODEV;
403got_one:
404 dbg("Gained control for hotplug HW for pci %s (%s)\n",
405 pci_name(pdev), (char *)string.pointer);
406 kfree(string.pointer);
407 return 0;
408}
409EXPORT_SYMBOL(acpi_get_hp_hw_control_from_firmware);
410
411static int is_ejectable(acpi_handle handle)
412{
413 acpi_status status;
414 acpi_handle tmp;
415 unsigned long long removable;
416 status = acpi_get_handle(handle, "_ADR", &tmp);
417 if (ACPI_FAILURE(status))
418 return 0;
419 status = acpi_get_handle(handle, "_EJ0", &tmp);
420 if (ACPI_SUCCESS(status))
421 return 1;
422 status = acpi_evaluate_integer(handle, "_RMV", NULL, &removable);
423 if (ACPI_SUCCESS(status) && removable)
424 return 1;
425 return 0;
426}
427
428
429
430
431
432
433
434
435int acpi_pci_check_ejectable(struct pci_bus *pbus, acpi_handle handle)
436{
437 acpi_handle bridge_handle, parent_handle;
438
439 if (!(bridge_handle = acpi_pci_get_bridge_handle(pbus)))
440 return 0;
441 if ((ACPI_FAILURE(acpi_get_parent(handle, &parent_handle))))
442 return 0;
443 if (bridge_handle != parent_handle)
444 return 0;
445 return is_ejectable(handle);
446}
447EXPORT_SYMBOL_GPL(acpi_pci_check_ejectable);
448
449static acpi_status
450check_hotplug(acpi_handle handle, u32 lvl, void *context, void **rv)
451{
452 int *found = (int *)context;
453 if (is_ejectable(handle)) {
454 *found = 1;
455 return AE_CTRL_TERMINATE;
456 }
457 return AE_OK;
458}
459
460
461
462
463
464
465
466int acpi_pci_detect_ejectable(acpi_handle handle)
467{
468 int found = 0;
469
470 if (!handle)
471 return found;
472
473 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
474 check_hotplug, (void *)&found, NULL);
475 return found;
476}
477EXPORT_SYMBOL_GPL(acpi_pci_detect_ejectable);
478
479module_param(debug_acpi, bool, 0644);
480MODULE_PARM_DESC(debug_acpi, "Debugging mode for ACPI enabled or not");
481
