1.. SPDX-License-Identifier: GPL-2.0+ 2 3.. include:: ../disclaimer-zh_CN.rst 4 5:Original: Documentation/core-api/packing.rst 6 7:������: 8 9 ��������� Binbin Zhou <zhoubinbin@loongson.cn> 10 11:������: 12 13 ��������� Yanteng Si <siyanteng@loongson.cn> 14 ��������� Wu Xiangcheng <bobwxc@email.cn> 15 ��������� Alex Shi <alexs@kernel.org> 16 17======================== 18������������������������������������ 19======================== 20 21������������ 22-------- 23 24��������������������������������������������������������������������������� 25 26������������������������������������������������������������������������������������������������������������������������ 27������������������������������������������CPU��������������������������������������������������������������������������� 28��������������������������������� 29 30��������������������������������������������������������������������������������������������������������������������� 31������������������������������������������������������������������������������������64��������������������������������� 32��������������������������������������������������������������������������������������������������������������������� 33 34������������������������������������������������������������������������������������������������������������������������ 35������������������������������������������������������������������������������������������������������������������������ 36��������������������������������������������������������������������������������������� 37 38������������������������������������������������������������������������������������������������������������������������ 39������������������������������������������������������������������������������ 40 41������������ 42-------- 43 44���API������2������������������ 45 46 - ���������CPU������������������������������������������������������������������/��������������� 47 - ���������������������������������������/������������������������������CPU��������������������� 48 49���API������������������������������������������������CPU������������������������������������������������������������ 50 51������API������������������������u64������CPU���������������������63���������������������7���������������7��������� 52������������������������������������������������������������������������������������ 53 54���������������������������u64���������������������������������������������������������������������������0���1...7��� 55������������������������������������������������������ 56 571. ��������������������������������������������������������� 58 59:: 60 61 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 62 7 6 5 4 63 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 64 3 2 1 0 65 66���������������CPU������������u64���MSByte(7)���������������������0���������u64���LSByte(0)���������������������7������ 67 68���������������������������������������������������������i���������������2^i������������������������������������������������������ 69 70 712. ���������������QUIRK_MSB_ON_THE_RIGHT��������������������������������� 72 73:: 74 75 56 57 58 59 60 61 62 63 48 49 50 51 52 53 54 55 40 41 42 43 44 45 46 47 32 33 34 35 36 37 38 39 76 7 6 5 4 77 24 25 26 27 28 29 30 31 16 17 18 19 20 21 22 23 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 78 3 2 1 0 79 80���������������QUIRK_MSB_ON_THE_RIGHT������������������������������������������������������������������ 81 82 833. ���������������QUIRK_LITTLE_ENDIAN��������������������������������� 84 85:: 86 87 39 38 37 36 35 34 33 32 47 46 45 44 43 42 41 40 55 54 53 52 51 50 49 48 63 62 61 60 59 58 57 56 88 4 5 6 7 89 7 6 5 4 3 2 1 0 15 14 13 12 11 10 9 8 23 22 21 20 19 18 17 16 31 30 29 28 27 26 25 24 90 0 1 2 3 91 92���������QUIRK_LITTLE_ENDIAN������������������������������������4��������������������������������������������� 93��������������������������������������� 94 95 964. ���������������QUIRK_MSB_ON_THE_RIGHT���QUIRK_LITTLE_ENDIAN��������������������� 97 98:: 99 100 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 101 4 5 6 7 102 0 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 103 0 1 2 3 104 105 1065. ������������������QUIRK_LSW32_IS_FIRST��������������������� 107 108:: 109 110 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 111 3 2 1 0 112 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 113 7 6 5 4 114 115���������������������8������������������������������������4���������������������������4������������������4������������ 116������������4��������������� 117 1186. ���������������QUIRK_LSW32_IS_FIRST���QUIRK_MSB_ON_THE_RIGHT��������������������� 119 120:: 121 122 24 25 26 27 28 29 30 31 16 17 18 19 20 21 22 23 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 123 3 2 1 0 124 56 57 58 59 60 61 62 63 48 49 50 51 52 53 54 55 40 41 42 43 44 45 46 47 32 33 34 35 36 37 38 39 125 7 6 5 4 126 127 1287. ���������������QUIRK_LSW32_IS_FIRST���QUIRK_LITTLE_ENDIAN��������������������� 129 130:: 131 132 7 6 5 4 3 2 1 0 15 14 13 12 11 10 9 8 23 22 21 20 19 18 17 16 31 30 29 28 27 26 25 24 133 0 1 2 3 134 39 38 37 36 35 34 33 32 47 46 45 44 43 42 41 40 55 54 53 52 51 50 49 48 63 62 61 60 59 58 57 56 135 4 5 6 7 136 137 1388. ���������������QUIRK_LSW32_IS_FIRST���QUIRK_LITTLE_ENDIAN���QUIRK_MSB_ON_THE_RIGHT��� 139 ������������������ 140 141:: 142 143 0 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 144 0 1 2 3 145 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 146 4 5 6 7 147 148 149������������������������������������������������������������������������������������������������������������ 150 151������������ 152-------- 153 154���������������API���������������������������������������3���quirk������������8������������������������������������ 155���������������������������������������������������packing()���������������������������xxx_packing()��������� 156���������QUIRK_* one-hot ������������������������ 157 158packing()������������������int���������������������������������������������������������API������������������������ 159������������������������������xxx_packing()������void������������������������������������������������������������ 160��������������������������������� 161