1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#define LOG_CATEGORY UCLASS_CROS_EC
17
18#include <common.h>
19#include <command.h>
20#include <dm.h>
21#include <flash.h>
22#include <i2c.h>
23#include <cros_ec.h>
24#include <fdtdec.h>
25#include <log.h>
26#include <malloc.h>
27#include <spi.h>
28#include <linux/delay.h>
29#include <linux/errno.h>
30#include <asm/io.h>
31#include <asm-generic/gpio.h>
32#include <dm/device-internal.h>
33#include <dm/of_extra.h>
34#include <dm/uclass-internal.h>
35
36#ifdef DEBUG_TRACE
37#define debug_trace(fmt, b...) debug(fmt, #b)
38#else
39#define debug_trace(fmt, b...)
40#endif
41
42enum {
43
44 CROS_EC_CMD_TIMEOUT_MS = 5000,
45
46 CROS_EC_CMD_HASH_TIMEOUT_MS = 2000,
47
48
49 CROS_EC_HASH_CHECK_DELAY_MS = 10,
50
51};
52
53#define INVALID_HCMD 0xFF
54
55
56
57
58
59static const struct {
60 u8 set_cmd;
61 u8 clear_cmd;
62 u8 get_cmd;
63} event_map[] = {
64 [EC_HOST_EVENT_MAIN] = {
65 INVALID_HCMD, EC_CMD_HOST_EVENT_CLEAR,
66 INVALID_HCMD,
67 },
68 [EC_HOST_EVENT_B] = {
69 INVALID_HCMD, EC_CMD_HOST_EVENT_CLEAR_B,
70 EC_CMD_HOST_EVENT_GET_B,
71 },
72 [EC_HOST_EVENT_SCI_MASK] = {
73 EC_CMD_HOST_EVENT_SET_SCI_MASK, INVALID_HCMD,
74 EC_CMD_HOST_EVENT_GET_SCI_MASK,
75 },
76 [EC_HOST_EVENT_SMI_MASK] = {
77 EC_CMD_HOST_EVENT_SET_SMI_MASK, INVALID_HCMD,
78 EC_CMD_HOST_EVENT_GET_SMI_MASK,
79 },
80 [EC_HOST_EVENT_ALWAYS_REPORT_MASK] = {
81 INVALID_HCMD, INVALID_HCMD, INVALID_HCMD,
82 },
83 [EC_HOST_EVENT_ACTIVE_WAKE_MASK] = {
84 EC_CMD_HOST_EVENT_SET_WAKE_MASK, INVALID_HCMD,
85 EC_CMD_HOST_EVENT_GET_WAKE_MASK,
86 },
87 [EC_HOST_EVENT_LAZY_WAKE_MASK_S0IX] = {
88 EC_CMD_HOST_EVENT_SET_WAKE_MASK, INVALID_HCMD,
89 EC_CMD_HOST_EVENT_GET_WAKE_MASK,
90 },
91 [EC_HOST_EVENT_LAZY_WAKE_MASK_S3] = {
92 EC_CMD_HOST_EVENT_SET_WAKE_MASK, INVALID_HCMD,
93 EC_CMD_HOST_EVENT_GET_WAKE_MASK,
94 },
95 [EC_HOST_EVENT_LAZY_WAKE_MASK_S5] = {
96 EC_CMD_HOST_EVENT_SET_WAKE_MASK, INVALID_HCMD,
97 EC_CMD_HOST_EVENT_GET_WAKE_MASK,
98 },
99};
100
101void cros_ec_dump_data(const char *name, int cmd, const uint8_t *data, int len)
102{
103#ifdef DEBUG
104 int i;
105
106 printf("%s: ", name);
107 if (cmd != -1)
108 printf("cmd=%#x: ", cmd);
109 for (i = 0; i < len; i++)
110 printf("%02x ", data[i]);
111 printf("\n");
112#endif
113}
114
115
116
117
118
119
120
121
122int cros_ec_calc_checksum(const uint8_t *data, int size)
123{
124 int csum, i;
125
126 for (i = csum = 0; i < size; i++)
127 csum += data[i];
128 return csum & 0xff;
129}
130
131
132
133
134
135
136
137
138
139
140
141
142
143static int create_proto3_request(struct cros_ec_dev *cdev,
144 int cmd, int cmd_version,
145 const void *dout, int dout_len)
146{
147 struct ec_host_request *rq = (struct ec_host_request *)cdev->dout;
148 int out_bytes = dout_len + sizeof(*rq);
149
150
151 if (out_bytes > (int)sizeof(cdev->dout)) {
152 debug("%s: Cannot send %d bytes\n", __func__, dout_len);
153 return -EC_RES_REQUEST_TRUNCATED;
154 }
155
156
157 rq->struct_version = EC_HOST_REQUEST_VERSION;
158 rq->checksum = 0;
159 rq->command = cmd;
160 rq->command_version = cmd_version;
161 rq->reserved = 0;
162 rq->data_len = dout_len;
163
164
165 memcpy(rq + 1, dout, dout_len);
166
167
168 rq->checksum = (uint8_t)(-cros_ec_calc_checksum(cdev->dout, out_bytes));
169
170 cros_ec_dump_data("out", cmd, cdev->dout, out_bytes);
171
172
173 return out_bytes;
174}
175
176
177
178
179
180
181
182
183static int prepare_proto3_response_buffer(struct cros_ec_dev *cdev, int din_len)
184{
185 int in_bytes = din_len + sizeof(struct ec_host_response);
186
187
188 if (in_bytes > (int)sizeof(cdev->din)) {
189 debug("%s: Cannot receive %d bytes\n", __func__, din_len);
190 return -EC_RES_RESPONSE_TOO_BIG;
191 }
192
193
194 return in_bytes;
195}
196
197
198
199
200
201
202
203
204
205
206
207
208
209static int handle_proto3_response(struct cros_ec_dev *dev,
210 uint8_t **dinp, int din_len)
211{
212 struct ec_host_response *rs = (struct ec_host_response *)dev->din;
213 int in_bytes;
214 int csum;
215
216 cros_ec_dump_data("in-header", -1, dev->din, sizeof(*rs));
217
218
219 if (rs->struct_version != EC_HOST_RESPONSE_VERSION) {
220 debug("%s: EC response version mismatch\n", __func__);
221 return -EC_RES_INVALID_RESPONSE;
222 }
223
224 if (rs->reserved) {
225 debug("%s: EC response reserved != 0\n", __func__);
226 return -EC_RES_INVALID_RESPONSE;
227 }
228
229 if (rs->data_len > din_len) {
230 debug("%s: EC returned too much data\n", __func__);
231 return -EC_RES_RESPONSE_TOO_BIG;
232 }
233
234 cros_ec_dump_data("in-data", -1, dev->din + sizeof(*rs), rs->data_len);
235
236
237 in_bytes = sizeof(*rs) + rs->data_len;
238
239
240 csum = cros_ec_calc_checksum(dev->din, in_bytes);
241 if (csum) {
242 debug("%s: EC response checksum invalid: 0x%02x\n", __func__,
243 csum);
244 return -EC_RES_INVALID_CHECKSUM;
245 }
246
247
248 if (rs->result)
249 return -(int)rs->result;
250
251
252 *dinp = (uint8_t *)(rs + 1);
253
254 return rs->data_len;
255}
256
257static int send_command_proto3(struct cros_ec_dev *cdev,
258 int cmd, int cmd_version,
259 const void *dout, int dout_len,
260 uint8_t **dinp, int din_len)
261{
262 struct dm_cros_ec_ops *ops;
263 int out_bytes, in_bytes;
264 int rv;
265
266
267 out_bytes = create_proto3_request(cdev, cmd, cmd_version,
268 dout, dout_len);
269 if (out_bytes < 0)
270 return out_bytes;
271
272
273 in_bytes = prepare_proto3_response_buffer(cdev, din_len);
274 if (in_bytes < 0)
275 return in_bytes;
276
277 ops = dm_cros_ec_get_ops(cdev->dev);
278 rv = ops->packet ? ops->packet(cdev->dev, out_bytes, in_bytes) :
279 -ENOSYS;
280 if (rv < 0)
281 return rv;
282
283
284 return handle_proto3_response(cdev, dinp, din_len);
285}
286
287static int send_command(struct cros_ec_dev *dev, uint cmd, int cmd_version,
288 const void *dout, int dout_len,
289 uint8_t **dinp, int din_len)
290{
291 struct dm_cros_ec_ops *ops;
292 int ret = -1;
293
294
295 if (dev->protocol_version == 3) {
296 return send_command_proto3(dev, cmd, cmd_version,
297 dout, dout_len, dinp, din_len);
298 }
299
300 ops = dm_cros_ec_get_ops(dev->dev);
301 ret = ops->command(dev->dev, cmd, cmd_version,
302 (const uint8_t *)dout, dout_len, dinp, din_len);
303
304 return ret;
305}
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323static int ec_command_inptr(struct udevice *dev, uint cmd,
324 int cmd_version, const void *dout, int dout_len,
325 uint8_t **dinp, int din_len)
326{
327 struct cros_ec_dev *cdev = dev_get_uclass_priv(dev);
328 uint8_t *din = NULL;
329 int len;
330
331 len = send_command(cdev, cmd, cmd_version, dout, dout_len, &din,
332 din_len);
333
334
335 if (len == -EC_RES_IN_PROGRESS) {
336 struct ec_response_get_comms_status *resp = NULL;
337 ulong start;
338
339
340 start = get_timer(0);
341 do {
342 int ret;
343
344 mdelay(50);
345 ret = send_command(cdev, EC_CMD_GET_COMMS_STATUS, 0,
346 NULL, 0,
347 (uint8_t **)&resp, sizeof(*resp));
348 if (ret < 0)
349 return ret;
350
351 if (get_timer(start) > CROS_EC_CMD_TIMEOUT_MS) {
352 debug("%s: Command %#02x timeout\n",
353 __func__, cmd);
354 return -EC_RES_TIMEOUT;
355 }
356 } while (resp->flags & EC_COMMS_STATUS_PROCESSING);
357
358
359
360 len = send_command(cdev, EC_CMD_RESEND_RESPONSE, 0, NULL, 0,
361 &din, din_len);
362 }
363
364 debug("%s: len=%d, din=%p\n", __func__, len, din);
365 if (dinp) {
366
367 assert(len <= 0 || !((uintptr_t)din & 7));
368 *dinp = din;
369 }
370
371 return len;
372}
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390static int ec_command(struct udevice *dev, uint cmd, int cmd_version,
391 const void *dout, int dout_len,
392 void *din, int din_len)
393{
394 uint8_t *in_buffer;
395 int len;
396
397 assert((din_len == 0) || din);
398 len = ec_command_inptr(dev, cmd, cmd_version, dout, dout_len,
399 &in_buffer, din_len);
400 if (len > 0) {
401
402
403
404
405 if (din && in_buffer) {
406 assert(len <= din_len);
407 if (len > din_len)
408 return -ENOSPC;
409 memmove(din, in_buffer, len);
410 }
411 }
412 return len;
413}
414
415int cros_ec_scan_keyboard(struct udevice *dev, struct mbkp_keyscan *scan)
416{
417 if (ec_command(dev, EC_CMD_MKBP_STATE, 0, NULL, 0, scan,
418 sizeof(scan->data)) != sizeof(scan->data))
419 return -1;
420
421 return 0;
422}
423
424int cros_ec_get_next_event(struct udevice *dev,
425 struct ec_response_get_next_event *event)
426{
427 int ret;
428
429 ret = ec_command(dev, EC_CMD_GET_NEXT_EVENT, 0, NULL, 0,
430 event, sizeof(*event));
431 if (ret < 0)
432 return ret;
433 else if (ret != sizeof(*event))
434 return -EC_RES_INVALID_RESPONSE;
435
436 return 0;
437}
438
439int cros_ec_read_id(struct udevice *dev, char *id, int maxlen)
440{
441 struct ec_response_get_version *r;
442 int ret;
443
444 ret = ec_command_inptr(dev, EC_CMD_GET_VERSION, 0, NULL, 0,
445 (uint8_t **)&r, sizeof(*r));
446 if (ret != sizeof(*r)) {
447 log_err("Got rc %d, expected %u\n", ret, (uint)sizeof(*r));
448 return -1;
449 }
450
451 if (maxlen > (int)sizeof(r->version_string_ro))
452 maxlen = sizeof(r->version_string_ro);
453
454 switch (r->current_image) {
455 case EC_IMAGE_RO:
456 memcpy(id, r->version_string_ro, maxlen);
457 break;
458 case EC_IMAGE_RW:
459 memcpy(id, r->version_string_rw, maxlen);
460 break;
461 default:
462 log_err("Invalid EC image %d\n", r->current_image);
463 return -1;
464 }
465
466 id[maxlen - 1] = '\0';
467 return 0;
468}
469
470int cros_ec_read_version(struct udevice *dev,
471 struct ec_response_get_version **versionp)
472{
473 if (ec_command_inptr(dev, EC_CMD_GET_VERSION, 0, NULL, 0,
474 (uint8_t **)versionp, sizeof(**versionp))
475 != sizeof(**versionp))
476 return -1;
477
478 return 0;
479}
480
481int cros_ec_read_build_info(struct udevice *dev, char **strp)
482{
483 if (ec_command_inptr(dev, EC_CMD_GET_BUILD_INFO, 0, NULL, 0,
484 (uint8_t **)strp, EC_PROTO2_MAX_PARAM_SIZE) < 0)
485 return -1;
486
487 return 0;
488}
489
490int cros_ec_read_current_image(struct udevice *dev,
491 enum ec_current_image *image)
492{
493 struct ec_response_get_version *r;
494
495 if (ec_command_inptr(dev, EC_CMD_GET_VERSION, 0, NULL, 0,
496 (uint8_t **)&r, sizeof(*r)) != sizeof(*r))
497 return -1;
498
499 *image = r->current_image;
500 return 0;
501}
502
503static int cros_ec_wait_on_hash_done(struct udevice *dev,
504 struct ec_params_vboot_hash *p,
505 struct ec_response_vboot_hash *hash)
506{
507 ulong start;
508
509 start = get_timer(0);
510 while (hash->status == EC_VBOOT_HASH_STATUS_BUSY) {
511 mdelay(CROS_EC_HASH_CHECK_DELAY_MS);
512
513 p->cmd = EC_VBOOT_HASH_GET;
514
515 if (ec_command(dev, EC_CMD_VBOOT_HASH, 0, p, sizeof(*p), hash,
516 sizeof(*hash)) < 0)
517 return -1;
518
519 if (get_timer(start) > CROS_EC_CMD_HASH_TIMEOUT_MS) {
520 debug("%s: EC_VBOOT_HASH_GET timeout\n", __func__);
521 return -EC_RES_TIMEOUT;
522 }
523 }
524 return 0;
525}
526
527int cros_ec_read_hash(struct udevice *dev, uint hash_offset,
528 struct ec_response_vboot_hash *hash)
529{
530 struct ec_params_vboot_hash p;
531 int rv;
532
533 p.cmd = EC_VBOOT_HASH_GET;
534 p.offset = hash_offset;
535 if (ec_command(dev, EC_CMD_VBOOT_HASH, 0, &p, sizeof(p),
536 hash, sizeof(*hash)) < 0)
537 return -1;
538
539
540 rv = cros_ec_wait_on_hash_done(dev, &p, hash);
541 if (rv)
542 return rv;
543
544
545
546
547
548 if (hash->status == EC_VBOOT_HASH_STATUS_DONE && hash->size)
549 return 0;
550
551 debug("%s: No valid hash (status=%d size=%d). Compute one...\n",
552 __func__, hash->status, hash->size);
553
554 p.cmd = EC_VBOOT_HASH_START;
555 p.hash_type = EC_VBOOT_HASH_TYPE_SHA256;
556 p.nonce_size = 0;
557 p.offset = hash_offset;
558
559 if (ec_command(dev, EC_CMD_VBOOT_HASH, 0, &p, sizeof(p),
560 hash, sizeof(*hash)) < 0)
561 return -1;
562
563 rv = cros_ec_wait_on_hash_done(dev, &p, hash);
564 if (rv)
565 return rv;
566 if (hash->status != EC_VBOOT_HASH_STATUS_DONE) {
567 log_err("Hash did not complete, status=%d\n", hash->status);
568 return -EIO;
569 }
570
571 debug("%s: hash done\n", __func__);
572
573 return 0;
574}
575
576static int cros_ec_invalidate_hash(struct udevice *dev)
577{
578 struct ec_params_vboot_hash p;
579 struct ec_response_vboot_hash *hash;
580
581
582
583
584
585 p.cmd = EC_VBOOT_HASH_RECALC;
586 p.hash_type = EC_VBOOT_HASH_TYPE_SHA256;
587 p.nonce_size = 0;
588 p.offset = 0;
589 p.size = 0;
590
591 debug("%s:\n", __func__);
592
593 if (ec_command_inptr(dev, EC_CMD_VBOOT_HASH, 0, &p, sizeof(p),
594 (uint8_t **)&hash, sizeof(*hash)) < 0)
595 return -1;
596
597
598 return 0;
599}
600
601int cros_ec_hello(struct udevice *dev, uint *handshakep)
602{
603 struct ec_params_hello req;
604 struct ec_response_hello *resp;
605
606 req.in_data = 0x12345678;
607 if (ec_command_inptr(dev, EC_CMD_HELLO, 0, &req, sizeof(req),
608 (uint8_t **)&resp, sizeof(*resp)) < 0)
609 return -EIO;
610 if (resp->out_data != req.in_data + 0x01020304) {
611 printf("Received invalid handshake %x\n", resp->out_data);
612 if (handshakep)
613 *handshakep = req.in_data;
614 return -ENOTSYNC;
615 }
616
617 return 0;
618}
619
620int cros_ec_reboot(struct udevice *dev, enum ec_reboot_cmd cmd, uint8_t flags)
621{
622 struct ec_params_reboot_ec p;
623
624 p.cmd = cmd;
625 p.flags = flags;
626
627 if (ec_command_inptr(dev, EC_CMD_REBOOT_EC, 0, &p, sizeof(p), NULL, 0)
628 < 0)
629 return -1;
630
631 if (!(flags & EC_REBOOT_FLAG_ON_AP_SHUTDOWN)) {
632 ulong start;
633
634
635
636
637
638
639
640 mdelay(50);
641 start = get_timer(0);
642 while (cros_ec_hello(dev, NULL)) {
643 if (get_timer(start) > 3000) {
644 log_err("EC did not return from reboot\n");
645 return -ETIMEDOUT;
646 }
647 mdelay(5);
648 }
649 }
650
651 return 0;
652}
653
654int cros_ec_interrupt_pending(struct udevice *dev)
655{
656 struct cros_ec_dev *cdev = dev_get_uclass_priv(dev);
657
658
659 if (!dm_gpio_is_valid(&cdev->ec_int))
660 return -ENOENT;
661
662 return dm_gpio_get_value(&cdev->ec_int);
663}
664
665int cros_ec_info(struct udevice *dev, struct ec_response_mkbp_info *info)
666{
667 if (ec_command(dev, EC_CMD_MKBP_INFO, 0, NULL, 0, info,
668 sizeof(*info)) != sizeof(*info))
669 return -1;
670
671 return 0;
672}
673
674int cros_ec_get_event_mask(struct udevice *dev, uint type, uint32_t *mask)
675{
676 struct ec_response_host_event_mask rsp;
677 int ret;
678
679 ret = ec_command(dev, type, 0, NULL, 0, &rsp, sizeof(rsp));
680 if (ret < 0)
681 return ret;
682 else if (ret != sizeof(rsp))
683 return -EINVAL;
684
685 *mask = rsp.mask;
686
687 return 0;
688}
689
690int cros_ec_set_event_mask(struct udevice *dev, uint type, uint32_t mask)
691{
692 struct ec_params_host_event_mask req;
693 int ret;
694
695 req.mask = mask;
696
697 ret = ec_command(dev, type, 0, &req, sizeof(req), NULL, 0);
698 if (ret < 0)
699 return ret;
700
701 return 0;
702}
703
704int cros_ec_get_host_events(struct udevice *dev, uint32_t *events_ptr)
705{
706 struct ec_response_host_event_mask *resp;
707
708
709
710
711
712 if (ec_command_inptr(dev, EC_CMD_HOST_EVENT_GET_B, 0, NULL, 0,
713 (uint8_t **)&resp, sizeof(*resp)) < (int)sizeof(*resp))
714 return -1;
715
716 if (resp->mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_INVALID))
717 return -1;
718
719 *events_ptr = resp->mask;
720 return 0;
721}
722
723int cros_ec_clear_host_events(struct udevice *dev, uint32_t events)
724{
725 struct ec_params_host_event_mask params;
726
727 params.mask = events;
728
729
730
731
732
733 if (ec_command_inptr(dev, EC_CMD_HOST_EVENT_CLEAR_B, 0,
734 ¶ms, sizeof(params), NULL, 0) < 0)
735 return -1;
736
737 return 0;
738}
739
740int cros_ec_flash_protect(struct udevice *dev, uint32_t set_mask,
741 uint32_t set_flags,
742 struct ec_response_flash_protect *resp)
743{
744 struct ec_params_flash_protect params;
745
746 params.mask = set_mask;
747 params.flags = set_flags;
748
749 if (ec_command(dev, EC_CMD_FLASH_PROTECT, EC_VER_FLASH_PROTECT,
750 ¶ms, sizeof(params),
751 resp, sizeof(*resp)) != sizeof(*resp))
752 return -1;
753
754 return 0;
755}
756
757static int cros_ec_check_version(struct udevice *dev)
758{
759 struct cros_ec_dev *cdev = dev_get_uclass_priv(dev);
760 struct ec_params_hello req;
761
762 struct dm_cros_ec_ops *ops;
763 int ret;
764
765 ops = dm_cros_ec_get_ops(dev);
766 if (ops->check_version) {
767 ret = ops->check_version(dev);
768 if (ret)
769 return ret;
770 }
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787 cdev->protocol_version = 3;
788 req.in_data = 0;
789 ret = cros_ec_hello(dev, NULL);
790 if (!ret || ret == -ENOTSYNC)
791 return 0;
792
793
794 cdev->protocol_version = 2;
795 ret = cros_ec_hello(dev, NULL);
796 if (!ret || ret == -ENOTSYNC)
797 return 0;
798
799
800
801
802
803
804
805 cdev->protocol_version = 0;
806 printf("%s: ERROR: old EC interface not supported\n", __func__);
807 return -1;
808}
809
810int cros_ec_test(struct udevice *dev)
811{
812 uint out_data;
813 int ret;
814
815 ret = cros_ec_hello(dev, &out_data);
816 if (ret == -ENOTSYNC) {
817 printf("Received invalid handshake %x\n", out_data);
818 return ret;
819 } else if (ret) {
820 printf("ec_command_inptr() returned error\n");
821 return ret;
822 }
823
824 return 0;
825}
826
827int cros_ec_flash_offset(struct udevice *dev, enum ec_flash_region region,
828 uint32_t *offset, uint32_t *size)
829{
830 struct ec_params_flash_region_info p;
831 struct ec_response_flash_region_info *r;
832 int ret;
833
834 p.region = region;
835 ret = ec_command_inptr(dev, EC_CMD_FLASH_REGION_INFO,
836 EC_VER_FLASH_REGION_INFO,
837 &p, sizeof(p), (uint8_t **)&r, sizeof(*r));
838 if (ret != sizeof(*r))
839 return -1;
840
841 if (offset)
842 *offset = r->offset;
843 if (size)
844 *size = r->size;
845
846 return 0;
847}
848
849int cros_ec_flash_erase(struct udevice *dev, uint32_t offset, uint32_t size)
850{
851 struct ec_params_flash_erase p;
852
853 p.offset = offset;
854 p.size = size;
855 return ec_command_inptr(dev, EC_CMD_FLASH_ERASE, 0, &p, sizeof(p),
856 NULL, 0);
857}
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877static int cros_ec_flash_write_block(struct udevice *dev, const uint8_t *data,
878 uint32_t offset, uint32_t size)
879{
880 struct ec_params_flash_write *p;
881 int ret;
882
883 p = malloc(sizeof(*p) + size);
884 if (!p)
885 return -ENOMEM;
886
887 p->offset = offset;
888 p->size = size;
889 assert(data && p->size <= EC_FLASH_WRITE_VER0_SIZE);
890 memcpy(p + 1, data, p->size);
891
892 ret = ec_command_inptr(dev, EC_CMD_FLASH_WRITE, 0,
893 p, sizeof(*p) + size, NULL, 0) >= 0 ? 0 : -1;
894
895 free(p);
896
897 return ret;
898}
899
900
901
902
903static int cros_ec_flash_write_burst_size(struct udevice *dev)
904{
905 return EC_FLASH_WRITE_VER0_SIZE;
906}
907
908
909
910
911
912
913
914
915
916
917
918static int cros_ec_data_is_erased(const uint32_t *data, int size)
919{
920 assert(!(size & 3));
921 size /= sizeof(uint32_t);
922 for (; size > 0; size -= 4, data++)
923 if (*data != -1U)
924 return 0;
925
926 return 1;
927}
928
929
930
931
932
933
934
935
936
937int cros_ec_read_flashinfo(struct udevice *dev,
938 struct ec_response_flash_info *info)
939{
940 int ret;
941
942 ret = ec_command(dev, EC_CMD_FLASH_INFO, 0,
943 NULL, 0, info, sizeof(*info));
944 if (ret < 0)
945 return ret;
946
947 return ret < sizeof(*info) ? -1 : 0;
948}
949
950int cros_ec_flash_write(struct udevice *dev, const uint8_t *data,
951 uint32_t offset, uint32_t size)
952{
953 struct cros_ec_dev *cdev = dev_get_uclass_priv(dev);
954 uint32_t burst = cros_ec_flash_write_burst_size(dev);
955 uint32_t end, off;
956 int ret;
957
958 if (!burst)
959 return -EINVAL;
960
961
962
963
964
965 end = offset + size;
966 for (off = offset; off < end; off += burst, data += burst) {
967 uint32_t todo;
968
969
970 todo = min(end - off, burst);
971 if (cdev->optimise_flash_write &&
972 cros_ec_data_is_erased((uint32_t *)data, todo))
973 continue;
974
975 ret = cros_ec_flash_write_block(dev, data, off, todo);
976 if (ret)
977 return ret;
978 }
979
980 return 0;
981}
982
983
984
985
986
987
988
989
990int cros_ec_efs_verify(struct udevice *dev, enum ec_flash_region region)
991{
992 struct ec_params_efs_verify p;
993 int rv;
994
995 log_info("EFS: EC is verifying updated image...\n");
996 p.region = region;
997
998 rv = ec_command(dev, EC_CMD_EFS_VERIFY, 0, &p, sizeof(p), NULL, 0);
999 if (rv >= 0) {
1000 log_info("EFS: Verification success\n");
1001 return 0;
1002 }
1003 if (rv == -EC_RES_INVALID_COMMAND) {
1004 log_info("EFS: EC doesn't support EFS_VERIFY command\n");
1005 return 0;
1006 }
1007 log_info("EFS: Verification failed\n");
1008
1009 return rv;
1010}
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027static int cros_ec_flash_read_block(struct udevice *dev, uint8_t *data,
1028 uint32_t offset, uint32_t size)
1029{
1030 struct ec_params_flash_read p;
1031
1032 p.offset = offset;
1033 p.size = size;
1034
1035 return ec_command(dev, EC_CMD_FLASH_READ, 0,
1036 &p, sizeof(p), data, size) >= 0 ? 0 : -1;
1037}
1038
1039int cros_ec_flash_read(struct udevice *dev, uint8_t *data, uint32_t offset,
1040 uint32_t size)
1041{
1042 uint32_t burst = cros_ec_flash_write_burst_size(dev);
1043 uint32_t end, off;
1044 int ret;
1045
1046 end = offset + size;
1047 for (off = offset; off < end; off += burst, data += burst) {
1048 ret = cros_ec_flash_read_block(dev, data, off,
1049 min(end - off, burst));
1050 if (ret)
1051 return ret;
1052 }
1053
1054 return 0;
1055}
1056
1057int cros_ec_flash_update_rw(struct udevice *dev, const uint8_t *image,
1058 int image_size)
1059{
1060 uint32_t rw_offset, rw_size;
1061 int ret;
1062
1063 if (cros_ec_flash_offset(dev, EC_FLASH_REGION_ACTIVE, &rw_offset,
1064 &rw_size))
1065 return -1;
1066 if (image_size > (int)rw_size)
1067 return -1;
1068
1069
1070
1071
1072
1073 ret = cros_ec_invalidate_hash(dev);
1074 if (ret)
1075 return ret;
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085 ret = cros_ec_flash_erase(dev, rw_offset, rw_size);
1086 if (ret)
1087 return ret;
1088
1089
1090 ret = cros_ec_flash_write(dev, image, rw_offset, image_size);
1091 if (ret)
1092 return ret;
1093
1094 return 0;
1095}
1096
1097int cros_ec_get_sku_id(struct udevice *dev)
1098{
1099 struct ec_sku_id_info *r;
1100 int ret;
1101
1102 ret = ec_command_inptr(dev, EC_CMD_GET_SKU_ID, 0, NULL, 0,
1103 (uint8_t **)&r, sizeof(*r));
1104 if (ret != sizeof(*r))
1105 return -ret;
1106
1107 return r->sku_id;
1108}
1109
1110int cros_ec_read_nvdata(struct udevice *dev, uint8_t *block, int size)
1111{
1112 struct ec_params_vbnvcontext p;
1113 int len;
1114
1115 if (size != EC_VBNV_BLOCK_SIZE && size != EC_VBNV_BLOCK_SIZE_V2)
1116 return -EINVAL;
1117
1118 p.op = EC_VBNV_CONTEXT_OP_READ;
1119
1120 len = ec_command(dev, EC_CMD_VBNV_CONTEXT, EC_VER_VBNV_CONTEXT,
1121 &p, sizeof(uint32_t) + size, block, size);
1122 if (len != size) {
1123 log_err("Expected %d bytes, got %d\n", size, len);
1124 return -EIO;
1125 }
1126
1127 return 0;
1128}
1129
1130int cros_ec_write_nvdata(struct udevice *dev, const uint8_t *block, int size)
1131{
1132 struct ec_params_vbnvcontext p;
1133 int len;
1134
1135 if (size != EC_VBNV_BLOCK_SIZE && size != EC_VBNV_BLOCK_SIZE_V2)
1136 return -EINVAL;
1137 p.op = EC_VBNV_CONTEXT_OP_WRITE;
1138 memcpy(p.block, block, size);
1139
1140 len = ec_command_inptr(dev, EC_CMD_VBNV_CONTEXT, EC_VER_VBNV_CONTEXT,
1141 &p, sizeof(uint32_t) + size, NULL, 0);
1142 if (len < 0)
1143 return -1;
1144
1145 return 0;
1146}
1147
1148int cros_ec_battery_cutoff(struct udevice *dev, uint8_t flags)
1149{
1150 struct ec_params_battery_cutoff p;
1151 int len;
1152
1153 p.flags = flags;
1154 len = ec_command(dev, EC_CMD_BATTERY_CUT_OFF, 1, &p, sizeof(p),
1155 NULL, 0);
1156
1157 if (len < 0)
1158 return -1;
1159 return 0;
1160}
1161
1162int cros_ec_set_pwm_duty(struct udevice *dev, uint8_t index, uint16_t duty)
1163{
1164 struct ec_params_pwm_set_duty p;
1165 int ret;
1166
1167 p.duty = duty;
1168 p.pwm_type = EC_PWM_TYPE_GENERIC;
1169 p.index = index;
1170
1171 ret = ec_command(dev, EC_CMD_PWM_SET_DUTY, 0, &p, sizeof(p),
1172 NULL, 0);
1173 if (ret < 0)
1174 return ret;
1175
1176 return 0;
1177}
1178
1179int cros_ec_set_ldo(struct udevice *dev, uint8_t index, uint8_t state)
1180{
1181 struct ec_params_ldo_set params;
1182
1183 params.index = index;
1184 params.state = state;
1185
1186 if (ec_command_inptr(dev, EC_CMD_LDO_SET, 0, ¶ms, sizeof(params),
1187 NULL, 0))
1188 return -1;
1189
1190 return 0;
1191}
1192
1193int cros_ec_get_ldo(struct udevice *dev, uint8_t index, uint8_t *state)
1194{
1195 struct ec_params_ldo_get params;
1196 struct ec_response_ldo_get *resp;
1197
1198 params.index = index;
1199
1200 if (ec_command_inptr(dev, EC_CMD_LDO_GET, 0, ¶ms, sizeof(params),
1201 (uint8_t **)&resp, sizeof(*resp)) !=
1202 sizeof(*resp))
1203 return -1;
1204
1205 *state = resp->state;
1206
1207 return 0;
1208}
1209
1210int cros_ec_register(struct udevice *dev)
1211{
1212 struct cros_ec_dev *cdev = dev_get_uclass_priv(dev);
1213 char id[MSG_BYTES];
1214
1215 cdev->dev = dev;
1216 gpio_request_by_name(dev, "ec-interrupt", 0, &cdev->ec_int,
1217 GPIOD_IS_IN);
1218 cdev->optimise_flash_write = dev_read_bool(dev, "optimise-flash-write");
1219
1220 if (cros_ec_check_version(dev)) {
1221 debug("%s: Could not detect CROS-EC version\n", __func__);
1222 return -CROS_EC_ERR_CHECK_VERSION;
1223 }
1224
1225 if (cros_ec_read_id(dev, id, sizeof(id))) {
1226 debug("%s: Could not read KBC ID\n", __func__);
1227 return -CROS_EC_ERR_READ_ID;
1228 }
1229
1230
1231 debug("Google Chrome EC v%d CROS-EC driver ready, id '%s'\n",
1232 cdev->protocol_version, id);
1233
1234 return 0;
1235}
1236
1237int cros_ec_decode_ec_flash(struct udevice *dev, struct fdt_cros_ec *config)
1238{
1239 ofnode flash_node, node;
1240
1241 flash_node = dev_read_subnode(dev, "flash");
1242 if (!ofnode_valid(flash_node)) {
1243 debug("Failed to find flash node\n");
1244 return -1;
1245 }
1246
1247 if (ofnode_read_fmap_entry(flash_node, &config->flash)) {
1248 debug("Failed to decode flash node in chrome-ec\n");
1249 return -1;
1250 }
1251
1252 config->flash_erase_value = ofnode_read_s32_default(flash_node,
1253 "erase-value", -1);
1254 ofnode_for_each_subnode(node, flash_node) {
1255 const char *name = ofnode_get_name(node);
1256 enum ec_flash_region region;
1257
1258 if (0 == strcmp(name, "ro")) {
1259 region = EC_FLASH_REGION_RO;
1260 } else if (0 == strcmp(name, "rw")) {
1261 region = EC_FLASH_REGION_ACTIVE;
1262 } else if (0 == strcmp(name, "wp-ro")) {
1263 region = EC_FLASH_REGION_WP_RO;
1264 } else {
1265 debug("Unknown EC flash region name '%s'\n", name);
1266 return -1;
1267 }
1268
1269 if (ofnode_read_fmap_entry(node, &config->region[region])) {
1270 debug("Failed to decode flash region in chrome-ec'\n");
1271 return -1;
1272 }
1273 }
1274
1275 return 0;
1276}
1277
1278int cros_ec_i2c_tunnel(struct udevice *dev, int port, struct i2c_msg *in,
1279 int nmsgs)
1280{
1281 union {
1282 struct ec_params_i2c_passthru p;
1283 uint8_t outbuf[EC_PROTO2_MAX_PARAM_SIZE];
1284 } params;
1285 union {
1286 struct ec_response_i2c_passthru r;
1287 uint8_t inbuf[EC_PROTO2_MAX_PARAM_SIZE];
1288 } response;
1289 struct ec_params_i2c_passthru *p = ¶ms.p;
1290 struct ec_response_i2c_passthru *r = &response.r;
1291 struct ec_params_i2c_passthru_msg *msg;
1292 uint8_t *pdata, *read_ptr = NULL;
1293 int read_len;
1294 int size;
1295 int rv;
1296 int i;
1297
1298 p->port = port;
1299
1300 p->num_msgs = nmsgs;
1301 size = sizeof(*p) + p->num_msgs * sizeof(*msg);
1302
1303
1304 pdata = (uint8_t *)p + size;
1305
1306 read_len = 0;
1307 for (i = 0, msg = p->msg; i < nmsgs; i++, msg++, in++) {
1308 bool is_read = in->flags & I2C_M_RD;
1309
1310 msg->addr_flags = in->addr;
1311 msg->len = in->len;
1312 if (is_read) {
1313 msg->addr_flags |= EC_I2C_FLAG_READ;
1314 read_len += in->len;
1315 read_ptr = in->buf;
1316 if (sizeof(*r) + read_len > sizeof(response)) {
1317 puts("Read length too big for buffer\n");
1318 return -1;
1319 }
1320 } else {
1321 if (pdata - (uint8_t *)p + in->len > sizeof(params)) {
1322 puts("Params too large for buffer\n");
1323 return -1;
1324 }
1325 memcpy(pdata, in->buf, in->len);
1326 pdata += in->len;
1327 }
1328 }
1329
1330 rv = ec_command(dev, EC_CMD_I2C_PASSTHRU, 0, p, pdata - (uint8_t *)p,
1331 r, sizeof(*r) + read_len);
1332 if (rv < 0)
1333 return rv;
1334
1335
1336 if (r->i2c_status & EC_I2C_STATUS_ERROR) {
1337 printf("Transfer failed with status=0x%x\n", r->i2c_status);
1338 return -1;
1339 }
1340
1341 if (rv < sizeof(*r) + read_len) {
1342 puts("Truncated read response\n");
1343 return -1;
1344 }
1345
1346
1347 if (read_len)
1348 memcpy(read_ptr, r->data, read_len);
1349
1350 return 0;
1351}
1352
1353int cros_ec_get_features(struct udevice *dev, u64 *featuresp)
1354{
1355 struct ec_response_get_features r;
1356 int rv;
1357
1358 rv = ec_command(dev, EC_CMD_GET_FEATURES, 0, NULL, 0, &r, sizeof(r));
1359 if (rv != sizeof(r))
1360 return -EIO;
1361 *featuresp = r.flags[0] | (u64)r.flags[1] << 32;
1362
1363 return 0;
1364}
1365
1366int cros_ec_check_feature(struct udevice *dev, uint feature)
1367{
1368 struct ec_response_get_features r;
1369 int rv;
1370
1371 rv = ec_command(dev, EC_CMD_GET_FEATURES, 0, NULL, 0, &r, sizeof(r));
1372 if (rv != sizeof(r))
1373 return -EIO;
1374
1375 if (feature >= 8 * sizeof(r.flags))
1376 return -EINVAL;
1377
1378 return r.flags[feature / 32] & EC_FEATURE_MASK_0(feature) ? true :
1379 false;
1380}
1381
1382
1383
1384
1385
1386static int cros_ec_uhepi_cmd(struct udevice *dev, uint mask, uint action,
1387 uint64_t *value)
1388{
1389 int ret;
1390 struct ec_params_host_event req;
1391 struct ec_response_host_event rsp;
1392
1393 req.action = action;
1394 req.mask_type = mask;
1395 if (action != EC_HOST_EVENT_GET)
1396 req.value = *value;
1397 else
1398 *value = 0;
1399 ret = ec_command(dev, EC_CMD_HOST_EVENT, 0, &req, sizeof(req), &rsp,
1400 sizeof(rsp));
1401
1402 if (action != EC_HOST_EVENT_GET)
1403 return ret;
1404 if (ret == 0)
1405 *value = rsp.value;
1406
1407 return ret;
1408}
1409
1410static int cros_ec_handle_non_uhepi_cmd(struct udevice *dev, uint hcmd,
1411 uint action, uint64_t *value)
1412{
1413 int ret = -1;
1414 struct ec_params_host_event_mask req;
1415 struct ec_response_host_event_mask rsp;
1416
1417 if (hcmd == INVALID_HCMD)
1418 return ret;
1419
1420 if (action != EC_HOST_EVENT_GET)
1421 req.mask = (uint32_t)*value;
1422 else
1423 *value = 0;
1424
1425 ret = ec_command(dev, hcmd, 0, &req, sizeof(req), &rsp, sizeof(rsp));
1426 if (action != EC_HOST_EVENT_GET)
1427 return ret;
1428 if (ret == 0)
1429 *value = rsp.mask;
1430
1431 return ret;
1432}
1433
1434bool cros_ec_is_uhepi_supported(struct udevice *dev)
1435{
1436#define UHEPI_SUPPORTED 1
1437#define UHEPI_NOT_SUPPORTED 2
1438 static int uhepi_support;
1439
1440 if (!uhepi_support) {
1441 uhepi_support = cros_ec_check_feature(dev,
1442 EC_FEATURE_UNIFIED_WAKE_MASKS) > 0 ? UHEPI_SUPPORTED :
1443 UHEPI_NOT_SUPPORTED;
1444 log_debug("Chrome EC: UHEPI %s\n",
1445 uhepi_support == UHEPI_SUPPORTED ? "supported" :
1446 "not supported");
1447 }
1448 return uhepi_support == UHEPI_SUPPORTED;
1449}
1450
1451static int cros_ec_get_mask(struct udevice *dev, uint type)
1452{
1453 u64 value = 0;
1454
1455 if (cros_ec_is_uhepi_supported(dev)) {
1456 cros_ec_uhepi_cmd(dev, type, EC_HOST_EVENT_GET, &value);
1457 } else {
1458 assert(type < ARRAY_SIZE(event_map));
1459 cros_ec_handle_non_uhepi_cmd(dev, event_map[type].get_cmd,
1460 EC_HOST_EVENT_GET, &value);
1461 }
1462 return value;
1463}
1464
1465static int cros_ec_clear_mask(struct udevice *dev, uint type, u64 mask)
1466{
1467 if (cros_ec_is_uhepi_supported(dev))
1468 return cros_ec_uhepi_cmd(dev, type, EC_HOST_EVENT_CLEAR, &mask);
1469
1470 assert(type < ARRAY_SIZE(event_map));
1471
1472 return cros_ec_handle_non_uhepi_cmd(dev, event_map[type].clear_cmd,
1473 EC_HOST_EVENT_CLEAR, &mask);
1474}
1475
1476uint64_t cros_ec_get_events_b(struct udevice *dev)
1477{
1478 return cros_ec_get_mask(dev, EC_HOST_EVENT_B);
1479}
1480
1481int cros_ec_clear_events_b(struct udevice *dev, uint64_t mask)
1482{
1483 log_debug("Chrome EC: clear events_b mask to 0x%016llx\n", mask);
1484
1485 return cros_ec_clear_mask(dev, EC_HOST_EVENT_B, mask);
1486}
1487
1488int cros_ec_read_limit_power(struct udevice *dev, int *limit_powerp)
1489{
1490 struct ec_params_charge_state p;
1491 struct ec_response_charge_state r;
1492 int ret;
1493
1494 p.cmd = CHARGE_STATE_CMD_GET_PARAM;
1495 p.get_param.param = CS_PARAM_LIMIT_POWER;
1496 ret = ec_command(dev, EC_CMD_CHARGE_STATE, 0, &p, sizeof(p),
1497 &r, sizeof(r));
1498
1499
1500
1501
1502
1503 if (ret == -EC_RES_INVALID_PARAM || ret == -EC_RES_INVALID_COMMAND) {
1504 log_warning("PARAM_LIMIT_POWER not supported by EC\n");
1505 return -ENOSYS;
1506 }
1507
1508 if (ret != sizeof(r.get_param))
1509 return -EINVAL;
1510
1511 *limit_powerp = r.get_param.value;
1512 return 0;
1513}
1514
1515int cros_ec_config_powerbtn(struct udevice *dev, uint32_t flags)
1516{
1517 struct ec_params_config_power_button params;
1518 int ret;
1519
1520 params.flags = flags;
1521 ret = ec_command(dev, EC_CMD_CONFIG_POWER_BUTTON, 0,
1522 ¶ms, sizeof(params), NULL, 0);
1523 if (ret < 0)
1524 return ret;
1525
1526 return 0;
1527}
1528
1529int cros_ec_get_lid_shutdown_mask(struct udevice *dev)
1530{
1531 u32 mask;
1532 int ret;
1533
1534 ret = cros_ec_get_event_mask(dev, EC_CMD_HOST_EVENT_GET_SMI_MASK,
1535 &mask);
1536 if (ret < 0)
1537 return ret;
1538
1539 return !!(mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_CLOSED));
1540}
1541
1542int cros_ec_set_lid_shutdown_mask(struct udevice *dev, int enable)
1543{
1544 u32 mask;
1545 int ret;
1546
1547 ret = cros_ec_get_event_mask(dev, EC_CMD_HOST_EVENT_GET_SMI_MASK,
1548 &mask);
1549 if (ret < 0)
1550 return ret;
1551
1552
1553 if (enable)
1554 mask |= EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_CLOSED);
1555 else
1556 mask &= ~EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_CLOSED);
1557
1558 ret = cros_ec_set_event_mask(dev, EC_CMD_HOST_EVENT_SET_SMI_MASK, mask);
1559 if (ret < 0)
1560 return ret;
1561
1562 printf("EC: %sabled lid close event\n", enable ? "en" : "dis");
1563 return 0;
1564}
1565
1566int cros_ec_vstore_supported(struct udevice *dev)
1567{
1568 return cros_ec_check_feature(dev, EC_FEATURE_VSTORE);
1569}
1570
1571int cros_ec_vstore_info(struct udevice *dev, u32 *lockedp)
1572{
1573 struct ec_response_vstore_info *resp;
1574
1575 if (ec_command_inptr(dev, EC_CMD_VSTORE_INFO, 0, NULL, 0,
1576 (uint8_t **)&resp, sizeof(*resp)) != sizeof(*resp))
1577 return -EIO;
1578
1579 if (lockedp)
1580 *lockedp = resp->slot_locked;
1581
1582 return resp->slot_count;
1583}
1584
1585
1586
1587
1588
1589
1590
1591int cros_ec_vstore_read(struct udevice *dev, int slot, uint8_t *data)
1592{
1593 struct ec_params_vstore_read req;
1594 struct ec_response_vstore_read *resp;
1595
1596 req.slot = slot;
1597 if (ec_command_inptr(dev, EC_CMD_VSTORE_READ, 0, &req, sizeof(req),
1598 (uint8_t **)&resp, sizeof(*resp)) != sizeof(*resp))
1599 return -EIO;
1600
1601 if (!data || req.slot >= EC_VSTORE_SLOT_MAX)
1602 return -EINVAL;
1603
1604 memcpy(data, resp->data, sizeof(resp->data));
1605
1606 return 0;
1607}
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620int cros_ec_vstore_write(struct udevice *dev, int slot, const uint8_t *data,
1621 size_t size)
1622{
1623 struct ec_params_vstore_write req;
1624
1625 if (slot >= EC_VSTORE_SLOT_MAX || size > EC_VSTORE_SLOT_SIZE)
1626 return -EINVAL;
1627
1628 req.slot = slot;
1629 memcpy(req.data, data, size);
1630
1631 if (ec_command(dev, EC_CMD_VSTORE_WRITE, 0, &req, sizeof(req), NULL, 0))
1632 return -EIO;
1633
1634 return 0;
1635}
1636
1637int cros_ec_get_switches(struct udevice *dev)
1638{
1639 struct dm_cros_ec_ops *ops;
1640 int ret;
1641
1642 ops = dm_cros_ec_get_ops(dev);
1643 if (!ops->get_switches)
1644 return -ENOSYS;
1645
1646 ret = ops->get_switches(dev);
1647 if (ret < 0)
1648 return log_msg_ret("get", ret);
1649
1650 return ret;
1651}
1652
1653int cros_ec_read_batt_charge(struct udevice *dev, uint *chargep)
1654{
1655 struct ec_params_charge_state req;
1656 struct ec_response_charge_state resp;
1657 int ret;
1658
1659 req.cmd = CHARGE_STATE_CMD_GET_STATE;
1660 ret = ec_command(dev, EC_CMD_CHARGE_STATE, 0, &req, sizeof(req),
1661 &resp, sizeof(resp));
1662 if (ret)
1663 return log_msg_ret("read", ret);
1664
1665 *chargep = resp.get_state.batt_state_of_charge;
1666
1667 return 0;
1668}
1669
1670UCLASS_DRIVER(cros_ec) = {
1671 .id = UCLASS_CROS_EC,
1672 .name = "cros-ec",
1673 .per_device_auto = sizeof(struct cros_ec_dev),
1674#if CONFIG_IS_ENABLED(OF_REAL)
1675 .post_bind = dm_scan_fdt_dev,
1676#endif
1677 .flags = DM_UC_FLAG_ALLOC_PRIV_DMA,
1678};
1679