汇编指令和时序电路的关系?

cjaizss

原帖由 怪怪虎 于 2009-12-29 13:30 发表


都给讲到这个份上了,看来自己不明白只能看驱动的code了. 哈哈
可是现在基于linux操作系统的驱动,在书写方式上,个人感觉他把底层的实现都给隐藏了. 在c语言code里看到的只是一些设备逻辑,根本看不出"协议 ...

呵呵,你用C语言看不出来的话,你用汇编一样看不出来,打个比方
*(volatile unsigned*)(0x0d000000) = 1
换成汇编假如长这样:
mov r1,0x0d000000
mov *r1,0x1
你能通过这样的语句知道处理器是如何控制各信号线的吗?
你还是看不出来.
或者,你还没有明白什么是协议.

cjaizss

原帖由 cjaizss 于 2009-12-29 13:41 发表

呵呵,你用C语言看不出来的话,你用汇编一样看不出来,打个比方
*(volatile unsigned*)(0x0d000000) = 1
换成汇编假如长这样:
mov r1,0x0d000000
mov *r1,0x1
你能通过这样的语句知道处理器是如何控制各信号 ...

另外,协议要参照的不是代码,而是manual,datasheet!!!
我把我最近使用的一个硬件的硬件驱动部分代码节选一下给你看下

1. 
   
2. /*
   
3. *      Using MDC/MDIO
   
4.          PC4    MDC
   
5.          PC5    MDIO
   
6. */
   
7. #ifdef IN
   
8. #undef IN
   
9. #endif
   
10. #ifdef OUT
    
11. #undef OUT
    
12. #endif
    
13. #define IN      0x0
    
14. #define OUT     0x1
    
15. #define SETMDC(x) ({PDATD=(PDATD&(~(0x1<<6)))|(((unsigned)(x))<<6);})
    
16. #define SETMDIO(x)      (PDATD=(PDATD&(~(0x1<<7)))|(((unsigned)(x))<<7))
    
17. #define GETMDIO()       ((PDATD&(0x1<<7))>>7)
    
18. #define SETMDIOMOD(x)   ({PCOND = (PCOND & (~(0x3<<14))) | ((x)<<14);}) /*****x is IN or OUT*******/
    
19. 
    
20. #define RD_MDIO1(addr)  ({                      \
    
21.                 int j;                          \
    
22.                 register unsigned short x;      \
    
23.                 x=addr;                         \
    
24.                 SETMDIOMOD(OUT);                \
    
25.                 SETMDIO(1);                     \
    
26.                 for(j=0;j<32;j++) {             \
    
27.                         SETMDC(0);              \
    
28.                         SETMDC(1);              \
    
29.                 }                               \
    
30.                 /****ST!01******/               \
    
31.                 SETMDC(0);                      \
    
32.                 SETMDIO(0);                     \
    
33.                 SETMDC(1);                      \
    
34.                 SETMDC(0);                      \
    
35.                 SETMDIO(1);                     \
    
36.                 SETMDC(1);                      \
    
37.                 /***OP!10=READ*******/          \
    
38.                 SETMDC(0);                      \
    
39.                 /*SETMDIO(1);*/                 \
    
40.                 SETMDC(1);                      \
    
41.                 SETMDC(0);                      \
    
42.                 SETMDIO(0);                     \
    
43.                 SETMDC(1);                      \
    
44.                 /***PHYAD!11110*****/           \
    
45.                 SETMDC(0);                      \
    
46.                 SETMDIO(1);                     \
    
47.                 SETMDC(1);                      \
    
48.                 SETMDC(0);                      \
    
49.                 SETMDC(1);                      \
    
50.                 SETMDC(0);                      \
    
51.                 SETMDC(1);                      \
    
52.                 SETMDC(0);                      \
    
53.                 SETMDC(1);                      \
    
54.                 SETMDC(0);                      \
    
55.                 SETMDIO(0);                     \
    
56.                 SETMDC(1);                      \
    
57.                 /***REGAD**********/            \
    
58.                 SETMDC(0);                      \
    
59.                 SETMDIO((x&(0x1<<4))>>4);       \
    
