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