[PATCH] acpi_pcihp: Add support for _HPX
[linux-2.6.git] / drivers / pci / hotplug / shpchp_pci.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/kernel.h>
32 #include <linux/types.h>
33 #include <linux/pci.h>
34 #include "../pci.h"
35 #include "shpchp.h"
36
37 static void program_fw_provided_values(struct pci_dev *dev)
38 {
39         u16 pci_cmd, pci_bctl;
40         struct pci_dev *cdev;
41         struct hotplug_params hpp;
42
43         /* Program hpp values for this device */
44         if (!(dev->hdr_type == PCI_HEADER_TYPE_NORMAL ||
45                         (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE &&
46                         (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI)))
47                 return;
48
49         /* use default values if we can't get them from firmware */
50         if (get_hp_params_from_firmware(dev, &hpp) ||
51             !hpp.t0 || (hpp.t0->revision > 1)) {
52                 printk(KERN_WARNING
53                        "%s: Could not get hotplug parameters. Use defaults\n",
54                        __FUNCTION__);
55                 hpp.t0 = &hpp.type0_data;
56                 hpp.t0->revision = 0;
57                 hpp.t0->cache_line_size = 8;
58                 hpp.t0->latency_timer = 0x40;
59                 hpp.t0->enable_serr = 0;
60                 hpp.t0->enable_perr = 0;
61         }
62
63         pci_write_config_byte(dev,
64                               PCI_CACHE_LINE_SIZE, hpp.t0->cache_line_size);
65         pci_write_config_byte(dev, PCI_LATENCY_TIMER, hpp.t0->latency_timer);
66         pci_read_config_word(dev, PCI_COMMAND, &pci_cmd);
67         if (hpp.t0->enable_serr)
68                 pci_cmd |= PCI_COMMAND_SERR;
69         else
70                 pci_cmd &= ~PCI_COMMAND_SERR;
71         if (hpp.t0->enable_perr)
72                 pci_cmd |= PCI_COMMAND_PARITY;
73         else
74                 pci_cmd &= ~PCI_COMMAND_PARITY;
75         pci_write_config_word(dev, PCI_COMMAND, pci_cmd);
76
77         /* Program bridge control value and child devices */
78         if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI) {
79                 pci_write_config_byte(dev, PCI_SEC_LATENCY_TIMER,
80                                 hpp.t0->latency_timer);
81                 pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &pci_bctl);
82                 if (hpp.t0->enable_serr)
83                         pci_bctl |= PCI_BRIDGE_CTL_SERR;
84                 else
85                         pci_bctl &= ~PCI_BRIDGE_CTL_SERR;
86                 if (hpp.t0->enable_perr)
87                         pci_bctl |= PCI_BRIDGE_CTL_PARITY;
88                 else
89                         pci_bctl &= ~PCI_BRIDGE_CTL_PARITY;
90                 pci_write_config_word(dev, PCI_BRIDGE_CONTROL, pci_bctl);
91                 if (dev->subordinate) {
92                         list_for_each_entry(cdev, &dev->subordinate->devices,
93                                         bus_list)
94                                 program_fw_provided_values(cdev);
95                 }
96         }
97 }
98
99 int shpchp_configure_device(struct slot *p_slot)
100 {
101         struct pci_dev *dev;
102         struct pci_bus *parent = p_slot->ctrl->pci_dev->subordinate;
103         int num, fn;
104
105         dev = pci_get_slot(parent, PCI_DEVFN(p_slot->device, 0));
106         if (dev) {
107                 err("Device %s already exists at %x:%x, cannot hot-add\n",
108                                 pci_name(dev), p_slot->bus, p_slot->device);
109                 pci_dev_put(dev);
110                 return -EINVAL;
111         }
112
113         num = pci_scan_slot(parent, PCI_DEVFN(p_slot->device, 0));
114         if (num == 0) {
115                 err("No new device found\n");
116                 return -ENODEV;
117         }
118
119         for (fn = 0; fn < 8; fn++) {
120                 dev = pci_get_slot(parent, PCI_DEVFN(p_slot->device, fn));
121                 if (!dev)
122                         continue;
123                 if ((dev->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
124                         err("Cannot hot-add display device %s\n",
125                                         pci_name(dev));
126                         pci_dev_put(dev);
127                         continue;
128                 }
129                 if ((dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) ||
130                                 (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)) {
131                         /* Find an unused bus number for the new bridge */
132                         struct pci_bus *child;
133                         unsigned char busnr, start = parent->secondary;
134                         unsigned char end = parent->subordinate;
135                         for (busnr = start; busnr <= end; busnr++) {
136                                 if (!pci_find_bus(pci_domain_nr(parent),
137                                                         busnr))
138                                         break;
139                         }
140                         if (busnr >= end) {
141                                 err("No free bus for hot-added bridge\n");
142                                 pci_dev_put(dev);
143                                 continue;
144                         }
145                         child = pci_add_new_bus(parent, dev, busnr);
146                         if (!child) {
147                                 err("Cannot add new bus for %s\n",
148                                                 pci_name(dev));
149                                 pci_dev_put(dev);
150                                 continue;
151                         }
152                         child->subordinate = pci_do_scan_bus(child);
153                         pci_bus_size_bridges(child);
154                 }
155                 program_fw_provided_values(dev);
156                 pci_dev_put(dev);
157         }
158
159         pci_bus_assign_resources(parent);
160         pci_bus_add_devices(parent);
161         pci_enable_bridges(parent);
162         return 0;
163 }
164
165 int shpchp_unconfigure_device(struct slot *p_slot)
166 {
167         int rc = 0;
168         int j;
169         u8 bctl = 0;
170         struct pci_bus *parent = p_slot->ctrl->pci_dev->subordinate;
171
172         dbg("%s: bus/dev = %x/%x\n", __FUNCTION__, p_slot->bus, p_slot->device);
173
174         for (j=0; j<8 ; j++) {
175                 struct pci_dev* temp = pci_get_slot(parent,
176                                 (p_slot->device << 3) | j);
177                 if (!temp)
178                         continue;
179                 if ((temp->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
180                         err("Cannot remove display device %s\n",
181                                         pci_name(temp));
182                         pci_dev_put(temp);
183                         continue;
184                 }
185                 if (temp->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
186                         pci_read_config_byte(temp, PCI_BRIDGE_CONTROL, &bctl);
187                         if (bctl & PCI_BRIDGE_CTL_VGA) {
188                                 err("Cannot remove display device %s\n",
189                                                 pci_name(temp));
190                                 pci_dev_put(temp);
191                                 continue;
192                         }
193                 }
194                 pci_remove_bus_device(temp);
195                 pci_dev_put(temp);
196         }
197         return rc;
198 }
199