Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/jk/spufs into...
[linux-2.6] / drivers / pci / hotplug / acpiphp_core.c
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
47 static int debug;
48 int acpiphp_debug;
49
50 /* local variables */
51 static int num_slots;
52 static 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
58 MODULE_AUTHOR(DRIVER_AUTHOR);
59 MODULE_DESCRIPTION(DRIVER_DESC);
60 MODULE_LICENSE("GPL");
61 MODULE_PARM_DESC(debug, "Debugging mode enabled or not");
62 module_param(debug, bool, 0644);
63
64 /* export the attention callback registration methods */
65 EXPORT_SYMBOL_GPL(acpiphp_register_attention);
66 EXPORT_SYMBOL_GPL(acpiphp_unregister_attention);
67
68 static int enable_slot          (struct hotplug_slot *slot);
69 static int disable_slot         (struct hotplug_slot *slot);
70 static int set_attention_status (struct hotplug_slot *slot, u8 value);
71 static int get_power_status     (struct hotplug_slot *slot, u8 *value);
72 static int get_attention_status (struct hotplug_slot *slot, u8 *value);
73 static int get_address          (struct hotplug_slot *slot, u32 *value);
74 static int get_latch_status     (struct hotplug_slot *slot, u8 *value);
75 static int get_adapter_status   (struct hotplug_slot *slot, u8 *value);
76
77 static 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  */
98 int 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  */
119 int 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 static int enable_slot(struct hotplug_slot *hotplug_slot)
138 {
139         struct slot *slot = hotplug_slot->private;
140
141         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
142
143         /* enable the specified slot */
144         return acpiphp_enable_slot(slot->acpi_slot);
145 }
146
147
148 /**
149  * disable_slot - disable and power off a slot
150  * @hotplug_slot: slot to disable
151  *
152  * Actual tasks are done in acpiphp_disable_slot()
153  */
154 static int disable_slot(struct hotplug_slot *hotplug_slot)
155 {
156         struct slot *slot = hotplug_slot->private;
157         int retval;
158
159         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
160
161         /* disable the specified slot */
162         retval = acpiphp_disable_slot(slot->acpi_slot);
163         if (!retval)
164                 retval = acpiphp_eject_slot(slot->acpi_slot);
165         return retval;
166 }
167
168
169 /**
170  * set_attention_status - set attention LED
171  * @hotplug_slot: slot to set attention LED on
172  * @status: value to set attention LED to (0 or 1)
173  *
174  * attention status LED, so we use a callback that
175  * was registered with us.  This allows hardware specific
176  * ACPI implementations to blink the light for us.
177  */
178  static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
179  {
180         int retval = -ENODEV;
181
182         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
183  
184         if (attention_info && try_module_get(attention_info->owner)) {
185                 retval = attention_info->set_attn(hotplug_slot, status);
186                 module_put(attention_info->owner);
187         } else
188                 attention_info = NULL;
189         return retval;
190  }
191  
192
193 /**
194  * get_power_status - get power status of a slot
195  * @hotplug_slot: slot to get status
196  * @value: pointer to store status
197  *
198  * Some platforms may not implement _STA method properly.
199  * In that case, the value returned may not be reliable.
200  */
201 static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
202 {
203         struct slot *slot = hotplug_slot->private;
204
205         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
206
207         *value = acpiphp_get_power_status(slot->acpi_slot);
208
209         return 0;
210 }
211
212
213 /**
214  * get_attention_status - get attention LED status
215  * @hotplug_slot: slot to get status from
216  * @value: returns with value of attention LED
217  *
218  * ACPI doesn't have known method to determine the state
219  * of the attention status LED, so we use a callback that
220  * was registered with us.  This allows hardware specific
221  * ACPI implementations to determine its state.
222  */
223 static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
224 {
225         int retval = -EINVAL;
226
227         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
228
229         if (attention_info && try_module_get(attention_info->owner)) {
230                 retval = attention_info->get_attn(hotplug_slot, value);
231                 module_put(attention_info->owner);
232         } else
233                 attention_info = NULL;
234         return retval;
235 }
236
237
238 /**
239  * get_latch_status - get latch status of a slot
240  * @hotplug_slot: slot to get status
241  * @value: pointer to store status
242  *
243  * ACPI doesn't provide any formal means to access latch status.
244  * Instead, we fake latch status from _STA.
245  */
246 static 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 static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
267 {
268         struct slot *slot = hotplug_slot->private;
269
270         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
271
272         *value = acpiphp_get_adapter_status(slot->acpi_slot);
273
274         return 0;
275 }
276
277
278 /**
279  * get_address - get pci address of a slot
280  * @hotplug_slot: slot to get status
281  * @value: pointer to struct pci_busdev (seg, bus, dev)
282  */
283 static int get_address(struct hotplug_slot *hotplug_slot, u32 *value)
284 {
285         struct slot *slot = hotplug_slot->private;
286
287         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
288
289         *value = acpiphp_get_address(slot->acpi_slot);
290
291         return 0;
292 }
293
294 static int __init init_acpi(void)
295 {
296         int retval;
297
298         /* initialize internal data structure etc. */
299         retval = acpiphp_glue_init();
300
301         /* read initial number of slots */
302         if (!retval) {
303                 num_slots = acpiphp_get_num_slots();
304                 if (num_slots == 0) {
305                         acpiphp_glue_exit();
306                         retval = -ENODEV;
307                 }
308         }
309
310         return retval;
311 }
312
313 /**
314  * release_slot - free up the memory used by a slot
315  * @hotplug_slot: slot to free
316  */
317 static void release_slot(struct hotplug_slot *hotplug_slot)
318 {
319         struct slot *slot = hotplug_slot->private;
320
321         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
322
323         kfree(slot->hotplug_slot);
324         kfree(slot);
325 }
326
327 /* callback routine to initialize 'struct slot' for each slot */
328 int acpiphp_register_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
329 {
330         struct slot *slot;
331         int retval = -ENOMEM;
332
333         slot = kzalloc(sizeof(*slot), GFP_KERNEL);
334         if (!slot)
335                 goto error;
336
337         slot->hotplug_slot = kzalloc(sizeof(*slot->hotplug_slot), GFP_KERNEL);
338         if (!slot->hotplug_slot)
339                 goto error_slot;
340
341         slot->hotplug_slot->info = &slot->info;
342
343         slot->hotplug_slot->name = slot->name;
344
345         slot->hotplug_slot->private = slot;
346         slot->hotplug_slot->release = &release_slot;
347         slot->hotplug_slot->ops = &acpi_hotplug_slot_ops;
348
349         slot->acpi_slot = acpiphp_slot;
350         slot->hotplug_slot->info->power_status = acpiphp_get_power_status(slot->acpi_slot);
351         slot->hotplug_slot->info->attention_status = 0;
352         slot->hotplug_slot->info->latch_status = acpiphp_get_latch_status(slot->acpi_slot);
353         slot->hotplug_slot->info->adapter_status = acpiphp_get_adapter_status(slot->acpi_slot);
354         slot->hotplug_slot->info->max_bus_speed = PCI_SPEED_UNKNOWN;
355         slot->hotplug_slot->info->cur_bus_speed = PCI_SPEED_UNKNOWN;
356
357         acpiphp_slot->slot = slot;
358         snprintf(slot->name, sizeof(slot->name), "%u", slot->acpi_slot->sun);
359
360         retval = pci_hp_register(slot->hotplug_slot);
361         if (retval) {
362                 err("pci_hp_register failed with error %d\n", retval);
363                 goto error_hpslot;
364         }
365
366         info("Slot [%s] registered\n", slot->hotplug_slot->name);
367
368         return 0;
369 error_hpslot:
370         kfree(slot->hotplug_slot);
371 error_slot:
372         kfree(slot);
373 error:
374         return retval;
375 }
376
377
378 void acpiphp_unregister_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
379 {
380         struct slot *slot = acpiphp_slot->slot;
381         int retval = 0;
382
383         info ("Slot [%s] unregistered\n", slot->hotplug_slot->name);
384
385         retval = pci_hp_deregister(slot->hotplug_slot);
386         if (retval)
387                 err("pci_hp_deregister failed with error %d\n", retval);
388 }
389
390
391 static int __init acpiphp_init(void)
392 {
393         info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
394
395         if (acpi_pci_disabled)
396                 return 0;
397
398         acpiphp_debug = debug;
399
400         /* read all the ACPI info from the system */
401         return init_acpi();
402 }
403
404
405 static void __exit acpiphp_exit(void)
406 {
407         if (acpi_pci_disabled)
408                 return;
409
410         /* deallocate internal data structures etc. */
411         acpiphp_glue_exit();
412 }
413
414 module_init(acpiphp_init);
415 module_exit(acpiphp_exit);