/*
We assume target mcu is running now,and send command to MCU for resetting to ISP mode
work flow:
sending reset cmd->mcu->wait response
if(response okay)
run download firmware process
*/
int download_firmware_all_in_one(const char* download_port,const char* firmware_filename){
uint8 io_buf[64];
uint8 payload_buffer[16];
int payload_len,packet_len;
int ret;
uint8 reset_delay=2;
mcu_xfer xfer;
payload_len=setup_vendor_payload(payload_buffer,16,CMD_CLASS_MCU,MCU_SUB_CMD_RESET,2/*params num*/,MCU_RESET_TYPE_ISP,reset_delay);
packet_len=setup_vendor_packet(io_buf,64,payload_buffer,payload_len);
xfer.xfer_type = XFER_TYPE_OUT_IN;
xfer.xfer_to = DEF_XFER_TIMEOUT_MS;
xfer.req = io_buf;xfer.reqsize = packet_len;
xfer.resp = io_buf,xfer.respsize = 64;
xfer.xfer_impl = NULL;
ret = submit_xfer(download_port,NULL,&xfer);
if(!ret){
if(STATUS_CODE(xfer.resp)==STATUS_CODE_SUCCESS){
printf("mcu reset in %dms\n"
"Enter download firmware process now...\n"
,reset_delay*1000);
return download_firmware(download_port,firmware_filename);
}else {
printf("mcu reset failed ,err=[%2x%2x]\n",io_buf[0],io_buf[1]);
return eDownloadErrCodeUnknown;
}
}
printf("xfer packet error[%x],please check your port\n",ret);
return eDownloadErrCodePortError;
}
static int gb_bootrom_firmware_size_request(struct gb_operation *op)
{
struct gb_bootrom *bootrom = gb_connection_get_data(op->connection);
struct gb_bootrom_firmware_size_request *size_request = op->request->payload;
struct gb_bootrom_firmware_size_response *size_response;
struct device *dev = &op->connection->bundle->dev;
int ret;
/* Disable timeouts */
cancel_delayed_work_sync(&bootrom->dwork);
if (op->request->payload_size != sizeof(*size_request)) {
dev_err(dev, "%s: illegal size of firmware size request (%zu != %zu)\n",
__func__, op->request->payload_size,
sizeof(*size_request));
ret = -EINVAL;
goto queue_work;
}
mutex_lock(&bootrom->mutex);
ret = download_firmware(bootrom, size_request->stage);
if (ret) {
dev_err(dev, "%s: failed to download firmware (%d)\n", __func__,
ret);
goto unlock;
}
if (!gb_operation_response_alloc(op, sizeof(*size_response),
GFP_KERNEL)) {
dev_err(dev, "%s: error allocating response\n", __func__);
free_firmware(bootrom);
ret = -ENOMEM;
goto unlock;
}
size_response = op->response->payload;
size_response->size = cpu_to_le32(bootrom->fw->size);
dev_dbg(dev, "%s: firmware size %d bytes\n", __func__, size_response->size);
unlock:
mutex_unlock(&bootrom->mutex);
queue_work:
/* Refresh timeout */
schedule_delayed_work(&bootrom->dwork, NEXT_REQ_TIMEOUT_J);
return ret;
}
static int gb_firmware_size_request(struct gb_operation *op)
{
struct gb_firmware *firmware = gb_connection_get_data(op->connection);
struct gb_firmware_size_request *size_request = op->request->payload;
struct gb_firmware_size_response *size_response;
struct device *dev = &op->connection->bundle->dev;
int ret;
if (op->request->payload_size != sizeof(*size_request)) {
dev_err(dev, "%s: illegal size of firmware size request (%zu != %zu)\n",
__func__, op->request->payload_size,
sizeof(*size_request));
return -EINVAL;
}
ret = download_firmware(firmware, size_request->stage);
if (ret) {
dev_err(dev, "%s: failed to download firmware (%d)\n", __func__,
ret);
return ret;
}
if (!gb_operation_response_alloc(op, sizeof(*size_response),
GFP_KERNEL)) {
dev_err(dev, "%s: error allocating response\n", __func__);
free_firmware(firmware);
return -ENOMEM;
}
size_response = op->response->payload;
size_response->size = cpu_to_le32(firmware->fw->size);
dev_dbg(dev, "%s: firmware size %d bytes\n", __func__, size_response->size);
return 0;
}
static int
start_cx28975(struct sbsh_softc *sc, struct cx28975_cfg cfg)
{
static char thresh[] = { +8, -4, -16, -40 };
volatile struct cx28975_cmdarea *p = sc->cmdp;
u_int8_t t, parm[12];
p->intr_host = 0;
t = p->intr_host;
/* reset chip set */
sc->regs->IMR = EXT;
sc->regs->CR = 0;
sc->regs->SR = 0xff;
DELAY(2);
sc->regs->CR = XRST;
if (cfg.crc16)
sc->regs->CR |= CMOD;
if (cfg.fill_7e)
sc->regs->CR |= FMOD;
if (cfg.inv)
sc->regs->CR |= PMOD;
sc->regs->CRB |= RODD | RXDE;
if (cfg.rburst)
sc->regs->CRB |= RDBE;
if (cfg.wburst)
sc->regs->CRB |= WTBE;
tsleep(sc, 0, "sbsh", 0);
if ((p->out_ack & 0x1f) != _ACK_BOOT_WAKE_UP)
return (-1);
if (download_firmware(sc, cfg.firmw_image, cfg.firmw_len))
return (-1);
tsleep(sc, 0, "sbsh", 0);
if ((p->out_ack & 0x1f) != _ACK_OPER_WAKE_UP)
return (-1);
t = cfg.master ? 1 : 9;
if (issue_cx28975_cmd(sc, _DSL_SYSTEM_ENABLE, &t, 1))
return (-1);
t = 0x63;
if (issue_cx28975_cmd(sc, _DSL_SYSTEM_CONFIG, &t, 1))
return (-1);
*(u_int16_t *)parm = cfg.lrate >> 3;
parm[2] = parm[3] = parm[0];
parm[5] = cfg.lrate & 7;
parm[4] = parm[7] = 1;
parm[6] = 0;
if (issue_cx28975_cmd(sc, _DSL_MULTI_RATE_CONFIG, parm, 8))
return (-1);
parm[0] = 0x02 | (cfg.mod << 4);
parm[1] = 0;
if (issue_cx28975_cmd(sc, _DSL_TRAINING_MODE, parm, 2))
return (-1);
bzero(parm, 12);
parm[0] = 0x04; /* pre-activation: G.hs */
parm[4] = 0x04; /* no remote configuration */
parm[7] = 0x01; /* annex A (default) */
parm[8] = 0xff; /* i-bit mask (all bits) */
if (issue_cx28975_cmd(sc, _DSL_PREACTIVATION_CFG, parm, 12))
return (-1);
parm[0] = 0x03; /* dying gasp time - 3 frames */
parm[1] = thresh[cfg.mod];
parm[2] = 0xff; /* attenuation */
parm[3] = 0x04; /* line probe NMR (+2 dB) */
parm[4] = 0x00; /* reserved */
parm[5] = 0x00;
if (issue_cx28975_cmd(sc, _DSL_THRESHOLDS, parm, 6))
return (-1);
t = cfg.master ? 0x23 : 0x21;
if (issue_cx28975_cmd(sc, _DSL_FR_PCM_CONFIG, &t, 1))
return (-1);
t = 0x02;
if (issue_cx28975_cmd(sc, _DSL_INTR_HOST_MASK, &t, 1))
return (-1);
sc->state = DOWN;
return (0);
}
bool Usb3Camera::upload_firmware (const std::string& firmware_package,
const std::string& firmware,
std::function<void(int)> progress)
{
int r = -1;
std::vector<unsigned char> fw;
if (is_package_file(firmware_package))
{
fw = extract_file_from_package(firmware_package, firmware);
}
else
fw = load_file(firmware_package);
if (fw.empty())
{
throw std::runtime_error("Firmware File could not be loaded correctly");
}
auto map_progress = [] ( std::function<void(int)> progress, int begin, int end )
{
return [=]( int x )
{
progress( begin + x * (end-begin) / 100 );
};
};
int retry = 0;
while (retry++ < 5)
{
progress( 0 );
r = erase_eeprom( map_progress( progress, 0, 20 ) );
if ( r < 0 )
{
continue;
}
try
{
r = upload_firmware_file( fw, map_progress( progress, 20, 70 ) );
}
catch (std::runtime_error& err)
{
}
if ( r < 0 )
{
continue;
}
std::vector<unsigned char> buffer( fw.size() );
try
{
r = download_firmware( buffer, map_progress( progress, 70, 100 ) );
}
catch (std::runtime_error& err)
{
throw;
}
if ( r < 0 )
continue;
if ( fw == buffer )
{
progress( 100 );
return true;
}
}
progress( 0 );
return false;
}