60.                 SETMDC(1);                      \
    
61.                 SETMDC(0);                      \
    
62.                 SETMDIO((x&(0x1<<3))>>3);       \
    
63.                 SETMDC(1);                      \
    
64.                 SETMDC(0);                      \
    
65.                 SETMDIO((x&(0x1<<2))>>2);       \
    
66.                 SETMDC(1);                      \
    
67.                 SETMDC(0);                      \
    
68.                 SETMDIO((x&(0x1<<1))>>1);       \
    
69.                 SETMDC(1);                      \
    
70.                 SETMDC(0);                      \
    
71.                 SETMDIO(x&0x1);         \
    
72.                 SETMDC(1);                      \
    
73.                 /*****TA********/               \
    
74.                 SETMDIOMOD(IN);/**?**/          \
    
75.                 SETMDC(0);                      \
    
76.                 SETMDC(1);                      \
    
77.                 SETMDC(0);                      \
    
78.                 SETMDC(1);                      \
    
79.                 /*****DATA******/               \
    
80.                 x=0;                            \
    
81.                 SETMDC(0);                      \
    
82.                 x |= GETMDIO()<<15;             \
    
83.                 SETMDC(1);                      \
    
84.                 SETMDC(0);                      \
    
85.                 x |= GETMDIO()<<14;             \
    
86.                 SETMDC(1);                      \
    
87.                 SETMDC(0);                      \
    
88.                 x |= GETMDIO()<<13;             \
    
89.                 SETMDC(1);                      \
    
90.                 SETMDC(0);                      \
    
91.                 x |= GETMDIO()<<12;             \
    
92.                 SETMDC(1);                      \
    
93.                 SETMDC(0);                      \
    
94.                 x |= GETMDIO()<<11;             \
    
95.                 SETMDC(1);                      \
    
96.                 SETMDC(0);                      \
    
97.                 x |= GETMDIO()<<10;             \
    
98.                 SETMDC(1);                      \
    
99.                 SETMDC(0);                      \
    
100.                 x |= GETMDIO()<<9;              \
     
101.                 SETMDC(1);                      \
     
102.                 SETMDC(0);                      \
     
103.                 x |= GETMDIO()<<8;              \
     
104.                 SETMDC(1);                      \
     
105.                 SETMDC(0);                      \
     
106.                 x |= GETMDIO()<<7;              \
     
107.                 SETMDC(1);                      \
     
108.                 SETMDC(0);                      \
     
109.                 x |= GETMDIO()<<6;              \
     
110.                 SETMDC(1);                      \
     
111.                 SETMDC(0);                      \
     
112.                 x |= GETMDIO()<<5;              \
     
113.                 SETMDC(1);                      \
     
114.                 SETMDC(0);                      \
     
115.                 x |= GETMDIO()<<4;              \
     
116.                 SETMDC(1);                      \
     
117.                 SETMDC(0);                      \
     
118.                 x |= GETMDIO()<<3;              \
     
119.                 SETMDC(1);                      \
     
120.                 SETMDC(0);                      \
     
121.                 x |= GETMDIO()<<2;              \
     
122.                 SETMDC(1);                      \
     
123.                 SETMDC(0);                      \
     
124.                 x |= GETMDIO()<<1;              \
     
125.                 SETMDC(1);                      \
     
126.                 SETMDC(0);                      \
     
127.                 x |= GETMDIO();                 \
     
128.                 SETMDC(1);                      \
     
129.                 /*******IDLE****/               \
     
130.                 SETMDIOMOD(OUT);                \
     
131.                 SETMDIO(1);                     \
     
132.                 for(j=0;j<1;j++) {              \
     
133.                         SETMDC(0);              \
     
134.                         SETMDC(1);              \
     
135.                 }                               \
     
136.                 x;                              \
     
137.                 })
     
138. 
     
139. #define WR_MDIO(addr,value)     ({              \
     
140.                 int j;                          \
     
141.                 register unsigned short x;      \
     
142.                 SETMDIOMOD(OUT);                \
     
143.                 /****ST!01******/               \
     
