board/keymile/common/qrio.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2013 Keymile AG
   4  * Valentin Longchamp <valentin.longchamp@keymile.com>
   5  */
   6
   7 #include <common.h>
   8
   9 #include "common.h"
  10 #include "qrio.h"
  11
  12 /* QRIO GPIO register offsets */
  13 #define DIRECT_OFF              0x18
  14 #define GPRT_OFF                0x1c
  15
  16 int qrio_get_gpio(u8 port_off, u8 gpio_nr)
  17 {
  18         u32 gprt;
  19
  20         void __iomem *qrio_base = (void *)CONFIG_SYS_QRIO_BASE;
  21
  22         gprt = in_be32(qrio_base + port_off + GPRT_OFF);
  23
  24         return (gprt >> gpio_nr) & 1U;
  25 }
  26
  27 void qrio_set_gpio(u8 port_off, u8 gpio_nr, bool value)
  28 {
  29         u32 gprt, mask;
  30
  31         void __iomem *qrio_base = (void *)CONFIG_SYS_QRIO_BASE;
  32
  33         mask = 1U << gpio_nr;
  34
  35         gprt = in_be32(qrio_base + port_off + GPRT_OFF);
  36         if (value)
  37                 gprt |= mask;
  38         else
  39                 gprt &= ~mask;
  40
  41         out_be32(qrio_base + port_off + GPRT_OFF, gprt);
  42 }
  43
  44 void qrio_gpio_direction_output(u8 port_off, u8 gpio_nr, bool value)
  45 {
  46         u32 direct, mask;
  47
  48         void __iomem *qrio_base = (void *)CONFIG_SYS_QRIO_BASE;
  49
  50         mask = 1U << gpio_nr;
  51
  52         direct = in_be32(qrio_base + port_off + DIRECT_OFF);
  53         direct |= mask;
  54         out_be32(qrio_base + port_off + DIRECT_OFF, direct);
  55
  56         qrio_set_gpio(port_off, gpio_nr, value);
  57 }
  58
  59 void qrio_gpio_direction_input(u8 port_off, u8 gpio_nr)
  60 {
  61         u32 direct, mask;
  62
  63         void __iomem *qrio_base = (void *)CONFIG_SYS_QRIO_BASE;
  64
  65         mask = 1U << gpio_nr;
  66
  67         direct = in_be32(qrio_base + port_off + DIRECT_OFF);
  68         direct &= ~mask;
  69         out_be32(qrio_base + port_off + DIRECT_OFF, direct);
  70 }
  71
  72 void qrio_set_opendrain_gpio(u8 port_off, u8 gpio_nr, u8 val)
  73 {
  74         u32 direct, mask;
  75
  76         void __iomem *qrio_base = (void *)CONFIG_SYS_QRIO_BASE;
  77
  78         mask = 1U << gpio_nr;
  79
  80         direct = in_be32(qrio_base + port_off + DIRECT_OFF);
  81         if (val == 0)
  82                 /* set to output -> GPIO drives low */
  83                 direct |= mask;
  84         else
  85                 /* set to input -> GPIO floating */
  86                 direct &= ~mask;
  87
  88         out_be32(qrio_base + port_off + DIRECT_OFF, direct);
  89 }
  90
  91 #define WDMASK_OFF      0x16
  92
  93 void qrio_wdmask(u8 bit, bool wden)
  94 {
  95         u16 wdmask;
  96         void __iomem *qrio_base = (void *)CONFIG_SYS_QRIO_BASE;
  97
  98         wdmask = in_be16(qrio_base + WDMASK_OFF);
  99
 100         if (wden)
 101                 wdmask |= (1 << bit);
 102         else
 103                 wdmask &= ~(1 << bit);
 104
 105         out_be16(qrio_base + WDMASK_OFF, wdmask);
 106 }
 107
 108 #define PRST_OFF        0x1a
 109
 110 void qrio_prst(u8 bit, bool en, bool wden)
 111 {
 112         u16 prst;
 113         void __iomem *qrio_base = (void *)CONFIG_SYS_QRIO_BASE;
 114
 115         qrio_wdmask(bit, wden);
 116
 117         prst = in_be16(qrio_base + PRST_OFF);
 118
 119         if (en)
 120                 prst &= ~(1 << bit);
 121         else
 122                 prst |= (1 << bit);
 123
 124         out_be16(qrio_base + PRST_OFF, prst);
 125 }
 126
 127 #define PRSTCFG_OFF     0x1c
 128
 129 void qrio_prstcfg(u8 bit, u8 mode)
 130 {
 131         u32 prstcfg;
 132         u8 i;
 133         void __iomem *qrio_base = (void *)CONFIG_SYS_QRIO_BASE;
 134
 135         prstcfg = in_be32(qrio_base + PRSTCFG_OFF);
 136
 137         for (i = 0; i < 2; i++) {
 138                 if (mode & (1 << i))
 139                         set_bit(2 * bit + i, &prstcfg);
 140                 else
 141                         clear_bit(2 * bit + i, &prstcfg);
 142         }
 143
 144         out_be32(qrio_base + PRSTCFG_OFF, prstcfg);
 145 }
 146
 147 #define CTRLH_OFF               0x02
 148 #define CTRLH_WRL_BOOT          0x01
 149 #define CTRLH_WRL_UNITRUN       0x02
 150
 151 void qrio_set_leds(void)
 152 {
 153         u8 ctrlh;
 154         void __iomem *qrio_base = (void *)CONFIG_SYS_QRIO_BASE;
 155
 156         /* set UNIT LED to RED and BOOT LED to ON */
 157         ctrlh = in_8(qrio_base + CTRLH_OFF);
 158         ctrlh |= (CTRLH_WRL_BOOT | CTRLH_WRL_UNITRUN);
 159         out_8(qrio_base + CTRLH_OFF, ctrlh);
 160 }
 161
 162 #define CTRLL_OFF               0x03
 163 #define CTRLL_WRB_BUFENA        0x20
 164
 165 void qrio_enable_app_buffer(void)
 166 {
 167         u8 ctrll;
 168         void __iomem *qrio_base = (void *)CONFIG_SYS_QRIO_BASE;
 169
 170         /* enable application buffer */
 171         ctrll = in_8(qrio_base + CTRLL_OFF);
 172         ctrll |= (CTRLL_WRB_BUFENA);
 173         out_8(qrio_base + CTRLL_OFF, ctrll);
 174 }
 175
 176 #define REASON1_OFF     0x12
 177 #define REASON1_CPUWD   0x01
 178
 179 void qrio_cpuwd_flag(bool flag)
 180 {
 181         u8 reason1;
 182         void __iomem *qrio_base = (void *)CONFIG_SYS_QRIO_BASE;
 183
 184         reason1 = in_8(qrio_base + REASON1_OFF);
 185         if (flag)
 186                 reason1 |= REASON1_CPUWD;
 187         else
 188                 reason1 &= ~REASON1_CPUWD;
 189         out_8(qrio_base + REASON1_OFF, reason1);
 190 }
 191
 192 #define REASON0_OFF     0x13
 193 #define REASON0_SWURST  0x80
 194 #define REASON0_CPURST  0x40
 195 #define REASON0_BPRST   0x20
 196 #define REASON0_COPRST  0x10
 197 #define REASON0_SWCRST  0x08
 198 #define REASON0_WDRST   0x04
 199 #define REASON0_KBRST   0x02
 200 #define REASON0_POWUP   0x01
 201 #define UNIT_RESET\
 202         ((REASON1_CPUWD << 8) |\
 203         REASON0_POWUP | REASON0_COPRST | REASON0_KBRST |\
 204         REASON0_BPRST | REASON0_SWURST | REASON0_WDRST)
 205 #define CORE_RESET      REASON0_SWCRST
 206
 207 bool qrio_reason_unitrst(void)
 208 {
 209         u16 reason;
 210         void __iomem *qrio_base = (void *)CONFIG_SYS_QRIO_BASE;
 211
 212         reason = in_be16(qrio_base + REASON1_OFF);
 213
 214         return (reason & UNIT_RESET) > 0;
 215 }
 216
 217 #define RSTCFG_OFF      0x11
 218
 219 void qrio_uprstreq(u8 mode)
 220 {
 221         u32 rstcfg;
 222         void __iomem *qrio_base = (void *)CONFIG_SYS_QRIO_BASE;
 223
 224         rstcfg = in_8(qrio_base + RSTCFG_OFF);
 225
 226         if (mode & UPREQ_CORE_RST)
 227                 rstcfg |= UPREQ_CORE_RST;
 228         else
 229                 rstcfg &= ~UPREQ_CORE_RST;
 230
 231         out_8(qrio_base + RSTCFG_OFF, rstcfg);
 232 }
 233
 234 /* I2C deblocking uses the algorithm defined in board/keymile/common/common.c
 235  * 2 dedicated QRIO GPIOs externally pull the SCL and SDA lines
 236  * For I2C only the low state is activly driven and high state is pulled-up
 237  * by a resistor. Therefore the deblock GPIOs are used
 238  *  -> as an active output to drive a low state
 239  *  -> as an open-drain input to have a pulled-up high state
 240  */
 241
 242 /* By default deblock GPIOs are floating */
 243 void i2c_deblock_gpio_cfg(void)
 244 {
 245         /* set I2C bus 1 deblocking GPIOs input, but 0 value for open drain */
 246         qrio_gpio_direction_input(KM_I2C_DEBLOCK_PORT,
 247                                   KM_I2C_DEBLOCK_SCL);
 248         qrio_gpio_direction_input(KM_I2C_DEBLOCK_PORT,
 249                                   KM_I2C_DEBLOCK_SDA);
 250
 251         qrio_set_gpio(KM_I2C_DEBLOCK_PORT,
 252                       KM_I2C_DEBLOCK_SCL, 0);
 253         qrio_set_gpio(KM_I2C_DEBLOCK_PORT,
 254                       KM_I2C_DEBLOCK_SDA, 0);
 255 }
 256
 257 void set_sda(int state)
 258 {
 259         qrio_set_opendrain_gpio(KM_I2C_DEBLOCK_PORT,
 260                                 KM_I2C_DEBLOCK_SDA, state);
 261 }
 262
 263 void set_scl(int state)
 264 {
 265         qrio_set_opendrain_gpio(KM_I2C_DEBLOCK_PORT,
 266                                 KM_I2C_DEBLOCK_SCL, state);
 267 }
 268
 269 int get_sda(void)
 270 {
 271         return qrio_get_gpio(KM_I2C_DEBLOCK_PORT,
 272                              KM_I2C_DEBLOCK_SDA);
 273 }
 274
 275 int get_scl(void)
 276 {
 277         return qrio_get_gpio(KM_I2C_DEBLOCK_PORT,
 278                              KM_I2C_DEBLOCK_SCL);
 279 }
 280