forked from u-root/u-root
-
Notifications
You must be signed in to change notification settings - Fork 1
/
commands.go
3426 lines (2856 loc) · 86.9 KB
/
commands.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
package main
/* Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
/* Host communication command constants for Chrome EC */
const (
/*
* Current version of this protocol
*
* TODO(crosbug.com/p/11223): This is effectively useless; protocol is
* determined in other ways. Remove this once the kernel code no longer
* depends on it.
*/
ecProtoVersion = 0x00000002
/* I/O addresses for ACPI commands */
ecLpcAddrAcpiData = 0x62
ecLpcAddrAcpiCmd = 0x66
/* I/O addresses for host command */
ecLpcAddrHostData = 0x200
ecLpcAddrHostCmd = 0x204
/* I/O addresses for host command args and params */
/* Protocol version 2 */
ecLpcAddrHostArgs = 0x800 /* And 0x801, 0x802, 0x803 */
ecLpcAddrHostParam = 0x804 /* For version 2 params; size is
* ecProto2MaxParamSize */
/* Protocol version 3 */
ecLpcAddrHostPacket = 0x800 /* Offset of version 3 packet */
ecLpcHostPacketSize = 0x100 /* Max size of version 3 packet */
/* The actual block is 0x800-0x8ff, but some BIOSes think it's 0x880-0x8ff
* and they tell the kernel that so we have to think of it as two parts. */
ecHostCmdRegion0 = 0x800
ecHostCmdRegion1 = 0x880
ecHostCmdRegionSize = 0x80
/* EC command register bit functions */
ecLpcCmdrData = (1 << 0) /* Data ready for host to read */
ecLpcCmdrPending = (1 << 1) /* Write pending to EC */
ecLpcCmdrBusy = (1 << 2) /* EC is busy processing a command */
ecLpcCmdrCmd = (1 << 3) /* Last host write was a command */
ecLpcCmdrAcpiBrst = (1 << 4) /* Burst mode (not used) */
ecLpcCmdrSci = (1 << 5) /* SCI event is pending */
ecLpcCmdrSmi = (1 << 6) /* SMI event is pending */
ecLpcAddrMemmap = 0x900
ecMemmapSize = 255 /* ACPI IO buffer max is 255 bytes */
ecMemmapTextMax = 8 /* Size of a string in the memory map */
/* The offset address of each type of data in mapped memory. */
ecMemmapTempSensor = 0x00 /* Temp sensors 0x00 - 0x0f */
ecMemmapFan = 0x10 /* Fan speeds 0x10 - 0x17 */
ecMemmapTempSensorB = 0x18 /* More temp sensors 0x18 - 0x1f */
ecMemmapID = 0x20 /* 0x20 == 'E', 0x21 == 'C' */
ecMemmapIDVersion = 0x22 /* Version of data in 0x20 - 0x2f */
ecMemmapThermalVersion = 0x23 /* Version of data in 0x00 - 0x1f */
ecMemmapBatteryVersion = 0x24 /* Version of data in 0x40 - 0x7f */
ecMemmapSwitchesVersion = 0x25 /* Version of data in 0x30 - 0x33 */
ecMemmapEventsVersion = 0x26 /* Version of data in 0x34 - 0x3f */
ecMemmapHostCmdFlags = 0x27 /* Host cmd interface flags (8 bits) */
/* Unused 0x28 - 0x2f */
ecMemmapSwitches = 0x30 /* 8 bits */
/* Unused 0x31 - 0x33 */
ecMemmapHostEvents = 0x34 /* 32 bits */
/* Reserve 0x38 - 0x3f for additional host event-related stuff */
/* Battery values are all 32 bits */
ecMemmapBattVolt = 0x40 /* Battery Present Voltage */
ecMemmapBattRate = 0x44 /* Battery Present Rate */
ecMemmapBattCap = 0x48 /* Battery Remaining Capacity */
ecMemmapBattFlag = 0x4c /* Battery State, defined below */
ecMemmapBattDcap = 0x50 /* Battery Design Capacity */
ecMemmapBattDvlt = 0x54 /* Battery Design Voltage */
ecMemmapBattLfcc = 0x58 /* Battery Last Full Charge Capacity */
ecMemmapBattCcnt = 0x5c /* Battery Cycle Count */
/* Strings are all 8 bytes (ecMemmapTextMax) */
ecMemmapBattMfgr = 0x60 /* Battery Manufacturer String */
ecMemmapBattModel = 0x68 /* Battery Model Number String */
ecMemmapBattSerial = 0x70 /* Battery Serial Number String */
ecMemmapBattType = 0x78 /* Battery Type String */
ecMemmapAls = 0x80 /* ALS readings in lux (2 X 16 bits) */
/* Unused 0x84 - 0x8f */
ecMemmapAccStatus = 0x90 /* Accelerometer status (8 bits )*/
/* Unused 0x91 */
ecMemmapAccData = 0x92 /* Accelerometer data 0x92 - 0x9f */
ecMemmapGyroData = 0xa0 /* Gyroscope data 0xa0 - 0xa5 */
/* Unused 0xa6 - 0xdf */
/*
* ACPI is unable to access memory mapped data at or above this offset due to
* limitations of the ACPI protocol. Do not place data in the range 0xe0 - 0xfe
* which might be needed by ACPI.
*/
ecMemmapNoAcpi = 0xe0
/* Define the format of the accelerometer mapped memory status byte. */
ecMemmapAccStatusSampleIDMask = 0x0f
ecMemmapAccStatusBusyBit = (1 << 4)
ecMemmapAccStatusPresenceBit = (1 << 7)
/* Number of temp sensors at ecMemmapTempSensor */
ecTempSensorEntries = 16
/*
* Number of temp sensors at ecMemmapTempSensorB.
*
* Valid only if ecMemmapThermalVersion returns >= 2.
*/
ecTempSensorBEntries = 8
/* Special values for mapped temperature sensors */
ecTempSensorNotPresent = 0xff
ecTempSensorError = 0xfe
ecTempSensorNotPowered = 0xfd
ecTempSensorNotCalibrated = 0xfc
/*
* The offset of temperature value stored in mapped memory. This allows
* reporting a temperature range of 200K to 454K = -73C to 181C.
*/
ecTempSensorOffset = 200
/*
* Number of ALS readings at ecMemmapAls
*/
ecAlsEntries = 2
/*
* The default value a temperature sensor will return when it is present but
* has not been read this boot. This is a reasonable number to avoid
* triggering alarms on the host.
*/
ecTempSensorDefault = (296 - ecTempSensorOffset)
ecFanSpeedEntries = 4 /* Number of fans at ecMemmapFan */
ecFanSpeedNotPresent = 0xffff /* Entry not present */
ecFanSpeedStalled = 0xfffe /* Fan stalled */
/* Battery bit flags at ecMemmapBattFlag. */
ecBattFlagAcPresent = 0x01
ecBattFlagBattPresent = 0x02
ecBattFlagDischarging = 0x04
ecBattFlagCharging = 0x08
ecBattFlagLevelCritical = 0x10
/* Switch flags at ecMemmapSwitches */
ecSwitchLidOpen = 0x01
ecSwitchPowerButtonPressed = 0x02
ecSwitchWriteProtectDisabled = 0x04
/* Was recovery requested via keyboard; now unused. */
ecSwitchIgnore1 = 0x08
/* Recovery requested via dedicated signal (from servo board) */
ecSwitchDedicatedRecovery = 0x10
/* Was fake developer mode switch; now unused. Remove in next refactor. */
ecSwitchIgnore0 = 0x20
/* Host command interface flags */
/* Host command interface supports LPC args (LPC interface only) */
ecHostCmdFlagLpcArgsSupported = 0x01
/* Host command interface supports version 3 protocol */
ecHostCmdFlagVersion3 = 0x02
/* Wireless switch flags */
ecWirelessSwitchAll = ^0x00 /* All flags */
ecWirelessSwitchWlan = 0x01 /* WLAN radio */
ecWirelessSwitchBluetooth = 0x02 /* Bluetooth radio */
ecWirelessSwitchWwan = 0x04 /* WWAN power */
ecWirelessSwitchWlanPower = 0x08 /* WLAN power */
/*****************************************************************************/
/*
* ACPI commands
*
* These are valid ONLY on the ACPI command/data port.
*/
/*
* ACPI Read Embedded Controller
*
* This reads from ACPI memory space on the EC (ecAcpiMem_*).
*
* Use the following sequence:
*
* - Write ecCmdAcpiRead to ecLpcAddrAcpiCmd
* - Wait for ecLpcCmdrPending bit to clear
* - Write address to ecLpcAddrAcpiData
* - Wait for ecLpcCmdrData bit to set
* - Read value from ecLpcAddrAcpiData
*/
ecCmdAcpiRead = 0x80
/*
* ACPI Write Embedded Controller
*
* This reads from ACPI memory space on the EC (ecAcpiMem_*).
*
* Use the following sequence:
*
* - Write ecCmdAcpiWrite to ecLpcAddrAcpiCmd
* - Wait for ecLpcCmdrPending bit to clear
* - Write address to ecLpcAddrAcpiData
* - Wait for ecLpcCmdrPending bit to clear
* - Write value to ecLpcAddrAcpiData
*/
ecCmdAcpiWrite = 0x81
/*
* ACPI Burst Enable Embedded Controller
*
* This enables burst mode on the EC to allow the host to issue several
* commands back-to-back. While in this mode, writes to mapped multi-byte
* data are locked out to ensure data consistency.
*/
ecCmdAcpiBurstEnable = 0x82
/*
* ACPI Burst Disable Embedded Controller
*
* This disables burst mode on the EC and stops preventing EC writes to mapped
* multi-byte data.
*/
ecCmdAcpiBurstDisable = 0x83
/*
* ACPI Query Embedded Controller
*
* This clears the lowest-order bit in the currently pending host events, and
* sets the result code to the 1-based index of the bit (event 0x00000001 = 1
* event 0x80000000 = 32), or 0 if no event was pending.
*/
ecCmdAcpiQueryEvent = 0x84
/* Valid addresses in ACPI memory space, for read/write commands */
/* Memory space version; set to ecAcpiMemVersionCurrent */
ecAcpiMemVersion = 0x00
/*
* Test location; writing value here updates test compliment byte to (0xff -
* value).
*/
ecAcpiMemTest = 0x01
/* Test compliment; writes here are ignored. */
ecAcpiMemTestCompliment = 0x02
/* Keyboard backlight brightness percent (0 - 100) */
ecAcpiMemKeyboardBacklight = 0x03
/* DPTF Target Fan Duty (0-100, 0xff for auto/none) */
ecAcpiMemFanDuty = 0x04
/*
* DPTF temp thresholds. Any of the EC's temp sensors can have up to two
* independent thresholds attached to them. The current value of the ID
* register determines which sensor is affected by the THRESHOLD and COMMIT
* registers. The THRESHOLD register uses the same ecTempSensorOffset scheme
* as the memory-mapped sensors. The COMMIT register applies those settings.
*
* The spec does not mandate any way to read back the threshold settings
* themselves, but when a threshold is crossed the AP needs a way to determine
* which sensor(s) are responsible. Each reading of the ID register clears and
* returns one sensor ID that has crossed one of its threshold (in either
* direction) since the last read. A value of 0xFF means "no new thresholds
* have tripped". Setting or enabling the thresholds for a sensor will clear
* the unread event count for that sensor.
*/
ecAcpiMemTempID = 0x05
ecAcpiMemTempThreshold = 0x06
ecAcpiMemTempCommit = 0x07
/*
* Here are the bits for the COMMIT register:
* bit 0 selects the threshold index for the chosen sensor (0/1)
* bit 1 enables/disables the selected threshold (0 = off, 1 = on)
* Each write to the commit register affects one threshold.
*/
ecAcpiMemTempCommitSelectMask = (1 << 0)
ecAcpiMemTempCommitEnableMask = (1 << 1)
/*
* Example:
*
* Set the thresholds for sensor 2 to 50 C and 60 C:
* write 2 to [0x05] -- select temp sensor 2
* write 0x7b to [0x06] -- CToK(50) - ecTempSensorOffset
* write 0x2 to [0x07] -- enable threshold 0 with this value
* write 0x85 to [0x06] -- CToK(60) - ecTempSensorOffset
* write 0x3 to [0x07] -- enable threshold 1 with this value
*
* Disable the 60 C threshold, leaving the 50 C threshold unchanged:
* write 2 to [0x05] -- select temp sensor 2
* write 0x1 to [0x07] -- disable threshold 1
*/
/* DPTF battery charging current limit */
ecAcpiMemChargingLimit = 0x08
/* Charging limit is specified in 64 mA steps */
ecAcpiMemChargingLimitStepMa = 64
/* Value to disable DPTF battery charging limit */
ecAcpiMemChargingLimitDisabled = 0xff
/*
* ACPI addresses 0x20 - 0xff map to ecMemmap offset 0x00 - 0xdf. This data
* is read-only from the AP. Added in ecAcpiMemVersion 2.
*/
ecAcpiMemMappedBegin = 0x20
ecAcpiMemMappedSize = 0xe0
/* Current version of ACPI memory address space */
ecAcpiMemVersionCurrent = 2
/*
* This header file is used in coreboot both in C and ACPI code. The ACPI code
* is pre-processed to handle constants but the ASL compiler is unable to
* handle actual C code so keep it separate.
*/
/* LPC command status byte masks */
/* EC has written a byte in the data register and host hasn't read it yet */
ecLpcStatusToHost = 0x01
/* Host has written a command/data byte and the EC hasn't read it yet */
ecLpcStatusFromHost = 0x02
/* EC is processing a command */
ecLpcStatusProcessing = 0x04
/* Last write to EC was a command, not data */
ecLpcStatusLastCmd = 0x08
/* EC is in burst mode */
ecLpcStatusBurstMode = 0x10
/* SCI event is pending (requesting SCI query) */
ecLpcStatusSciPending = 0x20
/* SMI event is pending (requesting SMI query) */
ecLpcStatusSmiPending = 0x40
/* (reserved) */
ecLpcStatusReserved = 0x80
/*
* EC is busy. This covers both the EC processing a command, and the host has
* written a new command but the EC hasn't picked it up yet.
*/
ecLpcStatusBusyMask = (ecLpcStatusFromHost | ecLpcStatusProcessing)
)
/* Host command response codes */
type ecStatus uint8
const (
ecResSuccess ecStatus = 0
ecResInvalidCommand = 1
ecResError = 2
ecResInvalidParam = 3
ecResAccessDenied = 4
ecResInvalidResponse = 5
ecResInvalidVersion = 6
ecResInvalidChecksum = 7
ecResInProgress = 8 /* Accepted, command in progress */
ecResUnavailable = 9 /* No response available */
ecResTimeout = 10 /* We got a timeout */
ecResOverflow = 11 /* Table / data overflow */
ecResInvalidHeader = 12 /* Header contains invalid data */
ecResRequestTruncated = 13 /* Didn't get the entire request */
ecResResponseTooBig = 14 /* Response was too big to handle */
ecResBusError = 15 /* Communications bus error */
ecResBusy = 16 /* Up but too busy. Should retry */
)
/*
* Host event codes. Note these are 1-based, not 0-based, because ACPI query
* EC command uses code 0 to mean "no event pending". We explicitly specify
* each value in the enum listing so they won't change if we delete/insert an
* item or rearrange the list (it needs to be stable across platforms, not
* just within a single compiled instance).
*/
type hostEventCode uint8
const (
ecHostEventLidClosed hostEventCode = 1
ecHostEventLidOpen = 2
ecHostEventPowerButton = 3
ecHostEventAcConnected = 4
ecHostEventAcDisconnected = 5
ecHostEventBatteryLow = 6
ecHostEventBatteryCritical = 7
ecHostEventBattery = 8
ecHostEventThermalThreshold = 9
ecHostEventThermalOverload = 10
ecHostEventThermal = 11
ecHostEventUsbCharger = 12
ecHostEventKeyPressed = 13
/*
* EC has finished initializing the host interface. The host can check
* for this event following sending a ecCmdRebootEc command to
* determine when the EC is ready to accept subsequent commands.
*/
ecHostEventInterfaceReady = 14
/* Keyboard recovery combo has been pressed */
ecHostEventKeyboardRecovery = 15
/* Shutdown due to thermal overload */
ecHostEventThermalShutdown = 16
/* Shutdown due to battery level too low */
ecHostEventBatteryShutdown = 17
/* Suggest that the AP throttle itself */
ecHostEventThrottleStart = 18
/* Suggest that the AP resume normal speed */
ecHostEventThrottleStop = 19
/* Hang detect logic detected a hang and host event timeout expired */
ecHostEventHangDetect = 20
/* Hang detect logic detected a hang and warm rebooted the AP */
ecHostEventHangReboot = 21
/* PD MCU triggering host event */
ecHostEventPdMcu = 22
/* Battery Status flags have changed */
ecHostEventBatteryStatus = 23
/* EC encountered a panic, triggering a reset */
ecHostEventPanic = 24
/*
* The high bit of the event mask is not used as a host event code. If
* it reads back as set, then the entire event mask should be
* considered invalid by the host. This can happen when reading the
* raw event status via ecMemmapHostEvents but the LPC interface is
* not initialized on the EC, or improperly configured on the host.
*/
ecHostEventInvalid = 32
)
/* Host event mask */
func ecHostEventMask(eventCode uint8) uint8 {
return 1 << ((eventCode) - 1)
}
/* TYPE */
/* Arguments at ecLpcAddrHostArgs */
type ecLpcHostArgs struct {
flags uint8
commandVersion uint8
dataSize uint8
/*
* Checksum; sum of command + flags + commandVersion + dataSize +
* all params/response data bytes.
*/
checksum uint8
}
/* Flags for ecLpcHostArgs.flags */
/*
* Args are from host. Data area at ecLpcAddrHostParam contains command
* params.
*
* If EC gets a command and this flag is not set, this is an old-style command.
* Command version is 0 and params from host are at ecLpcAddrOldParam with
* unknown length. EC must respond with an old-style response (that is
* withouth setting ecHostArgsFlagToHost).
*/
const ecHostArgsFlagFromHost = 0x01
/*
* Args are from EC. Data area at ecLpcAddrHostParam contains response.
*
* If EC responds to a command and this flag is not set, this is an old-style
* response. Command version is 0 and response data from EC is at
* ecLpcAddrOldParam with unknown length.
*/
const ecHostArgsFlagToHost = 0x02
/*****************************************************************************/
/*
* Byte codes returned by EC over SPI interface.
*
* These can be used by the AP to debug the EC interface, and to determine
* when the EC is not in a state where it will ever get around to responding
* to the AP.
*
* Example of sequence of bytes read from EC for a current good transfer:
* 1. - - AP asserts chip select (CS#)
* 2. ecSpiOldReady - AP sends first byte(s) of request
* 3. - - EC starts handling CS# interrupt
* 4. ecSpiReceiving - AP sends remaining byte(s) of request
* 5. ecSpiProcessing - EC starts processing request; AP is clocking in
* bytes looking for ecSpiFrameStart
* 6. - - EC finishes processing and sets up response
* 7. ecSpiFrameStart - AP reads frame byte
* 8. (response packet) - AP reads response packet
* 9. ecSpiPastEnd - Any additional bytes read by AP
* 10 - - AP deasserts chip select
* 11 - - EC processes CS# interrupt and sets up DMA for
* next request
*
* If the AP is waiting for ecSpiFrameStart and sees any value other than
* the following byte values:
* ecSpiOldReady
* ecSpiRxReady
* ecSpiReceiving
* ecSpiProcessing
*
* Then the EC found an error in the request, or was not ready for the request
* and lost data. The AP should give up waiting for ecSpiFrameStart
* because the EC is unable to tell when the AP is done sending its request.
*/
/*
* Framing byte which precedes a response packet from the EC. After sending a
* request, the AP will clock in bytes until it sees the framing byte, then
* clock in the response packet.
*/
const (
ecSpiFrameStart = 0xec
/*
* Padding bytes which are clocked out after the end of a response packet.
*/
ecSpiPastEnd = 0xed
/*
* EC is ready to receive, and has ignored the byte sent by the AP. EC expects
* that the AP will send a valid packet header (starting with
* ecCommandProtocol3) in the next 32 bytes.
*/
ecSpiRxReady = 0xf8
/*
* EC has started receiving the request from the AP, but hasn't started
* processing it yet.
*/
ecSpiReceiving = 0xf9
/* EC has received the entire request from the AP and is processing it. */
ecSpiProcessing = 0xfa
/*
* EC received bad data from the AP, such as a packet header with an invalid
* length. EC will ignore all data until chip select deasserts.
*/
ecSpiRxBadData = 0xfb
/*
* EC received data from the AP before it was ready. That is, the AP asserted
* chip select and started clocking data before the EC was ready to receive it.
* EC will ignore all data until chip select deasserts.
*/
ecSpiNotReady = 0xfc
/*
* EC was ready to receive a request from the AP. EC has treated the byte sent
* by the AP as part of a request packet, or (for old-style ECs) is processing
* a fully received packet but is not ready to respond yet.
*/
ecSpiOldReady = 0xfd
/*****************************************************************************/
/*
* Protocol version 2 for I2C and SPI send a request this way:
*
* 0 ecCmdVersion0 + (command version)
* 1 Command number
* 2 Length of params = N
* 3..N+2 Params, if any
* N+3 8-bit checksum of bytes 0..N+2
*
* The corresponding response is:
*
* 0 Result code (ecRes_*)
* 1 Length of params = M
* 2..M+1 Params, if any
* M+2 8-bit checksum of bytes 0..M+1
*/
ecProto2RequestHeaderBytes = 3
ecProto2RequestTrailerBytes = 1
ecProto2RequestOverhead = (ecProto2RequestHeaderBytes +
ecProto2RequestTrailerBytes)
ecProto2ResponseHeaderBytes = 2
ecProto2ResponseTrailerBytes = 1
ecProto2ResponseOverhead = (ecProto2ResponseHeaderBytes +
ecProto2ResponseTrailerBytes)
/* Parameter length was limited by the LPC interface */
ecProto2MaxParamSize = 0xfc
/* Maximum request and response packet sizes for protocol version 2 */
ecProto2MaxRequestSize = (ecProto2RequestOverhead +
ecProto2MaxParamSize)
ecProto2MaxResponseSize = (ecProto2ResponseOverhead +
ecProto2MaxParamSize)
/*****************************************************************************/
/*
* Value written to legacy command port / prefix byte to indicate protocol
* 3+ structs are being used. Usage is bus-dependent.
*/
ecCommandProtocol3 = 0xda
ecHostRequestVersion = 3
)
/* TYPE */
/* Version 3 request from host */
type ecHostRequest struct {
/* Struct version (=3)
*
* EC will return ecResInvalidHeader if it receives a header with a
* version it doesn't know how to parse.
*/
structVersion uint8
/*
* Checksum of request and data; sum of all bytes including checksum
* should total to 0.
*/
checksum uint8
/* Command code */
command uint16
/* Command version */
commandVersion uint8
/* Unused byte in current protocol version; set to 0 */
reserved uint8
/* Length of data which follows this header */
dataLen uint16
}
const ecHostResponseVersion = 3
/* TYPE */
/* Version 3 response from EC */
type ecHostResponse struct {
/* Struct version (=3) */
structVersion uint8
/*
* Checksum of response and data; sum of all bytes including checksum
* should total to 0.
*/
checksum uint8
/* Result code (ecRes_*) */
result uint16
/* Length of data which follows this header */
dataLen uint16
/* Unused bytes in current protocol version; set to 0 */
reserved uint16
}
/*****************************************************************************/
/*
* Notes on commands:
*
* Each command is an 16-bit command value. Commands which take params or
* return response data specify structs for that data. If no struct is
* specified, the command does not input or output data, respectively.
* Parameter/response length is implicit in the structs. Some underlying
* communication protocols (I2C, SPI) may add length or checksum headers, but
* those are implementation-dependent and not defined here.
*/
/*****************************************************************************/
/* General / test commands */
/*
* Get protocol version, used to deal with non-backward compatible protocol
* changes.
*/
const ecCmdProtoVersion = 0x00
/* TYPE */
type ecResponseProtoVersion struct {
version uint32
}
const (
/*
* Hello. This is a simple command to test the EC is responsive to
* commands.
*/
ecCmdHello = 0x01
)
/* TYPE */
type ecParamsHello struct {
inData uint32 /* Pass anything here */
}
/* TYPE */
type ecResponseHello struct {
outData uint32 /* Output will be inData + 0x01020304 */
}
const (
/* Get version number */
ecCmdGetVersion = 0x02
)
type ecCurrentImage uint8
const (
ecImageUnknown ecCurrentImage = 0
ecImageRo
ecImageRw
)
/* TYPE */
type ecResponseGetVersion struct {
/* Null-terminated version strings for RO, RW */
versionStringRo [32]byte
versionStringRw [32]byte
reserved [32]byte /* Was previously RW-B string */
currentImage uint32 /* One of ecCurrentImage */
}
const (
/* Read test */
ecCmdReadTest = 0x03
)
/* TYPE */
type ecParamsReadTest struct {
offset uint32 /* Starting value for read buffer */
size uint32 /* Size to read in bytes */
}
/* TYPE */
type ecResponseReadTest struct {
data [32]uint32
}
const (
/*
* Get build information
*
* Response is null-terminated string.
*/
ecCmdGetBuildInfo = 0x04
/* Get chip info */
ecCmdGetChipInfo = 0x05
)
/* TYPE */
type ecResponseGetChipInfo struct {
/* Null-terminated strings */
vendor [32]byte
name [32]byte
revision [32]byte /* Mask version */
}
const (
/* Get board HW version */
ecCmdGetBoardVersion = 0x06
)
/* TYPE */
type ecResponseBoardVersion struct {
boardVersion uint16 /* A monotonously incrementing number. */
}
/*
* Read memory-mapped data.
*
* This is an alternate interface to memory-mapped data for bus protocols
* which don't support direct-mapped memory - I2C, SPI, etc.
*
* Response is params.size bytes of data.
*/
const (
ecCmdReadMemmap = 0x07
)
/* TYPE */
type ecParamsReadMemmap struct {
offset uint8 /* Offset in memmap (ecMemmap_*) */
size uint8 /* Size to read in bytes */
}
/* Read versions supported for a command */
const ecCmdGetCmdVersions = 0x08
/* TYPE */
type ecParamsGetCmdVersions struct {
cmd uint8 /* Command to check */
}
/* TYPE */
type ecParamsGetCmdVersionsV1 struct {
cmd uint16 /* Command to check */
}
/* TYPE */
type ecResponseGetCmdVersions struct {
/*
* Mask of supported versions; use ecVerMask() to compare with a
* desired version.
*/
versionMask uint32
}
/*
* Check EC communcations status (busy). This is needed on i2c/spi but not
* on lpc since it has its own out-of-band busy indicator.
*
* lpc must read the status from the command register. Attempting this on
* lpc will overwrite the args/parameter space and corrupt its data.
*/
const ecCmdGetCommsStatus = 0x09
/* Avoid using ecStatus which is for return values */
type ecCommsStatus uint8
const (
ecCommsStatusProcessing ecCommsStatus = 1 << 0 /* Processing cmd */
)
/* TYPE */
type ecResponseGetCommsStatus struct {
flags uint32 /* Mask of enum ecCommsStatus */
}
const (
/* Fake a variety of responses, purely for testing purposes. */
ecCmdTestProtocol = 0x0a
)
/* TYPE */
/* Tell the EC what to send back to us. */
type ecParamsTestProtocol struct {
ecResult uint32
retLen uint32
buf [32]uint8
}
/* TYPE */
/* Here it comes... */
type ecResponseTestProtocol struct {
buf [32]uint8
}
/* Get prococol information */
const ecCmdGetProtocolInfo = 0x0b
/* Flags for ecResponseGetProtocolInfo.flags */
/* ecResInProgress may be returned if a command is slow */
const ecProtocolInfoInProgressSupported = (1 << 0)
/* TYPE */
type ecResponseGetProtocolInfo struct {
/* Fields which exist if at least protocol version 3 supported */
/* Bitmask of protocol versions supported (1 << n means version n)*/
protocolVersions uint32
/* Maximum request packet size, in bytes */
maxRequestPacketSize uint16
/* Maximum response packet size, in bytes */
maxResponsePacketSize uint16
/* Flags; see ecProtocolInfo_* */
flags uint32
}
/*****************************************************************************/
/* Get/Set miscellaneous values */
const (
/* The upper byte of .flags tells what to do (nothing means "get") */
ecGsvSet = 0x80000000
/* The lower three bytes of .flags identifies the parameter, if that has
meaning for an individual command. */
ecGsvParamMask = 0x00ffffff
)
/* TYPE */
type ecParamsGetSetValue struct {
flags uint32
value uint32
}
/* TYPE */
type ecResponseGetSetValue struct {
flags uint32
value uint32
}
/* More than one command can use these structs to get/set parameters. */
const ecCmdGsvPauseInS5 = 0x0c
/*****************************************************************************/
/* Flash commands */
/* Get flash info */
const ecCmdFlashInfo = 0x10
/* TYPE */
/* Version 0 returns these fields */
type ecResponseFlashInfo struct {
/* Usable flash size, in bytes */
flashSize uint32
/*
* Write block size. Write offset and size must be a multiple
* of this.
*/
writeBlockSize uint32
/*
* Erase block size. Erase offset and size must be a multiple
* of this.
*/
eraseBlockSize uint32
/*
* Protection block size. Protection offset and size must be a
* multiple of this.
*/
protectBlockSize uint32
}
/* Flags for version 1+ flash info command */
/* EC flash erases bits to 0 instead of 1 */
const ecFlashInfoEraseTo0 = (1 << 0)
/* TYPE */
/*
* Version 1 returns the same initial fields as version 0, with additional
* fields following.
*
* gcc anonymous structs don't seem to get along with the directive;
* if they did we'd define the version 0 struct as a sub-struct of this one.
*/
type ecResponseFlashInfo1 struct {
/* Version 0 fields; see above for description */
flashSize uint32
writeBlockSize uint32
eraseBlockSize uint32
protectBlockSize uint32
/* Version 1 adds these fields: */
/*
* Ideal write size in bytes. Writes will be fastest if size is
* exactly this and offset is a multiple of this. For example, an EC
* may have a write buffer which can do half-page operations if data is
* aligned, and a slower word-at-a-time write mode.
*/
writeIdealSize uint32
/* Flags; see ecFlashInfo_* */
flags uint32
}
/*
* Read flash
*
* Response is params.size bytes of data.
*/
const ecCmdFlashRead = 0x11
/* TYPE */
type ecParamsFlashRead struct {
offset uint32 /* Byte offset to read */
size uint32 /* Size to read in bytes */
}
const (
/* Write flash */
ecCmdFlashWrite = 0x12
ecVerFlashWrite = 1
/* Version 0 of the flash command supported only 64 bytes of data */
ecFlashWriteVer0Size = 64
)
/* TYPE */
type ecParamsFlashWrite struct {
offset uint32 /* Byte offset to write */
size uint32 /* Size to write in bytes */
/* Followed by data to write */
}
/* Erase flash */
const ecCmdFlashErase = 0x13
/* TYPE */
type ecParamsFlashErase struct {
offset uint32 /* Byte offset to erase */
size uint32 /* Size to erase in bytes */
}
const (
/*
* Get/set flash protection.
*