mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
276 lines
6.9 KiB
276 lines
6.9 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Copyright (c) 2021 pureLiFi |
|
*/ |
|
|
|
#include <linux/firmware.h> |
|
#include <linux/bitrev.h> |
|
|
|
#include "mac.h" |
|
#include "usb.h" |
|
|
|
static int send_vendor_request(struct usb_device *udev, int request, |
|
unsigned char *buffer, int buffer_size) |
|
{ |
|
return usb_control_msg(udev, |
|
usb_rcvctrlpipe(udev, 0), |
|
request, 0xC0, 0, 0, |
|
buffer, buffer_size, PLF_USB_TIMEOUT); |
|
} |
|
|
|
static int send_vendor_command(struct usb_device *udev, int request, |
|
unsigned char *buffer, int buffer_size) |
|
{ |
|
return usb_control_msg(udev, |
|
usb_sndctrlpipe(udev, 0), |
|
request, USB_TYPE_VENDOR /*0x40*/, 0, 0, |
|
buffer, buffer_size, PLF_USB_TIMEOUT); |
|
} |
|
|
|
int plfxlc_download_fpga(struct usb_interface *intf) |
|
{ |
|
struct usb_device *udev = interface_to_usbdev(intf); |
|
unsigned char *fpga_dmabuff = NULL; |
|
const struct firmware *fw = NULL; |
|
int blk_tran_len = PLF_BULK_TLEN; |
|
unsigned char *fw_data; |
|
const char *fw_name; |
|
int r, actual_length; |
|
int fw_data_i = 0; |
|
|
|
if ((le16_to_cpu(udev->descriptor.idVendor) == |
|
PURELIFI_X_VENDOR_ID_0) && |
|
(le16_to_cpu(udev->descriptor.idProduct) == |
|
PURELIFI_X_PRODUCT_ID_0)) { |
|
fw_name = "plfxlc/lifi-x.bin"; |
|
dev_dbg(&intf->dev, "bin file for X selected\n"); |
|
|
|
} else if ((le16_to_cpu(udev->descriptor.idVendor)) == |
|
PURELIFI_XC_VENDOR_ID_0 && |
|
(le16_to_cpu(udev->descriptor.idProduct) == |
|
PURELIFI_XC_PRODUCT_ID_0)) { |
|
fw_name = "plfxlc/lifi-xc.bin"; |
|
dev_dbg(&intf->dev, "bin file for XC selected\n"); |
|
|
|
} else { |
|
r = -EINVAL; |
|
goto error; |
|
} |
|
|
|
r = request_firmware(&fw, fw_name, &intf->dev); |
|
if (r) { |
|
dev_err(&intf->dev, "request_firmware failed (%d)\n", r); |
|
goto error; |
|
} |
|
fpga_dmabuff = kmalloc(PLF_FPGA_STATUS_LEN, GFP_KERNEL); |
|
|
|
if (!fpga_dmabuff) { |
|
r = -ENOMEM; |
|
goto error_free_fw; |
|
} |
|
send_vendor_request(udev, PLF_VNDR_FPGA_SET_REQ, |
|
fpga_dmabuff, PLF_FPGA_STATUS_LEN); |
|
|
|
send_vendor_command(udev, PLF_VNDR_FPGA_SET_CMD, NULL, 0); |
|
|
|
if (fpga_dmabuff[0] != PLF_FPGA_MG) { |
|
dev_err(&intf->dev, "fpga_dmabuff[0] is wrong\n"); |
|
r = -EINVAL; |
|
goto error_free_fw; |
|
} |
|
|
|
for (fw_data_i = 0; fw_data_i < fw->size;) { |
|
int tbuf_idx; |
|
|
|
if ((fw->size - fw_data_i) < blk_tran_len) |
|
blk_tran_len = fw->size - fw_data_i; |
|
|
|
fw_data = kmemdup(&fw->data[fw_data_i], blk_tran_len, |
|
GFP_KERNEL); |
|
if (!fw_data) { |
|
r = -ENOMEM; |
|
goto error_free_fw; |
|
} |
|
|
|
for (tbuf_idx = 0; tbuf_idx < blk_tran_len; tbuf_idx++) { |
|
/* u8 bit reverse */ |
|
fw_data[tbuf_idx] = bitrev8(fw_data[tbuf_idx]); |
|
} |
|
r = usb_bulk_msg(udev, |
|
usb_sndbulkpipe(interface_to_usbdev(intf), |
|
fpga_dmabuff[0] & 0xff), |
|
fw_data, |
|
blk_tran_len, |
|
&actual_length, |
|
2 * PLF_USB_TIMEOUT); |
|
|
|
if (r) |
|
dev_err(&intf->dev, "Bulk msg failed (%d)\n", r); |
|
|
|
kfree(fw_data); |
|
fw_data_i += blk_tran_len; |
|
} |
|
|
|
kfree(fpga_dmabuff); |
|
fpga_dmabuff = kmalloc(PLF_FPGA_STATE_LEN, GFP_KERNEL); |
|
if (!fpga_dmabuff) { |
|
r = -ENOMEM; |
|
goto error_free_fw; |
|
} |
|
memset(fpga_dmabuff, 0xff, PLF_FPGA_STATE_LEN); |
|
|
|
send_vendor_request(udev, PLF_VNDR_FPGA_STATE_REQ, fpga_dmabuff, |
|
PLF_FPGA_STATE_LEN); |
|
|
|
dev_dbg(&intf->dev, "%*ph\n", 8, fpga_dmabuff); |
|
|
|
if (fpga_dmabuff[0] != 0) { |
|
r = -EINVAL; |
|
goto error_free_fw; |
|
} |
|
|
|
send_vendor_command(udev, PLF_VNDR_FPGA_STATE_CMD, NULL, 0); |
|
|
|
msleep(PLF_MSLEEP_TIME); |
|
|
|
error_free_fw: |
|
kfree(fpga_dmabuff); |
|
release_firmware(fw); |
|
error: |
|
return r; |
|
} |
|
|
|
int plfxlc_download_xl_firmware(struct usb_interface *intf) |
|
{ |
|
struct usb_device *udev = interface_to_usbdev(intf); |
|
const struct firmware *fwp = NULL; |
|
struct plfxlc_firmware_file file = {0}; |
|
const char *fw_pack; |
|
int s, r; |
|
u8 *buf; |
|
u32 i; |
|
|
|
r = send_vendor_command(udev, PLF_VNDR_XL_FW_CMD, NULL, 0); |
|
msleep(PLF_MSLEEP_TIME); |
|
|
|
if (r) { |
|
dev_err(&intf->dev, "vendor command failed (%d)\n", r); |
|
return -EINVAL; |
|
} |
|
/* Code for single pack file download */ |
|
|
|
fw_pack = "plfxlc/lifi-xl.bin"; |
|
|
|
r = request_firmware(&fwp, fw_pack, &intf->dev); |
|
if (r) { |
|
dev_err(&intf->dev, "Request_firmware failed (%d)\n", r); |
|
return -EINVAL; |
|
} |
|
file.total_files = get_unaligned_le32(&fwp->data[0]); |
|
file.total_size = get_unaligned_le32(&fwp->size); |
|
|
|
dev_dbg(&intf->dev, "XL Firmware (%d, %d)\n", |
|
file.total_files, file.total_size); |
|
|
|
buf = kzalloc(PLF_XL_BUF_LEN, GFP_KERNEL); |
|
if (!buf) { |
|
release_firmware(fwp); |
|
return -ENOMEM; |
|
} |
|
|
|
if (file.total_files > 10) { |
|
dev_err(&intf->dev, "Too many files (%d)\n", file.total_files); |
|
release_firmware(fwp); |
|
kfree(buf); |
|
return -EINVAL; |
|
} |
|
|
|
/* Download firmware files in multiple steps */ |
|
for (s = 0; s < file.total_files; s++) { |
|
buf[0] = s; |
|
r = send_vendor_command(udev, PLF_VNDR_XL_FILE_CMD, buf, |
|
PLF_XL_BUF_LEN); |
|
|
|
if (s < file.total_files - 1) |
|
file.size = get_unaligned_le32(&fwp->data[4 + ((s + 1) * 4)]) |
|
- get_unaligned_le32(&fwp->data[4 + (s) * 4]); |
|
else |
|
file.size = file.total_size - |
|
get_unaligned_le32(&fwp->data[4 + (s) * 4]); |
|
|
|
if (file.size > file.total_size || file.size > 60000) { |
|
dev_err(&intf->dev, "File size is too large (%d)\n", file.size); |
|
break; |
|
} |
|
|
|
file.start_addr = get_unaligned_le32(&fwp->data[4 + (s * 4)]); |
|
|
|
if (file.size % PLF_XL_BUF_LEN && s < 2) |
|
file.size += PLF_XL_BUF_LEN - file.size % PLF_XL_BUF_LEN; |
|
|
|
file.control_packets = file.size / PLF_XL_BUF_LEN; |
|
|
|
for (i = 0; i < file.control_packets; i++) { |
|
memcpy(buf, |
|
&fwp->data[file.start_addr + (i * PLF_XL_BUF_LEN)], |
|
PLF_XL_BUF_LEN); |
|
r = send_vendor_command(udev, PLF_VNDR_XL_DATA_CMD, buf, |
|
PLF_XL_BUF_LEN); |
|
} |
|
dev_dbg(&intf->dev, "fw-dw step=%d,r=%d size=%d\n", s, r, |
|
file.size); |
|
} |
|
release_firmware(fwp); |
|
kfree(buf); |
|
|
|
/* Code for single pack file download ends fw download finish */ |
|
|
|
r = send_vendor_command(udev, PLF_VNDR_XL_EX_CMD, NULL, 0); |
|
dev_dbg(&intf->dev, "Download fpga (4) (%d)\n", r); |
|
|
|
return 0; |
|
} |
|
|
|
int plfxlc_upload_mac_and_serial(struct usb_interface *intf, |
|
unsigned char *hw_address, |
|
unsigned char *serial_number) |
|
{ |
|
struct usb_device *udev = interface_to_usbdev(intf); |
|
unsigned long long firmware_version; |
|
unsigned char *dma_buffer = NULL; |
|
|
|
dma_buffer = kmalloc(PLF_SERIAL_LEN, GFP_KERNEL); |
|
if (!dma_buffer) |
|
return -ENOMEM; |
|
|
|
BUILD_BUG_ON(ETH_ALEN > PLF_SERIAL_LEN); |
|
BUILD_BUG_ON(PLF_FW_VER_LEN > PLF_SERIAL_LEN); |
|
|
|
send_vendor_request(udev, PLF_MAC_VENDOR_REQUEST, dma_buffer, |
|
ETH_ALEN); |
|
|
|
memcpy(hw_address, dma_buffer, ETH_ALEN); |
|
|
|
send_vendor_request(udev, PLF_SERIAL_NUMBER_VENDOR_REQUEST, |
|
dma_buffer, PLF_SERIAL_LEN); |
|
|
|
send_vendor_request(udev, PLF_SERIAL_NUMBER_VENDOR_REQUEST, |
|
dma_buffer, PLF_SERIAL_LEN); |
|
|
|
memcpy(serial_number, dma_buffer, PLF_SERIAL_LEN); |
|
|
|
memset(dma_buffer, 0x00, PLF_SERIAL_LEN); |
|
|
|
send_vendor_request(udev, PLF_FIRMWARE_VERSION_VENDOR_REQUEST, |
|
(unsigned char *)dma_buffer, PLF_FW_VER_LEN); |
|
|
|
memcpy(&firmware_version, dma_buffer, PLF_FW_VER_LEN); |
|
|
|
dev_info(&intf->dev, "Firmware Version: %llu\n", firmware_version); |
|
kfree(dma_buffer); |
|
|
|
dev_dbg(&intf->dev, "Mac: %pM\n", hw_address); |
|
|
|
return 0; |
|
} |
|
|
|
|