git.sur5r.net Git - u-boot/blob - 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 #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;
  18 static char test_buf1[2048];
  19 static char test_buf2[2048];
  20 void zuma_init_pbb(void);
  21 int zuma_mbox_init(void);
  22 int zuma_test_dma(int cmd, int size);
  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
 201 U_BOOT_CMD(
 202         zinit,   1,      0,      do_zuma_init_pbb,
 203         "zinit   - init zuma pbb\n",
 204         "\n"
 205         "    - init zuma pbb\n"
 206 );
 207 U_BOOT_CMD(
 208         zdtest,   3,      1,      do_zuma_test_dma,
 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 );
 213 U_BOOT_CMD(
 214         zminit,   1,      0,      do_zuma_init_mbox,
 215         "zminit  - init zuma mbox\n",
 216         "\n"
 217         "    - init zuma mbox\n"
 218 );
 219
 220 #endif /* CFG_CMD_BSP */