if (c->x86 >= 0x15)
snprintf(fw_name, sizeof(fw_name), "amd-ucode/microcode_amd_fam%.2xh.bin", c->x86);
- if (request_firmware_direct(&fw, (const char *)fw_name, device)) {
- pr_debug("failed to load file %s\n", fw_name);
+ if (request_firmware_direct(&fw, (const char *)fw_name, device))
goto out;
- }
ret = UCODE_ERROR;
if (!verify_container(fw->data, fw->size, false))
int err;
sprintf(buf, "%s%s", fore200e->bus->proc_name, FW_EXT);
- if ((err = request_firmware(&firmware, buf, fore200e->dev)) < 0) {
- printk(FORE200E "problem loading firmware image %s\n", fore200e->bus->model_name);
+ err = request_firmware(&firmware, buf, fore200e->dev);
+ if (err)
return err;
- }
fw_data = (const __le32 *)firmware->data;
fw_size = firmware->size / sizeof(u32);
le32_to_cpu(fw_version.rom_version));
ret = request_firmware(&firmware, filename, &udev->dev);
- if (ret < 0) {
- BT_ERR("Patch file not found %s", filename);
+ if (ret)
return ret;
- }
pt_rom_version = get_unaligned_le32(firmware->data +
firmware->size - 8);
le32_to_cpu(fw_version.rom_version), clk_value, ".dfu");
ret = request_firmware(&firmware, filename, &udev->dev);
- if (ret < 0) {
- BT_ERR("Configuration file not found %s", filename);
+ if (ret)
return ret;
- }
ret = ath3k_load_fwfile(udev, firmware);
release_firmware(firmware);
return -ENOMEM;
if (request_firmware(&firmware, "BCM2033-MD.hex", &udev->dev) < 0) {
- BT_ERR("Mini driver request failed");
usb_free_urb(data->urb);
return -EIO;
}
release_firmware(firmware);
if (request_firmware(&firmware, "BCM2033-FW.bin", &udev->dev) < 0) {
- BT_ERR("Firmware request failed");
usb_free_urb(data->urb);
kfree(data->buffer);
return -EIO;
skb_queue_head_init(&data->pending_q);
skb_queue_head_init(&data->completed_q);
- if (request_firmware(&firmware, "bfubase.frm", &udev->dev) < 0) {
- BT_ERR("Firmware request failed");
+ if (request_firmware(&firmware, "bfubase.frm", &udev->dev))
goto done;
- }
BT_DBG("firmware data %p size %zu", firmware->data, firmware->size);
/* Load firmware */
err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
- if (err < 0) {
- BT_ERR("Firmware request failed");
+ if (err)
goto error;
- }
err = bt3c_load_firmware(info, firmware->data, firmware->size);
ret = request_firmware(&fw_helper, card->helper,
&card->func->dev);
if ((ret < 0) || !fw_helper) {
- BT_ERR("request_firmware(helper) failed, error code = %d",
- ret);
ret = -ENOENT;
goto done;
}
ret = request_firmware(&fw_firmware, card->firmware,
&card->func->dev);
if ((ret < 0) || !fw_firmware) {
- BT_ERR("request_firmware(firmware) failed, error code = %d",
- ret);
ret = -ENOENT;
goto done;
}
}
err = request_firmware(&fw, fw_name, &pdev->dev);
platform_device_unregister(pdev);
- if (err) {
- printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
- fw_name, err);
+ if (err)
return err;
- }
if (fw->size % 3) {
printk(KERN_ERR "Bogus length %d in image \"%s\"\n",
fw->size, fw_name);
const struct sdma_script_start_addrs *addr;
unsigned short *ram_code;
- if (!fw) {
- dev_info(sdma->dev, "external firmware not found, using ROM firmware\n");
- /* In this case we just use the ROM firmware. */
+ if (!fw)
return;
- }
if (fw->size < sizeof(*header))
goto err_firmware;
}
rc = request_ihex_firmware(&fw, firmware_name, &pdev->dev);
platform_device_unregister(pdev);
- if (rc) {
- DRM_ERROR("mga: Failed to load microcode \"%s\"\n",
- firmware_name);
+ if (rc)
return rc;
- }
size = 0;
where = 0;
if (ret) {
snprintf(f, sizeof(f), "nouveau/%s", name);
ret = request_firmware(&fw, f, device->dev);
- if (ret) {
- nvkm_error(subdev, "failed to load %s\n", name);
+ if (ret)
return ret;
- }
}
blob->size = fw->size;
}
rc = request_firmware(&fw, FIRMWARE_NAME, &pdev->dev);
platform_device_unregister(pdev);
- if (rc) {
- pr_err("r128_cce: Failed to load firmware \"%s\"\n",
- FIRMWARE_NAME);
+ if (rc)
return rc;
- }
if (fw->size != 256 * 8) {
pr_err("r128_cce: Bogus length %zu in firmware \"%s\"\n",
out:
if (err) {
- if (err != -EINVAL)
- pr_err("ni_cp: Failed to load firmware \"%s\"\n",
- fw_name);
release_firmware(rdev->pfp_fw);
rdev->pfp_fw = NULL;
release_firmware(rdev->me_fw);
}
err = request_firmware(&rdev->me_fw, fw_name, rdev->dev);
- if (err) {
- pr_err("radeon_cp: Failed to load firmware \"%s\"\n", fw_name);
- } else if (rdev->me_fw->size % 8) {
+ if (err == 0 && rdev->me_fw->size % 8) {
pr_err("radeon_cp: Bogus length %zu in firmware \"%s\"\n",
rdev->me_fw->size, fw_name);
err = -EINVAL;
out:
if (err) {
- if (err != -EINVAL)
- pr_err("r600_cp: Failed to load firmware \"%s\"\n",
- fw_name);
release_firmware(rdev->pfp_fw);
rdev->pfp_fw = NULL;
release_firmware(rdev->me_fw);
}
ret = request_firmware(&fw, SD7220_FW_NAME, &dd->pcidev->dev);
- if (ret) {
- qib_dev_err(dd, "Failed to load IB SERDES image\n");
+ if (ret)
goto done;
- }
/* Substitute our deduced value for was_reset */
ret = qib_ibsd_ucode_loaded(dd->pport, fw);
int ret;
ret = request_firmware(&fw, fn, dev);
- if (ret) {
- dev_err(dev, "Unable to open firmware %s\n", fn);
+ if (ret)
return ret;
- }
/* Check for incorrect enc file */
ret = mxt_check_firmware_format(dev, fw);
card->isar.owner = THIS_MODULE;
err = request_firmware(&firmware, "isdn/ISAR.BIN", &card->pdev->dev);
- if (err < 0) {
- pr_info("%s: firmware request failed %d\n",
- card->name, err);
+ if (err)
goto error_fw;
- }
if (debug & DEBUG_HW)
pr_notice("%s: got firmware %zu bytes\n",
card->name, firmware->size);
return -EINVAL;
rc = request_firmware(&fw, fw_filename, coredev->device);
- if (rc < 0) {
- pr_err("failed to open firmware file '%s'\n", fw_filename);
+ if (rc < 0)
return rc;
- }
pr_debug("read fw %s, buffer size=0x%zx\n", fw_filename, fw->size);
fw_buf = kmalloc(ALIGN(fw->size + sizeof(struct sms_firmware),
SMS_ALLOC_ALIGNMENT), GFP_KERNEL | coredev->gfp_buf_flags);
/* Request the firmware, will block and timeout */
ret = request_firmware(&firmware, name, &client->dev);
- if (ret) {
- dev_info(&client->dev, "firmware file '%s' not found %d\n",
- name, ret);
+ if (ret)
goto err;
- }
-
- dev_info(&client->dev, "downloading firmware from file '%s'\n",
- name);
/* Write firmware checksum & size */
for (i = 0; i < firmware->size; i++)
int ret,i;
deb_info("requesting firmware\n");
- if ((ret = st->config->request_firmware(fe, &fw, BCM3510_DEFAULT_FIRMWARE)) < 0) {
- err("could not load firmware (%s): %d",BCM3510_DEFAULT_FIRMWARE,ret);
+ ret = st->config->request_firmware(fe, &fw, BCM3510_DEFAULT_FIRMWARE);
+ if (ret)
return ret;
- }
deb_info("got firmware: %zu\n", fw->size);
b = fw->data;
__func__, CX24116_DEFAULT_FIRMWARE);
ret = request_firmware(&fw, CX24116_DEFAULT_FIRMWARE,
state->i2c->dev.parent);
- printk(KERN_INFO "%s: Waiting for firmware upload(2)...\n",
- __func__);
- if (ret) {
- printk(KERN_ERR "%s: No firmware uploaded (timeout or file not found?)\n",
- __func__);
+ if (ret)
return ret;
- }
/* Make sure we don't recurse back through here
* during loading */
{
const struct firmware *fw;
- if (request_firmware(&fw, fw_name, state->dev) < 0) {
- printk(KERN_ERR "drxd: firmware load failure [%s]\n", fw_name);
+ if (request_firmware(&fw, fw_name, state->dev))
return -EIO;
- }
state->microcode = kmemdup(fw->data, fw->size, GFP_KERNEL);
if (!state->microcode) {
dprintk(1, ": %s\n", fw ? "firmware loaded" : "firmware not loaded");
if (!fw) {
- pr_err("Could not load firmware file %s.\n",
- state->microcode_name);
- pr_info("Copy %s to your hotplug directory!\n",
- state->microcode_name);
state->microcode_name = NULL;
/*
DS3000_DEFAULT_FIRMWARE);
ret = request_firmware(&fw, DS3000_DEFAULT_FIRMWARE,
state->i2c->dev.parent);
- printk(KERN_INFO "%s: Waiting for firmware upload(2)...\n", __func__);
- if (ret) {
- printk(KERN_ERR "%s: No firmware uploaded (timeout or file not found?)\n",
- __func__);
+ if (ret)
return ret;
- }
ret = ds3000_load_firmware(fe, fw);
if (ret)
__func__, NXT2002_DEFAULT_FIRMWARE);
ret = request_firmware(&fw, NXT2002_DEFAULT_FIRMWARE,
state->i2c->dev.parent);
- pr_debug("%s: Waiting for firmware upload(2)...\n", __func__);
- if (ret) {
- pr_err("%s: No firmware uploaded (timeout or file not found?)\n",
- __func__);
+ if (ret)
return ret;
- }
ret = nxt2002_load_firmware(fe, fw);
release_firmware(fw);
__func__, NXT2004_DEFAULT_FIRMWARE);
ret = request_firmware(&fw, NXT2004_DEFAULT_FIRMWARE,
state->i2c->dev.parent);
- pr_debug("%s: Waiting for firmware upload(2)...\n", __func__);
- if (ret) {
- pr_err("%s: No firmware uploaded (timeout or file not found?)\n",
- __func__);
+ if (ret)
return ret;
- }
ret = nxt2004_load_firmware(fe, fw);
release_firmware(fw);
printk("or51132: Waiting for firmware upload(%s)...\n",
fwname);
ret = request_firmware(&fw, fwname, state->i2c->dev.parent);
- if (ret) {
- printk(KERN_WARNING "or51132: No firmware uploaded(timeout or file not found?)\n");
+ if (ret)
return ret;
- }
ret = or51132_load_firmware(fe, fw);
release_firmware(fw);
if (ret) {
OR51211_DEFAULT_FIRMWARE);
ret = config->request_firmware(fe, &fw,
OR51211_DEFAULT_FIRMWARE);
- pr_info("Got Hotplug firmware\n");
- if (ret) {
- pr_warn("No firmware uploaded (timeout or file not found?)\n");
+ if (ret)
return ret;
- }
ret = or51211_load_firmware(fe, fw);
release_firmware(fw);
/* request the firmware, this will block until someone uploads it */
printk("sp887x: waiting for firmware upload (%s)...\n", SP887X_DEFAULT_FIRMWARE);
ret = state->config->request_firmware(fe, &fw, SP887X_DEFAULT_FIRMWARE);
- if (ret) {
- printk("sp887x: no firmware upload (timeout or file not found?)\n");
+ if (ret)
return ret;
- }
ret = sp887x_initial_setup(fe, fw);
release_firmware(fw);
ret = request_firmware(&fw, TDA10048_DEFAULT_FIRMWARE,
state->i2c->dev.parent);
if (ret) {
- printk(KERN_ERR "%s: Upload failed. (file not found?)\n",
- __func__);
return -EIO;
} else {
printk(KERN_INFO "%s: firmware read %zu bytes.\n",
/* request the firmware, this will block until someone uploads it */
printk(KERN_INFO "tda1004x: waiting for firmware upload (%s)...\n", TDA10045_DEFAULT_FIRMWARE);
ret = state->config->request_firmware(fe, &fw, TDA10045_DEFAULT_FIRMWARE);
- if (ret) {
- printk(KERN_ERR "tda1004x: no firmware upload (timeout or file not found?)\n");
+ if (ret)
return ret;
- }
/* reset chip */
tda1004x_write_mask(state, TDA1004X_CONFC4, 0x10, 0);
/* remain compatible to old bug: try to load with tda10045 image name */
ret = state->config->request_firmware(fe, &fw, TDA10045_DEFAULT_FIRMWARE);
if (ret) {
- printk(KERN_ERR "tda1004x: no firmware upload (timeout or file not found?)\n");
return ret;
} else {
printk(KERN_INFO "tda1004x: please rename the firmware file to %s\n",
/* request the firmware, this will block and timeout */
ret = request_firmware(&fw, fw_file, &client->dev);
- if (ret) {
- dev_err(&client->dev,
- "did not find the firmware file '%s' (status %d). You can use <kernel_dir>/scripts/get_dvb_firmware to get the firmware\n",
- fw_file, ret);
+ if (ret)
goto error;
- }
/* init */
for (i = 0; i < ARRAY_SIZE(tab2); i++) {
if (is_cx231xx(state) && max_buf_size > 16)
max_buf_size = 16;
- if (request_firmware(&fw, fwname, FWDEV(client)) != 0) {
- v4l_err(client, "unable to open firmware %s\n", fwname);
+ if (request_firmware(&fw, fwname, FWDEV(client)) != 0)
return -EINVAL;
- }
start_fw_load(client);
int rc;
rc = request_firmware(&fw_entry, "hcwamc.rbf", &btv->c.pci->dev);
- if (rc != 0) {
- pr_warn("%d: no altera firmware [via hotplug]\n", btv->c.nr);
+ if (rc != 0)
return rc;
- }
rc = pvr_altera_load(btv, fw_entry->data, fw_entry->size);
pr_info("%d: altera firmware upload %s\n",
btv->c.nr, (rc < 0) ? "failed" : "ok");
int i;
int retries1 = 0;
- if (request_firmware(&fw, FWFILE, &cx->pci_dev->dev) != 0) {
- CX18_ERR_DEV(sd, "unable to open firmware %s\n", FWFILE);
+ if (request_firmware(&fw, FWFILE, &cx->pci_dev->dev) != 0)
return -EINVAL;
- }
/* The firmware load often has byte errors, so allow for several
retries, both at byte level and at the firmware load level. */
int ret;
ret = request_firmware(fw, fn, &cx->pci_dev->dev);
- if (ret)
- CX18_ERR("Unable to open firmware file %s\n", fn);
- else {
+ if (!ret) {
size_t sz = (*fw)->size;
if (sz < 2 || sz > 64 || (sz % 2) != 0) {
CX18_ERR("Firmware %s has a bad size: %lu bytes\n",
u32 __iomem *dst = (u32 __iomem *)mem;
const u32 *src;
- if (request_firmware(&fw, fn, &cx->pci_dev->dev)) {
- CX18_ERR("Unable to open firmware %s\n", fn);
- CX18_ERR("Did you put the firmware in the hotplug firmware directory?\n");
+ if (request_firmware(&fw, fn, &cx->pci_dev->dev))
return -ENOMEM;
- }
src = (const u32 *)fw->data;
int sz;
if (request_firmware(&fw, fn, &cx->pci_dev->dev)) {
- CX18_ERR("unable to open firmware %s\n", fn);
- CX18_ERR("did you put the firmware in the hotplug firmware directory?\n");
cx18_setup_page(cx, 0);
return -ENOMEM;
}
retval = request_firmware(&firmware, CX23885_FIRM_IMAGE_NAME,
&dev->pci->dev);
- if (retval != 0) {
- pr_err("ERROR: Hotplug firmware request failed (%s).\n",
- CX23885_FIRM_IMAGE_NAME);
- pr_err("Please fix your hotplug setup, the board will not work without firmware loaded!\n");
+ if (retval != 0)
return -1;
- }
if (firmware->size != CX23885_FIRM_IMAGE_SIZE) {
pr_err("ERROR: Firmware size mismatch (have %zu, expected %d)\n",
cinfo.rev, filename);
ret = request_firmware(&fw, filename, &dev->pci->dev);
- if (ret != 0)
- pr_err("did not find the firmware file '%s'. You can use <kernel_dir>/scripts/get_dvb_firmware to get the firmware.",
- filename);
- else
+ if (ret == 0)
altera_init(&netup_config, fw);
release_firmware(fw);
retval = request_firmware(&firmware, CX2341X_FIRM_ENC_FILENAME,
&dev->pci->dev);
- if (retval != 0) {
- pr_err("Hotplug firmware request failed (%s).\n",
- CX2341X_FIRM_ENC_FILENAME);
- pr_err("Please fix your hotplug setup, the board will not work without firmware loaded!\n");
+ if (retval != 0)
return -EIO;
- }
if (firmware->size != BLACKBIRD_FIRM_IMAGE_SIZE) {
pr_err("Firmware size mismatch (have %zd, expected %d)\n",
release_firmware(fw);
return size;
}
- IVTV_ERR("Unable to open firmware %s (must be %ld bytes)\n", fn, size);
- IVTV_ERR("Did you put the firmware in the hotplug firmware directory?\n");
return -ENOMEM;
}
break;
}
- if (request_firmware(&fw, fw_name, &dev->pci_dev->dev) < 0) {
- dev_err(pdev, "Could not load firmware file %s.\n", fw_name);
- dev_info(pdev, "Copy %s to your hotplug directory!\n",
- fw_name);
+ if (request_firmware(&fw, fw_name, &dev->pci_dev->dev))
return -1;
- }
if (size == 0)
size = fw->size;
if (size != fw->size) {
dev_err(pdev, "Firmware %s has invalid size!", fw_name);
err = -1;
} else {
- dev_info(pdev, "Loading firmware file %s.\n", fw_name);
ngene_fw = (u8 *) fw->data;
err = ngene_command_load_firmware(dev, ngene_fw, size);
}
__func__, fwname);
ret = request_firmware(&fw, fwname, &dev->pci->dev);
- if (ret) {
- printk(KERN_ERR "%s() Upload failed. (file not found?)\n",
- __func__);
+ if (ret)
return -ENOMEM;
- }
printk(KERN_INFO "%s() firmware read %zu bytes.\n",
__func__, fw->size);
}
}
- if (err != 0) {
- mfc_err("Firmware is not present in the /lib/firmware directory nor compiled in kernel\n");
+ if (err != 0)
return -EINVAL;
- }
if (fw_blob->size > dev->fw_buf.size) {
mfc_err("MFC firmware is too big to be loaded\n");
release_firmware(fw_blob);
* Uploading the firmware patch is not always necessary,
* so we only print an info message.
*/
- if (request_firmware(&fw_p, fw_name, dev)) {
- dev_info(dev, "%s - %s not found\n", __func__, fw_name);
-
+ if (request_firmware(&fw_p, fw_name, dev))
return 0;
- }
ptr = (__u8 *) fw_p->data;
packet_num = ptr[0];
ret = request_firmware(&fw_entry, fw_name,
&fmdev->radio_dev->dev);
- if (ret < 0) {
- fmerr("Unable to read firmware(%s) content\n", fw_name);
+ if (ret)
return ret;
- }
fmdbg("Firmware(%s) length : %zu bytes\n", fw_name, fw_entry->size);
fw_data = (void *)fw_entry->data;
tuner_dbg("request_firmware_nowait(): %s\n", fw ? "OK" : "error");
if (!fw) {
- tuner_err("Could not load firmware %s.\n", priv->fname);
priv->state = XC2028_NODEV;
return;
}
struct cpia2_command cmd;
ret = request_firmware(&fw, fw_name, &cam->dev->dev);
- if (ret) {
- printk(KERN_ERR "cpia2: failed to load VP patch \"%s\"\n",
- fw_name);
+ if (ret)
return ret;
- }
cmd.req_mode = CAMERAACCESS_TYPE_REPEAT | CAMERAACCESS_VP;
cmd.direction = TRANSFER_WRITE;
dev->dev);
if (retval != 0) {
- dev_err(dev->dev,
- "ERROR: Hotplug firmware request failed (%s).\n",
- CX231xx_FIRM_IMAGE_NAME);
- dev_err(dev->dev,
- "Please fix your hotplug setup, the board will not work without firmware loaded!\n");
vfree(p_current_fw);
vfree(p_buffer);
return retval;
dib9000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, 0x80);
- if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
- deb_info("%s: Upload failed. (file not found?)\n", __func__);
+ if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev))
return -ENODEV;
- } else {
- deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
- }
+ deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size;
stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data;
msleep(20);
dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
- if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev)) {
- deb_info("%s: Upload failed. (file not found?)\n", __func__);
+ if (request_firmware(&state->frontend_firmware, "dib9090.fw", &adap->dev->udev->dev))
return -EIO;
- } else {
- deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
- }
+ deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size);
nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size;
nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data;
nim9090md_config[1].microcode_B_fe_size = state->frontend_firmware->size;
int ret;
const struct firmware *fw = NULL;
- if ((ret = request_firmware(&fw, props->firmware, &udev->dev)) != 0) {
- err("did not find the firmware file '%s' (status %d). You can use <kernel_dir>/scripts/get_dvb_firmware to get the firmware",
- props->firmware,ret);
+ ret = request_firmware(&fw, props->firmware, &udev->dev);
+ if (ret)
return ret;
- }
-
- info("downloading firmware from file '%s'",props->firmware);
switch (props->usb_ctrl) {
case CYPRESS_AN2135:
const u8 *ptr;
u8 *buf;
if ((ret = request_firmware(&fw, bcm4500_firmware,
- &d->udev->dev)) != 0) {
- err("did not find the bcm4500 firmware file '%s' (status %d). You can use <kernel_dir>/scripts/get_dvb_firmware to get the firmware",
- bcm4500_firmware,ret);
+ &d->udev->dev)) != 0)
return ret;
- }
ret = -EINVAL;
if (gp8psk_usb_out_op(d, LOAD_BCM4500,1,0,NULL, 0))
goto out_rel_fw;
- info("downloading bcm4500 firmware from file '%s'",bcm4500_firmware);
-
ptr = fw->data;
buf = kmalloc(64, GFP_KERNEL);
if (!buf) {
info("start downloading fpga firmware %s",filename);
if ((ret = request_firmware(&fw, filename, &dev->dev)) != 0) {
- err("did not find the firmware file '%s'. You can use <kernel_dir>/scripts/get_dvb_firmware to get the firmware",
- filename);
return ret;
} else {
p = kmalloc(fw->size, GFP_KERNEL);
u16 intr_val, intr_data;
if (go->boot_fw == NULL) {
- if (request_firmware(&fw_entry, fw_name, go->dev)) {
- v4l2_err(go, "unable to load firmware from file \"%s\"\n", fw_name);
+ if (request_firmware(&fw_entry, fw_name, go->dev))
return -1;
- }
if (fw_entry->size < 16 || memcmp(fw_entry->data, "WISGO7007FW", 11)) {
v4l2_err(go, "file \"%s\" does not appear to be go7007 firmware\n", fw_name);
release_firmware(fw_entry);
default:
return -1;
}
- if (request_firmware(&fw_entry, GO7007_FW_NAME, go->dev)) {
- dev_err(go->dev,
- "unable to load firmware from file \"%s\"\n",
- GO7007_FW_NAME);
+ if (request_firmware(&fw_entry, GO7007_FW_NAME, go->dev))
return -1;
- }
code = kcalloc(codespace, 2, GFP_KERNEL);
if (code == NULL)
goto fw_failed;
dev_info(&interface->dev, "loading firmware %s\n", fw1);
- if (request_firmware(&fw, fw1, &usbdev->dev)) {
- dev_err(&interface->dev,
- "unable to load firmware from file \"%s\"\n", fw1);
+ if (request_firmware(&fw, fw1, &usbdev->dev))
goto failed2;
- }
ret = cypress_load_firmware(usbdev, fw, CYPRESS_FX2);
release_firmware(fw);
if (0 != ret) {
if (fw2 == NULL)
return 0;
- if (request_firmware(&fw, fw2, &usbdev->dev)) {
- dev_err(&interface->dev,
- "unable to load firmware from file \"%s\"\n", fw2);
+ if (request_firmware(&fw, fw2, &usbdev->dev))
goto failed2;
- }
ret = cypress_load_firmware(usbdev, fw, CYPRESS_FX2);
release_firmware(fw);
if (0 != ret) {
ret = request_ihex_firmware(&fw, VICAM_FIRMWARE,
&gspca_dev->dev->dev);
- if (ret) {
- pr_err("Failed to load \"vicam/firmware.fw\": %d\n", ret);
+ if (ret)
return ret;
- }
firmware_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
if (!firmware_buf) {
"request_firmware fatal error with code=%d",ret);
return ret;
}
- pvr2_trace(PVR2_TRACE_ERROR_LEGS,
- "***WARNING*** Device %s firmware seems to be missing.",
- fwtypename);
- pvr2_trace(PVR2_TRACE_ERROR_LEGS,
- "Did you install the pvrusb2 firmware files in their proper location?");
- if (fwcount == 1) {
- pvr2_trace(PVR2_TRACE_ERROR_LEGS,
- "request_firmware unable to locate %s file %s",
- fwtypename,fwnames[0]);
- } else {
- pvr2_trace(PVR2_TRACE_ERROR_LEGS,
- "request_firmware unable to locate one of the following %s files:",
- fwtypename);
- for (idx = 0; idx < fwcount; idx++) {
- pvr2_trace(PVR2_TRACE_ERROR_LEGS,
- "request_firmware: Failed to find %s",
- fwnames[idx]);
- }
- }
return ret;
}
}
/* load the first chunk */
if (request_firmware(&dev->fw_data->fw,
- FIRMWARE_FILE_NAME, &dev->udev->dev)) {
- dev_err(&interface->dev, "sensoray 2255 failed to get firmware\n");
+ FIRMWARE_FILE_NAME, &dev->udev->dev))
goto errorREQFW;
- }
/* check the firmware is valid */
fw_size = dev->fw_data->fw->size;
pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8];
err = request_firmware(&fw, "ttusb-budget/dspbootcode.bin",
&ttusb->dev->dev);
- if (err) {
- pr_err("failed to request firmware\n");
+ if (err)
return err;
- }
/* BootBlock */
b[0] = 0xaa;
dprintk("%s\n", __func__);
result = request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev);
- if (result) {
- printk(KERN_ERR "%s: Firmware (%s) unavailable.\n",
- __func__, dec->firmware_name);
+ if (result)
return result;
- }
firmware = fw_entry->data;
firmware_size = fw_entry->size;
request_firmware(&kim_gdata->fw_entry, bts_scr_name,
&kim_gdata->kim_pdev->dev);
if (unlikely((err != 0) || (kim_gdata->fw_entry->data == NULL) ||
- (kim_gdata->fw_entry->size == 0))) {
- pr_err(" request_firmware failed(errno %ld) for %s", err,
- bts_scr_name);
+ (kim_gdata->fw_entry->size == 0)))
return -EINVAL;
- }
ptr = (void *)kim_gdata->fw_entry->data;
len = kim_gdata->fw_entry->size;
/*
int8_t type_end = 0, type_entrypoint = 0;
ret = request_firmware(&fw, file, &card->pdev->dev);
- if (ret) {
- dev_alert(&card->pdev->dev, "request_firmware(%s) got %i\n",
- file, ret);
+ if (ret)
return ret;
- }
dev_dbg(&card->pdev->dev, "firmware(%s) got %lu bytes\n",
file, (unsigned long)fw->size);
/* parse the firmware */
return 0;
err = request_firmware(&typhoon_fw, FIRMWARE_NAME, &tp->pdev->dev);
- if (err) {
- netdev_err(tp->dev, "Failed to load firmware \"%s\"\n",
- FIRMWARE_NAME);
+ if (err)
return err;
- }
image_data = typhoon_fw->data;
remaining = typhoon_fw->size;
#endif /* VLAN_SUPPORT */
retval = request_firmware(&fw_rx, FIRMWARE_RX, &np->pci_dev->dev);
- if (retval) {
- printk(KERN_ERR "starfire: Failed to load firmware \"%s\"\n",
- FIRMWARE_RX);
+ if (retval)
goto out_init;
- }
if (fw_rx->size % 4) {
printk(KERN_ERR "starfire: bogus length %zu in \"%s\"\n",
fw_rx->size, FIRMWARE_RX);
goto out_rx;
}
retval = request_firmware(&fw_tx, FIRMWARE_TX, &np->pci_dev->dev);
- if (retval) {
- printk(KERN_ERR "starfire: Failed to load firmware \"%s\"\n",
- FIRMWARE_TX);
+ if (retval)
goto out_rx;
- }
if (fw_tx->size % 4) {
printk(KERN_ERR "starfire: bogus length %zu in \"%s\"\n",
fw_tx->size, FIRMWARE_TX);
file = (sdev->model == SLIC_MODEL_OASIS) ? SLIC_RCV_FIRMWARE_OASIS :
SLIC_RCV_FIRMWARE_MOJAVE;
err = request_firmware(&fw, file, &sdev->pdev->dev);
- if (err) {
- dev_err(&sdev->pdev->dev,
- "failed to load receive sequencer firmware %s\n", file);
+ if (err)
return err;
- }
/* Do an initial sanity check concerning firmware size now. A further
* check follows below.
*/
file = (sdev->model == SLIC_MODEL_OASIS) ? SLIC_FIRMWARE_OASIS :
SLIC_FIRMWARE_MOJAVE;
err = request_firmware(&fw, file, &sdev->pdev->dev);
- if (err) {
- dev_err(&sdev->pdev->dev, "failed to load firmware %s\n", file);
+ if (err)
return err;
- }
/* Do an initial sanity check concerning firmware size now. A further
* check follows below.
*/
fw_name = "acenic/tg1.bin";
ret = request_firmware(&fw, fw_name, &ap->pdev->dev);
- if (ret) {
- printk(KERN_ERR "%s: Failed to load firmware \"%s\"\n",
- ap->name, fw_name);
+ if (ret)
return ret;
- }
fw_data = (void *)fw->data;
}
rc = request_firmware(&bp->mips_firmware, mips_fw_file, &bp->pdev->dev);
- if (rc) {
- pr_err("Can't load firmware file \"%s\"\n", mips_fw_file);
+ if (rc)
goto out;
- }
rc = request_firmware(&bp->rv2p_firmware, rv2p_fw_file, &bp->pdev->dev);
- if (rc) {
- pr_err("Can't load firmware file \"%s\"\n", rv2p_fw_file);
+ if (rc)
goto err_release_mips_firmware;
- }
+
mips_fw = (const struct bnx2_mips_fw_file *) bp->mips_firmware->data;
rv2p_fw = (const struct bnx2_rv2p_fw_file *) bp->rv2p_firmware->data;
if (bp->mips_firmware->size < sizeof(*mips_fw) ||
{
const struct tg3_firmware_hdr *fw_hdr;
- if (request_firmware(&tp->fw, tp->fw_needed, &tp->pdev->dev)) {
- netdev_err(tp->dev, "Failed to load firmware \"%s\"\n",
- tp->fw_needed);
+ if (request_firmware(&tp->fw, tp->fw_needed, &tp->pdev->dev))
return -ENOENT;
- }
fw_hdr = (struct tg3_firmware_hdr *)tp->fw->data;
const struct firmware *fw;
u32 n;
- if (request_firmware(&fw, fw_name, &pdev->dev)) {
- dev_alert(&pdev->dev, "can't load firmware %s\n", fw_name);
+ if (request_firmware(&fw, fw_name, &pdev->dev))
goto error;
- }
*bfi_image = (u32 *)fw->data;
*bfi_image_size = fw->size/sizeof(u32);
fw_name = get_edc_fw_name(edc_idx);
if (fw_name)
ret = request_firmware(&fw, fw_name, &adapter->pdev->dev);
- if (ret < 0) {
- dev_err(&adapter->pdev->dev,
- "could not upgrade firmware: unable to load %s\n",
- fw_name);
+ if (ret)
return ret;
- }
/* check size, take checksum in account */
if (fw->size > size + 4) {
struct device *dev = &adap->pdev->dev;
ret = request_firmware(&fw, FW_FNAME, dev);
- if (ret < 0) {
- dev_err(dev, "could not upgrade firmware: unable to load %s\n",
- FW_FNAME);
+ if (ret)
return ret;
- }
ret = t3_load_fw(adap, fw->data, fw->size);
release_firmware(fw);
snprintf(buf, sizeof(buf), TPSRAM_NAME, rev);
ret = request_firmware(&tpsram, buf, dev);
- if (ret < 0) {
- dev_err(dev, "could not load TP SRAM: unable to load %s\n",
- buf);
+ if (ret)
return ret;
- }
ret = t3_check_tpsram(adap, tpsram->data, tpsram->size);
if (ret)
if (err) {
if (required) {
- netif_err(nic, probe, nic->netdev,
- "Failed to load firmware \"%s\": %d\n",
- fw_name, err);
return ERR_PTR(err);
} else {
netif_info(nic, probe, nic->netdev,
unsigned i;
if (request_firmware(&fw, mgp->fw_name, dev) < 0) {
- dev_err(dev, "Unable to load %s firmware image via hotplug\n",
- mgp->fw_name);
status = -EINVAL;
goto abort_with_nothing;
}
int i, err;
err = request_firmware(&fw, FIRMWARE_NAME, &link->dev);
- if (err) {
- pr_err("Failed to load firmware \"%s\"\n", FIRMWARE_NAME);
+ if (err)
return err;
- }
/* Download the Seven of Diamonds firmware */
for (i = 0; i < fw->size; i++) {
return;
err = request_firmware(&fw, fw_name, &cp->pdev->dev);
- if (err) {
- pr_err("Failed to load firmware \"%s\"\n",
- fw_name);
+ if (err)
return;
- }
if (fw->size < 2) {
pr_err("bogus length %zu in \"%s\"\n",
fw->size, fw_name);
}
err = request_firmware(&fw, fw_name[predef], &pdev->dev);
platform_device_unregister(pdev);
- if (err) {
- printk(KERN_ERR "Failed to load firmware \"%s\"\n",
- fw_name[predef]);
+ if (err)
return NULL;
- }
if (fw->size != YAM_FPGA_SIZE) {
printk(KERN_ERR "Bogus length %zu in firmware \"%s\"\n",
fw->size, fw_name[predef]);
int ret;
ret = request_firmware(&fw, fwname, &kaweth->dev->dev);
- if (ret) {
- dev_err(&kaweth->intf->dev, "Firmware request failed\n");
+ if (ret)
return ret;
- }
if (fw->size > KAWETH_FIRMWARE_BUF_SIZE) {
dev_err(&kaweth->intf->dev, "Firmware too big: %zu\n",
if (!ret)
return;
- dev_err(&hif_dev->udev->dev,
- "ath9k_htc: Failed to get firmware %s\n",
- hif_dev->fw_name);
goto err_fw;
}
return;
}
- dev_err(&ar->udev->dev, "firmware not found.\n");
carl9170_usb_firmware_failed(ar);
}
at76_dbg(DBG_FW, "downloading firmware %s", fwe->fwname);
ret = request_firmware(&fwe->fw, fwe->fwname, &udev->dev);
- if (ret < 0) {
- dev_err(&udev->dev, "firmware %s not found!\n",
- fwe->fwname);
- dev_err(&udev->dev,
- "you may need to download the firmware from http://developer.berlios.de/projects/at76c503a/\n");
+ if (ret)
goto exit;
- }
at76_dbg(DBG_FW, "got it.");
fwh = (struct at76_fw_header *)(fwe->fw->data);
strcpy(priv->firmware_id, "atmel_at76c502.bin");
}
err = request_firmware(&fw_entry, priv->firmware_id, priv->sys_dev);
- if (err != 0) {
- printk(KERN_ALERT
- "%s: firmware %s is missing, cannot continue.\n",
- dev->name, priv->firmware_id);
+ if (err != 0)
return err;
- }
} else {
int fw_index = 0;
int success = 0;
}
err = request_firmware(&ctx->blob, ctx->fwname,
ctx->dev->dev->dev);
- if (err == -ENOENT) {
- snprintf(ctx->errors[ctx->req_type],
- sizeof(ctx->errors[ctx->req_type]),
- "Firmware file \"%s\" not found\n",
- ctx->fwname);
- return err;
- } else if (err) {
- snprintf(ctx->errors[ctx->req_type],
- sizeof(ctx->errors[ctx->req_type]),
- "Firmware file \"%s\" request failed (err=%d)\n",
- ctx->fwname, err);
+ if (err)
return err;
- }
fw_ready:
if (ctx->blob->size < sizeof(struct b43_fw_header))
goto err_format;
} else {
err = request_firmware(fw, path, dev->dev->dev);
}
- if (err) {
- b43legacyerr(dev->wl, "Firmware file \"%s\" not found "
- "or load failed.\n", path);
+ if (err)
return err;
- }
if ((*fw)->size < sizeof(struct b43legacy_fw_header))
goto err_format;
hdr = (struct b43legacy_fw_header *)((*fw)->data);
sprintf(fw_name, "%s-%d.fw", brcms_firmwares[i],
UCODE_LOADER_API_VER);
status = request_firmware(&wl->fw.fw_bin[i], fw_name, device);
- if (status) {
- wiphy_err(wl->wiphy, "%s: fail to load firmware %s\n",
- KBUILD_MODNAME, fw_name);
+ if (status)
return status;
- }
sprintf(fw_name, "%s_hdr-%d.fw", brcms_firmwares[i],
UCODE_LOADER_API_VER);
status = request_firmware(&wl->fw.fw_hdr[i], fw_name, device);
- if (status) {
- wiphy_err(wl->wiphy, "%s: fail to load firmware %s\n",
- KBUILD_MODNAME, fw_name);
+ if (status)
return status;
- }
wl->fw.hdr_num_entries[i] =
wl->fw.fw_hdr[i]->size / (sizeof(struct firmware_hdr));
}
rc = request_firmware(&fw->fw_entry, fw_name, &priv->pci_dev->dev);
- if (rc < 0) {
- printk(KERN_ERR DRV_NAME ": "
- "%s: Firmware '%s' not available or load failed.\n",
- priv->net_dev->name, fw_name);
+ if (rc)
return rc;
- }
IPW_DEBUG_INFO("firmware data %p size %zd\n", fw->fw_entry->data,
fw->fw_entry->size);
/* ask firmware_class module to get the boot firmware off disk */
rc = request_firmware(raw, name, &priv->pci_dev->dev);
- if (rc < 0) {
- IPW_ERROR("%s request_firmware failed: Reason %d\n", name, rc);
+ if (rc)
return rc;
- }
if ((*raw)->size < sizeof(*fw)) {
IPW_ERROR("%s is too small (%zd)\n", name, (*raw)->size);
sprintf(buf, "%s%u%s", name_pre, idx, ".ucode");
ret = request_firmware(&ucode_raw, buf, &il->pci_dev->dev);
if (ret < 0) {
- IL_ERR("%s firmware file req failed: %d\n", buf, ret);
if (ret == -ENOENT)
continue;
else
}
if (drv->fw_index < cfg->ucode_api_min) {
- IWL_ERR(drv, "no suitable firmware found!\n");
-
if (cfg->ucode_api_min == cfg->ucode_api_max) {
IWL_ERR(drv, "%s%d is required\n", cfg->fw_name_pre,
cfg->ucode_api_max);
err = request_firmware(&fw_entry, firmware, priv->dev);
if (err) {
- dev_err(dev, "Cannot find firmware %s\n", firmware);
err = -ENOENT;
goto free;
}
const struct firmware *fw_entry;
if (!orinoco_cached_fw_get(priv, true)) {
- if (request_firmware(&fw_entry, fw->pri_fw, priv->dev) != 0) {
- dev_err(dev, "Cannot find firmware: %s\n", fw->pri_fw);
+ if (request_firmware(&fw_entry, fw->pri_fw, priv->dev) != 0)
return -ENOENT;
- }
} else
fw_entry = orinoco_cached_fw_get(priv, true);
}
if (!orinoco_cached_fw_get(priv, false)) {
- if (request_firmware(&fw_entry, fw->sta_fw, priv->dev) != 0) {
- dev_err(dev, "Cannot find firmware: %s\n", fw->sta_fw);
+ if (request_firmware(&fw_entry, fw->sta_fw, priv->dev) != 0)
return -ENOENT;
- }
} else
fw_entry = orinoco_cached_fw_get(priv, false);
if (ezusb_firmware_download(upriv, &firmware) < 0)
goto error;
} else {
- err("No firmware to download");
goto error;
}
int err;
if (!fw) {
- dev_err(&pdev->dev, "Cannot find firmware (isl3886pci)\n");
err = -ENOENT;
goto out;
}
/* FIXME: should driver use it's own struct device? */
ret = request_firmware(&priv->firmware, "3826.arm", &priv->spi->dev);
- if (ret < 0) {
- dev_err(&priv->spi->dev, "request_firmware() failed: %d", ret);
+ if (ret)
return ret;
- }
ret = p54_parse_firmware(dev, priv->firmware);
if (ret) {
err = p54u_start_ops(priv);
} else {
err = -ENOENT;
- dev_err(&udev->dev, "Firmware not found.\n");
}
complete(&priv->fw_wait_load);
kernel_param_lock(THIS_MODULE);
ret = request_firmware(&cardp->fw, lbtf_fw_name, &cardp->udev->dev);
if (ret < 0) {
- pr_err("request_firmware() failed with %#x\n", ret);
- pr_err("firmware %s not found\n", lbtf_fw_name);
kernel_param_unlock(THIS_MODULE);
goto done;
}
struct wireless_dev *wdev;
struct completion *fw_done = adapter->fw_done;
- if (!firmware) {
- mwifiex_dbg(adapter, ERROR,
- "Failed to get firmware %s\n", adapter->fw_name);
+ if (!firmware)
goto err_dnld_fw;
- }
memset(&fw, 0, sizeof(struct mwifiex_fw_image));
adapter->firmware = firmware;
static void mwl8k_fw_state_machine(const struct firmware *fw, void *context)
{
struct mwl8k_priv *priv = context;
- struct mwl8k_device_info *di = priv->device_info;
int rc;
switch (priv->fw_state) {
case FW_STATE_INIT:
- if (!fw) {
- printk(KERN_ERR "%s: Error requesting helper fw %s\n",
- pci_name(priv->pdev), di->helper_image);
+ if (!fw)
goto fail;
- }
priv->fw_helper = fw;
rc = mwl8k_request_fw(priv, priv->fw_pref, &priv->fw_ucode,
true);
break;
case FW_STATE_LOADING_ALT:
- if (!fw) {
- printk(KERN_ERR "%s: Error requesting alt fw %s\n",
- pci_name(priv->pdev), di->helper_image);
+ if (!fw)
goto fail;
- }
priv->fw_ucode = fw;
rc = mwl8k_firmware_load_success(priv);
if (rc)
/* Ask userland hotplug daemon for the device firmware */
rc = mwl8k_request_firmware(priv, fw_image, nowait);
- if (rc) {
- wiphy_err(hw->wiphy, "Firmware files not found\n");
+ if (rc)
return rc;
- }
if (nowait)
return rc;
rt2x00_info(rt2x00dev, "Loading firmware file '%s'\n", fw_name);
retval = request_firmware(&fw, fw_name, device);
- if (retval) {
- rt2x00_err(rt2x00dev, "Failed to request Firmware\n");
+ if (retval)
return retval;
- }
if (!fw || !fw->size || !fw->data) {
rt2x00_err(rt2x00dev, "Failed to read Firmware\n");
if (!err)
goto found_alt;
}
- pr_err("Selected firmware is not available\n");
rtlpriv->max_fw_size = 0;
goto exit;
}
struct ieee80211_hw *hw = context;
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rt_firmware *pfirmware = NULL;
- char *fw_name = "rtlwifi/rtl8192sefw.bin";
rtl_dbg(rtlpriv, COMP_ERR, DBG_LOUD,
"Firmware callback routine entered!\n");
complete(&rtlpriv->firmware_loading_complete);
if (!firmware) {
- pr_err("Firmware %s not available\n", fw_name);
rtlpriv->max_fw_size = 0;
return;
}
ret = request_firmware(&fw, WL1251_FW_NAME, dev);
- if (ret < 0) {
- wl1251_error("could not get firmware: %d", ret);
+ if (ret)
return ret;
- }
if (fw->size % 4) {
wl1251_error("firmware size is not multiple of 32 bits: %zu",
ret = request_firmware(&fw, WL1251_NVS_NAME, dev);
- if (ret < 0) {
- wl1251_error("could not get nvs file: %d", ret);
+ if (ret)
return ret;
- }
if (fw->size % 4) {
wl1251_error("nvs size is not multiple of 32 bits: %zu",
ret = request_firmware(&fw, fw_name, wl->dev);
- if (ret < 0) {
- wl1271_error("could not get firmware %s: %d", fw_name, ret);
+ if (ret)
return ret;
- }
if (fw->size % 4) {
wl1271_error("firmware size is not multiple of 32 bits: %zu",
err = request_firmware(&fw_entry, fwfile, &dev->dev);
if (err) {
- dev_err(&dev->dev, "Failed to load %s firmware file!\n", fwfile);
- dev_err(&dev->dev, "Make sure the hotplug firmware loader is installed.\n");
dev_err(&dev->dev, "Goto http://linux-lc100020.sourceforge.net for more info.\n");
return err;
}
static int request_fw_file(
const struct firmware **fw, const char *name, struct device *device)
{
- int r;
-
dev_dbg_f(device, "fw name %s\n", name);
- r = request_firmware(fw, name, device);
- if (r)
- dev_err(device,
- "Could not load firmware file %s. Error number %d\n",
- name, r);
- return r;
+ return request_firmware(fw, name, device);
}
static inline u16 get_bcdDevice(const struct usb_device *udev)
err = request_firmware(&fw, fwname, asc_dvc->drv_ptr->dev);
if (err) {
- printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
- fwname, err);
asc_dvc->err_code |= ASC_IERR_MCODE_CHKSUM;
return err;
}
err = request_firmware(&fw, fwname, asc_dvc->drv_ptr->dev);
if (err) {
- printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
- fwname, err);
asc_dvc->err_code = ASC_IERR_MCODE_CHKSUM;
return err;
}
err = request_firmware(&fw, fwname, asc_dvc->drv_ptr->dev);
if (err) {
- printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
- fwname, err);
asc_dvc->err_code = ASC_IERR_MCODE_CHKSUM;
return err;
}
err = request_firmware(&fw, fwname, asc_dvc->drv_ptr->dev);
if (err) {
- printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
- fwname, err);
asc_dvc->err_code = ASC_IERR_MCODE_CHKSUM;
return err;
}
filename_ptr,
&asd_ha->pcidev->dev);
if (err) {
- asd_printk("Failed to load bios image file %s, error %d\n",
- filename_ptr, err);
err = FAIL_OPEN_BIOS_FILE;
goto out1;
}
err = asd_request_firmware(asd_ha);
- if (err) {
- asd_printk("Failed to load sequencer firmware file %s, error %d\n",
- SAS_RAZOR_SEQUENCER_FW_FILE, err);
+ if (err)
return err;
- }
err = asd_seq_download_seqs(asd_ha);
if (err) {
const struct firmware *fw;
if (request_firmware(&fw, fw_name, &pdev->dev)) {
- printk(KERN_ALERT "Can't locate firmware %s\n", fw_name);
*bfi_image = NULL;
goto out;
}
if (endline)
*endline = '\0';
- if (request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) {
- dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname);
+ if (request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev))
return -EIO;
- }
image_hdr = (struct ipr_ucode_image_header *)fw_entry->data;
pm8001_ha->dev);
if (ret) {
- pm8001_dbg(pm8001_ha, FAIL,
- "Failed to load firmware image file %s, error %d\n",
- filename_ptr, ret);
pm8001_ha->fw_status = FAIL_OPEN_BIOS_FILE;
goto out;
}
err = request_firmware(&fw, fwname, &ha->pdev->dev);
if (err) {
- printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
- fwname, err);
fw = ERR_PTR(err);
goto unlock;
}
/* Load firmware blob. */
blob = qla2x00_request_firmware(vha);
if (!blob) {
- ql_log(ql_log_info, vha, 0x0083,
- "Firmware image unavailable.\n");
- ql_log(ql_log_info, vha, 0x0084,
- "Firmware images can be retrieved from: "QLA_FW_URL ".\n");
return QLA_FUNCTION_FAILED;
}
blob = qla2x00_request_firmware(vha);
if (!blob) {
- ql_log(ql_log_warn, vha, 0x0092,
- "-> Firmware file not found.\n");
-
return QLA_FUNCTION_FAILED;
}
/* Load firmware blob. */
blob = ha->hablob = qla2x00_request_firmware(vha);
- if (!blob) {
- ql_log(ql_log_fatal, vha, 0x00a3,
- "Firmware image not present.\n");
+ if (!blob)
goto fw_load_failed;
- }
/* Validating firmware blob */
if (qla82xx_validate_firmware_blob(vha,
goto out;
if (request_firmware(&blob->fw, blob->name, &ha->pdev->dev)) {
- ql_log(ql_log_warn, vha, 0x0063,
- "Failed to load firmware image (%s).\n", blob->name);
blob->fw = NULL;
blob = NULL;
}
int i, timeout;
err = request_firmware(&fw, fwname, &qpti->op->dev);
- if (err) {
- printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
- fwname, err);
+ if (err)
return err;
- }
if (fw->size % 2) {
printk(KERN_ERR "Bogus length %zu in image \"%s\"\n",
fw->size, fwname);
*/
if (rst_opt == OPT_SYSTEM_RESET) {
rc = request_firmware(&fw_entry, fw_name[init_step], &priv->udev->dev);
- if (rc < 0) {
- RT_TRACE(COMP_ERR, "request firmware fail!\n");
+ if (rc)
goto download_firmware_fail;
- }
if (fw_entry->size > sizeof(pfirmware->firmware_buf)) {
RT_TRACE(COMP_ERR, "img file size exceed the container buffer fail!\n");
dev_info(dev, "r8712u: Loading firmware from \"%s\"\n", firmware_file);
rc = request_firmware_nowait(THIS_MODULE, 1, firmware_file, dev,
GFP_KERNEL, padapter, rtl871x_load_fw_cb);
- if (rc)
- dev_err(dev, "r8712u: Firmware request error %d\n", rc);
return rc;
}
MODULE_FIRMWARE("rtlwifi/rtl8712u.bin");
dev_dbg(dev, "---->Download firmware\n");
ret = request_firmware(&fw, FIRMWARE_NAME, dev);
- if (ret) {
- dev_err(dev, "firmware file %s request failed (%d)\n",
- FIRMWARE_NAME, ret);
+ if (ret)
goto end;
- }
for (ii = 0; ii < fw->size; ii += FIRMWARE_CHUNK_SIZE) {
length = min_t(int, fw->size - ii, FIRMWARE_CHUNK_SIZE);
}
ret = request_firmware(&fw, file, dev);
- if (ret) {
- printk(KERN_ERR "MOXA: request_firmware failed. Make sure "
- "you've placed '%s' file into your firmware "
- "loader directory (e.g. /lib/firmware)\n",
- file);
+ if (ret)
goto err_free;
- }
ret = moxa_load_fw(brd, fw);
/* Load Call Setup into Adapter */
if (request_firmware(&fw, "icom_call_setup.bin", &dev->dev) < 0) {
- dev_err(&dev->dev,"Unable to load icom_call_setup.bin firmware image\n");
status = -1;
goto load_code_exit;
}
/* Load Resident DCE portion of Adapter */
if (request_firmware(&fw, "icom_res_dce.bin", &dev->dev) < 0) {
- dev_err(&dev->dev,"Unable to load icom_res_dce.bin firmware image\n");
status = -1;
goto load_code_exit;
}
}
if (request_firmware(&fw, "icom_asc.bin", &dev->dev) < 0) {
- dev_err(&dev->dev,"Unable to load icom_asc.bin firmware image\n");
status = -1;
goto load_code_exit;
}
struct device *dev = context;
int ret;
- if (!fw) {
- dev_err(dev, "firmware not found\n");
+ if (!fw)
return;
- }
firmware = (struct qe_firmware *) fw->data;
return -ENOENT;
}
- usb_info(usbatm, "found firmware %s\n", buf);
-
return 0;
}
int ret, size;
uea_enters(usb);
- if (!fw_entry) {
- uea_err(usb, "firmware is not available\n");
+ if (!fw_entry)
goto err;
- }
pfw = fw_entry->data;
size = fw_entry->size;
ret = request_firmware_nowait(THIS_MODULE, 1, fw_name, &usb->dev,
GFP_KERNEL, usb,
uea_upload_pre_firmware);
- if (ret)
- uea_err(usb, "firmware %s is not available\n", fw_name);
- else
- uea_info(usb, "loading firmware %s\n", fw_name);
uea_leaves(usb);
return ret;
}
ret = request_firmware(&sc->dsp_firm, dsp_name, &sc->usb_dev->dev);
- if (ret < 0) {
- uea_err(INS_TO_USBDEV(sc),
- "requesting firmware %s failed with error %d\n",
- dsp_name, ret);
+ if (ret)
return ret;
- }
if (UEA_CHIP_VERSION(sc) == EAGLE_IV)
ret = check_dsp_e4(sc->dsp_firm->data, sc->dsp_firm->size);
cmvs_file_name(sc, cmv_name, 1);
ret = request_firmware(fw, cmv_name, &sc->usb_dev->dev);
- if (ret < 0) {
- uea_err(INS_TO_USBDEV(sc),
- "requesting firmware %s failed with error %d\n",
- cmv_name, ret);
+ if (ret)
return ret;
- }
data = (u8 *) (*fw)->data;
size = (*fw)->size;
"try to get older cmvs\n", cmv_name);
return request_cmvs_old(sc, cmvs, fw);
}
- uea_err(INS_TO_USBDEV(sc),
- "requesting firmware %s failed with error %d\n",
- cmv_name, ret);
return ret;
}
uea_enters(INS_TO_USBDEV(sc));
ret = request_firmware(&fw_entry, fw_name, &sc->usb_dev->dev);
- if (ret) {
- uea_err(INS_TO_USBDEV(sc), "firmware %s is not available\n",
- fw_name);
+ if (ret)
goto err0;
- }
pfw = fw_entry->data;
size = fw_entry->size;
err = request_ihex_firmware(&loader_fw, "emi26/loader.fw", &dev->dev);
if (err)
- goto nofw;
+ goto wraperr;
err = request_ihex_firmware(&bitstream_fw, "emi26/bitstream.fw",
&dev->dev);
if (err)
- goto nofw;
+ goto wraperr;
err = request_ihex_firmware(&firmware_fw, "emi26/firmware.fw",
&dev->dev);
- if (err) {
- nofw:
- dev_err(&dev->dev, "%s - request_firmware() failed\n",
- __func__);
+ if (err)
goto wraperr;
- }
/* Assert reset (stop the CPU in the EMI) */
err = emi26_set_reset(dev,1);
const struct ihex_binrec *record;
if (request_ihex_firmware(&firmware, firmware_path,
- &dev->dev)) {
- dev_err(&dev->dev,
- "%s - request \"%s\" failed\n",
- __func__, firmware_path);
+ &dev->dev))
goto out;
- }
ret = ezusb_set_reset(dev, fx.cpucs_reg, 0);
if (ret < 0)
return -ENOMEM;
if (request_firmware(&firmware, "isight.fw", &dev->dev) != 0) {
- printk(KERN_ERR "Unable to load isight firmware\n");
ret = -ENODEV;
goto out;
}
response = request_ihex_firmware(&fw, fw_name,
&edge_serial->serial->dev->dev);
- if (response) {
- dev_err(dev, "Failed to load image \"%s\" err %d\n",
- fw_name, response);
+ if (response)
return;
- }
rec = (const struct ihex_binrec *)fw->data;
BootMajorVersion = rec->data[0];
status = request_firmware(&fw, fw_name, dev);
if (status) {
- dev_err(dev, "Failed to load image \"%s\" err %d\n",
- fw_name, status);
return status;
}
}
check_firmware:
- if (status) {
- dev_err(&dev->dev, "%s - firmware not found\n", __func__);
+ if (status)
return -ENOENT;
- }
if (fw_p->size > TI_FIRMWARE_BUF_SIZE) {
dev_err(&dev->dev, "%s - firmware too large %zu\n", __func__, fw_p->size);
release_firmware(fw_p);
return -EINVAL;
err = request_firmware(&fw_entry, "broadsheet.wbf", dev);
- if (err < 0) {
- dev_err(dev, "Failed to get broadsheet waveform\n");
+ if (err)
goto err_failed;
- }
/* try to enforce reasonable min max on waveform */
if ((fw_entry->size < 8*1024) || (fw_entry->size > 64*1024)) {
a) request the waveform file from userspace
b) process waveform and decode into metromem */
retval = request_firmware(&fw_entry, "metronome.wbf", &dev->dev);
- if (retval < 0) {
- dev_err(&dev->dev, "Failed to get waveform\n");
+ if (retval)
goto err_csum_table;
- }
retval = load_waveform((u8 *) fw_entry->data, fw_entry->size, 3, 31,
par);
if (! fw_files[chip->type][i])
continue;
sprintf(path, "vx/%s", fw_files[chip->type][i]);
- if (request_firmware(&fw, path, chip->dev)) {
- snd_printk(KERN_ERR "vx: can't load firmware %s\n", path);
+ if (request_firmware(&fw, path, chip->dev))
return -ENOENT;
- }
err = chip->ops->load_dsp(chip, i, fw);
if (err < 0) {
release_firmware(fw);
outb(HPBLKSEL_0, chip->io + HP_BLKS);
err = request_firmware(&init_fw, INITCODEFILE, card->dev);
- if (err < 0) {
- printk(KERN_ERR LOGNAME ": Error loading " INITCODEFILE);
+ if (err)
goto cleanup1;
- }
err = request_firmware(&perm_fw, PERMCODEFILE, card->dev);
- if (err < 0) {
- printk(KERN_ERR LOGNAME ": Error loading " PERMCODEFILE);
+ if (err)
goto cleanup;
- }
memcpy_toio(chip->mappedbase, perm_fw->data, perm_fw->size);
if (snd_msnd_upload_host(chip, init_fw->data, init_fw->size) < 0) {
int ret;
ret = request_firmware(&init_fw, "scope.cod", card->dev);
- if (ret < 0) {
- snd_printk(KERN_ERR "sscape: Error loading scope.cod");
+ if (ret)
return ret;
- }
ret = upload_dma_data(sscape, init_fw->data, init_fw->size);
release_firmware(init_fw);
snprintf(name, sizeof(name), "sndscape.co%d", version);
err = request_firmware(&init_fw, name, card->dev);
- if (err < 0) {
- snd_printk(KERN_ERR "sscape: Error loading sndscape.co%d",
- version);
+ if (err)
return err;
- }
err = upload_dma_data(sscape, init_fw->data, init_fw->size);
if (err == 0)
snd_printk(KERN_INFO "sscape: MIDI firmware loaded %zu KBs\n",
const struct firmware *firmware;
err = request_firmware(&firmware, path, dev->card->dev);
- if (err < 0) {
- snd_printk(KERN_ERR "firmware (%s) download failed!!!\n", path);
+ if (err)
return 1;
- }
len = 0;
buf = firmware->data;
err = request_firmware(&firmware, fw_name, &dev->dev);
if (err || !firmware) {
- dev_err(&dev->dev, "%d, request_firmware failed for %s\n",
- err, fw_name);
goto error1;
}
if (firmware->size < sizeof(header)) {
#ifdef CONFIG_SND_CS46XX_NEW_DSP
for (i = 0; i < CS46XX_DSP_MODULES; i++) {
err = load_firmware(chip, &chip->modules[i], module_names[i]);
- if (err < 0) {
- dev_err(chip->card->dev, "firmware load error [%s]\n",
- module_names[i]);
+ if (err < 0)
return err;
- }
err = cs46xx_dsp_load_module(chip, chip->modules[i]);
if (err < 0) {
dev_err(chip->card->dev, "image download error [%s]\n",
"firmware requested: %s\n", card_fw[fw_index].data);
snprintf(name, sizeof(name), "ea/%s", card_fw[fw_index].data);
err = request_firmware(fw_entry, name, &chip->pci->dev);
- if (err < 0)
- dev_err(chip->card->dev,
- "get_firmware(): Firmware not available (%d)\n", err);
#ifdef CONFIG_PM_SLEEP
- else
+ if (!err)
chip->fw_cache[fw_index] = *fw_entry;
#endif
return err;
dev_info(emu->card->dev, "emu1010: EMU_HANA_ID = 0x%x\n", reg);
err = snd_emu1010_load_firmware(emu, 0, &emu->firmware);
- if (err < 0) {
- dev_info(emu->card->dev, "emu1010: Loading Firmware failed\n");
+ if (err < 0)
return err;
- }
/* ID, should read & 0x7f = 0x55 when FPGA programmed. */
snd_emu1010_fpga_read(emu, EMU_HANA_ID, ®);
if (fw)
chip->fw = fw;
- else
- dev_err(card->dev, "Cannot load firmware, continue without patching\n");
if (!chip->disabled) {
/* continue probing */
azx_probe_continue(chip);
err = request_firmware(&dsp_code, "korg/k1212.dsp", &pci->dev);
if (err < 0) {
- snd_printk(KERN_ERR "firmware not available\n");
return err;
}
for (i = 0; i < 3; i++) {
sprintf(path, "mixart/%s", fw_files[i]);
- if (request_firmware(&fw_entry, path, &mgr->pci->dev)) {
- dev_err(&mgr->pci->dev,
- "miXart: can't load firmware %s\n", path);
+ if (request_firmware(&fw_entry, path, &mgr->pci->dev))
return -ENOENT;
- }
/* fake hwdep dsp record */
err = mixart_dsp_load(mgr, i, fw_entry);
release_firmware(fw_entry);
if (!fw_files[fw_set][i])
continue;
sprintf(path, "pcxhr/%s", fw_files[fw_set][i]);
- if (request_firmware(&fw_entry, path, &mgr->pci->dev)) {
- dev_err(&mgr->pci->dev,
- "pcxhr: can't load firmware %s\n",
- path);
+ if (request_firmware(&fw_entry, path, &mgr->pci->dev))
return -ENOENT;
- }
/* fake hwdep dsp record */
err = pcxhr_dsp_load(mgr, i, fw_entry);
release_firmware(fw_entry);
if (!chip->fw_entry) {
err = request_firmware(&chip->fw_entry, "riptide.hex",
&chip->pci->dev);
- if (err) {
- snd_printk(KERN_ERR
- "Riptide: Firmware not available %d\n", err);
+ if (err)
return -EIO;
- }
}
err = loadfirmware(cif, chip->fw_entry->data, chip->fw_entry->size);
if (err) {
return -EINVAL;
}
- if (request_firmware(&fw, fwfile, &hdsp->pci->dev)) {
- dev_err(hdsp->card->dev,
- "cannot load firmware %s\n", fwfile);
+ if (request_firmware(&fw, fwfile, &hdsp->pci->dev))
return -ENOENT;
- }
if (fw->size < HDSP_FIRMWARE_SIZE) {
dev_err(hdsp->card->dev,
"too short firmware size %d (expected %d)\n",
}
ret = request_firmware(&fw, filename, &i2c->dev);
- if (ret != 0) {
- dev_err(&i2c->dev, "Failed to acquire ANC data: %d\n", ret);
+ if (ret != 0)
goto err_supplies;
- }
/* Pre-cook the concatenation of the register address onto the image */
wm2000->anc_download_size = fw->size + 2;
ret = request_firmware(&fw, fwname, &device->dev);
if (ret < 0) {
kfree(rec);
- dev_err(&intf->dev,
- "error requesting ezusb firmware %s.\n", fwname);
return ret;
}
ret = usb6fire_fw_ihex_init(fw, rec);
ret = request_firmware(&fw, fwname, &device->dev);
if (ret < 0) {
- dev_err(&intf->dev, "unable to get fpga firmware %s.\n",
- fwname);
kfree(buffer);
return -EIO;
}
projects / linux.git / commitdiff