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