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