Linux操作系统, 构建自己的内核——6.使用调色板绘制系统界面

﹏ヽ暗。殇╰゛Y 2024-04-18 15:32 125阅读 0赞

学习课程：
使用调色板绘制系统界面

在上一课程中，通过往0xA0000-0xAFFFF共64KB的的显存空间写入0-255的字符，来绘制界面。
0-255表示的颜色非常有限，画出来的效果很单调。利用调色板功能，能够绘制出更丰富的图案。

使用调色板功能时，显存空间的每个字符不再表示颜色，而是表示颜色的下标。
真正的颜色存储在一个数组中。因为一个字节最大只能表示到255，所以，表示颜色的数组最大也只能255。
在表示颜色的数组中，使用RGB方法表示颜色，每种颜色用3个字节表示，分别对应red，green，blue。
要打开调色板功能，和写入表示颜色的数组，都需要与硬件的端口打交道。

1. 使用调色板

kernel.asm

  1. %include "pm.inc"
  3. org   0x9000
  5. VRAM_ADDRESS  equ  0x000a0000
  7. jmp   LABEL_BEGIN
  9. [SECTION .gdt]
  10.  ;                                  段基址          段界限                属性
  11. LABEL_GDT:          Descriptor        0,            0,                   0
  12. LABEL_DESC_CODE32:  Descriptor        0,      SegCode32Len - 1,       DA_C + DA_32
  13. LABEL_DESC_VRAM:    Descriptor        0,         0ffffffffh,            DA_DRW
  14. LABEL_DESC_STACK:   Descriptor        0,             TopOfStack,        DA_DRWA+DA_32
  16. GdtLen     equ    $ - LABEL_GDT
  17. GdtPtr     dw     GdtLen - 1
  18.            dd     0
  20. SelectorCode32    equ   LABEL_DESC_CODE32 -  LABEL_GDT
  21. SelectorStack     equ   LABEL_DESC_STACK  -  LABEL_GDT
  22. SelectorVram      equ   LABEL_DESC_VRAM   -  LABEL_GDT
  25. [SECTION  .s16]
  26. [BITS  16]
  27. LABEL_BEGIN:
  28.      mov   ax, cs
  29.      mov   ds, ax
  30.      mov   es, ax
  31.      mov   ss, ax
  32.      mov   sp, 0100h
  34.      mov   al, 0x13
  35.      mov   ah, 0
  36.      int   0x10
  38.      xor   eax, eax
  39.      mov   ax,  cs
  40.      shl   eax, 4
  41.      add   eax, LABEL_SEG_CODE32
  42.      mov   word [LABEL_DESC_CODE32 + 2], ax
  43.      shr   eax, 16
  44.      mov   byte [LABEL_DESC_CODE32 + 4], al
  45.      mov   byte [LABEL_DESC_CODE32 + 7], ah
  47.      xor   eax, eax
  48.      mov   ax,  cs
  49.      shl   eax, 4
  50.      add   eax, LABEL_STACK
  51.      mov   word [LABEL_DESC_STACK + 2], ax
  52.      shr   eax, 16
  53.      mov   byte [LABEL_DESC_STACK + 4], al
  54.      mov   byte [LABEL_DESC_STACK + 7], ah
  56.      xor   eax, eax
  57.      mov   ax, ds
  58.      shl   eax, 4
  59.      add   eax,  LABEL_GDT
  60.      mov   dword  [GdtPtr + 2], eax
  62.      lgdt  [GdtPtr]
  64.      cli   ;关中断
  66.      in    al,  92h
  67.      or    al,  00000010b
  68.      out   92h, al
  70.      mov   eax, cr0
  71.      or    eax , 1
  72.      mov   cr0, eax
  74.      jmp   dword  SelectorCode32: 0
  76.      [SECTION .s32]
  77.      [BITS  32]
  78.      LABEL_SEG_CODE32:
  79.      ;initialize stack for c code
  80.      mov  ax, SelectorStack
  81.      mov  ss, ax
  82.      mov  esp, TopOfStack
  84.      mov  ax, SelectorVram
  85.      mov  ds,  ax
  87. C_CODE_ENTRY:
  88.      %include "palette1.asm"
  91.     io_hlt:  ;void io_hlt(void);
  92.       HLT
  93.       RET
  95. io_in8:
  96.       mov  edx, [esp + 4]
  97.       mov  eax, 0
  98.       in   al, dx
  100.     io_in16:
  101.       mov  edx, [esp + 4]
  102.       mov  eax, 0
  103.       in   ax, dx
  105.     io_in32:
  106.       mov edx, [esp + 4]
  107.       in  eax, dx
  108.       ret
  110.     io_out8:
  111.        mov edx, [esp + 4]
  112.        mov al, [esp + 8]
  113.        out dx, al
  114.        ret
  116.     io_out16:
  117.        mov edx, [esp + 4]
  118.        mov eax, [esp + 8]
  119.        out dx, ax
  120.        ret
  122.     io_out32:
  123.         mov edx, [esp + 4]
  124.         mov eax, [esp + 8]
  125.         out dx, eax
  126.         ret
  128.     io_cli:
  129.       CLI
  130.       RET
  131.     io_load_eflags:
  132.         pushfd
  133.         pop  eax
  134.         ret
  136.     io_store_eflags:
  137.         mov eax, [esp + 4]
  138.         push eax
  139.         popfd
  140.         ret
  144. SegCode32Len   equ  $ - LABEL_SEG_CODE32
  146. [SECTION .gs]
  147. ALIGN 32
  148. [BITS 32]
  149. LABEL_STACK:
  150. times 512  db 0
  151. TopOfStack  equ  $ - LABEL_STACK

