projects/linux·blob master · refs

674 lines · 16.9 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2
3#include <linux/ethtool.h>
4#include <linux/jiffies.h>
5#include <net/netdev_lock.h>
6
7#include "common.h"
8#include "module_fw.h"
9#include "cmis.h"
10
11/* For accessing the LPL field on page 9Fh, the allowable length extension is
12 * min(i, 15) byte octets where i specifies the allowable additional number of
13 * byte octets in a READ or a WRITE.
14 */
15u32 ethtool_cmis_get_max_lpl_size(u8 num_of_byte_octs)
16{
17 return 8 * (1 + min_t(u8, num_of_byte_octs, 15));
18}
19
20void ethtool_cmis_cdb_compose_args(struct ethtool_cmis_cdb_cmd_args *args,
21 enum ethtool_cmis_cdb_cmd_id cmd, u8 *lpl,
22 u8 lpl_len, u8 *epl, u16 epl_len,
23 u16 max_duration, u8 read_write_len_ext,
24 u16 msleep_pre_rpl, u8 rpl_exp_len, u8 flags)
25{
26 args->req.id = cpu_to_be16(cmd);
27 args->req.lpl_len = lpl_len;
28 if (lpl)
29 memcpy(args->req.payload, lpl, args->req.lpl_len);
30 if (epl) {
31 args->req.epl_len = cpu_to_be16(epl_len);
32 args->req.epl = epl;
33 }
34
35 args->max_duration = max_duration;
36 args->read_write_len_ext =
37 ethtool_cmis_get_max_lpl_size(read_write_len_ext);
38 args->msleep_pre_rpl = msleep_pre_rpl;
39 args->rpl_exp_len = rpl_exp_len;
40 args->flags = flags;
41 args->err_msg = NULL;
42}
43
44void ethtool_cmis_page_init(struct ethtool_module_eeprom *page_data,
45 u8 page, u32 offset, u32 length)
46{
47 page_data->page = page;
48 page_data->offset = offset;
49 page_data->length = length;
50 page_data->i2c_address = ETHTOOL_CMIS_CDB_PAGE_I2C_ADDR;
51}
52
53#define CMIS_REVISION_PAGE 0x00
54#define CMIS_REVISION_OFFSET 0x01
55
56struct cmis_rev_rpl {
57 u8 rev;
58};
59
60static u8 cmis_rev_rpl_major(struct cmis_rev_rpl *rpl)
61{
62 return rpl->rev >> 4;
63}
64
65static int cmis_rev_major_get(struct net_device *dev, u8 *rev_major)
66{
67 const struct ethtool_ops *ops = dev->ethtool_ops;
68 struct ethtool_module_eeprom page_data = {0};
69 struct netlink_ext_ack extack = {};
70 struct cmis_rev_rpl rpl = {};
71 int err;
72
73 ethtool_cmis_page_init(&page_data, CMIS_REVISION_PAGE,
74 CMIS_REVISION_OFFSET, sizeof(rpl));
75 page_data.data = (u8 *)&rpl;
76
77 err = ops->get_module_eeprom_by_page(dev, &page_data, &extack);
78 if (err < 0) {
79 if (extack._msg)
80 netdev_err(dev, "%s\n", extack._msg);
81 return err;
82 }
83
84 *rev_major = cmis_rev_rpl_major(&rpl);
85
86 return 0;
87}
88
89#define CMIS_CDB_ADVERTISEMENT_PAGE 0x01
90#define CMIS_CDB_ADVERTISEMENT_OFFSET 0xA3
91
92/* Based on section 8.4.11 "CDB Messaging Support Advertisement" in CMIS
93 * standard revision 5.2.
94 */
95struct cmis_cdb_advert_rpl {
96 u8 inst_supported;
97 u8 read_write_len_ext;
98 u8 resv1;
99 u8 resv2;
100};
101
102static u8 cmis_cdb_advert_rpl_inst_supported(struct cmis_cdb_advert_rpl *rpl)
103{
104 return rpl->inst_supported >> 6;
105}
106
107static int cmis_cdb_advertisement_get(struct ethtool_cmis_cdb *cdb,
108 struct net_device *dev,
109 struct ethnl_module_fw_flash_ntf_params *ntf_params)
110{
111 const struct ethtool_ops *ops = dev->ethtool_ops;
112 struct ethtool_module_eeprom page_data = {};
113 struct cmis_cdb_advert_rpl rpl = {};
114 struct netlink_ext_ack extack = {};
115 int err;
116
117 ethtool_cmis_page_init(&page_data, CMIS_CDB_ADVERTISEMENT_PAGE,
118 CMIS_CDB_ADVERTISEMENT_OFFSET, sizeof(rpl));
119 page_data.data = (u8 *)&rpl;
120
121 err = ops->get_module_eeprom_by_page(dev, &page_data, &extack);
122 if (err < 0) {
123 if (extack._msg)
124 netdev_err(dev, "%s\n", extack._msg);
125 return err;
126 }
127
128 if (!cmis_cdb_advert_rpl_inst_supported(&rpl)) {
129 ethnl_module_fw_flash_ntf_err(dev, ntf_params,
130 "CDB functionality is not supported",
131 NULL);
132 return -EOPNOTSUPP;
133 }
134
135 cdb->read_write_len_ext = rpl.read_write_len_ext;
136
137 return 0;
138}
139
140#define CMIS_PASSWORD_ENTRY_PAGE 0x00
141#define CMIS_PASSWORD_ENTRY_OFFSET 0x7A
142
143struct cmis_password_entry_pl {
144 __be32 password;
145};
146
147/* See section 9.3.1 "CMD 0000h: Query Status" in CMIS standard revision 5.2.
148 * struct cmis_cdb_query_status_pl and struct cmis_cdb_query_status_rpl are
149 * structured layouts of the flat arrays,
150 * struct ethtool_cmis_cdb_request::payload and
151 * struct ethtool_cmis_cdb_rpl::payload respectively.
152 */
153struct cmis_cdb_query_status_pl {
154 u16 response_delay;
155};
156
157struct cmis_cdb_query_status_rpl {
158 u8 length;
159 u8 status;
160};
161
162static int
163cmis_cdb_validate_password(struct ethtool_cmis_cdb *cdb,
164 struct net_device *dev,
165 const struct ethtool_module_fw_flash_params *params,
166 struct ethnl_module_fw_flash_ntf_params *ntf_params)
167{
168 const struct ethtool_ops *ops = dev->ethtool_ops;
169 struct cmis_cdb_query_status_pl qs_pl = {0};
170 struct ethtool_module_eeprom page_data = {};
171 struct ethtool_cmis_cdb_cmd_args args = {};
172 struct cmis_password_entry_pl pe_pl = {};
173 struct cmis_cdb_query_status_rpl *rpl;
174 struct netlink_ext_ack extack = {};
175 int err;
176
177 ethtool_cmis_page_init(&page_data, CMIS_PASSWORD_ENTRY_PAGE,
178 CMIS_PASSWORD_ENTRY_OFFSET, sizeof(pe_pl));
179 page_data.data = (u8 *)&pe_pl;
180
181 pe_pl = *((struct cmis_password_entry_pl *)page_data.data);
182 pe_pl.password = params->password;
183 netdev_assert_locked_ops(dev);
184 err = ops->set_module_eeprom_by_page(dev, &page_data, &extack);
185 if (err < 0) {
186 if (extack._msg)
187 netdev_err(dev, "%s\n", extack._msg);
188 return err;
189 }
190
191 ethtool_cmis_cdb_compose_args(&args, ETHTOOL_CMIS_CDB_CMD_QUERY_STATUS,
192 (u8 *)&qs_pl, sizeof(qs_pl), NULL, 0, 0,
193 cdb->read_write_len_ext, 1000,
194 sizeof(*rpl),
195 CDB_F_COMPLETION_VALID | CDB_F_STATUS_VALID);
196
197 err = ethtool_cmis_cdb_execute_cmd(dev, &args);
198 if (err < 0) {
199 ethnl_module_fw_flash_ntf_err(dev, ntf_params,
200 "Query Status command failed",
201 args.err_msg);
202 return err;
203 }
204
205 rpl = (struct cmis_cdb_query_status_rpl *)args.req.payload;
206 if (!rpl->length || !rpl->status) {
207 ethnl_module_fw_flash_ntf_err(dev, ntf_params,
208 "Password was not accepted",
209 NULL);
210 return -EINVAL;
211 }
212
213 return 0;
214}
215
216/* Some CDB commands asserts the CDB completion flag only from CMIS
217 * revision 5. Therefore, check the relevant validity flag only when
218 * the revision supports it.
219 */
220void ethtool_cmis_cdb_check_completion_flag(u8 cmis_rev, u8 *flags)
221{
222 *flags |= cmis_rev >= 5 ? CDB_F_COMPLETION_VALID : 0;
223}
224
225#define CMIS_CDB_MODULE_FEATURES_RESV_DATA 34
226
227/* See section 9.4.1 "CMD 0040h: Module Features" in CMIS standard revision 5.2.
228 * struct cmis_cdb_module_features_rpl is structured layout of the flat
229 * array, ethtool_cmis_cdb_rpl::payload.
230 */
231struct cmis_cdb_module_features_rpl {
232 u8 resv1[CMIS_CDB_MODULE_FEATURES_RESV_DATA];
233 __be16 max_completion_time;
234};
235
236static u16
237cmis_cdb_module_features_completion_time(struct cmis_cdb_module_features_rpl *rpl)
238{
239 return be16_to_cpu(rpl->max_completion_time);
240}
241
242static int cmis_cdb_module_features_get(struct ethtool_cmis_cdb *cdb,
243 struct net_device *dev,
244 struct ethnl_module_fw_flash_ntf_params *ntf_params)
245{
246 struct ethtool_cmis_cdb_cmd_args args = {};
247 struct cmis_cdb_module_features_rpl *rpl;
248 u8 flags = CDB_F_STATUS_VALID;
249 int err;
250
251 ethtool_cmis_cdb_check_completion_flag(cdb->cmis_rev, &flags);
252 ethtool_cmis_cdb_compose_args(&args,
253 ETHTOOL_CMIS_CDB_CMD_MODULE_FEATURES,
254 NULL, 0, NULL, 0, 0,
255 cdb->read_write_len_ext, 1000,
256 sizeof(*rpl), flags);
257
258 err = ethtool_cmis_cdb_execute_cmd(dev, &args);
259 if (err < 0) {
260 ethnl_module_fw_flash_ntf_err(dev, ntf_params,
261 "Module Features command failed",
262 args.err_msg);
263 return err;
264 }
265
266 rpl = (struct cmis_cdb_module_features_rpl *)args.req.payload;
267 cdb->max_completion_time =
268 cmis_cdb_module_features_completion_time(rpl);
269
270 return 0;
271}
272
273struct ethtool_cmis_cdb *
274ethtool_cmis_cdb_init(struct net_device *dev,
275 const struct ethtool_module_fw_flash_params *params,
276 struct ethnl_module_fw_flash_ntf_params *ntf_params)
277{
278 struct ethtool_cmis_cdb *cdb;
279 int err;
280
281 cdb = kzalloc_obj(*cdb);
282 if (!cdb)
283 return ERR_PTR(-ENOMEM);
284
285 err = cmis_rev_major_get(dev, &cdb->cmis_rev);
286 if (err < 0)
287 goto err;
288
289 if (cdb->cmis_rev < 4) {
290 ethnl_module_fw_flash_ntf_err(dev, ntf_params,
291 "CMIS revision doesn't support module firmware flashing",
292 NULL);
293 err = -EOPNOTSUPP;
294 goto err;
295 }
296
297 err = cmis_cdb_advertisement_get(cdb, dev, ntf_params);
298 if (err < 0)
299 goto err;
300
301 if (params->password_valid) {
302 err = cmis_cdb_validate_password(cdb, dev, params, ntf_params);
303 if (err < 0)
304 goto err;
305 }
306
307 err = cmis_cdb_module_features_get(cdb, dev, ntf_params);
308 if (err < 0)
309 goto err;
310
311 return cdb;
312
313err:
314 ethtool_cmis_cdb_fini(cdb);
315 return ERR_PTR(err);
316}
317
318void ethtool_cmis_cdb_fini(struct ethtool_cmis_cdb *cdb)
319{
320 kfree(cdb);
321}
322
323static bool is_completed(u8 data)
324{
325 return !!(data & 0x40);
326}
327
328#define CMIS_CDB_STATUS_SUCCESS 0x01
329
330static bool status_success(u8 data)
331{
332 return data == CMIS_CDB_STATUS_SUCCESS;
333}
334
335#define CMIS_CDB_STATUS_FAIL 0x40
336
337static bool status_fail(u8 data)
338{
339 return data & CMIS_CDB_STATUS_FAIL;
340}
341
342struct cmis_wait_for_cond_rpl {
343 u8 state;
344};
345
346static int
347ethtool_cmis_module_poll(struct net_device *dev,
348 struct cmis_wait_for_cond_rpl *rpl, u32 offset,
349 bool (*cond_success)(u8), bool (*cond_fail)(u8))
350{
351 const struct ethtool_ops *ops = dev->ethtool_ops;
352 struct ethtool_module_eeprom page_data = {0};
353 struct netlink_ext_ack extack = {};
354 int err;
355
356 ethtool_cmis_page_init(&page_data, 0, offset, sizeof(*rpl));
357 page_data.data = (u8 *)rpl;
358
359 err = ops->get_module_eeprom_by_page(dev, &page_data, &extack);
360 if (err < 0) {
361 if (extack._msg)
362 netdev_err_once(dev, "%s\n", extack._msg);
363 return -EBUSY;
364 }
365
366 if ((*cond_success)(rpl->state))
367 return 0;
368
369 if (*cond_fail && (*cond_fail)(rpl->state))
370 return -EIO;
371
372 return -EBUSY;
373}
374
375int ethtool_cmis_wait_for_cond(struct net_device *dev, u8 flags, u8 flag,
376 u16 max_duration, u32 offset,
377 bool (*cond_success)(u8), bool (*cond_fail)(u8),
378 u8 *state)
379{
380 struct cmis_wait_for_cond_rpl rpl = {};
381 unsigned long end;
382 int err;
383
384 if (!(flags & flag))
385 return 0;
386
387 if (max_duration == 0)
388 max_duration = U16_MAX;
389
390 end = jiffies + msecs_to_jiffies(max_duration);
391 do {
392 err = ethtool_cmis_module_poll(dev, &rpl, offset, cond_success,
393 cond_fail);
394 if (err != -EBUSY)
395 goto out;
396
397 msleep(20);
398 } while (time_before(jiffies, end));
399
400 err = ethtool_cmis_module_poll(dev, &rpl, offset, cond_success,
401 cond_fail);
402 if (err == -EBUSY)
403 err = -ETIMEDOUT;
404
405out:
406 *state = rpl.state;
407 return err;
408}
409
410#define CMIS_CDB_COMPLETION_FLAG_OFFSET 0x08
411
412static int cmis_cdb_wait_for_completion(struct net_device *dev,
413 struct ethtool_cmis_cdb_cmd_args *args)
414{
415 u8 flag;
416 int err;
417
418 /* Some vendors demand waiting time before checking completion flag
419 * in some CDB commands.
420 */
421 msleep(args->msleep_pre_rpl);
422
423 err = ethtool_cmis_wait_for_cond(dev, args->flags,
424 CDB_F_COMPLETION_VALID,
425 args->max_duration,
426 CMIS_CDB_COMPLETION_FLAG_OFFSET,
427 is_completed, NULL, &flag);
428 if (err < 0)
429 args->err_msg = "Completion Flag did not set on time";
430
431 return err;
432}
433
434#define CMIS_CDB_STATUS_OFFSET 0x25
435
436static void cmis_cdb_status_fail_msg_get(u8 status, char **err_msg)
437{
438 switch (status) {
439 case 0b10000001:
440 *err_msg = "CDB Status is in progress: Busy capturing command";
441 break;
442 case 0b10000010:
443 *err_msg =
444 "CDB Status is in progress: Busy checking/validating command";
445 break;
446 case 0b10000011:
447 *err_msg = "CDB Status is in progress: Busy executing";
448 break;
449 case 0b01000000:
450 *err_msg = "CDB status failed: no specific failure";
451 break;
452 case 0b01000010:
453 *err_msg =
454 "CDB status failed: Parameter range error or parameter not supported";
455 break;
456 case 0b01000101:
457 *err_msg = "CDB status failed: CdbChkCode error";
458 break;
459 case 0b01000110:
460 *err_msg = "CDB status failed: Password error";
461 break;
462 default:
463 *err_msg = "Unknown failure reason";
464 }
465};
466
467static int cmis_cdb_wait_for_status(struct net_device *dev,
468 struct ethtool_cmis_cdb_cmd_args *args)
469{
470 u8 status;
471 int err;
472
473 /* Some vendors demand waiting time before checking status in some
474 * CDB commands.
475 */
476 msleep(args->msleep_pre_rpl);
477
478 err = ethtool_cmis_wait_for_cond(dev, args->flags, CDB_F_STATUS_VALID,
479 args->max_duration,
480 CMIS_CDB_STATUS_OFFSET,
481 status_success, status_fail, &status);
482 if (err < 0 && !args->err_msg)
483 cmis_cdb_status_fail_msg_get(status, &args->err_msg);
484
485 return err;
486}
487
488#define CMIS_CDB_REPLY_OFFSET 0x86
489
490static int cmis_cdb_process_reply(struct net_device *dev,
491 struct ethtool_module_eeprom *page_data,
492 struct ethtool_cmis_cdb_cmd_args *args)
493{
494 u8 rpl_hdr_len = sizeof(struct ethtool_cmis_cdb_rpl_hdr);
495 u8 rpl_exp_len = args->rpl_exp_len + rpl_hdr_len;
496 const struct ethtool_ops *ops = dev->ethtool_ops;
497 struct netlink_ext_ack extack = {};
498 struct ethtool_cmis_cdb_rpl *rpl;
499 int err;
500
501 if (!args->rpl_exp_len)
502 return 0;
503
504 ethtool_cmis_page_init(page_data, ETHTOOL_CMIS_CDB_CMD_PAGE,
505 CMIS_CDB_REPLY_OFFSET, rpl_exp_len);
506 page_data->data = kmalloc(page_data->length, GFP_KERNEL);
507 if (!page_data->data)
508 return -ENOMEM;
509
510 err = ops->get_module_eeprom_by_page(dev, page_data, &extack);
511 if (err < 0) {
512 if (extack._msg)
513 netdev_err(dev, "%s\n", extack._msg);
514 goto out;
515 }
516
517 rpl = (struct ethtool_cmis_cdb_rpl *)page_data->data;
518 if (rpl->hdr.rpl_len != args->rpl_exp_len) {
519 netdev_warn(dev, "CDB reply length mismatch, expected %u got %u\n",
520 args->rpl_exp_len, rpl->hdr.rpl_len);
521 err = -EIO;
522 goto out;
523 }
524 if (!rpl->hdr.rpl_chk_code) {
525 err = -EIO;
526 goto out;
527 }
528
529 args->req.lpl_len = rpl->hdr.rpl_len;
530 memcpy(args->req.payload, rpl->payload, args->req.lpl_len);
531
532out:
533 kfree(page_data->data);
534 return err;
535}
536
537static int
538__ethtool_cmis_cdb_execute_cmd(struct net_device *dev,
539 struct ethtool_module_eeprom *page_data,
540 u8 page, u32 offset, u32 length, void *data)
541{
542 const struct ethtool_ops *ops = dev->ethtool_ops;
543 struct netlink_ext_ack extack = {};
544 int err;
545
546 ethtool_cmis_page_init(page_data, page, offset, length);
547 page_data->data = kmemdup(data, page_data->length, GFP_KERNEL);
548 if (!page_data->data)
549 return -ENOMEM;
550
551 netdev_assert_locked_ops(dev);
552 err = ops->set_module_eeprom_by_page(dev, page_data, &extack);
553 if (err < 0) {
554 if (extack._msg)
555 netdev_err(dev, "%s\n", extack._msg);
556 }
557
558 kfree(page_data->data);
559 return err;
560}
561
562#define CMIS_CDB_EPL_PAGE_START 0xA0
563#define CMIS_CDB_EPL_PAGE_END 0xAF
564#define CMIS_CDB_EPL_FW_BLOCK_OFFSET_START 128
565#define CMIS_CDB_EPL_FW_BLOCK_OFFSET_END 255
566
567static int
568ethtool_cmis_cdb_execute_epl_cmd(struct net_device *dev,
569 struct ethtool_cmis_cdb_cmd_args *args,
570 struct ethtool_module_eeprom *page_data)
571{
572 u16 epl_len = be16_to_cpu(args->req.epl_len);
573 u32 bytes_written = 0;
574 u8 page;
575 int err;
576
577 for (page = CMIS_CDB_EPL_PAGE_START;
578 page <= CMIS_CDB_EPL_PAGE_END && bytes_written < epl_len; page++) {
579 u16 offset = CMIS_CDB_EPL_FW_BLOCK_OFFSET_START;
580
581 while (offset <= CMIS_CDB_EPL_FW_BLOCK_OFFSET_END &&
582 bytes_written < epl_len) {
583 u32 bytes_left = epl_len - bytes_written;
584 u16 space_left, bytes_to_write;
585
586 space_left = CMIS_CDB_EPL_FW_BLOCK_OFFSET_END - offset + 1;
587 bytes_to_write = min_t(u16, bytes_left,
588 min_t(u16, space_left,
589 args->read_write_len_ext));
590
591 err = __ethtool_cmis_cdb_execute_cmd(dev, page_data,
592 page, offset,
593 bytes_to_write,
594 args->req.epl + bytes_written);
595 if (err < 0)
596 return err;
597
598 offset += bytes_to_write;
599 bytes_written += bytes_to_write;
600 }
601 }
602 return 0;
603}
604
605static u8 cmis_cdb_calc_checksum(const void *data, size_t size)
606{
607 const u8 *bytes = (const u8 *)data;
608 u8 checksum = 0;
609
610 for (size_t i = 0; i < size; i++)
611 checksum += bytes[i];
612
613 return ~checksum;
614}
615
616#define CMIS_CDB_CMD_ID_OFFSET 0x80
617
618int ethtool_cmis_cdb_execute_cmd(struct net_device *dev,
619 struct ethtool_cmis_cdb_cmd_args *args)
620{
621 struct ethtool_module_eeprom page_data = {};
622 u32 offset;
623 int err;
624
625 args->req.chk_code =
626 cmis_cdb_calc_checksum(&args->req,
627 offsetof(struct ethtool_cmis_cdb_request,
628 epl));
629
630 if (args->req.lpl_len > args->read_write_len_ext) {
631 args->err_msg = "LPL length is longer than CDB read write length extension allows";
632 return -EINVAL;
633 }
634
635 /* According to the CMIS standard, there are two options to trigger the
636 * CDB commands. The default option is triggering the command by writing
637 * the CMDID bytes. Therefore, the command will be split to 2 calls:
638 * First, with everything except the CMDID field and then the CMDID
639 * field.
640 */
641 offset = CMIS_CDB_CMD_ID_OFFSET +
642 offsetof(struct ethtool_cmis_cdb_request, body);
643 err = __ethtool_cmis_cdb_execute_cmd(dev, &page_data,
644 ETHTOOL_CMIS_CDB_CMD_PAGE, offset,
645 sizeof(args->req.body),
646 &args->req.body);
647 if (err < 0)
648 return err;
649
650 if (args->req.epl_len) {
651 err = ethtool_cmis_cdb_execute_epl_cmd(dev, args, &page_data);
652 if (err < 0)
653 return err;
654 }
655
656 offset = CMIS_CDB_CMD_ID_OFFSET +
657 offsetof(struct ethtool_cmis_cdb_request, id);
658 err = __ethtool_cmis_cdb_execute_cmd(dev, &page_data,
659 ETHTOOL_CMIS_CDB_CMD_PAGE, offset,
660 sizeof(args->req.id),
661 &args->req.id);
662 if (err < 0)
663 return err;
664
665 err = cmis_cdb_wait_for_completion(dev, args);
666 if (err < 0)
667 return err;
668
669 err = cmis_cdb_wait_for_status(dev, args);
670 if (err < 0)
671 return err;
672
673 return cmis_cdb_process_reply(dev, &page_data, args);
674}