assembler/test.asm

   1 /* This is a bcm43xx microcode assembly example.
   2  *
   3  * In this example file, r0 and r1 are always input
   4  * registers and r2 is output.
   5  * For input we can always have constant values or (one) memory
   6  * operand instead of the input registers shown here.
   7  *
   8  * Registers:
   9  *      GPRs:                   r0 - r63
  10  *      Offset Registers:       off0 - off5
  11  *      SPRs:                   spr000
  12  *
  13  * To access memory, two methods can be used. Examples follow.
  14  * Direct linear:
  15  *      mov r0,[0xCA]
  16  * Indirect through Offset Register (pointer):
  17  *      mov r0,[0xCA,off0]
  18  */
  19
  20
  21 /* The target architecture. Supported versions are 5 and 15 */
  22 %arch   5
  23
  24 /* Program entry point */
  25 %start  testlabel
  26
  27 #define PSM_BRC         spr848
  28
  29 #define ECOND_MAC_ON    (0x20 | 4)
  30
  31
  32 .text
  33
  34 label:
  35         /* ADD instructions */
  36         add     r0,r1,r2        /* add */
  37         add.    r0,r1,r2        /* add, set carry */
  38         addc    r0,r1,r2        /* add with carry */
  39         addc.   r0,r1,r2        /* add with carry, set carry */
  40
  41 testlabel:
  42         /* SUB instructions */
  43         sub     r0,r1,r2        /* sub */
  44         sub.    r0,r1,r2        /* sub, set carry */
  45         subc    r0,r1,r2        /* sub with carry */
  46         subc.   r0,r1,r2        /* sub with carry, set carry */
  47
  48         sra     r0,r1,r2        /* arithmetic rightshift */
  49
  50         /* Logical instructions */
  51         or      r0,r1,r2        /* bitwise OR */
  52         and     r0,r1,r2        /* bitwise AND */
  53         xor     r0,r1,r2        /* bitwise XOR */
  54         sr      r0,r1,r2        /* rightshift */
  55         sl      r0,r1,r2        /* leftshift */
  56
  57         srx     7,8,r0,r1,r2    /* eXtended right shift (two input regs) */
  58
  59         rl      r0,r1,r2        /* rotate left */
  60         rr      r0,r1,r2        /* rotate right */
  61         nand    r0,r1,r2        /* clear bits (notmask + and) */
  62
  63         orx     7,8,r0,r1,r2    /* eXtended OR */
  64
  65         /* Copy instruction. This is a virtual instruction
  66          * translated to more lowlevel stuff like OR. */
  67         mov     r0,r2           /* copy data */
  68
  69         /* Jumps */
  70         jmp     label           /* unconditional jump */
  71         jand    r0,r1,label     /* jump if binary AND */
  72         jnand   r0,r1,label     /* jump if not binary AND */
  73         js      r0,r1,label     /* jump if all bits set */
  74         jns     r0,r1,label     /* jump if not all bits set */
  75         je      r0,r1,label     /* jump if equal */
  76         jne     r0,r1,label     /* jump if not equal */
  77         jls     r0,r1,label     /* jump if less (signed) */
  78         jges    r0,r1,label     /* jump if greater or equal (signed) */
  79         jgs     r0,r1,label     /* jump if greater (signed) */
  80         jles    r0,r1,label     /* jump if less or equal (signed) */
  81         jl      r0,r1,label     /* jump if less */
  82         jge     r0,r1,label     /* jump if greater or equal */
  83         jg      r0,r1,label     /* jump if greater */
  84         jle     r0,r1,label     /* jump if less or equal */
  85
  86         jzx     7,8,r0,r1,label /* Jump if zero after shift and mask */
  87         jnzx    7,8,r0,r1,label /* Jump if nonzero after shift and mask */
  88
  89         /* jump on external conditions */
  90         jext    ECOND_MAC_ON,label  /* jump if external condition is TRUE */
  91         jnext   ECOND_MAC_ON,label  /* jump if external condition is FALSE */
  92
  93         /* Subroutines */
  94         call    lr0,label       /* store PC in lr0, call func at label */
  95         ret     lr0,lr1         /* store PC in lr0, return to lr1
  96                                  * Both link registers can be the same
  97                                  * and don't interfere. */
  98
  99         /* TKIP sbox lookup */
 100         tkiph   r0,r2           /* Lookup high */
 101         tkiphs  r0,r2           /* Lookup high, byteswap */
 102         tkipl   r0,r2           /* Lookup low */
 103         tkipls  r0,r2           /* Lookup low, byteswap */
 104
 105         nap                     /* sleep until event */
 106
 107         /* raw instruction */
 108         @160    r0,r1,r2        /* equivalent to  or r0,r1,r2 */
 109         @1C0    @C11, @C22, @BC3
 110
 111
 112         /* Support for directional jumps.
 113          * Directional jumps can be used to conveniently jump inside of
 114          * functions without using function specific label prefixes. Note
 115          * that this does not establish a sub-namespace, though. "loop"
 116          * and "out" are still in the global namespace and can't be used
 117          * anymore for absolute jumps (Assembler will warn about duplication).
 118          */
 119 function_a:
 120         jl r0, r1, out+
 121  loop:
 122         nap
 123         jmp loop-
 124  out:
 125         mov r0, r0
 126         ret lr0, lr1
 127
 128 function_b:
 129         jl r0, r1, out+
 130  loop:
 131         nap
 132         jmp loop-
 133  out:
 134         mov r0, r0
 135         ret lr0, lr1
 136
 137
 138 /* The assembler has support for fancy assemble-time
 139  * immediate constant expansion. This is called "complex immediates".
 140  * Complex immediates are _always_ clamped by parentheses. There is no
 141  * operator precedence. You must use parentheses to tell precedence.
 142  */
 143         mov     (2 + 3),r0
 144         mov     (6 - 2),r0
 145         mov     (2 * 3),r0
 146         mov     (10 / 5),r0
 147         mov     (1 | 2),r0
 148         mov     (3 & 2),r0
 149         mov     (3 ^ 2),r0
 150         mov     (~1),r0
 151         mov     (2 << 3),r0
 152         mov     (8 >> 2),r0
 153         mov     (1 << (0x3 + 2)),r0
 154         mov     (1 + (2 + (3 + 4))),r0
 155         mov     (4 >> (((((~5 | 0x21)))) | (~((10) & 2)))),r0
 156
 157
 158 /* Some regression testing for the assembler follows */
 159         mov     2,off0                  /* test memory stuff */
 160         xor     0x124,r1,[0x0,off0]     /* test memory stuff */
 161         xor     0x124,r0,[0x0]          /* test memory stuff */
 162         mov     -34,r0                  /* negative dec numbers are supported */
 163         or      r0,r1,@BC2              /* We also support single raw operands */
 164         mov     0xEEEE,r0               /* MOV supports up to 16bit */
 165         jand    0x3800,r0,label         /* This is emulated by jnzx */
 166         jnand   0x3800,r0,label         /* This is emulated by jzx */
 167         or      spr06c,0,spr06c         /* Can have one spr input and one spr output */
 168         or      [0],0,[0]               /* Can have one mem input and one mem output */
 169         mov     testlabel, r0           /* Can use label as immediate value */
 170         mov r0,r1;mov r2, r3            /* ; does split instructions */
 171         mov     [(1+1)],[(2+2),off0]    /* Can use complex immediates as memory offsets */
 172
 173
 174 /* The .initvals section generates an "Initial Values" file
 175  * with the name "foobar" in this example, which is uploaded
 176  * by the kernel driver on load. This is useful for writing ucode
 177  * specific values to the chip without bloating the small ucode
 178  * memory space with this initialization stuff.
 179  * Values are written in order they appear here.
 180  */
 181 .initvals(foobar)
 182         mmio16  0x1234, 0xABC                   /* Write 0x1234 to MMIO register 0xABC */
 183         mmio32  0x12345678, 0xABC               /* Write 0x12345678 to MMIO register 0xABC */
 184         phy     0x1234, 0xABC                   /* Write 0x1234 to PHY register 0xABC */
 185         radio   0x1234, 0xABC                   /* Write 0x1234 to RADIO register 0xABC */
 186         shm16   0x1234, 0x0001, 0x0002          /* Write 0x1234 to SHM routing 0x0001, register 0x0002 */
 187         shm32   0x12345678, 0x0001, 0x0002      /* Write 0x12345678 to SHM routing 0x0001, register 0x0002 */
 188
 189
 190 // vim: syntax=b43 ts=8