uint32_t piboffset (struct _file_ * file)
{
struct pib_header pib_header;
uint32_t offset = 0;
if (lseek (file->file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, file->name);
}
if (read (file->file, &pib_header, sizeof (pib_header)) < sizeof (pib_header))
{
error (1, errno, FILE_CANTREAD, file->name);
}
if (lseek (file->file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, file->name);
}
if (BE16TOH (*(uint16_t *)(&pib_header)) < 0x0305)
{
offset = LEGACY_PIBOFFSET;
}
else if (BE16TOH (*(uint16_t *)(&pib_header)) < 0x0500)
{
offset = INT6x00_PIBOFFSET;
}
else
{
offset = AR7x00_PIBOFFSET;
}
return (offset);
}
int
cs80status(void *v, int slave, int punit, struct cs80_stat *css)
{
struct cs80bus_softc *sc = v;
struct cs80_statuscmd rs;
u_int8_t stat;
rs.c_unit = CS80CMD_SUNIT(punit);
rs.c_sram = CS80CMD_SRAM;
rs.c_param = 0; /* single vector (i.e. sector number) */
rs.c_cmd = CS80CMD_STATUS;
memset((void *)css, 0, sizeof(*css));
(void) gpibsend(sc->sc_ic, slave, CS80CMD_SCMD, &rs, sizeof(rs));
(void) gpibrecv(sc->sc_ic, slave, CS80CMD_EXEC, css, sizeof(*css));
(void) gpibrecv(sc->sc_ic, slave, CS80CMD_QSTAT, &stat, 1);
if (stat != 0) {
DPRINTF(DBG_FAIL, ("cs80status: failed, stat=0x%x\n", stat));
return (1);
}
BE16TOH(css->c_ref);
BE16TOH(css->c_fef);
BE16TOH(css->c_aef);
BE16TOH(css->c_ief);
BE32TOH(css->c_blk);
return (0);
}
signed BootParameters1 (struct plc * plc)
{
struct pib_header pib_header;
uint32_t offset;
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error ((plc->flags & PLC_BAILOUT), errno, FILE_CANTHOME, plc->PIB.name);
}
if (read (plc->PIB.file, &pib_header, sizeof (pib_header)) != sizeof (pib_header))
{
error ((plc->flags & PLC_BAILOUT), errno, FILE_CANTREAD, plc->PIB.name);
}
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error ((plc->flags & PLC_BAILOUT), errno, FILE_CANTHOME, plc->PIB.name);
}
#if 1
/*
* this code is a fix to accommodate PIB relocation in memory; it is not needed when
* the PIB is stored in an NVM file since the memory address is recorded in the image
* header;
*/
if (BE16TOH (*(uint16_t *)(&pib_header)) < 0x0305)
{
offset = LEGACY_PIBOFFSET;
}
else if (BE16TOH (*(uint16_t *)(&pib_header)) < 0x0500)
{
offset = INT6x00_PIBOFFSET;
}
else
{
offset = AR7x00_PIBOFFSET;
}
#endif
if (plc->hardwareID < CHIPSET_AR7400)
{
if (WriteMEM (plc, &plc->PIB, 0, offset, LE16TOH (pib_header.PIBLENGTH)))
{
return (-1);
}
return (0);
}
if (WriteExecutePIB (plc, offset, &pib_header))
{
return (-1);
}
return (0);
}
int
psbuf_get_2(struct puffs_framebuf *pb, uint16_t *val)
{
int rv;
rv = puffs_framebuf_getdata(pb, val, 2);
BE16TOH(*val);
ERETURN(rv);
}
int
cs80describe(void *v, int slave, int punit, struct cs80_description *csd)
{
struct cs80bus_softc *sc = v;
struct cs80_describecmd desc;
u_int8_t stat;
DPRINTF(DBG_FOLLOW, ("cs80describe: sc=%p slave=%d\n", sc, slave));
/*
* Note command is always issued to unit 0.
*/
desc.c_unit = CS80CMD_SUNIT(0);
desc.c_vol = CS80CMD_SVOL(0);
desc.c_cmd = CS80CMD_DESC;
(void) gpibsend(sc->sc_ic, slave, CS80CMD_SCMD, &desc, sizeof(desc));
(void) gpibrecv(sc->sc_ic, slave, CS80CMD_EXEC, csd, sizeof(*csd));
(void) gpibrecv(sc->sc_ic, slave, CS80CMD_QSTAT, &stat, 1);
if (stat != 0) {
DPRINTF(DBG_FAIL, ("cs80describe: failed, stat=0x%x\n", stat));
return (1);
}
BE16TOH(csd->d_iuw);
BE16TOH(csd->d_cmaxxfr);
BE16TOH(csd->d_sectsize);
BE16TOH(csd->d_blocktime);
BE16TOH(csd->d_uavexfr);
BE16TOH(csd->d_retry);
BE16TOH(csd->d_access);
BE32TOH(csd->d_maxcylhead);
BE16TOH(csd->d_maxsect);
BE16TOH(csd->d_maxvsecth);
BE32TOH(csd->d_maxvsectl);
return (0);
}
void
cs80busattach(device_t parent, device_t self, void *aux)
{
struct cs80bus_softc *sc = device_private(self);
struct gpib_attach_args *ga = aux;
struct cs80bus_attach_args ca;
int slave;
u_int16_t id;
printf("\n");
sc->sc_dev = self;
sc->sc_ic = ga->ga_ic;
for (slave = 0; slave < 8; slave++) {
if (gpib_isalloc(device_private(device_parent(sc->sc_dev)),
slave))
continue;
if (gpibrecv(sc->sc_ic, GPIB_BROADCAST_ADDR,
slave, &id, 2) != 2)
continue;
BE16TOH(id);
DPRINTF(DBG_STATUS, ("cs80busattach: found id 0x%x\n", id));
if ((id & 0x200) == 0)
continue;
ca.ca_ic = sc->sc_ic;
ca.ca_slave = slave;
ca.ca_id = id;
(void)config_search_ia(cs80bussearch, sc->sc_dev, "cs80bus",
&ca);
}
}
signed EmulateHost (struct plc * plc)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
static char const * actions [] =
{
"start device",
"store firmware",
"store parameters",
"update host",
"config memory",
"restore defaults",
"unknown"
};
#ifndef __GNUC__
#pragma pack (push,1)
#endif
struct __packed vs_host_action_ind
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MACTION;
uint8_t MAJOR_VERSION;
uint8_t MINOR_VERSION;
}
* indicate = (struct vs_host_action_ind *) (message);
#if 0
struct __packed vs_host_action_rsp
{
struct ethernet_hdr ethernet;
struct qualcomm_hdr qualcomm;
uint8_t MSTATUS;
}
* response = (struct vs_host_action_rsp *) (message);
#endif
#ifndef __GNUC__
#pragma pack (pop)
#endif
struct nvm_header1 nvm_header;
struct pib_header pib_header;
uint32_t offset;
char const * PIB = plc->PIB.name;
char const * NVM = plc->NVM.name;
signed timer = channel->timeout;
signed status = 0;
Request (plc, "Waiting for Host Action");
while (1)
{
channel->timeout = plc->timer;
status = ReadMME (plc, 0, (VS_HOST_ACTION | MMTYPE_IND));
channel->timeout = timer;
if (status < 0)
{
break;
}
if (status > 0)
{
printf ("\n");
if (indicate->MACTION < (sizeof (actions) / sizeof (char const *)))
{
Confirm (plc, "Host Action Request is (%d) %s.", indicate->MACTION, actions [indicate->MACTION]);
}
else
{
error (0, ENOTSUP, "Host Action 0x%0X", indicate->MACTION);
continue;
}
memcpy (channel->peer, indicate->ethernet.OSA, sizeof (channel->peer));
channel->timeout = timer;
if (indicate->MACTION == 0x00)
{
unsigned module = 0;
char firmware [PLC_VERSION_STRING];
if (HostActionResponse (plc))
{
return (-1);
}
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, plc->PIB.name);
}
if (read (plc->PIB.file, &pib_header, sizeof (pib_header)) != sizeof (pib_header))
{
error (1, errno, FILE_CANTREAD, plc->PIB.name);
}
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, plc->PIB.name);
}
if (BE16TOH (*(uint16_t *)(&pib_header)) < 0x0305)
{
offset = LEGACY_PIBOFFSET;
}
else if (BE16TOH (*(uint16_t *)(&pib_header)) < 0x0500)
{
offset = INT6x00_PIBOFFSET;
}
else
{
offset = AR7x00_PIBOFFSET;
}
if (WriteMEM (plc, &plc->PIB, 0, offset, LE16TOH (pib_header.PIBLENGTH)))
{
return (-1);
}
if (lseek (plc->NVM.file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, plc->NVM.name);
}
if (read (plc->NVM.file, &nvm_header, sizeof (nvm_header)) != sizeof (nvm_header))
{
error (1, errno, FILE_CANTREAD, plc->NVM.name);
}
while (nvm_header.NEXTHEADER)
{
lseek (plc->NVM.file, LE32TOH (nvm_header.NEXTHEADER), SEEK_SET);
if (read (plc->NVM.file, &nvm_header, sizeof (nvm_header)) != sizeof (nvm_header))
{
error (1, errno, FILE_CANTREAD, plc->NVM.name);
}
module++;
}
if (WriteFirmware1 (plc, module, &nvm_header))
{
return (-1);
}
if (StartFirmware1 (plc, module, &nvm_header))
{
return (-1);
}
if (WaitForStart (plc, firmware, sizeof (firmware)))
{
return (-1);
}
if (_anyset (plc->flags, PLC_FLASH_DEVICE))
{
if (WriteNVM (plc))
{
return (-1);
}
if (WritePIB (plc))
{
return (-1);
}
if (FlashNVM (plc))
{
return (-1);
}
}
continue;
}
if (indicate->MACTION == 0x01)
{
if (HostActionResponse (plc))
{
return (-1);
}
close (plc->NVM.file);
if (ReadFirmware1 (plc))
{
return (-1);
}
if ((plc->NVM.file = open (plc->NVM.name = plc->nvm.name, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc->NVM.name);
}
if (ResetDevice (plc))
{
return (-1);
}
continue;
}
if (indicate->MACTION == 0x02)
{
if (HostActionResponse (plc))
{
return (-1);
}
close (plc->PIB.file);
if (ReadParameters1 (plc))
{
return (-1);
}
if ((plc->PIB.file = open (plc->PIB.name = plc->pib.name, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc->PIB.name);
}
if (ResetDevice (plc))
{
return (-1);
}
continue;
}
if (indicate->MACTION == 0x03)
{
if (HostActionResponse (plc))
{
return (-1);
}
close (plc->NVM.file);
if (ReadFirmware1 (plc))
{
return (-1);
}
if ((plc->NVM.file = open (plc->NVM.name = plc->nvm.name, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc->NVM.name);
}
close (plc->PIB.file);
if (ReadParameters1 (plc))
{
return (-1);
}
if ((plc->PIB.file = open (plc->PIB.name = plc->pib.name, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc->PIB.name);
}
if (ResetDevice (plc))
{
return (-1);
}
continue;
}
if (indicate->MACTION == 0x04)
{
#if 0
/*
* Due to an omission in the INT6300 BootLoader, responding to this VS_HOST_ACTION
* indication will suppress subsequent VS_HOST_ACTION messages and the device will
* not request firmware and parameters; this may be corrected on the INT6400;
*/
if (HostActionResponse (plc))
{
return (-1);
}
#endif
if (WriteCFG (plc))
{
return (-1);
}
/*
* At this point, one could download firmware and parameters without waiting for
* further requests from the device; however, we elect to wait for them since it
* is 'good form'; a device should send code 0x00 within 10 seconds of this one;
*/
continue;
}
if (indicate->MACTION == 0x05)
{
if (HostActionResponse (plc))
{
return (-1);
}
close (plc->NVM.file);
if ((plc->NVM.file = open (plc->NVM.name = NVM, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc->NVM.name);
}
close (plc->PIB.file);
if ((plc->PIB.file = open (plc->PIB.name = PIB, O_BINARY|O_RDONLY)) == -1)
{
error (1, errno, "%s", plc->PIB.name);
}
if (ResetDevice (plc))
{
return (-1);
}
continue;
}
error (0, ENOSYS, "Host Action 0x%0X", indicate->MACTION);
}
}
return (0);
}
static struct sgi_boot_block *
convert_sgi_boot_block(unsigned char *buf)
{
struct sgi_boot_block *vh;
int i;
vh = (struct sgi_boot_block *)buf;
BE32TOH(vh->magic);
BE16TOH(vh->root);
BE16TOH(vh->swap);
BE16TOH(vh->dp.dp_cyls);
BE16TOH(vh->dp.dp_shd0);
BE16TOH(vh->dp.dp_trks0);
BE16TOH(vh->dp.dp_secs);
BE16TOH(vh->dp.dp_secbytes);
BE16TOH(vh->dp.dp_interleave);
BE32TOH(vh->dp.dp_flags);
BE32TOH(vh->dp.dp_datarate);
BE32TOH(vh->dp.dp_nretries);
BE32TOH(vh->dp.dp_mspw);
BE16TOH(vh->dp.dp_xgap1);
BE16TOH(vh->dp.dp_xsync);
BE16TOH(vh->dp.dp_xrdly);
BE16TOH(vh->dp.dp_xgap2);
BE16TOH(vh->dp.dp_xrgate);
BE16TOH(vh->dp.dp_xwcont);
for (i = 0; i < SGI_BOOT_BLOCK_MAXVOLDIRS; i++) {
BE32TOH(vh->voldir[i].block);
BE32TOH(vh->voldir[i].bytes);
}
for (i = 0; i < SGI_BOOT_BLOCK_MAXPARTITIONS; i++) {
BE32TOH(vh->partitions[i].blocks);
BE32TOH(vh->partitions[i].first);
BE32TOH(vh->partitions[i].type);
}
BE32TOH(vh->checksum);
return (vh);
}
int StartDevice1 (struct plc * plc)
{
unsigned module = 0;
struct nvm_header1 nvm_header;
struct pib_header pib_header;
uint32_t offset;
if (WriteCFG (plc))
{
return (-1);
}
if (lseek (plc->NVM.file, 0, SEEK_SET))
{
error (PLC_EXIT (plc), errno, FILE_CANTHOME, plc->NVM.name);
return (-1);
}
if (read (plc->NVM.file, &nvm_header, sizeof (nvm_header)) != sizeof (nvm_header))
{
error (PLC_EXIT (plc), errno, FILE_CANTREAD, plc->NVM.name);
return (-1);
}
while (nvm_header.NEXTHEADER)
{
if (lseek (plc->NVM.file, LE32TOH (nvm_header.NEXTHEADER), SEEK_SET) == -1)
{
error (PLC_EXIT (plc), errno, FILE_CANTHOME, plc->NVM.name);
return (-1);
}
if (read (plc->NVM.file, &nvm_header, sizeof (nvm_header)) != sizeof (nvm_header))
{
error (PLC_EXIT (plc), errno, FILE_CANTREAD, plc->NVM.name);
return (-1);
}
module++;
}
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, plc->PIB.name);
}
if (read (plc->PIB.file, &pib_header, sizeof (pib_header)) != sizeof (pib_header))
{
error (1, errno, FILE_CANTREAD, plc->PIB.name);
}
if (lseek (plc->PIB.file, 0, SEEK_SET))
{
error (1, errno, FILE_CANTHOME, plc->PIB.name);
}
if (BE16TOH (*(uint16_t *)(&pib_header)) < 0x0305)
{
offset = LEGACY_PIBOFFSET;
}
else if (BE16TOH (*(uint16_t *)(&pib_header)) < 0x0500)
{
offset = INT6x00_PIBOFFSET;
}
else
{
offset = AR7x00_PIBOFFSET;
}
if (WriteMEM (plc, &plc->PIB, 0, offset, LE16TOH (pib_header.PIBLENGTH)))
{
return (-1);
}
if (WriteFirmware1 (plc, module, &nvm_header))
{
return (-1);
}
if (StartFirmware1 (plc, module, &nvm_header))
{
return (-1);
}
if (lseek (plc->NVM.file, 0, SEEK_SET))
{
error (PLC_EXIT (plc), errno, FILE_CANTHOME, plc->NVM.name);
return (-1);
}
return (0);
}
