Merge with /pub/scm/linux/kernel/git/torvalds/linux-2.6.git
[linux-2.6] / 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 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 = {0x8, 0x40, 0, 0}; /* defaults */
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         get_hp_params_from_firmware(dev, &hpp);
50
51         pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, hpp.cache_line_size);
52         pci_write_config_byte(dev, PCI_LATENCY_TIMER, hpp.latency_timer);
53         pci_read_config_word(dev, PCI_COMMAND, &pci_cmd);
54         if (hpp.enable_serr)
55                 pci_cmd |= PCI_COMMAND_SERR;
56         else
57                 pci_cmd &= ~PCI_COMMAND_SERR;
58         if (hpp.enable_perr)
59                 pci_cmd |= PCI_COMMAND_PARITY;
60         else
61                 pci_cmd &= ~PCI_COMMAND_PARITY;
62         pci_write_config_word(dev, PCI_COMMAND, pci_cmd);
63
64         /* Program bridge control value and child devices */
65         if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI) {
66                 pci_write_config_byte(dev, PCI_SEC_LATENCY_TIMER,
67                                 hpp.latency_timer);
68                 pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &pci_bctl);
69                 if (hpp.enable_serr)
70                         pci_bctl |= PCI_BRIDGE_CTL_SERR;
71                 else
72                         pci_bctl &= ~PCI_BRIDGE_CTL_SERR;
73                 if (hpp.enable_perr)
74                         pci_bctl |= PCI_BRIDGE_CTL_PARITY;
75                 else
76                         pci_bctl &= ~PCI_BRIDGE_CTL_PARITY;
77                 pci_write_config_word(dev, PCI_BRIDGE_CONTROL, pci_bctl);
78                 if (dev->subordinate) {
79                         list_for_each_entry(cdev, &dev->subordinate->devices,
80                                         bus_list)
81                                 program_fw_provided_values(cdev);
82                 }
83         }
84 }
85
86 int shpchp_configure_device(struct slot *p_slot)
87 {
88         struct pci_dev *dev;
89         struct pci_bus *parent = p_slot->ctrl->pci_dev->subordinate;
90         int num, fn;
91
92         dev = pci_find_slot(p_slot->bus, PCI_DEVFN(p_slot->device, 0));
93         if (dev) {
94                 err("Device %s already exists at %x:%x, cannot hot-add\n",
95                                 pci_name(dev), p_slot->bus, p_slot->device);
96                 return -EINVAL;
97         }
98
99         num = pci_scan_slot(parent, PCI_DEVFN(p_slot->device, 0));
100         if (num == 0) {
101                 err("No new device found\n");
102                 return -ENODEV;
103         }
104
105         for (fn = 0; fn < 8; fn++) {
106                 if (!(dev = pci_find_slot(p_slot->bus,
107                                         PCI_DEVFN(p_slot->device, fn))))
108                         continue;
109                 if ((dev->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
110                         err("Cannot hot-add display device %s\n",
111                                         pci_name(dev));
112                         continue;
113                 }
114                 if ((dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) ||
115                                 (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)) {
116                         /* Find an unused bus number for the new bridge */
117                         struct pci_bus *child;
118                         unsigned char busnr, start = parent->secondary;
119                         unsigned char end = parent->subordinate;
120                         for (busnr = start; busnr <= end; busnr++) {
121                                 if (!pci_find_bus(pci_domain_nr(parent),
122                                                         busnr))
123                                         break;
124                         }
125                         if (busnr >= end) {
126                                 err("No free bus for hot-added bridge\n");
127                                 continue;
128                         }
129                         child = pci_add_new_bus(parent, dev, busnr);
130                         if (!child) {
131                                 err("Cannot add new bus for %s\n",
132                                                 pci_name(dev));
133                                 continue;
134                         }
135                         child->subordinate = pci_do_scan_bus(child);
136                         pci_bus_size_bridges(child);
137                 }
138                 program_fw_provided_values(dev);
139         }
140
141         pci_bus_assign_resources(parent);
142         pci_bus_add_devices(parent);
143         pci_enable_bridges(parent);
144         return 0;
145 }
146
147 int shpchp_unconfigure_device(struct slot *p_slot)
148 {
149         int rc = 0;
150         int j;
151         u8 bctl = 0;
152         
153         dbg("%s: bus/dev = %x/%x\n", __FUNCTION__, p_slot->bus, p_slot->device);
154
155         for (j=0; j<8 ; j++) {
156                 struct pci_dev* temp = pci_find_slot(p_slot->bus,
157                                 (p_slot->device << 3) | j);
158                 if (!temp)
159                         continue;
160                 if ((temp->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
161                         err("Cannot remove display device %s\n",
162                                         pci_name(temp));
163                         continue;
164                 }
165                 if (temp->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
166                         pci_read_config_byte(temp, PCI_BRIDGE_CONTROL, &bctl);
167                         if (bctl & PCI_BRIDGE_CTL_VGA) {
168                                 err("Cannot remove display device %s\n",
169                                                 pci_name(temp));
170                                 continue;
171                         }
172                 }
173                 pci_remove_bus_device(temp);
174         }
175         return rc;
176 }
177