bootloader在内核启动结束还在运行不

brauceunix

如题，在Bootloader的时候，网卡的指示灯被点亮了，可是我按了ESC，进入了下载模式，那个灯还在不停的闪。。 进到了LINux，已经可以输入ls命令了，那个灯还在闪。。不知道。。这个灯是Bootloader控制的。。还是内核控制的..哪位大侠能帮小弟分析下不。。。。

brauceunix

刚刚用EZP2010清了Flash。。只放了Bootloader。。 把start_kernel函数的所有内容全部注释了，然后把这样的bootloader 烧到Flash中。没想到。。  这个灯还是勇敢的亮了。。 哥。。。哭死了。。

刚刚又在没有Flash的情况下启动了板子，发现，不错。。灯一直在亮。。。  大侠。。快点Help一下啦。。。    急死了。。

brauceunix

这个灯是网卡的指示灯： 我拨掉网线，灯就灭了，插入网线，灯就亮了。。

郁郁前行

嵌入式开发板上的灯有很多种连接方式，因此也有很多种控制方式，比如：
1.GPIO控制，你需要初始化GPIO为OUTPUT模式，然后拉高拉低GPIO就可以控制灯的亮灭。
2.硬件控制，比如大部分switch,phy在实际应用中，通过硬件控制LED，有包的时候就闪。当然也可以通过软件控制这些灯，因为这些灯其实是连在phy,switch后面的，具体要参考phy,switch的datasheet。实际应用中硬件控制LED降低了软件的负荷，但在生产测试的时候有可能要写一版特殊的程序软件控制LED，用来做测试，没人保证一生产出来这颗灯就是100%工作的，所以出厂之前要进行测试。但测试的时候不会叫操作人员插根网线看灯闪不闪，这样速度太慢，效率太低，并且很大程度上依赖于操作人员是否细心负责。所有现在测试这些灯的时候需要软件控制全部的灯全亮全灭，配合图像识别，把这些复杂琐碎的事情全部推给计算机！
3.如果板子上GPIO不够用，甚至可以通过一个锁存器，把LED连接在某些地址线上或者数据线上。
4.各种可行，奇怪的连接方式都有可能！

你看到的情况可以参考第2条。

brauceunix

嵌入式开发板上的灯有很多种连接方式，因此也有很多种控制方式，比如：
1.GPIO控制，你需要初始化GPIO为OU ...
郁郁前行 发表于 2011-07-23 17:14

嗯。。 谢谢大侠。。 那请问我在内核里可以用驱动继续控制他们吗？地址是0xb8003500.. 我驱动已经弄好了。。 但是只能读，写进去就不行。。。 网上说。是地址被别的程序战用了，我想会不会就是这段硬件给占了。。。
我把驱动贴出来，是LDD3书上silly那个驱动修改过来的。
我刚学驱动开发，这个是我写的第一个驱动程序，很多地方很生，不熟悉。。写得不好的地方。。还请多多包涵。
我测试的时候，主要就是：

1. mknod /dev/sillyb c 231 0

复制代码

。
这样的话，我就得到一个8字节读写的一个设备，试过32位的，都读写不成功，但是读写0x200的那个地址是成功的。。 我把这个程序下到开发板上，还是不行。。。  

:

1. /*
   
2. * silly.c -- Simple Tool for Unloading and Printing ISA Data
   
3. *
   
4. * Copyright (C) 2001 Alessandro Rubini and Jonathan Corbet
   
5. * Copyright (C) 2001 O'Reilly & Associates
   
6. *
   
7. * The source code in this file can be freely used, adapted,
   
8. * and redistributed in source or binary form, so long as an
   
9. * acknowledgment appears in derived source files.  The citation
   
10. * should list that the code comes from the book "Linux Device
    
11. * Drivers" by Alessandro Rubini and Jonathan Corbet, published
    
12. * by O'Reilly & Associates.   No warranty is attached;
    
13. * we cannot take responsibility for errors or fitness for use.
    
14. *
    
15. * $Id: silly.c,v 1.3 2004/09/26 07:02:43 gregkh Exp $
    
16. */
    