144.                 SETMDC(0);                      \
     
145.                 SETMDIO(0);                     \
     
146.                 SETMDC(1);                      \
     
147.                 SETMDC(0);                      \
     
148.                 SETMDIO(1);                     \
     
149.                 SETMDC(1);                      \
     
150.                 /***OP!01=WRITE*******/         \
     
151.                 SETMDC(0);                      \
     
152.                 SETMDIO(0);                     \
     
153.                 SETMDC(1);                      \
     
154.                 SETMDC(0);                      \
     
155.                 SETMDIO(1);                     \
     
156.                 SETMDC(1);                      \
     
157.                 /***PHYAD!11110*****/           \
     
158.                 SETMDC(0);                      \
     
159.                 SETMDIO(1);                     \
     
160.                 SETMDC(1);                      \
     
161.                 SETMDC(0);                      \
     
162.                 SETMDC(1);                      \
     
163.                 SETMDC(0);                      \
     
164.                 SETMDC(1);                      \
     
165.                 SETMDC(0);                      \
     
166.                 SETMDC(1);                      \
     
167.                 SETMDC(0);                      \
     
168.                 SETMDIO(0);                     \
     
169.                 SETMDC(1);                      \
     
170.                 /***REGAD**********/            \
     
171.                 SETMDC(0);                      \
     
172.                 x=addr;                         \
     
173.                 SETMDIO((x&(0x1<<4))>>4);       \
     
174.                 SETMDC(1);                      \
     
175.                 SETMDC(0);                      \
     
176.                 SETMDIO((x&(0x1<<3))>>3);       \
     
177.                 SETMDC(1);                      \
     
178.                 SETMDC(0);                      \
     
179.                 SETMDIO((x&(0x1<<2))>>2);       \
     
180.                 SETMDC(1);                      \
     
181.                 SETMDC(0);                      \
     
182.                 SETMDIO((x&(0x1<<1))>>1);       \
     
183.                 SETMDC(1);                      \
     
184.                 SETMDC(0);                      \
     
185.                 SETMDIO(x&0x1);         \
     
186.                 SETMDC(1);                      \
     
187.                 /*****TA********/               \
     
188.                 /*SETMDIOMOD(IN);*//**?**/      \
     
189.                 SETMDC(0);                      \
     
190.                 SETMDIO(1);                     \
     
191.                 SETMDC(1);                      \
     
192.                 SETMDC(0);                      \
     
193.                 SETMDIO(0);                     \
     
194.                 SETMDC(1);                      \
     
195.                 /*****DATA******/               \
     
196.                 /*SETMDIOMOD(OUT);*/            \
     
197.                 x=value;                        \
     
198.                 SETMDC(0);                      \
     
199.                 SETMDIO((x&((0x1)<<15))>>15);   \
     
200.                 SETMDC(1);                      \
     
201.                 SETMDC(0);                      \
     
202.                 SETMDIO((x&((0x1)<<14))>>14);   \
     
203.                 SETMDC(1);                      \
     
204.                 SETMDC(0);                      \
     
205.                 SETMDIO((x&((0x1)<<13))>>13);   \
     
206.                 SETMDC(1);                      \
     
207.                 SETMDC(0);                      \
     
208.                 SETMDIO((x&((0x1)<<12))>>12);   \
     
209.                 SETMDC(1);                      \
     
210.                 SETMDC(0);                      \
     
211.                 SETMDIO((x&((0x1)<<11))>>11);   \
     
212.                 SETMDC(1);                      \
     
213.                 SETMDC(0);                      \
     
214.                 SETMDIO((x&((0x1)<<10))>>10);   \
     
215.                 SETMDC(1);                      \
     
216.                 SETMDC(0);                      \
     
217.                 SETMDIO((x&((0x1)<<9))>>9);     \
     
218.                 SETMDC(1);                      \
     
219.                 SETMDC(0);                      \
     
220.                 SETMDIO((x&((0x1)<<8))>>8);     \
     
221.                 SETMDC(1);                      \
     
222.                 SETMDC(0);                      \
     
