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 | |
8 | struct 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 | |
17 | struct 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 | |
29 | static 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 | |
53 | static 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: &modinfo); |
64 | if (err < 0) |
65 | return err; |
66 | |
67 | err = fallback_set_params(request, modinfo: &modinfo, eeprom: &eeprom); |
68 | if (err < 0) |
69 | return err; |
70 | |
71 | data = kmalloc(size: eeprom.len, GFP_KERNEL); |
72 | if (!data) |
73 | return -ENOMEM; |
74 | err = ethtool_get_module_eeprom_call(dev, ee: &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 | |
83 | err_out: |
84 | kfree(objp: data); |
85 | return err; |
86 | } |
87 | |
88 | static 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(bus: dev->sfp_bus, page: 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 | |
103 | static 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(size: 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: &page_data, extack: 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 | |
136 | err_ops: |
137 | ethnl_ops_complete(dev); |
138 | err_free: |
139 | kfree(objp: page_data.data); |
140 | |
141 | if (ret == -EOPNOTSUPP) |
142 | return eeprom_fallback(request, reply); |
143 | return ret; |
144 | } |
145 | |
146 | static 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(nla: tb[ETHTOOL_A_MODULE_EEPROM_I2C_ADDRESS]); |
158 | request->offset = nla_get_u32(nla: tb[ETHTOOL_A_MODULE_EEPROM_OFFSET]); |
159 | request->length = nla_get_u32(nla: 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(nla: 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(nla: tb[ETHTOOL_A_MODULE_EEPROM_BANK]); |
187 | |
188 | return 0; |
189 | } |
190 | |
191 | static 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(payload: sizeof(u8) * request->length); /* _EEPROM_DATA */ |
197 | } |
198 | |
199 | static 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, attrtype: ETHTOOL_A_MODULE_EEPROM_DATA, attrlen: reply->length, data: reply->data); |
206 | } |
207 | |
208 | static 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(objp: reply->data); |
213 | } |
214 | |
215 | const 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 | |
229 | const 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 | |