int cx25840_loadfw(struct i2c_client *client)
{
struct cx25840_state *state = to_state(i2c_get_clientdata(client));
const struct firmware *fw = NULL;
u8 buffer[FWSEND];
const u8 *ptr;
const char *fwname = get_fw_name(client);
int size, retval;
int max_buf_size = FWSEND;
u32 gpio_oe = 0, gpio_da = 0;
if (is_cx2388x(state)) {
/* Preserve the GPIO OE and output bits */
gpio_oe = cx25840_read(client, 0x160);
gpio_da = cx25840_read(client, 0x164);
}
/* cx231xx cannot accept more than 16 bytes at a time */
if (is_cx231xx(state) && max_buf_size > 16)
max_buf_size = 16;
if (request_firmware(&fw, fwname, FWDEV(client)) != 0)
return -EINVAL;
start_fw_load(client);
buffer[0] = 0x08;
buffer[1] = 0x02;
size = fw->size;
ptr = fw->data;
while (size > 0) {
int len = min(max_buf_size - 2, size);
memcpy(buffer + 2, ptr, len);
retval = fw_write(client, buffer, len + 2);
if (retval < 0) {
release_firmware(fw);
return retval;
}
size -= len;
ptr += len;
}
end_fw_load(client);
size = fw->size;
release_firmware(fw);
if (is_cx2388x(state)) {
/* Restore GPIO configuration after f/w load */
cx25840_write(client, 0x160, gpio_oe);
cx25840_write(client, 0x164, gpio_da);
}
return check_fw_load(client, size);
}
int cx25840_loadfw(struct i2c_client *client)
{
struct cx25840_state *state = to_state(i2c_get_clientdata(client));
const struct firmware *fw = NULL;
u8 buffer[FWSEND];
const u8 *ptr;
int size, retval;
int MAX_BUF_SIZE = FWSEND;
if (state->is_cx23885)
firmware = FWFILE_CX23885;
else if (state->is_cx231xx)
firmware = FWFILE_CX231XX;
if ((state->is_cx231xx) && MAX_BUF_SIZE > 16) {
v4l_err(client, " Firmware download size changed to 16 bytes max length\n");
MAX_BUF_SIZE = 16; /* cx231xx cannot accept more than 16 bytes at a time */
}
if (request_firmware(&fw, firmware, FWDEV(client)) != 0) {
v4l_err(client, "unable to open firmware %s\n", firmware);
return -EINVAL;
}
start_fw_load(client);
buffer[0] = 0x08;
buffer[1] = 0x02;
size = fw->size;
ptr = fw->data;
while (size > 0) {
int len = min(MAX_BUF_SIZE - 2, size);
memcpy(buffer + 2, ptr, len);
retval = fw_write(client, buffer, len + 2);
if (retval < 0) {
release_firmware(fw);
return retval;
}
size -= len;
ptr += len;
}
end_fw_load(client);
size = fw->size;
release_firmware(fw);
return check_fw_load(client, size);
}
int raw1394_write(raw1394handle_t handle, nodeid_t node, nodeaddr_t addr,
size_t length, quadlet_t *data)
{
if (!handle) {
errno = EINVAL;
return -1;
}
if (handle->is_fw)
return fw_write(handle, node, addr, length, data);
else
return ieee1394_write(handle, node, addr, length, data);
}
static int load_kernel_fw_bootmode(struct i2c_client *client, const char *pFn)
{
unsigned int uFrameSize;
unsigned int uPos = 0;
int iRet = SUCCESS;
int iCheckFrameCrcError = 0;
int iCheckWatingFrameDataError = 0;
const struct firmware *fw = NULL;
pr_info("[SSP] ssp_load_fw start!!!\n");
if (request_firmware(&fw, pFn, &client->dev)) {
iRet = ERROR;
pr_err("[SSP]: %s - Unable to open firmware %s\n",
__func__, pFn);
return iRet;
}
/* Unlock bootloader */
unlock_bootloader(client);
while (uPos < fw->size) {
if (check_bootloader(client, BL_WAITING_FRAME_DATA)) {
iCheckWatingFrameDataError++;
if (iCheckWatingFrameDataError > 10) {
iRet = ERROR;
pr_err("[SSP]: %s - F/W update fail\n",
__func__);
goto out;
} else {
pr_err("[SSP]: %s - F/W data_error %d, retry\n",
__func__, iCheckWatingFrameDataError);
continue;
}
}
uFrameSize = ((*(fw->data + uPos) << 8) |
*(fw->data + uPos + 1));
/* We should add 2 at frame size as the the firmware data is not
* included the CRC bytes.
*/
uFrameSize += 2;
/* Write one frame to device */
fw_write(client, fw->data + uPos, uFrameSize);
if (check_bootloader(client, BL_FRAME_CRC_PASS)) {
iCheckFrameCrcError++;
if (iCheckFrameCrcError > 10) {
iRet = ERROR;
pr_err("[SSP]: %s - F/W Update Fail. crc err\n",
__func__);
goto out;
} else {
pr_err("[SSP]: %s - F/W crc_error %d, retry\n",
__func__, iCheckFrameCrcError);
continue;
}
}
uPos += uFrameSize;
pr_info("[SSP] Updated %d bytes / %zd bytes\n", uPos, fw->size);
mdelay(1);
}
out:
release_firmware(fw);
return iRet;
}
static int load_ums_fw_bootmode(struct i2c_client *client, const char *pFn)
{
const u8 *buff = NULL;
char fw_path[BL_UMS_FW_PATH+1];
unsigned int uFrameSize;
unsigned int uFSize = 0, uNRead = 0;
unsigned int uPos = 0;
int iRet = SUCCESS;
int iCheckFrameCrcError = 0;
int iCheckWatingFrameDataError = 0;
struct file *fp = NULL;
mm_segment_t old_fs = get_fs();
pr_info("[SSP] ssp_load_ums_fw start!!!\n");
old_fs = get_fs();
set_fs(get_ds());
snprintf(fw_path, BL_UMS_FW_PATH, "/sdcard/ssp/%s", pFn);
fp = filp_open(fw_path, O_RDONLY, 0);
if (IS_ERR(fp)) {
iRet = ERROR;
pr_err("file %s open error:%d\n", fw_path, (s32)fp);
goto err_open;
}
uFSize = (unsigned int)fp->f_path.dentry->d_inode->i_size;
pr_info("ssp_load_ums firmware size: %u\n", uFSize);
buff = kzalloc((size_t)uFSize, GFP_KERNEL);
if (!buff) {
iRet = ERROR;
pr_err("fail to alloc buffer for fw\n");
goto err_alloc;
}
uNRead = (unsigned int)vfs_read(fp, (char __user *)buff,
(unsigned int)uFSize, &fp->f_pos);
if (uNRead != uFSize) {
iRet = ERROR;
pr_err("fail to read file %s (nread = %u)\n", fw_path, uNRead);
goto err_fw_size;
}
/* Unlock bootloader */
unlock_bootloader(client);
while (uPos < uFSize) {
if (check_bootloader(client, BL_WAITING_FRAME_DATA)) {
iCheckWatingFrameDataError++;
if (iCheckWatingFrameDataError > 10) {
iRet = ERROR;
pr_err("[SSP]: %s - F/W update fail\n",
__func__);
goto out;
} else {
pr_err("[SSP]: %s - F/W data_error %d, retry\n",
__func__, iCheckWatingFrameDataError);
continue;
}
}
uFrameSize = (unsigned int)((*(buff + uPos) << 8) |
*(buff + uPos + 1));
/* We should add 2 at frame size as the the firmware data is not
* included the CRC bytes.
*/
uFrameSize += 2;
/* Write one frame to device */
fw_write(client, buff + uPos, uFrameSize);
if (check_bootloader(client, BL_FRAME_CRC_PASS)) {
iCheckFrameCrcError++;
if (iCheckFrameCrcError > 10) {
iRet = ERROR;
pr_err("[SSP]: %s - F/W Update Fail. crc err\n",
__func__);
goto out;
} else {
pr_err("[SSP]: %s - F/W crc_error %d, retry\n",
__func__, iCheckFrameCrcError);
continue;
}
}
uPos += uFrameSize;
pr_info("[SSP] Updated %u bytes / %u bytes\n", uPos, uFSize);
mdelay(1);
}
out:
err_fw_size:
kfree(buff);
err_alloc:
filp_close(fp, NULL);
err_open:
set_fs(old_fs);
return iRet;
}
static int load_kernel_fw_bootmode(struct ssp_data *data, const char *pFn)
{
const struct firmware *fw = NULL;
unsigned int uFrameSize;
unsigned int uPos = 0;
int iRet;
int iCheckFrameCrcError = 0;
int iCheckWatingFrameDataError = 0;
int count = 0;
pr_info("[SSP] ssp_load_fw start!!!\n");
iRet = request_firmware(&fw, pFn, &data->spi->dev);
if (iRet) {
pr_err("[SSP]: %s - Unable to open firmware %s\n",
__func__, pFn);
return iRet;
}
/* Unlock bootloader */
iRet = unlock_bootloader(data);
if (iRet < 0) {
pr_err("[SSP] %s - unlock_bootloader failed! %d\n",
__func__, iRet);
goto out;
}
while (uPos < fw->size) {
iRet = check_bootloader(data, BL_WAITING_FRAME_DATA);
if (iRet) {
iCheckWatingFrameDataError++;
if (iCheckWatingFrameDataError > 10) {
pr_err("[SSP]: %s - F/W update fail\n",
__func__);
goto out;
} else {
pr_err("[SSP]: %s - F/W data_error %d, retry\n",
__func__, iCheckWatingFrameDataError);
continue;
}
}
uFrameSize = ((*(fw->data + uPos) << 8) |
*(fw->data + uPos + 1));
/* We should add 2 at frame size as the the firmware data is not
* included the CRC bytes.
*/
uFrameSize += 2;
/* Write one frame to device */
fw_write(data, fw->data + uPos, uFrameSize);
iRet = check_bootloader(data, BL_FRAME_CRC_PASS);
if (iRet) {
iCheckFrameCrcError++;
if (iCheckFrameCrcError > 10) {
pr_err("[SSP]: %s - F/W Update Fail. crc err\n",
__func__);
goto out;
} else {
pr_err("[SSP]: %s - F/W crc_error %d, retry\n",
__func__, iCheckFrameCrcError);
continue;
}
}
uPos += uFrameSize;
if (count++ == 100) {
pr_info("[SSP] Updated %d bytes / %zd bytes\n", uPos,
fw->size);
count = 0;
}
}
pr_info("[SSP] Firmware download is success.(%d bytes)\n", uPos);
out:
release_firmware(fw);
return iRet;
}
