7dfb408fe2cac07830c3ed552aeeee3a8cafd8e2
[linux-2.6.git] / include / asm-powerpc / eeh.h
1 /*
2  * eeh.h
3  * Copyright (C) 2001  Dave Engebretsen & Todd Inglett IBM Corporation.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
18  */
19
20 #ifndef _PPC64_EEH_H
21 #define _PPC64_EEH_H
22 #ifdef __KERNEL__
23
24 #include <linux/config.h>
25 #include <linux/init.h>
26 #include <linux/list.h>
27 #include <linux/string.h>
28
29 struct pci_dev;
30 struct pci_bus;
31 struct device_node;
32
33 #ifdef CONFIG_EEH
34
35 extern int eeh_subsystem_enabled;
36
37 /* Values for eeh_mode bits in device_node */
38 #define EEH_MODE_SUPPORTED     (1<<0)
39 #define EEH_MODE_NOCHECK       (1<<1)
40 #define EEH_MODE_ISOLATED      (1<<2)
41 #define EEH_MODE_RECOVERING    (1<<3)
42 #define EEH_MODE_IRQ_DISABLED  (1<<4)
43
44 /* Max number of EEH freezes allowed before we consider the device
45  * to be permanently disabled. */
46 #define EEH_MAX_ALLOWED_FREEZES 5
47
48 void __init eeh_init(void);
49 unsigned long eeh_check_failure(const volatile void __iomem *token,
50                                 unsigned long val);
51 int eeh_dn_check_failure(struct device_node *dn, struct pci_dev *dev);
52 void __init pci_addr_cache_build(void);
53
54 /**
55  * eeh_add_device_early
56  * eeh_add_device_late
57  *
58  * Perform eeh initialization for devices added after boot.
59  * Call eeh_add_device_early before doing any i/o to the
60  * device (including config space i/o).  Call eeh_add_device_late
61  * to finish the eeh setup for this device.
62  */
63 void eeh_add_device_early(struct device_node *);
64 void eeh_add_device_tree_early(struct device_node *);
65 void eeh_add_device_tree_late(struct pci_bus *);
66
67 /**
68  * eeh_remove_device - undo EEH setup for the indicated pci device
69  * @dev: pci device to be removed
70  *
71  * This routine should be called when a device is removed from
72  * a running system (e.g. by hotplug or dlpar).  It unregisters
73  * the PCI device from the EEH subsystem.  I/O errors affecting
74  * this device will no longer be detected after this call; thus,
75  * i/o errors affecting this slot may leave this device unusable.
76  */
77 void eeh_remove_device(struct pci_dev *);
78
79 /**
80  * eeh_remove_device_recursive - undo EEH for device & children.
81  * @dev: pci device to be removed
82  *
83  * As above, this removes the device; it also removes child
84  * pci devices as well.
85  */
86 void eeh_remove_bus_device(struct pci_dev *);
87
88 /**
89  * EEH_POSSIBLE_ERROR() -- test for possible MMIO failure.
90  *
91  * If this macro yields TRUE, the caller relays to eeh_check_failure()
92  * which does further tests out of line.
93  */
94 #define EEH_POSSIBLE_ERROR(val, type)   ((val) == (type)~0 && eeh_subsystem_enabled)
95
96 /*
97  * Reads from a device which has been isolated by EEH will return
98  * all 1s.  This macro gives an all-1s value of the given size (in
99  * bytes: 1, 2, or 4) for comparing with the result of a read.
100  */
101 #define EEH_IO_ERROR_VALUE(size)        (~0U >> ((4 - (size)) * 8))
102
103 #else /* !CONFIG_EEH */
104 static inline void eeh_init(void) { }
105
106 static inline unsigned long eeh_check_failure(const volatile void __iomem *token, unsigned long val)
107 {
108         return val;
109 }
110
111 static inline int eeh_dn_check_failure(struct device_node *dn, struct pci_dev *dev)
112 {
113         return 0;
114 }
115
116 static inline void pci_addr_cache_build(void) { }
117
118 static inline void eeh_add_device_early(struct device_node *dn) { }
119
120 static inline void eeh_remove_device(struct pci_dev *dev) { }
121
122 static inline void eeh_add_device_tree_early(struct device_node *dn) { }
123
124 static inline void eeh_add_device_tree_late(struct pci_bus *bus) { }
125
126 static inline void eeh_remove_bus_device(struct pci_dev *dev) { }
127 #define EEH_POSSIBLE_ERROR(val, type) (0)
128 #define EEH_IO_ERROR_VALUE(size) (-1UL)
129 #endif /* CONFIG_EEH */
130
131 /*
132  * MMIO read/write operations with EEH support.
133  */
134 static inline u8 eeh_readb(const volatile void __iomem *addr)
135 {
136         u8 val = in_8(addr);
137         if (EEH_POSSIBLE_ERROR(val, u8))
138                 return eeh_check_failure(addr, val);
139         return val;
140 }
141 static inline void eeh_writeb(u8 val, volatile void __iomem *addr)
142 {
143         out_8(addr, val);
144 }
145
146 static inline u16 eeh_readw(const volatile void __iomem *addr)
147 {
148         u16 val = in_le16(addr);
149         if (EEH_POSSIBLE_ERROR(val, u16))
150                 return eeh_check_failure(addr, val);
151         return val;
152 }
153 static inline void eeh_writew(u16 val, volatile void __iomem *addr)
154 {
155         out_le16(addr, val);
156 }
157 static inline u16 eeh_raw_readw(const volatile void __iomem *addr)
158 {
159         u16 val = in_be16(addr);
160         if (EEH_POSSIBLE_ERROR(val, u16))
161                 return eeh_check_failure(addr, val);
162         return val;
163 }
164 static inline void eeh_raw_writew(u16 val, volatile void __iomem *addr) {
165         volatile u16 __iomem *vaddr = (volatile u16 __iomem *) addr;
166         out_be16(vaddr, val);
167 }
168
169 static inline u32 eeh_readl(const volatile void __iomem *addr)
170 {
171         u32 val = in_le32(addr);
172         if (EEH_POSSIBLE_ERROR(val, u32))
173                 return eeh_check_failure(addr, val);
174         return val;
175 }
176 static inline void eeh_writel(u32 val, volatile void __iomem *addr)
177 {
178         out_le32(addr, val);
179 }
180 static inline u32 eeh_raw_readl(const volatile void __iomem *addr)
181 {
182         u32 val = in_be32(addr);
183         if (EEH_POSSIBLE_ERROR(val, u32))
184                 return eeh_check_failure(addr, val);
185         return val;
186 }
187 static inline void eeh_raw_writel(u32 val, volatile void __iomem *addr)
188 {
189         out_be32(addr, val);
190 }
191
192 static inline u64 eeh_readq(const volatile void __iomem *addr)
193 {
194         u64 val = in_le64(addr);
195         if (EEH_POSSIBLE_ERROR(val, u64))
196                 return eeh_check_failure(addr, val);
197         return val;
198 }
199 static inline void eeh_writeq(u64 val, volatile void __iomem *addr)
200 {
201         out_le64(addr, val);
202 }
203 static inline u64 eeh_raw_readq(const volatile void __iomem *addr)
204 {
205         u64 val = in_be64(addr);
206         if (EEH_POSSIBLE_ERROR(val, u64))
207                 return eeh_check_failure(addr, val);
208         return val;
209 }
210 static inline void eeh_raw_writeq(u64 val, volatile void __iomem *addr)
211 {
212         out_be64(addr, val);
213 }
214
215 #define EEH_CHECK_ALIGN(v,a) \
216         ((((unsigned long)(v)) & ((a) - 1)) == 0)
217
218 static inline void eeh_memset_io(volatile void __iomem *addr, int c,
219                                  unsigned long n)
220 {
221         void *p = (void __force *)addr;
222         u32 lc = c;
223         lc |= lc << 8;
224         lc |= lc << 16;
225
226         while(n && !EEH_CHECK_ALIGN(p, 4)) {
227                 *((volatile u8 *)p) = c;
228                 p++;
229                 n--;
230         }
231         while(n >= 4) {
232                 *((volatile u32 *)p) = lc;
233                 p += 4;
234                 n -= 4;
235         }
236         while(n) {
237                 *((volatile u8 *)p) = c;
238                 p++;
239                 n--;
240         }
241         __asm__ __volatile__ ("sync" : : : "memory");
242 }
243 static inline void eeh_memcpy_fromio(void *dest, const volatile void __iomem *src,
244                                      unsigned long n)
245 {
246         void *vsrc = (void __force *) src;
247         void *destsave = dest;
248         unsigned long nsave = n;
249
250         while(n && (!EEH_CHECK_ALIGN(vsrc, 4) || !EEH_CHECK_ALIGN(dest, 4))) {
251                 *((u8 *)dest) = *((volatile u8 *)vsrc);
252                 __asm__ __volatile__ ("eieio" : : : "memory");
253                 vsrc++;
254                 dest++;
255                 n--;
256         }
257         while(n > 4) {
258                 *((u32 *)dest) = *((volatile u32 *)vsrc);
259                 __asm__ __volatile__ ("eieio" : : : "memory");
260                 vsrc += 4;
261                 dest += 4;
262                 n -= 4;
263         }
264         while(n) {
265                 *((u8 *)dest) = *((volatile u8 *)vsrc);
266                 __asm__ __volatile__ ("eieio" : : : "memory");
267                 vsrc++;
268                 dest++;
269                 n--;
270         }
271         __asm__ __volatile__ ("sync" : : : "memory");
272
273         /* Look for ffff's here at dest[n].  Assume that at least 4 bytes
274          * were copied. Check all four bytes.
275          */
276         if ((nsave >= 4) &&
277                 (EEH_POSSIBLE_ERROR((*((u32 *) destsave+nsave-4)), u32))) {
278                 eeh_check_failure(src, (*((u32 *) destsave+nsave-4)));
279         }
280 }
281
282 static inline void eeh_memcpy_toio(volatile void __iomem *dest, const void *src,
283                                    unsigned long n)
284 {
285         void *vdest = (void __force *) dest;
286
287         while(n && (!EEH_CHECK_ALIGN(vdest, 4) || !EEH_CHECK_ALIGN(src, 4))) {
288                 *((volatile u8 *)vdest) = *((u8 *)src);
289                 src++;
290                 vdest++;
291                 n--;
292         }
293         while(n > 4) {
294                 *((volatile u32 *)vdest) = *((volatile u32 *)src);
295                 src += 4;
296                 vdest += 4;
297                 n-=4;
298         }
299         while(n) {
300                 *((volatile u8 *)vdest) = *((u8 *)src);
301                 src++;
302                 vdest++;
303                 n--;
304         }
305         __asm__ __volatile__ ("sync" : : : "memory");
306 }
307
308 #undef EEH_CHECK_ALIGN
309
310 static inline u8 eeh_inb(unsigned long port)
311 {
312         u8 val;
313         if (!_IO_IS_VALID(port))
314                 return ~0;
315         val = in_8((u8 __iomem *)(port+pci_io_base));
316         if (EEH_POSSIBLE_ERROR(val, u8))
317                 return eeh_check_failure((void __iomem *)(port), val);
318         return val;
319 }
320
321 static inline void eeh_outb(u8 val, unsigned long port)
322 {
323         if (_IO_IS_VALID(port))
324                 out_8((u8 __iomem *)(port+pci_io_base), val);
325 }
326
327 static inline u16 eeh_inw(unsigned long port)
328 {
329         u16 val;
330         if (!_IO_IS_VALID(port))
331                 return ~0;
332         val = in_le16((u16 __iomem *)(port+pci_io_base));
333         if (EEH_POSSIBLE_ERROR(val, u16))
334                 return eeh_check_failure((void __iomem *)(port), val);
335         return val;
336 }
337
338 static inline void eeh_outw(u16 val, unsigned long port)
339 {
340         if (_IO_IS_VALID(port))
341                 out_le16((u16 __iomem *)(port+pci_io_base), val);
342 }
343
344 static inline u32 eeh_inl(unsigned long port)
345 {
346         u32 val;
347         if (!_IO_IS_VALID(port))
348                 return ~0;
349         val = in_le32((u32 __iomem *)(port+pci_io_base));
350         if (EEH_POSSIBLE_ERROR(val, u32))
351                 return eeh_check_failure((void __iomem *)(port), val);
352         return val;
353 }
354
355 static inline void eeh_outl(u32 val, unsigned long port)
356 {
357         if (_IO_IS_VALID(port))
358                 out_le32((u32 __iomem *)(port+pci_io_base), val);
359 }
360
361 /* in-string eeh macros */
362 static inline void eeh_insb(unsigned long port, void * buf, int ns)
363 {
364         _insb((u8 __iomem *)(port+pci_io_base), buf, ns);
365         if (EEH_POSSIBLE_ERROR((*(((u8*)buf)+ns-1)), u8))
366                 eeh_check_failure((void __iomem *)(port), *(u8*)buf);
367 }
368
369 static inline void eeh_insw_ns(unsigned long port, void * buf, int ns)
370 {
371         _insw_ns((u16 __iomem *)(port+pci_io_base), buf, ns);
372         if (EEH_POSSIBLE_ERROR((*(((u16*)buf)+ns-1)), u16))
373                 eeh_check_failure((void __iomem *)(port), *(u16*)buf);
374 }
375
376 static inline void eeh_insl_ns(unsigned long port, void * buf, int nl)
377 {
378         _insl_ns((u32 __iomem *)(port+pci_io_base), buf, nl);
379         if (EEH_POSSIBLE_ERROR((*(((u32*)buf)+nl-1)), u32))
380                 eeh_check_failure((void __iomem *)(port), *(u32*)buf);
381 }
382
383 #endif /* __KERNEL__ */
384 #endif /* _PPC64_EEH_H */