223.                 SETMDIO((x&((0x1)<<7))>>7);     \
     
224.                 SETMDC(1);                      \
     
225.                 SETMDC(0);                      \
     
226.                 SETMDIO((x&((0x1)<<6))>>6);     \
     
227.                 SETMDC(1);                      \
     
228.                 SETMDC(0);                      \
     
229.                 SETMDIO((x&((0x1)<<5))>>5);     \
     
230.                 SETMDC(1);                      \
     
231.                 SETMDC(0);                      \
     
232.                 SETMDIO((x&((0x1)<<4))>>4);     \
     
233.                 SETMDC(1);                      \
     
234.                 SETMDC(0);                      \
     
235.                 SETMDIO((x&((0x1)<<3))>>3);     \
     
236.                 SETMDC(1);                      \
     
237.                 SETMDC(0);                      \
     
238.                 SETMDIO((x&((0x1)<<2))>>2);     \
     
239.                 SETMDC(1);                      \
     
240.                 SETMDC(0);                      \
     
241.                 SETMDIO((x&((0x1)<<1))>>1);     \
     
242.                 SETMDC(1);                      \
     
243.                 SETMDC(0);                      \
     
244.                 SETMDIO(x&0x1);                 \
     
245.                 SETMDC(1);                      \
     
246.                 /*******IDLE****/               \
     
247.                 SETMDIO(1);                     \
     
248.                 for(j=0;j<1;j++) {              \
     
249.                         SETMDC(0);              \
     
250.                         SETMDC(1);              \
     
251.                 }                               \
     
252.                 })
     
253. 
     
254. int read_MDC_MDIO_reverse(unsigned char page,unsigned char addr,unsigned char*dest,int len)
     
255. {
     
256.         unsigned short tmp;
     
257.         int i;
     
258.         tmp = 0x01 | (((unsigned short)page)<<8);
     
259.         WR_MDIO(16,tmp);
     
260.         tmp = 0x02 | (((unsigned short)addr)<<8);
     
261.         WR_MDIO(17,tmp);
     
262.         while(1) {
     
263.                 tmp = RD_MDIO(17);
     
264.                 if((tmp & 0x3) == 0)
     
265.                         break;
     
266.         }
     
267.         for(i=len;i>0;i-=2) {
     
268.                 tmp = RD_MDIO(23+i/2);
     
269.                 dest[0] = tmp>>8;
     
270.                 dest[-1] = tmp;
     
271.                 dest -= 2;
     
272.         }
     
273.         return 0;
     
274. }
     
275. 
     
276. int write_MDC_MDIO(unsigned char page,unsigned char addr,const unsigned char*src,int len)
     
277. {
     
278.         unsigned short tmp;
     
279.         int i;
     
280.         tmp = 0x01 | (((unsigned short)page)<<8);
     
281.         WR_MDIO(16,tmp);
     
282.         for(i=0;i<len;i+=2) {
     
283.                 tmp = (unsigned short)src[0]<<8;
     
284.                 if(i != len-1)
     
285.                         tmp |= (unsigned short)src[1];
     
286.                 WR_MDIO(24+i/2,tmp);
     
287.                 src += 2;
     
288.         }
     
289.         tmp = 0x01 | (((unsigned short)addr)<<8);
     
290.         WR_MDIO(17,tmp);
     
291.         while(1) {
     
292.                 tmp = RD_MDIO(17);
     
293.                 if((tmp & 0x3) == 0)
     
294.                         break;
     
295.         }
     
296.         return 0;
     
297. }
     

复制代码

咱就没有整明白了,它怎么就屏蔽了实现了.

[ 本帖最后由 cjaizss 于 2009-12-30 09:17 编辑 ]

怪怪虎

原帖由 cjaizss 于 2009-12-29 13:41 发表

呵呵,你用C语言看不出来的话,你用汇编一样看不出来,打个比方
*(volatile unsigned*)(0x0d000000) = 1
换成汇编假如长这样:
mov r1,0x0d000000
mov *r1,0x1
你能通过这样的语句知道处理器是如何控制各信号 ...

