int
cpu_ucode_apply(const struct cpu_ucode *data)
{
struct cpu_ucode_softc *sc = &ucode_softc;
int error;
sc->loader_version = data->loader_version;
error = cpu_ucode_load(sc, data->fwname);
if (error)
return error;
switch (cpu_vendor) {
case CPUVENDOR_AMD:
error = cpu_ucode_amd_apply(sc, data->cpu_nr);
break;
case CPUVENDOR_INTEL:
error = cpu_ucode_intel_apply(sc, data->cpu_nr);
break;
default:
return EOPNOTSUPP;
}
if (sc->sc_blob != NULL)
firmware_free(sc->sc_blob, 0);
sc->sc_blob = NULL;
sc->sc_blobsize = 0;
return error;
}
int radeon_load_a_microcode(const char *fmt, const char *chip_name, void **codep, size_t *sizep)
{
firmware_handle_t fh;
char fw_name[30];
int error;
snprintf(fw_name, sizeof(fw_name), fmt, chip_name);
if ((error = firmware_open("radeon", fw_name, &fh)) != 0) {
DRM_ERROR("Cannot open radeon/%s firmware: %d\n", fw_name, error);
return error;
}
*sizep = firmware_get_size(fh);
if ((*codep = firmware_malloc(*sizep)) == NULL) {
DRM_ERROR("Cannot alloc memory for radeon/%s firmware\n", chip_name);
firmware_close(fh);
return ENOMEM;
}
if ((error = firmware_read(fh, 0, *codep, *sizep)) != 0) {
DRM_ERROR("Cannot read radeon/%s firmware: %d\n", chip_name, error);
firmware_free(*codep, *sizep);
}
firmware_close(fh);
return error;
}
int
compat6_cpu_ucode_apply(const struct compat6_cpu_ucode *data)
{
struct cpu_ucode_softc *sc = &ucode_softc;
int error;
if (cpu_vendor != CPUVENDOR_AMD)
return EOPNOTSUPP;
sc->loader_version = CPU_UCODE_LOADER_AMD;
error = cpu_ucode_load(sc, data->fwname);
if (error)
return error;
error = cpu_ucode_amd_apply(sc, CPU_UCODE_ALL_CPUS);
if (sc->sc_blob != NULL)
firmware_free(sc->sc_blob, 0);
sc->sc_blob = NULL;
sc->sc_blobsize = 0;
return error;
}
int
stuirda_fwload(struct uirda_softc *sc) {
int rc;
firmware_handle_t fh;
off_t fwsize;
usb_device_descriptor_t usbddsc;
usbd_xfer_handle fwxfer;
usbd_pipe_handle fwpipe;
usbd_status status;
usb_device_request_t req;
char *buffer;
char *p;
char fwname[12];
int n;
u_int8_t *usbbuf;
/* size_t bsize; */
printf("%s: needing to download firmware\n",
device_xname(sc->sc_dev));
status = usbd_get_device_desc(sc->sc_udev, &usbddsc);
if (status) {
printf("%s: can't get device descriptor, status %d\n",
device_xname(sc->sc_dev), status);
return status;
}
rc = usbd_get_class_desc(sc->sc_udev, UDESC_IRDA, 0,
USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc);
printf("error %d reading class desc\n", rc);
snprintf(fwname, sizeof(fwname), "4210%02x%02x.sb",
usbddsc.bcdDevice[1],
usbddsc.bcdDevice[0]);
printf("%s: Attempting to load firmware %s\n",
device_xname(sc->sc_dev), fwname);
rc = firmware_open("stuirda", fwname, &fh);
if (rc) {
printf("%s: Cannot load firmware\n",
device_xname(sc->sc_dev));
return rc;
}
fwsize = firmware_get_size(fh);
printf("%s: Firmware size %lld\n",
device_xname(sc->sc_dev), (long long)fwsize);
buffer = firmware_malloc(fwsize);
if (buffer == NULL) {
printf("%s: Cannot load firmware: out of memory\n",
device_xname(sc->sc_dev));
goto giveup2;
}
rc = firmware_read(fh, 0, buffer, (size_t)fwsize);
if (rc) {
printf("%s: Cannot read firmware\n", device_xname(sc->sc_dev));
goto giveup3;
}
for (p = buffer + sizeof("Product Version:");
p < buffer + fwsize - 5; p++) {
if (0x1A == *p)
break;
}
if (0x1a != *p || memcmp(p+1, "STMP", 4) != 0) {
/* firmware bad */
printf("%s: Bad firmware\n", device_xname(sc->sc_dev));
goto giveup3;
}
p += 5;
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req.bRequest = 2 /* XXX magic */;
USETW(req.wValue, 0);
USETW(req.wIndex, 0);
USETW(req.wLength, 0);
rc = usbd_do_request(sc->sc_udev, &req, 0);
if (rc) {
printf("%s: Cannot switch to f/w d/l mode, error %d\n",
device_xname(sc->sc_dev), rc);
goto giveup3;
}
delay(100000);
rc = usbd_open_pipe(sc->sc_iface, sc->sc_wr_addr, 0, &fwpipe);
if (rc) {
printf("%s: Cannot open pipe, rc=%d\n",
device_xname(sc->sc_dev), rc);
goto giveup3;
}
fwxfer = usbd_alloc_xfer(sc->sc_udev);
if (fwxfer == NULL) {
printf("%s: Cannot alloc xfer\n", device_xname(sc->sc_dev));
goto giveup4;
}
usbbuf = usbd_alloc_buffer(fwxfer, 1024);
if (usbbuf == NULL) {
printf("%s: Cannot alloc usb buf\n", device_xname(sc->sc_dev));
goto giveup5;
}
n = (buffer + fwsize - p);
while (n > 0) {
if (n > 1023)
n = 1023;
memcpy(usbbuf, p, n);
rc = usbd_bulk_transfer(fwxfer, fwpipe,
USBD_SYNCHRONOUS|USBD_FORCE_SHORT_XFER,
5000, usbbuf, &n, "uirda-fw-wr");
printf("%s: write: rc=%d, %d left\n",
device_xname(sc->sc_dev), rc, n);
if (rc) {
printf("%s: write: rc=%d, %d bytes written\n",
device_xname(sc->sc_dev), rc, n);
goto giveup4;
}
printf("%s: written %d\n", device_xname(sc->sc_dev), n);
p += n;
n = (buffer + fwsize - p);
}
delay(100000);
/* TODO: more code here */
rc = 0;
usbd_free_buffer(fwxfer);
giveup5: usbd_free_xfer(fwxfer);
giveup4: usbd_close_pipe(fwpipe);
giveup3: firmware_free(buffer, fwsize);
giveup2: firmware_close(fh);
return rc;
}
void radeon_free_a_microcode(void *code, size_t size)
{
firmware_free(code, size);
}
