Merge branch 'upstream'
[linux-2.6] / drivers / pci / hotplug / rpaphp_pci.c
1 /*
2  * PCI Hot Plug Controller Driver for RPA-compliant PPC64 platform.
3  * Copyright (C) 2003 Linda Xie <lxie@us.ibm.com>
4  *
5  * All rights reserved.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or (at
10  * your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
15  * NON INFRINGEMENT.  See the GNU General Public License for more
16  * details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  *
22  * Send feedback to <lxie@us.ibm.com>
23  *
24  */
25 #include <linux/pci.h>
26 #include <linux/string.h>
27
28 #include <asm/pci-bridge.h>
29 #include <asm/rtas.h>
30 #include <asm/machdep.h>
31
32 #include "../pci.h"             /* for pci_add_new_bus */
33 #include "rpaphp.h"
34
35 static struct pci_bus *find_bus_among_children(struct pci_bus *bus,
36                                         struct device_node *dn)
37 {
38         struct pci_bus *child = NULL;
39         struct list_head *tmp;
40         struct device_node *busdn;
41
42         busdn = pci_bus_to_OF_node(bus);
43         if (busdn == dn)
44                 return bus;
45
46         list_for_each(tmp, &bus->children) {
47                 child = find_bus_among_children(pci_bus_b(tmp), dn);
48                 if (child)
49                         break;
50         }
51         return child;
52 }
53
54 struct pci_bus *rpaphp_find_pci_bus(struct device_node *dn)
55 {
56         struct pci_dn *pdn = dn->data;
57
58         if (!pdn  || !pdn->phb || !pdn->phb->bus)
59                 return NULL;
60
61         return find_bus_among_children(pdn->phb->bus, dn);
62 }
63 EXPORT_SYMBOL_GPL(rpaphp_find_pci_bus);
64
65 static int rpaphp_get_sensor_state(struct slot *slot, int *state)
66 {
67         int rc;
68         int setlevel;
69
70         rc = rtas_get_sensor(DR_ENTITY_SENSE, slot->index, state);
71
72         if (rc < 0) {
73                 if (rc == -EFAULT || rc == -EEXIST) {
74                         dbg("%s: slot must be power up to get sensor-state\n",
75                             __FUNCTION__);
76
77                         /* some slots have to be powered up 
78                          * before get-sensor will succeed.
79                          */
80                         rc = rtas_set_power_level(slot->power_domain, POWER_ON,
81                                                   &setlevel);
82                         if (rc < 0) {
83                                 dbg("%s: power on slot[%s] failed rc=%d.\n",
84                                     __FUNCTION__, slot->name, rc);
85                         } else {
86                                 rc = rtas_get_sensor(DR_ENTITY_SENSE,
87                                                      slot->index, state);
88                         }
89                 } else if (rc == -ENODEV)
90                         info("%s: slot is unusable\n", __FUNCTION__);
91                 else
92                         err("%s failed to get sensor state\n", __FUNCTION__);
93         }
94         return rc;
95 }
96
97 /**
98  * get_pci_adapter_status - get the status of a slot
99  * 
100  * 0-- slot is empty
101  * 1-- adapter is configured
102  * 2-- adapter is not configured
103  * 3-- not valid
104  */
105 int rpaphp_get_pci_adapter_status(struct slot *slot, int is_init, u8 * value)
106 {
107         struct pci_bus *bus;
108         int state, rc;
109
110         *value = NOT_VALID;
111         rc = rpaphp_get_sensor_state(slot, &state);
112         if (rc)
113                 goto exit;
114
115         if (state == EMPTY)
116                 *value = EMPTY;
117         else if (state == PRESENT) {
118                 if (!is_init) {
119                         /* at run-time slot->state can be changed by */
120                         /* config/unconfig adapter */
121                         *value = slot->state;
122                 } else {
123                         bus = rpaphp_find_pci_bus(slot->dn);
124                         if (bus && !list_empty(&bus->devices))
125                                 *value = CONFIGURED;
126                         else
127                                 *value = NOT_CONFIGURED;
128                 }
129         }
130 exit:
131         return rc;
132 }
133
134 /* Must be called before pci_bus_add_devices */
135 void rpaphp_fixup_new_pci_devices(struct pci_bus *bus, int fix_bus)
136 {
137         struct pci_dev *dev;
138
139         list_for_each_entry(dev, &bus->devices, bus_list) {
140                 /*
141                  * Skip already-present devices (which are on the
142                  * global device list.)
143                  */
144                 if (list_empty(&dev->global_list)) {
145                         int i;
146                         
147                         /* Need to setup IOMMU tables */
148                         ppc_md.iommu_dev_setup(dev);
149
150                         if(fix_bus)
151                                 pcibios_fixup_device_resources(dev, bus);
152                         pci_read_irq_line(dev);
153                         for (i = 0; i < PCI_NUM_RESOURCES; i++) {
154                                 struct resource *r = &dev->resource[i];
155
156                                 if (r->parent || !r->start || !r->flags)
157                                         continue;
158                                 pci_claim_resource(dev, i);
159                         }
160                 }
161         }
162 }
163
164 static void rpaphp_eeh_add_bus_device(struct pci_bus *bus)
165 {
166         struct pci_dev *dev;
167
168         list_for_each_entry(dev, &bus->devices, bus_list) {
169                 eeh_add_device_late(dev);
170                 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
171                         struct pci_bus *subbus = dev->subordinate;
172                         if (subbus)
173                                 rpaphp_eeh_add_bus_device (subbus);
174                 }
175         }
176 }
177
178 static int rpaphp_pci_config_bridge(struct pci_dev *dev)
179 {
180         u8 sec_busno;
181         struct pci_bus *child_bus;
182         struct pci_dev *child_dev;
183
184         dbg("Enter %s:  BRIDGE dev=%s\n", __FUNCTION__, pci_name(dev));
185
186         /* get busno of downstream bus */
187         pci_read_config_byte(dev, PCI_SECONDARY_BUS, &sec_busno);
188                 
189         /* add to children of PCI bridge dev->bus */
190         child_bus = pci_add_new_bus(dev->bus, dev, sec_busno);
191         if (!child_bus) {
192                 err("%s: could not add second bus\n", __FUNCTION__);
193                 return -EIO;
194         }
195         sprintf(child_bus->name, "PCI Bus #%02x", child_bus->number);
196         /* do pci_scan_child_bus */
197         pci_scan_child_bus(child_bus);
198
199         list_for_each_entry(child_dev, &child_bus->devices, bus_list) {
200                 eeh_add_device_late(child_dev);
201         }
202
203          /* fixup new pci devices without touching bus struct */
204         rpaphp_fixup_new_pci_devices(child_bus, 0);
205
206         /* Make the discovered devices available */
207         pci_bus_add_devices(child_bus);
208         return 0;
209 }
210
211 void rpaphp_init_new_devs(struct pci_bus *bus)
212 {
213         rpaphp_fixup_new_pci_devices(bus, 0);
214         rpaphp_eeh_add_bus_device(bus);
215 }
216 EXPORT_SYMBOL_GPL(rpaphp_init_new_devs);
217
218 /*****************************************************************************
219  rpaphp_pci_config_slot() will  configure all devices under the
220  given slot->dn and return the the first pci_dev.
221  *****************************************************************************/
222 static struct pci_dev *
223 rpaphp_pci_config_slot(struct pci_bus *bus)
224 {
225         struct device_node *dn = pci_bus_to_OF_node(bus);
226         struct pci_dev *dev = NULL;
227         int slotno;
228         int num;
229
230         dbg("Enter %s: dn=%s bus=%s\n", __FUNCTION__, dn->full_name, bus->name);
231         if (!dn || !dn->child)
232                 return NULL;
233
234         if (_machine == PLATFORM_PSERIES_LPAR) {
235                 of_scan_bus(dn, bus);
236                 if (list_empty(&bus->devices)) {
237                         err("%s: No new device found\n", __FUNCTION__);
238                         return NULL;
239                 }
240
241                 rpaphp_init_new_devs(bus);
242                 pci_bus_add_devices(bus);
243                 dev = list_entry(&bus->devices, struct pci_dev, bus_list);
244         } else {
245                 slotno = PCI_SLOT(PCI_DN(dn->child)->devfn);
246
247                 /* pci_scan_slot should find all children */
248                 num = pci_scan_slot(bus, PCI_DEVFN(slotno, 0));
249                 if (num) {
250                         rpaphp_fixup_new_pci_devices(bus, 1);
251                         pci_bus_add_devices(bus);
252                 }
253                 if (list_empty(&bus->devices)) {
254                         err("%s: No new device found\n", __FUNCTION__);
255                         return NULL;
256                 }
257                 list_for_each_entry(dev, &bus->devices, bus_list) {
258                         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE)
259                                 rpaphp_pci_config_bridge(dev);
260
261                         rpaphp_eeh_add_bus_device(bus);
262                 }
263         }
264
265         return dev;
266 }
267
268 static void print_slot_pci_funcs(struct pci_bus *bus)
269 {
270         struct device_node *dn;
271         struct pci_dev *dev;
272
273         dn = pci_bus_to_OF_node(bus);
274         if (!dn)
275                 return;
276
277         dbg("%s: pci_devs of slot[%s]\n", __FUNCTION__, dn->full_name);
278         list_for_each_entry (dev, &bus->devices, bus_list)
279                 dbg("\t%s\n", pci_name(dev));
280         return;
281 }
282
283 int rpaphp_config_pci_adapter(struct pci_bus *bus)
284 {
285         struct device_node *dn = pci_bus_to_OF_node(bus);
286         struct pci_dev *dev;
287         int rc = -ENODEV;
288
289         dbg("Entry %s: slot[%s]\n", __FUNCTION__, dn->full_name);
290         if (!dn)
291                 goto exit;
292
293         eeh_add_device_tree_early(dn);
294         dev = rpaphp_pci_config_slot(bus);
295         if (!dev) {
296                 err("%s: can't find any devices.\n", __FUNCTION__);
297                 goto exit;
298         }
299         print_slot_pci_funcs(bus);
300         rc = 0;
301 exit:
302         dbg("Exit %s:  rc=%d\n", __FUNCTION__, rc);
303         return rc;
304 }
305 EXPORT_SYMBOL_GPL(rpaphp_config_pci_adapter);
306
307 static void rpaphp_eeh_remove_bus_device(struct pci_dev *dev)
308 {
309         eeh_remove_device(dev);
310         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
311                 struct pci_bus *bus = dev->subordinate;
312                 struct list_head *ln;
313                 if (!bus)
314                         return; 
315                 for (ln = bus->devices.next; ln != &bus->devices; ln = ln->next) {
316                         struct pci_dev *pdev = pci_dev_b(ln);
317                         if (pdev)
318                                 rpaphp_eeh_remove_bus_device(pdev);
319                 }
320
321         }
322         return;
323 }
324
325 int rpaphp_unconfig_pci_adapter(struct pci_bus *bus)
326 {
327         struct pci_dev *dev, *tmp;
328
329         list_for_each_entry_safe(dev, tmp, &bus->devices, bus_list) {
330                 rpaphp_eeh_remove_bus_device(dev);
331                 pci_remove_bus_device(dev);
332         }
333         return 0;
334 }
335 EXPORT_SYMBOL_GPL(rpaphp_unconfig_pci_adapter);
336
337 static int setup_pci_hotplug_slot_info(struct slot *slot)
338 {
339         struct hotplug_slot_info *hotplug_slot_info = slot->hotplug_slot->info;
340
341         dbg("%s Initilize the PCI slot's hotplug->info structure ...\n",
342             __FUNCTION__);
343         rpaphp_get_power_status(slot, &hotplug_slot_info->power_status);
344         rpaphp_get_pci_adapter_status(slot, 1,
345                                       &hotplug_slot_info->adapter_status);
346         if (hotplug_slot_info->adapter_status == NOT_VALID) {
347                 err("%s: NOT_VALID: skip dn->full_name=%s\n",
348                     __FUNCTION__, slot->dn->full_name);
349                 return -EINVAL;
350         }
351         return 0;
352 }
353
354 static void set_slot_name(struct slot *slot)
355 {
356         struct pci_bus *bus = slot->bus;
357         struct pci_dev *bridge;
358
359         bridge = bus->self;
360         if (bridge)
361                 strcpy(slot->name, pci_name(bridge));
362         else
363                 sprintf(slot->name, "%04x:%02x:00.0", pci_domain_nr(bus),
364                         bus->number);
365 }
366
367 static int setup_pci_slot(struct slot *slot)
368 {
369         struct device_node *dn = slot->dn;
370         struct pci_bus *bus;
371
372         BUG_ON(!dn);
373         bus = rpaphp_find_pci_bus(dn);
374         if (!bus) {
375                 err("%s: no pci_bus for dn %s\n", __FUNCTION__, dn->full_name);
376                 goto exit_rc;
377         }
378
379         slot->bus = bus;
380         slot->pci_devs = &bus->devices;
381         set_slot_name(slot);
382
383         /* find slot's pci_dev if it's not empty */
384         if (slot->hotplug_slot->info->adapter_status == EMPTY) {
385                 slot->state = EMPTY;    /* slot is empty */
386         } else {
387                 /* slot is occupied */
388                 if (!dn->child) {
389                         /* non-empty slot has to have child */
390                         err("%s: slot[%s]'s device_node doesn't have child for adapter\n", 
391                                 __FUNCTION__, slot->name);
392                         goto exit_rc;
393                 }
394
395                 if (slot->hotplug_slot->info->adapter_status == NOT_CONFIGURED) {
396                         dbg("%s CONFIGURING pci adapter in slot[%s]\n",  
397                                 __FUNCTION__, slot->name);
398                         if (rpaphp_config_pci_adapter(slot->bus)) {
399                                 err("%s: CONFIG pci adapter failed\n", __FUNCTION__);
400                                 goto exit_rc;           
401                         }
402
403                 } else if (slot->hotplug_slot->info->adapter_status != CONFIGURED) {
404                         err("%s: slot[%s]'s adapter_status is NOT_VALID.\n",
405                                 __FUNCTION__, slot->name);
406                         goto exit_rc;
407                 }
408                 print_slot_pci_funcs(slot->bus);
409                 if (!list_empty(slot->pci_devs)) {
410                         slot->state = CONFIGURED;
411                 } else {
412                         /* DLPAR add as opposed to 
413                          * boot time */
414                         slot->state = NOT_CONFIGURED;
415                 }
416         }
417         return 0;
418 exit_rc:
419         dealloc_slot_struct(slot);
420         return -EINVAL;
421 }
422
423 int register_pci_slot(struct slot *slot)
424 {
425         int rc = -EINVAL;
426
427         if (setup_pci_hotplug_slot_info(slot))
428                 goto exit_rc;
429         if (setup_pci_slot(slot))
430                 goto exit_rc;
431         rc = register_slot(slot);
432 exit_rc:
433         return rc;
434 }
435
436 int rpaphp_enable_pci_slot(struct slot *slot)
437 {
438         int retval = 0, state;
439
440         retval = rpaphp_get_sensor_state(slot, &state);
441         if (retval)
442                 goto exit;
443         dbg("%s: sensor state[%d]\n", __FUNCTION__, state);
444         /* if slot is not empty, enable the adapter */
445         if (state == PRESENT) {
446                 dbg("%s : slot[%s] is occupied.\n", __FUNCTION__, slot->name);
447                 retval = rpaphp_config_pci_adapter(slot->bus);
448                 if (!retval) {
449                         slot->state = CONFIGURED;
450                         info("%s: devices in slot[%s] configured\n",
451                                         __FUNCTION__, slot->name);
452                 } else {
453                         slot->state = NOT_CONFIGURED;
454                         dbg("%s: no pci_dev struct for adapter in slot[%s]\n",
455                             __FUNCTION__, slot->name);
456                 }
457         } else if (state == EMPTY) {
458                 dbg("%s : slot[%s] is empty\n", __FUNCTION__, slot->name);
459                 slot->state = EMPTY;
460         } else {
461                 err("%s: slot[%s] is in invalid state\n", __FUNCTION__,
462                     slot->name);
463                 slot->state = NOT_VALID;
464                 retval = -EINVAL;
465         }
466 exit:
467         dbg("%s - Exit: rc[%d]\n", __FUNCTION__, retval);
468         return retval;
469 }