用网络卡从并口上启动Linux（I386）

雪中独行

看到好文章为什么不能拿过来跟这里的朋友分享呢？

出自：http://www.linuxforum.net
作者：raoxianhong

1. 
   
2. 1、到底想干什么
   
3.    了解Linux的启动过程，制作一个自己的Linux启动程序，可以增加对Linux的了解，
   
4. 还能学习PC机的启动机制，增进对计算机结构的了解，增强对Linux内核学习的信心。
   
5. 也可以在某些专用产品中使用（比如专用的服务器）。为此，我尝试在原来代码的基础
   
6. 上修改制作了一个用网络卡从并口上启动Linux的程序，以博一笑，其中有许多问题值得研究。
   
7. 2、Linux对启动程序的要求
   
8.    Linux（bzImage Kernel）对启动程序的要求比较简单，你只要能够建立一个启动头（setup.S），
   
9. 给出一些信息，然后将kernel(/usr/src/linux/arch/i386/boot/compressed/bvmlinux.out)调到
   
10. 绝对地址0x100000(1M地址处)，如果有initrd，则将它调到内存高端（离0x100000越远越好,比如如果
    
11. initrd小于4M，就可以将它调到地址0xB00000，即12M处，相信现在已经很少有少于16M内存的机器了），
    
12. 然后执行一些初始化操作，跳到内核处就行了。
    
13.    当然，说起来容易做起来还有点麻烦，以下分几个问题解释。
    
14. 3、PC机开机流程--启动程序放在何处
    
15.    PC机加电后，进入实模式，先进行自检，然后初始化各个总线扩展设备（ISA, EISA，PCI，AGP），
    
16. 全部初始化做完后，从当前启动设备中读一个块（512字节）到07C0:0000处，将控制转到该处。
    
17.    了解这个过程，我们可以决定将启动程序放在何处：
    
18.       1）放在启动设备的MBR(主启动记录中)，比如磁盘的启动扇区。这是一般的启动方式。
    
19.       2）放在总线扩展设备的扩展rom中，比如网卡的boot rom就行，这里制作的启动程序就是放在网卡中,可以支持
    
20.           16K字节。
    
21.       3）哪位高手能够修改ROMBIOS，让BIOS在做完初始化后不要马上从启动设备读数据，而是调用一段外面
    
22.           加入的程序（2K字节就够了，当然也必须与修改后的BIOS一起烧在BIOS ROM中)，就可以从BIOS启动！
    
23.       4）先启动一个操作系统，再在此操作系统中写启动程序（比如lodlin16就是从DOS中启动Linux，好象中软
    
24.          提供了一个从Windows下启动Linux的启动程序）。
    
25. 4、操作系统放在何处
    
26.    操作系统（一般内核在500K-1M之间，加上应用程序可以控制在2M以内，当然都经过压缩了）的数据选择余地就大了，
    
27. 可以从软盘、硬盘、CDROM、网络、磁带机、并口（软件狗上烧个内核和应用程序？）、串口（外接你的设备）、
    
28. USB设备（？）、PCI扩展卡、IC卡等等上面来读；各位还有什么意见，提醒提醒。有位老兄说实在不行可以用键盘启动，
    
29. 每次启动时把内核敲进去，还有int 16h支持呢，做起来也不难，应该是最节省的方案了。
    
30.    反正一个原则是，在启动程序中能够从该设备上读就行了，这里最简单的就是并口了，简单的端口操作，不需
    
31. 要任何驱动程序支持，不需要BIOS支持，比磁盘还简单(磁盘一般使用int 13h,主要是计算柱面啊、磁头啊、磁道啊、
    
32. 扇区啊好麻烦，幸好有现成的源代码，可以学习学习)。
    
33.    好了，我们挑个简单的方案，将启动代码（bootsect.S+setup.S）放到网络卡的boot rom中，内核数据和应用数据放
    
34. 到另外一台计算机上，用并口提供。下面谈谈几个相关的问题。
    
35. 5、将数据移动到绝对地址处
    
36.    第一个问题，我们得到数据，因为是在实模式下，所以一般是放在1M地址空间内，怎样将它移动到指定的地方去，
    
37. 在setup.S 的源代码中，使用了int 15h（87h号功能）。这里将该段代码稍加改动,做了些假设，列到下面：
    
38. 流程是：
    
39.         if (%cs:move_es==0)/*由于使用前move_es初始化为0，因此这是第一次调用，此时es:bx是要移动的数据
    
40.                                 存放处bx=0,es低四为位为零表示es:bx在64K边界上，fs的低8位指定目的地地址，
    
41.                                 也以64K字节为单位，用不着那么精确，以简化操作*/
    
42.         {
    
43.                 将es右移四位，得到64K单位的8位地址（这样一来，最多只能将数据移动到16M以下了），作为源数据
    
44.                 描述符中24位地址的高8位，低16位为零。
    
45.                 将fs的低8位作为目的地的描述符中24位地址的高8位，同样，它的低16位为零。
    
46.                 将es存放在move_es中，es自然不会是零，因此以后再调用该例程时就进行正常的移动操作了。
    
47.                 ax清零返回。
    
48.         }
    
49.         else
    
50.         {
    
51.                 if (bx==0)/*bx为零，表示数据已经满64K了，应该进行实际的移动*/
    
52.                 {       
    
53.                         调用int15h 87h号功能，进行实际的数据移动（64K, 0x8000个16字节块）。
    
54.                         目的地址（24位）高8位增一，往后走64K
    
55.                         ax = 1
    
56.                         return;
    
57.                 }
    
58.                 else
    
59.                 {
    
60.                         ax = 0;
    
61.                         return;
    
62.                 }
    
63.         }
    
64. 
    
65. 
    
66. # we will move %cx bytes from es:bx to %fs(64Kbytes per unit)
    
67. # when we first call movetohigh(%cs:move_es is zero),
    
68. # the es:bx and %edx is valid
    
69. # we configure the param first
    
70. # follow calls will move data actually
    
71. # %ax return 0 if no data really moved, and return 1 if there is data
    
72. # really to be moved
    
73. #
    
74. movetohigh:
    
75.         cmpw        $0, %cs:move_es
    
76.         jnz        move_second
    
