github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-14 01:08:22 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

drm/bridge: add support for lontium lt8713sx bridge driver

Browse Source 
The lt8713sx is a Type-C/DP1.4 to DP1.4/HDMI2.0 converter,
with three configurable DP1.4/HDMI2.0/DP++ output interfaces and
audio output interface.

Driver is required for firmware upgrade and enabling the bridge chip.

Co-developed-by: Prahlad Valluru <vvalluru@qti.qualcomm.com>
Signed-off-by: Prahlad Valluru <vvalluru@qti.qualcomm.com>
Signed-off-by: Vishnu Saini <vishnu.saini@oss.qualcomm.com>
Reviewed-by: Dmitry Baryshkov <dmitry.baryshkov@oss.qualcomm.com>
Cc: Simon Zhu <xmzhu@lontium.corp-partner.google.com>
Link: https://patch.msgid.link/20260303-lt8713sx-bridge-driver-v5-2-6cc2a855aafa@oss.qualcomm.com
Signed-off-by: Dmitry Baryshkov <dmitry.baryshkov@oss.qualcomm.com>
This commit is contained in:
Vishnu Saini 2026-03-03 22:13:36 +05:30 committed by Dmitry Baryshkov
parent 130daea1cb
commit 4037c6adc1
3 changed files with 609 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
drivers/gpu/drm/bridge/Kconfig
View File

@ -191,6 +191,16 @@ config DRM_LONTIUM_LT9611UXC
HDMI signals
Please say Y if you have such hardware.
config DRM_LONTIUM_LT8713SX
tristate "Lontium LT8713SX DP MST bridge"
depends on OF
select REGMAP_I2C
help
Driver for Lontium LT8713SX DP MST bridge
chip firmware upgrade, which converts Type-C/DP1.4
to 3 configurable Type-C/DP1.4/HDMI2.0 outputs
Please say Y if you have such hardware.
config DRM_ITE_IT66121
tristate "ITE IT66121 HDMI bridge"
depends on OF

1
drivers/gpu/drm/bridge/Makefile
View File

@ -17,6 +17,7 @@ obj-$(CONFIG_DRM_LONTIUM_LT8912B) += lontium-lt8912b.o
obj-$(CONFIG_DRM_LONTIUM_LT9211) += lontium-lt9211.o
obj-$(CONFIG_DRM_LONTIUM_LT9611) += lontium-lt9611.o
obj-$(CONFIG_DRM_LONTIUM_LT9611UXC) += lontium-lt9611uxc.o
obj-$(CONFIG_DRM_LONTIUM_LT8713SX) += lontium-lt8713sx.o
obj-$(CONFIG_DRM_LVDS_CODEC) += lvds-codec.o
obj-$(CONFIG_DRM_MEGACHIPS_STDPXXXX_GE_B850V3_FW) += megachips-stdpxxxx-ge-b850v3-fw.o
obj-$(CONFIG_DRM_MICROCHIP_LVDS_SERIALIZER) += microchip-lvds.o

598
drivers/gpu/drm/bridge/lontium-lt8713sx.c Normal file
View File

