drivers/net/bna/bfa_cs.h

   1 /*
   2  * Linux network driver for Brocade Converged Network Adapter.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License (GPL) Version 2 as
   6  * published by the Free Software Foundation
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  */
  13 /*
  14  * Copyright (c) 2005-2011 Brocade Communications Systems, Inc.
  15  * All rights reserved
  16  * www.brocade.com
  17  */
  18
  19 /**
  20  * @file bfa_cs.h BFA common services
  21  */
  22
  23 #ifndef __BFA_CS_H__
  24 #define __BFA_CS_H__
  25
  26 #include "cna.h"
  27
  28 /**
  29  * @ BFA state machine interfaces
  30  */
  31
  32 typedef void (*bfa_sm_t)(void *sm, int event);
  33
  34 /**
  35  * oc - object class eg. bfa_ioc
  36  * st - state, eg. reset
  37  * otype - object type, eg. struct bfa_ioc
  38  * etype - object type, eg. enum ioc_event
  39  */
  40 #define bfa_sm_state_decl(oc, st, otype, etype)                 \
  41         static void oc ## _sm_ ## st(otype * fsm, etype event)
  42
  43 #define bfa_sm_set_state(_sm, _state)   ((_sm)->sm = (bfa_sm_t)(_state))
  44 #define bfa_sm_send_event(_sm, _event)  ((_sm)->sm((_sm), (_event)))
  45 #define bfa_sm_get_state(_sm)           ((_sm)->sm)
  46 #define bfa_sm_cmp_state(_sm, _state)   ((_sm)->sm == (bfa_sm_t)(_state))
  47
  48 /**
  49  * For converting from state machine function to state encoding.
  50  */
  51 struct bfa_sm_table {
  52         bfa_sm_t        sm;     /*!< state machine function     */
  53         int             state;  /*!< state machine encoding     */
  54         char            *name;  /*!< state name for display     */
  55 };
  56 #define BFA_SM(_sm)             ((bfa_sm_t)(_sm))
  57
  58 /**
  59  * State machine with entry actions.
  60  */
  61 typedef void (*bfa_fsm_t)(void *fsm, int event);
  62
  63 /**
  64  * oc - object class eg. bfa_ioc
  65  * st - state, eg. reset
  66  * otype - object type, eg. struct bfa_ioc
  67  * etype - object type, eg. enum ioc_event
  68  */
  69 #define bfa_fsm_state_decl(oc, st, otype, etype)                        \
  70         static void oc ## _sm_ ## st(otype * fsm, etype event);         \
  71         static void oc ## _sm_ ## st ## _entry(otype * fsm)
  72
  73 #define bfa_fsm_set_state(_fsm, _state) do {                            \
  74         (_fsm)->fsm = (bfa_fsm_t)(_state);                              \
  75         _state ## _entry(_fsm);                                         \
  76 } while (0)
  77
  78 #define bfa_fsm_send_event(_fsm, _event)        ((_fsm)->fsm((_fsm), (_event)))
  79 #define bfa_fsm_get_state(_fsm)                 ((_fsm)->fsm)
  80 #define bfa_fsm_cmp_state(_fsm, _state)                                 \
  81         ((_fsm)->fsm == (bfa_fsm_t)(_state))
  82
  83 static inline int
  84 bfa_sm_to_state(const struct bfa_sm_table *smt, bfa_sm_t sm)
  85 {
  86         int     i = 0;
  87
  88         while (smt[i].sm && smt[i].sm != sm)
  89                 i++;
  90         return smt[i].state;
  91 }
  92
  93 /**
  94  * @ Generic wait counter.
  95  */
  96
  97 typedef void (*bfa_wc_resume_t) (void *cbarg);
  98
  99 struct bfa_wc {
 100         bfa_wc_resume_t wc_resume;
 101         void            *wc_cbarg;
 102         int             wc_count;
 103 };
 104
 105 static inline void
 106 bfa_wc_up(struct bfa_wc *wc)
 107 {
 108         wc->wc_count++;
 109 }
 110
 111 static inline void
 112 bfa_wc_down(struct bfa_wc *wc)
 113 {
 114         wc->wc_count--;
 115         if (wc->wc_count == 0)
 116                 wc->wc_resume(wc->wc_cbarg);
 117 }
 118
 119 /**
 120  * Initialize a waiting counter.
 121  */
 122 static inline void
 123 bfa_wc_init(struct bfa_wc *wc, bfa_wc_resume_t wc_resume, void *wc_cbarg)
 124 {
 125         wc->wc_resume = wc_resume;
 126         wc->wc_cbarg = wc_cbarg;
 127         wc->wc_count = 0;
 128         bfa_wc_up(wc);
 129 }
 130
 131 /**
 132  * Wait for counter to reach zero
 133  */
 134 static inline void
 135 bfa_wc_wait(struct bfa_wc *wc)
 136 {
 137         bfa_wc_down(wc);
 138 }
 139
 140 #endif /* __BFA_CS_H__ */