77. 
    
78.         # at this point , es:bx(bx = 0) is the source address
    
79.         # %edx is the destination address
    
80. 
    
81.         movb        $0x20, %cs:type_of_loader
    
82.         movw        %es, %ax
    
83.         shrw        $4, %ax
    
84.         movb        %ah, %cs:move_src_base+2
    
85.         movw        %fs, %ax
    
86.         movb        %al, %cs:move_dst_base+2
    
87.         movw        %es, %ax
    
88.         movw        %ax, %cs:move_es
    
89.         xorw        %ax, %ax
    
90.         ret                                        # nothing else to do for now
    
91. 
    
92. move_second:
    
93.         xorw        %ax, %ax
    
94.         testw        %bx, %bx
    
95.         jne        move_ex
    
96.         pushw        %ds       
    
97.         pushw        %cx
    
98.         pushw        %si
    
99.         pushw        %bx
    
100. 
     
101.         movw        $0x8000, %cx                        # full 64K, INT15 moves words
     
102.         pushw        %cs
     
103.         popw        %es
     
104.         leaw        %cs:move_gdt, %si
     
105.         movw        $0x8700, %ax
     
106.         int        $0x15
     
107.         jc        move_panic                        # this, if INT15 fails
     
108. 
     
109.         movw        %cs:move_es, %es                # we reset %es to always point
     
110.         incb        %cs:move_dst_base+2                # to 0x10000
     
111.         popw        %bx
     
112.         popw        %si
     
113.         popw        %cx
     
114.         popw        %ds
     
115.         movw        $1, %ax
     
116. move_ex:
     
117.         ret
     
118. 
     
119. move_gdt:
     
120.         .word        0, 0, 0, 0
     
121.         .word        0, 0, 0, 0
     
122. 
     
123. move_src:
     
124.         .word        0xffff
     
125. 
     
126. move_src_base:
     
127.         .byte        0x00, 0x00, 0x01                # base = 0x010000
     
128.         .byte        0x93                                # typbyte
     
129.         .word        0                                # limit16,base24 =0
     
130. 
     
131. move_dst:
     
132.         .word        0xffff
     
133. 
     
134. move_dst_base:
     
135.         .byte        0x00, 0x00, 0x10                # base = 0x100000
     
136.         .byte        0x93                                # typbyte
     
137.         .word        0                                # limit16,base24 =0
     
138.         .word        0, 0, 0, 0                        # BIOS CS
     
139.         .word        0, 0, 0, 0                        # BIOS DS
     
140. 
     
141. move_es:
     
142.         .word        0
     
143. 
     
144. move_panic:
     
145.         pushw        %cs
     
146.         popw        %ds
     
147.         cld
     
148.         leaw        move_panic_mess, %si
     
149.         call        prtstr
     
150.        
     
151. move_panic_loop:
     
152.         jmp        move_panic_loop
     
153. 
     
154. move_panic_mess:
     
155.         .string        "INT15 refuses to access high mem, giving up."
     
156. 
     
157. 
     
158. 6、用并口传输数据
     
159.    用并口传输数据，可以从/usr/src/linux/driver/net/plip.c中抄一段，我们采用半字节协议，
     
160. 并口线连接参考该文件。字节收发过程如下：
     
161. 
     
162. #define PORT_BASE                0x378
     
163. 
     
164. #define data_write(b) outportb(PORT_BASE, b)
     
165. #define data_read() inportb(PORT_BASE+1)
     
166. 
     
167. #define OK                        0
     
168. #define TIMEOUT                        1
     
169. #define FAIL                        2
     
170. 
     
171. int sendbyte(unsigned char data)
     
172. {
     
173.         unsigned char c0;
     
174.         unsigned long cx;
     
175. 
     
176.         data_write((data & 0x0f));
     
177.         data_write((0x10 | (data & 0x0f)));
     
178.         cx = 32767l * 1024l;
     
179.         while (1) {
     
180.                 c0 = data_read();
     
181.                 if ((c0 & 0x80) == 0)
     
182.                         break;
     
183.                 if (--cx == 0)
     
184.                         return TIMEOUT;
     
185.         }
     
186.         data_write(0x10 | (data >;>; 4));
     
187.         data_write((data >;>; 4));
     
188.         cx = 32767l * 1024l;
     
189.         while (1) {
     
190.                 c0 = data_read();
     
191.                 if (c0 & 0x80)
     
192.                         break;
     
193.                 if (--cx == 0)
     
194.                         return TIMEOUT;
     
195.         }
     
196.         return OK;
     
197. }
     
198. 
     
199. int rcvbyte(unsigned char * pByte)
     
200. {
     
201.         unsigned char c0, c1;
     
202.         unsigned long cx;
     
203. 
     
204.         cx = 32767l * 1024l;
     
205.         while (1) {
     
206.                 c0 = data_read();
     
207.                 if ((c0 & 0x80) == 0) {
     
208.                         c1 = data_read();
     
209.                         if (c0 == c1)
     
210.                                 break;
     
211.                 }
     
212.                 if (--cx == 0)
     
213.                         return TIMEOUT;
     
214.         }
     
215.         *pByte = (c0 >;>; 3) & 0x0f;
     
216.         data_write(0x10); /* send ACK */
     
217.         cx = 32767l * 1024l;
     
218.         while (1) {
     
219.                 c0 = data_read();
     
220.                 if (c0 & 0x80) {
     
221.                         c1 = data_read();
     
222.                         if (c0 == c1)
     
223.                                 break;
     
224.                 }
     
225.                 if (--cx == 0)
     
226.                         return TIMEOUT;
     
227.         }
     
228.         *pByte |= (c0 << 1) & 0xf0;
     
229.         data_write(0x00); /* send ACK */
     
230.         return OK;
     
231. }
     
232. 
     
233. 为了能够在setup.S下收字符，特将字符接收子程序该为AT&T汇编语法
     
234. （也没有什么好办法，在DOS下用TURBO C 2.0将上述代码编译成汇编
     
235. 代码，然后手工转换成AT&T格式，据说有程序可以自动进行这样的转换，
     
236. 有谁用过请指教）：
     
237. 
     
238. rcvbyte:
     
