Pull ec into test branch
[linux-2.6] / drivers / pci / hotplug / cpci_hotplug_pci.c
1 /*
2  * CompactPCI Hot Plug Driver PCI functions
3  *
4  * Copyright (C) 2002,2005 by SOMA Networks, Inc.
5  *
6  * All rights reserved.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or (at
11  * your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
16  * NON INFRINGEMENT.  See the GNU General Public License for more
17  * details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22  *
23  * Send feedback to <scottm@somanetworks.com>
24  */
25
26 #include <linux/module.h>
27 #include <linux/kernel.h>
28 #include <linux/pci.h>
29 #include <linux/pci_hotplug.h>
30 #include <linux/proc_fs.h>
31 #include "../pci.h"
32 #include "cpci_hotplug.h"
33
34 #define MY_NAME "cpci_hotplug"
35
36 extern int cpci_debug;
37
38 #define dbg(format, arg...)                                     \
39         do {                                                    \
40                 if (cpci_debug)                                 \
41                         printk (KERN_DEBUG "%s: " format "\n",  \
42                                 MY_NAME , ## arg);              \
43         } while (0)
44 #define err(format, arg...) printk(KERN_ERR "%s: " format "\n", MY_NAME , ## arg)
45 #define info(format, arg...) printk(KERN_INFO "%s: " format "\n", MY_NAME , ## arg)
46 #define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n", MY_NAME , ## arg)
47
48 #define ROUND_UP(x, a)          (((x) + (a) - 1) & ~((a) - 1))
49
50
51 u8 cpci_get_attention_status(struct slot* slot)
52 {
53         int hs_cap;
54         u16 hs_csr;
55
56         hs_cap = pci_bus_find_capability(slot->bus,
57                                          slot->devfn,
58                                          PCI_CAP_ID_CHSWP);
59         if (!hs_cap)
60                 return 0;
61
62         if (pci_bus_read_config_word(slot->bus,
63                                      slot->devfn,
64                                      hs_cap + 2,
65                                      &hs_csr))
66                 return 0;
67
68         return hs_csr & 0x0008 ? 1 : 0;
69 }
70
71 int cpci_set_attention_status(struct slot* slot, int status)
72 {
73         int hs_cap;
74         u16 hs_csr;
75
76         hs_cap = pci_bus_find_capability(slot->bus,
77                                          slot->devfn,
78                                          PCI_CAP_ID_CHSWP);
79         if (!hs_cap)
80                 return 0;
81         if (pci_bus_read_config_word(slot->bus,
82                                      slot->devfn,
83                                      hs_cap + 2,
84                                      &hs_csr))
85                 return 0;
86         if (status)
87                 hs_csr |= HS_CSR_LOO;
88         else
89                 hs_csr &= ~HS_CSR_LOO;
90         if (pci_bus_write_config_word(slot->bus,
91                                       slot->devfn,
92                                       hs_cap + 2,
93                                       hs_csr))
94                 return 0;
95         return 1;
96 }
97
98 u16 cpci_get_hs_csr(struct slot* slot)
99 {
100         int hs_cap;
101         u16 hs_csr;
102
103         hs_cap = pci_bus_find_capability(slot->bus,
104                                          slot->devfn,
105                                          PCI_CAP_ID_CHSWP);
106         if (!hs_cap)
107                 return 0xFFFF;
108         if (pci_bus_read_config_word(slot->bus,
109                                      slot->devfn,
110                                      hs_cap + 2,
111                                      &hs_csr))
112                 return 0xFFFF;
113         return hs_csr;
114 }
115
116 int cpci_check_and_clear_ins(struct slot* slot)
117 {
118         int hs_cap;
119         u16 hs_csr;
120         int ins = 0;
121
122         hs_cap = pci_bus_find_capability(slot->bus,
123                                          slot->devfn,
124                                          PCI_CAP_ID_CHSWP);
125         if (!hs_cap)
126                 return 0;
127         if (pci_bus_read_config_word(slot->bus,
128                                      slot->devfn,
129                                      hs_cap + 2,
130                                      &hs_csr))
131                 return 0;
132         if (hs_csr & HS_CSR_INS) {
133                 /* Clear INS (by setting it) */
134                 if (pci_bus_write_config_word(slot->bus,
135                                               slot->devfn,
136                                               hs_cap + 2,
137                                               hs_csr))
138                         ins = 0;
139                 else
140                         ins = 1;
141         }
142         return ins;
143 }
144
145 int cpci_check_ext(struct slot* slot)
146 {
147         int hs_cap;
148         u16 hs_csr;
149         int ext = 0;
150
151         hs_cap = pci_bus_find_capability(slot->bus,
152                                          slot->devfn,
153                                          PCI_CAP_ID_CHSWP);
154         if (!hs_cap)
155                 return 0;
156         if (pci_bus_read_config_word(slot->bus,
157                                      slot->devfn,
158                                      hs_cap + 2,
159                                      &hs_csr))
160                 return 0;
161         if (hs_csr & HS_CSR_EXT)
162                 ext = 1;
163         return ext;
164 }
165
166 int cpci_clear_ext(struct slot* slot)
167 {
168         int hs_cap;
169         u16 hs_csr;
170
171         hs_cap = pci_bus_find_capability(slot->bus,
172                                          slot->devfn,
173                                          PCI_CAP_ID_CHSWP);
174         if (!hs_cap)
175                 return -ENODEV;
176         if (pci_bus_read_config_word(slot->bus,
177                                      slot->devfn,
178                                      hs_cap + 2,
179                                      &hs_csr))
180                 return -ENODEV;
181         if (hs_csr & HS_CSR_EXT) {
182                 /* Clear EXT (by setting it) */
183                 if (pci_bus_write_config_word(slot->bus,
184                                               slot->devfn,
185                                               hs_cap + 2,
186                                               hs_csr))
187                         return -ENODEV;
188         }
189         return 0;
190 }
191
192 int cpci_led_on(struct slot* slot)
193 {
194         int hs_cap;
195         u16 hs_csr;
196
197         hs_cap = pci_bus_find_capability(slot->bus,
198                                          slot->devfn,
199                                          PCI_CAP_ID_CHSWP);
200         if (!hs_cap)
201                 return -ENODEV;
202         if (pci_bus_read_config_word(slot->bus,
203                                      slot->devfn,
204                                      hs_cap + 2,
205                                      &hs_csr))
206                 return -ENODEV;
207         if ((hs_csr & HS_CSR_LOO) != HS_CSR_LOO) {
208                 hs_csr |= HS_CSR_LOO;
209                 if (pci_bus_write_config_word(slot->bus,
210                                               slot->devfn,
211                                               hs_cap + 2,
212                                               hs_csr)) {
213                         err("Could not set LOO for slot %s",
214                             slot->hotplug_slot->name);
215                         return -ENODEV;
216                 }
217         }
218         return 0;
219 }
220
221 int cpci_led_off(struct slot* slot)
222 {
223         int hs_cap;
224         u16 hs_csr;
225
226         hs_cap = pci_bus_find_capability(slot->bus,
227                                          slot->devfn,
228                                          PCI_CAP_ID_CHSWP);
229         if (!hs_cap)
230                 return -ENODEV;
231         if (pci_bus_read_config_word(slot->bus,
232                                      slot->devfn,
233                                      hs_cap + 2,
234                                      &hs_csr))
235                 return -ENODEV;
236         if (hs_csr & HS_CSR_LOO) {
237                 hs_csr &= ~HS_CSR_LOO;
238                 if (pci_bus_write_config_word(slot->bus,
239                                               slot->devfn,
240                                               hs_cap + 2,
241                                               hs_csr)) {
242                         err("Could not clear LOO for slot %s",
243                             slot->hotplug_slot->name);
244                         return -ENODEV;
245                 }
246         }
247         return 0;
248 }
249
250
251 /*
252  * Device configuration functions
253  */
254
255 int cpci_configure_slot(struct slot* slot)
256 {
257         struct pci_bus *parent;
258         int fn;
259
260         dbg("%s - enter", __FUNCTION__);
261
262         if (slot->dev == NULL) {
263                 dbg("pci_dev null, finding %02x:%02x:%x",
264                     slot->bus->number, PCI_SLOT(slot->devfn), PCI_FUNC(slot->devfn));
265                 slot->dev = pci_get_slot(slot->bus, slot->devfn);
266         }
267
268         /* Still NULL? Well then scan for it! */
269         if (slot->dev == NULL) {
270                 int n;
271                 dbg("pci_dev still null");
272
273                 /*
274                  * This will generate pci_dev structures for all functions, but
275                  * we will only call this case when lookup fails.
276                  */
277                 n = pci_scan_slot(slot->bus, slot->devfn);
278                 dbg("%s: pci_scan_slot returned %d", __FUNCTION__, n);
279                 slot->dev = pci_get_slot(slot->bus, slot->devfn);
280                 if (slot->dev == NULL) {
281                         err("Could not find PCI device for slot %02x", slot->number);
282                         return -ENODEV;
283                 }
284         }
285         parent = slot->dev->bus;
286
287         for (fn = 0; fn < 8; fn++) {
288                 struct pci_dev *dev;
289
290                 dev = pci_get_slot(parent, PCI_DEVFN(PCI_SLOT(slot->devfn), fn));
291                 if (!dev)
292                         continue;
293                 if ((dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) ||
294                     (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)) {
295                         /* Find an unused bus number for the new bridge */
296                         struct pci_bus *child;
297                         unsigned char busnr, start = parent->secondary;
298                         unsigned char end = parent->subordinate;
299
300                         for (busnr = start; busnr <= end; busnr++) {
301                                 if (!pci_find_bus(pci_domain_nr(parent),
302                                                   busnr))
303                                         break;
304                         }
305                         if (busnr >= end) {
306                                 err("No free bus for hot-added bridge\n");
307                                 pci_dev_put(dev);
308                                 continue;
309                         }
310                         child = pci_add_new_bus(parent, dev, busnr);
311                         if (!child) {
312                                 err("Cannot add new bus for %s\n",
313                                     pci_name(dev));
314                                 pci_dev_put(dev);
315                                 continue;
316                         }
317                         child->subordinate = pci_do_scan_bus(child);
318                         pci_bus_size_bridges(child);
319                 }
320                 pci_dev_put(dev);
321         }
322
323         pci_bus_assign_resources(parent);
324         pci_bus_add_devices(parent);
325         pci_enable_bridges(parent);
326
327         dbg("%s - exit", __FUNCTION__);
328         return 0;
329 }
330
331 int cpci_unconfigure_slot(struct slot* slot)
332 {
333         int i;
334         struct pci_dev *dev;
335
336         dbg("%s - enter", __FUNCTION__);
337         if (!slot->dev) {
338                 err("No device for slot %02x\n", slot->number);
339                 return -ENODEV;
340         }
341
342         for (i = 0; i < 8; i++) {
343                 dev = pci_get_slot(slot->bus,
344                                     PCI_DEVFN(PCI_SLOT(slot->devfn), i));
345                 if (dev) {
346                         pci_remove_bus_device(dev);
347                         pci_dev_put(dev);
348                 }
349         }
350         pci_dev_put(slot->dev);
351         slot->dev = NULL;
352
353         dbg("%s - exit", __FUNCTION__);
354         return 0;
355 }