purelifi/plfxlc/firmware.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (c) 2021 pureLiFi
0004  */
0005
0006 #include <linux/firmware.h>
0007 #include <linux/bitrev.h>
0008
0009 #include "mac.h"
0010 #include "usb.h"
0011
0012 static int send_vendor_request(struct usb_device *udev, int request,
0013                    unsigned char *buffer, int buffer_size)
0014 {
0015     return usb_control_msg(udev,
0016                    usb_rcvctrlpipe(udev, 0),
0017                    request, 0xC0, 0, 0,
0018                    buffer, buffer_size, PLF_USB_TIMEOUT);
0019 }
0020
0021 static int send_vendor_command(struct usb_device *udev, int request,
0022                    unsigned char *buffer, int buffer_size)
0023 {
0024     return usb_control_msg(udev,
0025                    usb_sndctrlpipe(udev, 0),
0026                    request, USB_TYPE_VENDOR /*0x40*/, 0, 0,
0027                    buffer, buffer_size, PLF_USB_TIMEOUT);
0028 }
0029
0030 int plfxlc_download_fpga(struct usb_interface *intf)
0031 {
0032     struct usb_device *udev = interface_to_usbdev(intf);
0033     unsigned char *fpga_dmabuff = NULL;
0034     const struct firmware *fw = NULL;
0035     int blk_tran_len = PLF_BULK_TLEN;
0036     unsigned char *fw_data;
0037     const char *fw_name;
0038     int r, actual_length;
0039     int fw_data_i = 0;
0040
0041     if ((le16_to_cpu(udev->descriptor.idVendor) ==
0042                 PURELIFI_X_VENDOR_ID_0) &&
0043         (le16_to_cpu(udev->descriptor.idProduct) ==
0044                 PURELIFI_X_PRODUCT_ID_0)) {
0045         fw_name = "plfxlc/lifi-x.bin";
0046         dev_dbg(&intf->dev, "bin file for X selected\n");
0047
0048     } else if ((le16_to_cpu(udev->descriptor.idVendor)) ==
0049                     PURELIFI_XC_VENDOR_ID_0 &&
0050            (le16_to_cpu(udev->descriptor.idProduct) ==
0051                     PURELIFI_XC_PRODUCT_ID_0)) {
0052         fw_name = "plfxlc/lifi-xc.bin";
0053         dev_dbg(&intf->dev, "bin file for XC selected\n");
0054
0055     } else {
0056         r = -EINVAL;
0057         goto error;
0058     }
0059
0060     r = request_firmware(&fw, fw_name, &intf->dev);
0061     if (r) {
0062         dev_err(&intf->dev, "request_firmware failed (%d)\n", r);
0063         goto error;
0064     }
0065     fpga_dmabuff = kmalloc(PLF_FPGA_STATUS_LEN, GFP_KERNEL);
0066
0067     if (!fpga_dmabuff) {
0068         r = -ENOMEM;
0069         goto error_free_fw;
0070     }
0071     send_vendor_request(udev, PLF_VNDR_FPGA_SET_REQ,
0072                 fpga_dmabuff, PLF_FPGA_STATUS_LEN);
0073
0074     send_vendor_command(udev, PLF_VNDR_FPGA_SET_CMD, NULL, 0);
0075
0076     if (fpga_dmabuff[0] != PLF_FPGA_MG) {
0077         dev_err(&intf->dev, "fpga_dmabuff[0] is wrong\n");
0078         r = -EINVAL;
0079         goto error_free_fw;
0080     }
0081
0082     for (fw_data_i = 0; fw_data_i < fw->size;) {
0083         int tbuf_idx;
0084
0085         if ((fw->size - fw_data_i) < blk_tran_len)
0086             blk_tran_len = fw->size - fw_data_i;
0087
0088         fw_data = kmemdup(&fw->data[fw_data_i], blk_tran_len,
0089                   GFP_KERNEL);
0090         if (!fw_data) {
0091             r = -ENOMEM;
0092             goto error_free_fw;
0093         }
0094
0095         for (tbuf_idx = 0; tbuf_idx < blk_tran_len; tbuf_idx++) {
0096             /* u8 bit reverse */
0097             fw_data[tbuf_idx] = bitrev8(fw_data[tbuf_idx]);
0098         }
0099         r = usb_bulk_msg(udev,
0100                  usb_sndbulkpipe(interface_to_usbdev(intf),
0101                          fpga_dmabuff[0] & 0xff),
0102                  fw_data,
0103                  blk_tran_len,
0104                  &actual_length,
0105                  2 * PLF_USB_TIMEOUT);
0106
0107         if (r)
0108             dev_err(&intf->dev, "Bulk msg failed (%d)\n", r);
0109
0110         kfree(fw_data);
0111         fw_data_i += blk_tran_len;
0112     }
0113
0114     kfree(fpga_dmabuff);
0115     fpga_dmabuff = kmalloc(PLF_FPGA_STATE_LEN, GFP_KERNEL);
0116     if (!fpga_dmabuff) {
0117         r = -ENOMEM;
0118         goto error_free_fw;
0119     }
0120     memset(fpga_dmabuff, 0xff, PLF_FPGA_STATE_LEN);
0121
0122     send_vendor_request(udev, PLF_VNDR_FPGA_STATE_REQ, fpga_dmabuff,
0123                 PLF_FPGA_STATE_LEN);
0124
0125     dev_dbg(&intf->dev, "%*ph\n", 8, fpga_dmabuff);
0126
0127     if (fpga_dmabuff[0] != 0) {
0128         r = -EINVAL;
0129         goto error_free_fw;
0130     }
0131
0132     send_vendor_command(udev, PLF_VNDR_FPGA_STATE_CMD, NULL, 0);
0133
0134     msleep(PLF_MSLEEP_TIME);
0135
0136 error_free_fw:
0137     kfree(fpga_dmabuff);
0138     release_firmware(fw);
0139 error:
0140     return r;
0141 }
0142
0143 int plfxlc_download_xl_firmware(struct usb_interface *intf)
0144 {
0145     struct usb_device *udev = interface_to_usbdev(intf);
0146     const struct firmware *fwp = NULL;
0147     struct plfxlc_firmware_file file = {0};
0148     const char *fw_pack;
0149     int s, r;
0150     u8 *buf;
0151     u32 i;
0152
0153     r = send_vendor_command(udev, PLF_VNDR_XL_FW_CMD, NULL, 0);
0154     msleep(PLF_MSLEEP_TIME);
0155
0156     if (r) {
0157         dev_err(&intf->dev, "vendor command failed (%d)\n", r);
0158         return -EINVAL;
0159     }
0160     /* Code for single pack file download */
0161
0162     fw_pack = "plfxlc/lifi-xl.bin";
0163
0164     r = request_firmware(&fwp, fw_pack, &intf->dev);
0165     if (r) {
0166         dev_err(&intf->dev, "Request_firmware failed (%d)\n", r);
0167         return -EINVAL;
0168     }
0169     file.total_files = get_unaligned_le32(&fwp->data[0]);
0170     file.total_size = get_unaligned_le32(&fwp->size);
0171
0172     dev_dbg(&intf->dev, "XL Firmware (%d, %d)\n",
0173         file.total_files, file.total_size);
0174
0175     buf = kzalloc(PLF_XL_BUF_LEN, GFP_KERNEL);
0176     if (!buf) {
0177         release_firmware(fwp);
0178         return -ENOMEM;
0179     }
0180
0181     if (file.total_files > 10) {
0182         dev_err(&intf->dev, "Too many files (%d)\n", file.total_files);
0183         release_firmware(fwp);
0184         kfree(buf);
0185         return -EINVAL;
0186     }
0187
0188     /* Download firmware files in multiple steps */
0189     for (s = 0; s < file.total_files; s++) {
0190         buf[0] = s;
0191         r = send_vendor_command(udev, PLF_VNDR_XL_FILE_CMD, buf,
0192                     PLF_XL_BUF_LEN);
0193
0194         if (s < file.total_files - 1)
0195             file.size = get_unaligned_le32(&fwp->data[4 + ((s + 1) * 4)])
0196                     - get_unaligned_le32(&fwp->data[4 + (s) * 4]);
0197         else
0198             file.size = file.total_size -
0199                     get_unaligned_le32(&fwp->data[4 + (s) * 4]);
0200
0201         if (file.size > file.total_size || file.size > 60000) {
0202             dev_err(&intf->dev, "File size is too large (%d)\n", file.size);
0203             break;
0204         }
0205
0206         file.start_addr = get_unaligned_le32(&fwp->data[4 + (s * 4)]);
0207
0208         if (file.size % PLF_XL_BUF_LEN && s < 2)
0209             file.size += PLF_XL_BUF_LEN - file.size % PLF_XL_BUF_LEN;
0210
0211         file.control_packets = file.size / PLF_XL_BUF_LEN;
0212
0213         for (i = 0; i < file.control_packets; i++) {
0214             memcpy(buf,
0215                    &fwp->data[file.start_addr + (i * PLF_XL_BUF_LEN)],
0216                    PLF_XL_BUF_LEN);
0217             r = send_vendor_command(udev, PLF_VNDR_XL_DATA_CMD, buf,
0218                         PLF_XL_BUF_LEN);
0219         }
0220         dev_dbg(&intf->dev, "fw-dw step=%d,r=%d size=%d\n", s, r,
0221             file.size);
0222     }
0223     release_firmware(fwp);
0224     kfree(buf);
0225
0226     /* Code for single pack file download ends fw download finish */
0227
0228     r = send_vendor_command(udev, PLF_VNDR_XL_EX_CMD, NULL, 0);
0229     dev_dbg(&intf->dev, "Download fpga (4) (%d)\n", r);
0230
0231     return 0;
0232 }
0233
0234 int plfxlc_upload_mac_and_serial(struct usb_interface *intf,
0235                  unsigned char *hw_address,
0236                  unsigned char *serial_number)
0237 {
0238     struct usb_device *udev = interface_to_usbdev(intf);
0239     unsigned long long firmware_version;
0240     unsigned char *dma_buffer = NULL;
0241
0242     dma_buffer = kmalloc(PLF_SERIAL_LEN, GFP_KERNEL);
0243     if (!dma_buffer)
0244         return -ENOMEM;
0245
0246     BUILD_BUG_ON(ETH_ALEN > PLF_SERIAL_LEN);
0247     BUILD_BUG_ON(PLF_FW_VER_LEN > PLF_SERIAL_LEN);
0248
0249     send_vendor_request(udev, PLF_MAC_VENDOR_REQUEST, dma_buffer,
0250                 ETH_ALEN);
0251
0252     memcpy(hw_address, dma_buffer, ETH_ALEN);
0253
0254     send_vendor_request(udev, PLF_SERIAL_NUMBER_VENDOR_REQUEST,
0255                 dma_buffer, PLF_SERIAL_LEN);
0256
0257     send_vendor_request(udev, PLF_SERIAL_NUMBER_VENDOR_REQUEST,
0258                 dma_buffer, PLF_SERIAL_LEN);
0259
0260     memcpy(serial_number, dma_buffer, PLF_SERIAL_LEN);
0261
0262     memset(dma_buffer, 0x00, PLF_SERIAL_LEN);
0263
0264     send_vendor_request(udev, PLF_FIRMWARE_VERSION_VENDOR_REQUEST,
0265                 (unsigned char *)dma_buffer, PLF_FW_VER_LEN);
0266
0267     memcpy(&firmware_version, dma_buffer, PLF_FW_VER_LEN);
0268
0269     dev_info(&intf->dev, "Firmware Version: %llu\n", firmware_version);
0270     kfree(dma_buffer);
0271
0272     dev_dbg(&intf->dev, "Mac: %pM\n", hw_address);
0273
0274     return 0;
0275 }
0276