/* ***** Support functions ***** */
static uint32
pcie_devcontrol_mrrs(void *pch, uint32 mask, uint32 val)
{
pcicore_info_t *pi = (pcicore_info_t *)pch;
uint32 reg_val;
uint8 offset;
offset = pi->pciecap_devctrl_offset;
if (!offset)
return 0;
reg_val = OSL_PCI_READ_CONFIG(pi->osh, offset, sizeof(uint32));
/* set operation */
if (mask) {
if (val > PCIE_CAP_DEVCTRL_MRRS_128B) {
if (PCIE_GEN1(pi->sih) && (pi->sih->buscorerev < 18)) {
PCI_ERROR(("%s pcie corerev %d doesn't support >128B MRRS",
__FUNCTION__, pi->sih->buscorerev));
val = PCIE_CAP_DEVCTRL_MRRS_128B;
}
}
reg_val &= ~PCIE_CAP_DEVCTRL_MRRS_MASK;
reg_val |= (val << PCIE_CAP_DEVCTRL_MRRS_SHIFT) & PCIE_CAP_DEVCTRL_MRRS_MASK;
OSL_PCI_WRITE_CONFIG(pi->osh, offset, sizeof(uint32), reg_val);
reg_val = OSL_PCI_READ_CONFIG(pi->osh, offset, sizeof(uint32));
}
return reg_val;
}
/* ***** Support functions ***** */
uint8
pcie_clkreq(void *pch, uint32 mask, uint32 val)
{
pcicore_info_t *pi = (pcicore_info_t *)pch;
uint32 reg_val;
uint8 offset;
offset = pi->pciecap_lcreg_offset;
if (!offset)
return 0;
reg_val = OSL_PCI_READ_CONFIG(pi->osh, offset, sizeof(uint32));
/* set operation */
if (mask) {
if (val)
reg_val |= PCIE_CLKREQ_ENAB;
else
reg_val &= ~PCIE_CLKREQ_ENAB;
OSL_PCI_WRITE_CONFIG(pi->osh, offset, sizeof(uint32), reg_val);
reg_val = OSL_PCI_READ_CONFIG(pi->osh, offset, sizeof(uint32));
}
if (reg_val & PCIE_CLKREQ_ENAB)
return 1;
else
return 0;
}
void
pcie_set_L1substate(void *pch, uint32 substate)
{
pcicore_info_t *pi = (pcicore_info_t *)pch;
si_t *sih = pi->sih;
sbpcieregs_t *pcieregs = pi->regs.pcieregs;
uint32 data;
ASSERT(PCIE_GEN2(sih));
ASSERT(substate <= 3);
if (substate != 0) {
/* turn on ASPM L1 */
data = pcie_readreg(sih, pcieregs, PCIE_CONFIGREGS, pi->pciecap_lcreg_offset);
pcie_writereg(sih, pcieregs, PCIE_CONFIGREGS, pi->pciecap_lcreg_offset, data | 2);
/* enable LTR */
pcie_ltrenable(pch, 1, 1);
}
/* PML1_sub_control1 can only be accessed by OSL_PCI_xxxx_CONFIG */
data = OSL_PCI_READ_CONFIG(pi->osh, PCIECFGREG_PML1_SUB_CTRL1, sizeof(uint32)) & 0xfffffff0;
/* JIRA:SWWLAN-28455 */
if (substate & 1)
data |= PCI_PM_L1_2_ENA_MASK | ASPM_L1_2_ENA_MASK;
if (substate & 2)
data |= PCI_PM_L1_1_ENA_MASK | ASPM_L1_1_ENA_MASK;
OSL_PCI_WRITE_CONFIG(pi->osh, PCIECFGREG_PML1_SUB_CTRL1, sizeof(uint32), data);
}
uint8
pcie_ltrenable(void *pch, uint32 mask, uint32 val)
{
pcicore_info_t *pi = (pcicore_info_t *)pch;
uint32 reg_val;
uint8 offset;
offset = pi->pciecap_devctrl2_offset;
if (!offset)
return 0;
reg_val = OSL_PCI_READ_CONFIG(pi->osh, offset, sizeof(uint32));
/* set operation */
if (mask) {
if (val)
reg_val |= PCIE_CAP_DEVCTRL2_LTR_ENAB_MASK;
else
reg_val &= ~PCIE_CAP_DEVCTRL2_LTR_ENAB_MASK;
OSL_PCI_WRITE_CONFIG(pi->osh, offset, sizeof(uint32), reg_val);
reg_val = OSL_PCI_READ_CONFIG(pi->osh, offset, sizeof(uint32));
}
if (reg_val & PCIE_CAP_DEVCTRL2_LTR_ENAB_MASK)
return 1;
else
return 0;
}
/* Enable PME generation */
void
pcicore_pmeen(void *pch)
{
pcicore_info_t *pi = (pcicore_info_t *)pch;
uint32 w;
/* if not pmecapable return */
if (!pcicore_pmecap(pi))
return;
w = OSL_PCI_READ_CONFIG(pi->osh, pi->pmecap_offset + PME_CSR_OFFSET, sizeof(uint32));
w |= (PME_CSR_PME_EN);
OSL_PCI_WRITE_CONFIG(pi->osh, pi->pmecap_offset + PME_CSR_OFFSET, sizeof(uint32), w);
}
uint32
pcie_lcreg(void *pch, uint32 mask, uint32 val)
{
pcicore_info_t *pi = (pcicore_info_t *)pch;
uint8 offset;
offset = pi->pciecap_lcreg_offset;
if (!offset)
return 0;
/* set operation */
if (mask)
OSL_PCI_WRITE_CONFIG(pi->osh, offset, sizeof(uint32), val);
return OSL_PCI_READ_CONFIG(pi->osh, offset, sizeof(uint32));
}
int
pcie_configspace_restore(void* pch)
{
pcicore_info_t *pi = (pcicore_info_t *)pch;
uint offset = 0;
uint32 *tmp = (uint32 *)pi->pcie_configspace;
/* if config space was not buffered, than abort restore */
if (*tmp == 0)
return -1;
while (offset < PCI_CONFIG_SPACE_SIZE) {
OSL_PCI_WRITE_CONFIG(pi->osh, offset, sizeof(uint32), *tmp);
tmp++;
offset += 4;
}
return 0;
}
/* Needs to happen when update to shadow SROM is needed
* : Coming out of 'standby'/'hibernate'
* : If pcie_war_aspm_ovr state changed
*/
static void
pcie_war_aspm_clkreq(pcicore_info_t *pi)
{
sbpcieregs_t *pcieregs = pi->regs.pcieregs;
si_t *sih = pi->sih;
uint16 val16, *reg16;
uint32 w;
if (!PCIEGEN1_ASPM(sih))
return;
/* bypass this on QT or VSIM */
if (!ISSIM_ENAB(sih)) {
reg16 = &pcieregs->sprom[SRSH_ASPM_OFFSET];
val16 = R_REG(pi->osh, reg16);
val16 &= ~SRSH_ASPM_ENB;
if (pi->pcie_war_aspm_ovr == PCIE_ASPM_ENAB)
val16 |= SRSH_ASPM_ENB;
else if (pi->pcie_war_aspm_ovr == PCIE_ASPM_L1_ENAB)
val16 |= SRSH_ASPM_L1_ENB;
else if (pi->pcie_war_aspm_ovr == PCIE_ASPM_L0s_ENAB)
val16 |= SRSH_ASPM_L0s_ENB;
W_REG(pi->osh, reg16, val16);
w = OSL_PCI_READ_CONFIG(pi->osh, pi->pciecap_lcreg_offset, sizeof(uint32));
w &= ~PCIE_ASPM_ENAB;
w |= pi->pcie_war_aspm_ovr;
OSL_PCI_WRITE_CONFIG(pi->osh, pi->pciecap_lcreg_offset, sizeof(uint32), w);
}
reg16 = &pcieregs->sprom[SRSH_CLKREQ_OFFSET_REV5];
val16 = R_REG(pi->osh, reg16);
if (pi->pcie_war_aspm_ovr != PCIE_ASPM_DISAB) {
val16 |= SRSH_CLKREQ_ENB;
pi->pcie_pr42767 = TRUE;
} else
val16 &= ~SRSH_CLKREQ_ENB;
W_REG(pi->osh, reg16, val16);
}
/* Disable PME generation, clear the PME status bit if set
*/
void
pcicore_pmeclr(void *pch)
{
pcicore_info_t *pi = (pcicore_info_t *)pch;
uint32 w;
if (!pcicore_pmecap(pi))
return;
pcie_war_pmebits(pi);
w = OSL_PCI_READ_CONFIG(pi->osh, pi->pmecap_offset + PME_CSR_OFFSET, sizeof(uint32));
PCI_ERROR(("pcicore_pci_pmeclr PMECSR : 0x%x\n", w));
/* PMESTAT is cleared by writing 1 to it */
w &= ~(PME_CSR_PME_EN);
OSL_PCI_WRITE_CONFIG(pi->osh, pi->pmecap_offset + PME_CSR_OFFSET, sizeof(uint32), w);
}
/* Needs to happen when update to shadow SROM is needed
* : Coming out of 'standby'/'hibernate'
* : If pcie_war_aspm_ovr state changed
*/
static void
pcie_war_aspm_clkreq(pcicore_info_t *pi)
{
sbpcieregs_t *pcieregs = pi->regs.pcieregs;
si_t *sih = pi->sih;
uint16 val16, *reg16;
uint32 w;
if (!PCIE_ASPM(sih))
return;
/* PR43448 WAR: Enable ASPM in the shadow SROM and Link control */
/* bypass this on QT or VSIM */
if (sih->chippkg != HDLSIM_PKG_ID && sih->chippkg != HWSIM_PKG_ID) {
reg16 = &pcieregs->sprom[SRSH_ASPM_OFFSET];
val16 = R_REG(pi->osh, reg16);
if (!pi->pcie_war_aspm_ovr)
val16 |= SRSH_ASPM_ENB;
else
val16 &= ~SRSH_ASPM_ENB;
W_REG(pi->osh, reg16, val16);
w = OSL_PCI_READ_CONFIG(pi->osh, pi->pciecap_lcreg_offset, sizeof(uint32));
if (!pi->pcie_war_aspm_ovr)
w |= PCIE_ASPM_ENAB;
else
w &= ~PCIE_ASPM_ENAB;
OSL_PCI_WRITE_CONFIG(pi->osh, pi->pciecap_lcreg_offset, sizeof(uint32), w);
}
/* PR42767 WAR: if clockreq is not advertized in SROM, advertize it */
reg16 = &pcieregs->sprom[SRSH_CLKREQ_OFFSET_REV5];
val16 = R_REG(pi->osh, reg16);
if (!pi->pcie_war_aspm_ovr) {
val16 |= SRSH_CLKREQ_ENB;
pi->pcie_pr42767 = TRUE;
} else
val16 &= ~SRSH_CLKREQ_ENB;
W_REG(pi->osh, reg16, val16);
}
/* When the device is going to enter D3 state (or the system is going to enter S3/S4 states */
void
pcicore_sleep(void *pch)
{
pcicore_info_t *pi = (pcicore_info_t *)pch;
uint32 w;
if (!pi || !PCIE_ASPM(pi->sih))
return;
/* PR43448: Clear ASPM L1 when going to sleep as while coming out of standby/sleep,
* ASPM L1 should not be accidentally enabled before driver has a chance to apply
* the WAR
*/
w = OSL_PCI_READ_CONFIG(pi->osh, pi->pciecap_lcreg_offset, sizeof(uint32));
w &= ~PCIE_CAP_LCREG_ASPML1;
OSL_PCI_WRITE_CONFIG(pi->osh, pi->pciecap_lcreg_offset, sizeof(uint32), w);
/* Clear the state for PR42767 to make sure it's applied on the way up */
pi->pcie_pr42767 = FALSE;
}
void
pcicore_pmestatclr(void *pch)
{
pcicore_info_t *pi = (pcicore_info_t *)pch;
uint32 w;
if (!pcicore_pmecap(pi))
return;
pcie_war_pmebits(pi);
w = OSL_PCI_READ_CONFIG(pi->osh, pi->pmecap_offset + PME_CSR_OFFSET, sizeof(uint32));
PCI_ERROR(("pcicore_pmestatclr PMECSR : 0x%x\n", w));
/* Writing a 1 to PMESTAT will clear it */
if ((w & PME_CSR_PME_STAT) == PME_CSR_PME_STAT) {
OSL_PCI_WRITE_CONFIG(pi->osh, pi->pmecap_offset + PME_CSR_OFFSET, sizeof(uint32),
w);
}
}
/* Disable PME generation, clear the PME status bit if set and
* return TRUE if PME status set
*/
bool
pcicore_pmeclr(void *pch)
{
pcicore_info_t *pi = (pcicore_info_t *)pch;
uint32 w;
bool ret = FALSE;
if (!pcicore_pmecap(pi))
return ret;
w = OSL_PCI_READ_CONFIG(pi->osh, pi->pmecap_offset + PME_CSR_OFFSET, sizeof(uint32));
PCI_ERROR(("pcicore_pci_pmeclr PMECSR : 0x%x\n", w));
ret = (w & PME_CSR_PME_STAT) == PME_CSR_PME_STAT;
/* PMESTAT is cleared by writing 1 to it */
w &= ~(PME_CSR_PME_EN);
OSL_PCI_WRITE_CONFIG(pi->osh, pi->pmecap_offset + PME_CSR_OFFSET, sizeof(uint32), w);
return ret;
}
static uint32
pcie_devcontrol_mps(void *pch, uint32 mask, uint32 val)
{
pcicore_info_t *pi = (pcicore_info_t *)pch;
uint32 reg_val;
uint8 offset;
offset = pi->pciecap_devctrl_offset;
if (!offset)
return 0;
reg_val = OSL_PCI_READ_CONFIG(pi->osh, offset, sizeof(uint32));
/* set operation */
if (mask) {
reg_val &= ~PCIE_CAP_DEVCTRL_MPS_MASK;
reg_val |= (val << PCIE_CAP_DEVCTRL_MPS_SHIFT) & PCIE_CAP_DEVCTRL_MPS_MASK;
OSL_PCI_WRITE_CONFIG(pi->osh, offset, sizeof(uint32), reg_val);
reg_val = OSL_PCI_READ_CONFIG(pi->osh, offset, sizeof(uint32));
}
return reg_val;
}
/* When the device is going to enter D3 state (or the system is going to enter S3/S4 states */
void
pcicore_sleep(void *pch)
{
pcicore_info_t *pi = (pcicore_info_t *)pch;
uint32 w;
if (!pi || !PCIE_GEN1(pi->sih))
return;
pcie_power_save_upd(pi, FALSE);
if (!PCIEGEN1_ASPM(pi->sih))
return;
w = OSL_PCI_READ_CONFIG(pi->osh, pi->pciecap_lcreg_offset, sizeof(uint32));
w &= ~PCIE_CAP_LCREG_ASPML1;
OSL_PCI_WRITE_CONFIG(pi->osh, pi->pciecap_lcreg_offset, sizeof(uint32), w);
pi->pcie_pr42767 = FALSE;
}
/* JIRA:SWWLAN-28745
val and return value:
0 Disabled
1 Enable using Message signaling[Var A]
2 Enable using Message signaling[Var B]
3 Enable using WAKE# signaling
*/
uint8
pcie_obffenable(void *pch, uint32 mask, uint32 val)
{
pcicore_info_t *pi = (pcicore_info_t *)pch;
uint32 reg_val;
uint8 offset;
offset = pi->pciecap_devctrl2_offset;
if (!offset)
return 0;
reg_val = OSL_PCI_READ_CONFIG(pi->osh, offset, sizeof(uint32));
/* set operation */
if (mask) {
reg_val = (reg_val & ~PCIE_CAP_DEVCTRL2_OBFF_ENAB_MASK) |
((val << PCIE_CAP_DEVCTRL2_OBFF_ENAB_SHIFT) &
PCIE_CAP_DEVCTRL2_OBFF_ENAB_MASK);
OSL_PCI_WRITE_CONFIG(pi->osh, offset, sizeof(uint32), reg_val);
reg_val = OSL_PCI_READ_CONFIG(pi->osh, offset, sizeof(uint32));
}
return (reg_val & PCIE_CAP_DEVCTRL2_OBFF_ENAB_MASK) >> PCIE_CAP_DEVCTRL2_OBFF_ENAB_SHIFT;
}
/* support only 16-bit word write into srom */
int
srom_write(uint bus, void *curmap, void *osh, uint byteoff, uint nbytes, uint16 *buf)
{
uint16 *srom;
uint i, off, nw, crc_range;
uint16 image[SPROM_SIZE], *p;
uint8 crc;
volatile uint32 val32;
/* check input - 16-bit access only */
if (byteoff & 1 || nbytes & 1 || (byteoff + nbytes) > (SPROM_SIZE * 2))
return 1;
crc_range = ((bus == PCMCIA_BUS) ? SPROM_SIZE : SPROM_CRC_RANGE) * 2;
/* if changes made inside crc cover range */
if (byteoff < crc_range) {
nw = (((byteoff + nbytes) > crc_range) ? byteoff + nbytes : crc_range) / 2;
/* read data including entire first 64 words from srom */
if (srom_read(bus, curmap, osh, 0, nw * 2, image))
return 1;
/* make changes */
bcopy((void*)buf, (void*)&image[byteoff / 2], nbytes);
/* calculate crc */
htol16_buf(image, crc_range);
crc = ~crc8((uint8 *)image, crc_range - 1, CRC8_INIT_VALUE);
ltoh16_buf(image, crc_range);
image[(crc_range / 2) - 1] = (crc << 8) | (image[(crc_range / 2) - 1] & 0xff);
p = image;
off = 0;
} else {
p = buf;
off = byteoff / 2;
nw = nbytes / 2;
}
if (bus == PCI_BUS) {
srom = (uint16*)((uint)curmap + PCI_BAR0_SPROM_OFFSET);
/* enable writes to the SPROM */
val32 = OSL_PCI_READ_CONFIG(osh, PCI_SPROM_CONTROL, sizeof(uint32));
val32 |= SPROM_WRITEEN;
OSL_PCI_WRITE_CONFIG(osh, PCI_SPROM_CONTROL, sizeof(uint32), val32);
bcm_mdelay(500);
/* write srom */
for (i = 0; i < nw; i++) {
W_REG(&srom[off + i], p[i]);
bcm_mdelay(20);
}
/* disable writes to the SPROM */
OSL_PCI_WRITE_CONFIG(osh, PCI_SPROM_CONTROL, sizeof(uint32), val32 & ~SPROM_WRITEEN);
} else if (bus == PCMCIA_BUS) {
/* enable writes to the SPROM */
if (sprom_cmd_pcmcia(osh, SROM_WEN))
return 1;
bcm_mdelay(500);
/* write srom */
for (i = 0; i < nw; i++) {
sprom_write_pcmcia(osh, (uint16)(off + i), p[i]);
bcm_mdelay(20);
}
/* disable writes to the SPROM */
if (sprom_cmd_pcmcia(osh, SROM_WDS))
return 1;
} else {
return 1;
}
bcm_mdelay(500);
return 0;
}
static si_info_t *
si_doattach(si_info_t *sii, uint devid, osl_t *osh, void *regs,
uint bustype, void *sdh, char **vars, uint *varsz)
{
struct si_pub *sih = &sii->pub;
uint32 w, savewin;
chipcregs_t *cc;
char *pvars = NULL;
uint origidx;
ASSERT(GOODREGS(regs));
bzero((uchar*)sii, sizeof(si_info_t));
{
if (NULL == (common_info_alloced = (void *)MALLOC(osh, sizeof(si_common_info_t)))) {
SI_ERROR(("si_doattach: malloc failed! malloced %dbytes\n", MALLOCED(osh)));
return (NULL);
}
bzero((uchar*)(common_info_alloced), sizeof(si_common_info_t));
}
sii->common_info = (si_common_info_t *)common_info_alloced;
sii->common_info->attach_count++;
savewin = 0;
sih->buscoreidx = BADIDX;
sii->curmap = regs;
sii->sdh = sdh;
sii->osh = osh;
/* find Chipcommon address */
if (bustype == PCI_BUS) {
savewin = OSL_PCI_READ_CONFIG(sii->osh, PCI_BAR0_WIN, sizeof(uint32));
if (!GOODCOREADDR(savewin, SI_ENUM_BASE))
savewin = SI_ENUM_BASE;
OSL_PCI_WRITE_CONFIG(sii->osh, PCI_BAR0_WIN, 4, SI_ENUM_BASE);
cc = (chipcregs_t *)regs;
} else
if ((bustype == SDIO_BUS) || (bustype == SPI_BUS)) {
cc = (chipcregs_t *)sii->curmap;
} else {
cc = (chipcregs_t *)REG_MAP(SI_ENUM_BASE, SI_CORE_SIZE);
}
sih->bustype = bustype;
if (bustype != BUSTYPE(bustype)) {
SI_ERROR(("si_doattach: bus type %d does not match configured bus type %d\n",
bustype, BUSTYPE(bustype)));
return NULL;
}
/* bus/core/clk setup for register access */
if (!si_buscore_prep(sii, bustype, devid, sdh)) {
SI_ERROR(("si_doattach: si_core_clk_prep failed %d\n", bustype));
return NULL;
}
/* ChipID recognition.
* We assume we can read chipid at offset 0 from the regs arg.
* If we add other chiptypes (or if we need to support old sdio hosts w/o chipcommon),
* some way of recognizing them needs to be added here.
*/
w = R_REG(osh, &cc->chipid);
sih->socitype = (w & CID_TYPE_MASK) >> CID_TYPE_SHIFT;
/* Might as wll fill in chip id rev & pkg */
sih->chip = w & CID_ID_MASK;
sih->chiprev = (w & CID_REV_MASK) >> CID_REV_SHIFT;
sih->chippkg = (w & CID_PKG_MASK) >> CID_PKG_SHIFT;
if ((CHIPID(sih->chip) == BCM4329_CHIP_ID) && (sih->chippkg != BCM4329_289PIN_PKG_ID))
sih->chippkg = BCM4329_182PIN_PKG_ID;
sih->issim = IS_SIM(sih->chippkg);
/* scan for cores */
if (CHIPTYPE(sii->pub.socitype) == SOCI_SB) {
SI_MSG(("Found chip type SB (0x%08x)\n", w));
sb_scan(&sii->pub, regs, devid);
} else if (CHIPTYPE(sii->pub.socitype) == SOCI_AI) {
SI_MSG(("Found chip type AI (0x%08x)\n", w));
/* pass chipc address instead of original core base */
ai_scan(&sii->pub, (void *)cc, devid);
} else {
SI_ERROR(("Found chip of unkown type (0x%08x)\n", w));
return NULL;
}
/* no cores found, bail out */
if (sii->numcores == 0) {
SI_ERROR(("si_doattach: could not find any cores\n"));
return NULL;
}
/* bus/core/clk setup */
origidx = SI_CC_IDX;
if (!si_buscore_setup(sii, cc, bustype, savewin, &origidx, regs)) {
SI_ERROR(("si_doattach: si_buscore_setup failed\n"));
return NULL;
}
pvars = NULL;
if (sii->pub.ccrev >= 20) {
cc = (chipcregs_t *)si_setcore(sih, CC_CORE_ID, 0);
W_REG(osh, &cc->gpiopullup, 0);
W_REG(osh, &cc->gpiopulldown, 0);
si_setcoreidx(sih, origidx);
}
/* Skip PMU initialization from the Dongle Host.
* Firmware will take care of it when it comes up.
*/
return (sii);
}
/* support only 16-bit word write into srom */
int
srom_write(uint bustype, void *curmap, osl_t *osh, uint byteoff, uint nbytes, uint16 *buf)
{
uint16 *srom;
uint i, nw, crc_range;
uint16 image[SPROM_SIZE];
uint8 crc;
volatile uint32 val32;
ASSERT(bustype == BUSTYPE(bustype));
/* check input - 16-bit access only */
if (byteoff & 1 || nbytes & 1 || (byteoff + nbytes) > (SPROM_SIZE * 2))
return 1;
/* Are we writing the whole thing at once? */
if ((byteoff == 0) &&
((nbytes == SPROM_SIZE) ||
(nbytes == (SPROM_CRC_RANGE * 2)) ||
(nbytes == (SROM4_WORDS * 2)))) {
crc_range = nbytes;
bcopy((void*)buf, (void*)image, nbytes);
nw = nbytes / 2;
} else {
if ((BUSTYPE(bustype) == PCMCIA_BUS) || (BUSTYPE(bustype) == SDIO_BUS))
crc_range = SPROM_SIZE;
else
crc_range = SPROM_CRC_RANGE * 2; /* Tentative */
nw = crc_range / 2;
/* read first 64 words from srom */
if (srom_read(bustype, curmap, osh, 0, crc_range, image))
return 1;
if (image[SROM4_SIGN] == SROM4_SIGNATURE) {
crc_range = SROM4_WORDS;
nw = crc_range / 2;
if (srom_read(bustype, curmap, osh, 0, crc_range, image))
return 1;
}
/* make changes */
bcopy((void*)buf, (void*)&image[byteoff / 2], nbytes);
}
/* calculate crc */
htol16_buf(image, crc_range);
crc = ~hndcrc8((uint8 *)image, crc_range - 1, CRC8_INIT_VALUE);
ltoh16_buf(image, crc_range);
image[(crc_range / 2) - 1] = (crc << 8) | (image[(crc_range / 2) - 1] & 0xff);
if (BUSTYPE(bustype) == PCI_BUS) {
srom = (uint16*)((uchar*)curmap + PCI_BAR0_SPROM_OFFSET);
/* enable writes to the SPROM */
val32 = OSL_PCI_READ_CONFIG(osh, PCI_SPROM_CONTROL, sizeof(uint32));
val32 |= SPROM_WRITEEN;
OSL_PCI_WRITE_CONFIG(osh, PCI_SPROM_CONTROL, sizeof(uint32), val32);
bcm_mdelay(WRITE_ENABLE_DELAY);
/* write srom */
for (i = 0; i < nw; i++) {
W_REG(osh, &srom[i], image[i]);
bcm_mdelay(WRITE_WORD_DELAY);
}
/* disable writes to the SPROM */
OSL_PCI_WRITE_CONFIG(osh, PCI_SPROM_CONTROL, sizeof(uint32), val32 &
~SPROM_WRITEEN);
} else if (BUSTYPE(bustype) == PCMCIA_BUS) {
/* enable writes to the SPROM */
if (sprom_cmd_pcmcia(osh, SROM_WEN))
return 1;
bcm_mdelay(WRITE_ENABLE_DELAY);
/* write srom */
for (i = 0; i < nw; i++) {
sprom_write_pcmcia(osh, (uint16)(i), image[i]);
bcm_mdelay(WRITE_WORD_DELAY);
}
/* disable writes to the SPROM */
if (sprom_cmd_pcmcia(osh, SROM_WDS))
return 1;
} else {
return 1;
}
bcm_mdelay(WRITE_ENABLE_DELAY);
return 0;
}