17. 
    
18. /* =========================> BIG FAT WARNING:
    
19. * This will only work on architectures with an ISA memory range.
    
20. * It won't work on other computers.
    
21. */
    
22. 
    
23. #include <linux/module.h>
    
24. #include <linux/init.h>
    
25. #include <linux/moduleparam.h>
    
26. #include <linux/version.h>
    
27. 
    
28. #include <linux/sched.h>
    
29. #include <linux/kernel.h> /* printk() */
    
30. #include <linux/fs.h>          /* everything... */
    
31. #include <linux/errno.h>  /* error codes */
    
32. #include <linux/slab.h>
    
33. #include <linux/mm.h>
    
34. #include <linux/ioport.h>
    
35. #include <linux/poll.h>
    
36. 
    
37. #include <asm/io.h>
    
38. #include <asm/uaccess.h>
    
39. 
    
40. int silly_major = 231;
    
41. module_param(silly_major, int, 0);
    
42. MODULE_AUTHOR("Alessandro Rubini");
    
43. MODULE_LICENSE("Dual BSD/GPL");
    
44. 
    
45. /*
    
46. * The devices access the 640k-1M memory.
    
47. * minor 0 uses ioread8/iowrite8
    
48. * minor 1 uses ioread16/iowrite16
    
49. * minor 2 uses ioread32/iowrite32
    
50. * minor 3 uses memcpy_fromio()/memcpy_toio()
    
51. */
    
52. 
    
53. /*
    
54. * Here's our address range, and a place to store the ioremap'd base.
    
55. */
    
56. #if 1
    
57. #define ISA_BASE        0xb8003500
    
58. #define ISA_MAX     0xb80035f0  /* for general memory access */
    
59. #endif
    
60. #if 0
    
61. #define ISA_BASE        0x200
    
62. #define ISA_MAX                0x2ff  /* for general memory access */
    
63. #endif
    
64. #define VIDEO_MAX        0xC0000  /* for vga access */
    
65. #define VGA_BASE        0xb8000
    
66. static void __iomem *io_base;
    
67. 
    
68. 
    
69. 
    
70. int silly_open(struct inode *inode, struct file *filp)
    
71. {
    
72.         return 0;
    
73. }
    
74. 
    
75. int silly_release(struct inode *inode, struct file *filp)
    
76. {
    
77.         return 0;
    
78. }
    
79. 
    
80. enum silly_modes {M_8=0, M_16, M_32, M_memcpy};
    
81. 
    
82. ssize_t silly_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
    
