aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/feature-removal-schedule.txt11
-rw-r--r--arch/sparc/kernel/errtbls.c144
-rw-r--r--arch/sparc/kernel/of_device.c27
-rw-r--r--arch/sparc/kernel/vmlinux.lds.S4
-rw-r--r--arch/sparc64/Kconfig4
-rw-r--r--arch/sparc64/kernel/iommu.c352
-rw-r--r--arch/sparc64/kernel/iommu_common.h33
-rw-r--r--arch/sparc64/kernel/kprobes.c113
-rw-r--r--arch/sparc64/kernel/of_device.c26
-rw-r--r--arch/sparc64/kernel/pci_sun4v.c278
-rw-r--r--include/asm-sparc/a.out.h31
-rw-r--r--include/asm-sparc/bpp.h2
-rw-r--r--include/asm-sparc/bsderrno.h94
-rw-r--r--include/asm-sparc/bug.h18
-rw-r--r--include/asm-sparc/bugs.h18
-rw-r--r--include/asm-sparc/byteorder.h51
-rw-r--r--include/asm-sparc/cache.h21
-rw-r--r--include/asm-sparc/current.h31
-rw-r--r--include/asm-sparc/device.h2
-rw-r--r--include/asm-sparc/errno.h1
-rw-r--r--include/asm-sparc/fb.h16
-rw-r--r--include/asm-sparc/of_platform.h5
-rw-r--r--include/asm-sparc/prom.h11
-rw-r--r--include/asm-sparc64/a.out.h99
-rw-r--r--include/asm-sparc64/auxvec.h5
-rw-r--r--include/asm-sparc64/bpp.h74
-rw-r--r--include/asm-sparc64/bsderrno.h94
-rw-r--r--include/asm-sparc64/bug.h23
-rw-r--r--include/asm-sparc64/bugs.h11
-rw-r--r--include/asm-sparc64/byteorder.h50
-rw-r--r--include/asm-sparc64/cache.h19
-rw-r--r--include/asm-sparc64/cputime.h7
-rw-r--r--include/asm-sparc64/current.h9
-rw-r--r--include/asm-sparc64/device.h22
-rw-r--r--include/asm-sparc64/div64.h2
-rw-r--r--include/asm-sparc64/emergency-restart.h7
-rw-r--r--include/asm-sparc64/errno.h115
-rw-r--r--include/asm-sparc64/fb.h28
-rw-r--r--include/asm-sparc64/io.h2
-rw-r--r--include/asm-sparc64/iommu.h1
-rw-r--r--include/asm-sparc64/kprobes.h4
-rw-r--r--include/asm-sparc64/of_device.h39
-rw-r--r--include/asm-sparc64/of_platform.h5
-rw-r--r--include/asm-sparc64/prom.h104
44 files changed, 689 insertions, 1324 deletions
diff --git a/Documentation/feature-removal-schedule.txt b/Documentation/feature-removal-schedule.txt
index ce9503c892b5..2039f47f2e65 100644
--- a/Documentation/feature-removal-schedule.txt
+++ b/Documentation/feature-removal-schedule.txt
@@ -304,3 +304,14 @@ Why: The support code for the old firmware hurts code readability/maintainabilit
304 and slightly hurts runtime performance. Bugfixes for the old firmware 304 and slightly hurts runtime performance. Bugfixes for the old firmware
305 are not provided by Broadcom anymore. 305 are not provided by Broadcom anymore.
306Who: Michael Buesch <mb@bu3sch.de> 306Who: Michael Buesch <mb@bu3sch.de>
307
308---------------------------
309
310What: Solaris/SunOS syscall and binary support on Sparc
311When: 2.6.26
312Why: Largely unmaintained and almost entirely unused. File system
313 layering used to divert library and dynamic linker searches to
314 /usr/gnemul is extremely buggy and unfixable. Making it work
315 is largely pointless as without a lot of work only the most
316 trivial of Solaris binaries can work with the emulation code.
317Who: David S. Miller <davem@davemloft.net>
diff --git a/arch/sparc/kernel/errtbls.c b/arch/sparc/kernel/errtbls.c
index bb36f6eadfee..ed14df7116e9 100644
--- a/arch/sparc/kernel/errtbls.c
+++ b/arch/sparc/kernel/errtbls.c
@@ -1,21 +1,18 @@
1/* $Id: errtbls.c,v 1.2 1995/11/25 00:57:55 davem Exp $ 1/* errtbls.c: Error number conversion tables.
2 * errtbls.c: Error number conversion tables between various syscall
3 * OS semantics.
4 * 2 *
5 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) 3 * Copyright (C) 1995, 2007 David S. Miller (davem@davemloft.net)
6 * 4 *
7 * Based upon preliminary work which is: 5 * Based upon preliminary work which is:
8 * 6 *
9 * Copyright (C) 1995 Adrian M. Rodriguez (adrian@remus.rutgers.edu) 7 * Copyright (C) 1995 Adrian M. Rodriguez (adrian@remus.rutgers.edu)
10 */ 8 */
11 9
12#include <asm/bsderrno.h> /* NetBSD (bsd4.4) errnos */
13#include <asm/solerrno.h> /* Solaris errnos */ 10#include <asm/solerrno.h> /* Solaris errnos */
14 11
15/* Here are tables which convert between Linux/SunOS error number 12/* Here is the table which converts between Linux error number values
16 * values to the equivalent in other OSs. Note that since the Linux 13 * to the equivalent under Solaris. Note that since the Linux ones
17 * ones have been set up to match exactly those of SunOS, no 14 * have been set up to match exactly those of SunOS, no translation
18 * translation table is needed for that OS. 15 * table is needed for that OS.
19 */ 16 */
20 17
21int solaris_errno[] = { 18int solaris_errno[] = {
@@ -145,132 +142,3 @@ int solaris_errno[] = {
145 SOL_ELIBMAX, 142 SOL_ELIBMAX,
146 SOL_ELIBSCN, 143 SOL_ELIBSCN,
147}; 144};
148
149int netbsd_errno[] = {
150 0,
151 BSD_EPERM,
152 BSD_ENOENT,
153 BSD_ESRCH,
154 BSD_EINTR,
155 BSD_EIO,
156 BSD_ENXIO,
157 BSD_E2BIG,
158 BSD_ENOEXEC,
159 BSD_EBADF,
160 BSD_ECHILD,
161 BSD_EAGAIN,
162 BSD_ENOMEM,
163 BSD_EACCES,
164 BSD_EFAULT,
165 BSD_NOTBLK,
166 BSD_EBUSY,
167 BSD_EEXIST,
168 BSD_EXDEV,
169 BSD_ENODEV,
170 BSD_ENOTDIR,
171 BSD_EISDIR,
172 BSD_EINVAL,
173 BSD_ENFILE,
174 BSD_EMFILE,
175 BSD_ENOTTY,
176 BSD_ETXTBSY,
177 BSD_EFBIG,
178 BSD_ENOSPC,
179 BSD_ESPIPE,
180 BSD_EROFS,
181 BSD_EMLINK,
182 BSD_EPIPE,
183 BSD_EDOM,
184 BSD_ERANGE,
185 BSD_EWOULDBLOCK,
186 BSD_EINPROGRESS,
187 BSD_EALREADY,
188 BSD_ENOTSOCK,
189 BSD_EDESTADDRREQ,
190 BSD_EMSGSIZE,
191 BSD_EPROTOTYPE,
192 BSD_ENOPROTOOPT,
193 BSD_EPROTONOSUPPORT,
194 BSD_ESOCKTNOSUPPORT,
195 BSD_EOPNOTSUPP,
196 BSD_EPFNOSUPPORT,
197 BSD_EAFNOSUPPORT,
198 BSD_EADDRINUSE,
199 BSD_EADDRNOTAVAIL,
200 BSD_ENETDOWN,
201 BSD_ENETUNREACH,
202 BSD_ENETRESET,
203 BSD_ECONNABORTED,
204 BSD_ECONNRESET,
205 BSD_ENOBUFS,
206 BSD_EISCONN,
207 BSD_ENOTONN,
208 BSD_ESHUTDOWN,
209 BSD_ETOOMANYREFS,
210 BSD_ETIMEDOUT,
211 BSD_ECONNREFUSED,
212 BSD_ELOOP,
213 BSD_ENAMETOOLONG,
214 BSD_EHOSTDOWN,
215 BSD_EHOSTUNREACH,
216 BSD_ENOTEMPTY,
217 BSD_EPROCLIM,
218 BSD_EUSERS,
219 BSD_EDQUOT,
220 BSD_ESTALE,
221 BSD_EREMOTE,
222 BSD_ENOSTR,
223 BSD_ETIME,
224 BSD_ENOSR,
225 BSD_ENOMSG,
226 BSD_EBADMSG,
227 BSD_IDRM,
228 BSD_EDEADLK,
229 BSD_ENOLCK,
230 BSD_ENONET,
231 BSD_ERREMOTE,
232 BSD_ENOLINK,
233 BSD_EADV,
234 BSD_ESRMNT,
235 BSD_ECOMM,
236 BSD_EPROTO,
237 BSD_EMULTIHOP,
238 BSD_EINVAL, /* EDOTDOT XXX??? */
239 BSD_REMCHG,
240 BSD_NOSYS,
241 BSD_STRPIPE,
242 BSD_EOVERFLOW,
243 BSD_EBADFD,
244 BSD_ECHRNG,
245 BSD_EL2NSYNC,
246 BSD_EL3HLT,
247 BSD_EL3RST,
248 BSD_NRNG,
249 BSD_EUNATCH,
250 BSD_ENOCSI,
251 BSD_EL2HLT,
252 BSD_EBADE,
253 BSD_EBADR,
254 BSD_EXFULL,
255 BSD_ENOANO,
256 BSD_EBADRQC,
257 BSD_EBADSLT,
258 BSD_EDEADLOCK,
259 BSD_EBFONT,
260 BSD_ELIBEXEC,
261 BSD_ENODATA,
262 BSD_ELIBBAD,
263 BSD_ENOPKG,
264 BSD_ELIBACC,
265 BSD_ENOTUNIQ,
266 BSD_ERESTART,
267 BSD_EUCLEAN,
268 BSD_ENOTNAM,
269 BSD_ENAVAIL,
270 BSD_EISNAM,
271 BSD_EREMOTEIO,
272 BSD_EILSEQ,
273 BSD_ELIBMAX,
274 BSD_ELIBSCN,
275};
276
diff --git a/arch/sparc/kernel/of_device.c b/arch/sparc/kernel/of_device.c
index 3ea000d15e3a..cc4c235c4f59 100644
--- a/arch/sparc/kernel/of_device.c
+++ b/arch/sparc/kernel/of_device.c
@@ -584,30 +584,3 @@ static int __init of_debug(char *str)
584} 584}
585 585
586__setup("of_debug=", of_debug); 586__setup("of_debug=", of_debug);
587
588struct of_device* of_platform_device_create(struct device_node *np,
589 const char *bus_id,
590 struct device *parent,
591 struct bus_type *bus)
592{
593 struct of_device *dev;
594
595 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
596 if (!dev)
597 return NULL;
598
599 dev->dev.parent = parent;
600 dev->dev.bus = bus;
601 dev->dev.release = of_release_dev;
602
603 strlcpy(dev->dev.bus_id, bus_id, BUS_ID_SIZE);
604
605 if (of_device_register(dev) != 0) {
606 kfree(dev);
607 return NULL;
608 }
609
610 return dev;
611}
612
613EXPORT_SYMBOL(of_platform_device_create);
diff --git a/arch/sparc/kernel/vmlinux.lds.S b/arch/sparc/kernel/vmlinux.lds.S
index 216147d6e61f..b1002c607196 100644
--- a/arch/sparc/kernel/vmlinux.lds.S
+++ b/arch/sparc/kernel/vmlinux.lds.S
@@ -89,6 +89,10 @@ SECTIONS
89 .data.cacheline_aligned : { 89 .data.cacheline_aligned : {
90 *(.data.cacheline_aligned) 90 *(.data.cacheline_aligned)
91 } 91 }
92 . = ALIGN(32);
93 .data.read_mostly : {
94 *(.data.read_mostly)
95 }
92 96
93 __bss_start = .; 97 __bss_start = .;
94 .sbss : { 98 .sbss : {
diff --git a/arch/sparc64/Kconfig b/arch/sparc64/Kconfig
index 810755637311..3af378ddb6ae 100644
--- a/arch/sparc64/Kconfig
+++ b/arch/sparc64/Kconfig
@@ -41,6 +41,10 @@ config MMU
41 bool 41 bool
42 default y 42 default y
43 43
44config IOMMU_HELPER
45 bool
46 default y
47
44config QUICKLIST 48config QUICKLIST
45 bool 49 bool
46 default y 50 default y
diff --git a/arch/sparc64/kernel/iommu.c b/arch/sparc64/kernel/iommu.c
index 5623a4d59dff..d3276ebcfb47 100644
--- a/arch/sparc64/kernel/iommu.c
+++ b/arch/sparc64/kernel/iommu.c
@@ -1,6 +1,6 @@
1/* iommu.c: Generic sparc64 IOMMU support. 1/* iommu.c: Generic sparc64 IOMMU support.
2 * 2 *
3 * Copyright (C) 1999, 2007 David S. Miller (davem@davemloft.net) 3 * Copyright (C) 1999, 2007, 2008 David S. Miller (davem@davemloft.net)
4 * Copyright (C) 1999, 2000 Jakub Jelinek (jakub@redhat.com) 4 * Copyright (C) 1999, 2000 Jakub Jelinek (jakub@redhat.com)
5 */ 5 */
6 6
@@ -10,6 +10,7 @@
10#include <linux/device.h> 10#include <linux/device.h>
11#include <linux/dma-mapping.h> 11#include <linux/dma-mapping.h>
12#include <linux/errno.h> 12#include <linux/errno.h>
13#include <linux/iommu-helper.h>
13 14
14#ifdef CONFIG_PCI 15#ifdef CONFIG_PCI
15#include <linux/pci.h> 16#include <linux/pci.h>
@@ -41,7 +42,7 @@
41 "i" (ASI_PHYS_BYPASS_EC_E)) 42 "i" (ASI_PHYS_BYPASS_EC_E))
42 43
43/* Must be invoked under the IOMMU lock. */ 44/* Must be invoked under the IOMMU lock. */
44static void __iommu_flushall(struct iommu *iommu) 45static void iommu_flushall(struct iommu *iommu)
45{ 46{
46 if (iommu->iommu_flushinv) { 47 if (iommu->iommu_flushinv) {
47 iommu_write(iommu->iommu_flushinv, ~(u64)0); 48 iommu_write(iommu->iommu_flushinv, ~(u64)0);
@@ -83,54 +84,91 @@ static inline void iopte_make_dummy(struct iommu *iommu, iopte_t *iopte)
83 iopte_val(*iopte) = val; 84 iopte_val(*iopte) = val;
84} 85}
85 86
86/* Based largely upon the ppc64 iommu allocator. */ 87/* Based almost entirely upon the ppc64 iommu allocator. If you use the 'handle'
87static long arena_alloc(struct iommu *iommu, unsigned long npages) 88 * facility it must all be done in one pass while under the iommu lock.
89 *
90 * On sun4u platforms, we only flush the IOMMU once every time we've passed
91 * over the entire page table doing allocations. Therefore we only ever advance
92 * the hint and cannot backtrack it.
93 */
94unsigned long iommu_range_alloc(struct device *dev,
95 struct iommu *iommu,
96 unsigned long npages,
97 unsigned long *handle)
88{ 98{
99 unsigned long n, end, start, limit, boundary_size;
89 struct iommu_arena *arena = &iommu->arena; 100 struct iommu_arena *arena = &iommu->arena;
90 unsigned long n, i, start, end, limit; 101 int pass = 0;
91 int pass; 102
103 /* This allocator was derived from x86_64's bit string search */
104
105 /* Sanity check */
106 if (unlikely(npages == 0)) {
107 if (printk_ratelimit())
108 WARN_ON(1);
109 return DMA_ERROR_CODE;
110 }
111
112 if (handle && *handle)
113 start = *handle;
114 else
115 start = arena->hint;
92 116
93 limit = arena->limit; 117 limit = arena->limit;
94 start = arena->hint;
95 pass = 0;
96 118
97again: 119 /* The case below can happen if we have a small segment appended
98 n = find_next_zero_bit(arena->map, limit, start); 120 * to a large, or when the previous alloc was at the very end of
99 end = n + npages; 121 * the available space. If so, go back to the beginning and flush.
100 if (unlikely(end >= limit)) { 122 */
123 if (start >= limit) {
124 start = 0;
125 if (iommu->flush_all)
126 iommu->flush_all(iommu);
127 }
128
129 again:
130
131 if (dev)
132 boundary_size = ALIGN(dma_get_seg_boundary(dev) + 1,
133 1 << IO_PAGE_SHIFT);
134 else
135 boundary_size = ALIGN(1UL << 32, 1 << IO_PAGE_SHIFT);
136
137 n = iommu_area_alloc(arena->map, limit, start, npages, 0,
138 boundary_size >> IO_PAGE_SHIFT, 0);
139 if (n == -1) {
101 if (likely(pass < 1)) { 140 if (likely(pass < 1)) {
102 limit = start; 141 /* First failure, rescan from the beginning. */
103 start = 0; 142 start = 0;
104 __iommu_flushall(iommu); 143 if (iommu->flush_all)
144 iommu->flush_all(iommu);
105 pass++; 145 pass++;
106 goto again; 146 goto again;
107 } else { 147 } else {
108 /* Scanned the whole thing, give up. */ 148 /* Second failure, give up */
109 return -1; 149 return DMA_ERROR_CODE;
110 }
111 }
112
113 for (i = n; i < end; i++) {
114 if (test_bit(i, arena->map)) {
115 start = i + 1;
116 goto again;
117 } 150 }
118 } 151 }
119 152
120 for (i = n; i < end; i++) 153 end = n + npages;
121 __set_bit(i, arena->map);
122 154
123 arena->hint = end; 155 arena->hint = end;
124 156
157 /* Update handle for SG allocations */
158 if (handle)
159 *handle = end;
160
125 return n; 161 return n;
126} 162}
127 163
128static void arena_free(struct iommu_arena *arena, unsigned long base, unsigned long npages) 164void iommu_range_free(struct iommu *iommu, dma_addr_t dma_addr, unsigned long npages)
129{ 165{
130 unsigned long i; 166 struct iommu_arena *arena = &iommu->arena;
167 unsigned long entry;
131 168
132 for (i = base; i < (base + npages); i++) 169 entry = (dma_addr - iommu->page_table_map_base) >> IO_PAGE_SHIFT;
133 __clear_bit(i, arena->map); 170
171 iommu_area_free(arena->map, entry, npages);
134} 172}
135 173
136int iommu_table_init(struct iommu *iommu, int tsbsize, 174int iommu_table_init(struct iommu *iommu, int tsbsize,
@@ -156,6 +194,9 @@ int iommu_table_init(struct iommu *iommu, int tsbsize,
156 } 194 }
157 iommu->arena.limit = num_tsb_entries; 195 iommu->arena.limit = num_tsb_entries;
158 196
197 if (tlb_type != hypervisor)
198 iommu->flush_all = iommu_flushall;
199
159 /* Allocate and initialize the dummy page which we 200 /* Allocate and initialize the dummy page which we
160 * set inactive IO PTEs to point to. 201 * set inactive IO PTEs to point to.
161 */ 202 */
@@ -192,22 +233,18 @@ out_free_map:
192 return -ENOMEM; 233 return -ENOMEM;
193} 234}
194 235
195static inline iopte_t *alloc_npages(struct iommu *iommu, unsigned long npages) 236static inline iopte_t *alloc_npages(struct device *dev, struct iommu *iommu,
237 unsigned long npages)
196{ 238{
197 long entry; 239 unsigned long entry;
198 240
199 entry = arena_alloc(iommu, npages); 241 entry = iommu_range_alloc(dev, iommu, npages, NULL);
200 if (unlikely(entry < 0)) 242 if (unlikely(entry == DMA_ERROR_CODE))
201 return NULL; 243 return NULL;
202 244
203 return iommu->page_table + entry; 245 return iommu->page_table + entry;
204} 246}
205 247
206static inline void free_npages(struct iommu *iommu, dma_addr_t base, unsigned long npages)
207{
208 arena_free(&iommu->arena, base >> IO_PAGE_SHIFT, npages);
209}
210
211static int iommu_alloc_ctx(struct iommu *iommu) 248static int iommu_alloc_ctx(struct iommu *iommu)
212{ 249{
213 int lowest = iommu->ctx_lowest_free; 250 int lowest = iommu->ctx_lowest_free;
@@ -258,7 +295,7 @@ static void *dma_4u_alloc_coherent(struct device *dev, size_t size,
258 iommu = dev->archdata.iommu; 295 iommu = dev->archdata.iommu;
259 296
260 spin_lock_irqsave(&iommu->lock, flags); 297 spin_lock_irqsave(&iommu->lock, flags);
261 iopte = alloc_npages(iommu, size >> IO_PAGE_SHIFT); 298 iopte = alloc_npages(dev, iommu, size >> IO_PAGE_SHIFT);
262 spin_unlock_irqrestore(&iommu->lock, flags); 299 spin_unlock_irqrestore(&iommu->lock, flags);
263 300
264 if (unlikely(iopte == NULL)) { 301 if (unlikely(iopte == NULL)) {
@@ -296,7 +333,7 @@ static void dma_4u_free_coherent(struct device *dev, size_t size,
296 333
297 spin_lock_irqsave(&iommu->lock, flags); 334 spin_lock_irqsave(&iommu->lock, flags);
298 335
299 free_npages(iommu, dvma - iommu->page_table_map_base, npages); 336 iommu_range_free(iommu, dvma, npages);
300 337
301 spin_unlock_irqrestore(&iommu->lock, flags); 338 spin_unlock_irqrestore(&iommu->lock, flags);
302 339
@@ -327,7 +364,7 @@ static dma_addr_t dma_4u_map_single(struct device *dev, void *ptr, size_t sz,
327 npages >>= IO_PAGE_SHIFT; 364 npages >>= IO_PAGE_SHIFT;
328 365
329 spin_lock_irqsave(&iommu->lock, flags); 366 spin_lock_irqsave(&iommu->lock, flags);
330 base = alloc_npages(iommu, npages); 367 base = alloc_npages(dev, iommu, npages);
331 ctx = 0; 368 ctx = 0;
332 if (iommu->iommu_ctxflush) 369 if (iommu->iommu_ctxflush)
333 ctx = iommu_alloc_ctx(iommu); 370 ctx = iommu_alloc_ctx(iommu);
@@ -465,7 +502,7 @@ static void dma_4u_unmap_single(struct device *dev, dma_addr_t bus_addr,
465 for (i = 0; i < npages; i++) 502 for (i = 0; i < npages; i++)
466 iopte_make_dummy(iommu, base + i); 503 iopte_make_dummy(iommu, base + i);
467 504
468 free_npages(iommu, bus_addr - iommu->page_table_map_base, npages); 505 iommu_range_free(iommu, bus_addr, npages);
469 506
470 iommu_free_ctx(iommu, ctx); 507 iommu_free_ctx(iommu, ctx);
471 508
@@ -475,124 +512,209 @@ static void dma_4u_unmap_single(struct device *dev, dma_addr_t bus_addr,
475static int dma_4u_map_sg(struct device *dev, struct scatterlist *sglist, 512static int dma_4u_map_sg(struct device *dev, struct scatterlist *sglist,
476 int nelems, enum dma_data_direction direction) 513 int nelems, enum dma_data_direction direction)
477{ 514{
478 unsigned long flags, ctx, i, npages, iopte_protection; 515 struct scatterlist *s, *outs, *segstart;
479 struct scatterlist *sg; 516 unsigned long flags, handle, prot, ctx;
517 dma_addr_t dma_next = 0, dma_addr;
518 unsigned int max_seg_size;
519 int outcount, incount, i;
480 struct strbuf *strbuf; 520 struct strbuf *strbuf;
481 struct iommu *iommu; 521 struct iommu *iommu;
482 iopte_t *base; 522
483 u32 dma_base; 523 BUG_ON(direction == DMA_NONE);
484
485 /* Fast path single entry scatterlists. */
486 if (nelems == 1) {
487 sglist->dma_address =
488 dma_4u_map_single(dev, sg_virt(sglist),
489 sglist->length, direction);
490 if (unlikely(sglist->dma_address == DMA_ERROR_CODE))
491 return 0;
492 sglist->dma_length = sglist->length;
493 return 1;
494 }
495 524
496 iommu = dev->archdata.iommu; 525 iommu = dev->archdata.iommu;
497 strbuf = dev->archdata.stc; 526 strbuf = dev->archdata.stc;
498 527 if (nelems == 0 || !iommu)
499 if (unlikely(direction == DMA_NONE)) 528 return 0;
500 goto bad_no_ctx;
501
502 npages = calc_npages(sglist, nelems);
503 529
504 spin_lock_irqsave(&iommu->lock, flags); 530 spin_lock_irqsave(&iommu->lock, flags);
505 531
506 base = alloc_npages(iommu, npages);
507 ctx = 0; 532 ctx = 0;
508 if (iommu->iommu_ctxflush) 533 if (iommu->iommu_ctxflush)
509 ctx = iommu_alloc_ctx(iommu); 534 ctx = iommu_alloc_ctx(iommu);
510 535
511 spin_unlock_irqrestore(&iommu->lock, flags);
512
513 if (base == NULL)
514 goto bad;
515
516 dma_base = iommu->page_table_map_base +
517 ((base - iommu->page_table) << IO_PAGE_SHIFT);
518
519 if (strbuf->strbuf_enabled) 536 if (strbuf->strbuf_enabled)
520 iopte_protection = IOPTE_STREAMING(ctx); 537 prot = IOPTE_STREAMING(ctx);
521 else 538 else
522 iopte_protection = IOPTE_CONSISTENT(ctx); 539 prot = IOPTE_CONSISTENT(ctx);
523 if (direction != DMA_TO_DEVICE) 540 if (direction != DMA_TO_DEVICE)
524 iopte_protection |= IOPTE_WRITE; 541 prot |= IOPTE_WRITE;
525 542
526 for_each_sg(sglist, sg, nelems, i) { 543 outs = s = segstart = &sglist[0];
527 unsigned long paddr = SG_ENT_PHYS_ADDRESS(sg); 544 outcount = 1;
528 unsigned long slen = sg->length; 545 incount = nelems;
529 unsigned long this_npages; 546 handle = 0;
547
548 /* Init first segment length for backout at failure */
549 outs->dma_length = 0;
550
551 max_seg_size = dma_get_max_seg_size(dev);
552 for_each_sg(sglist, s, nelems, i) {
553 unsigned long paddr, npages, entry, slen;
554 iopte_t *base;
555
556 slen = s->length;
557 /* Sanity check */
558 if (slen == 0) {
559 dma_next = 0;
560 continue;
561 }
562 /* Allocate iommu entries for that segment */
563 paddr = (unsigned long) SG_ENT_PHYS_ADDRESS(s);
564 npages = iommu_num_pages(paddr, slen);
565 entry = iommu_range_alloc(dev, iommu, npages, &handle);
566
567 /* Handle failure */
568 if (unlikely(entry == DMA_ERROR_CODE)) {
569 if (printk_ratelimit())
570 printk(KERN_INFO "iommu_alloc failed, iommu %p paddr %lx"
571 " npages %lx\n", iommu, paddr, npages);
572 goto iommu_map_failed;
573 }
530 574
531 this_npages = iommu_num_pages(paddr, slen); 575 base = iommu->page_table + entry;
532 576
533 sg->dma_address = dma_base | (paddr & ~IO_PAGE_MASK); 577 /* Convert entry to a dma_addr_t */
534 sg->dma_length = slen; 578 dma_addr = iommu->page_table_map_base +
579 (entry << IO_PAGE_SHIFT);
580 dma_addr |= (s->offset & ~IO_PAGE_MASK);
535 581
582 /* Insert into HW table */
536 paddr &= IO_PAGE_MASK; 583 paddr &= IO_PAGE_MASK;
537 while (this_npages--) { 584 while (npages--) {
538 iopte_val(*base) = iopte_protection | paddr; 585 iopte_val(*base) = prot | paddr;
539
540 base++; 586 base++;
541 paddr += IO_PAGE_SIZE; 587 paddr += IO_PAGE_SIZE;
542 dma_base += IO_PAGE_SIZE;
543 } 588 }
589
590 /* If we are in an open segment, try merging */
591 if (segstart != s) {
592 /* We cannot merge if:
593 * - allocated dma_addr isn't contiguous to previous allocation
594 */
595 if ((dma_addr != dma_next) ||
596 (outs->dma_length + s->length > max_seg_size)) {
597 /* Can't merge: create a new segment */
598 segstart = s;
599 outcount++;
600 outs = sg_next(outs);
601 } else {
602 outs->dma_length += s->length;
603 }
604 }
605
606 if (segstart == s) {
607 /* This is a new segment, fill entries */
608 outs->dma_address = dma_addr;
609 outs->dma_length = slen;
610 }
611
612 /* Calculate next page pointer for contiguous check */
613 dma_next = dma_addr + slen;
544 } 614 }
545 615
546 return nelems; 616 spin_unlock_irqrestore(&iommu->lock, flags);
617
618 if (outcount < incount) {
619 outs = sg_next(outs);
620 outs->dma_address = DMA_ERROR_CODE;
621 outs->dma_length = 0;
622 }
623
624 return outcount;
625
626iommu_map_failed:
627 for_each_sg(sglist, s, nelems, i) {
628 if (s->dma_length != 0) {
629 unsigned long vaddr, npages, entry, i;
630 iopte_t *base;
631
632 vaddr = s->dma_address & IO_PAGE_MASK;
633 npages = iommu_num_pages(s->dma_address, s->dma_length);
634 iommu_range_free(iommu, vaddr, npages);
635
636 entry = (vaddr - iommu->page_table_map_base)
637 >> IO_PAGE_SHIFT;
638 base = iommu->page_table + entry;
639
640 for (i = 0; i < npages; i++)
641 iopte_make_dummy(iommu, base + i);
642
643 s->dma_address = DMA_ERROR_CODE;
644 s->dma_length = 0;
645 }
646 if (s == outs)
647 break;
648 }
649 spin_unlock_irqrestore(&iommu->lock, flags);
547 650
548bad:
549 iommu_free_ctx(iommu, ctx);
550bad_no_ctx:
551 if (printk_ratelimit())
552 WARN_ON(1);
553 return 0; 651 return 0;
554} 652}
555 653
654/* If contexts are being used, they are the same in all of the mappings
655 * we make for a particular SG.
656 */
657static unsigned long fetch_sg_ctx(struct iommu *iommu, struct scatterlist *sg)
658{
659 unsigned long ctx = 0;
660
661 if (iommu->iommu_ctxflush) {
662 iopte_t *base;
663 u32 bus_addr;
664
665 bus_addr = sg->dma_address & IO_PAGE_MASK;
666 base = iommu->page_table +
667 ((bus_addr - iommu->page_table_map_base) >> IO_PAGE_SHIFT);
668
669 ctx = (iopte_val(*base) & IOPTE_CONTEXT) >> 47UL;
670 }
671 return ctx;
672}
673
556static void dma_4u_unmap_sg(struct device *dev, struct scatterlist *sglist, 674static void dma_4u_unmap_sg(struct device *dev, struct scatterlist *sglist,
557 int nelems, enum dma_data_direction direction) 675 int nelems, enum dma_data_direction direction)
558{ 676{
559 unsigned long flags, ctx, i, npages; 677 unsigned long flags, ctx;
678 struct scatterlist *sg;
560 struct strbuf *strbuf; 679 struct strbuf *strbuf;
561 struct iommu *iommu; 680 struct iommu *iommu;
562 iopte_t *base;
563 u32 bus_addr;
564 681
565 if (unlikely(direction == DMA_NONE)) { 682 BUG_ON(direction == DMA_NONE);
566 if (printk_ratelimit())
567 WARN_ON(1);
568 }
569 683
570 iommu = dev->archdata.iommu; 684 iommu = dev->archdata.iommu;
571 strbuf = dev->archdata.stc; 685 strbuf = dev->archdata.stc;
572 686
573 bus_addr = sglist->dma_address & IO_PAGE_MASK; 687 ctx = fetch_sg_ctx(iommu, sglist);
574 688
575 npages = calc_npages(sglist, nelems); 689 spin_lock_irqsave(&iommu->lock, flags);
576 690
577 base = iommu->page_table + 691 sg = sglist;
578 ((bus_addr - iommu->page_table_map_base) >> IO_PAGE_SHIFT); 692 while (nelems--) {
693 dma_addr_t dma_handle = sg->dma_address;
694 unsigned int len = sg->dma_length;
695 unsigned long npages, entry;
696 iopte_t *base;
697 int i;
579 698
580 spin_lock_irqsave(&iommu->lock, flags); 699 if (!len)
700 break;
701 npages = iommu_num_pages(dma_handle, len);
702 iommu_range_free(iommu, dma_handle, npages);
581 703
582 /* Record the context, if any. */ 704 entry = ((dma_handle - iommu->page_table_map_base)
583 ctx = 0; 705 >> IO_PAGE_SHIFT);
584 if (iommu->iommu_ctxflush) 706 base = iommu->page_table + entry;
585 ctx = (iopte_val(*base) & IOPTE_CONTEXT) >> 47UL;
586 707
587 /* Step 1: Kick data out of streaming buffers if necessary. */ 708 dma_handle &= IO_PAGE_MASK;
588 if (strbuf->strbuf_enabled) 709 if (strbuf->strbuf_enabled)
589 strbuf_flush(strbuf, iommu, bus_addr, ctx, npages, direction); 710 strbuf_flush(strbuf, iommu, dma_handle, ctx,
711 npages, direction);
590 712
591 /* Step 2: Clear out the TSB entries. */ 713 for (i = 0; i < npages; i++)
592 for (i = 0; i < npages; i++) 714 iopte_make_dummy(iommu, base + i);
593 iopte_make_dummy(iommu, base + i);
594 715
595 free_npages(iommu, bus_addr - iommu->page_table_map_base, npages); 716 sg = sg_next(sg);
717 }
596 718
597 iommu_free_ctx(iommu, ctx); 719 iommu_free_ctx(iommu, ctx);
598 720
diff --git a/arch/sparc64/kernel/iommu_common.h b/arch/sparc64/kernel/iommu_common.h
index 4b5cafa2877a..0713bd58499c 100644
--- a/arch/sparc64/kernel/iommu_common.h
+++ b/arch/sparc64/kernel/iommu_common.h
@@ -1,9 +1,11 @@
1/* $Id: iommu_common.h,v 1.5 2001/12/11 09:41:01 davem Exp $ 1/* iommu_common.h: UltraSparc SBUS/PCI common iommu declarations.
2 * iommu_common.h: UltraSparc SBUS/PCI common iommu declarations.
3 * 2 *
4 * Copyright (C) 1999 David S. Miller (davem@redhat.com) 3 * Copyright (C) 1999, 2008 David S. Miller (davem@davemloft.net)
5 */ 4 */
6 5
6#ifndef _IOMMU_COMMON_H
7#define _IOMMU_COMMON_H
8
7#include <linux/kernel.h> 9#include <linux/kernel.h>
8#include <linux/types.h> 10#include <linux/types.h>
9#include <linux/sched.h> 11#include <linux/sched.h>
@@ -56,21 +58,12 @@ static inline unsigned long calc_npages(struct scatterlist *sglist, int nelems)
56 return npages; 58 return npages;
57} 59}
58 60
59/* You are _strongly_ advised to enable the following debugging code 61extern unsigned long iommu_range_alloc(struct device *dev,
60 * any time you make changes to the sg code below, run it for a while 62 struct iommu *iommu,
61 * with filesystems mounted read-only before buying the farm... -DaveM 63 unsigned long npages,
62 */ 64 unsigned long *handle);
63#undef VERIFY_SG 65extern void iommu_range_free(struct iommu *iommu,
64 66 dma_addr_t dma_addr,
65#ifdef VERIFY_SG 67 unsigned long npages);
66extern void verify_sglist(struct scatterlist *sg, int nents, iopte_t *iopte, int npages);
67#endif
68
69/* Two addresses are "virtually contiguous" if and only if:
70 * 1) They are equal, or...
71 * 2) They are both on a page boundary
72 */
73#define VCONTIG(__X, __Y) (((__X) == (__Y)) || \
74 (((__X) | (__Y)) << (64UL - PAGE_SHIFT)) == 0UL)
75 68
76extern unsigned long prepare_sg(struct device *dev, struct scatterlist *sg, int nents); 69#endif /* _IOMMU_COMMON_H */
diff --git a/arch/sparc64/kernel/kprobes.c b/arch/sparc64/kernel/kprobes.c
index d94f901d321e..34fc3ddd5002 100644
--- a/arch/sparc64/kernel/kprobes.c
+++ b/arch/sparc64/kernel/kprobes.c
@@ -480,8 +480,117 @@ int __kprobes longjmp_break_handler(struct kprobe *p, struct pt_regs *regs)
480 return 0; 480 return 0;
481} 481}
482 482
483/* architecture specific initialization */ 483/* Called with kretprobe_lock held. The value stored in the return
484int arch_init_kprobes(void) 484 * address register is actually 2 instructions before where the
485 * callee will return to. Sequences usually look something like this
486 *
487 * call some_function <--- return register points here
488 * nop <--- call delay slot
489 * whatever <--- where callee returns to
490 *
491 * To keep trampoline_probe_handler logic simpler, we normalize the
492 * value kept in ri->ret_addr so we don't need to keep adjusting it
493 * back and forth.
494 */
495void __kprobes arch_prepare_kretprobe(struct kretprobe_instance *ri,
496 struct pt_regs *regs)
497{
498 ri->ret_addr = (kprobe_opcode_t *)(regs->u_regs[UREG_RETPC] + 8);
499
500 /* Replace the return addr with trampoline addr */
501 regs->u_regs[UREG_RETPC] =
502 ((unsigned long)kretprobe_trampoline) - 8;
503}
504
505/*
506 * Called when the probe at kretprobe trampoline is hit
507 */
508int __kprobes trampoline_probe_handler(struct kprobe *p, struct pt_regs *regs)
509{
510 struct kretprobe_instance *ri = NULL;
511 struct hlist_head *head, empty_rp;
512 struct hlist_node *node, *tmp;
513 unsigned long flags, orig_ret_address = 0;
514 unsigned long trampoline_address =(unsigned long)&kretprobe_trampoline;
515
516 INIT_HLIST_HEAD(&empty_rp);
517 spin_lock_irqsave(&kretprobe_lock, flags);
518 head = kretprobe_inst_table_head(current);
519
520 /*
521 * It is possible to have multiple instances associated with a given
522 * task either because an multiple functions in the call path
523 * have a return probe installed on them, and/or more then one return
524 * return probe was registered for a target function.
525 *
526 * We can handle this because:
527 * - instances are always inserted at the head of the list
528 * - when multiple return probes are registered for the same
529 * function, the first instance's ret_addr will point to the
530 * real return address, and all the rest will point to
531 * kretprobe_trampoline
532 */
533 hlist_for_each_entry_safe(ri, node, tmp, head, hlist) {
534 if (ri->task != current)
535 /* another task is sharing our hash bucket */
536 continue;
537
538 if (ri->rp && ri->rp->handler)
539 ri->rp->handler(ri, regs);
540
541 orig_ret_address = (unsigned long)ri->ret_addr;
542 recycle_rp_inst(ri, &empty_rp);
543
544 if (orig_ret_address != trampoline_address)
545 /*
546 * This is the real return address. Any other
547 * instances associated with this task are for
548 * other calls deeper on the call stack
549 */
550 break;
551 }
552
553 kretprobe_assert(ri, orig_ret_address, trampoline_address);
554 regs->tpc = orig_ret_address;
555 regs->tnpc = orig_ret_address + 4;
556
557 reset_current_kprobe();
558 spin_unlock_irqrestore(&kretprobe_lock, flags);
559 preempt_enable_no_resched();
560
561 hlist_for_each_entry_safe(ri, node, tmp, &empty_rp, hlist) {
562 hlist_del(&ri->hlist);
563 kfree(ri);
564 }
565 /*
566 * By returning a non-zero value, we are telling
567 * kprobe_handler() that we don't want the post_handler
568 * to run (and have re-enabled preemption)
569 */
570 return 1;
571}
572
573void kretprobe_trampoline_holder(void)
574{
575 asm volatile(".global kretprobe_trampoline\n"
576 "kretprobe_trampoline:\n"
577 "\tnop\n"
578 "\tnop\n");
579}
580static struct kprobe trampoline_p = {
581 .addr = (kprobe_opcode_t *) &kretprobe_trampoline,
582 .pre_handler = trampoline_probe_handler
583};
584
585int __init arch_init_kprobes(void)
485{ 586{
587 return register_kprobe(&trampoline_p);
588}
589
590int __kprobes arch_trampoline_kprobe(struct kprobe *p)
591{
592 if (p->addr == (kprobe_opcode_t *)&kretprobe_trampoline)
593 return 1;
594
486 return 0; 595 return 0;
487} 596}
diff --git a/arch/sparc64/kernel/of_device.c b/arch/sparc64/kernel/of_device.c
index fc5c0cc793b8..0fd9db95b896 100644
--- a/arch/sparc64/kernel/of_device.c
+++ b/arch/sparc64/kernel/of_device.c
@@ -868,29 +868,3 @@ static int __init of_debug(char *str)
868} 868}
869 869
870__setup("of_debug=", of_debug); 870__setup("of_debug=", of_debug);
871
872struct of_device* of_platform_device_create(struct device_node *np,
873 const char *bus_id,
874 struct device *parent,
875 struct bus_type *bus)
876{
877 struct of_device *dev;
878
879 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
880 if (!dev)
881 return NULL;
882
883 dev->dev.parent = parent;
884 dev->dev.bus = bus;
885 dev->dev.release = of_release_dev;
886
887 strlcpy(dev->dev.bus_id, bus_id, BUS_ID_SIZE);
888
889 if (of_device_register(dev) != 0) {
890 kfree(dev);
891 return NULL;
892 }
893
894 return dev;
895}
896EXPORT_SYMBOL(of_platform_device_create);
diff --git a/arch/sparc64/kernel/pci_sun4v.c b/arch/sparc64/kernel/pci_sun4v.c
index 61baf8dc095e..ddca6c6c0b49 100644
--- a/arch/sparc64/kernel/pci_sun4v.c
+++ b/arch/sparc64/kernel/pci_sun4v.c
@@ -1,6 +1,6 @@
1/* pci_sun4v.c: SUN4V specific PCI controller support. 1/* pci_sun4v.c: SUN4V specific PCI controller support.
2 * 2 *
3 * Copyright (C) 2006, 2007 David S. Miller (davem@davemloft.net) 3 * Copyright (C) 2006, 2007, 2008 David S. Miller (davem@davemloft.net)
4 */ 4 */
5 5
6#include <linux/kernel.h> 6#include <linux/kernel.h>
@@ -89,6 +89,17 @@ static long iommu_batch_flush(struct iommu_batch *p)
89 return 0; 89 return 0;
90} 90}
91 91
92static inline void iommu_batch_new_entry(unsigned long entry)
93{
94 struct iommu_batch *p = &__get_cpu_var(iommu_batch);
95
96 if (p->entry + p->npages == entry)
97 return;
98 if (p->entry != ~0UL)
99 iommu_batch_flush(p);
100 p->entry = entry;
101}
102
92/* Interrupts must be disabled. */ 103/* Interrupts must be disabled. */
93static inline long iommu_batch_add(u64 phys_page) 104static inline long iommu_batch_add(u64 phys_page)
94{ 105{
@@ -113,54 +124,6 @@ static inline long iommu_batch_end(void)
113 return iommu_batch_flush(p); 124 return iommu_batch_flush(p);
114} 125}
115 126
116static long arena_alloc(struct iommu_arena *arena, unsigned long npages)
117{
118 unsigned long n, i, start, end, limit;
119 int pass;
120
121 limit = arena->limit;
122 start = arena->hint;
123 pass = 0;
124
125again:
126 n = find_next_zero_bit(arena->map, limit, start);
127 end = n + npages;
128 if (unlikely(end >= limit)) {
129 if (likely(pass < 1)) {
130 limit = start;
131 start = 0;
132 pass++;
133 goto again;
134 } else {
135 /* Scanned the whole thing, give up. */
136 return -1;
137 }
138 }
139
140 for (i = n; i < end; i++) {
141 if (test_bit(i, arena->map)) {
142 start = i + 1;
143 goto again;
144 }
145 }
146
147 for (i = n; i < end; i++)
148 __set_bit(i, arena->map);
149
150 arena->hint = end;
151
152 return n;
153}
154
155static void arena_free(struct iommu_arena *arena, unsigned long base,
156 unsigned long npages)
157{
158 unsigned long i;
159
160 for (i = base; i < (base + npages); i++)
161 __clear_bit(i, arena->map);
162}
163
164static void *dma_4v_alloc_coherent(struct device *dev, size_t size, 127static void *dma_4v_alloc_coherent(struct device *dev, size_t size,
165 dma_addr_t *dma_addrp, gfp_t gfp) 128 dma_addr_t *dma_addrp, gfp_t gfp)
166{ 129{
@@ -185,11 +148,11 @@ static void *dma_4v_alloc_coherent(struct device *dev, size_t size,
185 iommu = dev->archdata.iommu; 148 iommu = dev->archdata.iommu;
186 149
187 spin_lock_irqsave(&iommu->lock, flags); 150 spin_lock_irqsave(&iommu->lock, flags);
188 entry = arena_alloc(&iommu->arena, npages); 151 entry = iommu_range_alloc(dev, iommu, npages, NULL);
189 spin_unlock_irqrestore(&iommu->lock, flags); 152 spin_unlock_irqrestore(&iommu->lock, flags);
190 153
191 if (unlikely(entry < 0L)) 154 if (unlikely(entry == DMA_ERROR_CODE))
192 goto arena_alloc_fail; 155 goto range_alloc_fail;
193 156
194 *dma_addrp = (iommu->page_table_map_base + 157 *dma_addrp = (iommu->page_table_map_base +
195 (entry << IO_PAGE_SHIFT)); 158 (entry << IO_PAGE_SHIFT));
@@ -219,10 +182,10 @@ static void *dma_4v_alloc_coherent(struct device *dev, size_t size,
219iommu_map_fail: 182iommu_map_fail:
220 /* Interrupts are disabled. */ 183 /* Interrupts are disabled. */
221 spin_lock(&iommu->lock); 184 spin_lock(&iommu->lock);
222 arena_free(&iommu->arena, entry, npages); 185 iommu_range_free(iommu, *dma_addrp, npages);
223 spin_unlock_irqrestore(&iommu->lock, flags); 186 spin_unlock_irqrestore(&iommu->lock, flags);
224 187
225arena_alloc_fail: 188range_alloc_fail:
226 free_pages(first_page, order); 189 free_pages(first_page, order);
227 return NULL; 190 return NULL;
228} 191}
@@ -243,7 +206,7 @@ static void dma_4v_free_coherent(struct device *dev, size_t size, void *cpu,
243 206
244 spin_lock_irqsave(&iommu->lock, flags); 207 spin_lock_irqsave(&iommu->lock, flags);
245 208
246 arena_free(&iommu->arena, entry, npages); 209 iommu_range_free(iommu, dvma, npages);
247 210
248 do { 211 do {
249 unsigned long num; 212 unsigned long num;
@@ -281,10 +244,10 @@ static dma_addr_t dma_4v_map_single(struct device *dev, void *ptr, size_t sz,
281 npages >>= IO_PAGE_SHIFT; 244 npages >>= IO_PAGE_SHIFT;
282 245
283 spin_lock_irqsave(&iommu->lock, flags); 246 spin_lock_irqsave(&iommu->lock, flags);
284 entry = arena_alloc(&iommu->arena, npages); 247 entry = iommu_range_alloc(dev, iommu, npages, NULL);
285 spin_unlock_irqrestore(&iommu->lock, flags); 248 spin_unlock_irqrestore(&iommu->lock, flags);
286 249
287 if (unlikely(entry < 0L)) 250 if (unlikely(entry == DMA_ERROR_CODE))
288 goto bad; 251 goto bad;
289 252
290 bus_addr = (iommu->page_table_map_base + 253 bus_addr = (iommu->page_table_map_base +
@@ -319,7 +282,7 @@ bad:
319iommu_map_fail: 282iommu_map_fail:
320 /* Interrupts are disabled. */ 283 /* Interrupts are disabled. */
321 spin_lock(&iommu->lock); 284 spin_lock(&iommu->lock);
322 arena_free(&iommu->arena, entry, npages); 285 iommu_range_free(iommu, bus_addr, npages);
323 spin_unlock_irqrestore(&iommu->lock, flags); 286 spin_unlock_irqrestore(&iommu->lock, flags);
324 287
325 return DMA_ERROR_CODE; 288 return DMA_ERROR_CODE;
@@ -350,9 +313,9 @@ static void dma_4v_unmap_single(struct device *dev, dma_addr_t bus_addr,
350 313
351 spin_lock_irqsave(&iommu->lock, flags); 314 spin_lock_irqsave(&iommu->lock, flags);
352 315
353 entry = (bus_addr - iommu->page_table_map_base) >> IO_PAGE_SHIFT; 316 iommu_range_free(iommu, bus_addr, npages);
354 arena_free(&iommu->arena, entry, npages);
355 317
318 entry = (bus_addr - iommu->page_table_map_base) >> IO_PAGE_SHIFT;
356 do { 319 do {
357 unsigned long num; 320 unsigned long num;
358 321
@@ -368,88 +331,131 @@ static void dma_4v_unmap_single(struct device *dev, dma_addr_t bus_addr,
368static int dma_4v_map_sg(struct device *dev, struct scatterlist *sglist, 331static int dma_4v_map_sg(struct device *dev, struct scatterlist *sglist,
369 int nelems, enum dma_data_direction direction) 332 int nelems, enum dma_data_direction direction)
370{ 333{
371 unsigned long flags, npages, i, prot; 334 struct scatterlist *s, *outs, *segstart;
372 struct scatterlist *sg; 335 unsigned long flags, handle, prot;
336 dma_addr_t dma_next = 0, dma_addr;
337 unsigned int max_seg_size;
338 int outcount, incount, i;
373 struct iommu *iommu; 339 struct iommu *iommu;
374 long entry, err; 340 long err;
375 u32 dma_base; 341
376 342 BUG_ON(direction == DMA_NONE);
377 /* Fast path single entry scatterlists. */
378 if (nelems == 1) {
379 sglist->dma_address =
380 dma_4v_map_single(dev, sg_virt(sglist),
381 sglist->length, direction);
382 if (unlikely(sglist->dma_address == DMA_ERROR_CODE))
383 return 0;
384 sglist->dma_length = sglist->length;
385 return 1;
386 }
387 343
388 iommu = dev->archdata.iommu; 344 iommu = dev->archdata.iommu;
345 if (nelems == 0 || !iommu)
346 return 0;
389 347
390 if (unlikely(direction == DMA_NONE)) 348 prot = HV_PCI_MAP_ATTR_READ;
391 goto bad; 349 if (direction != DMA_TO_DEVICE)
392 350 prot |= HV_PCI_MAP_ATTR_WRITE;
393 npages = calc_npages(sglist, nelems);
394 351
395 spin_lock_irqsave(&iommu->lock, flags); 352 outs = s = segstart = &sglist[0];
396 entry = arena_alloc(&iommu->arena, npages); 353 outcount = 1;
397 spin_unlock_irqrestore(&iommu->lock, flags); 354 incount = nelems;
355 handle = 0;
398 356
399 if (unlikely(entry < 0L)) 357 /* Init first segment length for backout at failure */
400 goto bad; 358 outs->dma_length = 0;
401 359
402 dma_base = iommu->page_table_map_base + 360 spin_lock_irqsave(&iommu->lock, flags);
403 (entry << IO_PAGE_SHIFT);
404 361
405 prot = HV_PCI_MAP_ATTR_READ; 362 iommu_batch_start(dev, prot, ~0UL);
406 if (direction != DMA_TO_DEVICE)
407 prot |= HV_PCI_MAP_ATTR_WRITE;
408 363
409 local_irq_save(flags); 364 max_seg_size = dma_get_max_seg_size(dev);
365 for_each_sg(sglist, s, nelems, i) {
366 unsigned long paddr, npages, entry, slen;
410 367
411 iommu_batch_start(dev, prot, entry); 368 slen = s->length;
369 /* Sanity check */
370 if (slen == 0) {
371 dma_next = 0;
372 continue;
373 }
374 /* Allocate iommu entries for that segment */
375 paddr = (unsigned long) SG_ENT_PHYS_ADDRESS(s);
376 npages = iommu_num_pages(paddr, slen);
377 entry = iommu_range_alloc(dev, iommu, npages, &handle);
412 378
413 for_each_sg(sglist, sg, nelems, i) { 379 /* Handle failure */
414 unsigned long paddr = SG_ENT_PHYS_ADDRESS(sg); 380 if (unlikely(entry == DMA_ERROR_CODE)) {
415 unsigned long slen = sg->length; 381 if (printk_ratelimit())
416 unsigned long this_npages; 382 printk(KERN_INFO "iommu_alloc failed, iommu %p paddr %lx"
383 " npages %lx\n", iommu, paddr, npages);
384 goto iommu_map_failed;
385 }
417 386
418 this_npages = iommu_num_pages(paddr, slen); 387 iommu_batch_new_entry(entry);
419 388
420 sg->dma_address = dma_base | (paddr & ~IO_PAGE_MASK); 389 /* Convert entry to a dma_addr_t */
421 sg->dma_length = slen; 390 dma_addr = iommu->page_table_map_base +
391 (entry << IO_PAGE_SHIFT);
392 dma_addr |= (s->offset & ~IO_PAGE_MASK);
422 393
394 /* Insert into HW table */
423 paddr &= IO_PAGE_MASK; 395 paddr &= IO_PAGE_MASK;
424 while (this_npages--) { 396 while (npages--) {
425 err = iommu_batch_add(paddr); 397 err = iommu_batch_add(paddr);
426 if (unlikely(err < 0L)) { 398 if (unlikely(err < 0L))
427 local_irq_restore(flags);
428 goto iommu_map_failed; 399 goto iommu_map_failed;
400 paddr += IO_PAGE_SIZE;
401 }
402
403 /* If we are in an open segment, try merging */
404 if (segstart != s) {
405 /* We cannot merge if:
406 * - allocated dma_addr isn't contiguous to previous allocation
407 */
408 if ((dma_addr != dma_next) ||
409 (outs->dma_length + s->length > max_seg_size)) {
410 /* Can't merge: create a new segment */
411 segstart = s;
412 outcount++;
413 outs = sg_next(outs);
414 } else {
415 outs->dma_length += s->length;
429 } 416 }
417 }
430 418
431 paddr += IO_PAGE_SIZE; 419 if (segstart == s) {
432 dma_base += IO_PAGE_SIZE; 420 /* This is a new segment, fill entries */
421 outs->dma_address = dma_addr;
422 outs->dma_length = slen;
433 } 423 }
424
425 /* Calculate next page pointer for contiguous check */
426 dma_next = dma_addr + slen;
434 } 427 }
435 428
436 err = iommu_batch_end(); 429 err = iommu_batch_end();
437 430
438 local_irq_restore(flags);
439
440 if (unlikely(err < 0L)) 431 if (unlikely(err < 0L))
441 goto iommu_map_failed; 432 goto iommu_map_failed;
442 433
443 return nelems; 434 spin_unlock_irqrestore(&iommu->lock, flags);
444 435
445bad: 436 if (outcount < incount) {
446 if (printk_ratelimit()) 437 outs = sg_next(outs);
447 WARN_ON(1); 438 outs->dma_address = DMA_ERROR_CODE;
448 return 0; 439 outs->dma_length = 0;
440 }
441
442 return outcount;
449 443
450iommu_map_failed: 444iommu_map_failed:
451 spin_lock_irqsave(&iommu->lock, flags); 445 for_each_sg(sglist, s, nelems, i) {
452 arena_free(&iommu->arena, entry, npages); 446 if (s->dma_length != 0) {
447 unsigned long vaddr, npages;
448
449 vaddr = s->dma_address & IO_PAGE_MASK;
450 npages = iommu_num_pages(s->dma_address, s->dma_length);
451 iommu_range_free(iommu, vaddr, npages);
452 /* XXX demap? XXX */
453 s->dma_address = DMA_ERROR_CODE;
454 s->dma_length = 0;
455 }
456 if (s == outs)
457 break;
458 }
453 spin_unlock_irqrestore(&iommu->lock, flags); 459 spin_unlock_irqrestore(&iommu->lock, flags);
454 460
455 return 0; 461 return 0;
@@ -458,39 +464,43 @@ iommu_map_failed:
458static void dma_4v_unmap_sg(struct device *dev, struct scatterlist *sglist, 464static void dma_4v_unmap_sg(struct device *dev, struct scatterlist *sglist,
459 int nelems, enum dma_data_direction direction) 465 int nelems, enum dma_data_direction direction)
460{ 466{
461 unsigned long flags, npages;
462 struct pci_pbm_info *pbm; 467 struct pci_pbm_info *pbm;
463 u32 devhandle, bus_addr; 468 struct scatterlist *sg;
464 struct iommu *iommu; 469 struct iommu *iommu;
465 long entry; 470 unsigned long flags;
471 u32 devhandle;
466 472
467 if (unlikely(direction == DMA_NONE)) { 473 BUG_ON(direction == DMA_NONE);
468 if (printk_ratelimit())
469 WARN_ON(1);
470 }
471 474
472 iommu = dev->archdata.iommu; 475 iommu = dev->archdata.iommu;
473 pbm = dev->archdata.host_controller; 476 pbm = dev->archdata.host_controller;
474 devhandle = pbm->devhandle; 477 devhandle = pbm->devhandle;
475 478
476 bus_addr = sglist->dma_address & IO_PAGE_MASK;
477
478 npages = calc_npages(sglist, nelems);
479
480 entry = ((bus_addr - iommu->page_table_map_base) >> IO_PAGE_SHIFT);
481
482 spin_lock_irqsave(&iommu->lock, flags); 479 spin_lock_irqsave(&iommu->lock, flags);
483 480
484 arena_free(&iommu->arena, entry, npages); 481 sg = sglist;
485 482 while (nelems--) {
486 do { 483 dma_addr_t dma_handle = sg->dma_address;
487 unsigned long num; 484 unsigned int len = sg->dma_length;
485 unsigned long npages, entry;
486
487 if (!len)
488 break;
489 npages = iommu_num_pages(dma_handle, len);
490 iommu_range_free(iommu, dma_handle, npages);
491
492 entry = ((dma_handle - iommu->page_table_map_base) >> IO_PAGE_SHIFT);
493 while (npages) {
494 unsigned long num;
495
496 num = pci_sun4v_iommu_demap(devhandle, HV_PCI_TSBID(0, entry),
497 npages);
498 entry += num;
499 npages -= num;
500 }
488 501
489 num = pci_sun4v_iommu_demap(devhandle, HV_PCI_TSBID(0, entry), 502 sg = sg_next(sg);
490 npages); 503 }
491 entry += num;
492 npages -= num;
493 } while (npages != 0);
494 504
495 spin_unlock_irqrestore(&iommu->lock, flags); 505 spin_unlock_irqrestore(&iommu->lock, flags);
496} 506}
diff --git a/include/asm-sparc/a.out.h b/include/asm-sparc/a.out.h
index 744cfe6c0de8..2f1c3748a068 100644
--- a/include/asm-sparc/a.out.h
+++ b/include/asm-sparc/a.out.h
@@ -1,24 +1,27 @@
1/* $Id: a.out.h,v 1.13 2000/01/09 10:46:53 anton Exp $ */
2#ifndef __SPARC_A_OUT_H__ 1#ifndef __SPARC_A_OUT_H__
3#define __SPARC_A_OUT_H__ 2#define __SPARC_A_OUT_H__
4 3
5#define SPARC_PGSIZE 0x2000 /* Thanks to the sun4 architecture... */ 4#define SPARC_PGSIZE 0x2000 /* Thanks to the sun4 architecture... */
6#define SEGMENT_SIZE SPARC_PGSIZE /* whee... */ 5#define SEGMENT_SIZE SPARC_PGSIZE /* whee... */
7 6
7#ifndef __ASSEMBLY__
8
8struct exec { 9struct exec {
9 unsigned char a_dynamic:1; /* A __DYNAMIC is in this image */ 10 unsigned char a_dynamic:1; /* A __DYNAMIC is in this image */
10 unsigned char a_toolversion:7; 11 unsigned char a_toolversion:7;
11 unsigned char a_machtype; 12 unsigned char a_machtype;
12 unsigned short a_info; 13 unsigned short a_info;
13 unsigned long a_text; /* length of text, in bytes */ 14 unsigned int a_text; /* length of text, in bytes */
14 unsigned long a_data; /* length of data, in bytes */ 15 unsigned int a_data; /* length of data, in bytes */
15 unsigned long a_bss; /* length of bss, in bytes */ 16 unsigned int a_bss; /* length of bss, in bytes */
16 unsigned long a_syms; /* length of symbol table, in bytes */ 17 unsigned int a_syms; /* length of symbol table, in bytes */
17 unsigned long a_entry; /* where program begins */ 18 unsigned int a_entry; /* where program begins */
18 unsigned long a_trsize; 19 unsigned int a_trsize;
19 unsigned long a_drsize; 20 unsigned int a_drsize;
20}; 21};
21 22
23#endif /* !__ASSEMBLY__ */
24
22/* Where in the file does the text information begin? */ 25/* Where in the file does the text information begin? */
23#define N_TXTOFF(x) (N_MAGIC(x) == ZMAGIC ? 0 : sizeof (struct exec)) 26#define N_TXTOFF(x) (N_MAGIC(x) == ZMAGIC ? 0 : sizeof (struct exec))
24 27
@@ -28,19 +31,21 @@ struct exec {
28 (x).a_drsize) 31 (x).a_drsize)
29 32
30/* Where does text segment go in memory after being loaded? */ 33/* Where does text segment go in memory after being loaded? */
31#define N_TXTADDR(x) (((N_MAGIC(x) == ZMAGIC) && \ 34#define N_TXTADDR(x) (unsigned long)(((N_MAGIC(x) == ZMAGIC) && \
32 ((x).a_entry < SPARC_PGSIZE)) ? \ 35 ((x).a_entry < SPARC_PGSIZE)) ? \
33 0 : SPARC_PGSIZE) 36 0 : SPARC_PGSIZE)
34 37
35/* And same for the data segment.. */ 38/* And same for the data segment.. */
36#define N_DATADDR(x) (N_MAGIC(x)==OMAGIC ? \ 39#define N_DATADDR(x) (N_MAGIC(x)==OMAGIC ? \
37 (N_TXTADDR(x) + (x).a_text) \ 40 (N_TXTADDR(x) + (x).a_text) \
38 : (_N_SEGMENT_ROUND (_N_TXTENDADDR(x)))) 41 : (unsigned long) (_N_SEGMENT_ROUND (_N_TXTENDADDR(x))))
39 42
40#define N_TRSIZE(a) ((a).a_trsize) 43#define N_TRSIZE(a) ((a).a_trsize)
41#define N_DRSIZE(a) ((a).a_drsize) 44#define N_DRSIZE(a) ((a).a_drsize)
42#define N_SYMSIZE(a) ((a).a_syms) 45#define N_SYMSIZE(a) ((a).a_syms)
43 46
47#ifndef __ASSEMBLY__
48
44/* 49/*
45 * Sparc relocation types 50 * Sparc relocation types
46 */ 51 */
@@ -77,14 +82,16 @@ enum reloc_type
77 */ 82 */
78struct relocation_info /* used when header.a_machtype == M_SPARC */ 83struct relocation_info /* used when header.a_machtype == M_SPARC */
79{ 84{
80 unsigned long r_address; /* relocation addr */ 85 unsigned int r_address; /* relocation addr */
81 unsigned int r_index:24; /* segment index or symbol index */ 86 unsigned int r_index:24; /* segment index or symbol index */
82 unsigned int r_extern:1; /* if F, r_index==SEG#; if T, SYM idx */ 87 unsigned int r_extern:1; /* if F, r_index==SEG#; if T, SYM idx */
83 unsigned int r_pad:2; /* <unused> */ 88 unsigned int r_pad:2; /* <unused> */
84 enum reloc_type r_type:5; /* type of relocation to perform */ 89 enum reloc_type r_type:5; /* type of relocation to perform */
85 long r_addend; /* addend for relocation value */ 90 int r_addend; /* addend for relocation value */
86}; 91};
87 92
88#define N_RELOCATION_INFO_DECLARED 1 93#define N_RELOCATION_INFO_DECLARED 1
89 94
95#endif /* !(__ASSEMBLY__) */
96
90#endif /* __SPARC_A_OUT_H__ */ 97#endif /* __SPARC_A_OUT_H__ */
diff --git a/include/asm-sparc/bpp.h b/include/asm-sparc/bpp.h
index 3578ac113cf0..31f515e499a7 100644
--- a/include/asm-sparc/bpp.h
+++ b/include/asm-sparc/bpp.h
@@ -17,7 +17,7 @@
17 * with compliant or compatible devices. It will use whatever features 17 * with compliant or compatible devices. It will use whatever features
18 * the device supports, prefering those that are typically faster. 18 * the device supports, prefering those that are typically faster.
19 * 19 *
20 * When the device is opened, it is left in COMPATABILITY mode, and 20 * When the device is opened, it is left in COMPATIBILITY mode, and
21 * writes work like any printer device. The driver only attempt to 21 * writes work like any printer device. The driver only attempt to
22 * negotiate 1284 modes when needed so that plugs can be pulled, 22 * negotiate 1284 modes when needed so that plugs can be pulled,
23 * switch boxes switched, etc., without disrupting things. It will 23 * switch boxes switched, etc., without disrupting things. It will
diff --git a/include/asm-sparc/bsderrno.h b/include/asm-sparc/bsderrno.h
deleted file mode 100644
index 54a75be43abb..000000000000
--- a/include/asm-sparc/bsderrno.h
+++ /dev/null
@@ -1,94 +0,0 @@
1/* $Id: bsderrno.h,v 1.3 1996/04/25 06:12:47 davem Exp $
2 * bsderrno.h: Error numbers for NetBSD binary compatibility
3 *
4 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
5 */
6
7#ifndef _SPARC_BSDERRNO_H
8#define _SPARC_BSDERRNO_H
9
10#define BSD_EPERM 1 /* Operation not permitted */
11#define BSD_ENOENT 2 /* No such file or directory */
12#define BSD_ESRCH 3 /* No such process */
13#define BSD_EINTR 4 /* Interrupted system call */
14#define BSD_EIO 5 /* Input/output error */
15#define BSD_ENXIO 6 /* Device not configured */
16#define BSD_E2BIG 7 /* Argument list too long */
17#define BSD_ENOEXEC 8 /* Exec format error */
18#define BSD_EBADF 9 /* Bad file descriptor */
19#define BSD_ECHILD 10 /* No child processes */
20#define BSD_EDEADLK 11 /* Resource deadlock avoided */
21#define BSD_ENOMEM 12 /* Cannot allocate memory */
22#define BSD_EACCES 13 /* Permission denied */
23#define BSD_EFAULT 14 /* Bad address */
24#define BSD_ENOTBLK 15 /* Block device required */
25#define BSD_EBUSY 16 /* Device busy */
26#define BSD_EEXIST 17 /* File exists */
27#define BSD_EXDEV 18 /* Cross-device link */
28#define BSD_ENODEV 19 /* Operation not supported by device */
29#define BSD_ENOTDIR 20 /* Not a directory */
30#define BSD_EISDIR 21 /* Is a directory */
31#define BSD_EINVAL 22 /* Invalid argument */
32#define BSD_ENFILE 23 /* Too many open files in system */
33#define BSD_EMFILE 24 /* Too many open files */
34#define BSD_ENOTTY 25 /* Inappropriate ioctl for device */
35#define BSD_ETXTBSY 26 /* Text file busy */
36#define BSD_EFBIG 27 /* File too large */
37#define BSD_ENOSPC 28 /* No space left on device */
38#define BSD_ESPIPE 29 /* Illegal seek */
39#define BSD_EROFS 30 /* Read-only file system */
40#define BSD_EMLINK 31 /* Too many links */
41#define BSD_EPIPE 32 /* Broken pipe */
42#define BSD_EDOM 33 /* Numerical argument out of domain */
43#define BSD_ERANGE 34 /* Result too large */
44#define BSD_EAGAIN 35 /* Resource temporarily unavailable */
45#define BSD_EWOULDBLOCK EAGAIN /* Operation would block */
46#define BSD_EINPROGRESS 36 /* Operation now in progress */
47#define BSD_EALREADY 37 /* Operation already in progress */
48#define BSD_ENOTSOCK 38 /* Socket operation on non-socket */
49#define BSD_EDESTADDRREQ 39 /* Destination address required */
50#define BSD_EMSGSIZE 40 /* Message too long */
51#define BSD_EPROTOTYPE 41 /* Protocol wrong type for socket */
52#define BSD_ENOPROTOOPT 42 /* Protocol not available */
53#define BSD_EPROTONOSUPPORT 43 /* Protocol not supported */
54#define BSD_ESOCKTNOSUPPORT 44 /* Socket type not supported */
55#define BSD_EOPNOTSUPP 45 /* Operation not supported */
56#define BSD_EPFNOSUPPORT 46 /* Protocol family not supported */
57#define BSD_EAFNOSUPPORT 47 /* Address family not supported by protocol family */
58#define BSD_EADDRINUSE 48 /* Address already in use */
59#define BSD_EADDRNOTAVAIL 49 /* Can't assign requested address */
60#define BSD_ENETDOWN 50 /* Network is down */
61#define BSD_ENETUNREACH 51 /* Network is unreachable */
62#define BSD_ENETRESET 52 /* Network dropped connection on reset */
63#define BSD_ECONNABORTED 53 /* Software caused connection abort */
64#define BSD_ECONNRESET 54 /* Connection reset by peer */
65#define BSD_ENOBUFS 55 /* No buffer space available */
66#define BSD_EISCONN 56 /* Socket is already connected */
67#define BSD_ENOTCONN 57 /* Socket is not connected */
68#define BSD_ESHUTDOWN 58 /* Can't send after socket shutdown */
69#define BSD_ETOOMANYREFS 59 /* Too many references: can't splice */
70#define BSD_ETIMEDOUT 60 /* Operation timed out */
71#define BSD_ECONNREFUSED 61 /* Connection refused */
72#define BSD_ELOOP 62 /* Too many levels of symbolic links */
73#define BSD_ENAMETOOLONG 63 /* File name too long */
74#define BSD_EHOSTDOWN 64 /* Host is down */
75#define BSD_EHOSTUNREACH 65 /* No route to host */
76#define BSD_ENOTEMPTY 66 /* Directory not empty */
77#define BSD_EPROCLIM 67 /* Too many processes */
78#define BSD_EUSERS 68 /* Too many users */
79#define BSD_EDQUOT 69 /* Disc quota exceeded */
80#define BSD_ESTALE 70 /* Stale NFS file handle */
81#define BSD_EREMOTE 71 /* Too many levels of remote in path */
82#define BSD_EBADRPC 72 /* RPC struct is bad */
83#define BSD_ERPCMISMATCH 73 /* RPC version wrong */
84#define BSD_EPROGUNAVAIL 74 /* RPC prog. not avail */
85#define BSD_EPROGMISMATCH 75 /* Program version wrong */
86#define BSD_EPROCUNAVAIL 76 /* Bad procedure for program */
87#define BSD_ENOLCK 77 /* No locks available */
88#define BSD_ENOSYS 78 /* Function not implemented */
89#define BSD_EFTYPE 79 /* Inappropriate file type or format */
90#define BSD_EAUTH 80 /* Authentication error */
91#define BSD_ENEEDAUTH 81 /* Need authenticator */
92#define BSD_ELAST 81 /* Must be equal largest errno */
93
94#endif /* !(_SPARC_BSDERRNO_H) */
diff --git a/include/asm-sparc/bug.h b/include/asm-sparc/bug.h
index 04151208189f..8a59e5a8c217 100644
--- a/include/asm-sparc/bug.h
+++ b/include/asm-sparc/bug.h
@@ -2,28 +2,16 @@
2#define _SPARC_BUG_H 2#define _SPARC_BUG_H
3 3
4#ifdef CONFIG_BUG 4#ifdef CONFIG_BUG
5/* Only use the inline asm until a gcc release that can handle __builtin_trap 5#include <linux/compiler.h>
6 * -rob 2003-06-25
7 *
8 * gcc-3.3.1 and later will be OK -DaveM
9 */
10#if (__GNUC__ > 3) || \
11 (__GNUC__ == 3 && __GNUC_MINOR__ > 3) || \
12 (__GNUC__ == 3 && __GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ >= 4)
13#define __bug_trap() __builtin_trap()
14#else
15#define __bug_trap() \
16 __asm__ __volatile__ ("t 0x5\n\t" : : )
17#endif
18 6
19#ifdef CONFIG_DEBUG_BUGVERBOSE 7#ifdef CONFIG_DEBUG_BUGVERBOSE
20extern void do_BUG(const char *file, int line); 8extern void do_BUG(const char *file, int line);
21#define BUG() do { \ 9#define BUG() do { \
22 do_BUG(__FILE__, __LINE__); \ 10 do_BUG(__FILE__, __LINE__); \
23 __bug_trap(); \ 11 __builtin_trap(); \
24} while (0) 12} while (0)
25#else 13#else
26#define BUG() __bug_trap() 14#define BUG() __builtin_trap()
27#endif 15#endif
28 16
29#define HAVE_ARCH_BUG 17#define HAVE_ARCH_BUG
diff --git a/include/asm-sparc/bugs.h b/include/asm-sparc/bugs.h
index a0f939beeea1..2dfc07bc8e54 100644
--- a/include/asm-sparc/bugs.h
+++ b/include/asm-sparc/bugs.h
@@ -1,16 +1,24 @@
1/* $Id: bugs.h,v 1.1 1996/12/26 13:25:20 davem Exp $ 1/* include/asm-sparc/bugs.h: Sparc probes for various bugs.
2 * include/asm-sparc/bugs.h: Sparc probes for various bugs.
3 * 2 *
4 * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu) 3 * Copyright (C) 1996, 2007 David S. Miller (davem@davemloft.net)
5 */ 4 */
6 5
6#ifdef CONFIG_SPARC32
7#include <asm/cpudata.h> 7#include <asm/cpudata.h>
8#endif
9
10#ifdef CONFIG_SPARC64
11#include <asm/sstate.h>
12#endif
8 13
9extern unsigned long loops_per_jiffy; 14extern unsigned long loops_per_jiffy;
10 15
11static void check_bugs(void) 16static void __init check_bugs(void)
12{ 17{
13#ifndef CONFIG_SMP 18#if defined(CONFIG_SPARC32) && !defined(CONFIG_SMP)
14 cpu_data(0).udelay_val = loops_per_jiffy; 19 cpu_data(0).udelay_val = loops_per_jiffy;
15#endif 20#endif
21#ifdef CONFIG_SPARC64
22 sstate_running();
23#endif
16} 24}
diff --git a/include/asm-sparc/byteorder.h b/include/asm-sparc/byteorder.h
index a2949aea48ef..bcd83aa351c5 100644
--- a/include/asm-sparc/byteorder.h
+++ b/include/asm-sparc/byteorder.h
@@ -1,12 +1,55 @@
1/* $Id: byteorder.h,v 1.15 1997/12/16 19:20:44 davem Exp $ */
2#ifndef _SPARC_BYTEORDER_H 1#ifndef _SPARC_BYTEORDER_H
3#define _SPARC_BYTEORDER_H 2#define _SPARC_BYTEORDER_H
4 3
5#include <asm/types.h> 4#include <asm/types.h>
5#include <asm/asi.h>
6
7#ifdef __GNUC__
8
9#ifdef CONFIG_SPARC32
10#define __SWAB_64_THRU_32__
11#endif
12
13#ifdef CONFIG_SPARC64
14
15static inline __u16 ___arch__swab16p(const __u16 *addr)
16{
17 __u16 ret;
18
19 __asm__ __volatile__ ("lduha [%1] %2, %0"
20 : "=r" (ret)
21 : "r" (addr), "i" (ASI_PL));
22 return ret;
23}
24
25static inline __u32 ___arch__swab32p(const __u32 *addr)
26{
27 __u32 ret;
28
29 __asm__ __volatile__ ("lduwa [%1] %2, %0"
30 : "=r" (ret)
31 : "r" (addr), "i" (ASI_PL));
32 return ret;
33}
34
35static inline __u64 ___arch__swab64p(const __u64 *addr)
36{
37 __u64 ret;
38
39 __asm__ __volatile__ ("ldxa [%1] %2, %0"
40 : "=r" (ret)
41 : "r" (addr), "i" (ASI_PL));
42 return ret;
43}
44
45#define __arch__swab16p(x) ___arch__swab16p(x)
46#define __arch__swab32p(x) ___arch__swab32p(x)
47#define __arch__swab64p(x) ___arch__swab64p(x)
48
49#endif /* CONFIG_SPARC64 */
50
51#define __BYTEORDER_HAS_U64__
6 52
7#if defined(__GNUC__) && !defined(__STRICT_ANSI__) || defined(__KERNEL__)
8# define __BYTEORDER_HAS_U64__
9# define __SWAB_64_THRU_32__
10#endif 53#endif
11 54
12#include <linux/byteorder/big_endian.h> 55#include <linux/byteorder/big_endian.h>
diff --git a/include/asm-sparc/cache.h b/include/asm-sparc/cache.h
index cb971e88aea4..41f85ae4bd4a 100644
--- a/include/asm-sparc/cache.h
+++ b/include/asm-sparc/cache.h
@@ -1,20 +1,28 @@
1/* $Id: cache.h,v 1.9 1999/08/14 03:51:58 anton Exp $ 1/* cache.h: Cache specific code for the Sparc. These include flushing
2 * cache.h: Cache specific code for the Sparc. These include flushing
3 * and direct tag/data line access. 2 * and direct tag/data line access.
4 * 3 *
5 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) 4 * Copyright (C) 1995, 2007 David S. Miller (davem@davemloft.net)
6 */ 5 */
7 6
8#ifndef _SPARC_CACHE_H 7#ifndef _SPARC_CACHE_H
9#define _SPARC_CACHE_H 8#define _SPARC_CACHE_H
10 9
11#include <asm/asi.h>
12
13#define L1_CACHE_SHIFT 5 10#define L1_CACHE_SHIFT 5
14#define L1_CACHE_BYTES 32 11#define L1_CACHE_BYTES 32
15#define L1_CACHE_ALIGN(x) ((((x)+(L1_CACHE_BYTES-1))&~(L1_CACHE_BYTES-1))) 12#define L1_CACHE_ALIGN(x) ((((x)+(L1_CACHE_BYTES-1))&~(L1_CACHE_BYTES-1)))
16 13
17#define SMP_CACHE_BYTES 32 14#ifdef CONFIG_SPARC32
15#define SMP_CACHE_BYTES_SHIFT 5
16#else
17#define SMP_CACHE_BYTES_SHIFT 6
18#endif
19
20#define SMP_CACHE_BYTES (1 << SMP_CACHE_BYTES_SHIFT)
21
22#define __read_mostly __attribute__((__section__(".data.read_mostly")))
23
24#ifdef CONFIG_SPARC32
25#include <asm/asi.h>
18 26
19/* Direct access to the instruction cache is provided through and 27/* Direct access to the instruction cache is provided through and
20 * alternate address space. The IDC bit must be off in the ICCR on 28 * alternate address space. The IDC bit must be off in the ICCR on
@@ -125,5 +133,6 @@ static inline void flush_ei_user(unsigned int addr)
125 "r" (addr), "i" (ASI_M_FLUSH_USER) : 133 "r" (addr), "i" (ASI_M_FLUSH_USER) :
126 "memory"); 134 "memory");
127} 135}
136#endif /* CONFIG_SPARC32 */
128 137
129#endif /* !(_SPARC_CACHE_H) */ 138#endif /* !(_SPARC_CACHE_H) */
diff --git a/include/asm-sparc/current.h b/include/asm-sparc/current.h
index 8fe7c82a5e21..8a1d9d6643b0 100644
--- a/include/asm-sparc/current.h
+++ b/include/asm-sparc/current.h
@@ -1,31 +1,34 @@
1/* 1/* include/asm-sparc/current.h
2 * include/asm-sparc/current.h
3 * 2 *
4 * Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation 3 * Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
5 * Copyright (C) 2002 Pete Zaitcev (zaitcev@yahoo.com) 4 * Copyright (C) 2002 Pete Zaitcev (zaitcev@yahoo.com)
5 * Copyright (C) 2007 David S. Miller (davem@davemloft.net)
6 * 6 *
7 * Derived from "include/asm-s390/current.h" by 7 * Derived from "include/asm-s390/current.h" by
8 * Martin Schwidefsky (schwidefsky@de.ibm.com) 8 * Martin Schwidefsky (schwidefsky@de.ibm.com)
9 * Derived from "include/asm-i386/current.h" 9 * Derived from "include/asm-i386/current.h"
10 */ 10*/
11#ifndef _ASM_CURRENT_H 11#ifndef _SPARC_CURRENT_H
12#define _ASM_CURRENT_H 12#define _SPARC_CURRENT_H
13
14/*
15 * At the sparc64 DaveM keeps current_thread_info in %g4.
16 * We might want to consider doing the same to shave a few cycles.
17 */
18 13
19#include <linux/thread_info.h> 14#include <linux/thread_info.h>
20 15
21struct task_struct; 16#ifdef CONFIG_SPARC64
17register struct task_struct *current asm("g4");
18#endif
22 19
23/* Two stage process (inline + #define) for type-checking. */ 20#ifdef CONFIG_SPARC32
24/* We also obfuscate get_current() to check if anyone used that by mistake. */ 21/* We might want to consider using %g4 like sparc64 to shave a few cycles.
22 *
23 * Two stage process (inline + #define) for type-checking.
24 * We also obfuscate get_current() to check if anyone used that by mistake.
25 */
26struct task_struct;
25static inline struct task_struct *__get_current(void) 27static inline struct task_struct *__get_current(void)
26{ 28{
27 return current_thread_info()->task; 29 return current_thread_info()->task;
28} 30}
29#define current __get_current() 31#define current __get_current()
32#endif
30 33
31#endif /* !(_ASM_CURRENT_H) */ 34#endif /* !(_SPARC_CURRENT_H) */
diff --git a/include/asm-sparc/device.h b/include/asm-sparc/device.h
index c0a7786d65f7..680e51d87374 100644
--- a/include/asm-sparc/device.h
+++ b/include/asm-sparc/device.h
@@ -19,5 +19,3 @@ struct dev_archdata {
19}; 19};
20 20
21#endif /* _ASM_SPARC_DEVICE_H */ 21#endif /* _ASM_SPARC_DEVICE_H */
22
23
diff --git a/include/asm-sparc/errno.h b/include/asm-sparc/errno.h
index ed41c8bac1fa..a9ef172977de 100644
--- a/include/asm-sparc/errno.h
+++ b/include/asm-sparc/errno.h
@@ -1,4 +1,3 @@
1/* $Id: errno.h,v 1.6 1997/04/15 09:03:38 davem Exp $ */
2#ifndef _SPARC_ERRNO_H 1#ifndef _SPARC_ERRNO_H
3#define _SPARC_ERRNO_H 2#define _SPARC_ERRNO_H
4 3
diff --git a/include/asm-sparc/fb.h b/include/asm-sparc/fb.h
index c73ca081e1f5..b83e44729655 100644
--- a/include/asm-sparc/fb.h
+++ b/include/asm-sparc/fb.h
@@ -1,9 +1,17 @@
1#ifndef _ASM_FB_H_ 1#ifndef _SPARC_FB_H_
2#define _ASM_FB_H_ 2#define _SPARC_FB_H_
3#include <linux/fb.h> 3#include <linux/fb.h>
4#include <linux/fs.h>
5#include <asm/page.h>
4#include <asm/prom.h> 6#include <asm/prom.h>
5 7
6#define fb_pgprotect(...) do {} while (0) 8static inline void fb_pgprotect(struct file *file, struct vm_area_struct *vma,
9 unsigned long off)
10{
11#ifdef CONFIG_SPARC64
12 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
13#endif
14}
7 15
8static inline int fb_is_primary_device(struct fb_info *info) 16static inline int fb_is_primary_device(struct fb_info *info)
9{ 17{
@@ -18,4 +26,4 @@ static inline int fb_is_primary_device(struct fb_info *info)
18 return 0; 26 return 0;
19} 27}
20 28
21#endif /* _ASM_FB_H_ */ 29#endif /* _SPARC_FB_H_ */
diff --git a/include/asm-sparc/of_platform.h b/include/asm-sparc/of_platform.h
index d638737ff13c..38334351c36b 100644
--- a/include/asm-sparc/of_platform.h
+++ b/include/asm-sparc/of_platform.h
@@ -21,9 +21,4 @@ extern struct bus_type sbus_bus_type;
21 21
22#define of_bus_type of_platform_bus_type /* for compatibility */ 22#define of_bus_type of_platform_bus_type /* for compatibility */
23 23
24extern struct of_device *of_platform_device_create(struct device_node *np,
25 const char *bus_id,
26 struct device *parent,
27 struct bus_type *bus);
28
29#endif /* _ASM_SPARC_OF_PLATFORM_H */ 24#endif /* _ASM_SPARC_OF_PLATFORM_H */
diff --git a/include/asm-sparc/prom.h b/include/asm-sparc/prom.h
index 71f2a1998324..df5dc4422483 100644
--- a/include/asm-sparc/prom.h
+++ b/include/asm-sparc/prom.h
@@ -9,7 +9,7 @@
9 * Copyright (C) 1996-2005 Paul Mackerras. 9 * Copyright (C) 1996-2005 Paul Mackerras.
10 * 10 *
11 * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp. 11 * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp.
12 * Updates for SPARC32 by David S. Miller 12 * Updates for SPARC by David S. Miller
13 * 13 *
14 * This program is free software; you can redistribute it and/or 14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License 15 * modify it under the terms of the GNU General Public License
@@ -39,6 +39,7 @@ struct property {
39 unsigned int unique_id; 39 unsigned int unique_id;
40}; 40};
41 41
42struct of_irq_controller;
42struct device_node { 43struct device_node {
43 const char *name; 44 const char *name;
44 const char *type; 45 const char *type;
@@ -58,11 +59,19 @@ struct device_node {
58 unsigned long _flags; 59 unsigned long _flags;
59 void *data; 60 void *data;
60 unsigned int unique_id; 61 unsigned int unique_id;
62
63 struct of_irq_controller *irq_trans;
64};
65
66struct of_irq_controller {
67 unsigned int (*irq_build)(struct device_node *, unsigned int, void *);
68 void *data;
61}; 69};
62 70
63#define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags) 71#define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
64#define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags) 72#define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
65 73
74extern struct device_node *of_find_node_by_cpuid(int cpuid);
66extern int of_set_property(struct device_node *node, const char *name, void *val, int len); 75extern int of_set_property(struct device_node *node, const char *name, void *val, int len);
67extern int of_getintprop_default(struct device_node *np, 76extern int of_getintprop_default(struct device_node *np,
68 const char *name, 77 const char *name,
diff --git a/include/asm-sparc64/a.out.h b/include/asm-sparc64/a.out.h
index 53c95bdfc66e..44208c2a188e 100644
--- a/include/asm-sparc64/a.out.h
+++ b/include/asm-sparc64/a.out.h
@@ -1,98 +1 @@
1/* $Id: a.out.h,v 1.8 2002/02/09 19:49:31 davem Exp $ */ #include <asm-sparc/a.out.h>
2#ifndef __SPARC64_A_OUT_H__
3#define __SPARC64_A_OUT_H__
4
5#define SPARC_PGSIZE 0x2000 /* Thanks to the sun4 architecture... */
6#define SEGMENT_SIZE SPARC_PGSIZE /* whee... */
7
8#ifndef __ASSEMBLY__
9
10struct exec {
11 unsigned char a_dynamic:1; /* A __DYNAMIC is in this image */
12 unsigned char a_toolversion:7;
13 unsigned char a_machtype;
14 unsigned short a_info;
15 unsigned int a_text; /* length of text, in bytes */
16 unsigned int a_data; /* length of data, in bytes */
17 unsigned int a_bss; /* length of bss, in bytes */
18 unsigned int a_syms; /* length of symbol table, in bytes */
19 unsigned int a_entry; /* where program begins */
20 unsigned int a_trsize;
21 unsigned int a_drsize;
22};
23
24#endif /* !__ASSEMBLY__ */
25
26/* Where in the file does the text information begin? */
27#define N_TXTOFF(x) (N_MAGIC(x) == ZMAGIC ? 0 : sizeof (struct exec))
28
29/* Where do the Symbols start? */
30#define N_SYMOFF(x) (N_TXTOFF(x) + (x).a_text + \
31 (x).a_data + (x).a_trsize + \
32 (x).a_drsize)
33
34/* Where does text segment go in memory after being loaded? */
35#define N_TXTADDR(x) (unsigned long)(((N_MAGIC(x) == ZMAGIC) && \
36 ((x).a_entry < SPARC_PGSIZE)) ? \
37 0 : SPARC_PGSIZE)
38
39/* And same for the data segment.. */
40#define N_DATADDR(x) (N_MAGIC(x)==OMAGIC ? \
41 (N_TXTADDR(x) + (x).a_text) \
42 : (unsigned long)(_N_SEGMENT_ROUND (_N_TXTENDADDR(x))))
43
44#define N_TRSIZE(a) ((a).a_trsize)
45#define N_DRSIZE(a) ((a).a_drsize)
46#define N_SYMSIZE(a) ((a).a_syms)
47
48#ifndef __ASSEMBLY__
49
50/*
51 * Sparc relocation types
52 */
53enum reloc_type
54{
55 RELOC_8,
56 RELOC_16,
57 RELOC_32, /* simplest relocs */
58 RELOC_DISP8,
59 RELOC_DISP16,
60 RELOC_DISP32, /* Disp's (pc-rel) */
61 RELOC_WDISP30,
62 RELOC_WDISP22, /* SR word disp's */
63 RELOC_HI22,
64 RELOC_22, /* SR 22-bit relocs */
65 RELOC_13,
66 RELOC_LO10, /* SR 13&10-bit relocs */
67 RELOC_SFA_BASE,
68 RELOC_SFA_OFF13, /* SR S.F.A. relocs */
69 RELOC_BASE10,
70 RELOC_BASE13,
71 RELOC_BASE22, /* base_relative pic */
72 RELOC_PC10,
73 RELOC_PC22, /* special pc-rel pic */
74 RELOC_JMP_TBL, /* jmp_tbl_rel in pic */
75 RELOC_SEGOFF16, /* ShLib offset-in-seg */
76 RELOC_GLOB_DAT,
77 RELOC_JMP_SLOT,
78 RELOC_RELATIVE /* rtld relocs */
79};
80
81/*
82 * Format of a relocation datum.
83 */
84struct relocation_info /* used when header.a_machtype == M_SPARC */
85{
86 unsigned int r_address; /* relocation addr */
87 unsigned int r_index:24; /* segment index or symbol index */
88 unsigned int r_extern:1; /* if F, r_index==SEG#; if T, SYM idx */
89 unsigned int r_pad:2; /* <unused> */
90 enum reloc_type r_type:5; /* type of relocation to perform */
91 int r_addend; /* addend for relocation value */
92};
93
94#define N_RELOCATION_INFO_DECLARED 1
95
96#endif /* !(__ASSEMBLY__) */
97
98#endif /* !(__SPARC64_A_OUT_H__) */
diff --git a/include/asm-sparc64/auxvec.h b/include/asm-sparc64/auxvec.h
index 436a29129828..1f45c67d7316 100644
--- a/include/asm-sparc64/auxvec.h
+++ b/include/asm-sparc64/auxvec.h
@@ -1,4 +1 @@
1#ifndef __ASM_SPARC64_AUXVEC_H #include <asm-sparc/auxvec.h>
2#define __ASM_SPARC64_AUXVEC_H
3
4#endif /* !(__ASM_SPARC64_AUXVEC_H) */
diff --git a/include/asm-sparc64/bpp.h b/include/asm-sparc64/bpp.h
index abe163a50382..514eee20272e 100644
--- a/include/asm-sparc64/bpp.h
+++ b/include/asm-sparc64/bpp.h
@@ -1,73 +1 @@
1#ifndef _SPARC64_BPP_H #include <asm-sparc/bpp.h>
2#define _SPARC64_BPP_H
3
4/*
5 * Copyright (c) 1995 Picture Elements
6 * Stephen Williams
7 * Gus Baldauf
8 *
9 * Linux/SPARC port by Peter Zaitcev.
10 * Integration into SPARC tree by Tom Dyas.
11 */
12
13#include <linux/ioctl.h>
14
15/*
16 * This is a driver that supports IEEE Std 1284-1994 communications
17 * with compliant or compatible devices. It will use whatever features
18 * the device supports, prefering those that are typically faster.
19 *
20 * When the device is opened, it is left in COMPATIBILITY mode, and
21 * writes work like any printer device. The driver only attempt to
22 * negotiate 1284 modes when needed so that plugs can be pulled,
23 * switch boxes switched, etc., without disrupting things. It will
24 * also leave the device in compatibility mode when closed.
25 */
26
27
28
29/*
30 * This driver also supplies ioctls to manually manipulate the
31 * pins. This is great for testing devices, or writing code to deal
32 * with bizzarro-mode of the ACME Special TurboThingy Plus.
33 *
34 * NOTE: These ioctl currently do not interact well with
35 * read/write. Caveat emptor.
36 *
37 * PUT_PINS allows us to assign the sense of all the pins, including
38 * the data pins if being driven by the host. The GET_PINS returns the
39 * pins that the peripheral drives, including data if appropriate.
40 */
41
42# define BPP_PUT_PINS _IOW('B', 1, int)
43# define BPP_GET_PINS _IOR('B', 2, char) /* that's bogus - should've been _IO */
44# define BPP_PUT_DATA _IOW('B', 3, int)
45# define BPP_GET_DATA _IOR('B', 4, char) /* ditto */
46
47/*
48 * Set the data bus to input mode. Disengage the data bin driver and
49 * be prepared to read values from the peripheral. If the arg is 0,
50 * then revert the bus to output mode.
51 */
52# define BPP_SET_INPUT _IOW('B', 5, int)
53
54/*
55 * These bits apply to the PUT operation...
56 */
57# define BPP_PP_nStrobe 0x0001
58# define BPP_PP_nAutoFd 0x0002
59# define BPP_PP_nInit 0x0004
60# define BPP_PP_nSelectIn 0x0008
61
62/*
63 * These apply to the GET operation, which also reads the current value
64 * of the previously put values. A bit mask of these will be returned
65 * as a bit mask in the return code of the ioctl().
66 */
67# define BPP_GP_nAck 0x0100
68# define BPP_GP_Busy 0x0200
69# define BPP_GP_PError 0x0400
70# define BPP_GP_Select 0x0800
71# define BPP_GP_nFault 0x1000
72
73#endif
diff --git a/include/asm-sparc64/bsderrno.h b/include/asm-sparc64/bsderrno.h
deleted file mode 100644
index 52fe880d2af8..000000000000
--- a/include/asm-sparc64/bsderrno.h
+++ /dev/null
@@ -1,94 +0,0 @@
1/* $Id: bsderrno.h,v 1.1 1996/12/26 13:25:21 davem Exp $
2 * bsderrno.h: Error numbers for NetBSD binary compatibility
3 *
4 * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
5 */
6
7#ifndef _SPARC64_BSDERRNO_H
8#define _SPARC64_BSDERRNO_H
9
10#define BSD_EPERM 1 /* Operation not permitted */
11#define BSD_ENOENT 2 /* No such file or directory */
12#define BSD_ESRCH 3 /* No such process */
13#define BSD_EINTR 4 /* Interrupted system call */
14#define BSD_EIO 5 /* Input/output error */
15#define BSD_ENXIO 6 /* Device not configured */
16#define BSD_E2BIG 7 /* Argument list too long */
17#define BSD_ENOEXEC 8 /* Exec format error */
18#define BSD_EBADF 9 /* Bad file descriptor */
19#define BSD_ECHILD 10 /* No child processes */
20#define BSD_EDEADLK 11 /* Resource deadlock avoided */
21#define BSD_ENOMEM 12 /* Cannot allocate memory */
22#define BSD_EACCES 13 /* Permission denied */
23#define BSD_EFAULT 14 /* Bad address */
24#define BSD_ENOTBLK 15 /* Block device required */
25#define BSD_EBUSY 16 /* Device busy */
26#define BSD_EEXIST 17 /* File exists */
27#define BSD_EXDEV 18 /* Cross-device link */
28#define BSD_ENODEV 19 /* Operation not supported by device */
29#define BSD_ENOTDIR 20 /* Not a directory */
30#define BSD_EISDIR 21 /* Is a directory */
31#define BSD_EINVAL 22 /* Invalid argument */
32#define BSD_ENFILE 23 /* Too many open files in system */
33#define BSD_EMFILE 24 /* Too many open files */
34#define BSD_ENOTTY 25 /* Inappropriate ioctl for device */
35#define BSD_ETXTBSY 26 /* Text file busy */
36#define BSD_EFBIG 27 /* File too large */
37#define BSD_ENOSPC 28 /* No space left on device */
38#define BSD_ESPIPE 29 /* Illegal seek */
39#define BSD_EROFS 30 /* Read-only file system */
40#define BSD_EMLINK 31 /* Too many links */
41#define BSD_EPIPE 32 /* Broken pipe */
42#define BSD_EDOM 33 /* Numerical argument out of domain */
43#define BSD_ERANGE 34 /* Result too large */
44#define BSD_EAGAIN 35 /* Resource temporarily unavailable */
45#define BSD_EWOULDBLOCK EAGAIN /* Operation would block */
46#define BSD_EINPROGRESS 36 /* Operation now in progress */
47#define BSD_EALREADY 37 /* Operation already in progress */
48#define BSD_ENOTSOCK 38 /* Socket operation on non-socket */
49#define BSD_EDESTADDRREQ 39 /* Destination address required */
50#define BSD_EMSGSIZE 40 /* Message too long */
51#define BSD_EPROTOTYPE 41 /* Protocol wrong type for socket */
52#define BSD_ENOPROTOOPT 42 /* Protocol not available */
53#define BSD_EPROTONOSUPPORT 43 /* Protocol not supported */
54#define BSD_ESOCKTNOSUPPORT 44 /* Socket type not supported */
55#define BSD_EOPNOTSUPP 45 /* Operation not supported */
56#define BSD_EPFNOSUPPORT 46 /* Protocol family not supported */
57#define BSD_EAFNOSUPPORT 47 /* Address family not supported by protocol family */
58#define BSD_EADDRINUSE 48 /* Address already in use */
59#define BSD_EADDRNOTAVAIL 49 /* Can't assign requested address */
60#define BSD_ENETDOWN 50 /* Network is down */
61#define BSD_ENETUNREACH 51 /* Network is unreachable */
62#define BSD_ENETRESET 52 /* Network dropped connection on reset */
63#define BSD_ECONNABORTED 53 /* Software caused connection abort */
64#define BSD_ECONNRESET 54 /* Connection reset by peer */
65#define BSD_ENOBUFS 55 /* No buffer space available */
66#define BSD_EISCONN 56 /* Socket is already connected */
67#define BSD_ENOTCONN 57 /* Socket is not connected */
68#define BSD_ESHUTDOWN 58 /* Can't send after socket shutdown */
69#define BSD_ETOOMANYREFS 59 /* Too many references: can't splice */
70#define BSD_ETIMEDOUT 60 /* Operation timed out */
71#define BSD_ECONNREFUSED 61 /* Connection refused */
72#define BSD_ELOOP 62 /* Too many levels of symbolic links */
73#define BSD_ENAMETOOLONG 63 /* File name too long */
74#define BSD_EHOSTDOWN 64 /* Host is down */
75#define BSD_EHOSTUNREACH 65 /* No route to host */
76#define BSD_ENOTEMPTY 66 /* Directory not empty */
77#define BSD_EPROCLIM 67 /* Too many processes */
78#define BSD_EUSERS 68 /* Too many users */
79#define BSD_EDQUOT 69 /* Disc quota exceeded */
80#define BSD_ESTALE 70 /* Stale NFS file handle */
81#define BSD_EREMOTE 71 /* Too many levels of remote in path */
82#define BSD_EBADRPC 72 /* RPC struct is bad */
83#define BSD_ERPCMISMATCH 73 /* RPC version wrong */
84#define BSD_EPROGUNAVAIL 74 /* RPC prog. not avail */
85#define BSD_EPROGMISMATCH 75 /* Program version wrong */
86#define BSD_EPROCUNAVAIL 76 /* Bad procedure for program */
87#define BSD_ENOLCK 77 /* No locks available */
88#define BSD_ENOSYS 78 /* Function not implemented */
89#define BSD_EFTYPE 79 /* Inappropriate file type or format */
90#define BSD_EAUTH 80 /* Authentication error */
91#define BSD_ENEEDAUTH 81 /* Need authenticator */
92#define BSD_ELAST 81 /* Must be equal largest errno */
93
94#endif /* !(_SPARC64_BSDERRNO_H) */
diff --git a/include/asm-sparc64/bug.h b/include/asm-sparc64/bug.h
index 516bb27f3fc4..3433737c7a67 100644
--- a/include/asm-sparc64/bug.h
+++ b/include/asm-sparc64/bug.h
@@ -1,22 +1 @@
1#ifndef _SPARC64_BUG_H #include <asm-sparc/bug.h>
2#define _SPARC64_BUG_H
3
4#ifdef CONFIG_BUG
5#include <linux/compiler.h>
6
7#ifdef CONFIG_DEBUG_BUGVERBOSE
8extern void do_BUG(const char *file, int line);
9#define BUG() do { \
10 do_BUG(__FILE__, __LINE__); \
11 __builtin_trap(); \
12} while (0)
13#else
14#define BUG() __builtin_trap()
15#endif
16
17#define HAVE_ARCH_BUG
18#endif
19
20#include <asm-generic/bug.h>
21
22#endif
diff --git a/include/asm-sparc64/bugs.h b/include/asm-sparc64/bugs.h
index 11ade6841971..04ae9e2818cf 100644
--- a/include/asm-sparc64/bugs.h
+++ b/include/asm-sparc64/bugs.h
@@ -1,10 +1 @@
1/* bugs.h: Sparc64 probes for various bugs. #include <asm-sparc/bugs.h>
2 *
3 * Copyright (C) 1996, 2007 David S. Miller (davem@davemloft.net)
4 */
5#include <asm/sstate.h>
6
7static void __init check_bugs(void)
8{
9 sstate_running();
10}
diff --git a/include/asm-sparc64/byteorder.h b/include/asm-sparc64/byteorder.h
index 3943022906fd..f672855bee17 100644
--- a/include/asm-sparc64/byteorder.h
+++ b/include/asm-sparc64/byteorder.h
@@ -1,49 +1 @@
1#ifndef _SPARC64_BYTEORDER_H #include <asm-sparc/byteorder.h>
2#define _SPARC64_BYTEORDER_H
3
4#include <asm/types.h>
5#include <asm/asi.h>
6
7#ifdef __GNUC__
8
9static inline __u16 ___arch__swab16p(const __u16 *addr)
10{
11 __u16 ret;
12
13 __asm__ __volatile__ ("lduha [%1] %2, %0"
14 : "=r" (ret)
15 : "r" (addr), "i" (ASI_PL));
16 return ret;
17}
18
19static inline __u32 ___arch__swab32p(const __u32 *addr)
20{
21 __u32 ret;
22
23 __asm__ __volatile__ ("lduwa [%1] %2, %0"
24 : "=r" (ret)
25 : "r" (addr), "i" (ASI_PL));
26 return ret;
27}
28
29static inline __u64 ___arch__swab64p(const __u64 *addr)
30{
31 __u64 ret;
32
33 __asm__ __volatile__ ("ldxa [%1] %2, %0"
34 : "=r" (ret)
35 : "r" (addr), "i" (ASI_PL));
36 return ret;
37}
38
39#define __arch__swab16p(x) ___arch__swab16p(x)
40#define __arch__swab32p(x) ___arch__swab32p(x)
41#define __arch__swab64p(x) ___arch__swab64p(x)
42
43#define __BYTEORDER_HAS_U64__
44
45#endif /* __GNUC__ */
46
47#include <linux/byteorder/big_endian.h>
48
49#endif /* _SPARC64_BYTEORDER_H */
diff --git a/include/asm-sparc64/cache.h b/include/asm-sparc64/cache.h
index e9df17acedde..fa9de5cadbf1 100644
--- a/include/asm-sparc64/cache.h
+++ b/include/asm-sparc64/cache.h
@@ -1,18 +1 @@
1/* #include <asm-sparc/cache.h>
2 * include/asm-sparc64/cache.h
3 */
4#ifndef __ARCH_SPARC64_CACHE_H
5#define __ARCH_SPARC64_CACHE_H
6
7/* bytes per L1 cache line */
8#define L1_CACHE_SHIFT 5
9#define L1_CACHE_BYTES 32 /* Two 16-byte sub-blocks per line. */
10
11#define L1_CACHE_ALIGN(x) (((x)+(L1_CACHE_BYTES-1))&~(L1_CACHE_BYTES-1))
12
13#define SMP_CACHE_BYTES_SHIFT 6
14#define SMP_CACHE_BYTES (1 << SMP_CACHE_BYTES_SHIFT) /* L2 cache line size. */
15
16#define __read_mostly __attribute__((__section__(".data.read_mostly")))
17
18#endif
diff --git a/include/asm-sparc64/cputime.h b/include/asm-sparc64/cputime.h
index dec2fc7a36f8..435f37a92f7c 100644
--- a/include/asm-sparc64/cputime.h
+++ b/include/asm-sparc64/cputime.h
@@ -1,6 +1 @@
1#ifndef __SPARC64_CPUTIME_H #include <asm-sparc/cputime.h>
2#define __SPARC64_CPUTIME_H
3
4#include <asm-generic/cputime.h>
5
6#endif /* __SPARC64_CPUTIME_H */
diff --git a/include/asm-sparc64/current.h b/include/asm-sparc64/current.h
index 6c21e4ee2475..a7904a7f53a8 100644
--- a/include/asm-sparc64/current.h
+++ b/include/asm-sparc64/current.h
@@ -1,8 +1 @@
1#ifndef _SPARC64_CURRENT_H #include <asm-sparc/current.h>
2#define _SPARC64_CURRENT_H
3
4#include <linux/thread_info.h>
5
6register struct task_struct *current asm("g4");
7
8#endif /* !(_SPARC64_CURRENT_H) */
diff --git a/include/asm-sparc64/device.h b/include/asm-sparc64/device.h
index 5111e8717be3..4145c47097e2 100644
--- a/include/asm-sparc64/device.h
+++ b/include/asm-sparc64/device.h
@@ -1,21 +1 @@
1/* #include <asm-sparc/device.h>
2 * Arch specific extensions to struct device
3 *
4 * This file is released under the GPLv2
5 */
6#ifndef _ASM_SPARC64_DEVICE_H
7#define _ASM_SPARC64_DEVICE_H
8
9struct device_node;
10struct of_device;
11
12struct dev_archdata {
13 void *iommu;
14 void *stc;
15 void *host_controller;
16
17 struct device_node *prom_node;
18 struct of_device *op;
19};
20
21#endif /* _ASM_SPARC64_DEVICE_H */
diff --git a/include/asm-sparc64/div64.h b/include/asm-sparc64/div64.h
index 6cd978cefb28..928c94f99ecf 100644
--- a/include/asm-sparc64/div64.h
+++ b/include/asm-sparc64/div64.h
@@ -1 +1 @@
#include <asm-generic/div64.h> #include <asm-sparc/div64.h>
diff --git a/include/asm-sparc64/emergency-restart.h b/include/asm-sparc64/emergency-restart.h
index 108d8c48e42e..2cac7b644da8 100644
--- a/include/asm-sparc64/emergency-restart.h
+++ b/include/asm-sparc64/emergency-restart.h
@@ -1,6 +1 @@
1#ifndef _ASM_EMERGENCY_RESTART_H #include <asm-sparc/emergency-restart.h>
2#define _ASM_EMERGENCY_RESTART_H
3
4#include <asm-generic/emergency-restart.h>
5
6#endif /* _ASM_EMERGENCY_RESTART_H */
diff --git a/include/asm-sparc64/errno.h b/include/asm-sparc64/errno.h
index ea3509ee1b0b..9701fe01cc53 100644
--- a/include/asm-sparc64/errno.h
+++ b/include/asm-sparc64/errno.h
@@ -1,114 +1 @@
1/* $Id: errno.h,v 1.2 1997/04/15 12:46:11 jj Exp $ */ #include <asm-sparc/errno.h>
2#ifndef _SPARC64_ERRNO_H
3#define _SPARC64_ERRNO_H
4
5/* These match the SunOS error numbering scheme. */
6
7#include <asm-generic/errno-base.h>
8
9#define EWOULDBLOCK EAGAIN /* Operation would block */
10#define EINPROGRESS 36 /* Operation now in progress */
11#define EALREADY 37 /* Operation already in progress */
12#define ENOTSOCK 38 /* Socket operation on non-socket */
13#define EDESTADDRREQ 39 /* Destination address required */
14#define EMSGSIZE 40 /* Message too long */
15#define EPROTOTYPE 41 /* Protocol wrong type for socket */
16#define ENOPROTOOPT 42 /* Protocol not available */
17#define EPROTONOSUPPORT 43 /* Protocol not supported */
18#define ESOCKTNOSUPPORT 44 /* Socket type not supported */
19#define EOPNOTSUPP 45 /* Op not supported on transport endpoint */
20#define EPFNOSUPPORT 46 /* Protocol family not supported */
21#define EAFNOSUPPORT 47 /* Address family not supported by protocol */
22#define EADDRINUSE 48 /* Address already in use */
23#define EADDRNOTAVAIL 49 /* Cannot assign requested address */
24#define ENETDOWN 50 /* Network is down */
25#define ENETUNREACH 51 /* Network is unreachable */
26#define ENETRESET 52 /* Net dropped connection because of reset */
27#define ECONNABORTED 53 /* Software caused connection abort */
28#define ECONNRESET 54 /* Connection reset by peer */
29#define ENOBUFS 55 /* No buffer space available */
30#define EISCONN 56 /* Transport endpoint is already connected */
31#define ENOTCONN 57 /* Transport endpoint is not connected */
32#define ESHUTDOWN 58 /* No send after transport endpoint shutdown */
33#define ETOOMANYREFS 59 /* Too many references: cannot splice */
34#define ETIMEDOUT 60 /* Connection timed out */
35#define ECONNREFUSED 61 /* Connection refused */
36#define ELOOP 62 /* Too many symbolic links encountered */
37#define ENAMETOOLONG 63 /* File name too long */
38#define EHOSTDOWN 64 /* Host is down */
39#define EHOSTUNREACH 65 /* No route to host */
40#define ENOTEMPTY 66 /* Directory not empty */
41#define EPROCLIM 67 /* SUNOS: Too many processes */
42#define EUSERS 68 /* Too many users */
43#define EDQUOT 69 /* Quota exceeded */
44#define ESTALE 70 /* Stale NFS file handle */
45#define EREMOTE 71 /* Object is remote */
46#define ENOSTR 72 /* Device not a stream */
47#define ETIME 73 /* Timer expired */
48#define ENOSR 74 /* Out of streams resources */
49#define ENOMSG 75 /* No message of desired type */
50#define EBADMSG 76 /* Not a data message */
51#define EIDRM 77 /* Identifier removed */
52#define EDEADLK 78 /* Resource deadlock would occur */
53#define ENOLCK 79 /* No record locks available */
54#define ENONET 80 /* Machine is not on the network */
55#define ERREMOTE 81 /* SunOS: Too many lvls of remote in path */
56#define ENOLINK 82 /* Link has been severed */
57#define EADV 83 /* Advertise error */
58#define ESRMNT 84 /* Srmount error */
59#define ECOMM 85 /* Communication error on send */
60#define EPROTO 86 /* Protocol error */
61#define EMULTIHOP 87 /* Multihop attempted */
62#define EDOTDOT 88 /* RFS specific error */
63#define EREMCHG 89 /* Remote address changed */
64#define ENOSYS 90 /* Function not implemented */
65
66/* The rest have no SunOS equivalent. */
67#define ESTRPIPE 91 /* Streams pipe error */
68#define EOVERFLOW 92 /* Value too large for defined data type */
69#define EBADFD 93 /* File descriptor in bad state */
70#define ECHRNG 94 /* Channel number out of range */
71#define EL2NSYNC 95 /* Level 2 not synchronized */
72#define EL3HLT 96 /* Level 3 halted */
73#define EL3RST 97 /* Level 3 reset */
74#define ELNRNG 98 /* Link number out of range */
75#define EUNATCH 99 /* Protocol driver not attached */
76#define ENOCSI 100 /* No CSI structure available */
77#define EL2HLT 101 /* Level 2 halted */
78#define EBADE 102 /* Invalid exchange */
79#define EBADR 103 /* Invalid request descriptor */
80#define EXFULL 104 /* Exchange full */
81#define ENOANO 105 /* No anode */
82#define EBADRQC 106 /* Invalid request code */
83#define EBADSLT 107 /* Invalid slot */
84#define EDEADLOCK 108 /* File locking deadlock error */
85#define EBFONT 109 /* Bad font file format */
86#define ELIBEXEC 110 /* Cannot exec a shared library directly */
87#define ENODATA 111 /* No data available */
88#define ELIBBAD 112 /* Accessing a corrupted shared library */
89#define ENOPKG 113 /* Package not installed */
90#define ELIBACC 114 /* Can not access a needed shared library */
91#define ENOTUNIQ 115 /* Name not unique on network */
92#define ERESTART 116 /* Interrupted syscall should be restarted */
93#define EUCLEAN 117 /* Structure needs cleaning */
94#define ENOTNAM 118 /* Not a XENIX named type file */
95#define ENAVAIL 119 /* No XENIX semaphores available */
96#define EISNAM 120 /* Is a named type file */
97#define EREMOTEIO 121 /* Remote I/O error */
98#define EILSEQ 122 /* Illegal byte sequence */
99#define ELIBMAX 123 /* Atmpt to link in too many shared libs */
100#define ELIBSCN 124 /* .lib section in a.out corrupted */
101
102#define ENOMEDIUM 125 /* No medium found */
103#define EMEDIUMTYPE 126 /* Wrong medium type */
104#define ECANCELED 127 /* Operation Cancelled */
105#define ENOKEY 128 /* Required key not available */
106#define EKEYEXPIRED 129 /* Key has expired */
107#define EKEYREVOKED 130 /* Key has been revoked */
108#define EKEYREJECTED 131 /* Key was rejected by service */
109
110/* for robust mutexes */
111#define EOWNERDEAD 132 /* Owner died */
112#define ENOTRECOVERABLE 133 /* State not recoverable */
113
114#endif /* !(_SPARC64_ERRNO_H) */
diff --git a/include/asm-sparc64/fb.h b/include/asm-sparc64/fb.h
index 389012e5fbad..1c2ac5832f39 100644
--- a/include/asm-sparc64/fb.h
+++ b/include/asm-sparc64/fb.h
@@ -1,27 +1 @@
1#ifndef _ASM_FB_H_ #include <asm-sparc/fb.h>
2#define _ASM_FB_H_
3#include <linux/fb.h>
4#include <linux/fs.h>
5#include <asm/page.h>
6#include <asm/prom.h>
7
8static inline void fb_pgprotect(struct file *file, struct vm_area_struct *vma,
9 unsigned long off)
10{
11 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
12}
13
14static inline int fb_is_primary_device(struct fb_info *info)
15{
16 struct device *dev = info->device;
17 struct device_node *node;
18
19 node = dev->archdata.prom_node;
20 if (node &&
21 node == of_console_device)
22 return 1;
23
24 return 0;
25}
26
27#endif /* _ASM_FB_H_ */
diff --git a/include/asm-sparc64/io.h b/include/asm-sparc64/io.h
index b6ece223562d..c299b853b5ba 100644
--- a/include/asm-sparc64/io.h
+++ b/include/asm-sparc64/io.h
@@ -16,7 +16,7 @@
16/* BIO layer definitions. */ 16/* BIO layer definitions. */
17extern unsigned long kern_base, kern_size; 17extern unsigned long kern_base, kern_size;
18#define page_to_phys(page) (page_to_pfn(page) << PAGE_SHIFT) 18#define page_to_phys(page) (page_to_pfn(page) << PAGE_SHIFT)
19#define BIO_VMERGE_BOUNDARY 0 19#define BIO_VMERGE_BOUNDARY 8192
20 20
21static inline u8 _inb(unsigned long addr) 21static inline u8 _inb(unsigned long addr)
22{ 22{
diff --git a/include/asm-sparc64/iommu.h b/include/asm-sparc64/iommu.h
index 9eac6676caf1..46325ddee23b 100644
--- a/include/asm-sparc64/iommu.h
+++ b/include/asm-sparc64/iommu.h
@@ -26,6 +26,7 @@ struct iommu_arena {
26struct iommu { 26struct iommu {
27 spinlock_t lock; 27 spinlock_t lock;
28 struct iommu_arena arena; 28 struct iommu_arena arena;
29 void (*flush_all)(struct iommu *);
29 iopte_t *page_table; 30 iopte_t *page_table;
30 u32 page_table_map_base; 31 u32 page_table_map_base;
31 unsigned long iommu_control; 32 unsigned long iommu_control;
diff --git a/include/asm-sparc64/kprobes.h b/include/asm-sparc64/kprobes.h
index 5020eaf67c29..7237dd87663e 100644
--- a/include/asm-sparc64/kprobes.h
+++ b/include/asm-sparc64/kprobes.h
@@ -14,11 +14,15 @@ typedef u32 kprobe_opcode_t;
14 14
15#define arch_remove_kprobe(p) do {} while (0) 15#define arch_remove_kprobe(p) do {} while (0)
16 16
17#define ARCH_SUPPORTS_KRETPROBES
18
17#define flush_insn_slot(p) \ 19#define flush_insn_slot(p) \
18do { flushi(&(p)->ainsn.insn[0]); \ 20do { flushi(&(p)->ainsn.insn[0]); \
19 flushi(&(p)->ainsn.insn[1]); \ 21 flushi(&(p)->ainsn.insn[1]); \
20} while (0) 22} while (0)
21 23
24void kretprobe_trampoline(void);
25
22/* Architecture specific copy of original instruction*/ 26/* Architecture specific copy of original instruction*/
23struct arch_specific_insn { 27struct arch_specific_insn {
24 /* copy of the original instruction */ 28 /* copy of the original instruction */
diff --git a/include/asm-sparc64/of_device.h b/include/asm-sparc64/of_device.h
index 46d69b3223c5..a769fdbe164a 100644
--- a/include/asm-sparc64/of_device.h
+++ b/include/asm-sparc64/of_device.h
@@ -1,38 +1 @@
1#ifndef _ASM_SPARC64_OF_DEVICE_H #include <asm-sparc/of_device.h>
2#define _ASM_SPARC64_OF_DEVICE_H
3#ifdef __KERNEL__
4
5#include <linux/device.h>
6#include <linux/of.h>
7#include <linux/mod_devicetable.h>
8#include <asm/openprom.h>
9
10/*
11 * The of_device is a kind of "base class" that is a superset of
12 * struct device for use by devices attached to an OF node and
13 * probed using OF properties.
14 */
15struct of_device
16{
17 struct device_node *node;
18 struct device dev;
19 struct resource resource[PROMREG_MAX];
20 unsigned int irqs[PROMINTR_MAX];
21 int num_irqs;
22
23 void *sysdata;
24
25 int slot;
26 int portid;
27 int clock_freq;
28};
29
30extern void __iomem *of_ioremap(struct resource *res, unsigned long offset, unsigned long size, char *name);
31extern void of_iounmap(struct resource *res, void __iomem *base, unsigned long size);
32
33/* These are just here during the transition */
34#include <linux/of_device.h>
35#include <linux/of_platform.h>
36
37#endif /* __KERNEL__ */
38#endif /* _ASM_SPARC64_OF_DEVICE_H */
diff --git a/include/asm-sparc64/of_platform.h b/include/asm-sparc64/of_platform.h
index f15cfa723916..78aa032b674c 100644
--- a/include/asm-sparc64/of_platform.h
+++ b/include/asm-sparc64/of_platform.h
@@ -22,9 +22,4 @@ extern struct bus_type sbus_bus_type;
22 22
23#define of_bus_type of_platform_bus_type /* for compatibility */ 23#define of_bus_type of_platform_bus_type /* for compatibility */
24 24
25extern struct of_device *of_platform_device_create(struct device_node *np,
26 const char *bus_id,
27 struct device *parent,
28 struct bus_type *bus);
29
30#endif /* _ASM_SPARC64_OF_PLATFORM_H */ 25#endif /* _ASM_SPARC64_OF_PLATFORM_H */
diff --git a/include/asm-sparc64/prom.h b/include/asm-sparc64/prom.h
index 07843f9f05df..5fa166ee3ffa 100644
--- a/include/asm-sparc64/prom.h
+++ b/include/asm-sparc64/prom.h
@@ -1,103 +1 @@
1#ifndef _SPARC64_PROM_H #include <asm-sparc/prom.h>
2#define _SPARC64_PROM_H
3#ifdef __KERNEL__
4
5/*
6 * Definitions for talking to the Open Firmware PROM on
7 * Power Macintosh computers.
8 *
9 * Copyright (C) 1996-2005 Paul Mackerras.
10 *
11 * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp.
12 * Updates for SPARC64 by David S. Miller
13 *
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * as published by the Free Software Foundation; either version
17 * 2 of the License, or (at your option) any later version.
18 */
19#include <linux/types.h>
20#include <linux/proc_fs.h>
21#include <asm/atomic.h>
22
23#define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 2
24#define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1
25
26#define of_compat_cmp(s1, s2, l) strncmp((s1), (s2), (l))
27#define of_prop_cmp(s1, s2) strcasecmp((s1), (s2))
28#define of_node_cmp(s1, s2) strcmp((s1), (s2))
29
30typedef u32 phandle;
31typedef u32 ihandle;
32
33struct property {
34 char *name;
35 int length;
36 void *value;
37 struct property *next;
38 unsigned long _flags;
39 unsigned int unique_id;
40};
41
42struct of_irq_controller;
43struct device_node {
44 const char *name;
45 const char *type;
46 phandle node;
47 char *path_component_name;
48 char *full_name;
49
50 struct property *properties;
51 struct property *deadprops; /* removed properties */
52 struct device_node *parent;
53 struct device_node *child;
54 struct device_node *sibling;
55 struct device_node *next; /* next device of same type */
56 struct device_node *allnext; /* next in list of all nodes */
57 struct proc_dir_entry *pde; /* this node's proc directory */
58 struct kref kref;
59 unsigned long _flags;
60 void *data;
61 unsigned int unique_id;
62
63 struct of_irq_controller *irq_trans;
64};
65
66struct of_irq_controller {
67 unsigned int (*irq_build)(struct device_node *, unsigned int, void *);
68 void *data;
69};
70
71#define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
72#define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
73
74extern struct device_node *of_find_node_by_cpuid(int cpuid);
75extern int of_set_property(struct device_node *node, const char *name, void *val, int len);
76extern int of_getintprop_default(struct device_node *np,
77 const char *name,
78 int def);
79extern int of_find_in_proplist(const char *list, const char *match, int len);
80
81extern void prom_build_devicetree(void);
82
83/* Dummy ref counting routines - to be implemented later */
84static inline struct device_node *of_node_get(struct device_node *node)
85{
86 return node;
87}
88static inline void of_node_put(struct device_node *node)
89{
90}
91
92/*
93 * NB: This is here while we transition from using asm/prom.h
94 * to linux/of.h
95 */
96#include <linux/of.h>
97
98extern struct device_node *of_console_device;
99extern char *of_console_path;
100extern char *of_console_options;
101
102#endif /* __KERNEL__ */
103#endif /* _SPARC64_PROM_H */
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-21 00:07:04 -0500