239.         pushw        %bp
     
240.         movw        %sp, %bp
     
241.         subw        $6, %sp
     
242.         movw        $511, -2(%bp)
     
243.         movw        $-1024, -4(%bp)
     
244.         jmp        .L13
     
245. .L15:
     
246.         movw        $889, %dx
     
247.         inb        %dx, %al
     
248.         movb        %al, -6(%bp)
     
249.         testb        $128, -6(%bp)
     
250.         jne        .L16
     
251.         inb        %dx, %al
     
252.         movb        %al, -5(%bp)
     
253.         movb        -6(%bp), %al
     
254.         cmpb        -5(%bp), %al
     
255.         jne        .L17
     
256.         jmp        .L14
     
257. .L17:
     
258. .L16:
     
259.         subw        $1, -4(%bp)
     
260.         sbbw        $0, -2(%bp)
     
261.         movw        -2(%bp), %dx
     
262.         movw        -4(%bp), %ax
     
263.         orw        %ax, %dx
     
264.         jne        .L18
     
265.         movw        $1, %ax
     
266.         jmp        .L12
     
267. .L18:
     
268. .L13:
     
269.         jmp        .L15
     
270. .L14:
     
271.         movb        -6(%bp), %al
     
272.         shrb        $1, %al
     
273.         shrb        $1, %al
     
274.         shrb        $1, %al
     
275.         andb        $15, %al
     
276.         movw        4(%bp), %bx
     
277.         movb        %al, (%bx)
     
278.         movb        $16, %al
     
279.         movw        $888, %dx
     
280.         outb        %al, %dx
     
281.         movw        $511, -2(%bp)
     
282.         movw        $-1024, -4(%bp)
     
283.         jmp        .L19
     
284. .L21:
     
285.         movw        $889, %dx
     
286.         inb        %dx, %al  
     
287.         movb        %al, -6(%bp)
     
288.         testb        $128, %al
     
289.         je        .L22
     
290.         inb        %dx, %al
     
291.         movb        %al, -5(%bp)
     
292.         movb        -6(%bp), %al
     
293.         cmpb        -5(%bp), %al
     
294.         jne        .L23
     
295.         jmp        .L20
     
296. .L23:
     
297. .L22:
     
298.         subw        $1, -4(%bp)
     
299.         sbbw        $0, -2(%bp)
     
300.         movw        -2(%bp), %dx
     
301.         movw        -4(%bp), %ax
     
302.         orw        %ax, %dx
     
303.         jne        .L24
     
304.         movw        $1, %ax
     
305.         jmp        .L12
     
306. .L24:
     
307. .L19:
     
308.         jmp        .L21
     
309. .L20:       
     
310.         movb        -6(%bp), %al
     
311.         shlb        $1, %al
     
312.         andb        $240, %al
     
313.         movw        4(%bp), %bx
     
314.         orb        %al, (%bx)
     
315.         xorw        %ax, %ax
     
316.         movw        $888, %dx
     
317.         outb        %al, %dx
     
318.         jmp        .L12
     
319. .L12:
     
320.         movw        %bp, %sp
     
321.         popw        %bp
     
322.         ret
     
323. 
     
324. 能够收发字符还不行，作为协议，总得知道数据的起始和结束，也应该进行简单的检错。这里采用
     
325. 字符填充方式进行数据包编码，用‘\’表示转义字符，数据包头用\H表示，数据包结束用\T表示
     
326. 如果数据中有'\'，则用\\表示（从printf的格式串中学来的）,数据包后面跟一个字节的校验和，
     
327. 这样就可以收发数据包了，具体程序如下：
     
328. 
     
329. int rcvpack(unsigned char * pData, int * pLength)
     
330. {
     
331.         int ret;
     
332.         int length;
     
333.         unsigned char checksum;
     
334.         int maxlength;
     
335.         int status;
     
336.         maxlength = *pLength + 1;
     
337.         if (maxlength<=0)
     
338.                 return FAIL;
     
339.         if (pData == NULL)
     
340.                 return FAIL;
     
341.         checksum = 0;
     
342.         length = 0;
     
343.         status = 0;
     
344.         while (1)
     
345.         {
     
346.                 unsigned char ch;
     
347.                 int count;
     
348.                 count = 10;
     
349.                 while (1)
     
350.                 {
     
351.                 if ((ret = rcvbyte(&ch)) != OK)
     
352.                 {
     
353.                         count--;
     
354.                         if (count==0)
     
355.                         {
     
356.                                 printf("\nReceive byte timeout\n");
     
357.                                 return ret;
     
358.                         }
     
359.                 }
     
360.                         else
     
361.                                 break;
     
362.                 }
     
363.                 switch (status)
     
364.                 {
     
365.                         case 0:
     
366.                         {
     
367.                                 if (ch == '\\')
     
368.                                 {
     
369.                                         status = 1;
     
370.                                 }
     
371.                         }
     
372.                         break;
     
373.                         case 1:
     
374.                         {
     
375.                                 if (ch == 'H')
     
376.                                         status = 2;
     
377.                                 else
     
378.                                         status = 0;
     
379.                         }
     
380.                         break;
     
381.                         case 2:
     
382.                         {
     
383.                                 if (ch == '\\')
     
384.                                 {
     
385.                                         status = 3;
     
386.                                 }
     
387.                                 else
     
388.                                 {
     
389.                                         length ++;
     
390.                                         if (length>;maxlength)
     
391.                                         {
     
392.                                                 printf("Buffer overflow(%d>;%d)\n", length, maxlength);
     
393.                                                 return FAIL;
     
394.                                         }
     
395.                                         *pData++ = ch;
     
396.                                         checksum += ch;
     
397.                                 }
     
398.                         }
     
399.                         break;
     
400.                         case 3:
     
401.                         {
     
402.                                 if (ch == '\\')
     
403.                                 {
     
404.                                     length++;
     
405.                                     if (length>;maxlength)
     
406.                                     {
     
407.                                         printf("Buffer overflow (%d>;%d)\n", length, maxlength);
     
408.                                         return FAIL;
     
409.                                     }
     
410.                                     checksum += ch;
     
411.                                     *pData++ = ch;
     
412.                                     status = 2;
     
413.                                 }
     
414.                                 else
     
415.                                 if (ch =='T')
     
416.                                 {
     
417.                                         unsigned char chk;
     
418.                                         *pLength = length;
     
419.                                         if (rcvbyte(&chk)!=OK)
     
420.                                                 return FAIL;
     
421.                                         if (checksum==chk)
     
422.                                         {
     
423.                                                 return OK;
     
424.                                         }
     
425.                                         else
     
426.                                         {
     
427.                                                 printf("ERROR: Checksum is nozero(%d-%d)\n", checksum,chk);
     
428.                                                 return FAIL;
     
429.                                         }
     
430.                                 }
     
431.                                 else
     
432.                                 {
     
433.                                         printf("ERROR: a '\\' or 'T' expected('%c')!\n ", ch);
     
434.                                         return FAIL;
     
435.                                 }
     
436.                         }
     
437.                 }
     
438.         }
     
439. }
     
