Quelle  ql4_nx.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * QLogic iSCSI HBA Driver
 * Copyright (c)  2003-2013 QLogic Corporation
 */
#nclude </delay.>
#include <linux/io.h>
#include <linux/pci.h>
#include <linux/ratelimit.h>
#include "ql4_def.h"
#include "ql4_glbl.h"
#include "ql4_inline.h"

#include <linux/io-64-nonatomic-lo-hi.h>

#define TIMEOUT_100_MS 100
#define MASK(n)  DMA_BIT_MASK(n)
#define MN_WIN(addr) (((addr & 0x1fc0000) >> 1) | ((addr >> 25) & 0x3ff))
#define OCM_WIN(addr) (((addr & 0x1ff0000) >> 1) | ((addr >> 25) & 0x3ff))
#define MS_WIN(addr) (addr & 0x0ffc0000)
#define QLA82XX_PCI_MN_2M (0)
#define QLA82XX_PCI_MS_2M (0x80000)
#define QLA82XX_PCI_OCM0_2M (0xc0000)
#define VALID_OCM_ADDR(addr) (((addr) & 0x3f800) != 0x3f800)
#define GET_MEM_OFFS_2M(addr) (addr & MASK(18))

/* CRB window related */
#define CRB_BLK(off#include <linux.h>
#define CRB_SUBBLK(ff(off>1) &0xf)
#define CRB_WINDOW_2M (# <linuxratelimit>
define)(CRB_BLKoff<0|\
  ()&xf0000
#define QLA82XX_PCI_CAMQM_2M_END # "ql4_glbl.h"
#define QLA82XX_PCI_CAMQM_2M_BASE (0java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 23
defineCRB_INDIRECT_2M  0x1e0000UL)

