/*
   * Copyright 2012 Cisco Systems, Inc.  All rights reserved.
   *
   * This program is free software; you may redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation; version 2 of the License.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
   * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
   * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
   * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   * SOFTWARE.
   */
  
  #include <linux/module.h>
  #include <linux/mempool.h>
  #include <linux/errno.h>
  #include <linux/spinlock.h>
  #include <linux/kallsyms.h>
  #include <linux/time.h>
  #include <linux/vmalloc.h>
  #include "fnic_io.h"
  #include "fnic.h"
  
  unsigned int trace_max_pages;
  static int fnic_max_trace_entries;
  
  static unsigned long fnic_trace_buf_p;
  static DEFINE_SPINLOCK(fnic_trace_lock);
  
  static fnic_trace_dbg_t fnic_trace_entries;
  int fnic_tracing_enabled = 1;
  
  /* static char *fnic_fc_ctlr_trace_buf_p; */
  
  static int fc_trace_max_entries;
  static unsigned long fnic_fc_ctlr_trace_buf_p;
  static fnic_trace_dbg_t fc_trace_entries;
  int fnic_fc_tracing_enabled = 1;
  int fnic_fc_trace_cleared = 1;
  static DEFINE_SPINLOCK(fnic_fc_trace_lock);
  
  
  /*
   * fnic_trace_get_buf - Give buffer pointer to user to fill up trace information
   *
   * Description:
   * This routine gets next available trace buffer entry location @wr_idx
   * from allocated trace buffer pages and give that memory location
   * to user to store the trace information.
   *
   * Return Value:
   * This routine returns pointer to next available trace entry
   * @fnic_buf_head for user to fill trace information.
   */
  fnic_trace_data_t *fnic_trace_get_buf(void)
  {
  	unsigned long fnic_buf_head;
  	unsigned long flags;
  
  	spin_lock_irqsave(&fnic_trace_lock, flags);
  
  	/*
  	 * Get next available memory location for writing trace information
  	 * at @wr_idx and increment @wr_idx
  	 */
  	fnic_buf_head =
  		fnic_trace_entries.page_offset[fnic_trace_entries.wr_idx];
  	fnic_trace_entries.wr_idx++;
  
  	/*
  	 * Verify if trace buffer is full then change wd_idx to
  	 * start from zero
  	 */
  	if (fnic_trace_entries.wr_idx >= fnic_max_trace_entries)
  		fnic_trace_entries.wr_idx = 0;
  
  	/*
  	 * Verify if write index @wr_idx and read index @rd_idx are same then
  	 * increment @rd_idx to move to next entry in trace buffer
  	 */
  	if (fnic_trace_entries.wr_idx == fnic_trace_entries.rd_idx) {
  		fnic_trace_entries.rd_idx++;
  		if (fnic_trace_entries.rd_idx >= fnic_max_trace_entries)
  			fnic_trace_entries.rd_idx = 0;
  	}
  	spin_unlock_irqrestore(&fnic_trace_lock, flags);
  	return (fnic_trace_data_t *)fnic_buf_head;
  }
  
  /*
   * fnic_get_trace_data - Copy trace buffer to a memory file
   * @fnic_dbgfs_t: pointer to debugfs trace buffer
   *
   * Description:
   * This routine gathers the fnic trace debugfs data from the fnic_trace_data_t
   * buffer and dumps it to fnic_dbgfs_t. It will start at the rd_idx entry in
   * the log and process the log until the end of the buffer. Then it will gather
   * from the beginning of the log and process until the current entry @wr_idx.
   *
   * Return Value:
   * This routine returns the amount of bytes that were dumped into fnic_dbgfs_t
   */
  int fnic_get_trace_data(fnic_dbgfs_t *fnic_dbgfs_prt)
  {
  	int rd_idx;
  	int wr_idx;
  	int len = 0;
  	unsigned long flags;
  	char str[KSYM_SYMBOL_LEN];
  	struct timespec val;
  	fnic_trace_data_t *tbp;
  
  	spin_lock_irqsave(&fnic_trace_lock, flags);
  	rd_idx = fnic_trace_entries.rd_idx;
  	wr_idx = fnic_trace_entries.wr_idx;
  	if (wr_idx < rd_idx) {
  		while (1) {
  			/* Start from read index @rd_idx */
  			tbp = (fnic_trace_data_t *)
  				  fnic_trace_entries.page_offset[rd_idx];
  			if (!tbp) {
  				spin_unlock_irqrestore(&fnic_trace_lock, flags);
  				return 0;
  			}
  			/* Convert function pointer to function name */
  			if (sizeof(unsigned long) < 8) {
  				sprint_symbol(str, tbp->fnaddr.low);
  				jiffies_to_timespec(tbp->timestamp.low, &val);
  			} else {
  				sprint_symbol(str, tbp->fnaddr.val);
  				jiffies_to_timespec(tbp->timestamp.val, &val);
  			}
  			/*
  			 * Dump trace buffer entry to memory file
  			 * and increment read index @rd_idx
  			 */
  			len += snprintf(fnic_dbgfs_prt->buffer + len,
  				  (trace_max_pages * PAGE_SIZE * 3) - len,
  				  "%16lu.%16lu %-50s %8x %8x %16llx %16llx "
  				  "%16llx %16llx %16llx
  ", val.tv_sec,
  				  val.tv_nsec, str, tbp->host_no, tbp->tag,
  				  tbp->data[0], tbp->data[1], tbp->data[2],
  				  tbp->data[3], tbp->data[4]);
  			rd_idx++;
  			/*
  			 * If rd_idx is reached to maximum trace entries
  			 * then move rd_idx to zero
  			 */
  			if (rd_idx > (fnic_max_trace_entries-1))
  				rd_idx = 0;
  			/*
  			 * Continure dumpping trace buffer entries into
  			 * memory file till rd_idx reaches write index
  			 */
  			if (rd_idx == wr_idx)
  				break;
  		}
  	} else if (wr_idx > rd_idx) {
  		while (1) {
  			/* Start from read index @rd_idx */
  			tbp = (fnic_trace_data_t *)
  				  fnic_trace_entries.page_offset[rd_idx];
  			if (!tbp) {
  				spin_unlock_irqrestore(&fnic_trace_lock, flags);
  				return 0;
  			}
  			/* Convert function pointer to function name */
  			if (sizeof(unsigned long) < 8) {
  				sprint_symbol(str, tbp->fnaddr.low);
  				jiffies_to_timespec(tbp->timestamp.low, &val);
  			} else {
  				sprint_symbol(str, tbp->fnaddr.val);
  				jiffies_to_timespec(tbp->timestamp.val, &val);
  			}
  			/*
  			 * Dump trace buffer entry to memory file
  			 * and increment read index @rd_idx
  			 */
  			len += snprintf(fnic_dbgfs_prt->buffer + len,
  				  (trace_max_pages * PAGE_SIZE * 3) - len,
  				  "%16lu.%16lu %-50s %8x %8x %16llx %16llx "
  				  "%16llx %16llx %16llx
  ", val.tv_sec,
  				  val.tv_nsec, str, tbp->host_no, tbp->tag,
  				  tbp->data[0], tbp->data[1], tbp->data[2],
  				  tbp->data[3], tbp->data[4]);
  			rd_idx++;
  			/*
  			 * Continue dumpping trace buffer entries into
  			 * memory file till rd_idx reaches write index
  			 */
  			if (rd_idx == wr_idx)
  				break;
  		}
  	}
  	spin_unlock_irqrestore(&fnic_trace_lock, flags);
  	return len;
  }
  
  /*
   * fnic_get_stats_data - Copy fnic stats buffer to a memory file
   * @fnic_dbgfs_t: pointer to debugfs fnic stats buffer
   *
   * Description:
   * This routine gathers the fnic stats debugfs data from the fnic_stats struct
   * and dumps it to stats_debug_info.
   *
   * Return Value:
   * This routine returns the amount of bytes that were dumped into
   * stats_debug_info
   */
  int fnic_get_stats_data(struct stats_debug_info *debug,
  			struct fnic_stats *stats)
  {
  	int len = 0;
  	int buf_size = debug->buf_size;
  	struct timespec val1, val2;
  
  	len = snprintf(debug->debug_buffer + len, buf_size - len,
  		  "------------------------------------------
  "
  		  "\t\tIO Statistics
  "
  		  "------------------------------------------
  ");
  	len += snprintf(debug->debug_buffer + len, buf_size - len,
  		  "Number of Active IOs: %lld
  Maximum Active IOs: %lld
  "
  		  "Number of IOs: %lld
  Number of IO Completions: %lld
  "
  		  "Number of IO Failures: %lld
  Number of IO NOT Found: %lld
  "
  		  "Number of Memory alloc Failures: %lld
  "
  		  "Number of IOREQ Null: %lld
  "
  		  "Number of SCSI cmd pointer Null: %lld
  ",
  		  (u64)atomic64_read(&stats->io_stats.active_ios),
  		  (u64)atomic64_read(&stats->io_stats.max_active_ios),
  		  (u64)atomic64_read(&stats->io_stats.num_ios),
  		  (u64)atomic64_read(&stats->io_stats.io_completions),
  		  (u64)atomic64_read(&stats->io_stats.io_failures),
  		  (u64)atomic64_read(&stats->io_stats.io_not_found),
  		  (u64)atomic64_read(&stats->io_stats.alloc_failures),
  		  (u64)atomic64_read(&stats->io_stats.ioreq_null),
  		  (u64)atomic64_read(&stats->io_stats.sc_null));
  
  	len += snprintf(debug->debug_buffer + len, buf_size - len,
  		  "
  ------------------------------------------
  "
  		  "\t\tAbort Statistics
  "
  		  "------------------------------------------
  ");
  	len += snprintf(debug->debug_buffer + len, buf_size - len,
  		  "Number of Aborts: %lld
  "
  		  "Number of Abort Failures: %lld
  "
  		  "Number of Abort Driver Timeouts: %lld
  "
  		  "Number of Abort FW Timeouts: %lld
  "
  		  "Number of Abort IO NOT Found: %lld
  ",
  		  (u64)atomic64_read(&stats->abts_stats.aborts),
  		  (u64)atomic64_read(&stats->abts_stats.abort_failures),
  		  (u64)atomic64_read(&stats->abts_stats.abort_drv_timeouts),
  		  (u64)atomic64_read(&stats->abts_stats.abort_fw_timeouts),
  		  (u64)atomic64_read(&stats->abts_stats.abort_io_not_found));
  
  	len += snprintf(debug->debug_buffer + len, buf_size - len,
  		  "
  ------------------------------------------
  "
  		  "\t\tTerminate Statistics
  "
  		  "------------------------------------------
  ");
  	len += snprintf(debug->debug_buffer + len, buf_size - len,
  		  "Number of Terminates: %lld
  "
  		  "Maximum Terminates: %lld
  "
  		  "Number of Terminate Driver Timeouts: %lld
  "
  		  "Number of Terminate FW Timeouts: %lld
  "
  		  "Number of Terminate IO NOT Found: %lld
  "
  		  "Number of Terminate Failures: %lld
  ",
  		  (u64)atomic64_read(&stats->term_stats.terminates),
  		  (u64)atomic64_read(&stats->term_stats.max_terminates),
  		  (u64)atomic64_read(&stats->term_stats.terminate_drv_timeouts),
  		  (u64)atomic64_read(&stats->term_stats.terminate_fw_timeouts),
  		  (u64)atomic64_read(&stats->term_stats.terminate_io_not_found),
  		  (u64)atomic64_read(&stats->term_stats.terminate_failures));
  
  	len += snprintf(debug->debug_buffer + len, buf_size - len,
  		  "
  ------------------------------------------
  "
  		  "\t\tReset Statistics
  "
  		  "------------------------------------------
  ");
  
  	len += snprintf(debug->debug_buffer + len, buf_size - len,
  		  "Number of Device Resets: %lld
  "
  		  "Number of Device Reset Failures: %lld
  "
  		  "Number of Device Reset Aborts: %lld
  "
  		  "Number of Device Reset Timeouts: %lld
  "
  		  "Number of Device Reset Terminates: %lld
  "
  		  "Number of FW Resets: %lld
  "
  		  "Number of FW Reset Completions: %lld
  "
  		  "Number of FW Reset Failures: %lld
  "
  		  "Number of Fnic Reset: %lld
  "
  		  "Number of Fnic Reset Completions: %lld
  "
  		  "Number of Fnic Reset Failures: %lld
  ",
  		  (u64)atomic64_read(&stats->reset_stats.device_resets),
  		  (u64)atomic64_read(&stats->reset_stats.device_reset_failures),
  		  (u64)atomic64_read(&stats->reset_stats.device_reset_aborts),
  		  (u64)atomic64_read(&stats->reset_stats.device_reset_timeouts),
  		  (u64)atomic64_read(
  			  &stats->reset_stats.device_reset_terminates),
  		  (u64)atomic64_read(&stats->reset_stats.fw_resets),
  		  (u64)atomic64_read(&stats->reset_stats.fw_reset_completions),
  		  (u64)atomic64_read(&stats->reset_stats.fw_reset_failures),
  		  (u64)atomic64_read(&stats->reset_stats.fnic_resets),
  		  (u64)atomic64_read(
  			  &stats->reset_stats.fnic_reset_completions),
  		  (u64)atomic64_read(&stats->reset_stats.fnic_reset_failures));
  
  	len += snprintf(debug->debug_buffer + len, buf_size - len,
  		  "
  ------------------------------------------
  "
  		  "\t\tFirmware Statistics
  "
  		  "------------------------------------------
  ");
  
  	len += snprintf(debug->debug_buffer + len, buf_size - len,
  		  "Number of Active FW Requests %lld
  "
  		  "Maximum FW Requests: %lld
  "
  		  "Number of FW out of resources: %lld
  "
  		  "Number of FW IO errors: %lld
  ",
  		  (u64)atomic64_read(&stats->fw_stats.active_fw_reqs),
  		  (u64)atomic64_read(&stats->fw_stats.max_fw_reqs),
  		  (u64)atomic64_read(&stats->fw_stats.fw_out_of_resources),
  		  (u64)atomic64_read(&stats->fw_stats.io_fw_errs));
  
  	len += snprintf(debug->debug_buffer + len, buf_size - len,
  		  "
  ------------------------------------------
  "
  		  "\t\tVlan Discovery Statistics
  "
  		  "------------------------------------------
  ");
  
  	len += snprintf(debug->debug_buffer + len, buf_size - len,
  		  "Number of Vlan Discovery Requests Sent %lld
  "
  		  "Vlan Response Received with no FCF VLAN ID: %lld
  "
  		  "No solicitations recvd after vlan set, expiry count: %lld
  "
  		  "Flogi rejects count: %lld
  ",
  		  (u64)atomic64_read(&stats->vlan_stats.vlan_disc_reqs),
  		  (u64)atomic64_read(&stats->vlan_stats.resp_withno_vlanID),
  		  (u64)atomic64_read(&stats->vlan_stats.sol_expiry_count),
  		  (u64)atomic64_read(&stats->vlan_stats.flogi_rejects));
  
  	len += snprintf(debug->debug_buffer + len, buf_size - len,
  		  "
  ------------------------------------------
  "
  		  "\t\tOther Important Statistics
  "
  		  "------------------------------------------
  ");
  
  	jiffies_to_timespec(stats->misc_stats.last_isr_time, &val1);
  	jiffies_to_timespec(stats->misc_stats.last_ack_time, &val2);
  
  	len += snprintf(debug->debug_buffer + len, buf_size - len,
  		  "Last ISR time: %llu (%8lu.%8lu)
  "
  		  "Last ACK time: %llu (%8lu.%8lu)
  "
  		  "Number of ISRs: %lld
  "
  		  "Maximum CQ Entries: %lld
  "
  		  "Number of ACK index out of range: %lld
  "
  		  "Number of data count mismatch: %lld
  "
  		  "Number of FCPIO Timeouts: %lld
  "
  		  "Number of FCPIO Aborted: %lld
  "
  		  "Number of SGL Invalid: %lld
  "
  		  "Number of Copy WQ Alloc Failures for ABTs: %lld
  "
  		  "Number of Copy WQ Alloc Failures for Device Reset: %lld
  "
  		  "Number of Copy WQ Alloc Failures for IOs: %lld
  "
  		  "Number of no icmnd itmf Completions: %lld
  "
  		  "Number of QUEUE Fulls: %lld
  "
  		  "Number of rport not ready: %lld
  "
  		  "Number of receive frame errors: %lld
  ",
  		  (u64)stats->misc_stats.last_isr_time,
  		  val1.tv_sec, val1.tv_nsec,
  		  (u64)stats->misc_stats.last_ack_time,
  		  val2.tv_sec, val2.tv_nsec,
  		  (u64)atomic64_read(&stats->misc_stats.isr_count),
  		  (u64)atomic64_read(&stats->misc_stats.max_cq_entries),
  		  (u64)atomic64_read(&stats->misc_stats.ack_index_out_of_range),
  		  (u64)atomic64_read(&stats->misc_stats.data_count_mismatch),
  		  (u64)atomic64_read(&stats->misc_stats.fcpio_timeout),
  		  (u64)atomic64_read(&stats->misc_stats.fcpio_aborted),
  		  (u64)atomic64_read(&stats->misc_stats.sgl_invalid),
  		  (u64)atomic64_read(
  			  &stats->misc_stats.abts_cpwq_alloc_failures),
  		  (u64)atomic64_read(
  			  &stats->misc_stats.devrst_cpwq_alloc_failures),
  		  (u64)atomic64_read(&stats->misc_stats.io_cpwq_alloc_failures),
  		  (u64)atomic64_read(&stats->misc_stats.no_icmnd_itmf_cmpls),
  		  (u64)atomic64_read(&stats->misc_stats.queue_fulls),
  		  (u64)atomic64_read(&stats->misc_stats.rport_not_ready),
  		  (u64)atomic64_read(&stats->misc_stats.frame_errors));
  
  	return len;
  
  }
  
  /*
   * fnic_trace_buf_init - Initialize fnic trace buffer logging facility
   *
   * Description:
   * Initialize trace buffer data structure by allocating required memory and
   * setting page_offset information for every trace entry by adding trace entry
   * length to previous page_offset value.
   */
  int fnic_trace_buf_init(void)
  {
  	unsigned long fnic_buf_head;
  	int i;
  	int err = 0;
  
  	trace_max_pages = fnic_trace_max_pages;
  	fnic_max_trace_entries = (trace_max_pages * PAGE_SIZE)/
  					  FNIC_ENTRY_SIZE_BYTES;
  
  	fnic_trace_buf_p = (unsigned long)vmalloc((trace_max_pages * PAGE_SIZE));
  	if (!fnic_trace_buf_p) {
  		printk(KERN_ERR PFX "Failed to allocate memory "
  				  "for fnic_trace_buf_p
  ");
  		err = -ENOMEM;
  		goto err_fnic_trace_buf_init;
  	}
  	memset((void *)fnic_trace_buf_p, 0, (trace_max_pages * PAGE_SIZE));
  
  	fnic_trace_entries.page_offset = vmalloc(fnic_max_trace_entries *
  						  sizeof(unsigned long));
  	if (!fnic_trace_entries.page_offset) {
  		printk(KERN_ERR PFX "Failed to allocate memory for"
  				  " page_offset
  ");
  		if (fnic_trace_buf_p) {
  			vfree((void *)fnic_trace_buf_p);
  			fnic_trace_buf_p = 0;
  		}
  		err = -ENOMEM;
  		goto err_fnic_trace_buf_init;
  	}
  	memset((void *)fnic_trace_entries.page_offset, 0,
  		  (fnic_max_trace_entries * sizeof(unsigned long)));
  	fnic_trace_entries.wr_idx = fnic_trace_entries.rd_idx = 0;
  	fnic_buf_head = fnic_trace_buf_p;
  
  	/*
  	 * Set page_offset field of fnic_trace_entries struct by
  	 * calculating memory location for every trace entry using
  	 * length of each trace entry
  	 */
  	for (i = 0; i < fnic_max_trace_entries; i++) {
  		fnic_trace_entries.page_offset[i] = fnic_buf_head;
  		fnic_buf_head += FNIC_ENTRY_SIZE_BYTES;
  	}
  	err = fnic_trace_debugfs_init();
  	if (err < 0) {
  		pr_err("fnic: Failed to initialize debugfs for tracing
  ");
  		goto err_fnic_trace_debugfs_init;
  	}
  	pr_info("fnic: Successfully Initialized Trace Buffer
  ");
  	return err;
  err_fnic_trace_debugfs_init:
  	fnic_trace_free();
  err_fnic_trace_buf_init:
  	return err;
  }
  
  /*
   * fnic_trace_free - Free memory of fnic trace data structures.
   */
  void fnic_trace_free(void)
  {
  	fnic_tracing_enabled = 0;
  	fnic_trace_debugfs_terminate();
  	if (fnic_trace_entries.page_offset) {
  		vfree((void *)fnic_trace_entries.page_offset);
  		fnic_trace_entries.page_offset = NULL;
  	}
  	if (fnic_trace_buf_p) {
  		vfree((void *)fnic_trace_buf_p);
  		fnic_trace_buf_p = 0;
  	}
  	printk(KERN_INFO PFX "Successfully Freed Trace Buffer
  ");
  }
  
  /*
   * fnic_fc_ctlr_trace_buf_init -
   * Initialize trace buffer to log fnic control frames
   * Description:
   * Initialize trace buffer data structure by allocating
   * required memory for trace data as well as for Indexes.
   * Frame size is 256 bytes and
   * memory is allocated for 1024 entries of 256 bytes.
   * Page_offset(Index) is set to the address of trace entry
   * and page_offset is initialized by adding frame size
   * to the previous page_offset entry.
   */
  
  int fnic_fc_trace_init(void)
  {
  	unsigned long fc_trace_buf_head;
  	int err = 0;
  	int i;
  
  	fc_trace_max_entries = (fnic_fc_trace_max_pages * PAGE_SIZE)/
  				FC_TRC_SIZE_BYTES;
  	fnic_fc_ctlr_trace_buf_p = (unsigned long)vmalloc(
  					fnic_fc_trace_max_pages * PAGE_SIZE);
  	if (!fnic_fc_ctlr_trace_buf_p) {
  		pr_err("fnic: Failed to allocate memory for "
  		       "FC Control Trace Buf
  ");
  		err = -ENOMEM;
  		goto err_fnic_fc_ctlr_trace_buf_init;
  	}
  
  	memset((void *)fnic_fc_ctlr_trace_buf_p, 0,
  			fnic_fc_trace_max_pages * PAGE_SIZE);
  
  	/* Allocate memory for page offset */
  	fc_trace_entries.page_offset = vmalloc(fc_trace_max_entries *
  						sizeof(unsigned long));
  	if (!fc_trace_entries.page_offset) {
  		pr_err("fnic:Failed to allocate memory for page_offset
  ");
  		if (fnic_fc_ctlr_trace_buf_p) {
  			pr_err("fnic: Freeing FC Control Trace Buf
  ");
  			vfree((void *)fnic_fc_ctlr_trace_buf_p);
  			fnic_fc_ctlr_trace_buf_p = 0;
  		}
  		err = -ENOMEM;
  		goto err_fnic_fc_ctlr_trace_buf_init;
  	}
  	memset((void *)fc_trace_entries.page_offset, 0,
  	       (fc_trace_max_entries * sizeof(unsigned long)));
  
  	fc_trace_entries.rd_idx = fc_trace_entries.wr_idx = 0;
  	fc_trace_buf_head = fnic_fc_ctlr_trace_buf_p;
  
  	/*
  	* Set up fc_trace_entries.page_offset field with memory location
  	* for every trace entry
  	*/
  	for (i = 0; i < fc_trace_max_entries; i++) {
  		fc_trace_entries.page_offset[i] = fc_trace_buf_head;
  		fc_trace_buf_head += FC_TRC_SIZE_BYTES;
  	}
  	err = fnic_fc_trace_debugfs_init();
  	if (err < 0) {
  		pr_err("fnic: Failed to initialize FC_CTLR tracing.
  ");
  		goto err_fnic_fc_ctlr_trace_debugfs_init;
  	}
  	pr_info("fnic: Successfully Initialized FC_CTLR Trace Buffer
  ");
  	return err;
  
  err_fnic_fc_ctlr_trace_debugfs_init:
  	fnic_fc_trace_free();
  err_fnic_fc_ctlr_trace_buf_init:
  	return err;
  }
  
  /*
   * Fnic_fc_ctlr_trace_free - Free memory of fnic_fc_ctlr trace data structures.
   */
  void fnic_fc_trace_free(void)
  {
  	fnic_fc_tracing_enabled = 0;
  	fnic_fc_trace_debugfs_terminate();
  	if (fc_trace_entries.page_offset) {
  		vfree((void *)fc_trace_entries.page_offset);
  		fc_trace_entries.page_offset = NULL;
  	}
  	if (fnic_fc_ctlr_trace_buf_p) {
  		vfree((void *)fnic_fc_ctlr_trace_buf_p);
  		fnic_fc_ctlr_trace_buf_p = 0;
  	}
  	pr_info("fnic:Successfully FC_CTLR Freed Trace Buffer
  ");
  }
  
  /*
   * fnic_fc_ctlr_set_trace_data:
   *       Maintain rd & wr idx accordingly and set data
   * Passed parameters:
   *       host_no: host number accociated with fnic
   *       frame_type: send_frame, rece_frame or link event
   *       fc_frame: pointer to fc_frame
   *       frame_len: Length of the fc_frame
   * Description:
   *   This routine will get next available wr_idx and
   *   copy all passed trace data to the buffer pointed by wr_idx
   *   and increment wr_idx. It will also make sure that we dont
   *   overwrite the entry which we are reading and also
   *   wrap around if we reach the maximum entries.
   * Returned Value:
   *   It will return 0 for success or -1 for failure
   */
  int fnic_fc_trace_set_data(u32 host_no, u8 frame_type,
  				char *frame, u32 fc_trc_frame_len)
  {
  	unsigned long flags;
  	struct fc_trace_hdr *fc_buf;
  	unsigned long eth_fcoe_hdr_len;
  	char *fc_trace;
  
  	if (fnic_fc_tracing_enabled == 0)
  		return 0;
  
  	spin_lock_irqsave(&fnic_fc_trace_lock, flags);
  
  	if (fnic_fc_trace_cleared == 1) {
  		fc_trace_entries.rd_idx = fc_trace_entries.wr_idx = 0;
  		pr_info("fnic: Resetting the read idx
  ");
  		memset((void *)fnic_fc_ctlr_trace_buf_p, 0,
  				fnic_fc_trace_max_pages * PAGE_SIZE);
  		fnic_fc_trace_cleared = 0;
  	}
  
  	fc_buf = (struct fc_trace_hdr *)
  		fc_trace_entries.page_offset[fc_trace_entries.wr_idx];
  
  	fc_trace_entries.wr_idx++;
  
  	if (fc_trace_entries.wr_idx >= fc_trace_max_entries)
  		fc_trace_entries.wr_idx = 0;
  
  	if (fc_trace_entries.wr_idx == fc_trace_entries.rd_idx) {
  		fc_trace_entries.rd_idx++;
  		if (fc_trace_entries.rd_idx >= fc_trace_max_entries)
  			fc_trace_entries.rd_idx = 0;
  	}
  
  	fc_buf->time_stamp = CURRENT_TIME;
  	fc_buf->host_no = host_no;
  	fc_buf->frame_type = frame_type;
  
  	fc_trace = (char *)FC_TRACE_ADDRESS(fc_buf);
  
  	/* During the receive path, we do not have eth hdr as well as fcoe hdr
  	 * at trace entry point so we will stuff 0xff just to make it generic.
  	 */
  	if (frame_type == FNIC_FC_RECV) {
  		eth_fcoe_hdr_len = sizeof(struct ethhdr) +
  					sizeof(struct fcoe_hdr);
  		memset((char *)fc_trace, 0xff, eth_fcoe_hdr_len);
  		/* Copy the rest of data frame */
  		memcpy((char *)(fc_trace + eth_fcoe_hdr_len), (void *)frame,
  		min_t(u8, fc_trc_frame_len,
  			(u8)(FC_TRC_SIZE_BYTES - FC_TRC_HEADER_SIZE
  						- eth_fcoe_hdr_len)));
  	} else {
  		memcpy((char *)fc_trace, (void *)frame,
  		min_t(u8, fc_trc_frame_len,
  			(u8)(FC_TRC_SIZE_BYTES - FC_TRC_HEADER_SIZE)));
  	}
  
  	/* Store the actual received length */
  	fc_buf->frame_len = fc_trc_frame_len;
  
  	spin_unlock_irqrestore(&fnic_fc_trace_lock, flags);
  	return 0;
  }
  
  /*
   * fnic_fc_ctlr_get_trace_data: Copy trace buffer to a memory file
   * Passed parameter:
   *       @fnic_dbgfs_t: pointer to debugfs trace buffer
   *       rdata_flag: 1 => Unformated file
   *                   0 => formated file
   * Description:
   *       This routine will copy the trace data to memory file with
   *       proper formatting and also copy to another memory
   *       file without formatting for further procesing.
   * Retrun Value:
   *       Number of bytes that were dumped into fnic_dbgfs_t
   */
  
  int fnic_fc_trace_get_data(fnic_dbgfs_t *fnic_dbgfs_prt, u8 rdata_flag)
  {
  	int rd_idx, wr_idx;
  	unsigned long flags;
  	int len = 0, j;
  	struct fc_trace_hdr *tdata;
  	char *fc_trace;
  
  	spin_lock_irqsave(&fnic_fc_trace_lock, flags);
  	if (fc_trace_entries.wr_idx == fc_trace_entries.rd_idx) {
  		spin_unlock_irqrestore(&fnic_fc_trace_lock, flags);
  		pr_info("fnic: Buffer is empty
  ");
  		return 0;
  	}
  	rd_idx = fc_trace_entries.rd_idx;
  	wr_idx = fc_trace_entries.wr_idx;
  	if (rdata_flag == 0) {
  		len += snprintf(fnic_dbgfs_prt->buffer + len,
  			(fnic_fc_trace_max_pages * PAGE_SIZE * 3) - len,
  			"Time Stamp (UTC)\t\t"
  			"Host No:   F Type:  len:     FCoE_FRAME:
  ");
  	}
  
  	while (rd_idx != wr_idx) {
  		tdata = (struct fc_trace_hdr *)
  			fc_trace_entries.page_offset[rd_idx];
  		if (!tdata) {
  			pr_info("fnic: Rd data is NULL
  ");
  			spin_unlock_irqrestore(&fnic_fc_trace_lock, flags);
  			return 0;
  		}
  		if (rdata_flag == 0) {
  			copy_and_format_trace_data(tdata,
  				fnic_dbgfs_prt, &len, rdata_flag);
  		} else {
  			fc_trace = (char *)tdata;
  			for (j = 0; j < FC_TRC_SIZE_BYTES; j++) {
  				len += snprintf(fnic_dbgfs_prt->buffer + len,
  				(fnic_fc_trace_max_pages * PAGE_SIZE * 3)
  				- len, "%02x", fc_trace[j] & 0xff);
  			} /* for loop */
  			len += snprintf(fnic_dbgfs_prt->buffer + len,
  				(fnic_fc_trace_max_pages * PAGE_SIZE * 3) - len,
  				"
  ");
  		}
  		rd_idx++;
  		if (rd_idx > (fc_trace_max_entries - 1))
  			rd_idx = 0;
  	}
  
  	spin_unlock_irqrestore(&fnic_fc_trace_lock, flags);
  	return len;
  }
  
  /*
   * copy_and_format_trace_data: Copy formatted data to char * buffer
   * Passed Parameter:
   *      @fc_trace_hdr_t: pointer to trace data
   *      @fnic_dbgfs_t: pointer to debugfs trace buffer
   *      @orig_len: pointer to len
   *      rdata_flag: 0 => Formated file, 1 => Unformated file
   * Description:
   *      This routine will format and copy the passed trace data
   *      for formated file or unformated file accordingly.
   */
  
  void copy_and_format_trace_data(struct fc_trace_hdr *tdata,
  				fnic_dbgfs_t *fnic_dbgfs_prt, int *orig_len,
  				u8 rdata_flag)
  {
  	struct tm tm;
  	int j, i = 1, len;
  	char *fc_trace, *fmt;
  	int ethhdr_len = sizeof(struct ethhdr) - 1;
  	int fcoehdr_len = sizeof(struct fcoe_hdr);
  	int fchdr_len = sizeof(struct fc_frame_header);
  	int max_size = fnic_fc_trace_max_pages * PAGE_SIZE * 3;
  
  	tdata->frame_type = tdata->frame_type & 0x7F;
  
  	len = *orig_len;
  
  	time_to_tm(tdata->time_stamp.tv_sec, 0, &tm);
  
  	fmt = "%02d:%02d:%04ld %02d:%02d:%02d.%09lu ns%8x       %c%8x\t";
  	len += snprintf(fnic_dbgfs_prt->buffer + len,
  		max_size - len,
  		fmt,
  		tm.tm_mon + 1, tm.tm_mday, tm.tm_year + 1900,
  		tm.tm_hour, tm.tm_min, tm.tm_sec,
  		tdata->time_stamp.tv_nsec, tdata->host_no,
  		tdata->frame_type, tdata->frame_len);
  
  	fc_trace = (char *)FC_TRACE_ADDRESS(tdata);
  
  	for (j = 0; j < min_t(u8, tdata->frame_len,
  		(u8)(FC_TRC_SIZE_BYTES - FC_TRC_HEADER_SIZE)); j++) {
  		if (tdata->frame_type == FNIC_FC_LE) {
  			len += snprintf(fnic_dbgfs_prt->buffer + len,
  				max_size - len, "%c", fc_trace[j]);
  		} else {
  			len += snprintf(fnic_dbgfs_prt->buffer + len,
  				max_size - len, "%02x", fc_trace[j] & 0xff);
  			len += snprintf(fnic_dbgfs_prt->buffer + len,
  				max_size - len, " ");
  			if (j == ethhdr_len ||
  				j == ethhdr_len + fcoehdr_len ||
  				j == ethhdr_len + fcoehdr_len + fchdr_len ||
  				(i > 3 && j%fchdr_len == 0)) {
  				len += snprintf(fnic_dbgfs_prt->buffer
  					+ len, max_size - len,
  					"
  \t\t\t\t\t\t\t\t");
  				i++;
  			}
  		} /* end of else*/
  	} /* End of for loop*/
  	len += snprintf(fnic_dbgfs_prt->buffer + len,
  		max_size - len, "
  ");
  	*orig_len = len;
  }