]>
Commit | Line | Data |
---|---|---|
fe8c2806 WD |
1 | #include <common.h> |
2 | #include <malloc.h> | |
3 | ||
4 | #if (CONFIG_COMMANDS & CFG_CMD_BSP) | |
5 | #include <command.h> | |
fe8c2806 WD |
6 | #endif |
7 | ||
8 | #include <pci.h> | |
9 | #include <galileo/pci.h> | |
10 | #include "zuma_pbb.h" | |
11 | ||
12 | #undef DEBUG | |
13 | ||
14 | #define PAT_LO 0x00010203 | |
15 | #define PAT_HI 0x04050607 | |
16 | ||
17 | static PBB_DMA_REG_MAP *zuma_pbb_reg = NULL; | |
fe8c2806 WD |
18 | static char test_buf1[2048]; |
19 | static char test_buf2[2048]; | |
8bde7f77 WD |
20 | void zuma_init_pbb(void); |
21 | int zuma_mbox_init(void); | |
22 | int zuma_test_dma(int cmd, int size); | |
fe8c2806 WD |
23 | |
24 | int zuma_test_dma (int cmd, int size) | |
25 | { | |
26 | static const char *const test_legend[] = { | |
27 | "write", "verify", | |
28 | "copy", "compare", | |
29 | "write inc", "verify inc" | |
30 | }; | |
31 | register int i, j; | |
32 | unsigned int p1 = ((unsigned int) test_buf1 + 0xff) & (~0xff); | |
33 | unsigned int p2 = ((unsigned int) test_buf2 + 0xff) & (~0xff); | |
34 | volatile unsigned int *ps = (unsigned int *) p1; | |
35 | volatile unsigned int *pd = (unsigned int *) p2; | |
36 | unsigned int funct, pat_lo = PAT_LO, pat_hi = PAT_HI; | |
37 | DMA_INT_STATUS stat; | |
38 | int ret = 0; | |
39 | ||
40 | if (!zuma_pbb_reg) { | |
41 | printf ("not initted\n"); | |
42 | return -1; | |
43 | } | |
44 | ||
45 | if (cmd < 0 || cmd > 5) { | |
46 | printf ("inv cmd %d\n", cmd); | |
47 | return -1; | |
48 | } | |
49 | ||
50 | if (cmd == 2 || cmd == 3) { | |
51 | /* not implemented */ | |
52 | return 0; | |
53 | } | |
54 | ||
55 | if (size <= 0 || size > 1024) | |
56 | size = 1024; | |
57 | ||
58 | size &= (~7); /* throw away bottom 3 bits */ | |
59 | ||
60 | p1 = ((unsigned int) test_buf1 + 0xff) & (~0xff); | |
61 | p2 = ((unsigned int) test_buf2 + 0xff) & (~0xff); | |
62 | ||
63 | memset ((void *) p1, 0, size); | |
64 | memset ((void *) p2, 0, size); | |
65 | ||
66 | for (i = 0; i < size / 4; i += 2) { | |
67 | ps[i] = pat_lo; | |
68 | ps[i + 1] = pat_hi; | |
69 | if (cmd == 4 || cmd == 5) { | |
70 | unsigned char *pl = (unsigned char *) &pat_lo; | |
71 | unsigned char *ph = (unsigned char *) &pat_hi; | |
72 | ||
73 | for (j = 0; j < 4; j++) { | |
74 | pl[j] += 8; | |
75 | ph[j] += 8; | |
76 | } | |
77 | } | |
78 | } | |
79 | ||
80 | funct = (1 << 31) | (cmd << 24) | (size); | |
81 | ||
82 | zuma_pbb_reg->int_mask.pci_bits.chan0 = | |
83 | EOF_RX_FLAG | EOF_TX_FLAG | EOB_TX_FLAG; | |
84 | ||
85 | zuma_pbb_reg->debug_57 = PAT_LO; /* patl */ | |
86 | zuma_pbb_reg->debug_58 = PAT_HI; /* path */ | |
87 | ||
88 | zuma_pbb_reg->debug_54 = cpu_to_le32 (p1); /* src 0x01b0 */ | |
89 | zuma_pbb_reg->debug_55 = cpu_to_le32 (p2); /* dst 0x01b8 */ | |
90 | zuma_pbb_reg->debug_56 = cpu_to_le32 (funct); /* func, 0x01c0 */ | |
91 | ||
92 | /* give DMA time to chew on things.. dont use DRAM or PCI */ | |
93 | /* if you can avoid it. */ | |
94 | do { | |
95 | for (i = 0; i < 1000 * 10; i++); | |
96 | } while (le32_to_cpu (zuma_pbb_reg->debug_56) & (1 << 31)); | |
97 | ||
98 | stat.word = zuma_pbb_reg->status.word; | |
99 | zuma_pbb_reg->int_mask.word = 0; | |
100 | ||
101 | printf ("stat: %08x (%x)\n", stat.word, stat.pci_bits.chan0); | |
102 | ||
103 | printf ("func: %08x\n", le32_to_cpu (zuma_pbb_reg->debug_56)); | |
104 | printf ("src @%08x: %08x %08x %08x %08x\n", p1, ps[0], ps[1], ps[2], | |
105 | ps[3]); | |
106 | printf ("dst @%08x: %08x %08x %08x %08x\n", p2, pd[0], pd[1], pd[2], | |
107 | pd[3]); | |
108 | printf ("func: %08x\n", le32_to_cpu (zuma_pbb_reg->debug_56)); | |
109 | ||
110 | ||
111 | if (cmd == 0 || cmd == 4) { | |
112 | /* this is a write */ | |
113 | if (!(stat.pci_bits.chan0 & EOF_RX_FLAG) || /* not done */ | |
114 | (memcmp ((void *) ps, (void *) pd, size) != 0)) { /* cmp error */ | |
115 | for (i = 0; i < size / 4; i += 2) { | |
116 | if ((ps[i] != pd[i]) || (ps[i + 1] != pd[i + 1])) { | |
117 | printf ("s @%p:%08x %08x\n", &ps[i], ps[i], ps[i + 1]); | |
118 | printf ("d @%p:%08x %08x\n", &pd[i], pd[i], pd[i + 1]); | |
119 | } | |
120 | } | |
121 | ret = -1; | |
122 | } | |
123 | } else { | |
124 | /* this is a verify */ | |
125 | if (!(stat.pci_bits.chan0 & EOF_TX_FLAG) || /* not done */ | |
126 | (stat.pci_bits.chan0 & EOB_TX_FLAG)) { /* cmp error */ | |
127 | printf ("%08x: %08x %08x\n", | |
128 | le32_to_cpu (zuma_pbb_reg->debug_63), | |
129 | zuma_pbb_reg->debug_61, zuma_pbb_reg->debug_62); | |
130 | ret = -1; | |
131 | } | |
132 | } | |
133 | ||
134 | printf ("%s cmd %d, %d bytes: %s!\n", test_legend[cmd], cmd, size, | |
135 | (ret == 0) ? "PASSED" : "FAILED"); | |
136 | return 0; | |
137 | } | |
138 | ||
139 | void zuma_init_pbb (void) | |
140 | { | |
141 | unsigned int iobase; | |
142 | pci_dev_t dev = | |
143 | pci_find_device (VENDOR_ID_ZUMA, DEVICE_ID_ZUMA_PBB, 0); | |
144 | ||
145 | if (dev == -1) { | |
146 | printf ("no zuma pbb\n"); | |
147 | return; | |
148 | } | |
149 | ||
150 | pci_read_config_dword (dev, PCI_BASE_ADDRESS_0, &iobase); | |
151 | ||
152 | zuma_pbb_reg = | |
153 | (PBB_DMA_REG_MAP *) (iobase & PCI_BASE_ADDRESS_MEM_MASK); | |
154 | ||
155 | if (!zuma_pbb_reg) { | |
156 | printf ("zuma pbb bar none! (hah hah, get it?)\n"); | |
157 | return; | |
158 | } | |
159 | ||
160 | zuma_pbb_reg->int_mask.word = 0; | |
161 | ||
162 | printf ("pbb @ %p v%d.%d, timestamp %08x\n", zuma_pbb_reg, | |
163 | zuma_pbb_reg->version.pci_bits.rev_major, | |
164 | zuma_pbb_reg->version.pci_bits.rev_minor, | |
165 | zuma_pbb_reg->timestamp); | |
166 | ||
167 | } | |
168 | ||
169 | #if (CONFIG_COMMANDS & CFG_CMD_BSP) | |
170 | ||
171 | static int last_cmd = 4; /* write increment */ | |
172 | static int last_size = 64; | |
173 | ||
174 | int | |
175 | do_zuma_init_pbb (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) | |
176 | { | |
177 | zuma_init_pbb (); | |
178 | return 0; | |
179 | } | |
180 | ||
181 | int | |
182 | do_zuma_test_dma (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) | |
183 | { | |
184 | if (argc > 1) { | |
185 | last_cmd = simple_strtoul (argv[1], NULL, 10); | |
186 | } | |
187 | if (argc > 2) { | |
188 | last_size = simple_strtoul (argv[2], NULL, 10); | |
189 | } | |
190 | zuma_test_dma (last_cmd, last_size); | |
191 | return 0; | |
192 | } | |
193 | ||
194 | int | |
195 | do_zuma_init_mbox (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) | |
196 | { | |
197 | zuma_mbox_init (); | |
198 | return 0; | |
199 | } | |
200 | ||
0d498393 WD |
201 | U_BOOT_CMD( |
202 | zinit, 1, 0, do_zuma_init_pbb, | |
8bde7f77 WD |
203 | "zinit - init zuma pbb\n", |
204 | "\n" | |
205 | " - init zuma pbb\n" | |
206 | ); | |
0d498393 WD |
207 | U_BOOT_CMD( |
208 | zdtest, 3, 1, do_zuma_test_dma, | |
8bde7f77 WD |
209 | "zdtest - run dma test\n", |
210 | "[cmd [count]]\n" | |
211 | " - run dma cmd (w=0,v=1,cp=2,cmp=3,wi=4,vi=5), count bytes\n" | |
212 | ); | |
0d498393 WD |
213 | U_BOOT_CMD( |
214 | zminit, 1, 0, do_zuma_init_mbox, | |
8bde7f77 WD |
215 | "zminit - init zuma mbox\n", |
216 | "\n" | |
217 | " - init zuma mbox\n" | |
218 | ); | |
219 | ||
fe8c2806 | 220 | #endif /* CFG_CMD_BSP */ |