PageRenderTime 37ms CodeModel.GetById 17ms app.highlight 16ms RepoModel.GetById 0ms app.codeStats 0ms

/drivers/pci/hotplug/acpiphp_ibm.c

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