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 "pld.h"
  25 #include "log.h"
  26 #include "time_support.h"
  27
  28
  29 /* pld drivers
  30  */
  31 extern pld_driver_t virtex2_pld;
  32
  33 pld_driver_t *pld_drivers[] =
  34 {
  35         &virtex2_pld,
  36         NULL,
  37 };
  38
  39 pld_device_t *pld_devices;
  40 static command_t *pld_cmd;
  41
  42 int handle_pld_devices_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  43 int handle_pld_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  44 int handle_pld_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  45
  46 int pld_init(struct command_context_s *cmd_ctx)
  47 {
  48         if (pld_devices)
  49         {
  50                 register_command(cmd_ctx, pld_cmd, "devices", handle_pld_devices_command, COMMAND_EXEC,
  51                                                 "list configured pld devices");
  52                 register_command(cmd_ctx, pld_cmd, "load", handle_pld_load_command, COMMAND_EXEC,
  53                                                 "load configuration <file> into programmable logic device");
  54         }
  55
  56         return ERROR_OK;
  57 }
  58
  59 pld_device_t *get_pld_device_by_num(int num)
  60 {
  61         pld_device_t *p;
  62         int i = 0;
  63
  64         for (p = pld_devices; p; p = p->next)
  65         {
  66                 if (i++ == num)
  67                 {
  68                         return p;
  69                 }
  70         }
  71
  72         return NULL;
  73 }
  74
  75 /* pld device <driver> [driver_options ...]
  76  */
  77 int handle_pld_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
  78 {
  79         int i;
  80         int found = 0;
  81
  82         if (argc < 1)
  83         {
  84                 LOG_WARNING("incomplete 'pld bank' configuration");
  85                 return ERROR_OK;
  86         }
  87
  88         for (i = 0; pld_drivers[i]; i++)
  89         {
  90                 if (strcmp(args[0], pld_drivers[i]->name) == 0)
  91                 {
  92                         pld_device_t *p, *c;
  93
  94                         /* register pld specific commands */
  95                         if (pld_drivers[i]->register_commands(cmd_ctx) != ERROR_OK)
  96                         {
  97                                 LOG_ERROR("couldn't register '%s' commands", args[0]);
  98                                 exit(-1);
  99                         }
 100
 101                         c = malloc(sizeof(pld_device_t));
 102                         c->driver = pld_drivers[i];
 103                         c->next = NULL;
 104
 105                         if (pld_drivers[i]->pld_device_command(cmd_ctx, cmd, args, argc, c) != ERROR_OK)
 106                         {
 107                                 LOG_ERROR("'%s' driver rejected pld device", args[0]);
 108                                 free(c);
 109                                 return ERROR_OK;
 110                         }
 111
 112                         /* put pld device in linked list */
 113                         if (pld_devices)
 114                         {
 115                                 /* find last pld device */
 116                                 for (p = pld_devices; p && p->next; p = p->next);
 117                                 if (p)
 118                                         p->next = c;
 119                         }
 120                         else
 121                         {
 122                                 pld_devices = c;
 123                         }
 124
 125                         found = 1;
 126                 }
 127         }
 128
 129         /* no matching pld driver found */
 130         if (!found)
 131         {
 132                 LOG_ERROR("pld driver '%s' not found", args[0]);
 133                 exit(-1);
 134         }
 135
 136         return ERROR_OK;
 137 }
 138
 139 int handle_pld_devices_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 140 {
 141         pld_device_t *p;
 142         int i = 0;
 143
 144         if (!pld_devices)
 145         {
 146                 command_print(cmd_ctx, "no pld devices configured");
 147                 return ERROR_OK;
 148         }
 149
 150         for (p = pld_devices; p; p = p->next)
 151         {
 152                 command_print(cmd_ctx, "#%i: %s", i++, p->driver->name);
 153         }
 154
 155         return ERROR_OK;
 156 }
 157
 158 int handle_pld_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 159 {
 160         int retval;
 161         struct timeval start, end, duration;
 162         pld_device_t *p;
 163
 164         gettimeofday(&start, NULL);
 165
 166         if (argc < 2)
 167         {
 168                 command_print(cmd_ctx, "usage: pld load <device#> <file>");
 169                 return ERROR_OK;
 170         }
 171
 172         p = get_pld_device_by_num(strtoul(args[0], NULL, 0));
 173         if (!p)
 174         {
 175                 command_print(cmd_ctx, "pld device '#%s' is out of bounds", args[0]);
 176                 return ERROR_OK;
 177         }
 178
 179         if ((retval = p->driver->load(p, args[1])) != ERROR_OK)
 180         {
 181                 command_print(cmd_ctx, "failed loading file %s to pld device %lu",
 182                         args[1], strtoul(args[0], NULL, 0));
 183                 switch (retval)
 184                 {
 185                 }
 186         }
 187         else
 188         {
 189                 gettimeofday(&end, NULL);
 190                 timeval_subtract(&duration, &end, &start);
 191
 192                 command_print(cmd_ctx, "loaded file %s to pld device %lu in %lis %lius",
 193                         args[1], strtoul(args[0], NULL, 0),
 194                         duration.tv_sec, duration.tv_usec);
 195         }
 196
 197         return ERROR_OK;
 198 }
 199
 200 int pld_register_commands(struct command_context_s *cmd_ctx)
 201 {
 202         pld_cmd = register_command(cmd_ctx, NULL, "pld", NULL, COMMAND_ANY, "programmable logic device commands");
 203
 204         register_command(cmd_ctx, pld_cmd, "device", handle_pld_device_command, COMMAND_CONFIG, NULL);
 205
 206         return ERROR_OK;
 207 }