1// SPDX-License-Identifier: GPL-2.0-only 2 3#include <linux/ethtool.h> 4#include <linux/sfp.h> 5#include "netlink.h" 6#include "common.h" 7 8struct eeprom_req_info { 9 struct ethnl_req_info base; 10 u32 offset; 11 u32 length; 12 u8 page; 13 u8 bank; 14 u8 i2c_address; 15}; 16 17struct eeprom_reply_data { 18 struct ethnl_reply_data base; 19 u32 length; 20 u8 *data; 21}; 22 23#define MODULE_EEPROM_REQINFO(__req_base) \ 24 container_of(__req_base, struct eeprom_req_info, base) 25 26#define MODULE_EEPROM_REPDATA(__reply_base) \ 27 container_of(__reply_base, struct eeprom_reply_data, base) 28 29static int fallback_set_params(struct eeprom_req_info *request, 30 struct ethtool_modinfo *modinfo, 31 struct ethtool_eeprom *eeprom) 32{ 33 u32 offset = request->offset; 34 u32 length = request->length; 35 36 if (request->page) 37 offset = request->page * ETH_MODULE_EEPROM_PAGE_LEN + offset; 38 39 if (modinfo->type == ETH_MODULE_SFF_8472 && 40 request->i2c_address == 0x51) 41 offset += ETH_MODULE_EEPROM_PAGE_LEN * 2; 42 43 if (offset >= modinfo->eeprom_len) 44 return -EINVAL; 45 46 eeprom->cmd = ETHTOOL_GMODULEEEPROM; 47 eeprom->len = length; 48 eeprom->offset = offset; 49 50 return 0; 51} 52 53static int eeprom_fallback(struct eeprom_req_info *request, 54 struct eeprom_reply_data *reply) 55{ 56 struct net_device *dev = reply->base.dev; 57 struct ethtool_modinfo modinfo = {0}; 58 struct ethtool_eeprom eeprom = {0}; 59 u8 *data; 60 int err; 61 62 modinfo.cmd = ETHTOOL_GMODULEINFO; 63 err = ethtool_get_module_info_call(dev, &modinfo); 64 if (err < 0) 65 return err; 66 67 err = fallback_set_params(request, &modinfo, &eeprom); 68 if (err < 0) 69 return err; 70 71 data = kmalloc(eeprom.len, GFP_KERNEL); 72 if (!data) 73 return -ENOMEM; 74 err = ethtool_get_module_eeprom_call(dev, &eeprom, data); 75 if (err < 0) 76 goto err_out; 77 78 reply->data = data; 79 reply->length = eeprom.len; 80 81 return 0; 82 83err_out: 84 kfree(data); 85 return err; 86} 87 88static int get_module_eeprom_by_page(struct net_device *dev, 89 struct ethtool_module_eeprom *page_data, 90 struct netlink_ext_ack *extack) 91{ 92 const struct ethtool_ops *ops = dev->ethtool_ops; 93 94 if (dev->sfp_bus) 95 return sfp_get_module_eeprom_by_page(dev->sfp_bus, page_data, extack); 96 97 if (ops->get_module_eeprom_by_page) 98 return ops->get_module_eeprom_by_page(dev, page_data, extack); 99 100 return -EOPNOTSUPP; 101} 102 103static int eeprom_prepare_data(const struct ethnl_req_info *req_base, 104 struct ethnl_reply_data *reply_base, 105 const struct genl_info *info) 106{ 107 struct eeprom_reply_data *reply = MODULE_EEPROM_REPDATA(reply_base); 108 struct eeprom_req_info *request = MODULE_EEPROM_REQINFO(req_base); 109 struct ethtool_module_eeprom page_data = {0}; 110 struct net_device *dev = reply_base->dev; 111 int ret; 112 113 page_data.offset = request->offset; 114 page_data.length = request->length; 115 page_data.i2c_address = request->i2c_address; 116 page_data.page = request->page; 117 page_data.bank = request->bank; 118 page_data.data = kmalloc(page_data.length, GFP_KERNEL); 119 if (!page_data.data) 120 return -ENOMEM; 121 122 ret = ethnl_ops_begin(dev); 123 if (ret) 124 goto err_free; 125 126 ret = get_module_eeprom_by_page(dev, &page_data, info->extack); 127 if (ret < 0) 128 goto err_ops; 129 130 reply->length = ret; 131 reply->data = page_data.data; 132 133 ethnl_ops_complete(dev); 134 return 0; 135 136err_ops: 137 ethnl_ops_complete(dev); 138err_free: 139 kfree(page_data.data); 140 141 if (ret == -EOPNOTSUPP) 142 return eeprom_fallback(request, reply); 143 return ret; 144} 145 146static int eeprom_parse_request(struct ethnl_req_info *req_info, struct nlattr **tb, 147 struct netlink_ext_ack *extack) 148{ 149 struct eeprom_req_info *request = MODULE_EEPROM_REQINFO(req_info); 150 151 if (!tb[ETHTOOL_A_MODULE_EEPROM_OFFSET] || 152 !tb[ETHTOOL_A_MODULE_EEPROM_LENGTH] || 153 !tb[ETHTOOL_A_MODULE_EEPROM_PAGE] || 154 !tb[ETHTOOL_A_MODULE_EEPROM_I2C_ADDRESS]) 155 return -EINVAL; 156 157 request->i2c_address = nla_get_u8(tb[ETHTOOL_A_MODULE_EEPROM_I2C_ADDRESS]); 158 request->offset = nla_get_u32(tb[ETHTOOL_A_MODULE_EEPROM_OFFSET]); 159 request->length = nla_get_u32(tb[ETHTOOL_A_MODULE_EEPROM_LENGTH]); 160 161 /* The following set of conditions limit the API to only dump 1/2 162 * EEPROM page without crossing low page boundary located at offset 128. 163 * This means user may only request dumps of length limited to 128 from 164 * either low 128 bytes or high 128 bytes. 165 * For pages higher than 0 only high 128 bytes are accessible. 166 */ 167 request->page = nla_get_u8(tb[ETHTOOL_A_MODULE_EEPROM_PAGE]); 168 if (request->page && request->offset < ETH_MODULE_EEPROM_PAGE_LEN) { 169 NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_MODULE_EEPROM_PAGE], 170 "reading from lower half page is allowed for page 0 only"); 171 return -EINVAL; 172 } 173 174 if (request->offset < ETH_MODULE_EEPROM_PAGE_LEN && 175 request->offset + request->length > ETH_MODULE_EEPROM_PAGE_LEN) { 176 NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_MODULE_EEPROM_LENGTH], 177 "reading cross half page boundary is illegal"); 178 return -EINVAL; 179 } else if (request->offset + request->length > ETH_MODULE_EEPROM_PAGE_LEN * 2) { 180 NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_MODULE_EEPROM_LENGTH], 181 "reading cross page boundary is illegal"); 182 return -EINVAL; 183 } 184 185 if (tb[ETHTOOL_A_MODULE_EEPROM_BANK]) 186 request->bank = nla_get_u8(tb[ETHTOOL_A_MODULE_EEPROM_BANK]); 187 188 return 0; 189} 190 191static int eeprom_reply_size(const struct ethnl_req_info *req_base, 192 const struct ethnl_reply_data *reply_base) 193{ 194 const struct eeprom_req_info *request = MODULE_EEPROM_REQINFO(req_base); 195 196 return nla_total_size(sizeof(u8) * request->length); /* _EEPROM_DATA */ 197} 198 199static int eeprom_fill_reply(struct sk_buff *skb, 200 const struct ethnl_req_info *req_base, 201 const struct ethnl_reply_data *reply_base) 202{ 203 struct eeprom_reply_data *reply = MODULE_EEPROM_REPDATA(reply_base); 204 205 return nla_put(skb, ETHTOOL_A_MODULE_EEPROM_DATA, reply->length, reply->data); 206} 207 208static void eeprom_cleanup_data(struct ethnl_reply_data *reply_base) 209{ 210 struct eeprom_reply_data *reply = MODULE_EEPROM_REPDATA(reply_base); 211 212 kfree(reply->data); 213} 214 215const struct ethnl_request_ops ethnl_module_eeprom_request_ops = { 216 .request_cmd = ETHTOOL_MSG_MODULE_EEPROM_GET, 217 .reply_cmd = ETHTOOL_MSG_MODULE_EEPROM_GET_REPLY, 218 .hdr_attr = ETHTOOL_A_MODULE_EEPROM_HEADER, 219 .req_info_size = sizeof(struct eeprom_req_info), 220 .reply_data_size = sizeof(struct eeprom_reply_data), 221 222 .parse_request = eeprom_parse_request, 223 .prepare_data = eeprom_prepare_data, 224 .reply_size = eeprom_reply_size, 225 .fill_reply = eeprom_fill_reply, 226 .cleanup_data = eeprom_cleanup_data, 227}; 228 229const struct nla_policy ethnl_module_eeprom_get_policy[] = { 230 [ETHTOOL_A_MODULE_EEPROM_HEADER] = NLA_POLICY_NESTED(ethnl_header_policy), 231 [ETHTOOL_A_MODULE_EEPROM_OFFSET] = 232 NLA_POLICY_MAX(NLA_U32, ETH_MODULE_EEPROM_PAGE_LEN * 2 - 1), 233 [ETHTOOL_A_MODULE_EEPROM_LENGTH] = 234 NLA_POLICY_RANGE(NLA_U32, 1, ETH_MODULE_EEPROM_PAGE_LEN), 235 [ETHTOOL_A_MODULE_EEPROM_PAGE] = { .type = NLA_U8 }, 236 [ETHTOOL_A_MODULE_EEPROM_BANK] = { .type = NLA_U8 }, 237 [ETHTOOL_A_MODULE_EEPROM_I2C_ADDRESS] = 238 NLA_POLICY_RANGE(NLA_U8, 0, ETH_MODULE_MAX_I2C_ADDRESS), 239}; 240 241