1/*
2 * ACPI PCI Hot Plug Controller Driver
3 *
4 * Copyright (C) 1995,2001 Compaq Computer Corporation
5 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
6 * Copyright (C) 2001 IBM Corp.
7 * Copyright (C) 2002 Hiroshi Aono (h-aono@ap.jp.nec.com)
8 * Copyright (C) 2002,2003 Takayoshi Kochi (t-kochi@bq.jp.nec.com)
9 * Copyright (C) 2002,2003 NEC Corporation
10 * Copyright (C) 2003-2005 Matthew Wilcox (matthew.wilcox@hp.com)
11 * Copyright (C) 2003-2005 Hewlett Packard
12 *
13 * All rights reserved.
14 *
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or (at
18 * your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful, but
21 * WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
23 * NON INFRINGEMENT.  See the GNU General Public License for more
24 * details.
25 *
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 *
30 * Send feedback to <kristen.c.accardi@intel.com>
31 *
32 */
33
34#include <linux/init.h>
35#include <linux/module.h>
36#include <linux/moduleparam.h>
37
38#include <linux/kernel.h>
39#include <linux/pci.h>
40#include <linux/pci_hotplug.h>
41#include <linux/slab.h>
42#include <linux/smp.h>
43#include "acpiphp.h"
44
45#define MY_NAME	"acpiphp"
46
47static int debug;
48int acpiphp_debug;
49
50/* local variables */
51static int num_slots;
52static struct acpiphp_attention_info *attention_info;
53
54#define DRIVER_VERSION	"0.5"
55#define DRIVER_AUTHOR	"Greg Kroah-Hartman <gregkh@us.ibm.com>, Takayoshi Kochi <t-kochi@bq.jp.nec.com>, Matthew Wilcox <willy@hp.com>"
56#define DRIVER_DESC	"ACPI Hot Plug PCI Controller Driver"
57
58MODULE_AUTHOR(DRIVER_AUTHOR);
59MODULE_DESCRIPTION(DRIVER_DESC);
60MODULE_LICENSE("GPL");
61MODULE_PARM_DESC(debug, "Debugging mode enabled or not");
62module_param(debug, bool, 0644);
63
64/* export the attention callback registration methods */
65EXPORT_SYMBOL_GPL(acpiphp_register_attention);
66EXPORT_SYMBOL_GPL(acpiphp_unregister_attention);
67
68static int enable_slot		(struct hotplug_slot *slot);
69static int disable_slot		(struct hotplug_slot *slot);
70static int set_attention_status (struct hotplug_slot *slot, u8 value);
71static int get_power_status	(struct hotplug_slot *slot, u8 *value);
72static int get_attention_status (struct hotplug_slot *slot, u8 *value);
73static int get_address		(struct hotplug_slot *slot, u32 *value);
74static int get_latch_status	(struct hotplug_slot *slot, u8 *value);
75static int get_adapter_status	(struct hotplug_slot *slot, u8 *value);
76
77static struct hotplug_slot_ops acpi_hotplug_slot_ops = {
78	.owner			= THIS_MODULE,
79	.enable_slot		= enable_slot,
80	.disable_slot		= disable_slot,
81	.set_attention_status	= set_attention_status,
82	.get_power_status	= get_power_status,
83	.get_attention_status	= get_attention_status,
84	.get_latch_status	= get_latch_status,
85	.get_adapter_status	= get_adapter_status,
86	.get_address		= get_address,
87};
88
89
90/**
91 * acpiphp_register_attention - set attention LED callback
92 * @info: must be completely filled with LED callbacks
93 *
94 * Description: this is used to register a hardware specific ACPI
95 * driver that manipulates the attention LED.  All the fields in
96 * info must be set.
97 **/
98int acpiphp_register_attention(struct acpiphp_attention_info *info)
99{
100	int retval = -EINVAL;
101
102	if (info && info->owner && info->set_attn &&
103			info->get_attn && !attention_info) {
104		retval = 0;
105		attention_info = info;
106	}
107	return retval;
108}
109
110
111/**
112 * acpiphp_unregister_attention - unset attention LED callback
113 * @info: must match the pointer used to register
114 *
115 * Description: this is used to un-register a hardware specific acpi
116 * driver that manipulates the attention LED.  The pointer to the
117 * info struct must be the same as the one used to set it.
118 **/
119int acpiphp_unregister_attention(struct acpiphp_attention_info *info)
120{
121	int retval = -EINVAL;
122
123	if (info && attention_info == info) {
124		attention_info = NULL;
125		retval = 0;
126	}
127	return retval;
128}
129
130
131/**
132 * enable_slot - power on and enable a slot
133 * @hotplug_slot: slot to enable
134 *
135 * Actual tasks are done in acpiphp_enable_slot()
136 *
137 */
138static int enable_slot(struct hotplug_slot *hotplug_slot)
139{
140	struct slot *slot = hotplug_slot->private;
141
142	dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
143
144	/* enable the specified slot */
145	return acpiphp_enable_slot(slot->acpi_slot);
146}
147
148
149/**
150 * disable_slot - disable and power off a slot
151 * @hotplug_slot: slot to disable
152 *
153 * Actual tasks are done in acpiphp_disable_slot()
154 *
155 */
156static int disable_slot(struct hotplug_slot *hotplug_slot)
157{
158	struct slot *slot = hotplug_slot->private;
159
160	dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
161
162	/* disable the specified slot */
163	return acpiphp_disable_slot(slot->acpi_slot);
164}
165
166
167 /**
168  * set_attention_status - set attention LED
169 * @hotplug_slot: slot to set attention LED on
170 * @status: value to set attention LED to (0 or 1)
171 *
172 * attention status LED, so we use a callback that
173 * was registered with us.  This allows hardware specific
174 * ACPI implementations to blink the light for us.
175 **/
176 static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
177 {
178	int retval = -ENODEV;
179
180 	dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
181
182	if (attention_info && try_module_get(attention_info->owner)) {
183		retval = attention_info->set_attn(hotplug_slot, status);
184		module_put(attention_info->owner);
185	} else
186		attention_info = NULL;
187	return retval;
188 }
189
190
191/**
192 * get_power_status - get power status of a slot
193 * @hotplug_slot: slot to get status
194 * @value: pointer to store status
195 *
196 * Some platforms may not implement _STA method properly.
197 * In that case, the value returned may not be reliable.
198 *
199 */
200static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
201{
202	struct slot *slot = hotplug_slot->private;
203
204	dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
205
206	*value = acpiphp_get_power_status(slot->acpi_slot);
207
208	return 0;
209}
210
211
212 /**
213 * get_attention_status - get attention LED status
214 * @hotplug_slot: slot to get status from
215 * @value: returns with value of attention LED
216 *
217 * ACPI doesn't have known method to determine the state
218 * of the attention status LED, so we use a callback that
219 * was registered with us.  This allows hardware specific
220 * ACPI implementations to determine its state
221 **/
222static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
223{
224	int retval = -EINVAL;
225
226	dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
227
228	if (attention_info && try_module_get(attention_info->owner)) {
229		retval = attention_info->get_attn(hotplug_slot, value);
230		module_put(attention_info->owner);
231	} else
232		attention_info = NULL;
233	return retval;
234}
235
236
237/**
238 * get_latch_status - get latch status of a slot
239 * @hotplug_slot: slot to get status
240 * @value: pointer to store status
241 *
242 * ACPI doesn't provide any formal means to access latch status.
243 * Instead, we fake latch status from _STA
244 *
245 */
246static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
247{
248	struct slot *slot = hotplug_slot->private;
249
250	dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
251
252	*value = acpiphp_get_latch_status(slot->acpi_slot);
253
254	return 0;
255}
256
257
258/**
259 * get_adapter_status - get adapter status of a slot
260 * @hotplug_slot: slot to get status
261 * @value: pointer to store status
262 *
263 * ACPI doesn't provide any formal means to access adapter status.
264 * Instead, we fake adapter status from _STA
265 *
266 */
267static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
268{
269	struct slot *slot = hotplug_slot->private;
270
271	dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
272
273	*value = acpiphp_get_adapter_status(slot->acpi_slot);
274
275	return 0;
276}
277
278
279/**
280 * get_address - get pci address of a slot
281 * @hotplug_slot: slot to get status
282 * @value: pointer to struct pci_busdev (seg, bus, dev)
283 */
284static int get_address(struct hotplug_slot *hotplug_slot, u32 *value)
285{
286	struct slot *slot = hotplug_slot->private;
287
288	dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
289
290	*value = acpiphp_get_address(slot->acpi_slot);
291
292	return 0;
293}
294
295static int __init init_acpi(void)
296{
297	int retval;
298
299	/* initialize internal data structure etc. */
300	retval = acpiphp_glue_init();
301
302	/* read initial number of slots */
303	if (!retval) {
304		num_slots = acpiphp_get_num_slots();
305		if (num_slots == 0) {
306			acpiphp_glue_exit();
307			retval = -ENODEV;
308		}
309	}
310
311	return retval;
312}
313
314/**
315 * release_slot - free up the memory used by a slot
316 * @hotplug_slot: slot to free
317 */
318static void release_slot(struct hotplug_slot *hotplug_slot)
319{
320	struct slot *slot = hotplug_slot->private;
321
322	dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
323
324	kfree(slot->hotplug_slot);
325	kfree(slot);
326}
327
328/* callback routine to initialize 'struct slot' for each slot */
329int acpiphp_register_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
330{
331	struct slot *slot;
332	int retval = -ENOMEM;
333
334	slot = kzalloc(sizeof(*slot), GFP_KERNEL);
335	if (!slot)
336		goto error;
337
338	slot->hotplug_slot = kzalloc(sizeof(*slot->hotplug_slot), GFP_KERNEL);
339	if (!slot->hotplug_slot)
340		goto error_slot;
341
342	slot->hotplug_slot->info = &slot->info;
343
344	slot->hotplug_slot->name = slot->name;
345
346	slot->hotplug_slot->private = slot;
347	slot->hotplug_slot->release = &release_slot;
348	slot->hotplug_slot->ops = &acpi_hotplug_slot_ops;
349
350	slot->acpi_slot = acpiphp_slot;
351	slot->hotplug_slot->info->power_status = acpiphp_get_power_status(slot->acpi_slot);
352	slot->hotplug_slot->info->attention_status = 0;
353	slot->hotplug_slot->info->latch_status = acpiphp_get_latch_status(slot->acpi_slot);
354	slot->hotplug_slot->info->adapter_status = acpiphp_get_adapter_status(slot->acpi_slot);
355	slot->hotplug_slot->info->max_bus_speed = PCI_SPEED_UNKNOWN;
356	slot->hotplug_slot->info->cur_bus_speed = PCI_SPEED_UNKNOWN;
357
358	acpiphp_slot->slot = slot;
359	snprintf(slot->name, sizeof(slot->name), "%u", slot->acpi_slot->sun);
360
361	retval = pci_hp_register(slot->hotplug_slot);
362	if (retval) {
363		err("pci_hp_register failed with error %d\n", retval);
364		goto error_hpslot;
365 	}
366
367	info("Slot [%s] registered\n", slot->hotplug_slot->name);
368
369	return 0;
370error_hpslot:
371	kfree(slot->hotplug_slot);
372error_slot:
373	kfree(slot);
374error:
375	return retval;
376}
377
378
379void acpiphp_unregister_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
380{
381	struct slot *slot = acpiphp_slot->slot;
382	int retval = 0;
383
384	info ("Slot [%s] unregistered\n", slot->hotplug_slot->name);
385
386	retval = pci_hp_deregister(slot->hotplug_slot);
387	if (retval)
388		err("pci_hp_deregister failed with error %d\n", retval);
389}
390
391
392static int __init acpiphp_init(void)
393{
394	info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
395
396	acpiphp_debug = debug;
397
398	/* read all the ACPI info from the system */
399	return init_acpi();
400}
401
402
403static void __exit acpiphp_exit(void)
404{
405	/* deallocate internal data structures etc. */
406	acpiphp_glue_exit();
407}
408
409module_init(acpiphp_init);
410module_exit(acpiphp_exit);
411