ethernet/realtek/r8169_firmware.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /* r8169_firmware.c: RealTek 8169/8168/8101 ethernet driver.
0003  *
0004  * Copyright (c) 2002 ShuChen <shuchen@realtek.com.tw>
0005  * Copyright (c) 2003 - 2007 Francois Romieu <romieu@fr.zoreil.com>
0006  * Copyright (c) a lot of people too. Please respect their work.
0007  *
0008  * See MAINTAINERS file for support contact information.
0009  */
0010
0011 #include <linux/delay.h>
0012 #include <linux/firmware.h>
0013
0014 #include "r8169_firmware.h"
0015
0016 enum rtl_fw_opcode {
0017     PHY_READ        = 0x0,
0018     PHY_DATA_OR     = 0x1,
0019     PHY_DATA_AND        = 0x2,
0020     PHY_BJMPN       = 0x3,
0021     PHY_MDIO_CHG        = 0x4,
0022     PHY_CLEAR_READCOUNT = 0x7,
0023     PHY_WRITE       = 0x8,
0024     PHY_READCOUNT_EQ_SKIP   = 0x9,
0025     PHY_COMP_EQ_SKIPN   = 0xa,
0026     PHY_COMP_NEQ_SKIPN  = 0xb,
0027     PHY_WRITE_PREVIOUS  = 0xc,
0028     PHY_SKIPN       = 0xd,
0029     PHY_DELAY_MS        = 0xe,
0030 };
0031
0032 struct fw_info {
0033     u32 magic;
0034     char    version[RTL_VER_SIZE];
0035     __le32  fw_start;
0036     __le32  fw_len;
0037     u8  chksum;
0038 } __packed;
0039
0040 #define FW_OPCODE_SIZE sizeof_field(struct rtl_fw_phy_action, code[0])
0041
0042 static bool rtl_fw_format_ok(struct rtl_fw *rtl_fw)
0043 {
0044     const struct firmware *fw = rtl_fw->fw;
0045     struct fw_info *fw_info = (struct fw_info *)fw->data;
0046     struct rtl_fw_phy_action *pa = &rtl_fw->phy_action;
0047
0048     if (fw->size < FW_OPCODE_SIZE)
0049         return false;
0050
0051     if (!fw_info->magic) {
0052         size_t i, size, start;
0053         u8 checksum = 0;
0054
0055         if (fw->size < sizeof(*fw_info))
0056             return false;
0057
0058         for (i = 0; i < fw->size; i++)
0059             checksum += fw->data[i];
0060         if (checksum != 0)
0061             return false;
0062
0063         start = le32_to_cpu(fw_info->fw_start);
0064         if (start > fw->size)
0065             return false;
0066
0067         size = le32_to_cpu(fw_info->fw_len);
0068         if (size > (fw->size - start) / FW_OPCODE_SIZE)
0069             return false;
0070
0071         strscpy(rtl_fw->version, fw_info->version, RTL_VER_SIZE);
0072
0073         pa->code = (__le32 *)(fw->data + start);
0074         pa->size = size;
0075     } else {
0076         if (fw->size % FW_OPCODE_SIZE)
0077             return false;
0078
0079         strscpy(rtl_fw->version, rtl_fw->fw_name, RTL_VER_SIZE);
0080
0081         pa->code = (__le32 *)fw->data;
0082         pa->size = fw->size / FW_OPCODE_SIZE;
0083     }
0084
0085     return true;
0086 }
0087
0088 static bool rtl_fw_data_ok(struct rtl_fw *rtl_fw)
0089 {
0090     struct rtl_fw_phy_action *pa = &rtl_fw->phy_action;
0091     size_t index;
0092
0093     for (index = 0; index < pa->size; index++) {
0094         u32 action = le32_to_cpu(pa->code[index]);
0095         u32 val = action & 0x0000ffff;
0096         u32 regno = (action & 0x0fff0000) >> 16;
0097
0098         switch (action >> 28) {
0099         case PHY_READ:
0100         case PHY_DATA_OR:
0101         case PHY_DATA_AND:
0102         case PHY_CLEAR_READCOUNT:
0103         case PHY_WRITE:
0104         case PHY_WRITE_PREVIOUS:
0105         case PHY_DELAY_MS:
0106             break;
0107
0108         case PHY_MDIO_CHG:
0109             if (val > 1)
0110                 goto out;
0111             break;
0112
0113         case PHY_BJMPN:
0114             if (regno > index)
0115                 goto out;
0116             break;
0117         case PHY_READCOUNT_EQ_SKIP:
0118             if (index + 2 >= pa->size)
0119                 goto out;
0120             break;
0121         case PHY_COMP_EQ_SKIPN:
0122         case PHY_COMP_NEQ_SKIPN:
0123         case PHY_SKIPN:
0124             if (index + 1 + regno >= pa->size)
0125                 goto out;
0126             break;
0127
0128         default:
0129             dev_err(rtl_fw->dev, "Invalid action 0x%08x\n", action);
0130             return false;
0131         }
0132     }
0133
0134     return true;
0135 out:
0136     dev_err(rtl_fw->dev, "Out of range of firmware\n");
0137     return false;
0138 }
0139
0140 void rtl_fw_write_firmware(struct rtl8169_private *tp, struct rtl_fw *rtl_fw)
0141 {
0142     struct rtl_fw_phy_action *pa = &rtl_fw->phy_action;
0143     rtl_fw_write_t fw_write = rtl_fw->phy_write;
0144     rtl_fw_read_t fw_read = rtl_fw->phy_read;
0145     int predata = 0, count = 0;
0146     size_t index;
0147
0148     for (index = 0; index < pa->size; index++) {
0149         u32 action = le32_to_cpu(pa->code[index]);
0150         u32 data = action & 0x0000ffff;
0151         u32 regno = (action & 0x0fff0000) >> 16;
0152         enum rtl_fw_opcode opcode = action >> 28;
0153
0154         if (!action)
0155             break;
0156
0157         switch (opcode) {
0158         case PHY_READ:
0159             predata = fw_read(tp, regno);
0160             count++;
0161             break;
0162         case PHY_DATA_OR:
0163             predata |= data;
0164             break;
0165         case PHY_DATA_AND:
0166             predata &= data;
0167             break;
0168         case PHY_BJMPN:
0169             index -= (regno + 1);
0170             break;
0171         case PHY_MDIO_CHG:
0172             if (data) {
0173                 fw_write = rtl_fw->mac_mcu_write;
0174                 fw_read = rtl_fw->mac_mcu_read;
0175             } else {
0176                 fw_write = rtl_fw->phy_write;
0177                 fw_read = rtl_fw->phy_read;
0178             }
0179
0180             break;
0181         case PHY_CLEAR_READCOUNT:
0182             count = 0;
0183             break;
0184         case PHY_WRITE:
0185             fw_write(tp, regno, data);
0186             break;
0187         case PHY_READCOUNT_EQ_SKIP:
0188             if (count == data)
0189                 index++;
0190             break;
0191         case PHY_COMP_EQ_SKIPN:
0192             if (predata == data)
0193                 index += regno;
0194             break;
0195         case PHY_COMP_NEQ_SKIPN:
0196             if (predata != data)
0197                 index += regno;
0198             break;
0199         case PHY_WRITE_PREVIOUS:
0200             fw_write(tp, regno, predata);
0201             break;
0202         case PHY_SKIPN:
0203             index += regno;
0204             break;
0205         case PHY_DELAY_MS:
0206             msleep(data);
0207             break;
0208         }
0209     }
0210 }
0211
0212 void rtl_fw_release_firmware(struct rtl_fw *rtl_fw)
0213 {
0214     release_firmware(rtl_fw->fw);
0215 }
0216
0217 int rtl_fw_request_firmware(struct rtl_fw *rtl_fw)
0218 {
0219     int rc;
0220
0221     rc = request_firmware(&rtl_fw->fw, rtl_fw->fw_name, rtl_fw->dev);
0222     if (rc < 0)
0223         goto out;
0224
0225     if (!rtl_fw_format_ok(rtl_fw) || !rtl_fw_data_ok(rtl_fw)) {
0226         release_firmware(rtl_fw->fw);
0227         rc = -EINVAL;
0228         goto out;
0229     }
0230
0231     return 0;
0232 out:
0233     dev_err(rtl_fw->dev, "Unable to load firmware %s (%d)\n",
0234         rtl_fw->fw_name, rc);
0235     return rc;
0236 }