440. 
     
441. 
     
442. int sendpack(unsigned char * pData, int length)
     
443. {
     
444.         int ret;
     
445.         unsigned char checksum;
     
446.         checksum = 0;
     
447.         if (length<=0)
     
448.                 return OK;
     
449.         if ((ret = sendbyte('\\')) != OK)
     
450.                 return 1;
     
451.         if ((ret = sendbyte('H')) != OK)
     
452.                 return 2;
     
453.         while (length>;0)
     
454.         {
     
455.                 unsigned char ch;
     
456.                 ch = *pData++;
     
457.                 checksum += ch;
     
458.                 if ((ret = sendbyte(ch)) != OK)
     
459.                         return 3;
     
460.                 if (ch == '\\')
     
461.                 {
     
462.                         if ((ret = sendbyte(ch)) != OK)
     
463.                                 return 4;
     
464.                 }
     
465.                 length--;
     
466.         }
     
467. 
     
468.         if ((ret = sendbyte('\\')) != OK)
     
469.                 return 5;
     
470.         if ((ret = sendbyte('T')) != OK)
     
471.                 return 6;
     
472.         if ((ret = sendbyte(checksum)) != OK)
     
473.                 return 7;
     
474.         return OK;
     
475. }
     
476. 
     
477. 同样，也将rcvpack改成AT&T汇编(减少了几个printf语句)：
     
478. 
     
479. chbuffer:
     
480.         .byte 0
     
481. overflow:
     
482.         .string "Buffer overflow..."
     
483. rcvpack:
     
484.         pushw        %bp
     
485.         movw        %sp, %bp
     
486.         subw        $12, %sp
     
487.         pushw        %si
     
488.         movw        4(%bp), %si
     
489.         movw        6(%bp), %bx
     
490.         movw        (%bx), %ax
     
491.         incw         %ax
     
492.         movw        %ax, -6(%bp)
     
493.         cmpw        $0, -6(%bp)
     
494.         jg        .L26
     
495.         leaw        overflow, %si
     
496.         call        prtstr
     
497.         movw        $2, %ax
     
498.         jmp        .L25
     
499. .L26:
     
500.         orw        %si, %si       
     
501.         jne        .L27
     
502.         movw        $2, %ax
     
503.         jmp        .L25
     
504. .L27:
     
505.         movb        $0,-8(%bp)
     
506.         movw        $0, -10(%bp)
     
507.         movw        $0, -4(%bp)
     
508.         jmp        .L28
     
509. .L30:
     
510.         movw        $10, -2(%bp)
     
511.         jmp        .L31
     
512. .L33:
     
513. #        movw        -4(%bp), %ax
     
514. #        addb        $'0', %al
     
515. #        call        prtchr
     
516.         leaw        chbuffer, %ax
     
517.         pushw        %ax
     
518.         call        rcvbyte
     
519.         popw        %cx
     
520.         movw        %ax, -12(%bp)
     
521.         orw         %ax, %ax
     
522.         je        .L34
     
523.         decw        -2(%bp)
     
524.         cmpw        $0, -2(%bp)
     
525.         jne        .L35
     
526.         movw        -12(%bp), %ax
     
527.         jmp        .L25
     
528. .L35:
     
529.         jmp        .L36
     
530. .L34:
     
531.         jmp        .L32
     
532. .L36:
     
533. .L31:
     
534.         jmp        .L33
     
535. .L32:
     
536.         pushw        %si
     
537.         leaw        chbuffer, %si
     
538.         movb        (%si), %al
     
539.         movb        %al, -7(%bp)
     
540.         popw        %si
     
541. #        call        prtchr
     
542.         movw         -4(%bp), %ax
     
543.         cmpw        $3, %ax
     
544.         jbe        .L58
     
545.         jmp        .L56
     
546. .L58:
     
547.         cmpw        $0, %ax
     
548.         je        .L38
     
549.         cmpw        $1, %ax
     
550.         je        .L40
     
551.         cmpw        $2, %ax
     
552.         je        .L43
     
553.         cmpw        $3, %ax
     
554.         je        .L47
     
555.         jmp        .L56
     
556. .L38:       
     
557.         cmpb        $92, -7(%bp)
     
558.         jne        .L39
     
559.         movw        $1, -4(%bp)
     
560. .L39:
     
561.         jmp         .L37
     
562. .L40:
     
563.         cmpb        $72, -7(%bp)
     
564.         jne        .L41
     
565.         movw        $2, -4(%bp)
     
566.         jmp        .L42
     
567. .L41:
     
568.         movw        $0, -4(%bp)       
     
569. .L42:
     
570.         jmp        .L37
     
571. .L43:
     
572.         cmpb        $92, -7(%bp)
     
573.         jne        .L44
     
574.         movw        $3, -4(%bp)
     
575.         jmp         .L45
     
576. .L44:
     
577.         incw        -10(%bp)
     
578.         movw        -10(%bp), %ax
     
579.         cmpw        -6(%bp), %ax       
     
580.         jle        .L46
     
581.         movw        $2, %ax
     
582.         jmp        .L25
     
583. .L46:
     
584.         movb        -7(%bp), %al
     
585.         movb        %al, (%si)
     
586.         incw        %si       
     
587.         movb         -7(%bp), %al
     
588.         addb        %al, -8(%bp)
     