83. {
    
84.         int retval, i = 0;
    
85.         int mode = iminor(filp->f_dentry->d_inode);
    
86.         void __iomem *add;
    
87.         unsigned long isa_addr = ISA_BASE + *f_pos;
    
88.         unsigned char *kbuf, *ptr;
    
89. 
    
90.         if (isa_addr + count > ISA_MAX) /* range: 0xA0000-0x100000 */
    
91.                 count = ISA_MAX - isa_addr;
    
92.         printk("\nf_ops is %x\n", *f_pos);
    
93.         /*
    
94.          * too big an f_pos (caused by a malicious lseek())
    
95.          * would result in a negative count
    
96.          */
    
97.         if (count < 0)
    
98.                 return 0;
    
99. 
    
100.         kbuf = kmalloc(count, GFP_KERNEL);
     
101.         if (!kbuf)
     
102.                 return -ENOMEM;
     
103.         ptr = kbuf;
     
104.         retval = count;
     
105.         /*
     
106.          * Convert our address into our remapped area.
     
107.          */
     
108.         add = (void __iomem *)(io_base + (isa_addr - ISA_BASE));
     
109.         printk("add is %x\n", add);
     
110.         /*
     
111.          * kbuf is aligned, but the reads might not. In order not to
     
112.          * drive me mad with unaligned leading and trailing bytes,
     
113.          * I downgrade the `mode' if unaligned xfers are requested.
     
114.          */
     
115. 
     
116.         if (mode == M_32 && ((isa_addr | count) & 3))
     
117.                 mode = M_16;
     
118.         if (mode == M_16 && ((isa_addr | count) & 1))
     
119.                 mode = M_8;
     
120. 
     
121.         switch(mode) {
     
122.           case M_32:
     
123.                 while (count >= 4) {
     
124.                         *(u32 *)ptr = ioread32(add);
     
125.                         add += 4;
     
126.                         count -= 4;
     
127.                         ptr += 4;
     
128.                 }
     
129.                 break;
     
130.             
     
131.           case M_16:
     
132.                 while (count >= 2) {
     
133.                         *(u16 *)ptr = ioread16(add);
     
134.                         add+=2;
     
135.                         count-=2;
     
136.                         ptr+=2;
     
137.                 }
     
138.                 break;
     
139.             
     
140.           case M_8:
     
141.                 printk("begin:\n ");
     
142.                 while (count) {
     
143.                         *ptr = ioread8(add);
     
144.                         add++;
     
145.                         count--;
     
146.                         ptr++;
     
147.                         printk("%x ", *ptr);
     
148.                 }
     
149.                 printk("end\n");
     
150.                 break;
     
151. 
     
152.           case M_memcpy:
     
153.                 memcpy_fromio(ptr, add, count);
     
154.                 break;
     
155. 
     
156.             default:
     
157.                 return -EINVAL;
     
158.         }
     
159.         printk("copy:\n");
     
160.         for (i = 0; i < retval; i ++) {
     
161.                 printk("%x ", kbuf[i]);
     
162.         }
     
163.         if ((retval > 0) && copy_to_user(buf, kbuf, retval))
     
164.                 retval = -EFAULT;
     
165.         printk("end copy:\n");
     
166.         for (i = 0; i < retval; i ++) {
     
167.                 printk("%x ", kbuf[i]);
     
168.         }
     
169.         kfree(kbuf);
     
170.         *f_pos += retval;
     
171.         return retval;
     
172. }
     
173. 
     
174. 
     
175. ssize_t silly_write(struct file *filp, const char __user *buf, size_t count,
     
176.                     loff_t *f_pos)
     
