1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30#include <linux/module.h>
31#include <linux/moduleparam.h>
32#include <linux/kernel.h>
33#include <linux/slab.h>
34#include <linux/types.h>
35#include <linux/pci.h>
36#include "pciehp.h"
37#include <linux/interrupt.h>
38#include <linux/time.h>
39
40
41bool pciehp_debug;
42bool pciehp_poll_mode;
43int pciehp_poll_time;
44bool pciehp_force;
45
46#define DRIVER_VERSION "0.4"
47#define DRIVER_AUTHOR "Dan Zink <dan.zink@compaq.com>, Greg Kroah-Hartman <greg@kroah.com>, Dely Sy <dely.l.sy@intel.com>"
48#define DRIVER_DESC "PCI Express Hot Plug Controller Driver"
49
50MODULE_AUTHOR(DRIVER_AUTHOR);
51MODULE_DESCRIPTION(DRIVER_DESC);
52MODULE_LICENSE("GPL");
53
54module_param(pciehp_debug, bool, 0644);
55module_param(pciehp_poll_mode, bool, 0644);
56module_param(pciehp_poll_time, int, 0644);
57module_param(pciehp_force, bool, 0644);
58MODULE_PARM_DESC(pciehp_debug, "Debugging mode enabled or not");
59MODULE_PARM_DESC(pciehp_poll_mode, "Using polling mechanism for hot-plug events or not");
60MODULE_PARM_DESC(pciehp_poll_time, "Polling mechanism frequency, in seconds");
61MODULE_PARM_DESC(pciehp_force, "Force pciehp, even if OSHP is missing");
62
63#define PCIE_MODULE_NAME "pciehp"
64
65static int set_attention_status (struct hotplug_slot *slot, u8 value);
66static int enable_slot (struct hotplug_slot *slot);
67static int disable_slot (struct hotplug_slot *slot);
68static int get_power_status (struct hotplug_slot *slot, u8 *value);
69static int get_attention_status (struct hotplug_slot *slot, u8 *value);
70static int get_latch_status (struct hotplug_slot *slot, u8 *value);
71static int get_adapter_status (struct hotplug_slot *slot, u8 *value);
72
73
74
75
76
77static void release_slot(struct hotplug_slot *hotplug_slot)
78{
79 struct slot *slot = hotplug_slot->private;
80
81 ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
82 __func__, hotplug_slot_name(hotplug_slot));
83
84 kfree(hotplug_slot->ops);
85 kfree(hotplug_slot->info);
86 kfree(hotplug_slot);
87}
88
89static int init_slot(struct controller *ctrl)
90{
91 struct slot *slot = ctrl->slot;
92 struct hotplug_slot *hotplug = NULL;
93 struct hotplug_slot_info *info = NULL;
94 struct hotplug_slot_ops *ops = NULL;
95 char name[SLOT_NAME_SIZE];
96 int retval = -ENOMEM;
97
98 hotplug = kzalloc(sizeof(*hotplug), GFP_KERNEL);
99 if (!hotplug)
100 goto out;
101
102 info = kzalloc(sizeof(*info), GFP_KERNEL);
103 if (!info)
104 goto out;
105
106
107 ops = kzalloc(sizeof(*ops), GFP_KERNEL);
108 if (!ops)
109 goto out;
110 ops->enable_slot = enable_slot;
111 ops->disable_slot = disable_slot;
112 ops->get_power_status = get_power_status;
113 ops->get_adapter_status = get_adapter_status;
114 if (MRL_SENS(ctrl))
115 ops->get_latch_status = get_latch_status;
116 if (ATTN_LED(ctrl)) {
117 ops->get_attention_status = get_attention_status;
118 ops->set_attention_status = set_attention_status;
119 }
120
121
122 hotplug->info = info;
123 hotplug->private = slot;
124 hotplug->release = &release_slot;
125 hotplug->ops = ops;
126 slot->hotplug_slot = hotplug;
127 snprintf(name, SLOT_NAME_SIZE, "%u", PSN(ctrl));
128
129 ctrl_dbg(ctrl, "Registering domain:bus:dev=%04x:%02x:00 sun=%x\n",
130 pci_domain_nr(ctrl->pcie->port->subordinate),
131 ctrl->pcie->port->subordinate->number, PSN(ctrl));
132 retval = pci_hp_register(hotplug,
133 ctrl->pcie->port->subordinate, 0, name);
134 if (retval)
135 ctrl_err(ctrl,
136 "pci_hp_register failed with error %d\n", retval);
137out:
138 if (retval) {
139 kfree(ops);
140 kfree(info);
141 kfree(hotplug);
142 }
143 return retval;
144}
145
146static void cleanup_slot(struct controller *ctrl)
147{
148 pci_hp_deregister(ctrl->slot->hotplug_slot);
149}
150
151
152
153
154static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
155{
156 struct slot *slot = hotplug_slot->private;
157
158 ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
159 __func__, slot_name(slot));
160
161 return pciehp_set_attention_status(slot, status);
162}
163
164
165static int enable_slot(struct hotplug_slot *hotplug_slot)
166{
167 struct slot *slot = hotplug_slot->private;
168
169 ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
170 __func__, slot_name(slot));
171
172 return pciehp_sysfs_enable_slot(slot);
173}
174
175
176static int disable_slot(struct hotplug_slot *hotplug_slot)
177{
178 struct slot *slot = hotplug_slot->private;
179
180 ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
181 __func__, slot_name(slot));
182
183 return pciehp_sysfs_disable_slot(slot);
184}
185
186static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
187{
188 struct slot *slot = hotplug_slot->private;
189
190 ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
191 __func__, slot_name(slot));
192
193 return pciehp_get_power_status(slot, value);
194}
195
196static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
197{
198 struct slot *slot = hotplug_slot->private;
199
200 ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
201 __func__, slot_name(slot));
202
203 return pciehp_get_attention_status(slot, value);
204}
205
206static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
207{
208 struct slot *slot = hotplug_slot->private;
209
210 ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
211 __func__, slot_name(slot));
212
213 return pciehp_get_latch_status(slot, value);
214}
215
216static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
217{
218 struct slot *slot = hotplug_slot->private;
219
220 ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
221 __func__, slot_name(slot));
222
223 return pciehp_get_adapter_status(slot, value);
224}
225
226static int pciehp_probe(struct pcie_device *dev)
227{
228 int rc;
229 struct controller *ctrl;
230 struct slot *slot;
231 u8 occupied, poweron;
232
233 if (pciehp_force)
234 dev_info(&dev->device,
235 "Bypassing BIOS check for pciehp use on %s\n",
236 pci_name(dev->port));
237 else if (pciehp_acpi_slot_detection_check(dev->port))
238 goto err_out_none;
239
240 ctrl = pcie_init(dev);
241 if (!ctrl) {
242 dev_err(&dev->device, "Controller initialization failed\n");
243 goto err_out_none;
244 }
245 set_service_data(dev, ctrl);
246
247
248 rc = init_slot(ctrl);
249 if (rc) {
250 if (rc == -EBUSY)
251 ctrl_warn(ctrl, "Slot already registered by another "
252 "hotplug driver\n");
253 else
254 ctrl_err(ctrl, "Slot initialization failed\n");
255 goto err_out_release_ctlr;
256 }
257
258
259 rc = pcie_init_notification(ctrl);
260 if (rc) {
261 ctrl_err(ctrl, "Notification initialization failed\n");
262 goto err_out_free_ctrl_slot;
263 }
264
265
266 slot = ctrl->slot;
267 pciehp_get_adapter_status(slot, &occupied);
268 pciehp_get_power_status(slot, &poweron);
269 if (occupied && pciehp_force)
270 pciehp_enable_slot(slot);
271
272 if (!occupied && poweron && POWER_CTRL(ctrl))
273 pciehp_power_off_slot(slot);
274
275 return 0;
276
277err_out_free_ctrl_slot:
278 cleanup_slot(ctrl);
279err_out_release_ctlr:
280 pciehp_release_ctrl(ctrl);
281err_out_none:
282 return -ENODEV;
283}
284
285static void pciehp_remove(struct pcie_device *dev)
286{
287 struct controller *ctrl = get_service_data(dev);
288
289 cleanup_slot(ctrl);
290 pciehp_release_ctrl(ctrl);
291}
292
293#ifdef CONFIG_PM
294static int pciehp_suspend (struct pcie_device *dev)
295{
296 return 0;
297}
298
299static int pciehp_resume (struct pcie_device *dev)
300{
301 struct controller *ctrl;
302 struct slot *slot;
303 u8 status;
304
305 ctrl = get_service_data(dev);
306
307
308 pcie_enable_notification(ctrl);
309
310 slot = ctrl->slot;
311
312
313 pciehp_get_adapter_status(slot, &status);
314 if (status)
315 pciehp_enable_slot(slot);
316 else
317 pciehp_disable_slot(slot);
318 return 0;
319}
320#endif
321
322static struct pcie_port_service_driver hpdriver_portdrv = {
323 .name = PCIE_MODULE_NAME,
324 .port_type = PCIE_ANY_PORT,
325 .service = PCIE_PORT_SERVICE_HP,
326
327 .probe = pciehp_probe,
328 .remove = pciehp_remove,
329
330#ifdef CONFIG_PM
331 .suspend = pciehp_suspend,
332 .resume = pciehp_resume,
333#endif
334};
335
336static int __init pcied_init(void)
337{
338 int retval = 0;
339
340 pciehp_firmware_init();
341 retval = pcie_port_service_register(&hpdriver_portdrv);
342 dbg("pcie_port_service_register = %d\n", retval);
343 info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
344 if (retval)
345 dbg("Failure to register service\n");
346
347 return retval;
348}
349
350static void __exit pcied_cleanup(void)
351{
352 dbg("unload_pciehpd()\n");
353 pcie_port_service_unregister(&hpdriver_portdrv);
354 info(DRIVER_DESC " version: " DRIVER_VERSION " unloaded\n");
355}
356
357module_init(pcied_init);
358module_exit(pcied_cleanup);
359