589. .L45:
     
590.         jmp        .L37
     
591. .L47:
     
592.         cmpb        $92, -7(%bp)  
     
593.         jne        .L48
     
594.         incw        -10(%bp)
     
595.         movw        -10(%bp), %ax       
     
596.         cmpw        -6(%bp), %ax
     
597.         jle        .L49
     
598.         movw        $2, %ax
     
599.         jmp        .L25
     
600. .L49:
     
601.         movb        -7(%bp), %al
     
602.         addb        %al, -8(%bp)
     
603.         movb        -7(%bp), %al
     
604.         movb        %al, (%si)
     
605.         incw        %si       
     
606.         movw        $2, -4(%bp)
     
607.         jmp        .L50
     
608. .L48:
     
609.         cmpb        $84, -7(%bp)
     
610.         jne        .L51
     
611.         movw        -10(%bp), %ax
     
612.         movw        6(%bp), %bx
     
613.         movw        %ax, (%bx)
     
614.         leaw        chbuffer, %ax
     
615.         pushw        %ax
     
616.         call        rcvbyte
     
617.         popw        %cx
     
618.         orw        %ax, %ax
     
619.         je        .L52
     
620.         movw        $2, %ax
     
621.         jmp        .L25
     
622. .L52:
     
623.         movb        -8(%bp), %al
     
624.         cmpb        chbuffer, %al
     
625.         jne        .L53
     
626.         xorw        %ax, %ax
     
627.         jmp        .L25
     
628.         jmp        .L54
     
629. sChecksumFailed:
     
630.         .string "Checksum error!"
     
631. .L53:
     
632.         leaw        sChecksumFailed, %si
     
633.         call         prtstr
     
634.         movw        $2, %ax
     
635.         jmp        .L25
     
636. .L54:
     
637.         jmp        .L55
     
638. .L51:
     
639.         movw        $2, %ax
     
640.         jmp        .L25
     
641. .L55:
     
642. .L50:
     
643. .L56:
     
644. .L37:
     
645. .L28:
     
646.         jmp         .L30
     
647. .L29:
     
648. .L25:
     
649.         popw        %si
     
650.         movw        %bp, %sp
     
651.         popw        %bp
     
652.         ret
     
653. 
     
654. 好了，万事具备了，先用上面的c代码写另外一台计算机上的“服务”程序（也用来测试）,这台
     
655. 计算机运行DOS，用TURBO C 2.0编译运行：
     
656. 运行时将initrd.img和内核编译后的/usr/src/linux/arch/i386/boot/compressed/bvmlinux.out
     
657. 拷贝到该计算机的c:\下，然后带参数 s c:\bvmlinux.out c:\initrd.img运行即可。
     
658. 至于启动程序，还得进行少许修改，才能烧到boot rom 中，见后面的说明。
     
659. 
     
660. int main(int argc, char* argv[])
     
