1 /* $Id: sbus.c,v 1.19 2002/01/23 11:27:32 davem Exp $
2 * sbus.c: UltraSparc SBUS controller support.
4 * Copyright (C) 1999 David S. Miller (davem@redhat.com)
7 #include <linux/kernel.h>
8 #include <linux/types.h>
10 #include <linux/spinlock.h>
11 #include <linux/slab.h>
12 #include <linux/init.h>
13 #include <linux/interrupt.h>
19 #include <asm/cache.h>
22 #include <asm/starfire.h>
24 #include "iommu_common.h"
26 /* These should be allocated on an SMP_CACHE_BYTES
27 * aligned boundary for optimal performance.
29 * On SYSIO, using an 8K page size we have 1GB of SBUS
30 * DMA space mapped. We divide this space into equally
31 * sized clusters. We allocate a DMA mapping from the
32 * cluster that matches the order of the allocation, or
33 * if the order is greater than the number of clusters,
34 * we try to allocate from the last cluster.
38 #define ONE_GIG (1UL * 1024UL * 1024UL * 1024UL)
39 #define CLUSTER_SIZE (ONE_GIG / NCLUSTERS)
40 #define CLUSTER_MASK (CLUSTER_SIZE - 1)
41 #define CLUSTER_NPAGES (CLUSTER_SIZE >> IO_PAGE_SHIFT)
42 #define MAP_BASE ((u32)0xc0000000)
45 /*0x00*/spinlock_t lock
;
47 /*0x08*/iopte_t
*page_table
;
48 /*0x10*/unsigned long strbuf_regs
;
49 /*0x18*/unsigned long iommu_regs
;
50 /*0x20*/unsigned long sbus_control_reg
;
52 /*0x28*/volatile unsigned long strbuf_flushflag
;
54 /* If NCLUSTERS is ever decresed to 4 or lower,
55 * you must increase the size of the type of
56 * these counters. You have been duly warned. -DaveM
61 } alloc_info
[NCLUSTERS
];
63 /* The lowest used consistent mapping entry. Since
64 * we allocate consistent maps out of cluster 0 this
65 * is relative to the beginning of closter 0.
67 /*0x50*/u32 lowest_consistent_map
;
70 /* Offsets from iommu_regs */
71 #define SYSIO_IOMMUREG_BASE 0x2400UL
72 #define IOMMU_CONTROL (0x2400UL - 0x2400UL) /* IOMMU control register */
73 #define IOMMU_TSBBASE (0x2408UL - 0x2400UL) /* TSB base address register */
74 #define IOMMU_FLUSH (0x2410UL - 0x2400UL) /* IOMMU flush register */
75 #define IOMMU_VADIAG (0x4400UL - 0x2400UL) /* SBUS virtual address diagnostic */
76 #define IOMMU_TAGCMP (0x4408UL - 0x2400UL) /* TLB tag compare diagnostics */
77 #define IOMMU_LRUDIAG (0x4500UL - 0x2400UL) /* IOMMU LRU queue diagnostics */
78 #define IOMMU_TAGDIAG (0x4580UL - 0x2400UL) /* TLB tag diagnostics */
79 #define IOMMU_DRAMDIAG (0x4600UL - 0x2400UL) /* TLB data RAM diagnostics */
81 #define IOMMU_DRAM_VALID (1UL << 30UL)
83 static void __iommu_flushall(struct sbus_iommu
*iommu
)
85 unsigned long tag
= iommu
->iommu_regs
+ IOMMU_TAGDIAG
;
88 for (entry
= 0; entry
< 16; entry
++) {
92 upa_readq(iommu
->sbus_control_reg
);
94 for (entry
= 0; entry
< NCLUSTERS
; entry
++) {
95 iommu
->alloc_info
[entry
].flush
=
96 iommu
->alloc_info
[entry
].next
;
100 static void iommu_flush(struct sbus_iommu
*iommu
, u32 base
, unsigned long npages
)
103 upa_writeq(base
+ (npages
<< IO_PAGE_SHIFT
),
104 iommu
->iommu_regs
+ IOMMU_FLUSH
);
105 upa_readq(iommu
->sbus_control_reg
);
108 /* Offsets from strbuf_regs */
109 #define SYSIO_STRBUFREG_BASE 0x2800UL
110 #define STRBUF_CONTROL (0x2800UL - 0x2800UL) /* Control */
111 #define STRBUF_PFLUSH (0x2808UL - 0x2800UL) /* Page flush/invalidate */
112 #define STRBUF_FSYNC (0x2810UL - 0x2800UL) /* Flush synchronization */
113 #define STRBUF_DRAMDIAG (0x5000UL - 0x2800UL) /* data RAM diagnostic */
114 #define STRBUF_ERRDIAG (0x5400UL - 0x2800UL) /* error status diagnostics */
115 #define STRBUF_PTAGDIAG (0x5800UL - 0x2800UL) /* Page tag diagnostics */
116 #define STRBUF_LTAGDIAG (0x5900UL - 0x2800UL) /* Line tag diagnostics */
118 #define STRBUF_TAG_VALID 0x02UL
120 static void sbus_strbuf_flush(struct sbus_iommu
*iommu
, u32 base
, unsigned long npages
)
125 iommu
->strbuf_flushflag
= 0UL;
128 upa_writeq(base
+ (n
<< IO_PAGE_SHIFT
),
129 iommu
->strbuf_regs
+ STRBUF_PFLUSH
);
131 /* Whoopee cushion! */
132 upa_writeq(__pa(&iommu
->strbuf_flushflag
),
133 iommu
->strbuf_regs
+ STRBUF_FSYNC
);
134 upa_readq(iommu
->sbus_control_reg
);
137 while (iommu
->strbuf_flushflag
== 0UL) {
145 printk(KERN_WARNING
"sbus_strbuf_flush: flushflag timeout "
146 "vaddr[%08x] npages[%ld]\n",
150 static iopte_t
*alloc_streaming_cluster(struct sbus_iommu
*iommu
, unsigned long npages
)
152 iopte_t
*iopte
, *limit
, *first
, *cluster
;
153 unsigned long cnum
, ent
, nent
, flush_point
, found
;
157 while ((1UL << cnum
) < npages
)
159 if(cnum
>= NCLUSTERS
) {
160 nent
= 1UL << (cnum
- NCLUSTERS
);
161 cnum
= NCLUSTERS
- 1;
163 iopte
= iommu
->page_table
+ (cnum
* CLUSTER_NPAGES
);
166 limit
= (iommu
->page_table
+
167 iommu
->lowest_consistent_map
);
169 limit
= (iopte
+ CLUSTER_NPAGES
);
171 iopte
+= ((ent
= iommu
->alloc_info
[cnum
].next
) << cnum
);
172 flush_point
= iommu
->alloc_info
[cnum
].flush
;
178 if (iopte_val(*iopte
) == 0UL) {
183 /* Used cluster in the way */
191 iopte
+= (1 << cnum
);
193 if (iopte
>= limit
) {
194 iopte
= (iommu
->page_table
+ (cnum
* CLUSTER_NPAGES
));
197 /* Multiple cluster allocations must not wrap */
201 if (ent
== flush_point
)
202 __iommu_flushall(iommu
);
207 /* ent/iopte points to the last cluster entry we're going to use,
208 * so save our place for the next allocation.
210 if ((iopte
+ (1 << cnum
)) >= limit
)
214 iommu
->alloc_info
[cnum
].next
= ent
;
215 if (ent
== flush_point
)
216 __iommu_flushall(iommu
);
218 /* I've got your streaming cluster right here buddy boy... */
222 printk(KERN_EMERG
"sbus: alloc_streaming_cluster of npages(%ld) failed!\n",
227 static void free_streaming_cluster(struct sbus_iommu
*iommu
, u32 base
, unsigned long npages
)
229 unsigned long cnum
, ent
, nent
;
234 while ((1UL << cnum
) < npages
)
236 if(cnum
>= NCLUSTERS
) {
237 nent
= 1UL << (cnum
- NCLUSTERS
);
238 cnum
= NCLUSTERS
- 1;
240 ent
= (base
& CLUSTER_MASK
) >> (IO_PAGE_SHIFT
+ cnum
);
241 iopte
= iommu
->page_table
+ ((base
- MAP_BASE
) >> IO_PAGE_SHIFT
);
243 iopte_val(*iopte
) = 0UL;
247 /* If the global flush might not have caught this entry,
248 * adjust the flush point such that we will flush before
249 * ever trying to reuse it.
251 #define between(X,Y,Z) (((Z) - (Y)) >= ((X) - (Y)))
252 if (between(ent
, iommu
->alloc_info
[cnum
].next
, iommu
->alloc_info
[cnum
].flush
))
253 iommu
->alloc_info
[cnum
].flush
= ent
;
257 /* We allocate consistent mappings from the end of cluster zero. */
258 static iopte_t
*alloc_consistent_cluster(struct sbus_iommu
*iommu
, unsigned long npages
)
262 iopte
= iommu
->page_table
+ (1 * CLUSTER_NPAGES
);
263 while (iopte
> iommu
->page_table
) {
265 if (!(iopte_val(*iopte
) & IOPTE_VALID
)) {
266 unsigned long tmp
= npages
;
270 if (iopte_val(*iopte
) & IOPTE_VALID
)
274 u32 entry
= (iopte
- iommu
->page_table
);
276 if (entry
< iommu
->lowest_consistent_map
)
277 iommu
->lowest_consistent_map
= entry
;
285 static void free_consistent_cluster(struct sbus_iommu
*iommu
, u32 base
, unsigned long npages
)
287 iopte_t
*iopte
= iommu
->page_table
+ ((base
- MAP_BASE
) >> IO_PAGE_SHIFT
);
289 if ((iopte
- iommu
->page_table
) == iommu
->lowest_consistent_map
) {
290 iopte_t
*walk
= iopte
+ npages
;
293 limit
= iommu
->page_table
+ CLUSTER_NPAGES
;
294 while (walk
< limit
) {
295 if (iopte_val(*walk
) != 0UL)
299 iommu
->lowest_consistent_map
=
300 (walk
- iommu
->page_table
);
304 *iopte
++ = __iopte(0UL);
307 void *sbus_alloc_consistent(struct sbus_dev
*sdev
, size_t size
, dma_addr_t
*dvma_addr
)
309 unsigned long order
, first_page
, flags
;
310 struct sbus_iommu
*iommu
;
315 if (size
<= 0 || sdev
== NULL
|| dvma_addr
== NULL
)
318 size
= IO_PAGE_ALIGN(size
);
319 order
= get_order(size
);
322 first_page
= __get_free_pages(GFP_KERNEL
, order
);
323 if (first_page
== 0UL)
325 memset((char *)first_page
, 0, PAGE_SIZE
<< order
);
327 iommu
= sdev
->bus
->iommu
;
329 spin_lock_irqsave(&iommu
->lock
, flags
);
330 iopte
= alloc_consistent_cluster(iommu
, size
>> IO_PAGE_SHIFT
);
332 spin_unlock_irqrestore(&iommu
->lock
, flags
);
333 free_pages(first_page
, order
);
337 /* Ok, we're committed at this point. */
338 *dvma_addr
= MAP_BASE
+ ((iopte
- iommu
->page_table
) << IO_PAGE_SHIFT
);
339 ret
= (void *) first_page
;
340 npages
= size
>> IO_PAGE_SHIFT
;
342 *iopte
++ = __iopte(IOPTE_VALID
| IOPTE_CACHE
| IOPTE_WRITE
|
343 (__pa(first_page
) & IOPTE_PAGE
));
344 first_page
+= IO_PAGE_SIZE
;
346 iommu_flush(iommu
, *dvma_addr
, size
>> IO_PAGE_SHIFT
);
347 spin_unlock_irqrestore(&iommu
->lock
, flags
);
352 void sbus_free_consistent(struct sbus_dev
*sdev
, size_t size
, void *cpu
, dma_addr_t dvma
)
354 unsigned long order
, npages
;
355 struct sbus_iommu
*iommu
;
357 if (size
<= 0 || sdev
== NULL
|| cpu
== NULL
)
360 npages
= IO_PAGE_ALIGN(size
) >> IO_PAGE_SHIFT
;
361 iommu
= sdev
->bus
->iommu
;
363 spin_lock_irq(&iommu
->lock
);
364 free_consistent_cluster(iommu
, dvma
, npages
);
365 iommu_flush(iommu
, dvma
, npages
);
366 spin_unlock_irq(&iommu
->lock
);
368 order
= get_order(size
);
370 free_pages((unsigned long)cpu
, order
);
373 dma_addr_t
sbus_map_single(struct sbus_dev
*sdev
, void *ptr
, size_t size
, int dir
)
375 struct sbus_iommu
*iommu
= sdev
->bus
->iommu
;
376 unsigned long npages
, pbase
, flags
;
378 u32 dma_base
, offset
;
379 unsigned long iopte_bits
;
381 if (dir
== SBUS_DMA_NONE
)
384 pbase
= (unsigned long) ptr
;
385 offset
= (u32
) (pbase
& ~IO_PAGE_MASK
);
386 size
= (IO_PAGE_ALIGN(pbase
+ size
) - (pbase
& IO_PAGE_MASK
));
387 pbase
= (unsigned long) __pa(pbase
& IO_PAGE_MASK
);
389 spin_lock_irqsave(&iommu
->lock
, flags
);
390 npages
= size
>> IO_PAGE_SHIFT
;
391 iopte
= alloc_streaming_cluster(iommu
, npages
);
394 dma_base
= MAP_BASE
+ ((iopte
- iommu
->page_table
) << IO_PAGE_SHIFT
);
395 npages
= size
>> IO_PAGE_SHIFT
;
396 iopte_bits
= IOPTE_VALID
| IOPTE_STBUF
| IOPTE_CACHE
;
397 if (dir
!= SBUS_DMA_TODEVICE
)
398 iopte_bits
|= IOPTE_WRITE
;
400 *iopte
++ = __iopte(iopte_bits
| (pbase
& IOPTE_PAGE
));
401 pbase
+= IO_PAGE_SIZE
;
403 npages
= size
>> IO_PAGE_SHIFT
;
404 spin_unlock_irqrestore(&iommu
->lock
, flags
);
406 return (dma_base
| offset
);
409 spin_unlock_irqrestore(&iommu
->lock
, flags
);
414 void sbus_unmap_single(struct sbus_dev
*sdev
, dma_addr_t dma_addr
, size_t size
, int direction
)
416 struct sbus_iommu
*iommu
= sdev
->bus
->iommu
;
417 u32 dma_base
= dma_addr
& IO_PAGE_MASK
;
420 size
= (IO_PAGE_ALIGN(dma_addr
+ size
) - dma_base
);
422 spin_lock_irqsave(&iommu
->lock
, flags
);
423 free_streaming_cluster(iommu
, dma_base
, size
>> IO_PAGE_SHIFT
);
424 sbus_strbuf_flush(iommu
, dma_base
, size
>> IO_PAGE_SHIFT
);
425 spin_unlock_irqrestore(&iommu
->lock
, flags
);
428 #define SG_ENT_PHYS_ADDRESS(SG) \
429 (__pa(page_address((SG)->page)) + (SG)->offset)
431 static inline void fill_sg(iopte_t
*iopte
, struct scatterlist
*sg
, int nused
, int nelems
, unsigned long iopte_bits
)
433 struct scatterlist
*dma_sg
= sg
;
434 struct scatterlist
*sg_end
= sg
+ nelems
;
437 for (i
= 0; i
< nused
; i
++) {
438 unsigned long pteval
= ~0UL;
441 dma_npages
= ((dma_sg
->dma_address
& (IO_PAGE_SIZE
- 1UL)) +
443 ((IO_PAGE_SIZE
- 1UL))) >> IO_PAGE_SHIFT
;
445 unsigned long offset
;
448 /* If we are here, we know we have at least one
449 * more page to map. So walk forward until we
450 * hit a page crossing, and begin creating new
451 * mappings from that spot.
456 tmp
= (unsigned long) SG_ENT_PHYS_ADDRESS(sg
);
458 if (((tmp
^ pteval
) >> IO_PAGE_SHIFT
) != 0UL) {
459 pteval
= tmp
& IO_PAGE_MASK
;
460 offset
= tmp
& (IO_PAGE_SIZE
- 1UL);
463 if (((tmp
^ (tmp
+ len
- 1UL)) >> IO_PAGE_SHIFT
) != 0UL) {
464 pteval
= (tmp
+ IO_PAGE_SIZE
) & IO_PAGE_MASK
;
466 len
-= (IO_PAGE_SIZE
- (tmp
& (IO_PAGE_SIZE
- 1UL)));
472 pteval
= ((pteval
& IOPTE_PAGE
) | iopte_bits
);
474 *iopte
++ = __iopte(pteval
);
475 pteval
+= IO_PAGE_SIZE
;
476 len
-= (IO_PAGE_SIZE
- offset
);
481 pteval
= (pteval
& IOPTE_PAGE
) + len
;
484 /* Skip over any tail mappings we've fully mapped,
485 * adjusting pteval along the way. Stop when we
486 * detect a page crossing event.
488 while (sg
< sg_end
&&
489 (pteval
<< (64 - IO_PAGE_SHIFT
)) != 0UL &&
490 (pteval
== SG_ENT_PHYS_ADDRESS(sg
)) &&
492 (SG_ENT_PHYS_ADDRESS(sg
) + sg
->length
- 1UL)) >> IO_PAGE_SHIFT
) == 0UL) {
493 pteval
+= sg
->length
;
496 if ((pteval
<< (64 - IO_PAGE_SHIFT
)) == 0UL)
498 } while (dma_npages
!= 0);
503 int sbus_map_sg(struct sbus_dev
*sdev
, struct scatterlist
*sg
, int nents
, int dir
)
505 struct sbus_iommu
*iommu
= sdev
->bus
->iommu
;
506 unsigned long flags
, npages
;
509 struct scatterlist
*sgtmp
;
511 unsigned long iopte_bits
;
513 if (dir
== SBUS_DMA_NONE
)
516 /* Fast path single entry scatterlists. */
519 sbus_map_single(sdev
,
520 (page_address(sg
->page
) + sg
->offset
),
522 sg
->dma_length
= sg
->length
;
526 npages
= prepare_sg(sg
, nents
);
528 spin_lock_irqsave(&iommu
->lock
, flags
);
529 iopte
= alloc_streaming_cluster(iommu
, npages
);
532 dma_base
= MAP_BASE
+ ((iopte
- iommu
->page_table
) << IO_PAGE_SHIFT
);
534 /* Normalize DVMA addresses. */
538 while (used
&& sgtmp
->dma_length
) {
539 sgtmp
->dma_address
+= dma_base
;
545 iopte_bits
= IOPTE_VALID
| IOPTE_STBUF
| IOPTE_CACHE
;
546 if (dir
!= SBUS_DMA_TODEVICE
)
547 iopte_bits
|= IOPTE_WRITE
;
549 fill_sg(iopte
, sg
, used
, nents
, iopte_bits
);
551 verify_sglist(sg
, nents
, iopte
, npages
);
553 spin_unlock_irqrestore(&iommu
->lock
, flags
);
558 spin_unlock_irqrestore(&iommu
->lock
, flags
);
563 void sbus_unmap_sg(struct sbus_dev
*sdev
, struct scatterlist
*sg
, int nents
, int direction
)
565 unsigned long size
, flags
;
566 struct sbus_iommu
*iommu
;
570 /* Fast path single entry scatterlists. */
572 sbus_unmap_single(sdev
, sg
->dma_address
, sg
->dma_length
, direction
);
576 dvma_base
= sg
[0].dma_address
& IO_PAGE_MASK
;
577 for (i
= 0; i
< nents
; i
++) {
578 if (sg
[i
].dma_length
== 0)
582 size
= IO_PAGE_ALIGN(sg
[i
].dma_address
+ sg
[i
].dma_length
) - dvma_base
;
584 iommu
= sdev
->bus
->iommu
;
585 spin_lock_irqsave(&iommu
->lock
, flags
);
586 free_streaming_cluster(iommu
, dvma_base
, size
>> IO_PAGE_SHIFT
);
587 sbus_strbuf_flush(iommu
, dvma_base
, size
>> IO_PAGE_SHIFT
);
588 spin_unlock_irqrestore(&iommu
->lock
, flags
);
591 void sbus_dma_sync_single_for_cpu(struct sbus_dev
*sdev
, dma_addr_t base
, size_t size
, int direction
)
593 struct sbus_iommu
*iommu
= sdev
->bus
->iommu
;
596 size
= (IO_PAGE_ALIGN(base
+ size
) - (base
& IO_PAGE_MASK
));
598 spin_lock_irqsave(&iommu
->lock
, flags
);
599 sbus_strbuf_flush(iommu
, base
& IO_PAGE_MASK
, size
>> IO_PAGE_SHIFT
);
600 spin_unlock_irqrestore(&iommu
->lock
, flags
);
603 void sbus_dma_sync_single_for_device(struct sbus_dev
*sdev
, dma_addr_t base
, size_t size
, int direction
)
607 void sbus_dma_sync_sg_for_cpu(struct sbus_dev
*sdev
, struct scatterlist
*sg
, int nents
, int direction
)
609 struct sbus_iommu
*iommu
= sdev
->bus
->iommu
;
610 unsigned long flags
, size
;
614 base
= sg
[0].dma_address
& IO_PAGE_MASK
;
615 for (i
= 0; i
< nents
; i
++) {
616 if (sg
[i
].dma_length
== 0)
620 size
= IO_PAGE_ALIGN(sg
[i
].dma_address
+ sg
[i
].dma_length
) - base
;
622 spin_lock_irqsave(&iommu
->lock
, flags
);
623 sbus_strbuf_flush(iommu
, base
, size
>> IO_PAGE_SHIFT
);
624 spin_unlock_irqrestore(&iommu
->lock
, flags
);
627 void sbus_dma_sync_sg_for_device(struct sbus_dev
*sdev
, struct scatterlist
*sg
, int nents
, int direction
)
631 /* Enable 64-bit DVMA mode for the given device. */
632 void sbus_set_sbus64(struct sbus_dev
*sdev
, int bursts
)
634 struct sbus_iommu
*iommu
= sdev
->bus
->iommu
;
635 int slot
= sdev
->slot
;
636 unsigned long cfg_reg
;
639 cfg_reg
= iommu
->sbus_control_reg
;
667 val
= upa_readq(cfg_reg
);
668 if (val
& (1UL << 14UL)) {
669 /* Extended transfer mode already enabled. */
673 val
|= (1UL << 14UL);
675 if (bursts
& DMA_BURST8
)
677 if (bursts
& DMA_BURST16
)
679 if (bursts
& DMA_BURST32
)
681 if (bursts
& DMA_BURST64
)
683 upa_writeq(val
, cfg_reg
);
686 /* SBUS SYSIO INO number to Sparc PIL level. */
687 static unsigned char sysio_ino_to_pil
[] = {
688 0, 4, 4, 7, 5, 7, 8, 9, /* SBUS slot 0 */
689 0, 4, 4, 7, 5, 7, 8, 9, /* SBUS slot 1 */
690 0, 4, 4, 7, 5, 7, 8, 9, /* SBUS slot 2 */
691 0, 4, 4, 7, 5, 7, 8, 9, /* SBUS slot 3 */
692 4, /* Onboard SCSI */
693 5, /* Onboard Ethernet */
694 /*XXX*/ 8, /* Onboard BPP */
697 /*XXX*/15, /* PowerFail */
700 12, /* Zilog Serial Channels (incl. Keyboard/Mouse lines) */
702 0, /* Spare Hardware (bogon for now) */
703 0, /* Keyboard (bogon for now) */
704 0, /* Mouse (bogon for now) */
705 0, /* Serial (bogon for now) */
706 0, 0, /* Bogon, Bogon */
709 0, 0, /* Bogon, Bogon */
710 15, /* Uncorrectable SBUS Error */
711 15, /* Correctable SBUS Error */
713 /*XXX*/ 0, /* Power Management (bogon for now) */
716 /* INO number to IMAP register offset for SYSIO external IRQ's.
717 * This should conform to both Sunfire/Wildfire server and Fusion
720 #define SYSIO_IMAP_SLOT0 0x2c04UL
721 #define SYSIO_IMAP_SLOT1 0x2c0cUL
722 #define SYSIO_IMAP_SLOT2 0x2c14UL
723 #define SYSIO_IMAP_SLOT3 0x2c1cUL
724 #define SYSIO_IMAP_SCSI 0x3004UL
725 #define SYSIO_IMAP_ETH 0x300cUL
726 #define SYSIO_IMAP_BPP 0x3014UL
727 #define SYSIO_IMAP_AUDIO 0x301cUL
728 #define SYSIO_IMAP_PFAIL 0x3024UL
729 #define SYSIO_IMAP_KMS 0x302cUL
730 #define SYSIO_IMAP_FLPY 0x3034UL
731 #define SYSIO_IMAP_SHW 0x303cUL
732 #define SYSIO_IMAP_KBD 0x3044UL
733 #define SYSIO_IMAP_MS 0x304cUL
734 #define SYSIO_IMAP_SER 0x3054UL
735 #define SYSIO_IMAP_TIM0 0x3064UL
736 #define SYSIO_IMAP_TIM1 0x306cUL
737 #define SYSIO_IMAP_UE 0x3074UL
738 #define SYSIO_IMAP_CE 0x307cUL
739 #define SYSIO_IMAP_SBERR 0x3084UL
740 #define SYSIO_IMAP_PMGMT 0x308cUL
741 #define SYSIO_IMAP_GFX 0x3094UL
742 #define SYSIO_IMAP_EUPA 0x309cUL
744 #define bogon ((unsigned long) -1)
745 static unsigned long sysio_irq_offsets
[] = {
746 /* SBUS Slot 0 --> 3, level 1 --> 7 */
747 SYSIO_IMAP_SLOT0
, SYSIO_IMAP_SLOT0
, SYSIO_IMAP_SLOT0
, SYSIO_IMAP_SLOT0
,
748 SYSIO_IMAP_SLOT0
, SYSIO_IMAP_SLOT0
, SYSIO_IMAP_SLOT0
, SYSIO_IMAP_SLOT0
,
749 SYSIO_IMAP_SLOT1
, SYSIO_IMAP_SLOT1
, SYSIO_IMAP_SLOT1
, SYSIO_IMAP_SLOT1
,
750 SYSIO_IMAP_SLOT1
, SYSIO_IMAP_SLOT1
, SYSIO_IMAP_SLOT1
, SYSIO_IMAP_SLOT1
,
751 SYSIO_IMAP_SLOT2
, SYSIO_IMAP_SLOT2
, SYSIO_IMAP_SLOT2
, SYSIO_IMAP_SLOT2
,
752 SYSIO_IMAP_SLOT2
, SYSIO_IMAP_SLOT2
, SYSIO_IMAP_SLOT2
, SYSIO_IMAP_SLOT2
,
753 SYSIO_IMAP_SLOT3
, SYSIO_IMAP_SLOT3
, SYSIO_IMAP_SLOT3
, SYSIO_IMAP_SLOT3
,
754 SYSIO_IMAP_SLOT3
, SYSIO_IMAP_SLOT3
, SYSIO_IMAP_SLOT3
, SYSIO_IMAP_SLOT3
,
756 /* Onboard devices (not relevant/used on SunFire). */
785 #define NUM_SYSIO_OFFSETS (sizeof(sysio_irq_offsets) / sizeof(sysio_irq_offsets[0]))
787 /* Convert Interrupt Mapping register pointer to associated
788 * Interrupt Clear register pointer, SYSIO specific version.
790 #define SYSIO_ICLR_UNUSED0 0x3400UL
791 #define SYSIO_ICLR_SLOT0 0x340cUL
792 #define SYSIO_ICLR_SLOT1 0x344cUL
793 #define SYSIO_ICLR_SLOT2 0x348cUL
794 #define SYSIO_ICLR_SLOT3 0x34ccUL
795 static unsigned long sysio_imap_to_iclr(unsigned long imap
)
797 unsigned long diff
= SYSIO_ICLR_UNUSED0
- SYSIO_IMAP_SLOT0
;
801 unsigned int sbus_build_irq(void *buscookie
, unsigned int ino
)
803 struct sbus_bus
*sbus
= (struct sbus_bus
*)buscookie
;
804 struct sbus_iommu
*iommu
= sbus
->iommu
;
805 unsigned long reg_base
= iommu
->sbus_control_reg
- 0x2000UL
;
806 unsigned long imap
, iclr
;
807 int pil
, sbus_level
= 0;
809 pil
= sysio_ino_to_pil
[ino
];
811 printk("sbus_irq_build: Bad SYSIO INO[%x]\n", ino
);
812 panic("Bad SYSIO IRQ translations...");
815 if (PIL_RESERVED(pil
))
818 imap
= sysio_irq_offsets
[ino
];
819 if (imap
== ((unsigned long)-1)) {
820 prom_printf("get_irq_translations: Bad SYSIO INO[%x] cpu[%d]\n",
826 /* SYSIO inconsistency. For external SLOTS, we have to select
827 * the right ICLR register based upon the lower SBUS irq level
831 iclr
= sysio_imap_to_iclr(imap
);
833 int sbus_slot
= (ino
& 0x18)>>3;
835 sbus_level
= ino
& 0x7;
839 iclr
= reg_base
+ SYSIO_ICLR_SLOT0
;
842 iclr
= reg_base
+ SYSIO_ICLR_SLOT1
;
845 iclr
= reg_base
+ SYSIO_ICLR_SLOT2
;
849 iclr
= reg_base
+ SYSIO_ICLR_SLOT3
;
853 iclr
+= ((unsigned long)sbus_level
- 1UL) * 8UL;
855 return build_irq(pil
, sbus_level
, iclr
, imap
);
858 /* Error interrupt handling. */
859 #define SYSIO_UE_AFSR 0x0030UL
860 #define SYSIO_UE_AFAR 0x0038UL
861 #define SYSIO_UEAFSR_PPIO 0x8000000000000000UL /* Primary PIO cause */
862 #define SYSIO_UEAFSR_PDRD 0x4000000000000000UL /* Primary DVMA read cause */
863 #define SYSIO_UEAFSR_PDWR 0x2000000000000000UL /* Primary DVMA write cause */
864 #define SYSIO_UEAFSR_SPIO 0x1000000000000000UL /* Secondary PIO is cause */
865 #define SYSIO_UEAFSR_SDRD 0x0800000000000000UL /* Secondary DVMA read cause */
866 #define SYSIO_UEAFSR_SDWR 0x0400000000000000UL /* Secondary DVMA write cause*/
867 #define SYSIO_UEAFSR_RESV1 0x03ff000000000000UL /* Reserved */
868 #define SYSIO_UEAFSR_DOFF 0x0000e00000000000UL /* Doubleword Offset */
869 #define SYSIO_UEAFSR_SIZE 0x00001c0000000000UL /* Bad transfer size 2^SIZE */
870 #define SYSIO_UEAFSR_MID 0x000003e000000000UL /* UPA MID causing the fault */
871 #define SYSIO_UEAFSR_RESV2 0x0000001fffffffffUL /* Reserved */
872 static irqreturn_t
sysio_ue_handler(int irq
, void *dev_id
, struct pt_regs
*regs
)
874 struct sbus_bus
*sbus
= dev_id
;
875 struct sbus_iommu
*iommu
= sbus
->iommu
;
876 unsigned long reg_base
= iommu
->sbus_control_reg
- 0x2000UL
;
877 unsigned long afsr_reg
, afar_reg
;
878 unsigned long afsr
, afar
, error_bits
;
881 afsr_reg
= reg_base
+ SYSIO_UE_AFSR
;
882 afar_reg
= reg_base
+ SYSIO_UE_AFAR
;
884 /* Latch error status. */
885 afsr
= upa_readq(afsr_reg
);
886 afar
= upa_readq(afar_reg
);
888 /* Clear primary/secondary error status bits. */
890 (SYSIO_UEAFSR_PPIO
| SYSIO_UEAFSR_PDRD
| SYSIO_UEAFSR_PDWR
|
891 SYSIO_UEAFSR_SPIO
| SYSIO_UEAFSR_SDRD
| SYSIO_UEAFSR_SDWR
);
892 upa_writeq(error_bits
, afsr_reg
);
895 printk("SYSIO[%x]: Uncorrectable ECC Error, primary error type[%s]\n",
897 (((error_bits
& SYSIO_UEAFSR_PPIO
) ?
899 ((error_bits
& SYSIO_UEAFSR_PDRD
) ?
901 ((error_bits
& SYSIO_UEAFSR_PDWR
) ?
902 "DVMA Write" : "???")))));
903 printk("SYSIO[%x]: DOFF[%lx] SIZE[%lx] MID[%lx]\n",
905 (afsr
& SYSIO_UEAFSR_DOFF
) >> 45UL,
906 (afsr
& SYSIO_UEAFSR_SIZE
) >> 42UL,
907 (afsr
& SYSIO_UEAFSR_MID
) >> 37UL);
908 printk("SYSIO[%x]: AFAR[%016lx]\n", sbus
->portid
, afar
);
909 printk("SYSIO[%x]: Secondary UE errors [", sbus
->portid
);
911 if (afsr
& SYSIO_UEAFSR_SPIO
) {
915 if (afsr
& SYSIO_UEAFSR_SDRD
) {
917 printk("(DVMA Read)");
919 if (afsr
& SYSIO_UEAFSR_SDWR
) {
921 printk("(DVMA Write)");
930 #define SYSIO_CE_AFSR 0x0040UL
931 #define SYSIO_CE_AFAR 0x0048UL
932 #define SYSIO_CEAFSR_PPIO 0x8000000000000000UL /* Primary PIO cause */
933 #define SYSIO_CEAFSR_PDRD 0x4000000000000000UL /* Primary DVMA read cause */
934 #define SYSIO_CEAFSR_PDWR 0x2000000000000000UL /* Primary DVMA write cause */
935 #define SYSIO_CEAFSR_SPIO 0x1000000000000000UL /* Secondary PIO cause */
936 #define SYSIO_CEAFSR_SDRD 0x0800000000000000UL /* Secondary DVMA read cause */
937 #define SYSIO_CEAFSR_SDWR 0x0400000000000000UL /* Secondary DVMA write cause*/
938 #define SYSIO_CEAFSR_RESV1 0x0300000000000000UL /* Reserved */
939 #define SYSIO_CEAFSR_ESYND 0x00ff000000000000UL /* Syndrome Bits */
940 #define SYSIO_CEAFSR_DOFF 0x0000e00000000000UL /* Double Offset */
941 #define SYSIO_CEAFSR_SIZE 0x00001c0000000000UL /* Bad transfer size 2^SIZE */
942 #define SYSIO_CEAFSR_MID 0x000003e000000000UL /* UPA MID causing the fault */
943 #define SYSIO_CEAFSR_RESV2 0x0000001fffffffffUL /* Reserved */
944 static irqreturn_t
sysio_ce_handler(int irq
, void *dev_id
, struct pt_regs
*regs
)
946 struct sbus_bus
*sbus
= dev_id
;
947 struct sbus_iommu
*iommu
= sbus
->iommu
;
948 unsigned long reg_base
= iommu
->sbus_control_reg
- 0x2000UL
;
949 unsigned long afsr_reg
, afar_reg
;
950 unsigned long afsr
, afar
, error_bits
;
953 afsr_reg
= reg_base
+ SYSIO_CE_AFSR
;
954 afar_reg
= reg_base
+ SYSIO_CE_AFAR
;
956 /* Latch error status. */
957 afsr
= upa_readq(afsr_reg
);
958 afar
= upa_readq(afar_reg
);
960 /* Clear primary/secondary error status bits. */
962 (SYSIO_CEAFSR_PPIO
| SYSIO_CEAFSR_PDRD
| SYSIO_CEAFSR_PDWR
|
963 SYSIO_CEAFSR_SPIO
| SYSIO_CEAFSR_SDRD
| SYSIO_CEAFSR_SDWR
);
964 upa_writeq(error_bits
, afsr_reg
);
966 printk("SYSIO[%x]: Correctable ECC Error, primary error type[%s]\n",
968 (((error_bits
& SYSIO_CEAFSR_PPIO
) ?
970 ((error_bits
& SYSIO_CEAFSR_PDRD
) ?
972 ((error_bits
& SYSIO_CEAFSR_PDWR
) ?
973 "DVMA Write" : "???")))));
975 /* XXX Use syndrome and afar to print out module string just like
976 * XXX UDB CE trap handler does... -DaveM
978 printk("SYSIO[%x]: DOFF[%lx] ECC Syndrome[%lx] Size[%lx] MID[%lx]\n",
980 (afsr
& SYSIO_CEAFSR_DOFF
) >> 45UL,
981 (afsr
& SYSIO_CEAFSR_ESYND
) >> 48UL,
982 (afsr
& SYSIO_CEAFSR_SIZE
) >> 42UL,
983 (afsr
& SYSIO_CEAFSR_MID
) >> 37UL);
984 printk("SYSIO[%x]: AFAR[%016lx]\n", sbus
->portid
, afar
);
986 printk("SYSIO[%x]: Secondary CE errors [", sbus
->portid
);
988 if (afsr
& SYSIO_CEAFSR_SPIO
) {
992 if (afsr
& SYSIO_CEAFSR_SDRD
) {
994 printk("(DVMA Read)");
996 if (afsr
& SYSIO_CEAFSR_SDWR
) {
998 printk("(DVMA Write)");
1007 #define SYSIO_SBUS_AFSR 0x2010UL
1008 #define SYSIO_SBUS_AFAR 0x2018UL
1009 #define SYSIO_SBAFSR_PLE 0x8000000000000000UL /* Primary Late PIO Error */
1010 #define SYSIO_SBAFSR_PTO 0x4000000000000000UL /* Primary SBUS Timeout */
1011 #define SYSIO_SBAFSR_PBERR 0x2000000000000000UL /* Primary SBUS Error ACK */
1012 #define SYSIO_SBAFSR_SLE 0x1000000000000000UL /* Secondary Late PIO Error */
1013 #define SYSIO_SBAFSR_STO 0x0800000000000000UL /* Secondary SBUS Timeout */
1014 #define SYSIO_SBAFSR_SBERR 0x0400000000000000UL /* Secondary SBUS Error ACK */
1015 #define SYSIO_SBAFSR_RESV1 0x03ff000000000000UL /* Reserved */
1016 #define SYSIO_SBAFSR_RD 0x0000800000000000UL /* Primary was late PIO read */
1017 #define SYSIO_SBAFSR_RESV2 0x0000600000000000UL /* Reserved */
1018 #define SYSIO_SBAFSR_SIZE 0x00001c0000000000UL /* Size of transfer */
1019 #define SYSIO_SBAFSR_MID 0x000003e000000000UL /* MID causing the error */
1020 #define SYSIO_SBAFSR_RESV3 0x0000001fffffffffUL /* Reserved */
1021 static irqreturn_t
sysio_sbus_error_handler(int irq
, void *dev_id
, struct pt_regs
*regs
)
1023 struct sbus_bus
*sbus
= dev_id
;
1024 struct sbus_iommu
*iommu
= sbus
->iommu
;
1025 unsigned long afsr_reg
, afar_reg
, reg_base
;
1026 unsigned long afsr
, afar
, error_bits
;
1029 reg_base
= iommu
->sbus_control_reg
- 0x2000UL
;
1030 afsr_reg
= reg_base
+ SYSIO_SBUS_AFSR
;
1031 afar_reg
= reg_base
+ SYSIO_SBUS_AFAR
;
1033 afsr
= upa_readq(afsr_reg
);
1034 afar
= upa_readq(afar_reg
);
1036 /* Clear primary/secondary error status bits. */
1038 (SYSIO_SBAFSR_PLE
| SYSIO_SBAFSR_PTO
| SYSIO_SBAFSR_PBERR
|
1039 SYSIO_SBAFSR_SLE
| SYSIO_SBAFSR_STO
| SYSIO_SBAFSR_SBERR
);
1040 upa_writeq(error_bits
, afsr_reg
);
1042 /* Log the error. */
1043 printk("SYSIO[%x]: SBUS Error, primary error type[%s] read(%d)\n",
1045 (((error_bits
& SYSIO_SBAFSR_PLE
) ?
1047 ((error_bits
& SYSIO_SBAFSR_PTO
) ?
1049 ((error_bits
& SYSIO_SBAFSR_PBERR
) ?
1050 "Error Ack" : "???")))),
1051 (afsr
& SYSIO_SBAFSR_RD
) ? 1 : 0);
1052 printk("SYSIO[%x]: size[%lx] MID[%lx]\n",
1054 (afsr
& SYSIO_SBAFSR_SIZE
) >> 42UL,
1055 (afsr
& SYSIO_SBAFSR_MID
) >> 37UL);
1056 printk("SYSIO[%x]: AFAR[%016lx]\n", sbus
->portid
, afar
);
1057 printk("SYSIO[%x]: Secondary SBUS errors [", sbus
->portid
);
1059 if (afsr
& SYSIO_SBAFSR_SLE
) {
1061 printk("(Late PIO Error)");
1063 if (afsr
& SYSIO_SBAFSR_STO
) {
1065 printk("(Time Out)");
1067 if (afsr
& SYSIO_SBAFSR_SBERR
) {
1069 printk("(Error Ack)");
1075 /* XXX check iommu/strbuf for further error status XXX */
1080 #define ECC_CONTROL 0x0020UL
1081 #define SYSIO_ECNTRL_ECCEN 0x8000000000000000UL /* Enable ECC Checking */
1082 #define SYSIO_ECNTRL_UEEN 0x4000000000000000UL /* Enable UE Interrupts */
1083 #define SYSIO_ECNTRL_CEEN 0x2000000000000000UL /* Enable CE Interrupts */
1085 #define SYSIO_UE_INO 0x34
1086 #define SYSIO_CE_INO 0x35
1087 #define SYSIO_SBUSERR_INO 0x36
1089 static void __init
sysio_register_error_handlers(struct sbus_bus
*sbus
)
1091 struct sbus_iommu
*iommu
= sbus
->iommu
;
1092 unsigned long reg_base
= iommu
->sbus_control_reg
- 0x2000UL
;
1096 irq
= sbus_build_irq(sbus
, SYSIO_UE_INO
);
1097 if (request_irq(irq
, sysio_ue_handler
,
1098 SA_SHIRQ
, "SYSIO UE", sbus
) < 0) {
1099 prom_printf("SYSIO[%x]: Cannot register UE interrupt.\n",
1104 irq
= sbus_build_irq(sbus
, SYSIO_CE_INO
);
1105 if (request_irq(irq
, sysio_ce_handler
,
1106 SA_SHIRQ
, "SYSIO CE", sbus
) < 0) {
1107 prom_printf("SYSIO[%x]: Cannot register CE interrupt.\n",
1112 irq
= sbus_build_irq(sbus
, SYSIO_SBUSERR_INO
);
1113 if (request_irq(irq
, sysio_sbus_error_handler
,
1114 SA_SHIRQ
, "SYSIO SBUS Error", sbus
) < 0) {
1115 prom_printf("SYSIO[%x]: Cannot register SBUS Error interrupt.\n",
1120 /* Now turn the error interrupts on and also enable ECC checking. */
1121 upa_writeq((SYSIO_ECNTRL_ECCEN
|
1124 reg_base
+ ECC_CONTROL
);
1126 control
= upa_readq(iommu
->sbus_control_reg
);
1127 control
|= 0x100UL
; /* SBUS Error Interrupt Enable */
1128 upa_writeq(control
, iommu
->sbus_control_reg
);
1131 /* Boot time initialization. */
1132 void __init
sbus_iommu_init(int prom_node
, struct sbus_bus
*sbus
)
1134 struct linux_prom64_registers rprop
;
1135 struct sbus_iommu
*iommu
;
1136 unsigned long regs
, tsb_base
;
1140 sbus
->portid
= prom_getintdefault(sbus
->prom_node
,
1143 err
= prom_getproperty(prom_node
, "reg",
1144 (char *)&rprop
, sizeof(rprop
));
1146 prom_printf("sbus_iommu_init: Cannot map SYSIO control registers.\n");
1149 regs
= rprop
.phys_addr
;
1151 iommu
= kmalloc(sizeof(*iommu
) + SMP_CACHE_BYTES
, GFP_ATOMIC
);
1152 if (iommu
== NULL
) {
1153 prom_printf("sbus_iommu_init: Fatal error, kmalloc(iommu) failed\n");
1157 /* Align on E$ line boundary. */
1158 iommu
= (struct sbus_iommu
*)
1159 (((unsigned long)iommu
+ (SMP_CACHE_BYTES
- 1UL)) &
1160 ~(SMP_CACHE_BYTES
- 1UL));
1162 memset(iommu
, 0, sizeof(*iommu
));
1164 /* We start with no consistent mappings. */
1165 iommu
->lowest_consistent_map
= CLUSTER_NPAGES
;
1167 for (i
= 0; i
< NCLUSTERS
; i
++) {
1168 iommu
->alloc_info
[i
].flush
= 0;
1169 iommu
->alloc_info
[i
].next
= 0;
1172 /* Setup spinlock. */
1173 spin_lock_init(&iommu
->lock
);
1175 /* Init register offsets. */
1176 iommu
->iommu_regs
= regs
+ SYSIO_IOMMUREG_BASE
;
1177 iommu
->strbuf_regs
= regs
+ SYSIO_STRBUFREG_BASE
;
1179 /* The SYSIO SBUS control register is used for dummy reads
1180 * in order to ensure write completion.
1182 iommu
->sbus_control_reg
= regs
+ 0x2000UL
;
1184 /* Link into SYSIO software state. */
1185 sbus
->iommu
= iommu
;
1187 printk("SYSIO: UPA portID %x, at %016lx\n",
1188 sbus
->portid
, regs
);
1190 /* Setup for TSB_SIZE=7, TBW_SIZE=0, MMU_DE=1, MMU_EN=1 */
1191 control
= upa_readq(iommu
->iommu_regs
+ IOMMU_CONTROL
);
1192 control
= ((7UL << 16UL) |
1197 /* Using the above configuration we need 1MB iommu page
1198 * table (128K ioptes * 8 bytes per iopte). This is
1199 * page order 7 on UltraSparc.
1201 tsb_base
= __get_free_pages(GFP_ATOMIC
, get_order(IO_TSB_SIZE
));
1202 if (tsb_base
== 0UL) {
1203 prom_printf("sbus_iommu_init: Fatal error, cannot alloc TSB table.\n");
1207 iommu
->page_table
= (iopte_t
*) tsb_base
;
1208 memset(iommu
->page_table
, 0, IO_TSB_SIZE
);
1210 upa_writeq(control
, iommu
->iommu_regs
+ IOMMU_CONTROL
);
1212 /* Clean out any cruft in the IOMMU using
1213 * diagnostic accesses.
1215 for (i
= 0; i
< 16; i
++) {
1216 unsigned long dram
= iommu
->iommu_regs
+ IOMMU_DRAMDIAG
;
1217 unsigned long tag
= iommu
->iommu_regs
+ IOMMU_TAGDIAG
;
1219 dram
+= (unsigned long)i
* 8UL;
1220 tag
+= (unsigned long)i
* 8UL;
1221 upa_writeq(0, dram
);
1224 upa_readq(iommu
->sbus_control_reg
);
1226 /* Give the TSB to SYSIO. */
1227 upa_writeq(__pa(tsb_base
), iommu
->iommu_regs
+ IOMMU_TSBBASE
);
1229 /* Setup streaming buffer, DE=1 SB_EN=1 */
1230 control
= (1UL << 1UL) | (1UL << 0UL);
1231 upa_writeq(control
, iommu
->strbuf_regs
+ STRBUF_CONTROL
);
1233 /* Clear out the tags using diagnostics. */
1234 for (i
= 0; i
< 16; i
++) {
1235 unsigned long ptag
, ltag
;
1237 ptag
= iommu
->strbuf_regs
+ STRBUF_PTAGDIAG
;
1238 ltag
= iommu
->strbuf_regs
+ STRBUF_LTAGDIAG
;
1239 ptag
+= (unsigned long)i
* 8UL;
1240 ltag
+= (unsigned long)i
* 8UL;
1242 upa_writeq(0UL, ptag
);
1243 upa_writeq(0UL, ltag
);
1246 /* Enable DVMA arbitration for all devices/slots. */
1247 control
= upa_readq(iommu
->sbus_control_reg
);
1249 upa_writeq(control
, iommu
->sbus_control_reg
);
1251 /* Now some Xfire specific grot... */
1252 if (this_is_starfire
)
1253 sbus
->starfire_cookie
= starfire_hookup(sbus
->portid
);
1255 sbus
->starfire_cookie
= NULL
;
1257 sysio_register_error_handlers(sbus
);