[BACK]Return to bugio.c CVS log [TXT][DIR] Up to [local] / sys / arch / mvme88k / dev

Annotation of sys/arch/mvme88k/dev/bugio.c, Revision 1.1.1.1

1.1       nbrk        1: /*     $OpenBSD: bugio.c,v 1.17 2006/05/02 21:43:08 miod Exp $ */
                      2: /*  Copyright (c) 1998 Steve Murphree, Jr. */
                      3:
                      4: #include <sys/param.h>
                      5: #include <sys/systm.h>
                      6:
                      7: #include <machine/asm_macro.h>
                      8: #include <machine/bugio.h>
                      9: #include <machine/prom.h>
                     10:
                     11: register_t ossr0, ossr1, ossr2, ossr3;
                     12: register_t bugsr3;
                     13:
                     14: unsigned long bugvec[2], sysbugvec[2];
                     15:
                     16: void bug_vector(void);
                     17: void sysbug_vector(void);
                     18:
                     19: #ifdef MULTIPROCESSOR
                     20: #include <sys/lock.h>
                     21: __cpu_simple_lock_t bug_lock = __SIMPLELOCK_UNLOCKED;
                     22: #define        BUG_LOCK()      __cpu_simple_lock(&bug_lock)
                     23: #define        BUG_UNLOCK()    __cpu_simple_unlock(&bug_lock)
                     24: #else
                     25: #define        BUG_LOCK()      do { } while (0)
                     26: #define        BUG_UNLOCK()    do { } while (0)
                     27: #endif
                     28:
                     29: #define MVMEPROM_CALL(x)                                               \
                     30:        __asm__ __volatile__ ("or r9,r0," __STRING(x));                 \
                     31:        __asm__ __volatile__ ("tb0 0,r0,496" :::                        \
                     32:            "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8",             \
                     33:            "r9", "r10", "r11", "r12", "r13")
                     34:
                     35: void
                     36: bug_vector()
                     37: {
                     38:        unsigned long *vbr;
                     39:
                     40:        __asm__ __volatile__ ("ldcr %0, cr7" : "=r" (vbr));
                     41:        vbr[2 * MVMEPROM_VECTOR + 0] = bugvec[0];
                     42:        vbr[2 * MVMEPROM_VECTOR + 1] = bugvec[1];
                     43: }
                     44:
                     45: void
                     46: sysbug_vector()
                     47: {
                     48:        unsigned long *vbr;
                     49:
                     50:        __asm__ __volatile__ ("ldcr %0, cr7" : "=r" (vbr));
                     51:        vbr[2 * MVMEPROM_VECTOR + 0] = sysbugvec[0];
                     52:        vbr[2 * MVMEPROM_VECTOR + 1] = sysbugvec[1];
                     53: }
                     54:
                     55: #define        BUGCTXT()                                                       \
                     56: {                                                                      \
                     57:        BUG_LOCK();                                                     \
                     58:        disable_interrupt(psr);                 /* paranoia */          \
                     59:        bug_vector();                                                   \
                     60:        __asm__ __volatile__ ("ldcr %0, cr17" : "=r" (ossr0));          \
                     61:        __asm__ __volatile__ ("ldcr %0, cr18" : "=r" (ossr1));          \
                     62:        __asm__ __volatile__ ("ldcr %0, cr19" : "=r" (ossr2));          \
                     63:        __asm__ __volatile__ ("ldcr %0, cr20" : "=r" (ossr3));          \
                     64:                                                                        \
                     65:        __asm__ __volatile__ ("stcr %0, cr20" :: "r"(bugsr3));          \
                     66: }
                     67:
                     68: #define        OSCTXT()                                                        \
                     69: {                                                                      \
                     70:        __asm__ __volatile__ ("ldcr %0, cr20" : "=r" (bugsr3));         \
                     71:                                                                        \
                     72:        __asm__ __volatile__ ("stcr %0, cr17" :: "r"(ossr0));           \
                     73:        __asm__ __volatile__ ("stcr %0, cr18" :: "r"(ossr1));           \
                     74:        __asm__ __volatile__ ("stcr %0, cr19" :: "r"(ossr2));           \
                     75:        __asm__ __volatile__ ("stcr %0, cr20" :: "r"(ossr3));           \
                     76:        sysbug_vector();                                                \
                     77:        set_psr(psr);                                                   \
                     78:        BUG_UNLOCK();                                                   \
                     79: }
                     80:
                     81: void
                     82: bugpcrlf(void)
                     83: {
                     84:        u_int psr;
                     85:
                     86:        BUGCTXT();
                     87:        MVMEPROM_CALL(MVMEPROM_OUTCRLF);
                     88:        OSCTXT();
                     89: }
                     90:
                     91: void
                     92: buginit()
                     93: {
                     94:        __asm__ __volatile__ ("ldcr %0, cr20" : "=r" (bugsr3));
                     95: }
                     96:
                     97: char
                     98: buginchr(void)
                     99: {
                    100:        u_int psr;
                    101:        int ret;
                    102:
                    103:        BUGCTXT();
                    104:        MVMEPROM_CALL(MVMEPROM_INCHR);
                    105:        __asm__ __volatile__ ("or %0,r0,r2" : "=r" (ret));
                    106:        OSCTXT();
                    107:        return ((char)ret & 0xff);
                    108: }
                    109:
                    110: void
                    111: bugoutchr(int c)
                    112: {
                    113:        u_int psr;
                    114:
                    115:        BUGCTXT();
                    116:        __asm__ __volatile__ ("or r2,r0,%0" : : "r" (c));
                    117:        MVMEPROM_CALL(MVMEPROM_OUTCHR);
                    118:        OSCTXT();
                    119: }
                    120:
                    121: void
                    122: bugreturn(void)
                    123: {
                    124:        u_int psr;
                    125:
                    126:        BUGCTXT();
                    127:        MVMEPROM_CALL(MVMEPROM_EXIT);
                    128:        OSCTXT();
                    129: }
                    130:
                    131: void
                    132: bugbrdid(struct mvmeprom_brdid *id)
                    133: {
                    134:        u_int psr;
                    135:        struct mvmeprom_brdid *ptr;
                    136:
                    137:        BUGCTXT();
                    138:        MVMEPROM_CALL(MVMEPROM_GETBRDID);
                    139:        __asm__ __volatile__ ("or %0,r0,r2" : "=r" (ptr));
                    140:        OSCTXT();
                    141:
                    142:        bcopy(ptr, id, sizeof(struct mvmeprom_brdid));
                    143: }
                    144:
                    145: void
                    146: bugdiskrd(struct mvmeprom_dskio *dio)
                    147: {
                    148:        u_int psr;
                    149:
                    150:        BUGCTXT();
                    151:        __asm__ __volatile__ ("or r2, r0, %0" : : "r" (dio));
                    152:        MVMEPROM_CALL(MVMEPROM_DSKRD);
                    153:        OSCTXT();
                    154: }
                    155:
                    156: #ifdef MULTIPROCESSOR
                    157:
                    158: /*
                    159:  * Ask the BUG to start a particular cpu at our provided address.
                    160:  */
                    161: int
                    162: spin_cpu(cpuid_t cpu, vaddr_t address)
                    163: {
                    164:        u_int psr;
                    165:        int ret;
                    166:
                    167:        BUGCTXT();
                    168:        __asm__ __volatile__ ("or r2, r0, %0" : : "r" (cpu));
                    169:        __asm__ __volatile__ ("or r3, r0, %0" : : "r" (address));
                    170:        MVMEPROM_CALL(MVMEPROM_FORKMPU);
                    171:        __asm__ __volatile__ ("or %0,r0,r2" : "=r" (ret));
                    172:        OSCTXT();
                    173:
                    174:        return (ret);
                    175: }
                    176:
                    177: #endif /* MULTIPROCESSOR */

CVSweb