661. {
     
662.         FILE* pFile;
     
663.         int count = 2;
     
664.         if (argc<3)
     
665.         {
     
666.                 printf("Usage testspp [s | r] \n");
     
667.                 return 1;
     
668.         }
     
669.         while(count        {
     
670.         if (argv[1][0] == 's')
     
671.                 pFile = fopen(argv[count], "rb");
     
672.         else
     
673.                 pFile = fopen(argv[count], "wb");
     
674.         if (pFile==NULL)
     
675.         {
     
676.                 printf("Can't open/create file %s\n", argv[2]);
     
677.                 return 2;
     
678.         }
     
679.         if (argv[1][0]=='r')/*receive*/
     
680.         {
     
681.                 unsigned long filesize;
     
682.                 char buffer[10244];
     
683.                 int length;
     
684.                 /*get filelength */
     
685.                 length = 10244;
     
686.                
     
687.                 printf("Receiving filesize package\n");
     
688.                 while( (rcvpack(buffer, &length)!=OK) && (length!=4))
     
689.                         length = 10244;
     
690.                 filesize = *(long*)buffer;
     
691.                 printf("file size is:%ld\n", filesize);
     
692.                
     
693.                 while (filesize>;0)
     
694.                 {
     
695.                         length = 10244;
     
696.                         if (rcvpack(buffer, &length) != OK)
     
697.                         {
     
698.                                 printf("Receive data package failed\n");
     
699.                                 return 0;
     
700.                         }
     
701.                         if (length>;0)
     
702.                                 fwrite(buffer, 1, length, pFile);
     
703.                         filesize-=length;
     
704.                         printf("\r%ld Bytes Left         ", filesize);
     
705.                 }
     
706.         }
     
707.         else/*send*/
     
708.         {
     
709.                 unsigned long filesize;
     
710.                 /*send file length*/
     
711.                 unsigned long stemp;
     
712.                 int ret;
     
713.                 fseek(pFile, 0, 2);
     
714.                 filesize = ftell(pFile);
     
715.                 fseek(pFile, 0, 0);
     
716.                 printf("\nfile size is:%ld\n", filesize);
     
717.                 /*
     
718.                 while ((ret = sendpack((char *)&filesize, 4)) != OK)
     
719.                 {
     
720.                         printf("send file size failed(%d)\n", ret);
     
721.                 }
     
722.                 */
     
723.                 while (filesize>;0)
     
724.                 {
     
725.                         char buffer[10240];
     
726.                         long size;
     
727.                         int ret;
     
728.                         size = fread(buffer, 1, 10240, pFile);
     
729.                         if ((ret = sendpack(buffer, size)) != OK)
     
730.                         {
     
731.                                 printf("Send data package failed(%d)\n", ret);
     
732.                                 return 0;
     
733.                         }
     
734.                         filesize -= size;
     
735.                         printf("\r\t%ld Bytes Left", filesize);
     
736.                 }
     
737.         }
     
738.         fclose(pFile);
     
739.         count++;
     
740.         }/*while*/
     
741.         return 0;
     
742. }
     
743. 
     
744. 5、对bootsect.S的修改
     
745.    目前的bootsect.S ，主要的问题是，它是从软盘上读数据，将这些代码换成对rcvpack的调用即可，
     
746. 另外，它不支持调入initrd，应该增加相应的代码。问题在于，bootsect.S中没有那么多空间来放rcvpack
     
747. 相关的代码（毕竟只有512字节，当然，如果烧在boot rom中，就不存在这个问题了，但是用软盘调试时
     
748. 就不行了，因此干脆编制load_kernel和load_initrd放在setup.S中，然后在bootsect.S中进行回调即可。
     
749. bootsect.S 修改如下(只给出修改部分)：
     
750. .....
     
751. .....
     
752. ok_load_setup:
     
753.         call        kill_motor
     
754.         call        print_nl
     
755. # Now we will load kernel and initrd
     
756. loading:
     
757. # 先打印Loading字符
     
758.         movw        $INITSEG, %ax
     
759.         movw        %ax, %es                # set up es
     
760.         movb        $0x03, %ah                # read cursor pos
     
761.         xorb        %bh, %bh
     
762.         int        $0x10
     
763.         movw        $22, %cx
     
764.         movw        $0x0007, %bx                # page 0, attribute 7 (normal)
     
765.         movw    $msg1, %bp
     
766.         movw    $0x1301, %ax                # write string, move cursor
     
767.         int        $0x10                        # tell the user we're loading..
     
768. load_kernel_img:
     
769. # 将load_kernel函数的指针放到0x22C处这里进行调用就行了（软盘启动过程中，此前已经将setup.S
     
770. # 从磁盘上调到bootsect.S,即0x0200之后，注意setup.S的头部是一张表，这里“提前”消费了）
     
771. # 0x22C is the load kernel routine
     
772.         bootsect_readimage = 0x22C
     
773.         lcall        bootsect_readimage
     
774. load_initrd_img:
     
775. # 将load_initrd函数的指针放到0x220处
     
776. # 0x220 if the load initrd routine
     
777.         bootsect_readinitrd = 0x220
     
778.         lcall        bootsect_readinitrd
     
779. 
     
780. # After that (everything loaded), we jump to the setup-routine
     
781. # loaded directly after the bootblock:
     
782.         ljmp        $SETUPSEG, $0
     
783. ......
     
784. ......
     
785. 6、对setup.S的修改
     
786.    对setup.S进行修改，主要是：修改setup.S头部，增加load_kernel和load_initrd函数等，具体如下。
     
787.     修改setup.S头部如下（为好看，这里删除了原来的部分注释）：
     
788. 
     
789. start:
     
790.                         jmp        trampoline
     
791.                         .ascii        "HdrS"                # header signature
     
792.                         .word        0x0202                # header version number (>;= 0x0105)
     
793. realmode_swtch:        .word        0, 0                # default_switch, SETUPSEG
     
794. start_sys_seg:        .word        SYSSEG
     
795.                         .word        kernel_version        # pointing to kernel version string
     
796. type_of_loader:        .byte        0       
     
797. loadflags:
     
798. LOADED_HIGH        = 1                       
     
799.                         .byte        LOADED_HIGH   # 只支持bzImage
     
800. setup_move_size:         .word  0x8000       
     
801. code32_start:                                # here loaders can put a different
     
802.                         .long        0x100000        # 0x100000 = default for big kernel
     
803. ramdisk_image:        .long        0xB00000        # ramdisk 调到12M处
     
804. ramdisk_size:                .long        0                # 由load_initrd来设置长度
     
805. bootsect_kludge:
     
806.                         .word  load_initrd, SETUPSEG #0x220, 放置load_initrd函数的指针
     
807. heap_end_ptr:                .word        modelist+1024        pad1:                .word        0
     
808. cmd_line_ptr:                .long 0               
     
809. load_kernel_call:
     
810.                         .word  load_kernel, SETUPSEG
     
811. trampoline:                call        start_of_setup
     
812. 
     
813.                         .space        1024
     
814. 
     
815. load_kernel和load_initrd：
     
816. 
     
817. load_imsg:
     
818.         .byte 13, 10
     
819.         .string "Load INITRD from PARPort(378)"
     
820. load_kmsg:
     
821.         .byte 13, 10
     
822.         .string        "Load Kernel From PARPort(378)"
     
823. reading_suc:
     
824.         .string        "."
     
825. reading_failed:
     
826.         .string " failed"
     
827. read_len:
     
828.         .word 0, 0
     
829. read_total:
     
830.         .word 0, 0
     
831. read_buffer:
     
832.         # 如何在AT&T语法中完成intel语法中的 db 1280 dup(0)，那位请指教
     
833.         # AT&T汇编的语法何处寻？
     
834.         .string "012345678901234567890123456789012345678901234567890123456789"
     
835.         .string "012345678901234567890123456789012345678901234567890123456789"
     
836.         .string "012345678901234567890123456789012345678901234567890123456789"
     
837.         .string "012345678901234567890123456789012345678901234567890123456789"
     
838.         .string "012345678901234567890123456789012345678901234567890123456789"
     
839.         .string "012345678901234567890123456789012345678901234567890123456789"
     
840.         .string "012345678901234567890123456789012345678901234567890123456789"
     
841.         .string "012345678901234567890123456789012345678901234567890123456789"
     
842.         .string "012345678901234567890123456789012345678901234567890123456789"
     
843.         .string "012345678901234567890123456789012345678901234567890123456789"
     
844.         .string "012345678901234567890123456789012345678901234567890123456789"
     
845.         .string "012345678901234567890123456789012345678901234567890123456789"
     
846.         .string "012345678901234567890123456789012345678901234567890123456789"
     
847.         .string "012345678901234567890123456789012345678901234567890123456789"
     
848.         .string "012345678901234567890123456789012345678901234567890123456789"
     
849.         .string "012345678901234567890123456789012345678901234567890123456789"
     
850.         .string "012345678901234567890123456789012345678901234567890123456789"
     
851.         .string "012345678901234567890123456789012345678901234567890123456789"
     
852.         .string "012345678901234567890123456789012345678901234567890123456789"
     
853.         .string "012345678901234567890123456789012345678901234567890123456789"
     
854. 
     
855. load_initrd:
     
856.         pushw        %ds
     
857.         pushw        %es
     
858.         pushw        %cs
     
859.         popw        %ds
     
860.         pushw        %cs
     
861.         popw        %es
     
862.         cld       
     
863.         leaw        load_imsg, %si
     
864.         call        prtstr                                # 打印提示
     
865.         movw        $0x1000, %ax
     
866.         movw        %ax, %es
     
867.         xorw        %bx, %bx
     
868.         movw        $0x00B0, %ax                        # initrd数据先调到0x1000:0000处，
     
869.                                                 # 满64K即移动到12M(0xB00000)处
     
870.         movw        %ax, %fs
     
871.         movw        $0, %cs:move_es
     
872.         movl        $0, %cs:read_total
     
873.         call        movetohigh                        # 初始化数据移动部分
     
874.         call        .ld_img                        # 从并口上读入一个文件并移动到指定位置
     
875.         movl        %cs:read_total, %eax
     
876.         movl        %eax, %cs:ramdisk_size        # 设置ramdisk_size和ramdisk_image       
     
877.         movl        $0x00B00000, %eax
     
878.         movl        %eax, %cs:ramdisk_image
     
879.         popw        %es
     
880.         popw        %ds
     
881.         lret
     
882. 
     
883. load_kernel:
     
884.         pushw        %ds
     
885.         pushw        %es
     
886.         pushw        %cs
     
887.         popw        %ds
     
888.         pushw   %cs
     
889.         popw        %es
     
890.         cld
     
891.         leaw        load_kmsg, %si
     
892.         call        prtstr
     
893.         movw        $0x1000, %ax
     
894.         movw        %ax, %es
     
895.         xorw        %bx, %bx
     
896.         movw        $0x0010, %ax
     
897.         movw        %ax, %fs
     
898.         movw        $0, %cs:move_es
     
899.         movl        $0, %cs:read_total
     
900.         call        movetohigh
     
901.         call        .ld_img
     
902.         popw        %es
     
903.         popw        %ds
     
904.         lret
     
905. 
     
906. .ld_img:
     
907. .ld_nextpack:
     
908.         pushw        %bx
     
909.         pushw        %es
     
910.         leaw         read_len, %si
     
911.         movw        $1124, %ax
     
912.         movw        %ax, (%si)
     
913.         pushw        %si
     
914.         leaw        read_buffer, %ax
     
915.         pushw        %ax
     
916.         movw        %bx, %ax
     
917.         call        rcvpack                # 调用rcpack接收一个数据包read_buffer中
     
918.         popw        %cx
     
919.         popw        %cx
     
920.         popw        %es
     
921.         popw        %bx
     
922.         cmpw        $0, %ax                # 成功？
     
923.         je        .ld_suc
     
924.         leaw        reading_failed, %si       
     
925.         call        prtstr
     
926. .ld_panic:
     
927.         jmp        .ld_panic                # 失败则死循环
     
928. .ld_suc:
     
929.         leaw        read_buffer, %si
     
930.         movw        %bx, %di
     
931.         movw        $256, %cx                # move 1024 bytes
     
932.         rep       
     
933.         movsl                                # 从read_buffer移动到es:bx处，强制假定一个数据包长度
     
934.                                         # 就是1024字节，最后一个数据包除外。
     
935.         addw        $1024, %bx                # 更新bx, 如果bx加到零，则表示已经满64K，后面的调用中
     
936.         call         movetohigh                # 进行实际的数据移动
     
937.         movw        %ax, %dx                #
     
938.         cmpw        $0, %ax                # 如果进行了64K数据移动，就打印一个'.'
     
939.         je        .ld_1
     
940.         leaw        reading_suc, %si
     
941.         call         prtstr
     
942. .ld_1:
     
943.         leaw        read_len, %si               
     
944.         xorl        %eax, %eax
     
945.         movw        (%si), %ax
     
946.         addl        %eax, %cs:read_total
     
947.         cmpw        $1024, %ax                 # 更新收到数据总字节数，如果收到的字节数少于1024，则表示
     
948.                                         # 收到最后一个数据包，这得冒点风险，万一最后一个数据包刚好
     
949.                                         # 是1024字节，怎么办好呢？赌一把吧！
     
950.         jb        .ld_lastestpack
     
951.         jmp        .ld_nextpack                # 接着接收下一个数据包
     
952. .ld_lastestpack:
     
953.         # 最后一个数据包收到后，不见得满64K，此时应该强制数据移动
     
954.         cmpw        $0, %dx
     
955.         jne        .ld_exit
     
956.         xorw         %bx, %bx
     
957.         call        movetohigh
     
958. .ld_exit:
     
959.         ret
     
960. 
     
961. 7、用软盘进行调试，将启动程序烧到bootrom中
     
962.         好了，大功告成，对内核进行配置，然后make bzImage，将bvmlinux.out拷贝到“服务器”上，建立
     
963. initrd也放在“服务器”上，然后放张软盘在软驱中，dd if=/usr/src/linux/arch/i386/boot/bzImage of=
     
964. /dev/fd0 count=32将bootsect.S+setup.S部分拷贝到软盘上，重新启动（先连接好并口线）。启动后再在
     
965. “服务器”上启动文件“服务”程序，终于可以将Linux从并口上启动了！
     
966.         做少量调整（主要是去掉读setup.S部分的代码），即可以将此bzImage的前8(16?)K写在一个文件中，
     
967. 处理成boot rom映象，烧到boot rom中，插到网络卡上，启动机器即可。这就是用网络卡从并口上启动Linux。
     

复制代码

雪中独行

出自：http://www.linuxforum.net
作者：raoxianhong

1.系统自检完毕后在ROM空间中找（好象是2Kbytes为单位），如果某一段的前两表字节是0x55AA，那么第三个字节作为ROM程序的大小（512字节为单位）。然后将该段空间中的所有字节相加（计算校验和），结果为零时表示ROM程序有效。此时BIOS用一个长调用(lcall)，调用该块的第四个字节起始处（自然该用lret返回）。
2.有个问题原来一直不明白，如果此时某个启动网卡启动系统，但是后面还有带ROM的卡（比如PCI），那么该段ROM程序岂不是没有机会运行了吗，当然，如果不运行任何设备的扩展ROM，不知道Linux内会不会有问题！后来查资料得知，实际上制作网卡启动程序时还没有这么简单。
3.事实上，系统在自检及运行所有的扩展硬件检测之后，是用int 19h启动操作系统的！因此在扩展ROM中不直接启动操作系统，而是将操作系统启动代码作为int 19h的中断调用（其实也不用返回，操作系统没有必要返回）代码就行了。
明白这一点后，制作一个网卡启动程序就容易多了，具体请看某个网卡的启动源代码即可，附件中有一个，记不住是从哪里抄来的了！

雪中独行

1. 
   
2. Bootrom写好后要进行一些处理才能烧到EPROM中去。这里提供一段代码可以完成这个功能，上面讲的用并口启动Linux的程序就是这么处理的。
   
3. 基本的想法是，写一个通用的启动代码载入程序（stub），将bootsect.S+setup.S(也就是bzImage的前面一段)设置成0x19号中断的中断向量。在外面写一段代码将该段代码和启动代码进行合并，生成合法的bootrom映象就，可以烧到bootrom中去，在网络卡上启动。
   
4. 
   
5. 下面是通用的启动代码载入程序：
   
6. 
   
7. 
   
8. 
   
9. .code16
   
10. RomHeader:
    
11.         .byte 0x55, 0xaa #启动ROM标志
    
12. RomPageCount:
    
13.         .byte 0x20  #假定bootrom是16K bytes
    
14. 
    
15. RomCode:
    
16.         pushw %es
    
17.         pushw %bx
    
18.         pushw %ax
    
19. 
    
20.         movb  $0xc1, %al
    
21.         call  IntVectAddr
    
22.         movw  $0x6a6e, %ax
    
23.         cmpw  %es:(%bx), %ax
    
24.         jz    RomBootInit_x
    
25.         movw  %ax, %es:(%bx)
    
26.         movw  $0xc019, %ax
    
27.         call  MoveIntVector
    
28.         movw  $RomBootVect, %bx
    
29.         pushw %cs
    
30.         popw  %es
    
31.         call  SetIntVector
    
32. RomBootInit_x:
    
33.         popw  %ax
    
34.         popw  %bx
    
35.         popw  %es
    
36.         lret
    
37. 
    
38. IntVectAddr:
    
39.         xorw        %bx,%bx       
    
40.         movw        %bx,%es       
    
41.         movb        %al,%bl
    
42.         addw        %bx,%bx
    
43.         addw        %bx,%bx
    
44.         ret
    
45. 
    
46. GetIntVector:       
    
47.         call        IntVectAddr
    
48. GetIntVect_1:
    
49.                      les        %es:(%bx), %bx
    
50.         ret                       
    
51. 
    
52. SetIntVector:
    
53.         pushf                        #; entry AL=vector to set, ES:BX=value
    
54.         pushw        %es                #; exit: vector modified
    
55.         pushw        %bx                #; all registers preserved
    
56.         call        IntVectAddr
    
57.         cli
    
58.         popw        %es:(%bx)
    
59.         addw        $2, %bx
    
60.         popw        %es:(%bx)
    
61.         subw        $2, %bx
    
62.         popf
    
63.         jmp        GetIntVect_1
    
64. 
    
65. MoveIntVector:
    
66.         call        GetIntVector        #; entry AL=vect to get, AH=vect to set
    
67.         xchgb        %al,%ah                #; exit: vector set, ES:BX=vector value
    
68.         call        SetIntVector        #; other registers preserved
    
69.         xchgb        %al,%ah
    
70.         ret
    
71. 
    
72. RomBootVect:
    
73.         pushw   %cs
    
74.         popw        %ds
    
75.         movw        $0x07c0, %ax
    
76.         movw        %ax, %es
    
77.         movw        $BootCode, %si
    
78.         subw        %di, %di
    
79.         movw        $8192, %cx
    
80.         cld
    
81.         rep
    
82.         movsw
    
83.         ljmp        $0x07c0, $0
    
84.         lret
    
85. 
    
86. .org        0x0200
    
87. BootCode:
    
88. 
    
89. 
    
90. 
    
91. 
    
92. 在Linux下的编译方法与bootsect.S的编译方法一样，编译成可执行文件后，比如放在bootx文件中。
    
93. 内核编译后（make bzImage，支持上面所说的启动方式)，得到bzImage文件。
    
