1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2021 pureLiFi 4 */ 5 6 #include <linux/firmware.h> 7 #include <linux/bitrev.h> 8 9 #include "mac.h" 10 #include "usb.h" 11 12 static int send_vendor_request(struct usb_device *udev, int request, 13 unsigned char *buffer, int buffer_size) 14 { 15 return usb_control_msg(udev, 16 usb_rcvctrlpipe(udev, 0), 17 request, 0xC0, 0, 0, 18 buffer, buffer_size, PLF_USB_TIMEOUT); 19 } 20 21 static int send_vendor_command(struct usb_device *udev, int request, 22 unsigned char *buffer, int buffer_size) 23 { 24 return usb_control_msg(udev, 25 usb_sndctrlpipe(udev, 0), 26 request, USB_TYPE_VENDOR /*0x40*/, 0, 0, 27 buffer, buffer_size, PLF_USB_TIMEOUT); 28 } 29 30 int plfxlc_download_fpga(struct usb_interface *intf) 31 { 32 struct usb_device *udev = interface_to_usbdev(intf); 33 unsigned char *fpga_dmabuff = NULL; 34 const struct firmware *fw = NULL; 35 int blk_tran_len = PLF_BULK_TLEN; 36 unsigned char *fw_data; 37 const char *fw_name; 38 int r, actual_length; 39 int fw_data_i = 0; 40 41 if ((le16_to_cpu(udev->descriptor.idVendor) == 42 PURELIFI_X_VENDOR_ID_0) && 43 (le16_to_cpu(udev->descriptor.idProduct) == 44 PURELIFI_X_PRODUCT_ID_0)) { 45 fw_name = "plfxlc/lifi-x.bin"; 46 dev_dbg(&intf->dev, "bin file for X selected\n"); 47 48 } else if ((le16_to_cpu(udev->descriptor.idVendor)) == 49 PURELIFI_XC_VENDOR_ID_0 && 50 (le16_to_cpu(udev->descriptor.idProduct) == 51 PURELIFI_XC_PRODUCT_ID_0)) { 52 fw_name = "plfxlc/lifi-xc.bin"; 53 dev_dbg(&intf->dev, "bin file for XC selected\n"); 54 55 } else { 56 r = -EINVAL; 57 goto error; 58 } 59 60 r = request_firmware(&fw, fw_name, &intf->dev); 61 if (r) { 62 dev_err(&intf->dev, "request_firmware failed (%d)\n", r); 63 goto error; 64 } 65 fpga_dmabuff = kmalloc(PLF_FPGA_STATUS_LEN, GFP_KERNEL); 66 67 if (!fpga_dmabuff) { 68 r = -ENOMEM; 69 goto error_free_fw; 70 } 71 send_vendor_request(udev, PLF_VNDR_FPGA_SET_REQ, 72 fpga_dmabuff, PLF_FPGA_STATUS_LEN); 73 74 send_vendor_command(udev, PLF_VNDR_FPGA_SET_CMD, NULL, 0); 75 76 if (fpga_dmabuff[0] != PLF_FPGA_MG) { 77 dev_err(&intf->dev, "fpga_dmabuff[0] is wrong\n"); 78 r = -EINVAL; 79 goto error_free_fw; 80 } 81 82 for (fw_data_i = 0; fw_data_i < fw->size;) { 83 int tbuf_idx; 84 85 if ((fw->size - fw_data_i) < blk_tran_len) 86 blk_tran_len = fw->size - fw_data_i; 87 88 fw_data = kmemdup(&fw->data[fw_data_i], blk_tran_len, 89 GFP_KERNEL); 90 if (!fw_data) { 91 r = -ENOMEM; 92 goto error_free_fw; 93 } 94 95 for (tbuf_idx = 0; tbuf_idx < blk_tran_len; tbuf_idx++) { 96 /* u8 bit reverse */ 97 fw_data[tbuf_idx] = bitrev8(fw_data[tbuf_idx]); 98 } 99 r = usb_bulk_msg(udev, 100 usb_sndbulkpipe(interface_to_usbdev(intf), 101 fpga_dmabuff[0] & 0xff), 102 fw_data, 103 blk_tran_len, 104 &actual_length, 105 2 * PLF_USB_TIMEOUT); 106 107 if (r) 108 dev_err(&intf->dev, "Bulk msg failed (%d)\n", r); 109 110 kfree(fw_data); 111 fw_data_i += blk_tran_len; 112 } 113 114 kfree(fpga_dmabuff); 115 fpga_dmabuff = kmalloc(PLF_FPGA_STATE_LEN, GFP_KERNEL); 116 if (!fpga_dmabuff) { 117 r = -ENOMEM; 118 goto error_free_fw; 119 } 120 memset(fpga_dmabuff, 0xff, PLF_FPGA_STATE_LEN); 121 122 send_vendor_request(udev, PLF_VNDR_FPGA_STATE_REQ, fpga_dmabuff, 123 PLF_FPGA_STATE_LEN); 124 125 dev_dbg(&intf->dev, "%*ph\n", 8, fpga_dmabuff); 126 127 if (fpga_dmabuff[0] != 0) { 128 r = -EINVAL; 129 goto error_free_fw; 130 } 131 132 send_vendor_command(udev, PLF_VNDR_FPGA_STATE_CMD, NULL, 0); 133 134 msleep(PLF_MSLEEP_TIME); 135 136 error_free_fw: 137 kfree(fpga_dmabuff); 138 release_firmware(fw); 139 error: 140 return r; 141 } 142 143 int plfxlc_download_xl_firmware(struct usb_interface *intf) 144 { 145 struct usb_device *udev = interface_to_usbdev(intf); 146 const struct firmware *fwp = NULL; 147 struct plfxlc_firmware_file file = {0}; 148 const char *fw_pack; 149 int s, r; 150 u8 *buf; 151 u32 i; 152 153 r = send_vendor_command(udev, PLF_VNDR_XL_FW_CMD, NULL, 0); 154 msleep(PLF_MSLEEP_TIME); 155 156 if (r) { 157 dev_err(&intf->dev, "vendor command failed (%d)\n", r); 158 return -EINVAL; 159 } 160 /* Code for single pack file download */ 161 162 fw_pack = "plfxlc/lifi-xl.bin"; 163 164 r = request_firmware(&fwp, fw_pack, &intf->dev); 165 if (r) { 166 dev_err(&intf->dev, "Request_firmware failed (%d)\n", r); 167 return -EINVAL; 168 } 169 file.total_files = get_unaligned_le32(&fwp->data[0]); 170 file.total_size = get_unaligned_le32(&fwp->size); 171 172 dev_dbg(&intf->dev, "XL Firmware (%d, %d)\n", 173 file.total_files, file.total_size); 174 175 buf = kzalloc(PLF_XL_BUF_LEN, GFP_KERNEL); 176 if (!buf) { 177 release_firmware(fwp); 178 return -ENOMEM; 179 } 180 181 if (file.total_files > 10) { 182 dev_err(&intf->dev, "Too many files (%d)\n", file.total_files); 183 release_firmware(fwp); 184 kfree(buf); 185 return -EINVAL; 186 } 187 188 /* Download firmware files in multiple steps */ 189 for (s = 0; s < file.total_files; s++) { 190 buf[0] = s; 191 r = send_vendor_command(udev, PLF_VNDR_XL_FILE_CMD, buf, 192 PLF_XL_BUF_LEN); 193 194 if (s < file.total_files - 1) 195 file.size = get_unaligned_le32(&fwp->data[4 + ((s + 1) * 4)]) 196 - get_unaligned_le32(&fwp->data[4 + (s) * 4]); 197 else 198 file.size = file.total_size - 199 get_unaligned_le32(&fwp->data[4 + (s) * 4]); 200 201 if (file.size > file.total_size || file.size > 60000) { 202 dev_err(&intf->dev, "File size is too large (%d)\n", file.size); 203 break; 204 } 205 206 file.start_addr = get_unaligned_le32(&fwp->data[4 + (s * 4)]); 207 208 if (file.size % PLF_XL_BUF_LEN && s < 2) 209 file.size += PLF_XL_BUF_LEN - file.size % PLF_XL_BUF_LEN; 210 211 file.control_packets = file.size / PLF_XL_BUF_LEN; 212 213 for (i = 0; i < file.control_packets; i++) { 214 memcpy(buf, 215 &fwp->data[file.start_addr + (i * PLF_XL_BUF_LEN)], 216 PLF_XL_BUF_LEN); 217 r = send_vendor_command(udev, PLF_VNDR_XL_DATA_CMD, buf, 218 PLF_XL_BUF_LEN); 219 } 220 dev_dbg(&intf->dev, "fw-dw step=%d,r=%d size=%d\n", s, r, 221 file.size); 222 } 223 release_firmware(fwp); 224 kfree(buf); 225 226 /* Code for single pack file download ends fw download finish */ 227 228 r = send_vendor_command(udev, PLF_VNDR_XL_EX_CMD, NULL, 0); 229 dev_dbg(&intf->dev, "Download fpga (4) (%d)\n", r); 230 231 return 0; 232 } 233 234 int plfxlc_upload_mac_and_serial(struct usb_interface *intf, 235 unsigned char *hw_address, 236 unsigned char *serial_number) 237 { 238 struct usb_device *udev = interface_to_usbdev(intf); 239 unsigned long long firmware_version; 240 unsigned char *dma_buffer = NULL; 241 242 dma_buffer = kmalloc(PLF_SERIAL_LEN, GFP_KERNEL); 243 if (!dma_buffer) 244 return -ENOMEM; 245 246 BUILD_BUG_ON(ETH_ALEN > PLF_SERIAL_LEN); 247 BUILD_BUG_ON(PLF_FW_VER_LEN > PLF_SERIAL_LEN); 248 249 send_vendor_request(udev, PLF_MAC_VENDOR_REQUEST, dma_buffer, 250 ETH_ALEN); 251 252 memcpy(hw_address, dma_buffer, ETH_ALEN); 253 254 send_vendor_request(udev, PLF_SERIAL_NUMBER_VENDOR_REQUEST, 255 dma_buffer, PLF_SERIAL_LEN); 256 257 send_vendor_request(udev, PLF_SERIAL_NUMBER_VENDOR_REQUEST, 258 dma_buffer, PLF_SERIAL_LEN); 259 260 memcpy(serial_number, dma_buffer, PLF_SERIAL_LEN); 261 262 memset(dma_buffer, 0x00, PLF_SERIAL_LEN); 263 264 send_vendor_request(udev, PLF_FIRMWARE_VERSION_VENDOR_REQUEST, 265 (unsigned char *)dma_buffer, PLF_FW_VER_LEN); 266 267 memcpy(&firmware_version, dma_buffer, PLF_FW_VER_LEN); 268 269 dev_info(&intf->dev, "Firmware Version: %llu\n", firmware_version); 270 kfree(dma_buffer); 271 272 dev_dbg(&intf->dev, "Mac: %pM\n", hw_address); 273 274 return 0; 275 } 276 277