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