94. 
    
95. 下面是将这两个文件复合在一起得到bootrom映象的程序：
    
96. 
    
97. 
    
98. /* mkbtrom.c */
    
99. 
    
100. int main(int argc, char* argv[])
     
101. {
     
102.         char buf[16384];
     
103.         char ch;
     
104.         int i;
     
105.         if (argc<4)
     
106.         {
     
107.                 printf("Usage: mkbtrom   \n");
     
108.                 return 1;
     
109.         }
     
110.         FILE * pFile;
     
111.         pFile = fopen(argv[1], "rb");
     
112.         if (pFile==NULL)
     
113.         {
     
114.                 printf("File %s open failed\n", argv[1]);
     
115.                 return 2;
     
116.         }
     
117.         fread(buf, 1, 512, pFile);
     
118.         fclose(pFile);
     
119.         pFile = fopen(argv[2], "rb");
     
120.         if (pFile==NULL)
     
121.         {
     
122.                 printf("File %s open failed\n", argv[2]);
     
123.                 return 2;
     
124.         }
     
125.         fread(&buf[512], 1, 16384-512-1, pFile);
     
126.         fclose(pFile);
     
127.         ch = 0;
     
128.         for (i = 0;i<18383;i++)
     
129.                 ch += buf[ i ];
     
130.         buf[16383] = -ch;
     
131.         pFile = fopen(argv[3], "wb");
     
132.         fwrite(buf, 1, 16384, pFile);
     
133.         fclose(pFile);
     
134.         return 0;
     
135. }
     
136. 
     
137. 
     
138. 
     
139. 
     
140. 编译成执行文件后，运行mkbtrom bootx bzImage boot16k.bin后，boot16k.bin就可以烧到eprom中，从网络卡中启动了。
     
141. 
     

复制代码

shiv_kiev

高人

soway

牛啊

最爱linux

走召弓虽!!!!

simonzhan

好文，这篇文章应该对做无盘系统的兄弟有点助益

myforever

先收下，慢慢消化

babodx

根本看不懂，上面的代码是用什么写的？MASM??