3 * Copyright (C) 2001 Dave Engebretsen & Todd Inglett IBM Corporation.
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.
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.
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
23 #include <linux/config.h>
24 #include <linux/init.h>
25 #include <linux/list.h>
26 #include <linux/string.h>
33 extern int eeh_subsystem_enabled;
35 /* Values for eeh_mode bits in device_node */
36 #define EEH_MODE_SUPPORTED (1<<0)
37 #define EEH_MODE_NOCHECK (1<<1)
38 #define EEH_MODE_ISOLATED (1<<2)
40 /* Max number of EEH freezes allowed before we consider the device
41 * to be permanently disabled. */
42 #define EEH_MAX_ALLOWED_FREEZES 5
44 void __init eeh_init(void);
45 unsigned long eeh_check_failure(const volatile void __iomem *token,
47 int eeh_dn_check_failure(struct device_node *dn, struct pci_dev *dev);
48 void __init pci_addr_cache_build(void);
51 * eeh_add_device_early
54 * Perform eeh initialization for devices added after boot.
55 * Call eeh_add_device_early before doing any i/o to the
56 * device (including config space i/o). Call eeh_add_device_late
57 * to finish the eeh setup for this device.
59 void eeh_add_device_early(struct device_node *);
60 void eeh_add_device_tree_early(struct device_node *);
61 void eeh_add_device_late(struct pci_dev *);
64 * eeh_remove_device - undo EEH setup for the indicated pci device
65 * @dev: pci device to be removed
67 * This routine should be called when a device is removed from
68 * a running system (e.g. by hotplug or dlpar). It unregisters
69 * the PCI device from the EEH subsystem. I/O errors affecting
70 * this device will no longer be detected after this call; thus,
71 * i/o errors affecting this slot may leave this device unusable.
73 void eeh_remove_device(struct pci_dev *);
76 * eeh_remove_device_recursive - undo EEH for device & children.
77 * @dev: pci device to be removed
79 * As above, this removes the device; it also removes child
80 * pci devices as well.
82 void eeh_remove_bus_device(struct pci_dev *);
85 * EEH_POSSIBLE_ERROR() -- test for possible MMIO failure.
87 * If this macro yields TRUE, the caller relays to eeh_check_failure()
88 * which does further tests out of line.
90 #define EEH_POSSIBLE_ERROR(val, type) ((val) == (type)~0 && eeh_subsystem_enabled)
93 * Reads from a device which has been isolated by EEH will return
94 * all 1s. This macro gives an all-1s value of the given size (in
95 * bytes: 1, 2, or 4) for comparing with the result of a read.
97 #define EEH_IO_ERROR_VALUE(size) (~0U >> ((4 - (size)) * 8))
99 #else /* !CONFIG_EEH */
100 static inline void eeh_init(void) { }
102 static inline unsigned long eeh_check_failure(const volatile void __iomem *token, unsigned long val)
107 static inline int eeh_dn_check_failure(struct device_node *dn, struct pci_dev *dev)
112 static inline void pci_addr_cache_build(void) { }
114 static inline void eeh_add_device_early(struct device_node *dn) { }
116 static inline void eeh_add_device_late(struct pci_dev *dev) { }
118 static inline void eeh_remove_device(struct pci_dev *dev) { }
120 #define EEH_POSSIBLE_ERROR(val, type) (0)
121 #define EEH_IO_ERROR_VALUE(size) (-1UL)
122 #endif /* CONFIG_EEH */
125 * MMIO read/write operations with EEH support.
127 static inline u8 eeh_readb(const volatile void __iomem *addr)
130 if (EEH_POSSIBLE_ERROR(val, u8))
131 return eeh_check_failure(addr, val);
134 static inline void eeh_writeb(u8 val, volatile void __iomem *addr)
139 static inline u16 eeh_readw(const volatile void __iomem *addr)
141 u16 val = in_le16(addr);
142 if (EEH_POSSIBLE_ERROR(val, u16))
143 return eeh_check_failure(addr, val);
146 static inline void eeh_writew(u16 val, volatile void __iomem *addr)
150 static inline u16 eeh_raw_readw(const volatile void __iomem *addr)
152 u16 val = in_be16(addr);
153 if (EEH_POSSIBLE_ERROR(val, u16))
154 return eeh_check_failure(addr, val);
157 static inline void eeh_raw_writew(u16 val, volatile void __iomem *addr) {
158 volatile u16 __iomem *vaddr = (volatile u16 __iomem *) addr;
159 out_be16(vaddr, val);
162 static inline u32 eeh_readl(const volatile void __iomem *addr)
164 u32 val = in_le32(addr);
165 if (EEH_POSSIBLE_ERROR(val, u32))
166 return eeh_check_failure(addr, val);
169 static inline void eeh_writel(u32 val, volatile void __iomem *addr)
173 static inline u32 eeh_raw_readl(const volatile void __iomem *addr)
175 u32 val = in_be32(addr);
176 if (EEH_POSSIBLE_ERROR(val, u32))
177 return eeh_check_failure(addr, val);
180 static inline void eeh_raw_writel(u32 val, volatile void __iomem *addr)
185 static inline u64 eeh_readq(const volatile void __iomem *addr)
187 u64 val = in_le64(addr);
188 if (EEH_POSSIBLE_ERROR(val, u64))
189 return eeh_check_failure(addr, val);
192 static inline void eeh_writeq(u64 val, volatile void __iomem *addr)
196 static inline u64 eeh_raw_readq(const volatile void __iomem *addr)
198 u64 val = in_be64(addr);
199 if (EEH_POSSIBLE_ERROR(val, u64))
200 return eeh_check_failure(addr, val);
203 static inline void eeh_raw_writeq(u64 val, volatile void __iomem *addr)
208 #define EEH_CHECK_ALIGN(v,a) \
209 ((((unsigned long)(v)) & ((a) - 1)) == 0)
211 static inline void eeh_memset_io(volatile void __iomem *addr, int c,
214 void *p = (void __force *)addr;
219 while(n && !EEH_CHECK_ALIGN(p, 4)) {
220 *((volatile u8 *)p) = c;
225 *((volatile u32 *)p) = lc;
230 *((volatile u8 *)p) = c;
234 __asm__ __volatile__ ("sync" : : : "memory");
236 static inline void eeh_memcpy_fromio(void *dest, const volatile void __iomem *src,
239 void *vsrc = (void __force *) src;
240 void *destsave = dest;
241 unsigned long nsave = n;
243 while(n && (!EEH_CHECK_ALIGN(vsrc, 4) || !EEH_CHECK_ALIGN(dest, 4))) {
244 *((u8 *)dest) = *((volatile u8 *)vsrc);
245 __asm__ __volatile__ ("eieio" : : : "memory");
251 *((u32 *)dest) = *((volatile u32 *)vsrc);
252 __asm__ __volatile__ ("eieio" : : : "memory");
258 *((u8 *)dest) = *((volatile u8 *)vsrc);
259 __asm__ __volatile__ ("eieio" : : : "memory");
264 __asm__ __volatile__ ("sync" : : : "memory");
266 /* Look for ffff's here at dest[n]. Assume that at least 4 bytes
267 * were copied. Check all four bytes.
270 (EEH_POSSIBLE_ERROR((*((u32 *) destsave+nsave-4)), u32))) {
271 eeh_check_failure(src, (*((u32 *) destsave+nsave-4)));
275 static inline void eeh_memcpy_toio(volatile void __iomem *dest, const void *src,
278 void *vdest = (void __force *) dest;
280 while(n && (!EEH_CHECK_ALIGN(vdest, 4) || !EEH_CHECK_ALIGN(src, 4))) {
281 *((volatile u8 *)vdest) = *((u8 *)src);
287 *((volatile u32 *)vdest) = *((volatile u32 *)src);
293 *((volatile u8 *)vdest) = *((u8 *)src);
298 __asm__ __volatile__ ("sync" : : : "memory");
301 #undef EEH_CHECK_ALIGN
303 static inline u8 eeh_inb(unsigned long port)
306 if (!_IO_IS_VALID(port))
308 val = in_8((u8 __iomem *)(port+pci_io_base));
309 if (EEH_POSSIBLE_ERROR(val, u8))
310 return eeh_check_failure((void __iomem *)(port), val);
314 static inline void eeh_outb(u8 val, unsigned long port)
316 if (_IO_IS_VALID(port))
317 out_8((u8 __iomem *)(port+pci_io_base), val);
320 static inline u16 eeh_inw(unsigned long port)
323 if (!_IO_IS_VALID(port))
325 val = in_le16((u16 __iomem *)(port+pci_io_base));
326 if (EEH_POSSIBLE_ERROR(val, u16))
327 return eeh_check_failure((void __iomem *)(port), val);
331 static inline void eeh_outw(u16 val, unsigned long port)
333 if (_IO_IS_VALID(port))
334 out_le16((u16 __iomem *)(port+pci_io_base), val);
337 static inline u32 eeh_inl(unsigned long port)
340 if (!_IO_IS_VALID(port))
342 val = in_le32((u32 __iomem *)(port+pci_io_base));
343 if (EEH_POSSIBLE_ERROR(val, u32))
344 return eeh_check_failure((void __iomem *)(port), val);
348 static inline void eeh_outl(u32 val, unsigned long port)
350 if (_IO_IS_VALID(port))
351 out_le32((u32 __iomem *)(port+pci_io_base), val);
354 /* in-string eeh macros */
355 static inline void eeh_insb(unsigned long port, void * buf, int ns)
357 _insb((u8 __iomem *)(port+pci_io_base), buf, ns);
358 if (EEH_POSSIBLE_ERROR((*(((u8*)buf)+ns-1)), u8))
359 eeh_check_failure((void __iomem *)(port), *(u8*)buf);
362 static inline void eeh_insw_ns(unsigned long port, void * buf, int ns)
364 _insw_ns((u16 __iomem *)(port+pci_io_base), buf, ns);
365 if (EEH_POSSIBLE_ERROR((*(((u16*)buf)+ns-1)), u16))
366 eeh_check_failure((void __iomem *)(port), *(u16*)buf);
369 static inline void eeh_insl_ns(unsigned long port, void * buf, int nl)
371 _insl_ns((u32 __iomem *)(port+pci_io_base), buf, nl);
372 if (EEH_POSSIBLE_ERROR((*(((u32*)buf)+nl-1)), u32))
373 eeh_check_failure((void __iomem *)(port), *(u32*)buf);
376 #endif /* _PPC64_EEH_H */