1 /*
2  * ACPI PCI Hot Plug IBM Extension
3  *
4  * Copyright (C) 2004 Vernon Mauery <vernux@us.ibm.com>
5  * Copyright (C) 2004 IBM Corp.
6  *
7  * All rights reserved.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or (at
12  * your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful, but
15  * WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
17  * NON INFRINGEMENT.  See the GNU General Public License for more
18  * details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  *
24  * Send feedback to <vernux@us.ibm.com>
25  *
26  */
27 
28 #define pr_fmt(fmt) "acpiphp_ibm: " fmt
29 
30 #include <linux/init.h>
31 #include <linux/slab.h>
32 #include <linux/module.h>
33 #include <linux/kernel.h>
34 #include <linux/sysfs.h>
35 #include <linux/kobject.h>
36 #include <linux/moduleparam.h>
37 #include <linux/pci.h>
38 #include <asm/uaccess.h>
39 
40 #include "acpiphp.h"
41 #include "../pci.h"
42 
43 #define DRIVER_VERSION	"1.0.1"
44 #define DRIVER_AUTHOR	"Irene Zubarev <zubarev@us.ibm.com>, Vernon Mauery <vernux@us.ibm.com>"
45 #define DRIVER_DESC	"ACPI Hot Plug PCI Controller Driver IBM extension"
46 
47 
48 MODULE_AUTHOR(DRIVER_AUTHOR);
49 MODULE_DESCRIPTION(DRIVER_DESC);
50 MODULE_LICENSE("GPL");
51 MODULE_VERSION(DRIVER_VERSION);
52 
53 #define FOUND_APCI 0x61504349
54 /* these are the names for the IBM ACPI pseudo-device */
55 #define IBM_HARDWARE_ID1 "IBM37D0"
56 #define IBM_HARDWARE_ID2 "IBM37D4"
57 
58 #define hpslot_to_sun(A) (((struct slot *)((A)->private))->sun)
59 
60 /* union apci_descriptor - allows access to the
61  * various device descriptors that are embedded in the
62  * aPCI table
63  */
64 union apci_descriptor {
65 	struct {
66 		char sig[4];
67 		u8   len;
68 	} header;
69 	struct {
70 		u8  type;
71 		u8  len;
72 		u16 slot_id;
73 		u8  bus_id;
74 		u8  dev_num;
75 		u8  slot_num;
76 		u8  slot_attr[2];
77 		u8  attn;
78 		u8  status[2];
79 		u8  sun;
80 		u8  res[3];
81 	} slot;
82 	struct {
83 		u8 type;
84 		u8 len;
85 	} generic;
86 };
87 
88 /* struct notification - keeps info about the device
89  * that cause the ACPI notification event
90  */
91 struct notification {
92 	struct acpi_device *device;
93 	u8                  event;
94 };
95 
96 static int ibm_set_attention_status(struct hotplug_slot *slot, u8 status);
97 static int ibm_get_attention_status(struct hotplug_slot *slot, u8 *status);
98 static void ibm_handle_events(acpi_handle handle, u32 event, void *context);
99 static int ibm_get_table_from_acpi(char **bufp);
100 static ssize_t ibm_read_apci_table(struct file *filp, struct kobject *kobj,
101 				   struct bin_attribute *bin_attr,
102 				   char *buffer, loff_t pos, size_t size);
103 static acpi_status __init ibm_find_acpi_device(acpi_handle handle,
104 		u32 lvl, void *context, void **rv);
105 static int __init ibm_acpiphp_init(void);
106 static void __exit ibm_acpiphp_exit(void);
107 
108 static acpi_handle ibm_acpi_handle;
109 static struct notification ibm_note;
110 static struct bin_attribute ibm_apci_table_attr = {
111 	    .attr = {
112 		    .name = "apci_table",
113 		    .mode = S_IRUGO,
114 	    },
115 	    .read = ibm_read_apci_table,
116 	    .write = NULL,
117 };
118 static struct acpiphp_attention_info ibm_attention_info =
119 {
120 	.set_attn = ibm_set_attention_status,
121 	.get_attn = ibm_get_attention_status,
122 	.owner = THIS_MODULE,
123 };
124 
125 /**
126  * ibm_slot_from_id - workaround for bad ibm hardware
127  * @id: the slot number that linux refers to the slot by
128  *
129  * Description: This method returns the aCPI slot descriptor
130  * corresponding to the Linux slot number.  This descriptor
131  * has info about the aPCI slot id and attention status.
132  * This descriptor must be freed using kfree when done.
133  */
134 static union apci_descriptor *ibm_slot_from_id(int id)
135 {
136 	int ind = 0, size;
137 	union apci_descriptor *ret = NULL, *des;
138 	char *table;
139 
140 	size = ibm_get_table_from_acpi(&table);
141 	if (size < 0)
142 		return NULL;
143 	des = (union apci_descriptor *)table;
144 	if (memcmp(des->header.sig, "aPCI", 4) != 0)
145 		goto ibm_slot_done;
146 
147 	des = (union apci_descriptor *)&table[ind += des->header.len];
148 	while (ind < size && (des->generic.type != 0x82 ||
149 			des->slot.slot_num != id)) {
150 		des = (union apci_descriptor *)&table[ind += des->generic.len];
151 	}
152 
153 	if (ind < size && des->slot.slot_num == id)
154 		ret = des;
155 
156 ibm_slot_done:
157 	if (ret) {
158 		ret = kmalloc(sizeof(union apci_descriptor), GFP_KERNEL);
159 		if (ret)
160 			memcpy(ret, des, sizeof(union apci_descriptor));
161 	}
162 	kfree(table);
163 	return ret;
164 }
165 
166 /**
167  * ibm_set_attention_status - callback method to set the attention LED
168  * @slot: the hotplug_slot to work with
169  * @status: what to set the LED to (0 or 1)
170  *
171  * Description: This method is registered with the acpiphp module as a
172  * callback to do the device specific task of setting the LED status.
173  */
174 static int ibm_set_attention_status(struct hotplug_slot *slot, u8 status)
175 {
176 	union acpi_object args[2];
177 	struct acpi_object_list params = { .pointer = args, .count = 2 };
178 	acpi_status stat;
179 	unsigned long long rc;
180 	union apci_descriptor *ibm_slot;
181 	int id = hpslot_to_sun(slot);
182 
183 	ibm_slot = ibm_slot_from_id(id);
184 	if (!ibm_slot) {
185 		pr_err("APLS null ACPI descriptor for slot %d\n", id);
186 		return -ENODEV;
187 	}
188 
189 	pr_debug("%s: set slot %d (%d) attention status to %d\n", __func__,
190 			ibm_slot->slot.slot_num, ibm_slot->slot.slot_id,
191 			(status ? 1 : 0));
192 
193 	args[0].type = ACPI_TYPE_INTEGER;
194 	args[0].integer.value = ibm_slot->slot.slot_id;
195 	args[1].type = ACPI_TYPE_INTEGER;
196 	args[1].integer.value = (status) ? 1 : 0;
197 
198 	kfree(ibm_slot);
199 
200 	stat = acpi_evaluate_integer(ibm_acpi_handle, "APLS", &params, &rc);
201 	if (ACPI_FAILURE(stat)) {
202 		pr_err("APLS evaluation failed:  0x%08x\n", stat);
203 		return -ENODEV;
204 	} else if (!rc) {
205 		pr_err("APLS method failed:  0x%08llx\n", rc);
206 		return -ERANGE;
207 	}
208 	return 0;
209 }
210 
211 /**
212  * ibm_get_attention_status - callback method to get attention LED status
213  * @slot: the hotplug_slot to work with
214  * @status: returns what the LED is set to (0 or 1)
215  *
216  * Description: This method is registered with the acpiphp module as a
217  * callback to do the device specific task of getting the LED status.
218  *
219  * Because there is no direct method of getting the LED status directly
220  * from an ACPI call, we read the aPCI table and parse out our
221  * slot descriptor to read the status from that.
222  */
223 static int ibm_get_attention_status(struct hotplug_slot *slot, u8 *status)
224 {
225 	union apci_descriptor *ibm_slot;
226 	int id = hpslot_to_sun(slot);
227 
228 	ibm_slot = ibm_slot_from_id(id);
229 	if (!ibm_slot) {
230 		pr_err("APLS null ACPI descriptor for slot %d\n", id);
231 		return -ENODEV;
232 	}
233 
234 	if (ibm_slot->slot.attn & 0xa0 || ibm_slot->slot.status[1] & 0x08)
235 		*status = 1;
236 	else
237 		*status = 0;
238 
239 	pr_debug("%s: get slot %d (%d) attention status is %d\n", __func__,
240 			ibm_slot->slot.slot_num, ibm_slot->slot.slot_id,
241 			*status);
242 
243 	kfree(ibm_slot);
244 	return 0;
245 }
246 
247 /**
248  * ibm_handle_events - listens for ACPI events for the IBM37D0 device
249  * @handle: an ACPI handle to the device that caused the event
250  * @event: the event info (device specific)
251  * @context: passed context (our notification struct)
252  *
253  * Description: This method is registered as a callback with the ACPI
254  * subsystem it is called when this device has an event to notify the OS of.
255  *
256  * The events actually come from the device as two events that get
257  * synthesized into one event with data by this function.  The event
258  * ID comes first and then the slot number that caused it.  We report
259  * this as one event to the OS.
260  *
261  * From section 5.6.2.2 of the ACPI 2.0 spec, I understand that the OSPM will
262  * only re-enable the interrupt that causes this event AFTER this method
263  * has returned, thereby enforcing serial access for the notification struct.
264  */
265 static void ibm_handle_events(acpi_handle handle, u32 event, void *context)
266 {
267 	u8 detail = event & 0x0f;
268 	u8 subevent = event & 0xf0;
269 	struct notification *note = context;
270 
271 	pr_debug("%s: Received notification %02x\n", __func__, event);
272 
273 	if (subevent == 0x80) {
274 		pr_debug("%s: generating bus event\n", __func__);
275 		acpi_bus_generate_netlink_event(note->device->pnp.device_class,
276 						  dev_name(&note->device->dev),
277 						  note->event, detail);
278 	} else
279 		note->event = event;
280 }
281 
282 /**
283  * ibm_get_table_from_acpi - reads the APLS buffer from ACPI
284  * @bufp: address to pointer to allocate for the table
285  *
286  * Description: This method reads the APLS buffer in from ACPI and
287  * stores the "stripped" table into a single buffer
288  * it allocates and passes the address back in bufp.
289  *
290  * If NULL is passed in as buffer, this method only calculates
291  * the size of the table and returns that without filling
292  * in the buffer.
293  *
294  * Returns < 0 on error or the size of the table on success.
295  */
296 static int ibm_get_table_from_acpi(char **bufp)
297 {
298 	union acpi_object *package;
299 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
300 	acpi_status status;
301 	char *lbuf = NULL;
302 	int i, size = -EIO;
303 
304 	status = acpi_evaluate_object(ibm_acpi_handle, "APCI", NULL, &buffer);
305 	if (ACPI_FAILURE(status)) {
306 		pr_err("%s:  APCI evaluation failed\n", __func__);
307 		return -ENODEV;
308 	}
309 
310 	package = (union acpi_object *) buffer.pointer;
311 	if (!(package) ||
312 			(package->type != ACPI_TYPE_PACKAGE) ||
313 			!(package->package.elements)) {
314 		pr_err("%s:  Invalid APCI object\n", __func__);
315 		goto read_table_done;
316 	}
317 
318 	for (size = 0, i = 0; i < package->package.count; i++) {
319 		if (package->package.elements[i].type != ACPI_TYPE_BUFFER) {
320 			pr_err("%s:  Invalid APCI element %d\n", __func__, i);
321 			goto read_table_done;
322 		}
323 		size += package->package.elements[i].buffer.length;
324 	}
325 
326 	if (bufp == NULL)
327 		goto read_table_done;
328 
329 	lbuf = kzalloc(size, GFP_KERNEL);
330 	pr_debug("%s: element count: %i, ASL table size: %i, &table = 0x%p\n",
331 			__func__, package->package.count, size, lbuf);
332 
333 	if (lbuf) {
334 		*bufp = lbuf;
335 	} else {
336 		size = -ENOMEM;
337 		goto read_table_done;
338 	}
339 
340 	size = 0;
341 	for (i = 0; i < package->package.count; i++) {
342 		memcpy(&lbuf[size],
343 				package->package.elements[i].buffer.pointer,
344 				package->package.elements[i].buffer.length);
345 		size += package->package.elements[i].buffer.length;
346 	}
347 
348 read_table_done:
349 	kfree(buffer.pointer);
350 	return size;
351 }
352 
353 /**
354  * ibm_read_apci_table - callback for the sysfs apci_table file
355  * @filp: the open sysfs file
356  * @kobj: the kobject this binary attribute is a part of
357  * @bin_attr: struct bin_attribute for this file
358  * @buffer: the kernel space buffer to fill
359  * @pos: the offset into the file
360  * @size: the number of bytes requested
361  *
362  * Description: Gets registered with sysfs as the reader callback
363  * to be executed when /sys/bus/pci/slots/apci_table gets read.
364  *
365  * Since we don't get notified on open and close for this file,
366  * things get really tricky here...
367  * our solution is to only allow reading the table in all at once.
368  */
369 static ssize_t ibm_read_apci_table(struct file *filp, struct kobject *kobj,
370 				   struct bin_attribute *bin_attr,
371 				   char *buffer, loff_t pos, size_t size)
372 {
373 	int bytes_read = -EINVAL;
374 	char *table = NULL;
375 
376 	pr_debug("%s: pos = %d, size = %zd\n", __func__, (int)pos, size);
377 
378 	if (pos == 0) {
379 		bytes_read = ibm_get_table_from_acpi(&table);
380 		if (bytes_read > 0 && bytes_read <= size)
381 			memcpy(buffer, table, bytes_read);
382 		kfree(table);
383 	}
384 	return bytes_read;
385 }
386 
387 /**
388  * ibm_find_acpi_device - callback to find our ACPI device
389  * @handle: the ACPI handle of the device we are inspecting
390  * @lvl: depth into the namespace tree
391  * @context: a pointer to our handle to fill when we find the device
392  * @rv: a return value to fill if desired
393  *
394  * Description: Used as a callback when calling acpi_walk_namespace
395  * to find our device.  When this method returns non-zero
396  * acpi_walk_namespace quits its search and returns our value.
397  */
398 static acpi_status __init ibm_find_acpi_device(acpi_handle handle,
399 		u32 lvl, void *context, void **rv)
400 {
401 	acpi_handle *phandle = (acpi_handle *)context;
402 	acpi_status status;
403 	struct acpi_device_info *info;
404 	int retval = 0;
405 
406 	status = acpi_get_object_info(handle, &info);
407 	if (ACPI_FAILURE(status)) {
408 		pr_err("%s:  Failed to get device information status=0x%x\n",
409 			__func__, status);
410 		return retval;
411 	}
412 
413 	if (info->current_status && (info->valid & ACPI_VALID_HID) &&
414 			(!strcmp(info->hardware_id.string, IBM_HARDWARE_ID1) ||
415 			 !strcmp(info->hardware_id.string, IBM_HARDWARE_ID2))) {
416 		pr_debug("found hardware: %s, handle: %p\n",
417 			info->hardware_id.string, handle);
418 		*phandle = handle;
419 		/* returning non-zero causes the search to stop
420 		 * and returns this value to the caller of
421 		 * acpi_walk_namespace, but it also causes some warnings
422 		 * in the acpi debug code to print...
423 		 */
424 		retval = FOUND_APCI;
425 	}
426 	kfree(info);
427 	return retval;
428 }
429 
430 static int __init ibm_acpiphp_init(void)
431 {
432 	int retval = 0;
433 	acpi_status status;
434 	struct acpi_device *device;
435 	struct kobject *sysdir = &pci_slots_kset->kobj;
436 
437 	pr_debug("%s\n", __func__);
438 
439 	if (acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
440 			ACPI_UINT32_MAX, ibm_find_acpi_device, NULL,
441 			&ibm_acpi_handle, NULL) != FOUND_APCI) {
442 		pr_err("%s: acpi_walk_namespace failed\n", __func__);
443 		retval = -ENODEV;
444 		goto init_return;
445 	}
446 	pr_debug("%s: found IBM aPCI device\n", __func__);
447 	if (acpi_bus_get_device(ibm_acpi_handle, &device)) {
448 		pr_err("%s: acpi_bus_get_device failed\n", __func__);
449 		retval = -ENODEV;
450 		goto init_return;
451 	}
452 	if (acpiphp_register_attention(&ibm_attention_info)) {
453 		retval = -ENODEV;
454 		goto init_return;
455 	}
456 
457 	ibm_note.device = device;
458 	status = acpi_install_notify_handler(ibm_acpi_handle,
459 			ACPI_DEVICE_NOTIFY, ibm_handle_events,
460 			&ibm_note);
461 	if (ACPI_FAILURE(status)) {
462 		pr_err("%s: Failed to register notification handler\n",
463 				__func__);
464 		retval = -EBUSY;
465 		goto init_cleanup;
466 	}
467 
468 	ibm_apci_table_attr.size = ibm_get_table_from_acpi(NULL);
469 	retval = sysfs_create_bin_file(sysdir, &ibm_apci_table_attr);
470 
471 	return retval;
472 
473 init_cleanup:
474 	acpiphp_unregister_attention(&ibm_attention_info);
475 init_return:
476 	return retval;
477 }
478 
479 static void __exit ibm_acpiphp_exit(void)
480 {
481 	acpi_status status;
482 	struct kobject *sysdir = &pci_slots_kset->kobj;
483 
484 	pr_debug("%s\n", __func__);
485 
486 	if (acpiphp_unregister_attention(&ibm_attention_info))
487 		pr_err("%s: attention info deregistration failed", __func__);
488 
489 	status = acpi_remove_notify_handler(
490 			   ibm_acpi_handle,
491 			   ACPI_DEVICE_NOTIFY,
492 			   ibm_handle_events);
493 	if (ACPI_FAILURE(status))
494 		pr_err("%s: Notification handler removal failed\n", __func__);
495 	/* remove the /sys entries */
496 	sysfs_remove_bin_file(sysdir, &ibm_apci_table_attr);
497 }
498 
499 module_init(ibm_acpiphp_init);
500 module_exit(ibm_acpiphp_exit);
501