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