drivers/staging/media/atomisp/pci/atomisp2/css2400/hive_isp_css_common/host/fifo_monitor.c

   1 /*
   2  * Support for Intel Camera Imaging ISP subsystem.
   3  * Copyright (c) 2010-2015, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  */
  14
  15 #include "fifo_monitor.h"
  16
  17 #include <type_support.h>
  18 #include "device_access.h"
  19
  20 #include <hrt/bits.h>
  21
  22 #include "gp_device.h"
  23
  24 #include "assert_support.h"
  25
  26 #ifndef __INLINE_FIFO_MONITOR__
  27 #define STORAGE_CLASS_FIFO_MONITOR_DATA static const
  28 #else
  29 #define STORAGE_CLASS_FIFO_MONITOR_DATA const
  30 #endif /* __INLINE_FIFO_MONITOR__ */
  31
  32 STORAGE_CLASS_FIFO_MONITOR_DATA unsigned int FIFO_SWITCH_ADDR[N_FIFO_SWITCH] = {
  33         _REG_GP_SWITCH_IF_ADDR,
  34         _REG_GP_SWITCH_GDC1_ADDR,
  35         _REG_GP_SWITCH_GDC2_ADDR};
  36
  37 #ifndef __INLINE_FIFO_MONITOR__
  38 #include "fifo_monitor_private.h"
  39 #endif /* __INLINE_FIFO_MONITOR__ */
  40
  41 STORAGE_CLASS_INLINE bool fifo_monitor_status_valid (
  42         const fifo_monitor_ID_t         ID,
  43         const unsigned int                      reg,
  44         const unsigned int                      port_id);
  45
  46 STORAGE_CLASS_INLINE bool fifo_monitor_status_accept(
  47         const fifo_monitor_ID_t         ID,
  48         const unsigned int                      reg,
  49         const unsigned int                      port_id);
  50
  51
  52 void fifo_channel_get_state(
  53         const fifo_monitor_ID_t         ID,
  54         const fifo_channel_t            channel_id,
  55         fifo_channel_state_t            *state)
  56 {
  57         assert(channel_id < N_FIFO_CHANNEL);
  58         assert(state != NULL);
  59
  60         switch (channel_id) {
  61         case FIFO_CHANNEL_ISP0_TO_SP0:
  62                 state->src_valid   = fifo_monitor_status_valid(ID,
  63                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
  64                         ISP_STR_MON_PORT_SND_SP); /* ISP_STR_MON_PORT_ISP2SP */
  65                 state->fifo_accept = fifo_monitor_status_accept(ID,
  66                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
  67                         ISP_STR_MON_PORT_SND_SP);
  68                 state->fifo_valid  = fifo_monitor_status_valid(ID,
  69                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
  70                         SP_STR_MON_PORT_RCV_ISP); /* ISP_STR_MON_PORT_SP2ISP */
  71                 state->sink_accept = fifo_monitor_status_accept(ID,
  72                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
  73                         SP_STR_MON_PORT_RCV_ISP);
  74                 break;
  75         case FIFO_CHANNEL_SP0_TO_ISP0:
  76                 state->src_valid   = fifo_monitor_status_valid(ID,
  77                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
  78                         SP_STR_MON_PORT_SND_ISP); /* ISP_STR_MON_PORT_SP2ISP */
  79                 state->fifo_accept = fifo_monitor_status_accept(ID,
  80                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
  81                         SP_STR_MON_PORT_SND_ISP);
  82                 state->fifo_valid  = fifo_monitor_status_valid(ID,
  83                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
  84                         ISP_STR_MON_PORT_RCV_SP); /* ISP_STR_MON_PORT_ISP2SP */
  85                 state->sink_accept = fifo_monitor_status_accept(ID,
  86                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
  87                         ISP_STR_MON_PORT_RCV_SP);
  88                 break;
  89         case FIFO_CHANNEL_ISP0_TO_IF0:
  90                 state->src_valid   = fifo_monitor_status_valid(ID,
  91                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
  92                         ISP_STR_MON_PORT_SND_PIF_A); /* ISP_STR_MON_PORT_ISP2PIFA */
  93                 state->fifo_accept = fifo_monitor_status_accept(ID,
  94                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
  95                         ISP_STR_MON_PORT_SND_PIF_A);
  96                 state->fifo_valid  = fifo_monitor_status_valid(ID,
  97                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
  98                         MOD_STR_MON_PORT_RCV_PIF_A); /* MOD_STR_MON_PORT_CELLS2PIFA */
  99                 state->sink_accept = fifo_monitor_status_accept(ID,
 100                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 101                         MOD_STR_MON_PORT_RCV_PIF_A);
 102                 break;
 103         case FIFO_CHANNEL_IF0_TO_ISP0:
 104                 state->src_valid   = fifo_monitor_status_valid(ID,
 105                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 106                         MOD_STR_MON_PORT_SND_PIF_A); /* MOD_STR_MON_PORT_PIFA2CELLS */
 107                 state->fifo_accept = fifo_monitor_status_accept(ID,
 108                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 109                         MOD_STR_MON_PORT_SND_PIF_A);
 110                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 111                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 112                         ISP_STR_MON_PORT_RCV_PIF_A); /* ISP_STR_MON_PORT_PIFA2ISP */
 113                 state->sink_accept = fifo_monitor_status_accept(ID,
 114                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 115                         ISP_STR_MON_PORT_RCV_PIF_A);
 116                 break;
 117         case FIFO_CHANNEL_ISP0_TO_IF1:
 118                 state->src_valid   = fifo_monitor_status_valid(ID,
 119                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 120                         ISP_STR_MON_PORT_SND_PIF_B); /* ISP_STR_MON_PORT_ISP2PIFA */
 121                 state->fifo_accept = fifo_monitor_status_accept(ID,
 122                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 123                         ISP_STR_MON_PORT_SND_PIF_B);
 124                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 125                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 126                         MOD_STR_MON_PORT_RCV_PIF_B); /* MOD_STR_MON_PORT_CELLS2PIFB */
 127                 state->sink_accept = fifo_monitor_status_accept(ID,
 128                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 129                         MOD_STR_MON_PORT_RCV_PIF_B);
 130                 break;
 131         case FIFO_CHANNEL_IF1_TO_ISP0:
 132                 state->src_valid   = fifo_monitor_status_valid(ID,
 133                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 134                         MOD_STR_MON_PORT_SND_PIF_B); /* MOD_STR_MON_PORT_PIFB2CELLS */
 135                 state->fifo_accept = fifo_monitor_status_accept(ID,
 136                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 137                         MOD_STR_MON_PORT_SND_PIF_B);
 138                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 139                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 140                         ISP_STR_MON_PORT_RCV_PIF_B); /* ISP_STR_MON_PORT_PIFB2ISP */
 141                 state->sink_accept = fifo_monitor_status_accept(ID,
 142                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 143                         ISP_STR_MON_PORT_RCV_PIF_B);
 144                 break;
 145         case FIFO_CHANNEL_ISP0_TO_DMA0:
 146                 state->src_valid   = fifo_monitor_status_valid(ID,
 147                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 148                         ISP_STR_MON_PORT_SND_DMA); /* ISP_STR_MON_PORT_ISP2DMA */
 149                 state->fifo_accept = fifo_monitor_status_accept(ID,
 150                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 151                         ISP_STR_MON_PORT_SND_DMA);
 152                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 153                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 154                         MOD_STR_MON_PORT_RCV_DMA_FR_ISP); /* MOD_STR_MON_PORT_ISP2DMA */
 155                 state->sink_accept = fifo_monitor_status_accept(ID,
 156                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 157                         MOD_STR_MON_PORT_RCV_DMA_FR_ISP);
 158                 break;
 159         case FIFO_CHANNEL_DMA0_TO_ISP0:
 160                 state->src_valid   = fifo_monitor_status_valid(ID,
 161                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 162                         MOD_STR_MON_PORT_SND_DMA2ISP); /* MOD_STR_MON_PORT_DMA2ISP */
 163                 state->fifo_accept = fifo_monitor_status_accept(ID,
 164                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 165                         MOD_STR_MON_PORT_SND_DMA2ISP);
 166                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 167                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 168                         ISP_STR_MON_PORT_RCV_DMA); /* ISP_STR_MON_PORT_DMA2ISP */
 169                 state->sink_accept = fifo_monitor_status_accept(ID,
 170                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 171                         ISP_STR_MON_PORT_RCV_DMA);
 172                 break;
 173         case FIFO_CHANNEL_ISP0_TO_GDC0:
 174                 state->src_valid   = fifo_monitor_status_valid(ID,
 175                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 176                         ISP_STR_MON_PORT_SND_GDC); /* ISP_STR_MON_PORT_ISP2GDC1 */
 177                 state->fifo_accept = fifo_monitor_status_accept(ID,
 178                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 179                         ISP_STR_MON_PORT_SND_GDC);
 180                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 181                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 182                         MOD_STR_MON_PORT_RCV_GDC); /* MOD_STR_MON_PORT_CELLS2GDC1 */
 183                 state->sink_accept = fifo_monitor_status_accept(ID,
 184                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 185                         MOD_STR_MON_PORT_RCV_GDC);
 186                 break;
 187         case FIFO_CHANNEL_GDC0_TO_ISP0:
 188                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 189                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 190                         MOD_STR_MON_PORT_SND_GDC); /* MOD_STR_MON_PORT_GDC12CELLS */
 191                 state->sink_accept = fifo_monitor_status_accept(ID,
 192                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 193                         MOD_STR_MON_PORT_SND_GDC);
 194                 state->src_valid   = fifo_monitor_status_valid(ID,
 195                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 196                         ISP_STR_MON_PORT_RCV_GDC); /* ISP_STR_MON_PORT_GDC12ISP */
 197                 state->fifo_accept = fifo_monitor_status_accept(ID,
 198                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 199                         ISP_STR_MON_PORT_RCV_GDC);
 200                 break;
 201         case FIFO_CHANNEL_ISP0_TO_GDC1:
 202                 state->src_valid   = fifo_monitor_status_valid(ID,
 203                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 204                         ISP_STR_MON_PORT_ISP2GDC2);
 205                 state->fifo_accept = fifo_monitor_status_accept(ID,
 206                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 207                         ISP_STR_MON_PORT_ISP2GDC2);
 208                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 209                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 210                         MOD_STR_MON_PORT_CELLS2GDC2);
 211                 state->sink_accept = fifo_monitor_status_accept(ID,
 212                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 213                         MOD_STR_MON_PORT_CELLS2GDC2);
 214                 break;
 215         case FIFO_CHANNEL_GDC1_TO_ISP0:
 216                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 217                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 218                         MOD_STR_MON_PORT_GDC22CELLS);
 219                 state->sink_accept = fifo_monitor_status_accept(ID,
 220                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 221                         MOD_STR_MON_PORT_GDC22CELLS);
 222                 state->src_valid   = fifo_monitor_status_valid(ID,
 223                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 224                         ISP_STR_MON_PORT_GDC22ISP);
 225                 state->fifo_accept = fifo_monitor_status_accept(ID,
 226                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 227                         ISP_STR_MON_PORT_GDC22ISP);
 228                 break;
 229         case FIFO_CHANNEL_ISP0_TO_HOST0:
 230                 state->src_valid   = fifo_monitor_status_valid(ID,
 231                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 232                         ISP_STR_MON_PORT_SND_GPD); /* ISP_STR_MON_PORT_ISP2GPD */
 233                 state->fifo_accept = fifo_monitor_status_accept(ID,
 234                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 235                         ISP_STR_MON_PORT_SND_GPD);
 236                 {
 237                 hrt_data        value = ia_css_device_load_uint32(0x0000000000380014ULL);
 238                 state->fifo_valid  = !_hrt_get_bit(value, 0);
 239                 state->sink_accept = false; /* no monitor connected */
 240                 }
 241                 break;
 242         case FIFO_CHANNEL_HOST0_TO_ISP0:
 243                 {
 244                 hrt_data        value = ia_css_device_load_uint32(0x000000000038001CULL);
 245                 state->fifo_valid  = false; /* no monitor connected */
 246                 state->sink_accept = !_hrt_get_bit(value, 0);
 247                 }
 248                 state->src_valid   = fifo_monitor_status_valid(ID,
 249                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 250                         ISP_STR_MON_PORT_RCV_GPD); /* ISP_STR_MON_PORT_FA2ISP */
 251                 state->fifo_accept = fifo_monitor_status_accept(ID,
 252                         HIVE_GP_REGS_ISP_STREAM_STAT_IDX,
 253                         ISP_STR_MON_PORT_RCV_GPD);
 254                 break;
 255         case FIFO_CHANNEL_SP0_TO_IF0:
 256                 state->src_valid   = fifo_monitor_status_valid(ID,
 257                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 258                         SP_STR_MON_PORT_SND_PIF_A); /* SP_STR_MON_PORT_SP2PIFA */
 259                 state->fifo_accept = fifo_monitor_status_accept(ID,
 260                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 261                         SP_STR_MON_PORT_SND_PIF_A);
 262                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 263                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 264                         MOD_STR_MON_PORT_RCV_PIF_A); /* MOD_STR_MON_PORT_CELLS2PIFA */
 265                 state->sink_accept = fifo_monitor_status_accept(ID,
 266                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 267                         MOD_STR_MON_PORT_RCV_PIF_A);
 268                 break;
 269         case FIFO_CHANNEL_IF0_TO_SP0:
 270                 state->src_valid   = fifo_monitor_status_valid(ID,
 271                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 272                         MOD_STR_MON_PORT_SND_PIF_A); /* MOD_STR_MON_PORT_PIFA2CELLS */
 273                 state->fifo_accept = fifo_monitor_status_accept(ID,
 274                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 275                         MOD_STR_MON_PORT_SND_PIF_A);
 276                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 277                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 278                         SP_STR_MON_PORT_RCV_PIF_A); /* SP_STR_MON_PORT_PIFA2SP */
 279                 state->sink_accept = fifo_monitor_status_accept(ID,
 280                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 281                         SP_STR_MON_PORT_RCV_PIF_A);
 282                 break;
 283         case FIFO_CHANNEL_SP0_TO_IF1:
 284                 state->src_valid   = fifo_monitor_status_valid(ID,
 285                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 286                         SP_STR_MON_PORT_SND_PIF_B); /* SP_STR_MON_PORT_SP2PIFB */
 287                 state->fifo_accept = fifo_monitor_status_accept(ID,
 288                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 289                         SP_STR_MON_PORT_SND_PIF_B);
 290                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 291                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 292                         MOD_STR_MON_PORT_RCV_PIF_B); /* MOD_STR_MON_PORT_CELLS2PIFB */
 293                 state->sink_accept = fifo_monitor_status_accept(ID,
 294                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 295                         MOD_STR_MON_PORT_RCV_PIF_B);
 296                 break;
 297         case FIFO_CHANNEL_IF1_TO_SP0:
 298                 state->src_valid   = fifo_monitor_status_valid(ID,
 299                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 300                         MOD_STR_MON_PORT_SND_PIF_B); /* MOD_STR_MON_PORT_PIFB2CELLS */
 301                 state->fifo_accept = fifo_monitor_status_accept(ID,
 302                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 303                         MOD_STR_MON_PORT_SND_PIF_B);
 304                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 305                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 306                         ISP_STR_MON_PORT_RCV_PIF_B); /* SP_STR_MON_PORT_PIFB2SP */
 307                 state->sink_accept = fifo_monitor_status_accept(ID,
 308                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 309                         ISP_STR_MON_PORT_RCV_PIF_B);
 310                 break;
 311         case FIFO_CHANNEL_SP0_TO_IF2:
 312                 state->src_valid   = fifo_monitor_status_valid(ID,
 313                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 314                         SP_STR_MON_PORT_SND_SIF); /* SP_STR_MON_PORT_SP2SIF */
 315                 state->fifo_accept = fifo_monitor_status_accept(ID,
 316                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 317                         SP_STR_MON_PORT_SND_SIF);
 318                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 319                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 320                         MOD_STR_MON_PORT_RCV_SIF); /* MOD_STR_MON_PORT_SP2SIF */
 321                 state->sink_accept = fifo_monitor_status_accept(ID,
 322                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 323                         MOD_STR_MON_PORT_RCV_SIF);
 324                 break;
 325         case FIFO_CHANNEL_IF2_TO_SP0:
 326                 state->src_valid   = fifo_monitor_status_valid(ID,
 327                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 328                         MOD_STR_MON_PORT_SND_SIF); /* MOD_STR_MON_PORT_SIF2SP */
 329                 state->fifo_accept = fifo_monitor_status_accept(ID,
 330                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 331                         MOD_STR_MON_PORT_SND_SIF);
 332                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 333                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 334                         SP_STR_MON_PORT_RCV_SIF); /* SP_STR_MON_PORT_SIF2SP */
 335                 state->sink_accept = fifo_monitor_status_accept(ID,
 336                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 337                         SP_STR_MON_PORT_RCV_SIF);
 338                 break;
 339         case FIFO_CHANNEL_SP0_TO_DMA0:
 340                 state->src_valid   = fifo_monitor_status_valid(ID,
 341                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 342                         SP_STR_MON_PORT_SND_DMA); /* SP_STR_MON_PORT_SP2DMA */
 343                 state->fifo_accept = fifo_monitor_status_accept(ID,
 344                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 345                         SP_STR_MON_PORT_SND_DMA);
 346                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 347                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 348                         MOD_STR_MON_PORT_RCV_DMA_FR_SP); /* MOD_STR_MON_PORT_SP2DMA */
 349                 state->sink_accept = fifo_monitor_status_accept(ID,
 350                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 351                         MOD_STR_MON_PORT_RCV_DMA_FR_SP);
 352                 break;
 353         case FIFO_CHANNEL_DMA0_TO_SP0:
 354                 state->src_valid   = fifo_monitor_status_valid(ID,
 355                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 356                         MOD_STR_MON_PORT_SND_DMA2SP); /* MOD_STR_MON_PORT_DMA2SP */
 357                 state->fifo_accept = fifo_monitor_status_accept(ID,
 358                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 359                         MOD_STR_MON_PORT_SND_DMA2SP);
 360                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 361                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 362                         SP_STR_MON_PORT_RCV_DMA); /* SP_STR_MON_PORT_DMA2SP */
 363                 state->sink_accept = fifo_monitor_status_accept(ID,
 364                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 365                         SP_STR_MON_PORT_RCV_DMA);
 366                 break;
 367         case FIFO_CHANNEL_SP0_TO_GDC0:
 368                 state->src_valid   = fifo_monitor_status_valid(ID,
 369                         HIVE_GP_REGS_SP_STREAM_STAT_B_IDX,
 370                         SP_STR_MON_PORT_B_SP2GDC1);
 371                 state->fifo_accept = fifo_monitor_status_accept(ID,
 372                         HIVE_GP_REGS_SP_STREAM_STAT_B_IDX,
 373                         SP_STR_MON_PORT_B_SP2GDC1);
 374                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 375                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 376                         MOD_STR_MON_PORT_CELLS2GDC1);
 377                 state->sink_accept = fifo_monitor_status_accept(ID,
 378                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 379                         MOD_STR_MON_PORT_CELLS2GDC1);
 380                 break;
 381         case FIFO_CHANNEL_GDC0_TO_SP0:
 382                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 383                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 384                         MOD_STR_MON_PORT_GDC12CELLS);
 385                 state->sink_accept = fifo_monitor_status_accept(ID,
 386                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 387                         MOD_STR_MON_PORT_GDC12CELLS);
 388                 state->src_valid   = fifo_monitor_status_valid(ID,
 389                         HIVE_GP_REGS_SP_STREAM_STAT_B_IDX,
 390                         SP_STR_MON_PORT_B_GDC12SP);
 391                 state->fifo_accept = fifo_monitor_status_accept(ID,
 392                         HIVE_GP_REGS_SP_STREAM_STAT_B_IDX,
 393                         SP_STR_MON_PORT_B_GDC12SP);
 394                 break;
 395         case FIFO_CHANNEL_SP0_TO_GDC1:
 396                 state->src_valid   = fifo_monitor_status_valid(ID,
 397                         HIVE_GP_REGS_SP_STREAM_STAT_B_IDX,
 398                         SP_STR_MON_PORT_B_SP2GDC2);
 399                 state->fifo_accept = fifo_monitor_status_accept(ID,
 400                         HIVE_GP_REGS_SP_STREAM_STAT_B_IDX,
 401                         SP_STR_MON_PORT_B_SP2GDC2);
 402                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 403                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 404                         MOD_STR_MON_PORT_CELLS2GDC2);
 405                 state->sink_accept = fifo_monitor_status_accept(ID,
 406                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 407                         MOD_STR_MON_PORT_CELLS2GDC2);
 408                 break;
 409         case FIFO_CHANNEL_GDC1_TO_SP0:
 410                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 411                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 412                         MOD_STR_MON_PORT_GDC22CELLS);
 413                 state->sink_accept = fifo_monitor_status_accept(ID,
 414                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 415                         MOD_STR_MON_PORT_GDC22CELLS);
 416                 state->src_valid   = fifo_monitor_status_valid(ID,
 417                         HIVE_GP_REGS_SP_STREAM_STAT_B_IDX,
 418                         SP_STR_MON_PORT_B_GDC22SP);
 419                 state->fifo_accept = fifo_monitor_status_accept(ID,
 420                         HIVE_GP_REGS_SP_STREAM_STAT_B_IDX,
 421                         SP_STR_MON_PORT_B_GDC22SP);
 422                 break;
 423         case FIFO_CHANNEL_SP0_TO_HOST0:
 424                 state->src_valid   = fifo_monitor_status_valid(ID,
 425                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 426                         SP_STR_MON_PORT_SND_GPD); /* SP_STR_MON_PORT_SP2GPD */
 427                 state->fifo_accept = fifo_monitor_status_accept(ID,
 428                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 429                         SP_STR_MON_PORT_SND_GPD);
 430                 {
 431                 hrt_data        value = ia_css_device_load_uint32(0x0000000000380010ULL);
 432                 state->fifo_valid  = !_hrt_get_bit(value, 0);
 433                 state->sink_accept = false; /* no monitor connected */
 434                 }
 435                 break;
 436         case FIFO_CHANNEL_HOST0_TO_SP0:
 437                 {
 438                 hrt_data        value = ia_css_device_load_uint32(0x0000000000380018ULL);
 439                 state->fifo_valid  = false; /* no monitor connected */
 440                 state->sink_accept = !_hrt_get_bit(value, 0);
 441                 }
 442                 state->src_valid   = fifo_monitor_status_valid(ID,
 443                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 444                         SP_STR_MON_PORT_RCV_GPD); /* SP_STR_MON_PORT_FA2SP */
 445                 state->fifo_accept = fifo_monitor_status_accept(ID,
 446                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 447                         SP_STR_MON_PORT_RCV_GPD);
 448                 break;
 449         case FIFO_CHANNEL_SP0_TO_STREAM2MEM0:
 450                 state->src_valid   = fifo_monitor_status_valid(ID,
 451                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 452                         SP_STR_MON_PORT_SND_MC); /* SP_STR_MON_PORT_SP2MC */
 453                 state->fifo_accept = fifo_monitor_status_accept(ID,
 454                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 455                         SP_STR_MON_PORT_SND_MC);
 456                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 457                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 458                         MOD_STR_MON_PORT_RCV_MC); /* MOD_STR_MON_PORT_SP2MC */
 459                 state->sink_accept = fifo_monitor_status_accept(ID,
 460                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 461                         MOD_STR_MON_PORT_RCV_MC);
 462                 break;
 463         case FIFO_CHANNEL_STREAM2MEM0_TO_SP0:
 464                 state->fifo_valid  = fifo_monitor_status_valid(ID,
 465                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 466                         MOD_STR_MON_PORT_SND_MC); /* SP_STR_MON_PORT_MC2SP */
 467                 state->sink_accept = fifo_monitor_status_accept(ID,
 468                         HIVE_GP_REGS_MOD_STREAM_STAT_IDX,
 469                         MOD_STR_MON_PORT_SND_MC);
 470                 state->src_valid   = fifo_monitor_status_valid(ID,
 471                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 472                         SP_STR_MON_PORT_RCV_MC); /* MOD_STR_MON_PORT_MC2SP */
 473                 state->fifo_accept = fifo_monitor_status_accept(ID,
 474                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 475                         SP_STR_MON_PORT_RCV_MC);
 476                 break;
 477         case FIFO_CHANNEL_SP0_TO_INPUT_SYSTEM0:
 478                 state->src_valid   = fifo_monitor_status_valid(ID,
 479                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 480                         SP_STR_MON_PORT_SP2ISYS);
 481                 state->fifo_accept = fifo_monitor_status_accept(ID,
 482                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 483                         SP_STR_MON_PORT_SP2ISYS);
 484                 state->fifo_valid  = false;
 485                 state->sink_accept = false;
 486                 break;
 487         case FIFO_CHANNEL_INPUT_SYSTEM0_TO_SP0:
 488                 state->fifo_valid  = false;
 489                 state->sink_accept = false;
 490                 state->src_valid   = fifo_monitor_status_valid(ID,
 491                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 492                         SP_STR_MON_PORT_ISYS2SP);
 493                 state->fifo_accept = fifo_monitor_status_accept(ID,
 494                         HIVE_GP_REGS_SP_STREAM_STAT_IDX,
 495                         SP_STR_MON_PORT_ISYS2SP);
 496                 break;
 497         default:
 498                 assert(0);
 499                 break;
 500         }
 501
 502         return;
 503 }
 504
 505 void fifo_switch_get_state(
 506         const fifo_monitor_ID_t         ID,
 507         const fifo_switch_t                     switch_id,
 508         fifo_switch_state_t                     *state)
 509 {
 510         hrt_data                data = (hrt_data)-1;
 511
 512         assert(ID == FIFO_MONITOR0_ID);
 513         assert(switch_id < N_FIFO_SWITCH);
 514         assert(state != NULL);
 515
 516         (void)ID;
 517
 518         data = gp_device_reg_load(GP_DEVICE0_ID, FIFO_SWITCH_ADDR[switch_id]);
 519
 520         state->is_none = (data == HIVE_ISP_CSS_STREAM_SWITCH_NONE);
 521         state->is_sp = (data == HIVE_ISP_CSS_STREAM_SWITCH_SP);
 522         state->is_isp = (data == HIVE_ISP_CSS_STREAM_SWITCH_ISP);
 523
 524         return;
 525 }
 526
 527 void fifo_monitor_get_state(
 528         const fifo_monitor_ID_t         ID,
 529         fifo_monitor_state_t            *state)
 530 {
 531         fifo_channel_t  ch_id;
 532         fifo_switch_t   sw_id;
 533
 534         assert(ID < N_FIFO_MONITOR_ID);
 535         assert(state != NULL);
 536
 537         for (ch_id = 0; ch_id < N_FIFO_CHANNEL; ch_id++) {
 538                 fifo_channel_get_state(ID, ch_id,
 539                         &(state->fifo_channels[ch_id]));
 540         }
 541
 542         for (sw_id = 0; sw_id < N_FIFO_SWITCH; sw_id++) {
 543                 fifo_switch_get_state(ID, sw_id,
 544                         &(state->fifo_switches[sw_id]));
 545         }
 546         return;
 547 }
 548
 549 STORAGE_CLASS_INLINE bool fifo_monitor_status_valid (
 550         const fifo_monitor_ID_t         ID,
 551         const unsigned int                      reg,
 552         const unsigned int                      port_id)
 553 {
 554         hrt_data        data = fifo_monitor_reg_load(ID, reg);
 555
 556         return (data >> (((port_id * 2) + _hive_str_mon_valid_offset))) & 0x1;
 557 }
 558
 559 STORAGE_CLASS_INLINE bool fifo_monitor_status_accept(
 560         const fifo_monitor_ID_t         ID,
 561         const unsigned int                      reg,
 562         const unsigned int                      port_id)
 563 {
 564         hrt_data        data = fifo_monitor_reg_load(ID, reg);
 565
 566         return (data >> (((port_id * 2) + _hive_str_mon_accept_offset))) & 0x1;
 567 }