LXR linux/drivers/scsi/bfa/plog.c

   1/*
   2 * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
   3 * All rights reserved
   4 * www.brocade.com
   5 *
   6 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
   7 *
   8 * This program is free software; you can redistribute it and/or modify it
   9 * under the terms of the GNU General Public License (GPL) Version 2 as
  10 * published by the Free Software Foundation
  11 *
  12 * This program is distributed in the hope that it will be useful, but
  13 * WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 * General Public License for more details.
  16 */
  17
  18#include <bfa_os_inc.h>
  19#include <cs/bfa_plog.h>
  20#include <cs/bfa_debug.h>
  21
  22static int
  23plkd_validate_logrec(struct bfa_plog_rec_s *pl_rec)
  24{
  25        if ((pl_rec->log_type != BFA_PL_LOG_TYPE_INT)
  26            && (pl_rec->log_type != BFA_PL_LOG_TYPE_STRING))
  27                return 1;
  28
  29        if ((pl_rec->log_type != BFA_PL_LOG_TYPE_INT)
  30            && (pl_rec->log_num_ints > BFA_PL_INT_LOG_SZ))
  31                return 1;
  32
  33        return 0;
  34}
  35
  36static void
  37bfa_plog_add(struct bfa_plog_s *plog, struct bfa_plog_rec_s *pl_rec)
  38{
  39        u16        tail;
  40        struct bfa_plog_rec_s *pl_recp;
  41
  42        if (plog->plog_enabled == 0)
  43                return;
  44
  45        if (plkd_validate_logrec(pl_rec)) {
  46                bfa_assert(0);
  47                return;
  48        }
  49
  50        tail = plog->tail;
  51
  52        pl_recp = &(plog->plog_recs[tail]);
  53
  54        bfa_os_memcpy(pl_recp, pl_rec, sizeof(struct bfa_plog_rec_s));
  55
  56        pl_recp->tv = BFA_TRC_TS(plog);
  57        BFA_PL_LOG_REC_INCR(plog->tail);
  58
  59        if (plog->head == plog->tail)
  60                BFA_PL_LOG_REC_INCR(plog->head);
  61}
  62
  63void
  64bfa_plog_init(struct bfa_plog_s *plog)
  65{
  66        bfa_os_memset((char *)plog, 0, sizeof(struct bfa_plog_s));
  67
  68        bfa_os_memcpy(plog->plog_sig, BFA_PL_SIG_STR, BFA_PL_SIG_LEN);
  69        plog->head = plog->tail = 0;
  70        plog->plog_enabled = 1;
  71}
  72
  73void
  74bfa_plog_str(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
  75                enum bfa_plog_eid event,
  76                u16 misc, char *log_str)
  77{
  78        struct bfa_plog_rec_s  lp;
  79
  80        if (plog->plog_enabled) {
  81                bfa_os_memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
  82                lp.mid = mid;
  83                lp.eid = event;
  84                lp.log_type = BFA_PL_LOG_TYPE_STRING;
  85                lp.misc = misc;
  86                strncpy(lp.log_entry.string_log, log_str,
  87                        BFA_PL_STRING_LOG_SZ - 1);
  88                lp.log_entry.string_log[BFA_PL_STRING_LOG_SZ - 1] = '\0';
  89                bfa_plog_add(plog, &lp);
  90        }
  91}
  92
  93void
  94bfa_plog_intarr(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
  95                enum bfa_plog_eid event,
  96                u16 misc, u32 *intarr, u32 num_ints)
  97{
  98        struct bfa_plog_rec_s  lp;
  99        u32        i;
 100
 101        if (num_ints > BFA_PL_INT_LOG_SZ)
 102                num_ints = BFA_PL_INT_LOG_SZ;
 103
 104        if (plog->plog_enabled) {
 105                bfa_os_memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
 106                lp.mid = mid;
 107                lp.eid = event;
 108                lp.log_type = BFA_PL_LOG_TYPE_INT;
 109                lp.misc = misc;
 110
 111                for (i = 0; i < num_ints; i++)
 112                        bfa_os_assign(lp.log_entry.int_log[i],
 113                                        intarr[i]);
 114
 115                lp.log_num_ints = (u8) num_ints;
 116
 117                bfa_plog_add(plog, &lp);
 118        }
 119}
 120
 121void
 122bfa_plog_fchdr(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
 123                        enum bfa_plog_eid event,
 124                        u16 misc, struct fchs_s *fchdr)
 125{
 126        struct bfa_plog_rec_s  lp;
 127        u32       *tmp_int = (u32 *) fchdr;
 128        u32        ints[BFA_PL_INT_LOG_SZ];
 129
 130        if (plog->plog_enabled) {
 131                bfa_os_memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
 132
 133                ints[0] = tmp_int[0];
 134                ints[1] = tmp_int[1];
 135                ints[2] = tmp_int[4];
 136
 137                bfa_plog_intarr(plog, mid, event, misc, ints, 3);
 138        }
 139}
 140
 141void
 142bfa_plog_fchdr_and_pl(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
 143                      enum bfa_plog_eid event, u16 misc, struct fchs_s *fchdr,
 144                      u32 pld_w0)
 145{
 146        struct bfa_plog_rec_s  lp;
 147        u32       *tmp_int = (u32 *) fchdr;
 148        u32        ints[BFA_PL_INT_LOG_SZ];
 149
 150        if (plog->plog_enabled) {
 151                bfa_os_memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
 152
 153                ints[0] = tmp_int[0];
 154                ints[1] = tmp_int[1];
 155                ints[2] = tmp_int[4];
 156                ints[3] = pld_w0;
 157
 158                bfa_plog_intarr(plog, mid, event, misc, ints, 4);
 159        }
 160}
 161
 162void
 163bfa_plog_clear(struct bfa_plog_s *plog)
 164{
 165        plog->head = plog->tail = 0;
 166}
 167
 168void
 169bfa_plog_enable(struct bfa_plog_s *plog)
 170{
 171        plog->plog_enabled = 1;
 172}
 173
 174void
 175bfa_plog_disable(struct bfa_plog_s *plog)
 176{
 177        plog->plog_enabled = 0;
 178}
 179
 180bfa_boolean_t
 181bfa_plog_get_setting(struct bfa_plog_s *plog)
 182{
 183        return((bfa_boolean_t)plog->plog_enabled);
 184}
 185