Changeset 27166


Ignore:
Timestamp:
2011-06-13T10:12:40+02:00 (7 years ago)
Author:
juhosg
Message:

ar71xx: use ar933x_uart.h in the AR933X serial driver

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/ar71xx/files/drivers/serial/ar933x_uart.c

    r27065 r27166  
    3939#include <linux/slab.h> 
    4040 
     41#include <asm/mach-ar71xx/ar933x_uart.h> 
    4142#include <asm/mach-ar71xx/ar933x_uart_platform.h> 
    4243 
     
    5152#define AR933X_UART_REGS_SIZE   20 
    5253#define AR933X_UART_FIFO_SIZE   16 
    53  
    54 /* 
    55  * Uart block 
    56  */ 
    57 #define UARTDATA_UARTTXCSR_MSB                  9 
    58 #define UARTDATA_UARTTXCSR_LSB                  9 
    59 #define UARTDATA_UARTTXCSR_MASK                 0x00000200 
    60 #define UARTDATA_UARTTXCSR_GET(x)               (((x) & UARTDATA_UARTTXCSR_MASK) >> UARTDATA_UARTTXCSR_LSB) 
    61 #define UARTDATA_UARTTXCSR_SET(x)               (((0 | (x)) << UARTDATA_UARTTXCSR_LSB) & UARTDATA_UARTTXCSR_MASK) 
    62 #define UARTDATA_UARTTXCSR_RESET                0 
    63 #define UARTDATA_UARTRXCSR_MSB                  8 
    64 #define UARTDATA_UARTRXCSR_LSB                  8 
    65 #define UARTDATA_UARTRXCSR_MASK                 0x00000100 
    66 #define UARTDATA_UARTRXCSR_GET(x)               (((x) & UARTDATA_UARTRXCSR_MASK) >> UARTDATA_UARTRXCSR_LSB) 
    67 #define UARTDATA_UARTRXCSR_SET(x)               (((0 | (x)) << UARTDATA_UARTRXCSR_LSB) & UARTDATA_UARTRXCSR_MASK) 
    68 #define UARTDATA_UARTRXCSR_RESET                0 
    69 #define UARTDATA_UARTTXRXDATA_MSB               7 
    70 #define UARTDATA_UARTTXRXDATA_LSB               0 
    71 #define UARTDATA_UARTTXRXDATA_MASK              0x000000ff 
    72 #define UARTDATA_UARTTXRXDATA_GET(x)            (((x) & UARTDATA_UARTTXRXDATA_MASK) >> UARTDATA_UARTTXRXDATA_LSB) 
    73 #define UARTDATA_UARTTXRXDATA_SET(x)            (((0 | (x)) << UARTDATA_UARTTXRXDATA_LSB) & UARTDATA_UARTTXRXDATA_MASK) 
    74 #define UARTDATA_UARTTXRXDATA_RESET             0 
    75 #define UARTDATA_ADDRESS                        0x0000 
    76 #define UARTDATA_HW_MASK                        0x000003ff 
    77 #define UARTDATA_SW_MASK                        0x000003ff 
    78 #define UARTDATA_RSTMASK                        0x000003ff 
    79 #define UARTDATA_RESET                          0x00000000 
    80  
    81 // 0x0004 (UARTCS) 
    82 #define UARTCS_UARTRXBUSY_MSB                   15 
    83 #define UARTCS_UARTRXBUSY_LSB                   15 
    84 #define UARTCS_UARTRXBUSY_MASK                  0x00008000 
    85 #define UARTCS_UARTRXBUSY_GET(x)                (((x) & UARTCS_UARTRXBUSY_MASK) >> UARTCS_UARTRXBUSY_LSB) 
    86 #define UARTCS_UARTRXBUSY_SET(x)                (((0 | (x)) << UARTCS_UARTRXBUSY_LSB) & UARTCS_UARTRXBUSY_MASK) 
    87 #define UARTCS_UARTRXBUSY_RESET                 0 
    88 #define UARTCS_UARTTXBUSY_MSB                   14 
    89 #define UARTCS_UARTTXBUSY_LSB                   14 
    90 #define UARTCS_UARTTXBUSY_MASK                  0x00004000 
    91 #define UARTCS_UARTTXBUSY_GET(x)                (((x) & UARTCS_UARTTXBUSY_MASK) >> UARTCS_UARTTXBUSY_LSB) 
    92 #define UARTCS_UARTTXBUSY_SET(x)                (((0 | (x)) << UARTCS_UARTTXBUSY_LSB) & UARTCS_UARTTXBUSY_MASK) 
    93 #define UARTCS_UARTTXBUSY_RESET                 0 
    94 #define UARTCS_UARTHOSTINTEN_MSB                13 
    95 #define UARTCS_UARTHOSTINTEN_LSB                13 
    96 #define UARTCS_UARTHOSTINTEN_MASK               0x00002000 
    97 #define UARTCS_UARTHOSTINTEN_GET(x)             (((x) & UARTCS_UARTHOSTINTEN_MASK) >> UARTCS_UARTHOSTINTEN_LSB) 
    98 #define UARTCS_UARTHOSTINTEN_SET(x)             (((0 | (x)) << UARTCS_UARTHOSTINTEN_LSB) & UARTCS_UARTHOSTINTEN_MASK) 
    99 #define UARTCS_UARTHOSTINTEN_RESET              0 
    100 #define UARTCS_UARTHOSTINT_MSB                  12 
    101 #define UARTCS_UARTHOSTINT_LSB                  12 
    102 #define UARTCS_UARTHOSTINT_MASK                 0x00001000 
    103 #define UARTCS_UARTHOSTINT_GET(x)               (((x) & UARTCS_UARTHOSTINT_MASK) >> UARTCS_UARTHOSTINT_LSB) 
    104 #define UARTCS_UARTHOSTINT_SET(x)               (((0 | (x)) << UARTCS_UARTHOSTINT_LSB) & UARTCS_UARTHOSTINT_MASK) 
    105 #define UARTCS_UARTHOSTINT_RESET                0 
    106 #define UARTCS_UARTTXBREAK_MSB                  11 
    107 #define UARTCS_UARTTXBREAK_LSB                  11 
    108 #define UARTCS_UARTTXBREAK_MASK                 0x00000800 
    109 #define UARTCS_UARTTXBREAK_GET(x)               (((x) & UARTCS_UARTTXBREAK_MASK) >> UARTCS_UARTTXBREAK_LSB) 
    110 #define UARTCS_UARTTXBREAK_SET(x)               (((0 | (x)) << UARTCS_UARTTXBREAK_LSB) & UARTCS_UARTTXBREAK_MASK) 
    111 #define UARTCS_UARTTXBREAK_RESET                0 
    112 #define UARTCS_UARTRXBREAK_MSB                  10 
    113 #define UARTCS_UARTRXBREAK_LSB                  10 
    114 #define UARTCS_UARTRXBREAK_MASK                 0x00000400 
    115 #define UARTCS_UARTRXBREAK_GET(x)               (((x) & UARTCS_UARTRXBREAK_MASK) >> UARTCS_UARTRXBREAK_LSB) 
    116 #define UARTCS_UARTRXBREAK_SET(x)               (((0 | (x)) << UARTCS_UARTRXBREAK_LSB) & UARTCS_UARTRXBREAK_MASK) 
    117 #define UARTCS_UARTRXBREAK_RESET                0 
    118 #define UARTCS_UARTSERIATXREADY_MSB             9 
    119 #define UARTCS_UARTSERIATXREADY_LSB             9 
    120 #define UARTCS_UARTSERIATXREADY_MASK            0x00000200 
    121 #define UARTCS_UARTSERIATXREADY_GET(x)          (((x) & UARTCS_UARTSERIATXREADY_MASK) >> UARTCS_UARTSERIATXREADY_LSB) 
    122 #define UARTCS_UARTSERIATXREADY_SET(x)          (((0 | (x)) << UARTCS_UARTSERIATXREADY_LSB) & UARTCS_UARTSERIATXREADY_MASK) 
    123 #define UARTCS_UARTSERIATXREADY_RESET           0 
    124 #define UARTCS_UARTTXREADYORIDE_MSB             8 
    125 #define UARTCS_UARTTXREADYORIDE_LSB             8 
    126 #define UARTCS_UARTTXREADYORIDE_MASK            0x00000100 
    127 #define UARTCS_UARTTXREADYORIDE_GET(x)          (((x) & UARTCS_UARTTXREADYORIDE_MASK) >> UARTCS_UARTTXREADYORIDE_LSB) 
    128 #define UARTCS_UARTTXREADYORIDE_SET(x)          (((0 | (x)) << UARTCS_UARTTXREADYORIDE_LSB) & UARTCS_UARTTXREADYORIDE_MASK) 
    129 #define UARTCS_UARTTXREADYORIDE_RESET           0 
    130 #define UARTCS_UARTRXREADYORIDE_MSB             7 
    131 #define UARTCS_UARTRXREADYORIDE_LSB             7 
    132 #define UARTCS_UARTRXREADYORIDE_MASK            0x00000080 
    133 #define UARTCS_UARTRXREADYORIDE_GET(x)          (((x) & UARTCS_UARTRXREADYORIDE_MASK) >> UARTCS_UARTRXREADYORIDE_LSB) 
    134 #define UARTCS_UARTRXREADYORIDE_SET(x)          (((0 | (x)) << UARTCS_UARTRXREADYORIDE_LSB) & UARTCS_UARTRXREADYORIDE_MASK) 
    135 #define UARTCS_UARTRXREADYORIDE_RESET           0 
    136 #define UARTCS_UARTDMAEN_MSB                    6 
    137 #define UARTCS_UARTDMAEN_LSB                    6 
    138 #define UARTCS_UARTDMAEN_MASK                   0x00000040 
    139 #define UARTCS_UARTDMAEN_GET(x)                 (((x) & UARTCS_UARTDMAEN_MASK) >> UARTCS_UARTDMAEN_LSB) 
    140 #define UARTCS_UARTDMAEN_SET(x)                 (((0 | (x)) << UARTCS_UARTDMAEN_LSB) & UARTCS_UARTDMAEN_MASK) 
    141 #define UARTCS_UARTDMAEN_RESET                  0 
    142 #define UARTCS_UARTFLOWCONTROLMODE_MSB          5 
    143 #define UARTCS_UARTFLOWCONTROLMODE_LSB          4 
    144 #define UARTCS_UARTFLOWCONTROLMODE_MASK         0x00000030 
    145 #define UARTCS_UARTFLOWCONTROLMODE_GET(x)       (((x) & UARTCS_UARTFLOWCONTROLMODE_MASK) >> UARTCS_UARTFLOWCONTROLMODE_LSB) 
    146 #define UARTCS_UARTFLOWCONTROLMODE_SET(x)       (((0 | (x)) << UARTCS_UARTFLOWCONTROLMODE_LSB) & UARTCS_UARTFLOWCONTROLMODE_MASK) 
    147 #define UARTCS_UARTFLOWCONTROLMODE_RESET        0 
    148 #define UARTCS_UARTINTERFACEMODE_MSB            3 
    149 #define UARTCS_UARTINTERFACEMODE_LSB            2 
    150 #define UARTCS_UARTINTERFACEMODE_MASK           0x0000000c 
    151 #define UARTCS_UARTINTERFACEMODE_GET(x)         (((x) & UARTCS_UARTINTERFACEMODE_MASK) >> UARTCS_UARTINTERFACEMODE_LSB) 
    152 #define UARTCS_UARTINTERFACEMODE_SET(x)         (((0 | (x)) << UARTCS_UARTINTERFACEMODE_LSB) & UARTCS_UARTINTERFACEMODE_MASK) 
    153 #define UARTCS_UARTINTERFACEMODE_RESET          0 
    154 #define UARTCS_UARTPARITYMODE_MSB               1 
    155 #define UARTCS_UARTPARITYMODE_LSB               0 
    156 #define UARTCS_UARTPARITYMODE_MASK              0x00000003 
    157 #define UARTCS_UARTPARITYMODE_GET(x)            (((x) & UARTCS_UARTPARITYMODE_MASK) >> UARTCS_UARTPARITYMODE_LSB) 
    158 #define UARTCS_UARTPARITYMODE_SET(x)            (((0 | (x)) << UARTCS_UARTPARITYMODE_LSB) & UARTCS_UARTPARITYMODE_MASK) 
    159 #define UARTCS_UARTPARITYMODE_RESET             0 
    160 #define UARTCS_ADDRESS                          0x0004 
    161 #define UARTCS_HW_MASK                          0x0000ffff 
    162 #define UARTCS_SW_MASK                          0x0000ffff 
    163 #define UARTCS_RSTMASK                          0x000029ff 
    164 #define UARTCS_RESET                            0x00000000 
    165  
    166 // 0x0008 (UARTCLOCK) 
    167 #define UARTCLOCK_UARTCLOCKSCALE_MSB            23 
    168 #define UARTCLOCK_UARTCLOCKSCALE_LSB            16 
    169 #define UARTCLOCK_UARTCLOCKSCALE_MASK           0x00ff0000 
    170 #define UARTCLOCK_UARTCLOCKSCALE_GET(x)         (((x) & UARTCLOCK_UARTCLOCKSCALE_MASK) >> UARTCLOCK_UARTCLOCKSCALE_LSB) 
    171 #define UARTCLOCK_UARTCLOCKSCALE_SET(x)         (((0 | (x)) << UARTCLOCK_UARTCLOCKSCALE_LSB) & UARTCLOCK_UARTCLOCKSCALE_MASK) 
    172 #define UARTCLOCK_UARTCLOCKSCALE_RESET          0 
    173 #define UARTCLOCK_UARTCLOCKSTEP_MSB             15 
    174 #define UARTCLOCK_UARTCLOCKSTEP_LSB             0 
    175 #define UARTCLOCK_UARTCLOCKSTEP_MASK            0x0000ffff 
    176 #define UARTCLOCK_UARTCLOCKSTEP_GET(x)          (((x) & UARTCLOCK_UARTCLOCKSTEP_MASK) >> UARTCLOCK_UARTCLOCKSTEP_LSB) 
    177 #define UARTCLOCK_UARTCLOCKSTEP_SET(x)          (((0 | (x)) << UARTCLOCK_UARTCLOCKSTEP_LSB) & UARTCLOCK_UARTCLOCKSTEP_MASK) 
    178 #define UARTCLOCK_UARTCLOCKSTEP_RESET           0 
    179 #define UARTCLOCK_ADDRESS                       0x0008 
    180 #define UARTCLOCK_HW_MASK                       0x00ffffff 
    181 #define UARTCLOCK_SW_MASK                       0x00ffffff 
    182 #define UARTCLOCK_RSTMASK                       0x00ffffff 
    183 #define UARTCLOCK_RESET                         0x00000000 
    184  
    185 // 0x000c (UARTINT) 
    186 #define UARTINT_UARTTXEMPTYINT_MSB              9 
    187 #define UARTINT_UARTTXEMPTYINT_LSB              9 
    188 #define UARTINT_UARTTXEMPTYINT_MASK             0x00000200 
    189 #define UARTINT_UARTTXEMPTYINT_GET(x)           (((x) & UARTINT_UARTTXEMPTYINT_MASK) >> UARTINT_UARTTXEMPTYINT_LSB) 
    190 #define UARTINT_UARTTXEMPTYINT_SET(x)           (((0 | (x)) << UARTINT_UARTTXEMPTYINT_LSB) & UARTINT_UARTTXEMPTYINT_MASK) 
    191 #define UARTINT_UARTTXEMPTYINT_RESET            0 
    192 #define UARTINT_UARTRXFULLINT_MSB               8 
    193 #define UARTINT_UARTRXFULLINT_LSB               8 
    194 #define UARTINT_UARTRXFULLINT_MASK              0x00000100 
    195 #define UARTINT_UARTRXFULLINT_GET(x)            (((x) & UARTINT_UARTRXFULLINT_MASK) >> UARTINT_UARTRXFULLINT_LSB) 
    196 #define UARTINT_UARTRXFULLINT_SET(x)            (((0 | (x)) << UARTINT_UARTRXFULLINT_LSB) & UARTINT_UARTRXFULLINT_MASK) 
    197 #define UARTINT_UARTRXFULLINT_RESET             0 
    198 #define UARTINT_UARTRXBREAKOFFINT_MSB           7 
    199 #define UARTINT_UARTRXBREAKOFFINT_LSB           7 
    200 #define UARTINT_UARTRXBREAKOFFINT_MASK          0x00000080 
    201 #define UARTINT_UARTRXBREAKOFFINT_GET(x)        (((x) & UARTINT_UARTRXBREAKOFFINT_MASK) >> UARTINT_UARTRXBREAKOFFINT_LSB) 
    202 #define UARTINT_UARTRXBREAKOFFINT_SET(x)        (((0 | (x)) << UARTINT_UARTRXBREAKOFFINT_LSB) & UARTINT_UARTRXBREAKOFFINT_MASK) 
    203 #define UARTINT_UARTRXBREAKOFFINT_RESET         0 
    204 #define UARTINT_UARTRXBREAKONINT_MSB            6 
    205 #define UARTINT_UARTRXBREAKONINT_LSB            6 
    206 #define UARTINT_UARTRXBREAKONINT_MASK           0x00000040 
    207 #define UARTINT_UARTRXBREAKONINT_GET(x)         (((x) & UARTINT_UARTRXBREAKONINT_MASK) >> UARTINT_UARTRXBREAKONINT_LSB) 
    208 #define UARTINT_UARTRXBREAKONINT_SET(x)         (((0 | (x)) << UARTINT_UARTRXBREAKONINT_LSB) & UARTINT_UARTRXBREAKONINT_MASK) 
    209 #define UARTINT_UARTRXBREAKONINT_RESET          0 
    210 #define UARTINT_UARTRXPARITYERRINT_MSB          5 
    211 #define UARTINT_UARTRXPARITYERRINT_LSB          5 
    212 #define UARTINT_UARTRXPARITYERRINT_MASK         0x00000020 
    213 #define UARTINT_UARTRXPARITYERRINT_GET(x)       (((x) & UARTINT_UARTRXPARITYERRINT_MASK) >> UARTINT_UARTRXPARITYERRINT_LSB) 
    214 #define UARTINT_UARTRXPARITYERRINT_SET(x)       (((0 | (x)) << UARTINT_UARTRXPARITYERRINT_LSB) & UARTINT_UARTRXPARITYERRINT_MASK) 
    215 #define UARTINT_UARTRXPARITYERRINT_RESET        0 
    216 #define UARTINT_UARTTXOFLOWERRINT_MSB           4 
    217 #define UARTINT_UARTTXOFLOWERRINT_LSB           4 
    218 #define UARTINT_UARTTXOFLOWERRINT_MASK          0x00000010 
    219 #define UARTINT_UARTTXOFLOWERRINT_GET(x)        (((x) & UARTINT_UARTTXOFLOWERRINT_MASK) >> UARTINT_UARTTXOFLOWERRINT_LSB) 
    220 #define UARTINT_UARTTXOFLOWERRINT_SET(x)        (((0 | (x)) << UARTINT_UARTTXOFLOWERRINT_LSB) & UARTINT_UARTTXOFLOWERRINT_MASK) 
    221 #define UARTINT_UARTTXOFLOWERRINT_RESET         0 
    222 #define UARTINT_UARTRXOFLOWERRINT_MSB           3 
    223 #define UARTINT_UARTRXOFLOWERRINT_LSB           3 
    224 #define UARTINT_UARTRXOFLOWERRINT_MASK          0x00000008 
    225 #define UARTINT_UARTRXOFLOWERRINT_GET(x)        (((x) & UARTINT_UARTRXOFLOWERRINT_MASK) >> UARTINT_UARTRXOFLOWERRINT_LSB) 
    226 #define UARTINT_UARTRXOFLOWERRINT_SET(x)        (((0 | (x)) << UARTINT_UARTRXOFLOWERRINT_LSB) & UARTINT_UARTRXOFLOWERRINT_MASK) 
    227 #define UARTINT_UARTRXOFLOWERRINT_RESET         0 
    228 #define UARTINT_UARTRXFRAMINGERRINT_MSB         2 
    229 #define UARTINT_UARTRXFRAMINGERRINT_LSB         2 
    230 #define UARTINT_UARTRXFRAMINGERRINT_MASK        0x00000004 
    231 #define UARTINT_UARTRXFRAMINGERRINT_GET(x)      (((x) & UARTINT_UARTRXFRAMINGERRINT_MASK) >> UARTINT_UARTRXFRAMINGERRINT_LSB) 
    232 #define UARTINT_UARTRXFRAMINGERRINT_SET(x)      (((0 | (x)) << UARTINT_UARTRXFRAMINGERRINT_LSB) & UARTINT_UARTRXFRAMINGERRINT_MASK) 
    233 #define UARTINT_UARTRXFRAMINGERRINT_RESET       0 
    234 #define UARTINT_UARTTXREADYINT_MSB              1 
    235 #define UARTINT_UARTTXREADYINT_LSB              1 
    236 #define UARTINT_UARTTXREADYINT_MASK             0x00000002 
    237 #define UARTINT_UARTTXREADYINT_GET(x)           (((x) & UARTINT_UARTTXREADYINT_MASK) >> UARTINT_UARTTXREADYINT_LSB) 
    238 #define UARTINT_UARTTXREADYINT_SET(x)           (((0 | (x)) << UARTINT_UARTTXREADYINT_LSB) & UARTINT_UARTTXREADYINT_MASK) 
    239 #define UARTINT_UARTTXREADYINT_RESET            0 
    240 #define UARTINT_UARTRXVALIDINT_MSB              0 
    241 #define UARTINT_UARTRXVALIDINT_LSB              0 
    242 #define UARTINT_UARTRXVALIDINT_MASK             0x00000001 
    243 #define UARTINT_UARTRXVALIDINT_GET(x)           (((x) & UARTINT_UARTRXVALIDINT_MASK) >> UARTINT_UARTRXVALIDINT_LSB) 
    244 #define UARTINT_UARTRXVALIDINT_SET(x)           (((0 | (x)) << UARTINT_UARTRXVALIDINT_LSB) & UARTINT_UARTRXVALIDINT_MASK) 
    245 #define UARTINT_UARTRXVALIDINT_RESET            0 
    246 #define UARTINT_ADDRESS                         0x000c 
    247 #define UARTINT_HW_MASK                         0x000003ff 
    248 #define UARTINT_SW_MASK                         0x000003ff 
    249 #define UARTINT_RSTMASK                         0x000003ff 
    250 #define UARTINT_RESET                           0x00000000 
    251  
    252 // 0x0010 (UARTINTEN) 
    253 #define UARTINTEN_UARTTXEMPTYINTEN_MSB          9 
    254 #define UARTINTEN_UARTTXEMPTYINTEN_LSB          9 
    255 #define UARTINTEN_UARTTXEMPTYINTEN_MASK         0x00000200 
    256 #define UARTINTEN_UARTTXEMPTYINTEN_GET(x)       (((x) & UARTINTEN_UARTTXEMPTYINTEN_MASK) >> UARTINTEN_UARTTXEMPTYINTEN_LSB) 
    257 #define UARTINTEN_UARTTXEMPTYINTEN_SET(x)       (((0 | (x)) << UARTINTEN_UARTTXEMPTYINTEN_LSB) & UARTINTEN_UARTTXEMPTYINTEN_MASK) 
    258 #define UARTINTEN_UARTTXEMPTYINTEN_RESET        0 
    259 #define UARTINTEN_UARTRXFULLINTEN_MSB           8 
    260 #define UARTINTEN_UARTRXFULLINTEN_LSB           8 
    261 #define UARTINTEN_UARTRXFULLINTEN_MASK          0x00000100 
    262 #define UARTINTEN_UARTRXFULLINTEN_GET(x)        (((x) & UARTINTEN_UARTRXFULLINTEN_MASK) >> UARTINTEN_UARTRXFULLINTEN_LSB) 
    263 #define UARTINTEN_UARTRXFULLINTEN_SET(x)        (((0 | (x)) << UARTINTEN_UARTRXFULLINTEN_LSB) & UARTINTEN_UARTRXFULLINTEN_MASK) 
    264 #define UARTINTEN_UARTRXFULLINTEN_RESET         0 
    265 #define UARTINTEN_UARTRXBREAKOFFINTEN_MSB       7 
    266 #define UARTINTEN_UARTRXBREAKOFFINTEN_LSB       7 
    267 #define UARTINTEN_UARTRXBREAKOFFINTEN_MASK      0x00000080 
    268 #define UARTINTEN_UARTRXBREAKOFFINTEN_GET(x)    (((x) & UARTINTEN_UARTRXBREAKOFFINTEN_MASK) >> UARTINTEN_UARTRXBREAKOFFINTEN_LSB) 
    269 #define UARTINTEN_UARTRXBREAKOFFINTEN_SET(x)    (((0 | (x)) << UARTINTEN_UARTRXBREAKOFFINTEN_LSB) & UARTINTEN_UARTRXBREAKOFFINTEN_MASK) 
    270 #define UARTINTEN_UARTRXBREAKOFFINTEN_RESET     0 
    271 #define UARTINTEN_UARTRXBREAKONINTEN_MSB        6 
    272 #define UARTINTEN_UARTRXBREAKONINTEN_LSB        6 
    273 #define UARTINTEN_UARTRXBREAKONINTEN_MASK       0x00000040 
    274 #define UARTINTEN_UARTRXBREAKONINTEN_GET(x)     (((x) & UARTINTEN_UARTRXBREAKONINTEN_MASK) >> UARTINTEN_UARTRXBREAKONINTEN_LSB) 
    275 #define UARTINTEN_UARTRXBREAKONINTEN_SET(x)     (((0 | (x)) << UARTINTEN_UARTRXBREAKONINTEN_LSB) & UARTINTEN_UARTRXBREAKONINTEN_MASK) 
    276 #define UARTINTEN_UARTRXBREAKONINTEN_RESET      0 
    277 #define UARTINTEN_UARTRXPARITYERRINTEN_MSB      5 
    278 #define UARTINTEN_UARTRXPARITYERRINTEN_LSB      5 
    279 #define UARTINTEN_UARTRXPARITYERRINTEN_MASK     0x00000020 
    280 #define UARTINTEN_UARTRXPARITYERRINTEN_GET(x)   (((x) & UARTINTEN_UARTRXPARITYERRINTEN_MASK) >> UARTINTEN_UARTRXPARITYERRINTEN_LSB) 
    281 #define UARTINTEN_UARTRXPARITYERRINTEN_SET(x)   (((0 | (x)) << UARTINTEN_UARTRXPARITYERRINTEN_LSB) & UARTINTEN_UARTRXPARITYERRINTEN_MASK) 
    282 #define UARTINTEN_UARTRXPARITYERRINTEN_RESET    0 
    283 #define UARTINTEN_UARTTXOFLOWERRINTEN_MSB       4 
    284 #define UARTINTEN_UARTTXOFLOWERRINTEN_LSB       4 
    285 #define UARTINTEN_UARTTXOFLOWERRINTEN_MASK      0x00000010 
    286 #define UARTINTEN_UARTTXOFLOWERRINTEN_GET(x)    (((x) & UARTINTEN_UARTTXOFLOWERRINTEN_MASK) >> UARTINTEN_UARTTXOFLOWERRINTEN_LSB) 
    287 #define UARTINTEN_UARTTXOFLOWERRINTEN_SET(x)    (((0 | (x)) << UARTINTEN_UARTTXOFLOWERRINTEN_LSB) & UARTINTEN_UARTTXOFLOWERRINTEN_MASK) 
    288 #define UARTINTEN_UARTTXOFLOWERRINTEN_RESET     0 
    289 #define UARTINTEN_UARTRXOFLOWERRINTEN_MSB       3 
    290 #define UARTINTEN_UARTRXOFLOWERRINTEN_LSB       3 
    291 #define UARTINTEN_UARTRXOFLOWERRINTEN_MASK      0x00000008 
    292 #define UARTINTEN_UARTRXOFLOWERRINTEN_GET(x)    (((x) & UARTINTEN_UARTRXOFLOWERRINTEN_MASK) >> UARTINTEN_UARTRXOFLOWERRINTEN_LSB) 
    293 #define UARTINTEN_UARTRXOFLOWERRINTEN_SET(x)    (((0 | (x)) << UARTINTEN_UARTRXOFLOWERRINTEN_LSB) & UARTINTEN_UARTRXOFLOWERRINTEN_MASK) 
    294 #define UARTINTEN_UARTRXOFLOWERRINTEN_RESET     0 
    295 #define UARTINTEN_UARTRXFRAMINGERRINTEN_MSB     2 
    296 #define UARTINTEN_UARTRXFRAMINGERRINTEN_LSB     2 
    297 #define UARTINTEN_UARTRXFRAMINGERRINTEN_MASK    0x00000004 
    298 #define UARTINTEN_UARTRXFRAMINGERRINTEN_GET(x)  (((x) & UARTINTEN_UARTRXFRAMINGERRINTEN_MASK) >> UARTINTEN_UARTRXFRAMINGERRINTEN_LSB) 
    299 #define UARTINTEN_UARTRXFRAMINGERRINTEN_SET(x)  (((0 | (x)) << UARTINTEN_UARTRXFRAMINGERRINTEN_LSB) & UARTINTEN_UARTRXFRAMINGERRINTEN_MASK) 
    300 #define UARTINTEN_UARTRXFRAMINGERRINTEN_RESET   0 
    301 #define UARTINTEN_UARTTXREADYINTEN_MSB          1 
    302 #define UARTINTEN_UARTTXREADYINTEN_LSB          1 
    303 #define UARTINTEN_UARTTXREADYINTEN_MASK         0x00000002 
    304 #define UARTINTEN_UARTTXREADYINTEN_GET(x)       (((x) & UARTINTEN_UARTTXREADYINTEN_MASK) >> UARTINTEN_UARTTXREADYINTEN_LSB) 
    305 #define UARTINTEN_UARTTXREADYINTEN_SET(x)       (((0 | (x)) << UARTINTEN_UARTTXREADYINTEN_LSB) & UARTINTEN_UARTTXREADYINTEN_MASK) 
    306 #define UARTINTEN_UARTTXREADYINTEN_RESET        0 
    307 #define UARTINTEN_UARTRXVALIDINTEN_MSB          0 
    308 #define UARTINTEN_UARTRXVALIDINTEN_LSB          0 
    309 #define UARTINTEN_UARTRXVALIDINTEN_MASK         0x00000001 
    310 #define UARTINTEN_UARTRXVALIDINTEN_GET(x)       (((x) & UARTINTEN_UARTRXVALIDINTEN_MASK) >> UARTINTEN_UARTRXVALIDINTEN_LSB) 
    311 #define UARTINTEN_UARTRXVALIDINTEN_SET(x)       (((0 | (x)) << UARTINTEN_UARTRXVALIDINTEN_LSB) & UARTINTEN_UARTRXVALIDINTEN_MASK) 
    312 #define UARTINTEN_UARTRXVALIDINTEN_RESET        0 
    313 #define UARTINTEN_ADDRESS                       0x0010 
    314 #define UARTINTEN_HW_MASK                       0x000003ff 
    315 #define UARTINTEN_SW_MASK                       0x000003ff 
    316 #define UARTINTEN_RSTMASK                       0x000003ff 
    317 #define UARTINTEN_RESET                         0x00000000 
    31854 
    31955/* 
     
    407143static inline void ar933x_uart_start_tx_interrupt(struct ar933x_uart_port *up) 
    408144{ 
    409         ar933x_uart_rmw_set(up, UARTINTEN_ADDRESS, 
    410                             UARTINTEN_UARTTXEMPTYINTEN_SET(1)); 
     145        ar933x_uart_rmw_set(up, AR933X_UART_INT_EN_REG, 
     146                            AR933X_UART_INT_TX_EMPTY); 
    411147} 
    412148 
     
    417153 
    418154                /* FIXME: why this uses RXVALIDINTEN? */ 
    419                 ar933x_uart_rmw_clear(up, UARTINTEN_ADDRESS, 
    420                                       UARTINTEN_UARTRXVALIDINTEN_SET(1)); 
     155                ar933x_uart_rmw_clear(up, AR933X_UART_INT_EN_REG, 
     156                                      AR933X_UART_INT_RX_VALID); 
    421157        } 
    422158} 
     
    429165 
    430166        spin_lock_irqsave(&up->port.lock, flags); 
    431         rdata = ar933x_uart_read(up, UARTDATA_ADDRESS); 
     167        rdata = ar933x_uart_read(up, AR933X_UART_DATA_REG); 
    432168        spin_unlock_irqrestore(&up->port.lock, flags); 
    433169 
    434         return (rdata & UARTDATA_UARTTXCSR_MASK) ? 0 : TIOCSER_TEMT; 
     170        return (rdata & AR933X_UART_DATA_TX_CSR) ? 0 : TIOCSER_TEMT; 
    435171} 
    436172 
     
    465201        up->port.read_status_mask &= ~UART_LSR_DR; 
    466202 
    467         ar933x_uart_rmw_clear(up, UARTINTEN_ADDRESS, 
    468                               UARTINTEN_UARTRXVALIDINTEN_SET(1)); 
     203        ar933x_uart_rmw_clear(up, AR933X_UART_INT_EN_REG, 
     204                              AR933X_UART_INT_RX_VALID); 
    469205} 
    470206 
     
    482218                up->lcr &= ~UART_LCR_SBC; 
    483219 
    484         rdata = ar933x_uart_read(up, UARTCS_ADDRESS); 
     220        rdata = ar933x_uart_read(up, AR933X_UART_CS_REG); 
    485221        if (up->lcr & UART_LCR_SBC) 
    486                 rdata |= UARTCS_UARTTXBREAK_SET(1); 
     222                rdata |= AR933X_UART_CS_TX_BREAK; 
    487223        else 
    488                 rdata &= ~UARTCS_UARTTXBREAK_SET(1); 
    489  
    490         ar933x_uart_write(up, UARTCS_ADDRESS, rdata); 
     224                rdata &= ~AR933X_UART_CS_TX_BREAK; 
     225 
     226        ar933x_uart_write(up, AR933X_UART_CS_REG, rdata); 
    491227 
    492228        spin_unlock_irqrestore(&up->port.lock, flags); 
     
    614350                up->ier |= UART_IER_MSI; 
    615351 
    616         ar933x_uart_rmw_set(up, UARTCS_ADDRESS, 
    617                             UARTCS_UARTHOSTINTEN_SET(1)); 
     352        ar933x_uart_rmw_set(up, AR933X_UART_CS_REG, 
     353                            AR933X_UART_CS_HOST_INT_EN); 
    618354 
    619355        /* Save LCR */ 
     
    633369 
    634370        do { 
    635                 ch = (unsigned char)UARTDATA_UARTTXRXDATA_GET(lsr); 
     371                ch = lsr & AR933X_UART_DATA_TX_RX_MASK; 
    636372 
    637373                flag = TTY_NORMAL; 
    638374                up->port.icount.rx++; 
    639375 
    640                 lsr = UARTDATA_UARTRXCSR_SET(1); 
    641                 ar933x_uart_write(up, UARTDATA_ADDRESS, lsr); 
     376                lsr = AR933X_UART_DATA_RX_CSR; 
     377                ar933x_uart_write(up, AR933X_UART_DATA_REG, lsr); 
    642378 
    643379                if (unlikely(lsr & (UART_LSR_BI | UART_LSR_PE | 
     
    684420 
    685421ignore_char: 
    686                 lsr = ar933x_uart_read(up, UARTDATA_ADDRESS); 
    687         } while ((lsr & UARTDATA_UARTRXCSR_MASK) && (max_count-- > 0)); 
     422                lsr = ar933x_uart_read(up, AR933X_UART_DATA_REG); 
     423        } while ((lsr & AR933X_UART_DATA_RX_CSR) && (max_count-- > 0)); 
    688424 
    689425        spin_unlock(&up->port.lock); 
     
    700436        unsigned int rdata; 
    701437 
    702         rdata = ar933x_uart_read(up, UARTDATA_ADDRESS); 
    703         if (UARTDATA_UARTTXCSR_GET(rdata) == 0) { 
     438        rdata = ar933x_uart_read(up, AR933X_UART_DATA_REG); 
     439        if ((rdata & AR933X_UART_DATA_TX_CSR) == 0) { 
    704440                ar933x_uart_start_tx_interrupt(up); 
    705441                return; 
     
    707443 
    708444        if (up->port.x_char) { 
    709                 rdata = UARTDATA_UARTTXRXDATA_SET((unsigned int)(up->port.x_char)); 
    710                 rdata |= UARTDATA_UARTTXCSR_SET(1); 
    711                 ar933x_uart_write(up, UARTDATA_ADDRESS, rdata); 
     445                rdata = up->port.x_char & AR933X_UART_DATA_TX_RX_MASK; 
     446                rdata |= AR933X_UART_DATA_TX_CSR; 
     447                ar933x_uart_write(up, AR933X_UART_DATA_REG, rdata); 
    712448                up->port.icount.tx++; 
    713449                up->port.x_char = 0; 
     
    728464        count = up->port.fifosize / 4; 
    729465        do { 
    730                 rdata = ar933x_uart_read(up, UARTDATA_ADDRESS); 
    731                 if (UARTDATA_UARTTXCSR_GET(rdata) == 0) { 
     466                rdata = ar933x_uart_read(up, AR933X_UART_DATA_REG); 
     467                if ((rdata & AR933X_UART_DATA_TX_CSR) == 0) { 
    732468                        ar933x_uart_start_tx_interrupt(up); 
    733469                        return; 
    734470                } 
    735471 
    736                 rdata = UARTDATA_UARTTXRXDATA_SET((unsigned int)(xmit->buf[xmit->tail])); 
    737                 rdata |= UARTDATA_UARTTXCSR_SET(1); 
    738                 ar933x_uart_write(up, UARTDATA_ADDRESS, rdata); 
     472                rdata = xmit->buf[xmit->tail] & AR933X_UART_DATA_TX_RX_MASK; 
     473                rdata |= AR933X_UART_DATA_TX_CSR; 
     474                ar933x_uart_write(up, AR933X_UART_DATA_REG, rdata); 
    739475 
    740476                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); 
     
    744480        } while (--count > 0); 
    745481 
    746         rdata = ar933x_uart_read(up, UARTDATA_ADDRESS); 
    747         if (UARTDATA_UARTTXCSR_GET(rdata) == 0) { 
     482        rdata = ar933x_uart_read(up, AR933X_UART_DATA_REG); 
     483        if ((rdata & AR933X_UART_DATA_TX_CSR) == 0) { 
    748484                ar933x_uart_start_tx_interrupt(up); 
    749485                return; 
     
    779515 
    780516        /* 2. clear uartcs hostinten mask, bit13 */ 
    781         ar933x_uart_rmw_clear(up, UARTCS_ADDRESS, 
    782                               UARTCS_UARTHOSTINTEN_SET(1)); 
     517        ar933x_uart_rmw_clear(up, AR933X_UART_CS_REG, 
     518                              AR933X_UART_CS_HOST_INT_EN); 
    783519 
    784520        /* 3. clear rx uartint */ 
    785         ar933x_uart_write(up, UARTINT_ADDRESS, UARTINT_UARTRXVALIDINT_SET(1)); 
     521        ar933x_uart_write(up, AR933X_UART_INT_REG, AR933X_UART_INT_RX_VALID); 
    786522 
    787523        /* 4. clear misc interrupt status  */ 
     
    789525 
    790526        /* 5. clear rx uartinten*/ 
    791         ar933x_uart_rmw_clear(up, UARTINTEN_ADDRESS, 
    792                               UARTINTEN_UARTRXVALIDINTEN_SET(1)); 
     527        ar933x_uart_rmw_clear(up, AR933X_UART_INT_EN_REG, 
     528                              AR933X_UART_INT_RX_VALID); 
    793529 
    794530        /* 6. enable rx int*/ 
    795         ar933x_uart_rmw_set(up, UARTINTEN_ADDRESS, 
    796                             UARTINTEN_UARTRXVALIDINTEN_SET(1)); 
     531        ar933x_uart_rmw_set(up, AR933X_UART_INT_EN_REG, 
     532                            AR933X_UART_INT_RX_VALID); 
    797533 
    798534        /* 7. set uartcs hostinten mask */ 
    799         ar933x_uart_rmw_set(up, UARTCS_ADDRESS, 
    800                             UARTCS_UARTHOSTINTEN_SET(1)); 
     535        ar933x_uart_rmw_set(up, AR933X_UART_CS_REG, 
     536                            AR933X_UART_CS_HOST_INT_EN); 
    801537 
    802538        /* 8. set misc int mask */ 
     
    811547        unsigned long flags; 
    812548 
    813         status = ar933x_uart_read(up, UARTDATA_ADDRESS); 
    814         int_status = ar933x_uart_read(up, UARTINT_ADDRESS); 
    815         en_status = ar933x_uart_read(up, UARTINTEN_ADDRESS); 
     549        status = ar933x_uart_read(up, AR933X_UART_DATA_REG); 
     550        int_status = ar933x_uart_read(up, AR933X_UART_INT_REG); 
     551        en_status = ar933x_uart_read(up, AR933X_UART_INT_EN_REG); 
    816552 
    817553        spin_lock_irqsave(&up->port.lock, flags); 
    818554 
    819         if( (int_status & en_status) & UARTINT_UARTRXVALIDINT_MASK ) 
     555        if( (int_status & en_status) & AR933X_UART_INT_RX_VALID ) 
    820556                ar933x_uart_rx_chars(up, &status); 
    821557 
    822         if (((int_status & en_status) & UARTINT_UARTTXEMPTYINT_MASK)) { 
     558        if (((int_status & en_status) & AR933X_UART_INT_TX_EMPTY)) { 
    823559                /* clear TX empty interrupts */ 
    824                 ar933x_uart_write(up, UARTINT_ADDRESS, 
    825                                   UARTINT_UARTTXEMPTYINT_SET(1)); 
     560                ar933x_uart_write(up, AR933X_UART_INT_REG, 
     561                                  AR933X_UART_INT_TX_EMPTY); 
    826562 
    827563                /* disable TX empty interrupts */ 
    828                 ar933x_uart_rmw_clear(up, UARTINTEN_ADDRESS, 
    829                                       UARTINTEN_UARTTXEMPTYINTEN_SET(1)); 
     564                ar933x_uart_rmw_clear(up, AR933X_UART_INT_EN_REG, 
     565                                      AR933X_UART_INT_TX_EMPTY); 
    830566 
    831567                if (!uart_circ_empty(&up->port.state->xmit)) 
     
    843579        up = (struct ar933x_uart_port *) dev_id; 
    844580 
    845         iir = ar933x_uart_read(up, UARTCS_ADDRESS); 
    846         if ((iir & UARTCS_UARTHOSTINT_MASK) == 0) 
     581        iir = ar933x_uart_read(up, AR933X_UART_CS_REG); 
     582        if ((iir & AR933X_UART_CS_HOST_INT) == 0) 
    847583                return IRQ_NONE; 
    848584 
     
    875611                } 
    876612        } else { 
    877                 iir = ar933x_uart_read(up, UARTCS_ADDRESS); 
    878                 if (iir & UARTCS_UARTHOSTINT_MASK) { 
     613                iir = ar933x_uart_read(up, AR933X_UART_CS_REG); 
     614                if (iir & AR933X_UART_CS_HOST_INT) { 
    879615                        spin_lock(&up->port.lock); 
    880616                        ar933x_uart_handle_port(up); 
     
    902638         * Clear the interrupt registers. 
    903639         */ 
    904         ar933x_uart_read(up, UARTCS_ADDRESS); 
    905         ar933x_uart_read(up, UARTINT_ADDRESS); 
     640        ar933x_uart_read(up, AR933X_UART_CS_REG); 
     641        ar933x_uart_read(up, AR933X_UART_INT_REG); 
    906642 
    907643        if (!is_real_interrupt(up->port.irq) || ar933x_ev81847_war()) { 
     
    916652         * Enable host interrupts 
    917653         */ 
    918         ar933x_uart_rmw_set(up, UARTCS_ADDRESS, 
    919                             UARTCS_UARTHOSTINTEN_SET(1)); 
     654        ar933x_uart_rmw_set(up, AR933X_UART_CS_REG, 
     655                            AR933X_UART_CS_HOST_INT_EN); 
    920656 
    921657        /* 
     
    923659         */ 
    924660        up->ier = UART_IER_RLSI | UART_IER_RDI; 
    925         ar933x_uart_write(up, UARTINTEN_ADDRESS, 
    926                           UARTINTEN_UARTRXVALIDINTEN_SET(1)); 
     661        ar933x_uart_write(up, AR933X_UART_INT_EN_REG, 
     662                          AR933X_UART_INT_RX_VALID); 
    927663 
    928664        /* 
    929665         * And clear the interrupt registers again for luck. 
    930666         */ 
    931         ar933x_uart_read(up, UARTINT_ADDRESS); 
     667        ar933x_uart_read(up, AR933X_UART_INT_REG); 
    932668 
    933669        spin_unlock_irqrestore(&up->port.lock, flags); 
     
    945681         */ 
    946682        up->ier = 0; 
    947         ar933x_uart_write(up, UARTINTEN_ADDRESS, 0); 
     683        ar933x_uart_write(up, AR933X_UART_INT_EN_REG, 0); 
    948684 
    949685        spin_lock_irqsave(&up->port.lock, flags); 
     
    955691         * Disable break condition 
    956692         */ 
    957         ar933x_uart_rmw_clear(up, UARTCS_ADDRESS, 
    958                               UARTCS_UARTTXBREAK_SET(1)); 
     693        ar933x_uart_rmw_clear(up, AR933X_UART_CS_REG, 
     694                              AR933X_UART_CS_TX_BREAK); 
    959695 
    960696        if (!is_real_interrupt(up->port.irq) || 
     
    988724 
    989725        /* Clear mask, so no surprise interrupts. */ 
    990         ar933x_uart_read(up, UARTCS_ADDRESS); 
     726        ar933x_uart_read(up, AR933X_UART_CS_REG); 
    991727        /* Clear interrupts status register */ 
    992         ar933x_uart_read(up, UARTINT_ADDRESS); 
     728        ar933x_uart_read(up, AR933X_UART_INT_REG); 
    993729} 
    994730 
     
    1029765        /* Wait up to 60ms for the character(s) to be sent. */ 
    1030766        do { 
    1031                 status = ar933x_uart_read(up, UARTDATA_ADDRESS); 
     767                status = ar933x_uart_read(up, AR933X_UART_DATA_REG); 
    1032768                if (--timeout == 0) 
    1033769                        break; 
    1034770                udelay(1); 
    1035         } while (UARTDATA_UARTTXCSR_GET(status) == 0); 
     771        } while ((status & AR933X_UART_DATA_TX_CSR) == 0); 
    1036772} 
    1037773 
     
    1043779        ar933x_uart_wait_xmitr(up); 
    1044780 
    1045         rdata = UARTDATA_UARTTXRXDATA_SET(ch) | 
    1046                 UARTDATA_UARTTXCSR_SET(1); 
    1047         ar933x_uart_write(up, UARTDATA_ADDRESS, rdata); 
     781        rdata = ch & AR933X_UART_DATA_TX_RX_MASK; 
     782        rdata |= AR933X_UART_DATA_TX_CSR; 
     783        ar933x_uart_write(up, AR933X_UART_DATA_REG, rdata); 
    1048784} 
    1049785 
     
    1068804         * First save the IER then disable the interrupts 
    1069805         */ 
    1070         ier = ar933x_uart_read(up, UARTINTEN_ADDRESS); 
    1071         ar933x_uart_write(up, UARTINTEN_ADDRESS, 0); 
     806        ier = ar933x_uart_read(up, AR933X_UART_INT_EN_REG); 
     807        ar933x_uart_write(up, AR933X_UART_INT_EN_REG, 0); 
    1072808 
    1073809        uart_console_write(&up->port, s, count, ar933x_uart_console_putchar); 
     
    1079815        ar933x_uart_wait_xmitr(up); 
    1080816 
    1081         ar933x_uart_write(up, UARTINTEN_ADDRESS, ier); 
    1082         ar933x_uart_write(up, UARTINT_ADDRESS, UARTINT_RSTMASK); 
     817        ar933x_uart_write(up, AR933X_UART_INT_EN_REG, ier); 
     818        ar933x_uart_write(up, AR933X_UART_INT_REG, AR933X_UART_INT_ALLINTS); 
    1083819 
    1084820        if (locked) 
Note: See TracChangeset for help on using the changeset viewer.