drivers/soc/fsl/dpio/qbman-portal.h

   1 /* SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) */
   2 /*
   3  * Copyright (C) 2014-2016 Freescale Semiconductor, Inc.
   4  * Copyright 2016-2019 NXP
   5  *
   6  */
   7 #ifndef __FSL_QBMAN_PORTAL_H
   8 #define __FSL_QBMAN_PORTAL_H
   9
  10 #include <soc/fsl/dpaa2-fd.h>
  11
  12 struct dpaa2_dq;
  13 struct qbman_swp;
  14
  15 /* qbman software portal descriptor structure */
  16 struct qbman_swp_desc {
  17         void *cena_bar; /* Cache-enabled portal base address */
  18         void __iomem *cinh_bar; /* Cache-inhibited portal base address */
  19         u32 qman_version;
  20 };
  21
  22 #define QBMAN_SWP_INTERRUPT_EQRI 0x01
  23 #define QBMAN_SWP_INTERRUPT_EQDI 0x02
  24 #define QBMAN_SWP_INTERRUPT_DQRI 0x04
  25 #define QBMAN_SWP_INTERRUPT_RCRI 0x08
  26 #define QBMAN_SWP_INTERRUPT_RCDI 0x10
  27 #define QBMAN_SWP_INTERRUPT_VDCI 0x20
  28
  29 /* the structure for pull dequeue descriptor */
  30 struct qbman_pull_desc {
  31         u8 verb;
  32         u8 numf;
  33         u8 tok;
  34         u8 reserved;
  35         __le32 dq_src;
  36         __le64 rsp_addr;
  37         u64 rsp_addr_virt;
  38         u8 padding[40];
  39 };
  40
  41 enum qbman_pull_type_e {
  42         /* dequeue with priority precedence, respect intra-class scheduling */
  43         qbman_pull_type_prio = 1,
  44         /* dequeue with active FQ precedence, respect ICS */
  45         qbman_pull_type_active,
  46         /* dequeue with active FQ precedence, no ICS */
  47         qbman_pull_type_active_noics
  48 };
  49
  50 /* Definitions for parsing dequeue entries */
  51 #define QBMAN_RESULT_MASK      0x7f
  52 #define QBMAN_RESULT_DQ        0x60
  53 #define QBMAN_RESULT_FQRN      0x21
  54 #define QBMAN_RESULT_FQRNI     0x22
  55 #define QBMAN_RESULT_FQPN      0x24
  56 #define QBMAN_RESULT_FQDAN     0x25
  57 #define QBMAN_RESULT_CDAN      0x26
  58 #define QBMAN_RESULT_CSCN_MEM  0x27
  59 #define QBMAN_RESULT_CGCU      0x28
  60 #define QBMAN_RESULT_BPSCN     0x29
  61 #define QBMAN_RESULT_CSCN_WQ   0x2a
  62
  63 /* QBMan FQ management command codes */
  64 #define QBMAN_FQ_SCHEDULE       0x48
  65 #define QBMAN_FQ_FORCE          0x49
  66 #define QBMAN_FQ_XON            0x4d
  67 #define QBMAN_FQ_XOFF           0x4e
  68
  69 /* structure of enqueue descriptor */
  70 struct qbman_eq_desc {
  71         u8 verb;
  72         u8 dca;
  73         __le16 seqnum;
  74         __le16 orpid;
  75         __le16 reserved1;
  76         __le32 tgtid;
  77         __le32 tag;
  78         __le16 qdbin;
  79         u8 qpri;
  80         u8 reserved[3];
  81         u8 wae;
  82         u8 rspid;
  83         __le64 rsp_addr;
  84         u8 fd[32];
  85 };
  86
  87 /* buffer release descriptor */
  88 struct qbman_release_desc {
  89         u8 verb;
  90         u8 reserved;
  91         __le16 bpid;
  92         __le32 reserved2;
  93         __le64 buf[7];
  94 };
  95
  96 /* Management command result codes */
  97 #define QBMAN_MC_RSLT_OK      0xf0
  98
  99 #define CODE_CDAN_WE_EN    0x1
 100 #define CODE_CDAN_WE_CTX   0x4
 101
 102 /* portal data structure */
 103 struct qbman_swp {
 104         const struct qbman_swp_desc *desc;
 105         void *addr_cena;
 106         void __iomem *addr_cinh;
 107
 108         /* Management commands */
 109         struct {
 110                 u32 valid_bit; /* 0x00 or 0x80 */
 111         } mc;
 112
 113         /* Management response */
 114         struct {
 115                 u32 valid_bit; /* 0x00 or 0x80 */
 116         } mr;
 117
 118         /* Push dequeues */
 119         u32 sdq;
 120
 121         /* Volatile dequeues */
 122         struct {
 123                 atomic_t available; /* indicates if a command can be sent */
 124                 u32 valid_bit; /* 0x00 or 0x80 */
 125                 struct dpaa2_dq *storage; /* NULL if DQRR */
 126         } vdq;
 127
 128         /* DQRR */
 129         struct {
 130                 u32 next_idx;
 131                 u32 valid_bit;
 132                 u8 dqrr_size;
 133                 int reset_bug; /* indicates dqrr reset workaround is needed */
 134         } dqrr;
 135 };
 136
 137 struct qbman_swp *qbman_swp_init(const struct qbman_swp_desc *d);
 138 void qbman_swp_finish(struct qbman_swp *p);
 139 u32 qbman_swp_interrupt_read_status(struct qbman_swp *p);
 140 void qbman_swp_interrupt_clear_status(struct qbman_swp *p, u32 mask);
 141 u32 qbman_swp_interrupt_get_trigger(struct qbman_swp *p);
 142 void qbman_swp_interrupt_set_trigger(struct qbman_swp *p, u32 mask);
 143 int qbman_swp_interrupt_get_inhibit(struct qbman_swp *p);
 144 void qbman_swp_interrupt_set_inhibit(struct qbman_swp *p, int inhibit);
 145
 146 void qbman_swp_push_get(struct qbman_swp *p, u8 channel_idx, int *enabled);
 147 void qbman_swp_push_set(struct qbman_swp *p, u8 channel_idx, int enable);
 148
 149 void qbman_pull_desc_clear(struct qbman_pull_desc *d);
 150 void qbman_pull_desc_set_storage(struct qbman_pull_desc *d,
 151                                  struct dpaa2_dq *storage,
 152                                  dma_addr_t storage_phys,
 153                                  int stash);
 154 void qbman_pull_desc_set_numframes(struct qbman_pull_desc *d, u8 numframes);
 155 void qbman_pull_desc_set_fq(struct qbman_pull_desc *d, u32 fqid);
 156 void qbman_pull_desc_set_wq(struct qbman_pull_desc *d, u32 wqid,
 157                             enum qbman_pull_type_e dct);
 158 void qbman_pull_desc_set_channel(struct qbman_pull_desc *d, u32 chid,
 159                                  enum qbman_pull_type_e dct);
 160
 161 int qbman_swp_pull(struct qbman_swp *p, struct qbman_pull_desc *d);
 162
 163 const struct dpaa2_dq *qbman_swp_dqrr_next(struct qbman_swp *s);
 164 void qbman_swp_dqrr_consume(struct qbman_swp *s, const struct dpaa2_dq *dq);
 165
 166 int qbman_result_has_new_result(struct qbman_swp *p, const struct dpaa2_dq *dq);
 167
 168 void qbman_eq_desc_clear(struct qbman_eq_desc *d);
 169 void qbman_eq_desc_set_no_orp(struct qbman_eq_desc *d, int respond_success);
 170 void qbman_eq_desc_set_token(struct qbman_eq_desc *d, u8 token);
 171 void qbman_eq_desc_set_fq(struct qbman_eq_desc *d, u32 fqid);
 172 void qbman_eq_desc_set_qd(struct qbman_eq_desc *d, u32 qdid,
 173                           u32 qd_bin, u32 qd_prio);
 174
 175 int qbman_swp_enqueue(struct qbman_swp *p, const struct qbman_eq_desc *d,
 176                       const struct dpaa2_fd *fd);
 177
 178 void qbman_release_desc_clear(struct qbman_release_desc *d);
 179 void qbman_release_desc_set_bpid(struct qbman_release_desc *d, u16 bpid);
 180 void qbman_release_desc_set_rcdi(struct qbman_release_desc *d, int enable);
 181
 182 int qbman_swp_release(struct qbman_swp *s, const struct qbman_release_desc *d,
 183                       const u64 *buffers, unsigned int num_buffers);
 184 int qbman_swp_acquire(struct qbman_swp *s, u16 bpid, u64 *buffers,
 185                       unsigned int num_buffers);
 186 int qbman_swp_alt_fq_state(struct qbman_swp *s, u32 fqid,
 187                            u8 alt_fq_verb);
 188 int qbman_swp_CDAN_set(struct qbman_swp *s, u16 channelid,
 189                        u8 we_mask, u8 cdan_en,
 190                        u64 ctx);
 191
 192 void *qbman_swp_mc_start(struct qbman_swp *p);
 193 void qbman_swp_mc_submit(struct qbman_swp *p, void *cmd, u8 cmd_verb);
 194 void *qbman_swp_mc_result(struct qbman_swp *p);
 195
 196 /**
 197  * qbman_result_is_DQ() - check if the dequeue result is a dequeue response
 198  * @dq: the dequeue result to be checked
 199  *
 200  * DQRR entries may contain non-dequeue results, ie. notifications
 201  */
 202 static inline int qbman_result_is_DQ(const struct dpaa2_dq *dq)
 203 {
 204         return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_DQ);
 205 }
 206
 207 /**
 208  * qbman_result_is_SCN() - Check the dequeue result is notification or not
 209  * @dq: the dequeue result to be checked
 210  *
 211  */
 212 static inline int qbman_result_is_SCN(const struct dpaa2_dq *dq)
 213 {
 214         return !qbman_result_is_DQ(dq);
 215 }
 216
 217 /* FQ Data Availability */
 218 static inline int qbman_result_is_FQDAN(const struct dpaa2_dq *dq)
 219 {
 220         return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_FQDAN);
 221 }
 222
 223 /* Channel Data Availability */
 224 static inline int qbman_result_is_CDAN(const struct dpaa2_dq *dq)
 225 {
 226         return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_CDAN);
 227 }
 228
 229 /* Congestion State Change */
 230 static inline int qbman_result_is_CSCN(const struct dpaa2_dq *dq)
 231 {
 232         return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_CSCN_WQ);
 233 }
 234
 235 /* Buffer Pool State Change */
 236 static inline int qbman_result_is_BPSCN(const struct dpaa2_dq *dq)
 237 {
 238         return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_BPSCN);
 239 }
 240
 241 /* Congestion Group Count Update */
 242 static inline int qbman_result_is_CGCU(const struct dpaa2_dq *dq)
 243 {
 244         return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_CGCU);
 245 }
 246
 247 /* Retirement */
 248 static inline int qbman_result_is_FQRN(const struct dpaa2_dq *dq)
 249 {
 250         return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_FQRN);
 251 }
 252
 253 /* Retirement Immediate */
 254 static inline int qbman_result_is_FQRNI(const struct dpaa2_dq *dq)
 255 {
 256         return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_FQRNI);
 257 }
 258
 259  /* Park */
 260 static inline int qbman_result_is_FQPN(const struct dpaa2_dq *dq)
 261 {
 262         return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_FQPN);
 263 }
 264
 265 /**
 266  * qbman_result_SCN_state() - Get the state field in State-change notification
 267  */
 268 static inline u8 qbman_result_SCN_state(const struct dpaa2_dq *scn)
 269 {
 270         return scn->scn.state;
 271 }
 272
 273 #define SCN_RID_MASK 0x00FFFFFF
 274
 275 /**
 276  * qbman_result_SCN_rid() - Get the resource id in State-change notification
 277  */
 278 static inline u32 qbman_result_SCN_rid(const struct dpaa2_dq *scn)
 279 {
 280         return le32_to_cpu(scn->scn.rid_tok) & SCN_RID_MASK;
 281 }
 282
 283 /**
 284  * qbman_result_SCN_ctx() - Get the context data in State-change notification
 285  */
 286 static inline u64 qbman_result_SCN_ctx(const struct dpaa2_dq *scn)
 287 {
 288         return le64_to_cpu(scn->scn.ctx);
 289 }
 290
 291 /**
 292  * qbman_swp_fq_schedule() - Move the fq to the scheduled state
 293  * @s:    the software portal object
 294  * @fqid: the index of frame queue to be scheduled
 295  *
 296  * There are a couple of different ways that a FQ can end up parked state,
 297  * This schedules it.
 298  *
 299  * Return 0 for success, or negative error code for failure.
 300  */
 301 static inline int qbman_swp_fq_schedule(struct qbman_swp *s, u32 fqid)
 302 {
 303         return qbman_swp_alt_fq_state(s, fqid, QBMAN_FQ_SCHEDULE);
 304 }
 305
 306 /**
 307  * qbman_swp_fq_force() - Force the FQ to fully scheduled state
 308  * @s:    the software portal object
 309  * @fqid: the index of frame queue to be forced
 310  *
 311  * Force eligible will force a tentatively-scheduled FQ to be fully-scheduled
 312  * and thus be available for selection by any channel-dequeuing behaviour (push
 313  * or pull). If the FQ is subsequently "dequeued" from the channel and is still
 314  * empty at the time this happens, the resulting dq_entry will have no FD.
 315  * (qbman_result_DQ_fd() will return NULL.)
 316  *
 317  * Return 0 for success, or negative error code for failure.
 318  */
 319 static inline int qbman_swp_fq_force(struct qbman_swp *s, u32 fqid)
 320 {
 321         return qbman_swp_alt_fq_state(s, fqid, QBMAN_FQ_FORCE);
 322 }
 323
 324 /**
 325  * qbman_swp_fq_xon() - sets FQ flow-control to XON
 326  * @s:    the software portal object
 327  * @fqid: the index of frame queue
 328  *
 329  * This setting doesn't affect enqueues to the FQ, just dequeues.
 330  *
 331  * Return 0 for success, or negative error code for failure.
 332  */
 333 static inline int qbman_swp_fq_xon(struct qbman_swp *s, u32 fqid)
 334 {
 335         return qbman_swp_alt_fq_state(s, fqid, QBMAN_FQ_XON);
 336 }
 337
 338 /**
 339  * qbman_swp_fq_xoff() - sets FQ flow-control to XOFF
 340  * @s:    the software portal object
 341  * @fqid: the index of frame queue
 342  *
 343  * This setting doesn't affect enqueues to the FQ, just dequeues.
 344  * XOFF FQs will remain in the tenatively-scheduled state, even when
 345  * non-empty, meaning they won't be selected for scheduled dequeuing.
 346  * If a FQ is changed to XOFF after it had already become truly-scheduled
 347  * to a channel, and a pull dequeue of that channel occurs that selects
 348  * that FQ for dequeuing, then the resulting dq_entry will have no FD.
 349  * (qbman_result_DQ_fd() will return NULL.)
 350  *
 351  * Return 0 for success, or negative error code for failure.
 352  */
 353 static inline int qbman_swp_fq_xoff(struct qbman_swp *s, u32 fqid)
 354 {
 355         return qbman_swp_alt_fq_state(s, fqid, QBMAN_FQ_XOFF);
 356 }
 357
 358 /* If the user has been allocated a channel object that is going to generate
 359  * CDANs to another channel, then the qbman_swp_CDAN* functions will be
 360  * necessary.
 361  *
 362  * CDAN-enabled channels only generate a single CDAN notification, after which
 363  * they need to be reenabled before they'll generate another. The idea is
 364  * that pull dequeuing will occur in reaction to the CDAN, followed by a
 365  * reenable step. Each function generates a distinct command to hardware, so a
 366  * combination function is provided if the user wishes to modify the "context"
 367  * (which shows up in each CDAN message) each time they reenable, as a single
 368  * command to hardware.
 369  */
 370
 371 /**
 372  * qbman_swp_CDAN_set_context() - Set CDAN context
 373  * @s:         the software portal object
 374  * @channelid: the channel index
 375  * @ctx:       the context to be set in CDAN
 376  *
 377  * Return 0 for success, or negative error code for failure.
 378  */
 379 static inline int qbman_swp_CDAN_set_context(struct qbman_swp *s, u16 channelid,
 380                                              u64 ctx)
 381 {
 382         return qbman_swp_CDAN_set(s, channelid,
 383                                   CODE_CDAN_WE_CTX,
 384                                   0, ctx);
 385 }
 386
 387 /**
 388  * qbman_swp_CDAN_enable() - Enable CDAN for the channel
 389  * @s:         the software portal object
 390  * @channelid: the index of the channel to generate CDAN
 391  *
 392  * Return 0 for success, or negative error code for failure.
 393  */
 394 static inline int qbman_swp_CDAN_enable(struct qbman_swp *s, u16 channelid)
 395 {
 396         return qbman_swp_CDAN_set(s, channelid,
 397                                   CODE_CDAN_WE_EN,
 398                                   1, 0);
 399 }
 400
 401 /**
 402  * qbman_swp_CDAN_disable() - disable CDAN for the channel
 403  * @s:         the software portal object
 404  * @channelid: the index of the channel to generate CDAN
 405  *
 406  * Return 0 for success, or negative error code for failure.
 407  */
 408 static inline int qbman_swp_CDAN_disable(struct qbman_swp *s, u16 channelid)
 409 {
 410         return qbman_swp_CDAN_set(s, channelid,
 411                                   CODE_CDAN_WE_EN,
 412                                   0, 0);
 413 }
 414
 415 /**
 416  * qbman_swp_CDAN_set_context_enable() - Set CDAN contest and enable CDAN
 417  * @s:         the software portal object
 418  * @channelid: the index of the channel to generate CDAN
 419  * @ctx:i      the context set in CDAN
 420  *
 421  * Return 0 for success, or negative error code for failure.
 422  */
 423 static inline int qbman_swp_CDAN_set_context_enable(struct qbman_swp *s,
 424                                                     u16 channelid,
 425                                                     u64 ctx)
 426 {
 427         return qbman_swp_CDAN_set(s, channelid,
 428                                   CODE_CDAN_WE_EN | CODE_CDAN_WE_CTX,
 429                                   1, ctx);
 430 }
 431
 432 /* Wraps up submit + poll-for-result */
 433 static inline void *qbman_swp_mc_complete(struct qbman_swp *swp, void *cmd,
 434                                           u8 cmd_verb)
 435 {
 436         int loopvar = 2000;
 437
 438         qbman_swp_mc_submit(swp, cmd, cmd_verb);
 439
 440         do {
 441                 cmd = qbman_swp_mc_result(swp);
 442         } while (!cmd && loopvar--);
 443
 444         WARN_ON(!loopvar);
 445
 446         return cmd;
 447 }
 448
 449 /* Query APIs */
 450 struct qbman_fq_query_np_rslt {
 451         u8 verb;
 452         u8 rslt;
 453         u8 st1;
 454         u8 st2;
 455         u8 reserved[2];
 456         __le16 od1_sfdr;
 457         __le16 od2_sfdr;
 458         __le16 od3_sfdr;
 459         __le16 ra1_sfdr;
 460         __le16 ra2_sfdr;
 461         __le32 pfdr_hptr;
 462         __le32 pfdr_tptr;
 463         __le32 frm_cnt;
 464         __le32 byte_cnt;
 465         __le16 ics_surp;
 466         u8 is;
 467         u8 reserved2[29];
 468 };
 469
 470 int qbman_fq_query_state(struct qbman_swp *s, u32 fqid,
 471                          struct qbman_fq_query_np_rslt *r);
 472 u32 qbman_fq_state_frame_count(const struct qbman_fq_query_np_rslt *r);
 473 u32 qbman_fq_state_byte_count(const struct qbman_fq_query_np_rslt *r);
 474
 475 struct qbman_bp_query_rslt {
 476         u8 verb;
 477         u8 rslt;
 478         u8 reserved[4];
 479         u8 bdi;
 480         u8 state;
 481         __le32 fill;
 482         __le32 hdotr;
 483         __le16 swdet;
 484         __le16 swdxt;
 485         __le16 hwdet;
 486         __le16 hwdxt;
 487         __le16 swset;
 488         __le16 swsxt;
 489         __le16 vbpid;
 490         __le16 icid;
 491         __le64 bpscn_addr;
 492         __le64 bpscn_ctx;
 493         __le16 hw_targ;
 494         u8 dbe;
 495         u8 reserved2;
 496         u8 sdcnt;
 497         u8 hdcnt;
 498         u8 sscnt;
 499         u8 reserved3[9];
 500 };
 501
 502 int qbman_bp_query(struct qbman_swp *s, u16 bpid,
 503                    struct qbman_bp_query_rslt *r);
 504
 505 u32 qbman_bp_info_num_free_bufs(struct qbman_bp_query_rslt *a);
 506
 507 #endif /* __FSL_QBMAN_PORTAL_H */