@ -0,0 +1,598 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
*/
#include <linux/crc8.h>
#include <linux/firmware.h>
#include <linux/gpio/consumer.h>
#include <linux/i2c.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of_graph.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <linux/sizes.h>
#include <linux/wait.h>
#include <linux/workqueue.h>
#include <drm/drm_bridge.h>
#include <drm/drm_of.h>
#define FW_FILE "lt8713sx_fw.bin"
#define REG_PAGE_CONTROL 0xff
#define LT8713SX_PAGE_SIZE 256
DECLARE_CRC8_TABLE(lt8713sx_crc_table);
struct lt8713sx {
struct device *dev;
struct drm_bridge bridge;
struct drm_bridge *next_bridge;
struct regmap *regmap;
/* Protects all accesses to registers by stopping the on-chip MCU */
struct mutex ocm_lock;
struct gpio_desc *reset_gpio;
struct gpio_desc *enable_gpio;
struct i2c_client *client;
const struct firmware *fw;
u8 *fw_buffer;
u32 main_crc_value;
u32 bank_crc_value[17];
int bank_num;
};
static void lt8713sx_reset(struct lt8713sx *lt8713sx);
static const struct regmap_range lt8713sx_ranges[] = {
{
.range_min = 0x0000,
.range_max = 0xffff
},
};
static const struct regmap_access_table lt8713sx_table = {
.yes_ranges = lt8713sx_ranges,
.n_yes_ranges = ARRAY_SIZE(lt8713sx_ranges),
};
static const struct regmap_range_cfg lt8713sx_range_cfg = {
.name = "lt8713sx",
.range_min = 0x0000,
.range_max = 0xffff,
.selector_reg = REG_PAGE_CONTROL,
.selector_mask = 0xff,
.selector_shift = 0,
.window_start = 0,
.window_len = 0x100,
};
static const struct regmap_config lt8713sx_regmap_config = {
.reg_bits = 8,
.val_bits = 8,
.volatile_table = &lt8713sx_table,
.ranges = &lt8713sx_range_cfg,
.num_ranges = 1,
.cache_type = REGCACHE_NONE,
.max_register = 0xffff,
};
static void lt8713sx_i2c_enable(struct lt8713sx *lt8713sx)
{
regmap_write(lt8713sx->regmap, 0xe0ee, 0x01);
}
static void lt8713sx_i2c_disable(struct lt8713sx *lt8713sx)
{
regmap_write(lt8713sx->regmap, 0xe0ee, 0x00);
}
static int lt8713sx_prepare_firmware_data(struct lt8713sx *lt8713sx)
{
int ret = 0;
u64 sz_12k = 12 * SZ_1K;
ret = request_firmware(&lt8713sx->fw, FW_FILE, lt8713sx->dev);
if (ret < 0) {
dev_err(lt8713sx->dev, "request firmware failed\n");
return ret;
}
dev_dbg(lt8713sx->dev, "Firmware size: %zu bytes\n", lt8713sx->fw->size);
if (lt8713sx->fw->size > SZ_256K - 1) {
dev_err(lt8713sx->dev, "Firmware size exceeds 256KB limit\n");
release_firmware(lt8713sx->fw);
return -EINVAL;
}
lt8713sx->fw_buffer = kvmalloc(SZ_256K, GFP_KERNEL);
if (!lt8713sx->fw_buffer) {
release_firmware(lt8713sx->fw);
return -ENOMEM;
}
memset(lt8713sx->fw_buffer, 0xff, SZ_256K);
/* main firmware */
memcpy(lt8713sx->fw_buffer, lt8713sx->fw->data, SZ_64K - 1);
lt8713sx->fw_buffer[SZ_64K - 1] =
crc8(lt8713sx_crc_table, lt8713sx->fw_buffer, SZ_64K - 1, 0);
lt8713sx->main_crc_value = lt8713sx->fw_buffer[SZ_64K - 1];
dev_dbg(lt8713sx->dev,
"Main Firmware Data Crc = 0x%02X\n", lt8713sx->main_crc_value);
/* bank firmware */
memcpy(lt8713sx->fw_buffer + SZ_64K,
lt8713sx->fw->data + SZ_64K,
lt8713sx->fw->size - SZ_64K);
lt8713sx->bank_num = (lt8713sx->fw->size - SZ_64K + sz_12k - 1) / sz_12k;
dev_dbg(lt8713sx->dev, "Bank Number Total is %d.\n", lt8713sx->bank_num);
for (int i = 0; i < lt8713sx->bank_num; i++) {
lt8713sx->bank_crc_value[i] =
crc8(lt8713sx_crc_table, lt8713sx->fw_buffer + SZ_64K + i * sz_12k,
sz_12k, 0);
dev_dbg(lt8713sx->dev, "Bank number:%d; Firmware Data Crc:0x%02X\n",
i, lt8713sx->bank_crc_value[i]);
}
return 0;
}
static void lt8713sx_config_parameters(struct lt8713sx *lt8713sx)
{
regmap_write(lt8713sx->regmap, 0xe05e, 0xc1);
regmap_write(lt8713sx->regmap, 0xe058, 0x00);
regmap_write(lt8713sx->regmap, 0xe059, 0x50);
regmap_write(lt8713sx->regmap, 0xe05a, 0x10);
regmap_write(lt8713sx->regmap, 0xe05a, 0x00);
regmap_write(lt8713sx->regmap, 0xe058, 0x21);
}
static void lt8713sx_wren(struct lt8713sx *lt8713sx)
{
regmap_write(lt8713sx->regmap, 0xe103, 0xbf);
regmap_write(lt8713sx->regmap, 0xe103, 0xff);
regmap_write(lt8713sx->regmap, 0xe05a, 0x04);
regmap_write(lt8713sx->regmap, 0xe05a, 0x00);
}
static void lt8713sx_wrdi(struct lt8713sx *lt8713sx)
{
regmap_write(lt8713sx->regmap, 0xe05a, 0x08);
regmap_write(lt8713sx->regmap, 0xe05a, 0x00);
}
static void lt8713sx_fifo_reset(struct lt8713sx *lt8713sx)
{
regmap_write(lt8713sx->regmap, 0xe103, 0xbf);
regmap_write(lt8713sx->regmap, 0xe103, 0xff);
}
static void lt8713sx_disable_sram_write(struct lt8713sx *lt8713sx)
{
regmap_write(lt8713sx->regmap, 0xe055, 0x00);
}
static void lt8713sx_sram_to_flash(struct lt8713sx *lt8713sx)
{
regmap_write(lt8713sx->regmap, 0xe05a, 0x30);
regmap_write(lt8713sx->regmap, 0xe05a, 0x00);
}
static void lt8713sx_i2c_to_sram(struct lt8713sx *lt8713sx)
{
regmap_write(lt8713sx->regmap, 0xe055, 0x80);
regmap_write(lt8713sx->regmap, 0xe05e, 0xc0);
regmap_write(lt8713sx->regmap, 0xe058, 0x21);
}
static u8 lt8713sx_read_flash_status(struct lt8713sx *lt8713sx)
{
u32 flash_status = 0;
regmap_write(lt8713sx->regmap, 0xe103, 0x3f);
regmap_write(lt8713sx->regmap, 0xe103, 0xff);
regmap_write(lt8713sx->regmap, 0xe05e, 0x40);
regmap_write(lt8713sx->regmap, 0xe056, 0x05); /* opcode=read status register */
regmap_write(lt8713sx->regmap, 0xe055, 0x25);
regmap_write(lt8713sx->regmap, 0xe055, 0x01);
regmap_write(lt8713sx->regmap, 0xe058, 0x21);
regmap_read(lt8713sx->regmap, 0xe05f, &flash_status);
dev_dbg(lt8713sx->dev, "flash_status:%x\n", flash_status);
return flash_status;
}
static void lt8713sx_block_erase(struct lt8713sx *lt8713sx)
{
u32 i = 0;
u8 flash_status = 0;
u8 blocknum = 0x00;
u32 flashaddr = 0x00;
for (blocknum = 0; blocknum < 8; blocknum++) {
flashaddr = blocknum * SZ_32K;
regmap_write(lt8713sx->regmap, 0xe05a, 0x04);
regmap_write(lt8713sx->regmap, 0xe05a, 0x00);
regmap_write(lt8713sx->regmap, 0xe05b, flashaddr >> 16);
regmap_write(lt8713sx->regmap, 0xe05c, flashaddr >> 8);
regmap_write(lt8713sx->regmap, 0xe05d, flashaddr);
regmap_write(lt8713sx->regmap, 0xe05a, 0x01);
regmap_write(lt8713sx->regmap, 0xe05a, 0x00);
msleep(100);
i = 0;
while (1) {
flash_status = lt8713sx_read_flash_status(lt8713sx);
if ((flash_status & 0x01) == 0)
break;
if (i > 50)
break;
i++;
msleep(50);
}
}
dev_dbg(lt8713sx->dev, "erase flash done.\n");
}
static void lt8713sx_load_main_fw_to_sram(struct lt8713sx *lt8713sx)
{
regmap_write(lt8713sx->regmap, 0xe068, 0x00);
regmap_write(lt8713sx->regmap, 0xe069, 0x00);
regmap_write(lt8713sx->regmap, 0xe06a, 0x00);
regmap_write(lt8713sx->regmap, 0xe065, 0x00);
regmap_write(lt8713sx->regmap, 0xe066, 0xff);
regmap_write(lt8713sx->regmap, 0xe067, 0xff);
regmap_write(lt8713sx->regmap, 0xe06b, 0x00);
regmap_write(lt8713sx->regmap, 0xe06c, 0x00);
regmap_write(lt8713sx->regmap, 0xe060, 0x01);
msleep(200);
regmap_write(lt8713sx->regmap, 0xe060, 0x00);
}
static void lt8713sx_load_bank_fw_to_sram(struct lt8713sx *lt8713sx, u64 addr)
{
regmap_write(lt8713sx->regmap, 0xe068, ((addr & 0xff0000) >> 16));
regmap_write(lt8713sx->regmap, 0xe069, ((addr & 0x00ff00) >> 8));
regmap_write(lt8713sx->regmap, 0xe06a, (addr & 0x0000ff));
regmap_write(lt8713sx->regmap, 0xe065, 0x00);
regmap_write(lt8713sx->regmap, 0xe066, 0x30);
regmap_write(lt8713sx->regmap, 0xe067, 0x00);
regmap_write(lt8713sx->regmap, 0xe06b, 0x00);
regmap_write(lt8713sx->regmap, 0xe06c, 0x00);
regmap_write(lt8713sx->regmap, 0xe060, 0x01);
msleep(50);
regmap_write(lt8713sx->regmap, 0xe060, 0x00);
}
static int lt8713sx_write_data(struct lt8713sx *lt8713sx, const u8 *data, u64 filesize)
{
int page = 0, num = 0, i = 0, val;
page = (filesize % LT8713SX_PAGE_SIZE) ?
((filesize / LT8713SX_PAGE_SIZE) + 1) : (filesize / LT8713SX_PAGE_SIZE);
dev_dbg(lt8713sx->dev,
"Writing to Sram=%u pages, total size = %llu bytes\n", page, filesize);
for (num = 0; num < page; num++) {
dev_dbg(lt8713sx->dev, "page[%d]\n", num);
lt8713sx_i2c_to_sram(lt8713sx);
for (i = 0; i < LT8713SX_PAGE_SIZE; i++) {
if ((num * LT8713SX_PAGE_SIZE + i) < filesize)
val = *(data + (num * LT8713SX_PAGE_SIZE + i));
else
val = 0xff;
regmap_write(lt8713sx->regmap, 0xe059, val);
}
lt8713sx_wren(lt8713sx);
lt8713sx_sram_to_flash(lt8713sx);
}
lt8713sx_wrdi(lt8713sx);
lt8713sx_disable_sram_write(lt8713sx);
return 0;
}
static void lt8713sx_main_upgrade_result(struct lt8713sx *lt8713sx)
{
u32 main_crc_result;
regmap_read(lt8713sx->regmap, 0xe023, &main_crc_result);
dev_dbg(lt8713sx->dev, "Main CRC HW: 0x%02X\n", main_crc_result);
dev_dbg(lt8713sx->dev, "Main CRC FW: 0x%02X\n", lt8713sx->main_crc_value);
if (main_crc_result == lt8713sx->main_crc_value)
dev_info(lt8713sx->dev, "Main Firmware Upgrade Success.\n");
else
dev_err(lt8713sx->dev, "Main Firmware Upgrade Failed.\n");
}
static void lt8713sx_bank_upgrade_result(struct lt8713sx *lt8713sx, u8 banknum)
{
u32 bank_crc_result;
regmap_read(lt8713sx->regmap, 0xe023, &bank_crc_result);
dev_dbg(lt8713sx->dev, "Bank %d CRC Result: 0x%02X\n", banknum, bank_crc_result);
if (bank_crc_result == lt8713sx->bank_crc_value[banknum])
dev_info(lt8713sx->dev, "Bank %d Firmware Upgrade Success.\n", banknum);
else
dev_err(lt8713sx->dev, "Bank %d Firmware Upgrade Failed.\n", banknum);
}
static void lt8713sx_bank_result_check(struct lt8713sx *lt8713sx)
{
int i;
u64 addr = 0x010000;
for (i = 0; i < lt8713sx->bank_num; i++) {
lt8713sx_load_bank_fw_to_sram(lt8713sx, addr);
lt8713sx_bank_upgrade_result(lt8713sx, i);
addr += 0x3000;
}
}
static int lt8713sx_firmware_upgrade(struct lt8713sx *lt8713sx)
{
int ret;
lt8713sx_config_parameters(lt8713sx);
lt8713sx_block_erase(lt8713sx);
if (lt8713sx->fw->size < SZ_64K) {
ret = lt8713sx_write_data(lt8713sx, lt8713sx->fw_buffer, SZ_64K);
if (ret < 0) {
dev_err(lt8713sx->dev, "Failed to write firmware data: %d\n", ret);
return ret;
}
} else {
ret = lt8713sx_write_data(lt8713sx, lt8713sx->fw_buffer, lt8713sx->fw->size);
if (ret < 0) {
dev_err(lt8713sx->dev, "Failed to write firmware data: %d\n", ret);
return ret;
}
}
dev_dbg(lt8713sx->dev, "Write Data done.\n");
return 0;
}
static int lt8713sx_firmware_update(struct lt8713sx *lt8713sx)
{
int ret = 0;
guard(mutex)(&lt8713sx->ocm_lock);
lt8713sx_i2c_enable(lt8713sx);
ret = lt8713sx_prepare_firmware_data(lt8713sx);
if (ret < 0) {
dev_err(lt8713sx->dev, "Failed to prepare firmware data: %d\n", ret);
goto error;
}
ret = lt8713sx_firmware_upgrade(lt8713sx);
if (ret < 0) {
dev_err(lt8713sx->dev, "Upgrade failure.\n");
goto error;
}
/* Validate CRC */
lt8713sx_load_main_fw_to_sram(lt8713sx);
lt8713sx_main_upgrade_result(lt8713sx);
lt8713sx_wrdi(lt8713sx);
lt8713sx_fifo_reset(lt8713sx);
lt8713sx_bank_result_check(lt8713sx);
lt8713sx_wrdi(lt8713sx);
error:
lt8713sx_i2c_disable(lt8713sx);
if (!ret)
lt8713sx_reset(lt8713sx);
kvfree(lt8713sx->fw_buffer);
lt8713sx->fw_buffer = NULL;
if (lt8713sx->fw) {
release_firmware(lt8713sx->fw);
lt8713sx->fw = NULL;
}
return ret;
}
static void lt8713sx_reset(struct lt8713sx *lt8713sx)
{
dev_dbg(lt8713sx->dev, "reset bridge.\n");
gpiod_set_value_cansleep(lt8713sx->reset_gpio, 1);
msleep(20);
gpiod_set_value_cansleep(lt8713sx->reset_gpio, 0);
msleep(20);
dev_dbg(lt8713sx->dev, "reset done.\n");
}
static int lt8713sx_regulator_enable(struct lt8713sx *lt8713sx)
{
int ret;
ret = devm_regulator_get_enable(lt8713sx->dev, "vdd");
if (ret < 0)
return dev_err_probe(lt8713sx->dev, ret, "failed to enable vdd regulator\n");
usleep_range(1000, 10000);
ret = devm_regulator_get_enable(lt8713sx->dev, "vcc");
if (ret < 0)
return dev_err_probe(lt8713sx->dev, ret, "failed to enable vcc regulator\n");
return 0;
}
static int lt8713sx_bridge_attach(struct drm_bridge *bridge,
struct drm_encoder *encoder,
enum drm_bridge_attach_flags flags)
{
struct lt8713sx *lt8713sx = container_of(bridge, struct lt8713sx, bridge);
return drm_bridge_attach(encoder,
lt8713sx->next_bridge,
bridge, flags);
}
static int lt8713sx_gpio_init(struct lt8713sx *lt8713sx)
{
struct device *dev = lt8713sx->dev;
lt8713sx->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
if (IS_ERR(lt8713sx->reset_gpio))
return dev_err_probe(dev, PTR_ERR(lt8713sx->reset_gpio),
"failed to acquire reset gpio\n");
/* power enable gpio */
lt8713sx->enable_gpio = devm_gpiod_get_optional(dev, "enable", GPIOD_OUT_HIGH);
if (IS_ERR(lt8713sx->enable_gpio))
return dev_err_probe(dev, PTR_ERR(lt8713sx->enable_gpio),
"failed to acquire enable gpio\n");
return 0;
}
static ssize_t lt8713sx_firmware_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
{
struct lt8713sx *lt8713sx = dev_get_drvdata(dev);
int ret;
ret = lt8713sx_firmware_update(lt8713sx);
if (ret < 0)
return ret;
return len;
}
static DEVICE_ATTR_WO(lt8713sx_firmware);
static struct attribute *lt8713sx_attrs[] = {
&dev_attr_lt8713sx_firmware.attr,
NULL,
};
static const struct attribute_group lt8713sx_attr_group = {
.attrs = lt8713sx_attrs,
};
static const struct attribute_group *lt8713sx_attr_groups[] = {
&lt8713sx_attr_group,
NULL,
};
static const struct drm_bridge_funcs lt8713sx_bridge_funcs = {
.attach = lt8713sx_bridge_attach,
};
static int lt8713sx_probe(struct i2c_client *client)
{
struct lt8713sx *lt8713sx;
struct device *dev = &client->dev;
int ret;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
return dev_err_probe(dev, -ENODEV, "device doesn't support I2C\n");
lt8713sx = devm_drm_bridge_alloc(dev, struct lt8713sx, bridge, &lt8713sx_bridge_funcs);
if (IS_ERR(lt8713sx))
return PTR_ERR(lt8713sx);
lt8713sx->dev = dev;
lt8713sx->client = client;
i2c_set_clientdata(client, lt8713sx);
ret = devm_mutex_init(lt8713sx->dev, &lt8713sx->ocm_lock);
if (ret)
return ret;
lt8713sx->regmap = devm_regmap_init_i2c(client, &lt8713sx_regmap_config);
if (IS_ERR(lt8713sx->regmap))
return dev_err_probe(dev, PTR_ERR(lt8713sx->regmap), "regmap i2c init failed\n");
ret = drm_of_find_panel_or_bridge(lt8713sx->dev->of_node, 1, -1, NULL,
&lt8713sx->next_bridge);
if (ret < 0)
return ret;
ret = lt8713sx_gpio_init(lt8713sx);
if (ret < 0)
return ret;
ret = lt8713sx_regulator_enable(lt8713sx);
if (ret)
return ret;
lt8713sx_reset(lt8713sx);
lt8713sx->bridge.funcs = &lt8713sx_bridge_funcs;
lt8713sx->bridge.of_node = dev->of_node;
lt8713sx->bridge.type = DRM_MODE_CONNECTOR_DisplayPort;
drm_bridge_add(&lt8713sx->bridge);
crc8_populate_msb(lt8713sx_crc_table, 0x31);
return 0;
}
static void lt8713sx_remove(struct i2c_client *client)
{
struct lt8713sx *lt8713sx = i2c_get_clientdata(client);
drm_bridge_remove(&lt8713sx->bridge);
}
static struct i2c_device_id lt8713sx_id[] = {
{ "lontium,lt8713sx", 0 },
{ /* sentinel */ }
};
static const struct of_device_id lt8713sx_match_table[] = {
{ .compatible = "lontium,lt8713sx" },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, lt8713sx_match_table);
static struct i2c_driver lt8713sx_driver = {
.driver = {
.name = "lt8713sx",
.of_match_table = lt8713sx_match_table,
.dev_groups = lt8713sx_attr_groups,
},
.probe = lt8713sx_probe,
.remove = lt8713sx_remove,
.id_table = lt8713sx_id,
};
module_i2c_driver(lt8713sx_driver);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("lt8713sx drm bridge driver");
MODULE_AUTHOR("Vishnu Saini <vishnu.saini@oss.qualcomm.com>");
MODULE_FIRMWARE(FW_FILE);