7414fd9ad1d2f7f46e2cb1436570ca67e33e8568
[linux-2.6.git] / drivers / pci / hotplug / shpchp_core.c
1 /*
2  * Standard 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) 2003-2004 Intel Corporation
8  *
9  * All rights reserved.
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or (at
14  * your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful, but
17  * WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
19  * NON INFRINGEMENT.  See the GNU General Public License for more
20  * details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25  *
26  * Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
27  *
28  */
29
30 #include <linux/module.h>
31 #include <linux/moduleparam.h>
32 #include <linux/kernel.h>
33 #include <linux/types.h>
34 #include <linux/slab.h>
35 #include <linux/pci.h>
36 #include "shpchp.h"
37
38 /* Global variables */
39 bool shpchp_debug;
40 bool shpchp_poll_mode;
41 int shpchp_poll_time;
42 struct workqueue_struct *shpchp_wq;
43 struct workqueue_struct *shpchp_ordered_wq;
44
45 #define DRIVER_VERSION  "0.4"
46 #define DRIVER_AUTHOR   "Dan Zink <dan.zink@compaq.com>, Greg Kroah-Hartman <greg@kroah.com>, Dely Sy <dely.l.sy@intel.com>"
47 #define DRIVER_DESC     "Standard Hot Plug PCI Controller Driver"
48
49 MODULE_AUTHOR(DRIVER_AUTHOR);
50 MODULE_DESCRIPTION(DRIVER_DESC);
51 MODULE_LICENSE("GPL");
52
53 module_param(shpchp_debug, bool, 0644);
54 module_param(shpchp_poll_mode, bool, 0644);
55 module_param(shpchp_poll_time, int, 0644);
56 MODULE_PARM_DESC(shpchp_debug, "Debugging mode enabled or not");
57 MODULE_PARM_DESC(shpchp_poll_mode, "Using polling mechanism for hot-plug events or not");
58 MODULE_PARM_DESC(shpchp_poll_time, "Polling mechanism frequency, in seconds");
59
60 #define SHPC_MODULE_NAME "shpchp"
61
62 static int set_attention_status (struct hotplug_slot *slot, u8 value);
63 static int enable_slot          (struct hotplug_slot *slot);
64 static int disable_slot         (struct hotplug_slot *slot);
65 static int get_power_status     (struct hotplug_slot *slot, u8 *value);
66 static int get_attention_status (struct hotplug_slot *slot, u8 *value);
67 static int get_latch_status     (struct hotplug_slot *slot, u8 *value);
68 static int get_adapter_status   (struct hotplug_slot *slot, u8 *value);
69
70 static struct hotplug_slot_ops shpchp_hotplug_slot_ops = {
71         .set_attention_status = set_attention_status,
72         .enable_slot =          enable_slot,
73         .disable_slot =         disable_slot,
74         .get_power_status =     get_power_status,
75         .get_attention_status = get_attention_status,
76         .get_latch_status =     get_latch_status,
77         .get_adapter_status =   get_adapter_status,
78 };
79
80 /**
81  * release_slot - free up the memory used by a slot
82  * @hotplug_slot: slot to free
83  */
84 static void release_slot(struct hotplug_slot *hotplug_slot)
85 {
86         struct slot *slot = hotplug_slot->private;
87
88         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
89                  __func__, slot_name(slot));
90
91         kfree(slot->hotplug_slot->info);
92         kfree(slot->hotplug_slot);
93         kfree(slot);
94 }
95
96 static int init_slots(struct controller *ctrl)
97 {
98         struct slot *slot;
99         struct hotplug_slot *hotplug_slot;
100         struct hotplug_slot_info *info;
101         char name[SLOT_NAME_SIZE];
102         int retval = -ENOMEM;
103         int i;
104
105         for (i = 0; i < ctrl->num_slots; i++) {
106                 slot = kzalloc(sizeof(*slot), GFP_KERNEL);
107                 if (!slot)
108                         goto error;
109
110                 hotplug_slot = kzalloc(sizeof(*hotplug_slot), GFP_KERNEL);
111                 if (!hotplug_slot)
112                         goto error_slot;
113                 slot->hotplug_slot = hotplug_slot;
114
115                 info = kzalloc(sizeof(*info), GFP_KERNEL);
116                 if (!info)
117                         goto error_hpslot;
118                 hotplug_slot->info = info;
119
120                 slot->hp_slot = i;
121                 slot->ctrl = ctrl;
122                 slot->bus = ctrl->pci_dev->subordinate->number;
123                 slot->device = ctrl->slot_device_offset + i;
124                 slot->hpc_ops = ctrl->hpc_ops;
125                 slot->number = ctrl->first_slot + (ctrl->slot_num_inc * i);
126                 mutex_init(&slot->lock);
127                 INIT_DELAYED_WORK(&slot->work, shpchp_queue_pushbutton_work);
128
129                 /* register this slot with the hotplug pci core */
130                 hotplug_slot->private = slot;
131                 hotplug_slot->release = &release_slot;
132                 snprintf(name, SLOT_NAME_SIZE, "%d", slot->number);
133                 hotplug_slot->ops = &shpchp_hotplug_slot_ops;
134
135                 ctrl_dbg(ctrl, "Registering domain:bus:dev=%04x:%02x:%02x "
136                          "hp_slot=%x sun=%x slot_device_offset=%x\n",
137                          pci_domain_nr(ctrl->pci_dev->subordinate),
138                          slot->bus, slot->device, slot->hp_slot, slot->number,
139                          ctrl->slot_device_offset);
140                 retval = pci_hp_register(slot->hotplug_slot,
141                                 ctrl->pci_dev->subordinate, slot->device, name);
142                 if (retval) {
143                         ctrl_err(ctrl, "pci_hp_register failed with error %d\n",
144                                  retval);
145                         goto error_info;
146                 }
147
148                 get_power_status(hotplug_slot, &info->power_status);
149                 get_attention_status(hotplug_slot, &info->attention_status);
150                 get_latch_status(hotplug_slot, &info->latch_status);
151                 get_adapter_status(hotplug_slot, &info->adapter_status);
152
153                 list_add(&slot->slot_list, &ctrl->slot_list);
154         }
155
156         return 0;
157 error_info:
158         kfree(info);
159 error_hpslot:
160         kfree(hotplug_slot);
161 error_slot:
162         kfree(slot);
163 error:
164         return retval;
165 }
166
167 void cleanup_slots(struct controller *ctrl)
168 {
169         struct list_head *tmp;
170         struct list_head *next;
171         struct slot *slot;
172
173         list_for_each_safe(tmp, next, &ctrl->slot_list) {
174                 slot = list_entry(tmp, struct slot, slot_list);
175                 list_del(&slot->slot_list);
176                 cancel_delayed_work(&slot->work);
177                 flush_workqueue(shpchp_wq);
178                 flush_workqueue(shpchp_ordered_wq);
179                 pci_hp_deregister(slot->hotplug_slot);
180         }
181 }
182
183 /*
184  * set_attention_status - Turns the Amber LED for a slot on, off or blink
185  */
186 static int set_attention_status (struct hotplug_slot *hotplug_slot, u8 status)
187 {
188         struct slot *slot = get_slot(hotplug_slot);
189
190         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
191                  __func__, slot_name(slot));
192
193         hotplug_slot->info->attention_status = status;
194         slot->hpc_ops->set_attention_status(slot, status);
195
196         return 0;
197 }
198
199 static int enable_slot (struct hotplug_slot *hotplug_slot)
200 {
201         struct slot *slot = get_slot(hotplug_slot);
202
203         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
204                  __func__, slot_name(slot));
205
206         return shpchp_sysfs_enable_slot(slot);
207 }
208
209 static int disable_slot (struct hotplug_slot *hotplug_slot)
210 {
211         struct slot *slot = get_slot(hotplug_slot);
212
213         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
214                  __func__, slot_name(slot));
215
216         return shpchp_sysfs_disable_slot(slot);
217 }
218
219 static int get_power_status (struct hotplug_slot *hotplug_slot, u8 *value)
220 {
221         struct slot *slot = get_slot(hotplug_slot);
222         int retval;
223
224         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
225                  __func__, slot_name(slot));
226
227         retval = slot->hpc_ops->get_power_status(slot, value);
228         if (retval < 0)
229                 *value = hotplug_slot->info->power_status;
230
231         return 0;
232 }
233
234 static int get_attention_status (struct hotplug_slot *hotplug_slot, u8 *value)
235 {
236         struct slot *slot = get_slot(hotplug_slot);
237         int retval;
238
239         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
240                  __func__, slot_name(slot));
241
242         retval = slot->hpc_ops->get_attention_status(slot, value);
243         if (retval < 0)
244                 *value = hotplug_slot->info->attention_status;
245
246         return 0;
247 }
248
249 static int get_latch_status (struct hotplug_slot *hotplug_slot, u8 *value)
250 {
251         struct slot *slot = get_slot(hotplug_slot);
252         int retval;
253
254         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
255                  __func__, slot_name(slot));
256
257         retval = slot->hpc_ops->get_latch_status(slot, value);
258         if (retval < 0)
259                 *value = hotplug_slot->info->latch_status;
260
261         return 0;
262 }
263
264 static int get_adapter_status (struct hotplug_slot *hotplug_slot, u8 *value)
265 {
266         struct slot *slot = get_slot(hotplug_slot);
267         int retval;
268
269         ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
270                  __func__, slot_name(slot));
271
272         retval = slot->hpc_ops->get_adapter_status(slot, value);
273         if (retval < 0)
274                 *value = hotplug_slot->info->adapter_status;
275
276         return 0;
277 }
278
279 static int is_shpc_capable(struct pci_dev *dev)
280 {
281         if (dev->vendor == PCI_VENDOR_ID_AMD &&
282             dev->device == PCI_DEVICE_ID_AMD_GOLAM_7450)
283                 return 1;
284         if (!pci_find_capability(dev, PCI_CAP_ID_SHPC))
285                 return 0;
286         if (get_hp_hw_control_from_firmware(dev))
287                 return 0;
288         return 1;
289 }
290
291 static int shpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
292 {
293         int rc;
294         struct controller *ctrl;
295
296         if (!is_shpc_capable(pdev))
297                 return -ENODEV;
298
299         ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);
300         if (!ctrl) {
301                 dev_err(&pdev->dev, "%s: Out of memory\n", __func__);
302                 goto err_out_none;
303         }
304         INIT_LIST_HEAD(&ctrl->slot_list);
305
306         rc = shpc_init(ctrl, pdev);
307         if (rc) {
308                 ctrl_dbg(ctrl, "Controller initialization failed\n");
309                 goto err_out_free_ctrl;
310         }
311
312         pci_set_drvdata(pdev, ctrl);
313
314         /* Setup the slot information structures */
315         rc = init_slots(ctrl);
316         if (rc) {
317                 ctrl_err(ctrl, "Slot initialization failed\n");
318                 goto err_out_release_ctlr;
319         }
320
321         rc = shpchp_create_ctrl_files(ctrl);
322         if (rc)
323                 goto err_cleanup_slots;
324
325         return 0;
326
327 err_cleanup_slots:
328         cleanup_slots(ctrl);
329 err_out_release_ctlr:
330         ctrl->hpc_ops->release_ctlr(ctrl);
331 err_out_free_ctrl:
332         kfree(ctrl);
333 err_out_none:
334         return -ENODEV;
335 }
336
337 static void shpc_remove(struct pci_dev *dev)
338 {
339         struct controller *ctrl = pci_get_drvdata(dev);
340
341         shpchp_remove_ctrl_files(ctrl);
342         ctrl->hpc_ops->release_ctlr(ctrl);
343         kfree(ctrl);
344 }
345
346 static struct pci_device_id shpcd_pci_tbl[] = {
347         {PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_PCI << 8) | 0x00), ~0)},
348         { /* end: all zeroes */ }
349 };
350 MODULE_DEVICE_TABLE(pci, shpcd_pci_tbl);
351
352 static struct pci_driver shpc_driver = {
353         .name =         SHPC_MODULE_NAME,
354         .id_table =     shpcd_pci_tbl,
355         .probe =        shpc_probe,
356         .remove =       shpc_remove,
357 };
358
359 static int __init shpcd_init(void)
360 {
361         int retval = 0;
362
363         shpchp_wq = alloc_ordered_workqueue("shpchp", 0);
364         if (!shpchp_wq)
365                 return -ENOMEM;
366
367         shpchp_ordered_wq = alloc_ordered_workqueue("shpchp_ordered", 0);
368         if (!shpchp_ordered_wq) {
369                 destroy_workqueue(shpchp_wq);
370                 return -ENOMEM;
371         }
372
373         retval = pci_register_driver(&shpc_driver);
374         dbg("%s: pci_register_driver = %d\n", __func__, retval);
375         info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
376         if (retval) {
377                 destroy_workqueue(shpchp_ordered_wq);
378                 destroy_workqueue(shpchp_wq);
379         }
380         return retval;
381 }
382
383 static void __exit shpcd_cleanup(void)
384 {
385         dbg("unload_shpchpd()\n");
386         pci_unregister_driver(&shpc_driver);
387         destroy_workqueue(shpchp_ordered_wq);
388         destroy_workqueue(shpchp_wq);
389         info(DRIVER_DESC " version: " DRIVER_VERSION " unloaded\n");
390 }
391
392 module_init(shpcd_init);
393 module_exit(shpcd_cleanup);