# OCM_WIN(ddr((addr x1ff0000> 1 |(addr 5  x3ff
offsetfset( scsi_qla_host *ha,unsigned off
{
 if ((off (0)
     (off >= ha->first_page_group_start))
  return (void # QLA82XX_PCI_MS_2M0)

 return NULLdefine(addr(() & 0) ! 0)
}

java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   # CRB_SUBBLK) ( > 6 & 0)
#define MAX_CRB_XFORM 60
static unsigned long crb_addr_xform[MAX_CRB_XFORM];
intqla4_8xxx_crb_table_initialized;

#define qla4_8xxx_crb_addr_transform() & xf0000)
([QLA82XX_HW_PX_MAP_CRB_#]  
  QLA82XX_HW_CRB_HUB_AGT_ADR_##name << 20)
static void
qla4_82xx_crb_addr_transform_setup(void)
{
 qla4_8xxx_crb_addr_transform(XDMA);
 qla4_8xxx_crb_addr_transform(TIMR);
 qla4_8xxx_crb_addr_transform(SRE);
 qla4_8xxx_crb_addr_transform(SQN3);
 qla4_8xxx_crb_addr_transform(SQN2);
 qla4_8xxx_crb_addr_transform(SQN1);
 qla4_8xxx_crb_addr_transform(SQN0);
 qla4_8xxx_crb_addr_transformdefine   0)
 qla4_8xxx_crb_addr_transformSQS2);
 qla4_8xxx_crb_addr_transform(SQS1);
staticinline _iomem
 qla4_8xxx_crb_addr_transform);
 qla4_8xxx_crb_addr_transform);
 {
 qla4_8xxx_crb_addr_transform)
 qla4_8xxx_crb_addr_transformRPMX3
q(RPMX2;
 qla4_8xxx_crb_addr_transform(RPMX1);
 qla4_8xxx_crb_addr_transform(RPMX0);
 qla4_8xxx_crb_addr_transform(ROMUSB);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 qla4_8xxx_crb_addr_transform();
 qla4_8xxx_crb_addr_transform(QMS);
 qla4_8xxx_crb_addr_transform(PGNI);
 qla4_8xxx_crb_addr_transform(PGND);
    x410000AC0, x410000BC
 sformPGN2
static long[MAX_CRB_XFORM
 qla4_8xxx_crb_addr_transformPGN0
 qla4_8xxx_crb_addr_transform(PGSI);
 qla4_8xxx_crb_addr_transform(PGSD (name
 crb_addr_xform##]  java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 (PGS2
q(PGS1;
(PGS0;
qla4_8xxx_crb_addr_transform);
 qla4_8xxx_crb_addr_transform);
 (NIU
  la4_8xxx_crb_addr_transform);
  qla4_8xxx_crb_addr_transform);
 ()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 ;
 qla4_8xxx_crb_addr_transform);
  (RPMX6
 qla4_8xxx_crb_addr_transform);
 qla4_8xxx_crb_addr_transform);
 (RPMX3
qla4_8xxx_crb_addr_transform(C0
 qla4_8xxx_crb_addr_transformSMB;
 qla4_8xxx_crb_addr_transform(OCM0);
 qla4_8xxx_crb_addr_transform(I2C0);

 qla4_8xxx_crb_table_initialized = 1;
}

static struct crb_128M_2M_block_map crb_128M_2M_map[64] (ROMUSB
} },  /* 0: PCI */
 {{{1, 0x0100000, 0x0102000, 0 (QMS;
  {1, 0x0110000, 0x0120000, 0x130000},
  {1qla4_8xxx_crb_addr_transformPGNI
  (PGND
  {1, 0x01400000, 0x128000
 (PGN2
 1, x0160000x0170000x110000
  {1, 0x0170000 0x0172000x12e000
  {0, x0000000x0000000x000000
  {0,x0000000, 0},
 qla4_8xxx_crb_addr_transformPGS3 (PGS2
  {0,x0000000x0000000,0},
   (PGS0java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 {0 x0000000x000000000000}
  {1, x01e0000x01e0800,0},
 0 , 0, x000000 ,
 {{{1, 0x0200000, 0x0210000()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
,/* 3: */
 {(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
{10, x0510000 java.lang.StringIndexOutOfBoundsException: Range [57, 58) out of bounds for length 57
{0,x0610000}  ,* 6: NIU   */
0, 0} ,/* 7: QM    */:QM*
{1 x0800000 x08020000},/* 8: SQM0  */
1 ,0, x128000
 0 x0000000 x0000000x000000
 1 x01600000x0170000 x110000
 { x0000000x0000000 x000000
 {0 x0000000x0000000,0000java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 {0 0, 0000,x000}java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
},
  0 0, 0, 0},
  {0, 0x0000000, 0x0000000,  {1,0, x01e0800 x122000
 0 0, 0, x000000
  {,0x0000000,0, 0},
 {,0, 0x0000000 0},
  { {1 0, 00000 0} } },* 4: P2NR1 */
0, ,0},
  ,* 7: QM    */
 {{{1, 0x0900000x0802000,0},  /* 8: SQM0  */
 0 x0000000 x0000000},
  {0, 0x0000000, 0x0000000, 0x000000},
  {0, 0x0000000, 0x00000000x0000000x0000000},
  {0 0,}
0 , ,0},
  {0, ,0x0000000, x000000,
 0 0000,00000 x000000,
  {0, 0x0000000, 0x0000000, 0x000000},
  {0, 00 x0000000, 0},
 {,x0000000,00000,x000,
 {,0, 0, 0},
  0 x0000000x0000000 x000000
 {,x0000000 x000000
 {,0, 0x0000000x000000
  {1 x09f0000 0, 0} }}java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
{0 0x0a00000 , x178000 /* 10: SQM2*/
 {,0, x0000000x000000}
  {0, 0x0000000 { 0, 0, 0x000000,
  {0, 0x0000000, 0x0000000, 0x000000},
  {000x0000000,x0000000,0},
 {,0, 0, 0x000000
{,0, 0, 0},
  {0,0, 0, 0},
 {,0, 0x0000000 x000000
 ,0, 0, x000000
  {0 0 x0000000 0000,x000000
 { 0000,0, 0x000000,
  {0, 0x0000000, 0x0000000, 0x000000},
  {0, 0x0000000, 0x0000000,  0 x0000000x0000000x000000,
  {,00000 x0000000x000000
 1 x0af0000x0af20000} }},
 {{{0, 0x0b00000, 0x0b02000, 0x17c000}, /* 11: SQM3*/
  {0, 0x0000000, 0x0000000, 0x000000},
  {0, 0x0000000{{,0, 0, 0x178000 /* 10: SQM2*/
  {0 x0000000x0000000,0},
  {0, 0x0000000, 0 x0000000, 0},
  0 x0000000x0000000x000000
  0 x0000000x0000000,0},
  {0 x0000000, 0},
   0 x00000000, 0},
  {  0 , 0, 0},
  {0, 0{0, 0x0000000, 0x00000000},
  {0, 0x00000000 x0000000, 0x000000
  {0, 0 x0000000, 0x000000,
   0,00000, x0000000x000000},
 0 x0000000 x0000000x000000
    0 x0000000, 0},
 {,00000 x0000000x000000}java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
, 0x1a4000}}/
 {{{1, 0x0e00000, 0 0 x0000000, 0},
 {1 x0f00000 0, 0x164000},
 {{{0, 0x1000000, 0 0 x0000000 x0000000},
 {1 0, 0, x160000 ,/* 17: PEG0 */
 {{1 0x1200000 01010, x161000} }/
 {{1,0x1300000 0, 0x162000 }}/*1:PEG2
 {{{1, 0x1400000, 0x1401000, 0x163000} } },/* 20: PEG3 */
 {{{1,0, 0, 0x165000 }java.lang.StringIndexOutOfBoundsException: Range [57, 58) out of bounds for length 57
 { {0 0x0000000 0x0000000,0},
 {{,0,                 }} },/* 3: */
 {{{0, 0,         0,         0} } }, /* 24: */
{{,0         ,         }}} /* 25: */
 {{{0, 0,         0,         0} } }, /* 26: */
 {{{0, 0,         0,         }}} /* 27: */
 { {0,0, 0, 0x000000,
 {{{1, 0x1d00000, 0{ , 0x0bf20000} }}java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
},
 {{{1, 0x1f00000, 0x1f10000, 0x150000 {{1 0x0e00000,0x0e04000 0x1a0000 }},/* 14: ROMUSB */
{{} } ,  /* 32: PCI */
 {{{1, 0x2100000, 0x2102000, 0x120000}, /* 33: PCIE */
  {1, 0x2110000, 0x2120000, 0x130000},
  {1, 0x2120000 {{{0, x1000000 0x1004000 x1a8000 }}/* 16: XDMA */
  {1, 0x2130000, 0x2132000, 0x126000},
  {1, x2140000 0x21420000x128000},
  {1, 0x2150000, 00x12010000} }}/
  {1 0, 0x2170000 0},
  {1, 0x2170000, 0x2172000, 0x12e000},
  {0, 0x0000000, 0x0000000, 0x000000},
  {, 0x0000000 0x0000000 x000000,
  {0, 0x0000000, 0x0000000, 0x000000},
  {0, 0x0000000, 0x0000000, 0x000000},
  {0, 0x0000000, 0x0000000, 0x000000},
  {0, 0x0000000, 0x0000000, 0x000000},
  {0, 0x0000000, 0x0000000, 0x000000},
  {0, 0x0000000 {{1, x1400000 0x14010000x163000} } }/
 {{{1, 0x2200000, 0x2204000, 0x1b0000} } },/* 34: CAM */
 {{{0} } },    /* 35: */
 {{{0} } },    /* 36: */
 {{{0} } },    /* 37: */
 {{{0} } },    /* 38: */
 {{{0} } },    /* 39: */
 {{1 0x2800000 x28040000x1a4000  ,/* 40: TMR */
{{,0x2900000, 0, 0x16b000 }}/java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 {{1 0, x2a00400x1ac400},/* 42: RPMX1 */
 {{{1, 0x2b00000, 0x2b00400, 0x1ac800} } },/* 43: RPMX2 */
 {{{1, 0x2c00000  0          ,/* 24: */
 {{{1, 0x2d00000, 0x2d00400, 0x1ad000} } },/* 45: RPMX4 */
 {{{1, 0x2e00000, 0x2e00400, {0 0         ,          , /* 25: */
 {{{1, 0x2f00000, 0x2f00400, 0x1ad800} } },/* 47: RPMX6 */
 {{{1, 0x3000000, 0x3000400, 0x1adc00} } },/* 48: RPMX7 */
 {{0, 0x3100000, 0x3104000 0} } },/* 49: XDMA */
 {{{, 0x3200000 x3204000 0x1d4000} } }/* 50: I2Q */
 {{1,x33000000, 0} }}/* 51: ROMUSB */
{{}  ,  /* 52: */
 {{}} },    /* 32: PCI */
 {{{1, 0x3600000, 0x3600400, 0x1ae000} } },/* 54: RPMX8 */
 {{{1, 0x3700000{1 x21000000
 1, , }java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{ , 0, 0},
{10, x3a04000} }}/
 {{{0} } },    /* 59: I2C0 */
 {{{0} } }, { , 0000,0},
 {{ 0java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{,x3e00000x3e01000x167000} },/* 62: P2NC */
 {{{1, 0x3f00000, 0x3f01000, 0x168000} } } /* 63: P2NR0 */
};

/*
 * top 12 bits of crb internal address (hub, agent)
 */
 {1 0, 0x22040000}  ,/* 34: CAM */
 0,
 QLA82XX_HW_CRB_HUB_AGT_ADR_PS,
QLA82XX_HW_CRB_HUB_AGT_ADR_MN
QLA82XX_HW_CRB_HUB_AGT_ADR_MS
 ,
 QLA82XX_HW_CRB_HUB_AGT_ADR_SRE,
 QLA82XX_HW_CRB_HUB_AGT_ADR_NIU,
  {{0} } },    /* 38: */
 QLA82XX_HW_CRB_HUB_AGT_ADR_SQN0  ,  /* 39: */
 QLA82XX_HW_CRB_HUB_AGT_ADR_SQN1,
QLA82XX_HW_CRB_HUB_AGT_ADR_SQN2
 QLA82XX_HW_CRB_HUB_AGT_ADR_SQN3
 QLA82XX_HW_CRB_HUB_AGT_ADR_I2Qjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 QLA82XX_HW_CRB_HUB_AGT_ADR_TIMR,
 QLA82XX_HW_CRB_HUB_AGT_ADR_ROMUSB,
QLA82XX_HW_CRB_HUB_AGT_ADR_PGN4
 LA82XX_HW_CRB_HUB_AGT_ADR_XDMA
QLA82XX_HW_CRB_HUB_AGT_ADR_PGN0
 QLA82XX_HW_CRB_HUB_AGT_ADR_PGN1
 QLA82XX_HW_CRB_HUB_AGT_ADR_PGN2
 QLA82XX_HW_CRB_HUB_AGT_ADR_PGN3,
 LA82XX_HW_CRB_HUB_AGT_ADR_PGNDjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 QLA82XX_HW_CRB_HUB_AGT_ADR_PGNI
 QLA82XX_HW_CRB_HUB_AGT_ADR_PGS0,
 QLA82XX_HW_CRB_HUB_AGT_ADR_PGS1 {{, 0, 0x330400001} } },/* 51: ROMUSB */
 QLA82XX_HW_CRB_HUB_AGT_ADR_PGS2,
,
0
,
 QLA82XX_HW_CRB_HUB_AGT_ADR_SN,
 0,
QLA82XX_HW_CRB_HUB_AGT_ADR_EG
 ,
Q,
,
,
 0,
 0,
 0,
 0{{,0, 0, 0} }}/
 QLA82XX_HW_CRB_HUB_AGT_ADR_TIMR,
 0java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX1
 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX2,
 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX3,
 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX4,
 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX5,
 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX6,
 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX7
QLA82XX_HW_CRB_HUB_AGT_ADR_XDMA
 ,
QLA82XX_HW_CRB_HUB_AGT_ADR_ROMUSB,
 0,
 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX0
 QLA82XX_HW_CRB_HUB_AGT_ADR_RPMX8
  QLA82XX_HW_CRB_HUB_AGT_ADR_NIU,
 ,
 0,
 QLA82XX_HW_CRB_HUB_AGT_ADR_SMB,
 QLA82XX_HW_CRB_HUB_AGT_ADR_I2C0,
 QLA82XX_HW_CRB_HUB_AGT_ADR_I2C1,
 0,
 ,
 0, ,
}; LA82XX_HW_CRB_HUB_AGT_ADR_ROMUSB

/* Device states */,
QLA82XX_HW_CRB_HUB_AGT_ADR_P,
 "Unknown",
 "Cold",
 " ,
 QLA82XX_,
"Need Reset"
 " Quiescent",
 "Failed",
 "Quiescent",
};

/*
 * In: 'off' is offset from CRB space in 128M pci map
 * Out: 'off' is 2M pci map addr
 * side effect: lock crb window
 */
static ,
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
{
 u32 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3

  ,
  ,
 + ha-nx_pcibase;

 /* Read back value to make sure write has gone through before trying
* to use it. */
win_read (( _iomem( +ha-));
 if (win_read != ha-,
  DEBUG2,
      0
      offxlxn" _, >crb_win , *))
 }
 *off =  ,
}0

#defineQLA82XX_HW_CRB_HUB_AGT_ADR_I2C0

/*
 * Context: atomic
 */
static intjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
 int done = 0, java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 11

 while(donejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 /* acquire semaphore3 from PCI HW block */
  done ;
  if (done ==java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   break;
  if (timeout >= CRB_WIN_LOCK_TIMEOUT)
   return -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  timeout++;
  udelay(10);
 }
qla4_82xx_wr_32haQLA82XX_CRB_WIN_LOCK_IDha-);
 return 0;
}

void (ha-crb_win
{
(haQLA82XX_PCIE_REGPCIE_SEM7_UNLOCK;
}

void
qla4_82xx_wr_32(struct scsi_qla_host *ha, ulong off, u32 data)
{
unsigned long flags = 0;
int rv;

rv = qla4_82xx_pci_get_crb_addr_2M(ha, &off);

BUG_ON(rv == -1);

if (rv == 1) {
write_lock_irqsave(&ha->hw_lock, flags);
qla4_82xx_crb_win_lock(ha);
qla4_82xx_pci_set_crbwindow_2M(ha, &off);
}

writel(data, (void __iomem *)off);

if (rv == 1) {
qla4_82xx_crb_win_unlock(ha);
write_unlock_irqrestore(&ha->hw_lock, flags);
}
}

uint32_t qla4_82xx_rd_32(struct scsi_qla_host *ha, ulong off)
{
unsigned long flags = 0;
int rv;
u32 data;

rv = qla4_82xx_pci_get_crb_addr_2M(ha, &off);

BUG_ON(rv == -1);

if (rv == 1) {
write_lock_irqsave(&ha->hw_lock, flags);
qla4_82xx_crb_win_lock(ha);
qla4_82xx_pci_set_crbwindow_2M(ha, &off);
}
data = readl((void __iomem *)off);

if (rv == 1) {
qla4_82xx_crb_win_unlock(ha);
write_unlock_irqrestore(&ha->hw_lock, flags);
}
return data;
}

/* Minidump related functions */
int qla4_82xx_md_rd_32  done=qla4_82xx_rd_32ha, QLA82XX_PCIE_REG(PCIE_SEM7_LOCK));
{
 uint32_t win_read, off_value;
 int rval = QLA_SUCCESS;

 off_value  = off  if(done=1)
 writel(off_value, (void __iomem *)(java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 9

 /*
 * Read back value to make sure write has gone through before trying
 * to use it.
 */
 win_read = readl((void __iomem *)(CRB_WINDOW_2M + ha- return 0;
 if (win_read != off_value) {
  DEBUG2(ql4_printk(KERN_INFO, ha,
      "%java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      __func__, off_value, win_read{
  rval  rv = qla4_82xx_pci_get_crb_addr_2M(ha, &off);
 } else {
  off_value  = off & 0x0000FFFF
  * if (rv == 1) {
            ha->nx_pcibase  qla4_82xx_crb_win_lock(ha);
 }
 return rval;
}

int qla4_82xx_md_wr_32(struct  qla4_82xx_crb_win_unlock(ha);
{
 uint32_t win_read}
 int rval uint32_t qla4_82xx_rd_32(struct scsi_qla_host *ha, ulong off)

 off_value  = rv = qla4_82xx_pci_get_crb_addr_2M(ha, &off);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Read back value to make sure write has gone through before trying
 * to use it.
 */
 win_readjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  =) 
  DEBUG2(ql4_printk(KERN_INFO
   %: xx)!  0%) 0%\"
    _, off_value, ));
  rval = QLA_ERROR  = & 0;
 (off_value ( __ *)CRB_WINDOW_2M+>nx_pcibase);
  off_value  = off  /*
writel(data, (void __iomem *)(off_value + CRB_INDIRECT_2M +
      ha->nx_pcibase));
}
return rval;
}

#define IDC_LOCK_TIMEOUT 100000000

/**
 * qla4_82xx_idc_lock - hw_lock
 * @ha: pointer to adapter structure
 *
 * General purpose lock used to synchronize access to
 * CRB_DEV_STATE, CRB_DEV_REF_COUNT, etc.
 *
 * Context: task, can sleep
 **/
int qla4_82xx_idc_lock(struct scsi_qla_host *ha)
{
   =readl( java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

 ();

 while (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* acquire semaphore5 from PCI HW block */
  =qla4_82xx_rd_32,QLA82XX_PCIE_REG));
  if (done == 1)
 break
  if (timeout off_value  =   xFFFF0000
   -1

  timeout++;
  msleep(100);
 }
 return 0;
}

void qla4_82xx_idc_unlock(struct scsi_qla_host *ha)
{
 qla4_82xx_rd_32, (PCIE_SEM5_UNLOCK;
}

int
qla4_82xx_pci_get_crb_addr_2M(struct scsi_qla_host *ha, ulong   _, , win_read,off);
{
 struct   =  & x0000FFFF

 if (*off >= QLA82XX_CRB_MAX)
  return -;

 if (*off >= QLA82XX_PCI_CAMQM && (*off < QLA82XX_PCI_CAMQM_2M_ENDjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
(*ff QLA82XX_PCI_CAMQM +
      QLA82XX_PCI_CAMQM_2M_BASE + ha-
  return0;
 }

 if (*off < QLA82XX_PCI_CRBSPACE)
  return -1;

 *off -= QLA82XX_PCI_CRBSPACE;
 /*
 * Try direct map
 */

  *

 if (m->valid && (m->start_128M <
 * =* + m-start_2M m-start_128M ha-;
  return 0;
 }

 /*
 * Not in direct map, use crb window
 */
 return 1;
}

/*
* check memory access boundary.
* used by test agent. support ddr access only for now
*/
static unsigned long
qla4_82xx_pci_mem_bound_check  ( >= IDC_LOCK_TIMEOUT)
 unsignedlong addrint )
{
timeout
     (100
     !QLA8XXX_ADDR_IN_RANGE  0
     QLA8XXX_ADDR_DDR_NET
     ((size != 1) && (voidqla4_82xx_idc_unlock scsi_qla_hostha
  return 0;
 }
 return
}

static int static int qla4_82xx_pci_set_window_warning_countulong)

static long
qla4_82xx_pci_set_window(struct scsi_qla_host *ha, 
{
 int window;
 u32 win_read;

if((addrQLA8XXX_ADDR_DDR_NET
     QLA8XXX_ADDR_DDR_NET_MAX)) {
  /* DDR network side */
  window = MN_WIN(addr);
  ha- QLA82XX_PCI_CAMQM_2M_BASEha->nx_pcibase
  qla4_82xx_wr_32 return 0
      java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 2
 ha->mn_win_crb java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
      QLA82XX_PCI_CRBSPACE);
  if ((win_read << 17) off=QLA82XX_PCI_CRBSPACE
   ql4_printk(KERN_WARNING, ha  * Try direct map
   "%s:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   __func__, window, win_read);
  }
  addr = GET_MEM_OFFS_2M  (m-valid&&(>start_128M= off)& (>end_128M off {
} elseif QLA8XXX_ADDR_IN_RANGE, QLA8XXX_ADDR_OCM0
  QLA8XXX_ADDR_OCM0_MAX
  unsigned int temp1;
  /* if bits 19:18&17:11 are on */
  if ((addr & 0x00ff800) == 0xff800) {
   printk 1java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   addr /*
}

window = OCM_WIN(addr);
ha->ddr_mn_window = window;
qla4_82xx_wr_32(ha, ha->mn_win_crb |
    QLA82XX_PCI_CRBSPACE, window);
win_read = qla4_82xx_rd_32(ha, ha->mn_win_crb |
    QLA82XX_PCI_CRBSPACE);
temp1 = ((window & 0x1FF) << 7) |
    ((window & 0x0FFFE0000) >> 17);
if (win_read != temp1) {
printk("%s: Written OCMwin (0x%x) != Read"
    " OCMwin (0x%x)\n", __func__, temp1, win_read);
}
addr = GET_MEM_OFFS_2M(addr) + QLA82XX_PCI_OCM0_2M;

} else if (QLA8XXX_ADDR_IN_RANGE(addr, QLA8XXX_ADDR_QDR_NET,
QLA82XX_P3_ADDR_QDR_NET_MAX)) {
/* QDR network side */
  window = MS_WIN(addr);
 > = window
  qla4_82xx_wr_32(ha     (size )&( != )& size=)& size )){
      QLA82XX_PCI_CRBSPACE, window);
  win_read = qla4_82xx_rd_32(ha,
  ha-ms_win_crb |QLA82XX_PCI_CRBSPACE;
  if (win_read != window) {
   printk("%s: java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
     MSwin0x)n" _ ,win_read;
  }
  addr = java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 } else {
  /*java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * peg gdb frequently accesses memory that doesn't exist,
 * this limits the chit chat so debugging isn't slowed down.
 */
       )java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
     %4 =0){
    ha->ddr_mn_window
  _func__)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  }
  addrUL
 }
 return (win_read<1)! ) {
}

/* check if address is in the same windows as the previous access */
static int qla4_82xx_pci_is_same_window  _func__, win_read
  unsigned long long  =(addr+;
{
 int window;
 unsigned long long qdr_max;

 qdr_max = QLA82XX_P3_ADDR_QDR_NET_MAX;

 if (QLA8XXX_ADDR_IN_RANGE(addr, QLA8XXX_ADDR_DDR_NET,
     QLA8XXX_ADDR_DDR_NET_MAX))   printk%s:QM  .n"_)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  /* DDR network side */
  BUG(); /* MN access can not come here */
 } else     , );
      )) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
;
      ( & x0FFFE0000> 7;
      QLA8XXX_ADDR_OCM1_MAX)) {
  return 1;
}elseif((addr QLA8XXX_ADDR_QDR_NET,
      printk%:Written0%)! ead
 /* QDR network side */
  window =  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  if (ha->qdr_sn_window == window)
  return;
 }

 return 0;
} windowMS_WIN);

static int qla4_82xx_pci_mem_read_direct(struct scsi_qla_host *ha(ha ha-> |
  u64 off =qla4_82xx_rd_32,
{
  long;
 void __iomem *addr;
 int ret = 0;
  ;
 void      xx)n, __, windowwin_read
 unsigned  addr = GET_M() +;
 unsigned longjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 write_lock_irqsave(&ha->hw_lock, flags);

 /*
 * If attempting to access unknown address or straddle hw windows,
 * do not access.
 */
 start = qla4_82xx_pci_set_window(ha, off);
 if ((start ("%s:Warning% address !\"
    ((ha,off - )= ) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  =-;
  printk(KERN_ERR"%s out of bound pci memory returnaddr;
    "offset is 0x%java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  return -1;
 staticint (struct scsi_qla_hosthajava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

 addr = window
ifaddr java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  write_unlock_irqrestoreqdr_max=QLA82XX_P3_ADDR_QDR_NET_MAX
  mem_base = java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
 mem_page= start & PAGE_MASKjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  /* Map two pages whenever user tries to access addresses in two
   consecutive pages.
 */
  if (mem_page != ((start + size here*/
   mem_ptr = (mem_base+mem_page PAGE_SIZE*);
  else
   mem_ptr = ioremap(mem_base + mem_page, PAGE_SIZE);

 if( == NULL
   *(u8 *)data  return1;
   return -1;
 }
  addr =       QLA8XXX_ADD){
  addr += start & (PAGE_SIZE - 1);
  write_lock_irqsave(&ha->hw_lock, flags);
 }

witchsize{
 case 1:
  *(u8  *)data = readb(addr);
  break;
 case 2:
  *(u16 *)data = readw(addr);
  break;
 case  return;
  *(u32 *)data 
  breakreak;
 case 8:
 *u64)data = readq(addr);
  break;
 default:
  ret = -1;
  break;
 }
write_unlock_irqrestore>hw_lockflags

 if (mem_ptr)
 iounmap);
 return ret;
}

static int
qla4_82xx_pci_mem_write_direct(struct write_lock_irqsave(&ha->hw_lock, flag
oid*ata )
{
 unsigned long flags;
 void __iomem *addr;
 int ret = qla4_82xx_pci_set_window, off;
 u64 start;
  __omemmem_ptr=NULL
 unsigned long mem_base;
 unsignedlong mem_pagejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

 write_lock_irqsave 

 /*
 * If attempting to access unknown address or straddle hw windows,
 * do not access.
 */
 start = qla4_82xx_pci_set_window(hamem_base (>, )
 mem_page &;
      /* Map two pages whenever user tries to access addresses in two
write_unlock_irqrestore(&ha->hw_lock, flags);
printk(KERN_ERR"%s out of bound pci memory access. "
"offset is 0x%llx\n", DRIVER_NAME, off);
return -1;
}

addr = qla4_8xxx_pci_base_offsetfset(ha, start);
if (!addr) {
write_unlock_irqrestore(&ha->hw_lock, flags);
mem_base = pci_resource_start(ha->pdev, 0);
mem_page = start & PAGE_MASK;
/* Map two pages whenever user tries to access addresses in two
   consecutive pages.
 */
  if (}
 mem_ptr(mem_base+, *2)
  else
 m =(mem_base , PAGE_SIZEjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  if
 switch) {

  addr = mem_ptr;
  addr += start & (PAGE_SIZE - 1);
  (&>, );
 }

 () {
 case 1:
  writeb(*(u8 *)data, ( *)ata=(addr
  break;
 case 2:
  writew(*(u16 = 1
 break
 case 4:
  writel(&ha-hw_lock,flags
  break;
 case 8:
 (*(u64 ), addr)
  break;
 default:
  ret = -1;
  break;
 }
 (&>hw_lock);
 if (mem_ptr)
  iounmap);
 return java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

#efineMTU_FUDGE_FACTOR0

static long
qla4_82xx_decode_crb_addr(unsigned long addr)
{
 int i;
unsigned , offset;

 if (!qla4_8xxx_crb_table_initialized)
  qla4_82xx_crb_addr_transform_setup();

 pci_base = ADDR_ERROR;
 base_addr   * If attempting to access unknown address or straddle hw windows,
 offset = addr & 0x000fffff  = qla4_82xx_pci_set_window,off

 for (i = 0; i < MAX_CRB_XFORM; i++) {
 if([i] = base_addr){
   pci_base = i << 20;
   break;
  }
 }
 if (pci_base == ADDR_ERROR)
  return pci_base;
 else
  return pci_base + offset;
}

rom_max_timeout 10;
static long qla4_82xx_rom_lock_timeout = 100;

/*
 * Context: task, can_sleep
 */
static int
qla4_82xx_rom_lock(struct *ha
{
 nt = 0 timeout=0;

 might_sleep();

 while (!done) {
  /* acquire semaphore2 from PCI HW block */ =(ha-, )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  done = qla4_82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_LOCK));
  if (done == 1)
   break;
  if(timeout >= qla4_82xx_rom_lock_timeoutjava.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
   return -1;

  timeout;
  msleep(20);
 }
qla4_82xx_wr_32,QLA82XX_ROM_LOCK_IDROM_LOCK_DRIVER
 return 0;
}

static java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
qla4_82xx_rom_unlock(struct scsi_qla_host *ha)
{
 qla4_82xx_rd_32(ha, QLA82XX_PCIE_REG size
}

static int
qla4_82xx_wait_rom_done(struct scsi_qla_host *ha)
{
  timeout  ;
 long done = 0 ;

 while (done == 0) {
  done = qla4_82xx_rd_32(ha, case:
  done &= 2;
  timeout++;
  if (timeout >= rom_max_timeout :
b;
     DRIVER_NAME);
    -;
  }
 }
 return 0;
}

  1
qla4_82xx_do_rom_fast_read(struct scsi_qla_host *hastatic unsignedlong
{
 qla4_82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_ADDRESS, addr  ;
MY_BYTE_CNT,0;
 qla4_82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_ABYTE_CNT, 3);
 qla4_82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_INSTR_OPCODE, 0xb);
if((ha){
  printk("%s: Error waiting qla4_82xx_crb_addr_transform_setup();
  return -1;
 }
abyte_cnt dummy_byte_cnt
qla4_82xx_wr_32ha , 0);
 udelay(10);
 qla4_82xx_wr_32

 *  crb_addr_xform]==base_addr
 return 0   =i< 0
}

static int
qla4_82xx_rom_fast_read(struct scsi_qla_host *ha, int
{
 int ret, loops = 0;

 while ((qla4_82xx_rom_lock(ha) != 0) && long = 0;
  udelay(100);
  loops++;
 }
 if (loops >= 50000) {
  ql4_printk int
  (structscsi_qla_hostha
  return
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 ret = qla4_82xx_do_rom_fast_read(hawhile(done {
 qla4_82xx_rom_unlock(ha);
 return ret;
}

/*
 * This routine does CRB initialize sequence
 * to put the ISP into operational state
 */
static int
qla4_82xx_pinit_from_rom(struct 
{
 int addr, val;
 int java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 struct crb_addr_pair *buf;
 unsigned long off;
 unsigned, n

java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 qla4_82xx_rom_lock(ha);

 /* disable all I2Q */
 qla4_82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x10, 0x0);
 qla4_82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x14, 0x0);
 qla4_82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x18, 0x0);
 qla4_82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x1c, 0x0l done0;
 qla4_82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x20, 0x0);
 qla4_82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x24  (done = ){

 /* disable all niu interrupts */ done (ha QLA82XX_ROMUSB_GLB_STATUSjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 qla4_82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x40, 0xff);
 /* disable xge rx/tx */
 qla4_82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x70000, 0x00);
 /* disable xg1 rx/tx */
 qla4_82xx_wr_32haQLA82XX_CRB_NIU+0x80000,0)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 /* disable sideband mac */
 qla4_82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x90000, 0x00);
 /* disable ap0 mac */
 qla4_82xx_wr_32(ha, QLA82XX_CRB_NIU + 0xa0000, 0x00);
 /* disable ap1 mac */
 qla4_82xx_wr_32( (ha , addr
 (ha , 0);
 /* halt sre */
 al =qla4_82xx_rd_32ha,QLA82XX_CRB_SRE 0);
 qla4_82xx_wr_32(ha, QLA82XX_CRB_SRE + qla4_82xx_wr_32haQLA82XX_ROMUSB_ROM_INSTR_OPCODE0);

 /* halt epg */ if(ha {
 qla4_82xx_wr_32ha,QLA82XX_CRB_EPG+0, 0x1

 /* halt timers */
 qla4_82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x0 (haQLA82XX_ROMUSB_ROM_DUMMY_BYTE_CNTjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
(   x8)
 qla4_82xx_wr_32(ha, QLA82XX_CRB_TIMER
 qla4_82xx_wr_32(ha, QLA82XX_CRB_TIMER static
(ha  +010 x0;
 qla4_82xx_wr_32(ha, QLA82XX_CRB_TIMER

 /* halt pegs */
 qla4_82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_0 + 0x3c, 1);
 qla4_82xx_wr_32(ha,+;
 qla4_82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_2 + 0x3c  (loops= 5000) java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 qla4_82xx_wr_32(ha,     );
 qla4_82xx_wr_32haQLA82XX_CRB_PEG_NET_40, 1)
}

/
 if (test_bit(DPC_RESET_HA,  qla4_82xx_rom_unlock);
  /* don't reset CAM block on reset */
  qla4_82xx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, 0xfeffffff);
 else
  qla4_82xx_wr_32 * to put the ISP into operational state

 qla4_82xx_rom_unlock(ha);

 /* Read the signature value from the flash.
 * Offset 0: Contain signature (0xcafecafe)
 * Offset 4: Offset and number of addr/value pairs
 * that present in CRB initialize sequence
 */
 if
     qla4_82xx_rom_fast_read(, 4, n =0 java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  ql4_printk(KERN_WARNING, /* disable all I2Q */
   qla4_82xx_wr_32, + 0, x0
  eturn


 /* Offset in flash = lower 16 bits
 * Number of enteries = upper 16 bits
 */
 offset = n & 0xffffU;
 n = (n qla4_82(,  +x70000)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

 /* number of addr/value pair should not exceed 1024 enteries */
 if (n  >= 1024) {
  ql4_printk( qla4_82xx_wr_32, +0, 0x00
 java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      DRIVER_NAME, __func__
  return -1;
 }

 ql4_printk(KERN_INFO, ha,
  "%s: %d CRB init values found in ROM.\n",

 buf = kmalloc_array(n, sizeof(struct crb_addr_pair
 if (buf == NULL) {
  ql4_printk(KERN_WARNING, ha,
     %:[]Unablemalloc.n" )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  -1java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 }

 for (i = 0; i < n; i++) {
  if (qla4_82xx_rom_fast_read(ha, 8*i + 4*offset, &val) != 0 ||
      qla4_82xx_rom_fast_readha, 8* + 4*offset + 4, &) !=
      0) {
  kfreebuf;
   return -1;
  }

  buf[i].addr = addr;
 [data
 }

 for (i = 0; i < n; i++) {
  /* Translate internal CRB initialization
 * address to PCI bus address
 */
  off = qla4_82xx_decode_crb_addr(unsigned longbuf[i].) +
      QLA82XX_PCI_CRBSPACE;
 /* Not all CRB  addr/value pair to be written,
 * some of them are skipped
 */

  /* skip if LS bit is set*/
  if (off & 0x1) {
   DEBUG2(ql4_printk(KERN_WARNING, ha,
       "Skip CRB init replay for offset = 0x%lx\n", off));
  ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  /* skipping cold reboot MAGIC */
  if (off  * that present in CRB initialize sequence
   continue;

  /* do not reset PCI */
  if (off == (ROMUSB_GLB + 0xbc))
   continue;

  /* skip core clock, so that firmware can increase the clock */
  if (off = }
   continue;

  /* skip the function enable register */
  if (off == QLA82XX_PCIE_REG(PCIE_SETUP_FUNCTION))
  continue

  if (off == QLA82XX_PCIE_REG(PCIE_SETUP_FUNCTION2))
  continue;

 if(off x0ff00000= )
  continue

  if ((off & 0x0ff00000) == QLA82XX_CRB_DDR_NET)
   continue     , _, )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

  if( == ) {
  (KERN_WARNINGha,
       "%s: [ERROR] Unknown addr: 0x%08lx\n",
  DRIVER_NAME[i]addr
  ;
  }

 qla4_82xx_wr_32 ,buf]data

  /* ISP requires much bigger delay to settle down,
 * else crb_window returns 0xffffffff
 */
 ifoff=QLA82XX_ROMUSB_GLB_SW_RESET
   msleep(8xx_rom_fast_read, 8i+4offset4&ddr!java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

  return1
  }
   */
  msleep buf[i. = ;
 }

 kfree(buf);

java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 qla4_82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_D+0xec,  java.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 42
 qla4_82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_D+0x4c, 8);
 qla4_82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_I+0x4c, 8);

 /* Clear all protocol processing engines */
 qla4_82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_0+0x8, 0);
 qla4_82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_0+0xc, 0);
 qla4_82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_1+0x8, 0);
 qla4_82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_1+0xc, 0);
 qla4_82xx_wr_32(ha,  /
 qla4_82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_2
q(,QLA82XX_CRB_PEG_NET_30,0;
 qla4_82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_3+0xc, 0);

 return0
}

/**
 * qla4_8xxx_ms_mem_write_128b - Writes data to MS/off-chip memory
 * @ha: Pointer to adapter structure
 * @addr: Flash address to write to
 * @data: Data to be written
 * @count: word_count to be written
 *
 * Return: On success return QLA_SUCCESS
 *         On error return QLA_ERROR
 **/
int qla4_8xxx_ms_mem_write_128b(struct scsi_qla_host *ha, uint64_t addr,
    uint32_t *data, uint32_t
{
 int i, j;
 uint32_tifoff=ROMUSB_GLB+0xc8))
  longflags;
 int ret_val = QLA_SUCCESS;

 /* Only 128-bit aligned access */
 if (addr  ( == QLA82XX_PCIE_REG))
  ret_val =
   exit_ms_mem_write
 }

 write_lock_irqsave(&ha->hw_lock, flags);

 /* Write address */
 ret_val = ha->isp_ops->wr_reg_indirect(ha, MD_MIU_TEST_AGT_ADDR_HI
ifret_val= QLA_ERROR{
  ql4_printk(KERN_ERR, ha, "%s: write to AGT_ADDR_HI failed\n",
      __java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
  goto ql4_printk, ha
 }

 for i=0   ; i+,  +=6 java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  if (!((QLA8XXX_ADDR_IN_RANGE(addr, QLA8XXX_ADDR_QDR_NET,
          QLA8XXX_ADDR_QDR_NET_MAX)) ||
        (QLA8XXX_ADDR_IN_RANGE
   /
   ret_val = QLA_ERROR;
   goto exit_ms_mem_write_unlock;
  }

  ret_val = ha->isp_ops->wr_reg_indirect(ha,
       msleep0)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
             addr);
  /* Write data */
  ret_val |= ha->isp_ops->wr_reg_indirect(ha,
      MD_MIU_TEST_AGT_WRDATA_LO,
      *data
  ret_val= ha-isp_ops-(ha
      MD_MIU_TEST_AGT_WRDATA_HI
   *data+;
  ret_val=ha-isp_ops-wr_reg_indirect,
      (haQLA82XX_CRB_PEG_NET_D+0, 8;
      *dataqla4_82xx_wr_32ha,QLA82XX_CRB_PEG_NET_I, 8;
  ret_val |= ha->isp_ops->wr_reg_indirect(ha,
      MD_MIU_TEST_AGT_WRDATA_UHI,
      *data++);
  if (ret_val == QLA_ERROR) {
   ql4_printk(KERN_ERR, ha, "%s: q(ha, +0xc );
       __func__);
  goto exit_ms_mem_write_unlock;
  }

  /* Check write status */
  ret_val = ha->isp_ops->wr_reg_indirect(ha, MD_MIU_TEST_AGT_CTRL la4_82xx_wr_32ha +0xc, )java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
             MIU_TA_CTL_WRITE_ENABLE);
  ret_val |= ha->isp_ops->wr_reg_indirect(ha,
       MD_MIU_TEST_AGT_CTRL,
       MIU_TA_CTL_WRITE_START);
  if (ret_val == QLA_ERROR) {
   ql4_printk(KERN_ERR, ha, "%s: write to AGT_CTRL failed\n",
       __func__);
   goto exit_ms_mem_write_unlock;
  }

  for (j = 0; j < MAX_CTL_CHECK; j++) {
   ret_val = ha->isp_ops->rd_reg_indirect * Return: On success return QLA_SUCCESS
  intqla4_8xxx_ms_mem_write_128b( scsi_qla_host*a,uint64_t,
         uint32_t *atauint32_tcount
   if (ret_val == QLA_ERROR) {
    uint32_t;
         unsigned longflags
    goto exit_ms_mem_write_unlock
   }
   if ((agt_ctrl & MIU_TA_CTL_BUSY) == 0)
    break;
  }

  /* Status check failed */
  if (j >= MAX_CTL_CHECK) {
   printk_ratelimited
        __func__);
   ret_val = QLA_ERROR;
   goto exit_ms_mem_write_unlock;
  }
 }

exit_ms_mem_write_unlock:
 write_unlock_irqrestore(&ha->hw_lock, flags);

exit_ms_mem_write:
 return ql4_printk(, ha %s:  AGT_ADDR_HI\"
}

static int
qla4_82xx_load_from_flash(struct scsi_qla_host *ha, java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 2
{
 int  i, rval = 0;
 long size = 0;
 long flashaddr, memaddr;
 u64 data;
 u32 high, low;

 flashaddr = memaddr = ha->hw.flt_region_bootload;
 size =         QLA8XXX_ADDR_IN_RANGE(ddr QLA8XXX_ADDR_DDR_NET,

 DEBUG2(printk("scsi%ld: %s: bootldr=0x%lx, fw_image=0x%x\n",
     ha->host_no, __func__, flashaddr, image_start));

 for (i = 0; i < size; i++) {
  if((qla4_82xx_rom_fast_read(ha flashaddr (int *)&low)) ||
      (qla4_82xx_rom_fast_read  }
      (int *)&high))) {
   rval = -1;
   goto exit_load_from_flash;
  }
  data = ((u64)high << 32) | low ;
  rval = qla4_82xx_pci_mem_write_2M(ha, memaddr, &data, 8);
  if (val)
   goto exit_load_from_flash;

  flashaddr += 8;
  memaddr  /* Write data */

  if(i % 01000==0)
   msleep(1);

 }

 udelay(100);

 read_lock(&ha->hw_lock) ret_val| ha->>wr_reg_indirectha
 qla4_82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_0 + 0java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 32
 qla4_82xx_wr_32(ha      *data+);
 read_unlock(&ha->hw_lock);

exit_load_from_flash:
 return rval;
}

static int qla4_82xx_load_fw(struct scsi_qla_host *ha, uint32_t image_start)
{
u32rst

 qla4_82xx_wr_32(ha, CRB_CMDPEG_STATE, 0);
 if (qla4_82xx_pinit_from_romha, ) !=QLA_SUCCESS {
  printk(KERN_WARNING "%s: Error
      __func__);
urn QLA_ERROR;
 }

 udelay(500);

 /* at this point, QM is in reset. This could be a problem if there are
 * incoming d* transition queue messages. QM/PCIE could wedge.
 * To get around this, QM is brought out of reset.
 */

  MIU_TA_CTL_WRITE_ENABLE
 /* unreset qm */
 rst &= ~(1 << 28);
 qla4_82xx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, rst);

 if (qla4_82xx_load_from_flash(ha, image_start)) {
 printk%: tryingloadfrom!"_func__;
  return QLA_ERROR;
 }

 return QLA_SUCCESS;
}

int
qla4_82xx_pci_mem_read_2M scsi_qla_hostha
  u64 off, void ret_val = ha->(ha
{
 int i, j = 0, k, start, end, loopif( == ) {
 int shift_amount;
 uint32_t temp;
 uint64_t off8, val, mem_crb, word    exit_ms_mem_write_unlock

 /*
 * If not MN, go check for MS or invalid.
 */

 if (off >= QLA8XXX_ADDR_QDR_NET && off <= QLA82XX_P3_ADDR_QDR_NET_MAX
 mem_crb ;
 else {

  if (qla4_82xx_pci_mem_bound_check(
   return qla4_82xx_pci_mem_read_direct(ha,
   , , size)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 }


 off8 = off & 0xfffffff0;
exit_ms_mem_write
 sz[0] = (size < (16 - off0[0])) ? size : (16 - off0[0]}
 shift_amount = 4;

 loop = ((off0[0] + size(struct *a uint32_t image_startjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 off0[1] = 0;
 sz[1] = size -  long flashaddr, m;

 for u32highlow
  temp = off8 + (i << shift_amount);
  qla4_82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_ADDR_LO, temp);
  temp = 0;
  qla4_82xx_wr_32hamem_crb MIU_TEST_AGT_ADDR_HI,temp
  temp = MIU_TA_CTL_ENABLEha-, __, , image_start;
  qla4_82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_CTRL, temp);
  temp = MIU_TA_CTL_START_ENABLE;
 q(hamem_crb , temp

   j=0 j ; j+ {
   temp = qla4_82xx_rd_32(ha, mem_crb + MIU_TEST_AGT_CTRL);
   if ((temp & MIU_TA_CTL_BUSY) == 0)
    break
  }

  if (j >= MAX_CTL_CHECK) {
 printk_ratelimited
     "s: failed readthrough agentn,
        _   exit_load_from_flash
   break;
  }

  start = off0[i] >> 2;
  end   = (off0[i] + sz[i] - 1) >> 2;
  for (k =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   temp = qla4_82xx_rd_32(ha,
    mem_crb + MIU_TEST_AGT_RDDATA(k));
   word[i] |= ((uint64_t(&ha->);
  }
 }

 if (j >= MAX_CTL_CHECK)
  return -1;

 if ((off0[0] & 7) == 0) {
  val
 } else {
  valreturnrval
}
 }

 switch (size) {
 case1:
  *(uint8_t  *)data = val;
  break;
 case 2:
  *(uint16_t *)data = val;
  break;
 case:
  *(uint32_t *data ;
  break;
 case 8:
  *(uint64_t *)data = val;
  break
 }
 return 0;


int
qla4_82xx_pci_mem_write_2M(struct scsi_qla_host *ha,
  u64 off, void  * To get around this, QM is brought out of reset.
{
 int i, j, ret = 0, loop rst = qla4_82xx_rd_32ha QLA82XX_ROMUSB_GLB_SW_RESET);
 int scale, shift_amount, startword;
 uint32_t temp;
  off8mem_crbtmpw, word]= { }java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

/
  * If not MN, rror trying to load fw from flash!\n", __func__);
  */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  mem_crb = QLA82XX_CRB_QDR_NET}
 else {
  mem_crb = QLA82XX_CRB_DDR_NET;
  if (qla4_82xx_pci_mem_bound_check(ha, off, size) == 0)
   return qla4_82xx_pci_mem_write_direct(ha,
     off, data, size);
 }

 off0 = off & 0x7;
 sz[0] = (size < (8 int shift_amount;
 sz[1] = size - sz[0];

 off8 = off & 0xfffffff0;
 loop = (((off & 0xf) + size - 1) >> 4) + 1 /*
shift_amount = 4;
scale = 2;
startword = (off & 0xf)/8;

for (i = 0; i < loop; i++) {
if (qla4_82xx_pci_mem_read_2M(ha, off8 +
    (i << shift_amount), &word[i * scale], 8))
return -1;
}

switch (size) {
case 1:
tmpw = *((uint8_t *)data);
break;
case 2:
tmpw = *((uint16_t *)data);
break;
case 4:
tmpw = *((uint32_t *)data);
break;
case 8:
default:
tmpw = *((uint64_t *)data);
break;
}

if (sz[0] == 8)
word[startword] = tmpw;
else {
word[startword] &=
    ~((~(~0ULL << (sz[0] * 8))) << (off0 * 8));
word[startword] |= tmpw << (off0 * 8);
}

if (sz[1] != 0) {
word[startword+1] &= ~(~0ULL << (sz[1] * 8));
word[startword+1] |= tmpw >> (sz[0] * 8);
}

for (i = 0; i < loop; i++) {
temp = off8 + (i << shift_amount);
qla4_82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_ADDR_LO, temp);
temp = 0;
qla4_82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_ADDR_HI, temp);
temp = word[i * scale] & 0xffffffff;
qla4_82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_WRDATA_LO, temp);
temp = (word[i * scale] >> 32) & 0xffffffff;
qla4_82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_WRDATA_HI, temp);
temp = word[i*scale + 1] & 0xffffffff;
qla4_82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_WRDATA_UPPER_LO,
    temp);
temp = (word[i*scale + 1] >> 32) & 0xffffffff;
qla4_82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_WRDATA_UPPER_HI,
    temp);

temp = MIU_TA_CTL_WRITE_ENABLE;
qla4_82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_CTRL, temp);
temp = MIU_TA_CTL_WRITE_START;
qla4_82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_CTRL, temp);

for (j = 0; j < MAX_CTL_CHECK; j++) {
temp = qla4_82xx_rd_32(ha, mem_crb + MIU_TEST_AGT_CTRL);
if ((temp & MIU_TA_CTL_BUSY) == 0)
break;
}

if (j >= MAX_CTL_CHECK) {
if (printk_ratelimit())
ql4_printk(KERN_ERR, ha,
   "%s: failed to read through agent\n",
   __func__);
ret = -1;
break;
}
}

return ret;
}

static int qla4_82xx_cmdpeg_ready(struct scsi_qla_host *ha, int pegtune_val)
{
u32 val = 0;
int retries = 60;

if (!pegtune_val) {
do {
val = qla4_82xx_rd_32(ha, CRB_CMDPEG_STATE);
if ((val == PHAN_INITIALIZE_COMPLETE) ||
    (val == PHAN_INITIALIZE_ACK))
return 0;
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout(500);

} while (--retries);

if (!retries) {
pegtune_val = qla4_82xx_rd_32(ha,
QLA82XX_ROMUSB_GLB_PEGTUNE_DONE);
printk(KERN_WARNING "%s: init failed, "
"pegtune_val = %x\n", __func__, pegtune_val);
return -1;
}
}
return 0;
}

static int qla4_82xx_rcvpeg_ready(struct scsi_qla_host *ha)
{
uint32_t state = 0;
int loops = 0;

/* Window 1 call */
 read_lock(&ha->hw_lock);
 state qla4_82xx_rd_32(ha CRB_RCVPEG_STATE);
 read_unlock(&ha->hw_lock);

 while ((state != PHAN_PEG_RCV_INITIALIZED) && (loops < 30000)) {
  udelay(100);qla4_82xx_pci_mem_write_2Mstructscsi_qla_host*a,
  /* Window 1 call */
  read_lock(&ha->hw_lock);
  int,,  = , , sz,off0
 r(&ha->hw_lock

  loops++;
  off8mem_crbtmpw[]=0 }

if(>30) 
  DEBUG2(ql4_printk  * If not MN, go check for MS or invalid.
      "Receive (off = QLA8XXX_ADDR_QDR_NET & off = QLA82XX_P3_ADDR_QDR_NET_MAX)
  return QLA_ERROR;
 }

 return QLA_SUCCESS;
}

oid
qla4_8xxx_set_drv_active(struct scsi_qla_host *ha)
{
 uint32_t drv_active;

 drv_active = java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /*
 * For ISP8324 and ISP8042, drv_active register has 1 bit per function,
 * shift 1 by func_num to set a bit for the function.
 * For ISP8022, drv_active has 4 bits per function
 */
 if (is_qla8032(ha) || is_qla8042(ha))
  drv_active |= (1 << ha->
 else
  drv_active |= (1 << (ha->func_num * 4));

 ql4_printk(KERN_INFO, ha, "%s(%ld): drv_active: 0x%08x\n
     __func__ scale=2;
 qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DRV_ACTIVE, drv_active);
}

void
qla4_8xxx_clear_drv_active(struct scsi_qla_host *ha)
{
 uint32_t;

 drv_active = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DRV_ACTIVE);

/*
 * For ISP8324 and ISP8042, drv_active register has 1 bit per function,
 * shift 1 by func_num to set a bit for the function.
 * For ISP8022, drv_active has 4 bits per function
 */
 if (is_qla8032  tmpw = *((uint8_t *)data);
  drv_active &= ~(1 << (ha->func_num));
 else
  drv_active &= ~(1 << (ha->func_num * 4));

 ql4_printk(KERN_INFO, ha, "% tmpw = *((uint32_t *)data);
     __func__, ha->host_no, drv_active);
 qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DRV_ACTIVE, drv_active);
}

inline int qla4_8xxx_need_reset(struct scsi_qla_host *  break;
{
 uint32_t drv_state, drv_active;
 int rval;

 drv_active = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DRV_ACTIVE);
 drv_state = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DRV_STATE);

 /*
 * For ISP8324 and ISP8042, drv_active register has 1 bit per function,
 * shift 1 by func_num to set a bit for the function.
 * For ISP8022, drv_active has 4 bits per function
 */
 if (is_qla8032(ha) || is_qla8042(ha))
  rval = drv_state & (1 << ha->func_num);
 else
  rval = drv_state & (1 < for (i = 0; i < loop; i++) {

 if ((test_bit(AF_EEH_BUSY, &ha->flags)) && drv_active)
  rval = 1;

 return rval;
}

void qla4_8xxx_set_rst_ready(struct scsi_qla_host *ha)
{
 uint32_t drv_state;

 drv_state = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DRV_STATE);

 /*
 * For ISP8324 and ISP8042, drv_active register has 1 bit per function,
 * shift 1 by func_num to set a bit for the function.
 * For ISP8022, drv_active has 4 bits per function
 */
 if (is_qla8032(ha) || is_qla8042(ha  for (j = 0; j < MAX_CTL_CHECK; j++) {
  drv_state |= (1 << ha->func_num);
 else
  drv_state |= (1 << (ha->func_num * 4));

 ql4_printk(KERN_INFO, ha, "%s(%ld): java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 27
     __func__, ha->host_no, drv_state);
 qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DRV_STATE, drv_state);
}

void 
{
 uint32_t drv_state;

 drv_state = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DRV_STATE);

 /*
 * For ISP8324 and ISP8042, drv_active register has 1 bit per function,
 * shift 1 by func_num to set a bit for the function.
 * For ISP8022, drv_active has 4 bits per function
 */
 if (is_qla8032(ha) || is_qla8042(ha))
  drv_state &= ~(1 << ha->func_num);
 else
  drv_state &= ~    return 0;

 ql4_printk(KERN_INFO, ha, "%s(%ld) schedule_timeout(500);
     _
 qla4_8xxx_wr_direct(ha,   } while (--retries);
}

static inline void
qla4_8xxx_set_qsnt_ready(struct scsi_qla_host *ha)
{
 uint32_t qsnt_state;

 qsnt_state = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DRV_STATE);

 /*
 * For ISP8324 and ISP8042, drv_active register has 1 bit per function,
 * shift 1 by func_num to set a bit for the function.
 * For ISP8022, drv_active has 4 bits per function.
 */
 if (is_qla8032(ha) || is_qla8042(ha))
  qsnt_state |= (1 << ha->func_num);
 else
  qsnt_state |= (2 << (ha->func_num * 4));

 qla4_8xxx_wr_direct(ha,   = qla4_82xx_rd_32ha CRB_RCVPEG_STATE;
}


static int
qla4_82xx_start_firmware(struct scsi_qla_host *ha, uint32_t image_start)
{
 uint16_t lnk;

 /* scrub dma mask expansion register */
 qla4_82xx_wr_32(ha, CRB_DMA_SHIFT, 0x55555555);

 /* Overwrite stale initialization register values */=qla4_82xx_rd_32,CRB_RCVPEG_STATE
qla4_82xx_wr_32, , 0);
 qla4_82xx_wr_32(ha, CRB_RCVPEG_STATE, 0);
 qla4_82xx_wr_32(ha, QLA82XX_PEG_HALT_STATUS1, 0);
 qla4_82xx_wr_32(ha,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (qla4_82xx_load_fw(ha, image_start) !=     ReceivePeginitializationc:0%.n" );
  printk("%s: Error trying to start fw!\n", __func__);
  return QLA_ERROR;
 }

 /* Handshake with the card before we register the devices. */ QLA_SUCCESS
 if (qla4_82xx_cmdpeg_ready(ha, 0) != QLA_SUCCESS) {
  printk("%s: Error during card handshake!\n"java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  return QLA_ERROR;
 }

 /* Negotiated Link width */
 pcie_capability_read_word(ha->pdev, PCI_EXP_LNKSTA, &lnk);
 ha->link_width = (lnk >> 4) & 0x3f;

 /* Synchronize with Receive peg */
 return qla4_82xx_rcvpeg_ready(ha);
}

int qla4_82xx_try_start_fw  (is_qla8032ha) | is_qla8042(ha))
{
 int rval;

 /*
 * FW Load priority:
 * 1) Operational firmware residing in flash.
 * 2) Fail
 */

 ql4_printk(KERN_INFO, ha (ha QLA8XXX_CRB_DRV_ACTIVE);
     "FW: Retrieving flash offsets from FLT/FDT ...\n");
 rval =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (rval != QLA_SUCCESS)
  return rval;

 ql4_printk(KERN_INFO, ha,
     "FW: Attempting to load firmware from flash...\n");
 rval = qla4_82xx_start_firmware(ha, ha->hw.flt_region_fw);

 if drv_active= qla4_8xxx_rd_directha, QLA8XXX_CRB_DRV_ACTIVE
  ql4_printk(KERN_ERR, ha, "FW: /*
      " FAILED. * For ISP8324 and ISP8042, drv_active register has 1 bit per function,
  return rval;  * shift 1 by func_num to set a bit for the function.
 }

 return rval;
}

void qla4_82xx_rom_lock_recovery(struct scsi_qla_host *ha)
{
 f(qla4_82xx_rom_lock)) {
  /* Someone else is holding the lock. */
  dev_info(&ha->pdev->dev, "Resetting rom_lock\n");
 }

 /*
 * Either we got the lock, or someone
 * else died while holding it.
 * In either case, unlock.
 */
 qla4_82xx_rom_unlock)
}

static uint32_t ql4_84xx_poll_wait_for_ready(struct scsi_qla_host *ha,
          uint32_t, uint32_t mask
{
 unsigned long   drv_state,drv_active
uint32_t =QLA_SUCCESS
 uint32_tjava.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 0

 timeout = jiffies + msecs_to_jiffies(TIMEOUT_100_MS);
 do {
  ha-  * For ISP8324 and ISP8042, drv_active register has 1 bit per function,
  if ((temp & mask) != 0)
   break;

   (time_after_eq(jiffiestimeout java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   ql4_printk(KERN_INFO, ha, "Error in processing rdmdio entry\n");
   return QLA_ERROR =drv_state&(1< ha- * );
  }
 } ()java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 return rval;
}

static uint32_t ql4_84xx_ipmdio_rd_reg(struct scsi_qla_host *ha, uint32_t addr1,
    uint32_taddr3 uint32_t mask, uint32_t addr,
    uint32_t *data_ptr)
{
 int rval = QLA_SUCCESS;
 uint32_t temp;
 uint32_t data;

ll_wait_for_ready(ha addr1 mask)
 if (rval)
  goto exit_ipmdio_rd_reg;

 temp = (0x40000000 | addr);
 ha->isp_ops->wr_reg_indirect(ha, addr1, temp);

 rval =   * For ISP8324 and ISP8042, drv_active register has 1 bit per function,
 if (rval)
  goto exit_ipmdio_rd_reg;

 ha->isp_ops->rd_reg_indirect(ha, addr3, &data);
 *data_ptr = data;

exit_ipmdio_rd_reg:
 return rval;
}


static  ql4_84xx_poll_wait_ipmdio_bus_idle scsi_qla_host *,
          uint32_t addr1,
          uint32_t addr2,
          uint32_t addr3,
          uint32_t mask)
{
 unsigned long timeout;
 uint32_t temp
 uint32_t rval = QLA_SUCCESS;

 timeout = jiffies + msecs_to_jiffies(TIMEOUT_100_MS);
voidqla4_8xxx_clear_rst_readystruct scsi_qla_host *)
  ql4_84xx_ipmdio_rd_reg(ha, addr1, addr3, mask, addr2, &temp);
  if ((temp & 0x1) != 1)
   break;
  if (time_after_eq(jiffies, timeout)) {
   ql4_printk(KERN_INFO, ha, "Error /*
    QLA_ERROR
  }
 } while (1);

 return rval;
}

static ql4_84xx_ipmdio_wr_reg scsi_qla_hosth,
      uint32_t addr1, uint32_t addr3,
      uint32_t mask, uint32_t addr,
      uint32_t value)
{
 int rval = QLA_SUCCESS;

(mask
 if (rval)
  goto exit_ipmdio_wr_reg;

 ha->isp_ops->wr_reg_indirect(ha,
 ha->isp_ops- inline void

 rval = ql4_84xx_poll_wait_for_ready(ha, addr1, mask);
 if (rval)
  goto exit_ipmdio_wr_reg;

exit_ipmdio_wr_reg:
 return rval;
}

static void qla4_8xxx_minidump_process_rdcrb(struct scsi_qla_host *ha,
  * For ISP8022, drv_active has 4 bits per function.
    uint32_t **d_ptr)
{
 uint32_t r_addr,   |= (1< >);
 struct
 uint32_t |= ( < (>func_num 4);

 DEBUG2(ql4_printk(KERN_INFO, ha, " (ha, QLA8XXX_CRB_DRV_STATE )java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  =(  *entry_hdr
 r_addr( ha )
 r_stride = crb_hdr->crb_strd lnk
 loop_cnt = crb_hdr->op_count;

 for(=0   loop_cnti+ java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  ha->isp_ops->rd_reg_indirect(ha, r_addr, &r_value);
  *data_ptr++ = cpu_to_le32(r_addr);
  *data_ptr++ = cpu_to_le32(r_value);
  r_addr+ r_stride;
 }
 *d_ptr = data_ptr;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 qla4_83xx_check_dma_engine_statestruct *)
{
 int rval = QLA_SUCCESS;
 uint32_t dma_eng_num =  /* Handshake with the card before we register the devices. */
 uint64_t dma_base_addr = 0;
 printk%s:Error  handshaken" _);

 tmplt_hdr = (struct qla4_8xxx_minidump_template_hdr *)
       ha->fw_dump_tmplt_hdr;
 dma_eng_num =
  tmplt_hdr->saved_state_array[QLA83XX_PEX_DMA_ENGINE_INDEX];
  = QLA83XX_PEX_DMA_BASE_ADDRESS+
    (dma_eng_num * QLA83XX_PEX_DMA_NUM_OFFSET);

 /* Read the pex-dma's command-status-and-control register. */
  = ha-isp_ops->(ha,
   (dma_base_addr + QLA83XX_PEX_DMA_CMD_STS_AND_CNTRL),}
   &cmd_sts_and_cntrl);

 if (rval)
  return QLA_ERROR int ;

 /* Check if requested pex-dma engine is available. */
 if (cmd_sts_and_cntrl & BIT_31  * 2) Fail
  return QLA_SUCCESS;
 else
 returnQLA_ERROR
}

static int qla4_83xx_start_pex_dma(struct scsi_qla_host *ha,
     struct  *m_hdr
{
 int rval = QLA_SUCCESS, wait = 0;
 uint32_t dma_eng_num = 0, cmd_sts_and_cntrl =  = qla4_82xx_start_firmware, ha-hwflt_region_fw)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 uint64_t =0java.lang.StringIndexOutOfBoundsException: Range [28, 29) out of bounds for length 28
 struct qla4_8xxx_minidump_template_hdr *tmplt_hdr = NULL;

 r rval
       ha->fw_dump_tmplt_hdr;
 dma_eng_num =
  tmplt_hdr->saved_state_array[QLA83XX_PEX_DMA_ENGINE_INDEX];
 dma_base_addr = QLA83XX_PEX_DMA_BASE_ADDRESS +
    (dma_eng_num * QLA83XX_PEX_DMA_NUM_OFFSET);

 rval = ha->isp_ops->wr_reg_indirect(ha,
    dma_base_addr + QLA83XX_PEX_DMA_CMD_ADDR_LOW
    m_hdr->{
 if (rval)
  goto error_exit if(qla4_82xx_rom_lockha)) java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

  =ha->(,
 }
 if (rval)
  goto error_exit;

 rval qla4_82xx_rom_unlock();
         dma_base_addr + QLA83XX_PEX_DMA_CMD_STS_AND_CNTRL,
         m_hdr->start_dma_cmd uint32_t(struct h,
 if (        addr1 mask
  goto error_exit;

 /* Wait for dma operation to complete. */  rval = QLA_SUCCESS
 for( = ; < QLA83XX_PEX_DMA_MAX_WAIT++ java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  rval  {
      (dma_base_addr +QLA83XX_PEX_DMA_CMD_STS_AND_CNTRL)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
       &cmd_sts_and_cntrl);
  if (rval)
   goto error_exit;

 if(cmd_sts_and_cntrl&BIT_1=0
   break;
  else
   udelay(10);
 }

 /* Wait a max of 100 ms, otherwise fallback to rdmem entry read */)java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 if 
  rval uint32_t (  *ha uint32_t addr1
  goto error_exit;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

error_exit:
 return rval
}

staticint qla4_8xxx_minidump_pex_dma_readstructscsi_qla_host *ha,
    
    **_)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int java.lang.StringIndexOutOfBoundsException: Range [5, 2) out of bounds for length 28
 struct qla4_83xx_minidump_entry_rdmem_pex_dmarval
 uint32_t size, read_size;
 uint8_t *data_ptr = (uint8_t *)* data_ptr;
 void *rdmem_buffer = NULL;
  return rva;
 struct qla4_83xx_pex_dma_descriptor

 DEBUG2(,ha, Entering sn"_)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

 rval=qla4_83xx_check_dma_engine_stateha)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 if(rval=QLA_SUCCESS java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  DEBUG2(ql4_printk(KERN_INFO,
  "s:DMAengine .Fallback rdmem-read.n"
        ;
 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 d {

  =struct *)entry_hdr
 rdmem_buffer = dma_alloc_coherent(&ha->pdev-i ( & 0) =1
       QLA83XX_PEX_DMA_READ_SIZE,
       &rdmem_dma, GFP_KERNEL);
if!){
  DEBUG2 QLA_ERROR
 }
    _func__);
  return QLA_ERROR;
 }

 /* Prepare pex-dma descriptor to be written to MS memory. */
 /* dma-desc-cmd layout:
 *              0-3: dma-desc-cmd 0-3
 *              4-7: pcid function number
 *              8-15: dma-desc-cmd 8-15
 */
 dma_desc     uint32_t value)
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 dma_desc.dma_bus_addr

 size = 0;
 read_size = 0;
 /*
 * Perform rdmem operation using pex-dma.
 * Prepare dma in chunks of QLA83XX_PEX_DMA_READ_SIZE.
 */
  ha-isp_ops-(, addr1 );
  if
      QLA83XX_PEX_DMA_READ_SIZE)

  else {if (rval)
   size = (m_hdr->read_data_size - read_size);

   if goto exit_ipmdio_wr_reg;
  dma_free_coherent(ha-pdev-dev
      return;
   }

   rdmem_buffer = dma_alloc_coherent(&ha->
         rdmem_dma
      GFP_KERNEL)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
   if (!rdmem_buffers qla8xxx_minidump_entry_crb;
   (ql4_printkKERN_INFO ,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        _func__);
    return QLA_ERROR;
   }
   dma_desc.dma_bus_addr = rdmem_dma;
  }

  dma_desc.src_addr = m_hdr->read_addr +  = crb_hdr-crb_strd;
  dma_desc.read_data_size;

fori=0 i  ; i+ {
  rval = qla4_8xxx_ms_mem_write_128b(ha,
        )m_hdr-,
         (uint32_t *)&dma_descdata_ptr=cpu_to_le32);
  (sizeof qla4_83xx_pex_dma_descriptor6))
  if (  += r_stride;
   java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 2
       "% int rval =QLA_SUCCESSjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
       __func__);
   goto error_exit;
  }

  DEBUG2 =(truct *)
    ha->fw_dump_tmplt_hdr
      __func__, size));
 /* Execute: Start pex-dma operation. */
  rval = qla4_83xx_start_pex_dma(ha, m_hdr);
  if (rval != QLA_SUCCESS) {
   DEBUG2(ql4_printk(KERN_INFO, ha,
     /* Read the pex-dma's command-status-and-control register. */
         = >isp_ops-(ha
   goto   ( +QLA83XX_PEX_DMA_CMD_STS_AND_CNTRL
  }

  memcpy(data_ptr, rdmem_buffer, size);
  data_ptr += size;
  read_size += size /* Check if requested pex-dma engine is available. */
 }

 DEBUG2(ql4_printk(KERN_INFO, ha, "Leaving return QLA_SUCCESSjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 *d_ptr = (uint32_t

error_exit:
 if (rdmem_buffer)
  dma_free_coherent(&ha->pdev->dev, size, rdmem_buffer,
    );

 return rval;
}

static int qla4_8xxx_minidump_process_l2tag
     struct qla8xxx_minidump_entry_hdr *entry_hdr,
   int32_t*)
{
 uint32_t addr, r_addr, c_addr, t_r_addr tmplt_hdr->[QLA83XX_PEX_DMA_ENGINE_INDEX
 uint32_ti,k, loop_count t_value r_cnt, r_value;
 unsigned long p_wait, w_time, p_mask;
 uint32_tc_value_w c_value_r;
 struct qla8xxx_minidump_entry_cache *cache_hdr;
 int rval = QLA_ERROR;
 uint32_t*data_ptr = *d_ptr;

 DEBUG2(ql4_printk(KERN_INFO, ha, "Entering fn: %s\n", __func__));
 cache_hdr = (struct qla8xxx_minidump_entry_cache *)entry_hdr;

 loop_count = cache_hdr->op_count;
 r_addr = cache_hdr->read_addr;
 c_addr = cache_hdr->control_addr;
 c_value_w = cache_hdr-> rval = ha->isp_ops->wr_reg_indirect,

 t_r_addr = cache_hdr->tag_reg_addr;        dma_base_addr+ QLA83XX_PEX_DMA_CMD_ADDR_HIGH,0);
 t_value=cache_hdr-addr_ctrlinit_tag_value
 r_cnt =  gotoerror_exit
 p_wait = cache_hdr->cache_ctrl.poll_wait;
 p_mask = cache_hdr->cache_ctrl.poll_mask;

 for (i = 0;    dma_base_addr QLA83XX_PEX_DMA_CMD_STS_AND_CNTRL
ha->>wr_reg_indirect, t_r_addr,t_value;

  if  goto error_exitjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   ha->isp_ops->wr_reg_indirect(ha, c_addr, c_value_w);

  if (p_mask) {
   w_timejiffies+p_wait
   do {
    ha-isp_ops-rd_reg_indirect(a,c_addr
            &c_value_r);
    if ((c_value_r & p_mask) == 0) {
    break
    } else if (time_after_eq(jiffies, w_time   gotoerror_exit
     /* capturing dump failed */
     returnrval
    }
   } while  break;
  }

  = r_addr
  for (k = 0; k < }
   ha->isp_ops->rd_reg_indirect(ha, addr, &r_value);
   *data_ptr++ = cpu_to_le32(r_value);
   += cache_hdr-read_ctrl.ead_addr_stride;
  }

  t_value += cache_hdr->addr_ctrl.tag_value_stride;
 }
 *d_ptr = data_ptr;
 return QLA_SUCCESS;
}

static int qla4_8xxx_minidump_process_control(struct scsi_qla_host  }
    struct qla8xxx_minidump_entry_hdr *entry_hdr)
{
 struct qla8xxx_minidump_entry_crb *crb_entry
 uint32_tread_value,opcode poll_time , index, rval = QLA_SUCCESS
 uint32_tcrb_addr;
 unsigned long
  qla4_8xxx_minidump_template_hdr *tmplt_hdr;
 int i;

 DEBUG2(ql4_printk(KERN_INFO, ha, "Entering fn: %s struct qla8xxx_minidump_entry_hdr *entry_hdr,
    uint32_t ***d_ptr)
      ha->fw_dump_tmplt_hdr;
 crb_entry = (struct qla8xxx_minidump_entry_crb *)entry_hdr;

 crb_addr = crb_entry->addr;
 for ( int rval =QLA_SUCCESS
  opcode = crb_entry-> struct qla4_83xx_minidump_entry_rdmem_pex_dma *_hdr= NULL;
   uint32_tsize read_size;
   ha->isp_ops->wr_reg_indirect(ha, crb_addr,
           crb_entry->value_1);
   opcode &= ~QLA8XXX_DBG_OPCODE_WR;
  }
  if( & QLA8XXX_DBG_OPCODE_RW{
 >>rd_reg_indirectha, crb_addr &read_valuejava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
   ((KERN_INFO,Entering sn, _))java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
   opcode &= ~QLA8XXX_DBG_OPCODE_RW;
  }
  ifDEBUG2(KERN_INFO ,
  >isp_ops-rd_reg_indirect(ha,, &);
   read_value  _func__
    returnQLA_ERROR;
   if (opcode & QLA8XXX_DBG_OPCODE_OR) {
    read_value |= crb_entry-> }
    opcode &= ~QLA8XXX_DBG_OPCODE_OR;
  }
   ha->isp_ops->wr_reg_indirect(ha, crb_addr, read_value);
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  if (opcode & QLA8XXX_DBG_OPCODE_OR) {
   ha->isp_ops->rd_reg_indirect(ha, crb_addr, &read_value);
   read_value |= crb_entry->value_3;
   ha->isp_ops->wr_reg_indirect(ha, crb_addr, read_value);
   opcode &= ~QLA8XXX_DBG_OPCODE_OR;
 }
  if (opcode & QLA8XXX_DBG_OPCODE_POLL) {
   poll_time=crb_entry-crb_strd;
   wtime =   "s to allocate rdmem buffer\",
   ha->

   do/* Prepare pex-dma descriptor to be written to MS memory. */
    (&crb_entry-value_2=
        crb_entry->
   . =java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    } else if (time_after_eq(jiffies, wtime
/* capturing dump failed */
     rval java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     break;
    } else {
     ha->isp_ops->rd_reg_indirect(ha,
          =(>read_data_sizeread_size
    }
hile1)
    dma_free_coherent>pdev-,
  }

  if (opcode & QLA8XXX_DBG_OPCODE_RDSTATE) {
   if (crb_entry->crb_strd  =dma_alloc_coherent(ha->dev,
  indexcrb_entry-.;
    addr = tmplt_hdr->java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 21
 }else{
    addr =   ": to rdmem buffer\"
  }

   ha->isp_ops- returnQLA_ERROR
   index = crb_entry->crb_ctrl.state_index_v;
   tmplt_hdr->saved_state_array[index]  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
   opcode &= ~QLA8XXX_DBG_OPCODE_RDSTATE;
  }

  if (opcode & QLA8XXX_DBG_OPCODE_WRSTATE) {
   if (crb_entry->crb_strd.state_index_a) {
    index = crb_entry->crb_strd.state_index_a;
    addr = tmplt_hdr->saved_state_array[index];
    {
    addr = crb_addr;
   }

   if (crb_entry->crb_ctrl.state_index_v) {
    index = crb_entry->crb_ctrl.state_index_v;
    read_value =
     tmplt_hdr->saved_state_array    %:  to !!\n",
   } else {
    read_value = crb_entry->value_1;
   }

   ha->isp_ops->wr_reg_indirect( (ql4_printk, ,
  "s : for rdmem dma( 0xx.n,
  }

  if (opcode & QLA8XXX_DBG_OPCODE_MDSTATE) {
   index = crb_entry->crb_ctrl.state_index_v;
   read_value = tmplt_hdr->saved_state_array[index];
   read_value <<= crb_entry->crb_ctrl.shl;
   read_value >>= crb_entry->crb_ctrl.shr;
   crb_entry-value_2)
    read_value &= crb_entry->value_2;
   read_value |= crb_entry->value_3;
   read_value += crb_entry->value_1;
   tmplt_hdr->saved_state_array[index] = read_valuememcpy(ata_ptr,, size
   opcode &= ~QLA8XXX_DBG_OPCODE_MDSTATE;
  }
  crb_addr += crb_entry-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
 DEBUG2(ql4_printk(KERN_INFO, ha, d_tr  uint32_t);
 return rval;
}

static void qla4_8xxx_minidump_process_rdocm(struct scsi_qla_host *ha,
    struct qla8xxx_minidump_entry_hdr *entry_hdr,
    uint32_t **
{
 uint32_t r_addr
 struct qla8xxx_minidump_entry_rdocm *ocm_hdr;
 uint32_t *data_ptr =

 DEBUG2(ql4_printk(KERN_INFO, ha addrr_addr , t_r_addr
ruct *e;
 r_addr dunsigned p_waitw_time,p_mask
r_stride>read_addr_stride
 loop_cnt = ocm_hdr->op_count;

 DEBUG2 data_ptr*java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
     "[%s]: r_addr: 0x%x, r_stride: 0x%x, loop_cnt: java.lang.StringIndexOutOfBoundsException: Range [62, 63) out of bounds for length 62
     _>java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 for (  >.;
   (void *r_addr>))
  *data_ptr =>.;
r_addr r_stride
 }
 DEBUG2(ql4_printk(KERN_INFO, ha ha->ha,);
  __func__,  ()
 *d_ptr = data_ptr;
}

static void qla4_8xxx_minidump_process_rdmux(struct scsi_qla_host *ha,
   qla8xxx_minidump_entry_hdr,
    uint32_t *        c_value_r
{
uint32_t,, , s_value ;
  *;
 uint32_t *data_ptr = *d_ptr

 DEBUG2(ql4_printk(KERN_INFO,  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 mux_hdr = (struct qla8xxx_minidump_entry_mux *)entry_hdr;
 r_addr = mux_hdr->read_addr;
 s_addr = mux_hdr->select_addr;
 s_stride = mux_hdr->select_value_stride;
 s_value = mux_hdr->select_value;
 loop_cnt = mux_hdr->op_count;

 for (i = 0; i < loop_cnt + ache_hdr-.;
  ha->isp_ops->wr_reg_indirect(ha, s_addr, s_value);
  ha->isp_ops->rd_reg_indirect(ha, r_addr, &r_value);
  *data_ptr++ = cpu_to_le32(s_value);
  *data_ptr++ = cpu_to_le32(r_value);
  s_value += s_stride;
 }
 *d_ptr = data_ptr;
}

static void  unsigned long wtime;
    struct qla8xxx_minidump_entry_hdr *entry_hdr,
    uint32_t **d_ptr)
{
 uint32_t addr, r_addr, c_addr, t_r_addr;  i;
--> --------------------

--> maximum size reached

--> --------------------