看来是后者(协议)没理解好.
我有重新整理了下思路.
由于器件的可编程性,我们索性就通过配置寄存器来设置某款芯片使用的"协议". (多个寄存器的不同配置共同构成了某个芯片的协议).
在软件中,对硬件的访问也只可能通过寄存器的访问.
在你给的例子中,0x0d000000应该是对应某个寄存器的地址吧.

我的这个理解没错吧.请指教.^_^

自由建客

不知道你学过计算机网络没

cjaizss

原帖由 怪怪虎 于 2009-12-29 14:06 发表


看来是后者(协议)没理解好.
我有重新整理了下思路.
由于器件的可编程性,我们索性就通过配置寄存器来设置某款芯片使用的"协议". (多个寄存器的不同配置共同构成了某个芯片的协议).
在软件中,对硬件的访问 ...

这个认识也不一定对.
协议其实就是一规范,双方依照这规范办事即可.
完整的协议可能是用小的协议搭建起来的.
比如localbus是一套协议,你采用localbus配置寄存器以完成一个功能,这也是一个协议,但这个协议是建立在localbus之上的.
再者,我刚才贴的代码本身就是一个读写某IC的寄存器的协议.

怪怪虎

原帖由 自由建客 于 2009-12-29 14:10 发表
不知道你学过计算机网络没

学过,愿问其详.
PS.
难道你想套用网络里的协议?虽然他们存在着某些相似点, 我个人认为网络里的协议和这里要实现的协议,有一定的差距.(个人观点)

[ 本帖最后由 怪怪虎 于 2009-12-29 14:47 编辑 ]

怪怪虎

原帖由 cjaizss 于 2009-12-29 14:16 发表

这个认识也不一定对.
协议其实就是一规范,双方依照这规范办事即可.
完整的协议可能是用小的协议搭建起来的.
比如localbus是一套协议,你采用localbus配置寄存器以完成一个功能,这也是一个协议,但这个协议是 ...

先出去几个小时,回来在接着看.感觉你的引导,让我在逐渐的了解这个咚咚, 先谢谢 ^_^.

怪怪虎

原帖由 cjaizss 于 2009-12-29 13:50 发表

另外,协议要参照的不是代码,而是manual,datasheet!!!
我把我最近使用的一个硬件的硬件驱动部分代码节选一下给你看下

/*
*      Using MDC/MDIO
         PC4    MDC
         PC5    MDIO
*/
#ifde ...

以前确实没见过这样的驱动code,(太菜了). 坦白的说,没有看出code(#define RD_MDIO1和#define WR_MDIO)怎样驱动硬件来. 从code的注释看,好像是按照某种"协议"在做事请.
*****ST!01***
*****OP!10***
*****PHYAD***
*****REGAD***
*****TA******
*****DATA****
也许看了硬件手册后,才能清楚些. (准备找个硬件datasheet学习下)

另外,时序和指令应该没有太大的关系.
时序电路是固定的. cpu只会在某个时钟的上升沿或者下降沿读取/执行指令.  (以前老是认为不同的指令对应着不同的时序)

cjaizss

原帖由 怪怪虎 于 2009-12-29 22:14 发表


以前确实没见过这样的驱动code,(太菜了). 坦白的说,没有看出code(#define RD_MDIO1和#define WR_MDIO)怎样驱动硬件来. 从code的注释看,好像是按照某种"协议"在做事请.
*****ST!01***
*****OP!10***
**** ...

这个与硬件设计有关,恕我不能把这些给你,不过我可以给你一些例子.
用gpio来模拟硬件接口协议的例子.

cjaizss

打个比方吧,你可以使用GPIO模拟一个IIC吗?
IIC你可以参照
http://www.mcufan.com/xinshou/mcu-iic.htm
SCL和SDA两根线通信.
SCL和SDA接的都是处理器上的GPIO
假设我已经实现好
SETSCL(x)
SETSDA(x)
GETSCL()
GETSDA()
SETSCLMOD(x)/*IN or OUT*/
SETSDAMOD(x)/*IN or OUT*/

[ 本帖最后由 cjaizss 于 2009-12-30 09:53 编辑 ]