177. {
     
178.         int retval, i =0;
     
179.         int mode = iminor(filp->f_dentry->d_inode);
     
180.         *f_pos = 0;
     
181.         //unsigned long isa_addr = ISA_BASE + *f_pos;
     
182.         unsigned long isa_addr = ISA_BASE ;
     
183.         unsigned char *kbuf, *ptr;
     
184.         void __iomem *add;
     
185. #if 0
     
186.         unsigned long *light = 0xb8003500;
     
187.         printk("light is %u\n", *light);       
     
188.         *light = 0xff00;
     
189.         printk("light is %u\n", *light);
     
190. #endif
     
191. 
     
192.         /*
     
193.          * Writing is dangerous.
     
194.          * Allow root-only, independently of device permissions
     
195.          */
     
196.         if (!capable(CAP_SYS_RAWIO))
     
197.                 return -EPERM;
     
198. 
     
199.         if (isa_addr + count > ISA_MAX) /* range: 0xA0000-0x100000 */
     
200.                 count = ISA_MAX - isa_addr;
     
201.         printk("\nwrite...\n");
     
202.         printk("f_pos is %u\n", f_pos);
     
203.         printk("count is %u\n", count);
     
204.         /*
     
205.          * too big an f_pos (caused by a malicious lseek())
     
206.          * results in a negative count
     
207.          */
     
208.         if (count < 0)
     
209.                 return 0;
     
210. 
     
211.         kbuf = kmalloc(count, GFP_KERNEL);
     
212.         if (!kbuf)
     
213.                 return -ENOMEM;
     
214.         ptr = kbuf;
     
215.         retval=count;
     
216. 
     
217.         /*
     
218.          * kbuf is aligned, but the writes might not. In order not to
     
219.          * drive me mad with unaligned leading and trailing bytes,
     
220.          * I downgrade the `mode' if unaligned xfers are requested.
     
221.          */
     
222. 
     
223.         if (mode == M_32 && ((isa_addr | count) & 3))
     
224.                 mode = M_16;
     
225.         if (mode == M_16 && ((isa_addr | count) & 1))
     
226.                 mode = M_8;
     
227. 
     
228.         if (copy_from_user(kbuf, buf, count)) {
     
229.                 kfree(kbuf);
     
230.                 return -EFAULT;
     
231.         }
     
232.         ptr = kbuf;
     
233.         printk("data from user:\n");
     
234.         for (i = 0; i < 10; i ++)  {
     
235.                 printk(" %x", ptr[i]);
     
236.         }
     
237.         /*
     
238.          * Switch over to our remapped address space.
     
239.          */
     
240.         kbuf[0] = 'h';
     
241.         kbuf[1] = 'h';
     
242.         kbuf[2] = 'h';
     
243.         add = (void __iomem *)(io_base + (isa_addr - ISA_BASE));
     
244.         printk("add is %x\n", add);
     
245. 
     
246.         switch(mode) {
     
247.           case M_32:
     
248.                 while (count >= 4) {
     
249.                         iowrite8(*(u32 *)ptr, add);
     
250.                         add += 4;
     
251.                         count -= 4;
     
252.                         ptr += 4;
     
253.                 }
     
254.                 break;
     
255.             
     
256.           case M_16:
     
257.                 while (count >= 2) {
     
258.                         iowrite8(*(u16 *)ptr, add);
     
259.                         add += 2;
     
260.                         count -= 2;
     
261.                         ptr += 2;
     
262.                 }
     
263.                 break;
     
264.             
     
265.           case M_8:
     
266.        
     
267.                 while (count) {
     
268.                         iowrite8(*ptr, add);
     
269.                         printk("p:%x", *ptr);
     
270.                         add++;
     
271.                         count--;
     
272.                         ptr++;
     
273.                 }
     
274.                 break;
     
275. 
     
276.           case M_memcpy:
     
277.                 memcpy_toio(add, ptr, count);
     
278.                 break;
     
279. 
     
280.           default:
     
281.                 return -EINVAL;
     
282.         }
     
283.         *f_pos += retval;
     
284.         kfree(kbuf);
     
285.         return retval;
     
286. }
     
287. 
     
288. 
     
289. unsigned int silly_poll(struct file *filp, poll_table *wait)
     
290. {
     
291.     return POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM;
     
292. }
     
293. 
     
294. 
     
295. struct file_operations silly_fops = {
     
296.         .read =            silly_read,
     
297.         .write =    silly_write,
     
298.         .poll =            silly_poll,
     
299.         .open =            silly_open,
     
300.         .release =  silly_release,
     
301.         .owner =    THIS_MODULE
     
302. };
     
303. 
     
304. int silly_init(void)
     
305. {
     
306.         struct resource *res;
     
307.         int result = register_chrdev(silly_major, "silly", &silly_fops);
     
308.         if (result < 0) {
     
309.                 printk(KERN_INFO "silly: can't get major number\n");
     
310.                 return result;
     
311.         }
     
312.         if (silly_major == 0)
     
313.                 silly_major = result; /* dynamic */
     
314.         /*
     
315.          * Set up our I/O range.
     
316.          */
     
317. 
     
318.         /* this line appears in silly_init */
     
319.         io_base = ioremap(ISA_BASE, ISA_MAX - ISA_BASE);
     
320.         res = request_mem_region(ISA_BASE, ISA_MAX-ISA_BASE, "sillyb");
     
321.         if (res == NULL) {
     
322.                 printk("res is in use\n");
     
323.         }       
     
324.         return 0;
     
325. }
     
326. 
     
327. void silly_cleanup(void)
     
328. {
     
329.         iounmap(io_base);
     
330.         release_mem_region(ISA_BASE, ISA_MAX-ISA_BASE);
     
331.         unregister_chrdev(silly_major, "silly");
     
332. }
     
333. 
     
334. 
     
335. module_init(silly_init);
     
336. module_exit(silly_cleanup);
     

复制代码

brauceunix

问题找到了。。是没有在read或者write的时候进行关闭irq的操作。
最后这样了：在write那儿每写一次之前，加入local_irq_disable();  写入之后加入：local_irq_enable();