操作端口的这几个汇编函数，是很不错的封装，简化了在c语言中的使用。
可以看出来,
[esp+4]表示函数的第一个参数
[esp+8]表示函数的第二个参数

那便有一个疑问，[esp]表示的是什么呢？
esp表示的是上一个函数的返回地址。也就是这个函数执行完成之后，要执行的下一条指令。
而参数是按照从右向左的方式入栈的，所以取的时候，esp+4的位置便取到的是第一个参数。

write_vga.asm

  1. ; Disassembly of file: write_vga.o
  2. ; Sun Sep  8 06:05:48 2019
  3. ; Mode: 32 bits
  4. ; Syntax: YASM/NASM
  5. ; Instruction set: 80386
  12. CMain:  ; Function begin
  13.         push    ebp                                     ; 0000 _ 55
  14.         mov     ebp, esp                                ; 0001 _ 89. E5
  15.         sub     esp, 24                                 ; 0003 _ 83. EC, 18
  16.         mov     dword [ebp-0CH], 0                      ; 0006 _ C7. 45, F4, 00000000
  17.         call    init_palette                            ; 000D _ E8, FFFFFFFC(rel)
  18.         mov     dword [ebp-10H], 655360                 ; 0012 _ C7. 45, F0, 000A0000
  19.         jmp     ?_002                                   ; 0019 _ EB, 17
  21. ?_001:  mov     eax, dword [ebp-10H]                    ; 001B _ 8B. 45, F0
  22.         mov     dword [ebp-0CH], eax                    ; 001E _ 89. 45, F4
  23.         mov     eax, dword [ebp-10H]                    ; 0021 _ 8B. 45, F0
  24.         and     eax, 0FH                                ; 0024 _ 83. E0, 0F
  25.         mov     edx, eax                                ; 0027 _ 89. C2
  26.         mov     eax, dword [ebp-0CH]                    ; 0029 _ 8B. 45, F4
  27.         mov     byte [eax], dl                          ; 002C _ 88. 10
  28.         add     dword [ebp-10H], 1                      ; 002E _ 83. 45, F0, 01
  29. ?_002:  cmp     dword [ebp-10H], 720895                 ; 0032 _ 81. 7D, F0, 000AFFFF
  30.         jle     ?_001                                   ; 0039 _ 7E, E0
  31. ?_003:  call    io_hlt                                  ; 003B _ E8, FFFFFFFC(rel)
  32.         jmp     ?_003                                   ; 0040 _ EB, F9
  33. ; CMain End of function
  35. init_palette:; Function begin
  36.         push    ebp                                     ; 0042 _ 55
  37.         mov     ebp, esp                                ; 0043 _ 89. E5
  38.         sub     esp, 24                                 ; 0045 _ 83. EC, 18
  39.         mov     dword [esp+8H], table_rgb.1397          ; 0048 _ C7. 44 24, 08, 00000000(d)
  40.         mov     dword [esp+4H], 15                      ; 0050 _ C7. 44 24, 04, 0000000F
  41.         mov     dword [esp], 0                          ; 0058 _ C7. 04 24, 00000000
  42.         call    set_palette                             ; 005F _ E8, FFFFFFFC(rel)
  43.         nop                                             ; 0064 _ 90
  44.         leave                                           ; 0065 _ C9
  45.         ret                                             ; 0066 _ C3
  46. ; init_palette End of function
  48. set_palette:; Function begin
  49.         push    ebp                                     ; 0067 _ 55
  50.         mov     ebp, esp                                ; 0068 _ 89. E5
  51.         sub     esp, 40                                 ; 006A _ 83. EC, 28
  52.         call    io_load_eflags                          ; 006D _ E8, FFFFFFFC(rel)
  53.         mov     dword [ebp-0CH], eax                    ; 0072 _ 89. 45, F4
  54.         call    io_cli                                  ; 0075 _ E8, FFFFFFFC(rel)
  55.         mov     eax, dword [ebp+8H]                     ; 007A _ 8B. 45, 08
  56.         mov     dword [esp+4H], eax                     ; 007D _ 89. 44 24, 04
  57.         mov     dword [esp], 968                        ; 0081 _ C7. 04 24, 000003C8
  58.         call    io_out8                                 ; 0088 _ E8, FFFFFFFC(rel)
  59.         mov     eax, dword [ebp+8H]                     ; 008D _ 8B. 45, 08
  60.         mov     dword [ebp-10H], eax                    ; 0090 _ 89. 45, F0
  61.         jmp     ?_005                                   ; 0093 _ EB, 59
  63. ?_004:  mov     eax, dword [ebp+10H]                    ; 0095 _ 8B. 45, 10
  64.         movzx   eax, byte [eax]                         ; 0098 _ 0F B6. 00
  65.         movzx   eax, al                                 ; 009B _ 0F B6. C0
  66.         mov     dword [esp+4H], eax                     ; 009E _ 89. 44 24, 04
  67.         mov     dword [esp], 969                        ; 00A2 _ C7. 04 24, 000003C9
  68.         call    io_out8                                 ; 00A9 _ E8, FFFFFFFC(rel)
  69.         mov     eax, dword [ebp+10H]                    ; 00AE _ 8B. 45, 10
  70.         add     eax, 1                                  ; 00B1 _ 83. C0, 01
  71.         movzx   eax, byte [eax]                         ; 00B4 _ 0F B6. 00
  72.         movzx   eax, al                                 ; 00B7 _ 0F B6. C0
  73.         mov     dword [esp+4H], eax                     ; 00BA _ 89. 44 24, 04
  74.         mov     dword [esp], 969                        ; 00BE _ C7. 04 24, 000003C9
  75.         call    io_out8                                 ; 00C5 _ E8, FFFFFFFC(rel)
  76.         mov     eax, dword [ebp+10H]                    ; 00CA _ 8B. 45, 10
  77.         add     eax, 2                                  ; 00CD _ 83. C0, 02
  78.         movzx   eax, byte [eax]                         ; 00D0 _ 0F B6. 00
  79.         movzx   eax, al                                 ; 00D3 _ 0F B6. C0
  80.         mov     dword [esp+4H], eax                     ; 00D6 _ 89. 44 24, 04
  81.         mov     dword [esp], 969                        ; 00DA _ C7. 04 24, 000003C9
  82.         call    io_out8                                 ; 00E1 _ E8, FFFFFFFC(rel)
  83.         add     dword [ebp+10H], 3                      ; 00E6 _ 83. 45, 10, 03
  84.         add     dword [ebp-10H], 1                      ; 00EA _ 83. 45, F0, 01
  85. ?_005:  mov     eax, dword [ebp-10H]                    ; 00EE _ 8B. 45, F0
  86.         cmp     eax, dword [ebp+0CH]                    ; 00F1 _ 3B. 45, 0C
  87.         jle     ?_004                                   ; 00F4 _ 7E, 9F
  88.         mov     eax, dword [ebp-0CH]                    ; 00F6 _ 8B. 45, F4
  89.         mov     dword [esp], eax                        ; 00F9 _ 89. 04 24
  90.         call    io_store_eflags                         ; 00FC _ E8, FFFFFFFC(rel)
  91.         nop                                             ; 0101 _ 90
  92.         leave                                           ; 0102 _ C9
  93.         ret                                             ; 0103 _ C3
  94. ; set_palette End of function
  98. table_rgb.1397:                                         ; byte
  99.         db 00H, 00H, 00H, 0FFH, 00H, 00H, 00H, 0FFH     ; 0000 _ ........
  100.         db 00H, 0FFH, 0FFH, 00H, 00H, 00H, 0FFH, 0FFH   ; 0008 _ ........
  101.         db 00H, 0FFH, 00H, 0FFH, 0FFH, 0FFH, 0FFH, 0FFH ; 0010 _ ........
  102.         db 0C6H, 0C6H, 0C6H, 84H, 00H, 00H, 00H, 84H    ; 0018 _ ........
  103.         db 00H, 84H, 84H, 00H, 00H, 00H, 84H, 84H       ; 0020 _ ........
  104.         db 00H, 84H, 00H, 84H, 84H, 84H, 84H, 84H       ; 0028 _ ........

效果：
在这里插入图片描述

2. 绘制矩形&绘制桌面

都是调色板的具体应用而已，没有新的知识点。

发表评论

表情：
评论列表 （有 0 条评论，125人围观）

还没有评论，来说两句吧...

相关阅读