git.gag.com Git - fw/openocd/blob - src/pld/pld.c

   1 /***************************************************************************
   2  *   Copyright (C) 2006 by Dominic Rath                                    *
   3  *   Dominic.Rath@gmx.de                                                   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include "replacements.h"
  25
  26 #include "pld.h"
  27
  28 #include "jtag.h"
  29 #include "command.h"
  30 #include "log.h"
  31 #include "time_support.h"
  32
  33 #include <stdlib.h>
  34 #include <unistd.h>
  35 #include <sys/stat.h>
  36 #include <fcntl.h>
  37 #include <string.h>
  38
  39 #include <sys/time.h>
  40 #include <time.h>
  41
  42 /* pld drivers
  43  */
  44 extern pld_driver_t virtex2_pld;
  45
  46 pld_driver_t *pld_drivers[] =
  47 {
  48         &virtex2_pld,
  49         NULL,
  50 };
  51
  52 pld_device_t *pld_devices;
  53 static command_t *pld_cmd;
  54
  55 int handle_pld_devices_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  56 int handle_pld_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  57 int handle_pld_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  58
  59 int pld_init(struct command_context_s *cmd_ctx)
  60 {
  61         if (pld_devices)
  62         {
  63                 register_command(cmd_ctx, pld_cmd, "devices", handle_pld_devices_command, COMMAND_EXEC,
  64                                                 "list configured pld devices");
  65                 register_command(cmd_ctx, pld_cmd, "load", handle_pld_load_command, COMMAND_EXEC,
  66                                                 "load configuration <file> into programmable logic device");
  67         }
  68
  69         return ERROR_OK;
  70 }
  71
  72 pld_device_t *get_pld_device_by_num(int num)
  73 {
  74         pld_device_t *p;
  75         int i = 0;
  76
  77         for (p = pld_devices; p; p = p->next)
  78         {
  79                 if (i++ == num)
  80                 {
  81                         return p;
  82                 }
  83         }
  84
  85         return NULL;
  86 }
  87
  88 /* pld device <driver> [driver_options ...]
  89  */
  90 int handle_pld_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  91 {
  92         int i;
  93         int found = 0;
  94
  95         if (argc < 1)
  96         {
  97                 LOG_WARNING("incomplete 'pld bank' configuration");
  98                 return ERROR_OK;
  99         }
 100
 101         for (i = 0; pld_drivers[i]; i++)
 102         {
 103                 if (strcmp(args[0], pld_drivers[i]->name) == 0)
 104                 {
 105                         pld_device_t *p, *c;
 106
 107                         /* register pld specific commands */
 108                         if (pld_drivers[i]->register_commands(cmd_ctx) != ERROR_OK)
 109                         {
 110                                 LOG_ERROR("couldn't register '%s' commands", args[0]);
 111                                 exit(-1);
 112                         }
 113
 114                         c = malloc(sizeof(pld_device_t));
 115                         c->driver = pld_drivers[i];
 116                         c->next = NULL;
 117
 118                         if (pld_drivers[i]->pld_device_command(cmd_ctx, cmd, args, argc, c) != ERROR_OK)
 119                         {
 120                                 LOG_ERROR("'%s' driver rejected pld device", args[0]);
 121                                 free(c);
 122                                 return ERROR_OK;
 123                         }
 124
 125                         /* put pld device in linked list */
 126                         if (pld_devices)
 127                         {
 128                                 /* find last pld device */
 129                                 for (p = pld_devices; p && p->next; p = p->next);
 130                                 if (p)
 131                                         p->next = c;
 132                         }
 133                         else
 134                         {
 135                                 pld_devices = c;
 136                         }
 137
 138                         found = 1;
 139                 }
 140         }
 141
 142         /* no matching pld driver found */
 143         if (!found)
 144         {
 145                 LOG_ERROR("pld driver '%s' not found", args[0]);
 146                 exit(-1);
 147         }
 148
 149         return ERROR_OK;
 150 }
 151
 152 int handle_pld_devices_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 153 {
 154         pld_device_t *p;
 155         int i = 0;
 156
 157         if (!pld_devices)
 158         {
 159                 command_print(cmd_ctx, "no pld devices configured");
 160                 return ERROR_OK;
 161         }
 162
 163         for (p = pld_devices; p; p = p->next)
 164         {
 165                 command_print(cmd_ctx, "#%i: %s", i++, p->driver->name);
 166         }
 167
 168         return ERROR_OK;
 169 }
 170
 171 int handle_pld_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 172 {
 173         int retval;
 174         struct timeval start, end, duration;
 175         pld_device_t *p;
 176
 177         gettimeofday(&start, NULL);
 178
 179         if (argc < 2)
 180         {
 181                 command_print(cmd_ctx, "usage: pld load <device#> <file>");
 182                 return ERROR_OK;
 183         }
 184
 185         p = get_pld_device_by_num(strtoul(args[0], NULL, 0));
 186         if (!p)
 187         {
 188                 command_print(cmd_ctx, "pld device '#%s' is out of bounds", args[0]);
 189                 return ERROR_OK;
 190         }
 191
 192         if ((retval = p->driver->load(p, args[1])) != ERROR_OK)
 193         {
 194                 command_print(cmd_ctx, "failed loading file %s to pld device %i",
 195                         args[1], strtoul(args[0], NULL, 0));
 196                 switch (retval)
 197                 {
 198                 }
 199         }
 200         else
 201         {
 202                 gettimeofday(&end, NULL);
 203                 timeval_subtract(&duration, &end, &start);
 204
 205                 command_print(cmd_ctx, "loaded file %s to pld device %i in %is %ius",
 206                         args[1], strtoul(args[0], NULL, 0), duration.tv_sec, duration.tv_usec);
 207         }
 208
 209         return ERROR_OK;
 210 }
 211
 212 int pld_register_commands(struct command_context_s *cmd_ctx)
 213 {
 214         pld_cmd = register_command(cmd_ctx, NULL, "pld", NULL, COMMAND_ANY, "programmable logic device commands");
 215
 216         register_command(cmd_ctx, pld_cmd, "device", handle_pld_device_command, COMMAND_CONFIG, NULL);
 217
 218         return ERROR_OK;
 219 }