usr.sbin/fwcontrol/fwcontrol.c

   1 /*
   2  * Copyright (C) 2002
   3  *      Hidetoshi Shimokawa. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *
  16  *      This product includes software developed by Hidetoshi Shimokawa.
  17  *
  18  * 4. Neither the name of the author nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $FreeBSD: src/usr.sbin/fwcontrol/fwcontrol.c,v 1.1.2.8 2003/05/01 06:26:35 simokawa Exp $
  35  * $DragonFly: src/usr.sbin/fwcontrol/fwcontrol.c,v 1.3 2003/08/08 04:18:44 dillon Exp $
  36  */
  37
  38 #include <sys/param.h>
  39 #include <sys/malloc.h>
  40 #include <sys/socket.h>
  41 #include <sys/ioctl.h>
  42 #include <sys/errno.h>
  43 #include <bus/firewire/firewire.h>
  44 #include <bus/firewire/iec13213.h>
  45
  46 #include <netinet/in.h>
  47 #include <fcntl.h>
  48 #include <stdio.h>
  49 #include <err.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <unistd.h>
  53
  54 extern int dvrecv(int, char *, char, int);
  55 extern int dvsend(int, char *, char, int);
  56
  57 static void
  58 usage(void)
  59 {
  60         fprintf(stderr,
  61                 "fwcontrol [-g gap_count] [-o node] [-b pri_req] [-c node]"
  62                         " [-r] [-t] [-d node] [-l file] [-R file] [-S file]\n"
  63                 "\t-g: broadcast gap_count by phy_config packet\n"
  64                 "\t-o: send link-on packet to the node\n"
  65                 "\t-s: write RESET_START register on the node\n"
  66                 "\t-b: set PRIORITY_BUDGET register on all supported nodes\n"
  67                 "\t-c: read configuration ROM\n"
  68                 "\t-r: bus reset\n"
  69                 "\t-t: read topology map\n"
  70                 "\t-d: hex dump of configuration ROM\n"
  71                 "\t-l: load and parse hex dump file of configuration ROM\n"
  72                 "\t-R: Receive DV stream\n"
  73                 "\t-S: Send DV stream\n");
  74         exit(0);
  75 }
  76
  77 static struct fw_devlstreq *
  78 get_dev(int fd)
  79 {
  80         struct fw_devlstreq *data;
  81
  82         data = (struct fw_devlstreq *)malloc(sizeof(struct fw_devlstreq));
  83         if (data == NULL)
  84                 err(1, "malloc");
  85         if( ioctl(fd, FW_GDEVLST, data) < 0) {
  86                         err(1, "ioctl");
  87         }
  88         return data;
  89 }
  90
  91 static void
  92 list_dev(int fd)
  93 {
  94         struct fw_devlstreq *data;
  95         struct fw_devinfo *devinfo;
  96         int i;
  97
  98         data = get_dev(fd);
  99         printf("%d devices (info_len=%d)\n", data->n, data->info_len);
 100         printf("node       EUI64       status\n");
 101         for (i = 0; i < data->info_len; i++) {
 102                 devinfo = &data->dev[i];
 103                 printf("%4d  %08x%08x %6d\n",
 104                         (devinfo->status || i == 0) ? devinfo->dst : -1,
 105                         devinfo->eui.hi,
 106                         devinfo->eui.lo,
 107                         devinfo->status
 108                 );
 109         }
 110         free((void *)data);
 111 }
 112
 113 static u_int32_t
 114 read_write_quad(int fd, struct fw_eui64 eui, u_int32_t addr_lo, int read, u_int32_t data)
 115 {
 116         struct fw_asyreq *asyreq;
 117         u_int32_t *qld, res;
 118
 119         asyreq = (struct fw_asyreq *)malloc(sizeof(struct fw_asyreq_t) + 16);
 120         asyreq->req.len = 16;
 121 #if 0
 122         asyreq->req.type = FWASREQNODE;
 123         asyreq->pkt.mode.rreqq.dst = FWLOCALBUS | node;
 124 #else
 125         asyreq->req.type = FWASREQEUI;
 126         asyreq->req.dst.eui = eui;
 127 #endif
 128         asyreq->pkt.mode.rreqq.tlrt = 0;
 129         if (read)
 130                 asyreq->pkt.mode.rreqq.tcode = FWTCODE_RREQQ;
 131         else
 132                 asyreq->pkt.mode.rreqq.tcode = FWTCODE_WREQQ;
 133
 134         asyreq->pkt.mode.rreqq.dest_hi = 0xffff;
 135         asyreq->pkt.mode.rreqq.dest_lo = addr_lo;
 136
 137         qld = (u_int32_t *)&asyreq->pkt;
 138         if (!read)
 139                 asyreq->pkt.mode.wreqq.data = data;
 140
 141         if (ioctl(fd, FW_ASYREQ, asyreq) < 0) {
 142                 err(1, "ioctl");
 143         }
 144         res = qld[3];
 145         free(asyreq);
 146         if (read)
 147                 return ntohl(res);
 148         else
 149                 return 0;
 150 }
 151
 152 static void
 153 send_phy_config(int fd, int root_node, int gap_count)
 154 {
 155         struct fw_asyreq *asyreq;
 156
 157         asyreq = (struct fw_asyreq *)malloc(sizeof(struct fw_asyreq_t) + 12);
 158         asyreq->req.len = 12;
 159         asyreq->req.type = FWASREQNODE;
 160         asyreq->pkt.mode.ld[0] = 0;
 161         asyreq->pkt.mode.ld[1] = 0;
 162         asyreq->pkt.mode.common.tcode = FWTCODE_PHY;
 163         if (root_node >= 0)
 164                 asyreq->pkt.mode.ld[1] |= (root_node & 0x3f) << 24 | 1 << 23;
 165         if (gap_count >= 0)
 166                 asyreq->pkt.mode.ld[1] |= 1 << 22 | (gap_count & 0x3f) << 16;
 167         asyreq->pkt.mode.ld[2] = ~asyreq->pkt.mode.ld[1];
 168
 169         printf("send phy_config root_node=%d gap_count=%d\n",
 170                                                 root_node, gap_count);
 171
 172         if (ioctl(fd, FW_ASYREQ, asyreq) < 0)
 173                 err(1, "ioctl");
 174         free(asyreq);
 175 }
 176
 177 static void
 178 send_link_on(int fd, int node)
 179 {
 180         struct fw_asyreq *asyreq;
 181
 182         asyreq = (struct fw_asyreq *)malloc(sizeof(struct fw_asyreq_t) + 12);
 183         asyreq->req.len = 12;
 184         asyreq->req.type = FWASREQNODE;
 185         asyreq->pkt.mode.common.tcode = FWTCODE_PHY;
 186         asyreq->pkt.mode.ld[1] |= (1 << 30) | ((node & 0x3f) << 24);
 187         asyreq->pkt.mode.ld[2] = ~asyreq->pkt.mode.ld[1];
 188
 189         if (ioctl(fd, FW_ASYREQ, asyreq) < 0)
 190                 err(1, "ioctl");
 191         free(asyreq);
 192 }
 193
 194 static void
 195 reset_start(int fd, int node)
 196 {
 197         struct fw_asyreq *asyreq;
 198
 199         asyreq = (struct fw_asyreq *)malloc(sizeof(struct fw_asyreq_t) + 16);
 200         asyreq->req.len = 16;
 201         asyreq->req.type = FWASREQNODE;
 202         asyreq->pkt.mode.wreqq.dst = FWLOCALBUS | (node & 0x3f);
 203         asyreq->pkt.mode.wreqq.tlrt = 0;
 204         asyreq->pkt.mode.wreqq.tcode = FWTCODE_WREQQ;
 205
 206         asyreq->pkt.mode.wreqq.dest_hi = 0xffff;
 207         asyreq->pkt.mode.wreqq.dest_lo = 0xf0000000 | RESET_START;
 208
 209         asyreq->pkt.mode.wreqq.data = htonl(0x1);
 210
 211         if (ioctl(fd, FW_ASYREQ, asyreq) < 0)
 212                 err(1, "ioctl");
 213         free(asyreq);
 214 }
 215
 216 static void
 217 set_pri_req(int fd, int pri_req)
 218 {
 219         struct fw_devlstreq *data;
 220         struct fw_devinfo *devinfo;
 221         u_int32_t max, reg, old;
 222         int i;
 223
 224         data = get_dev(fd);
 225 #define BUGET_REG 0xf0000218
 226         for (i = 0; i < data->info_len; i++) {
 227                 devinfo = &data->dev[i];
 228                 if (!devinfo->status)
 229                         continue;
 230                 reg = read_write_quad(fd, devinfo->eui, BUGET_REG, 1, 0);
 231                 printf("%d %08x:%08x, %08x",
 232                         devinfo->dst, devinfo->eui.hi, devinfo->eui.lo, reg);
 233                 if (reg > 0 && pri_req >= 0) {
 234                         old = (reg & 0x3f);
 235                         max = (reg & 0x3f00) >> 8;
 236                         if (pri_req > max)
 237                                 pri_req =  max;
 238                         printf(" 0x%x -> 0x%x\n", old, pri_req);
 239                         read_write_quad(fd, devinfo->eui, BUGET_REG, 0, pri_req);
 240                 } else {
 241                         printf("\n");
 242                 }
 243         }
 244         free((void *)data);
 245 }
 246
 247 static void
 248 parse_bus_info_block(u_int32_t *p, int info_len)
 249 {
 250         int i;
 251
 252         for (i = 0; i < info_len; i++) {
 253                 printf("bus_info%d: 0x%08x\n", i, *p++);
 254         }
 255 }
 256
 257 static int
 258 get_crom(int fd, int node, void *crom_buf, int len)
 259 {
 260         struct fw_crom_buf buf;
 261         int i, error;
 262         struct fw_devlstreq *data;
 263
 264         data = get_dev(fd);
 265
 266         for (i = 0; i < data->info_len; i++) {
 267                 if (data->dev[i].dst == node && data->dev[i].eui.lo != 0)
 268                         break;
 269         }
 270         if (i == data->info_len)
 271                 errx(1, "no such node %d.", node);
 272         else if (i == 0)
 273                 errx(1, "node %d is myself.", node);
 274         else
 275                 buf.eui = data->dev[i].eui;
 276         free((void *)data);
 277
 278         buf.len = len;
 279         buf.ptr = crom_buf;
 280         if ((error = ioctl(fd, FW_GCROM, &buf)) < 0) {
 281                 err(1, "ioctl");
 282         }
 283
 284         return error;
 285 }
 286
 287 static void
 288 show_crom(u_int32_t *crom_buf)
 289 {
 290         int i;
 291         struct crom_context cc;
 292         char *desc, info[256];
 293         static char *key_types = "ICLD";
 294         struct csrreg *reg;
 295         struct csrdirectory *dir;
 296         struct csrhdr *hdr;
 297         u_int16_t crc;
 298
 299         printf("first quad: 0x%08x ", *crom_buf);
 300         hdr = (struct csrhdr *)crom_buf;
 301         if (hdr->info_len == 1) {
 302                 /* minimum ROM */
 303                 struct csrreg *reg;
 304                 reg = (struct csrreg *)hdr;
 305                 printf("verndor ID: 0x%06x\n",  reg->val);
 306                 return;
 307         }
 308         printf("info_len=%d crc_len=%d crc=0x%04x",
 309                 hdr->info_len, hdr->crc_len, hdr->crc);
 310         crc = crom_crc(crom_buf+1, hdr->crc_len);
 311         if (crc == hdr->crc)
 312                 printf("(OK)\n");
 313         else
 314                 printf("(NG)\n");
 315         parse_bus_info_block(crom_buf+1, hdr->info_len);
 316
 317         crom_init_context(&cc, crom_buf);
 318         dir = cc.stack[0].dir;
 319         printf("root_directory: len=0x%04x(%d) crc=0x%04x",
 320                         dir->crc_len, dir->crc_len, dir->crc);
 321         crc = crom_crc((u_int32_t *)&dir->entry[0], dir->crc_len);
 322         if (crc == dir->crc)
 323                 printf("(OK)\n");
 324         else
 325                 printf("(NG)\n");
 326         if (dir->crc_len < 1)
 327                 return;
 328         while (cc.depth >= 0) {
 329                 desc = crom_desc(&cc, info, sizeof(info));
 330                 reg = crom_get(&cc);
 331                 for (i = 0; i < cc.depth; i++)
 332                         printf("\t");
 333                 printf("%02x(%c:%02x) %06x %s: %s\n",
 334                         reg->key,
 335                         key_types[(reg->key & CSRTYPE_MASK)>>6],
 336                         reg->key & CSRKEY_MASK, reg->val,
 337                         desc, info);
 338                 crom_next(&cc);
 339         }
 340 }
 341
 342 #define DUMP_FORMAT     "%08x %08x %08x %08x %08x %08x %08x %08x\n"
 343
 344 static void
 345 dump_crom(u_int32_t *p)
 346 {
 347         int len=1024, i;
 348
 349         for (i = 0; i < len/(4*8); i ++) {
 350                 printf(DUMP_FORMAT,
 351                         p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
 352                 p += 8;
 353         }
 354 }
 355
 356 static void
 357 load_crom(char *filename, u_int32_t *p)
 358 {
 359         FILE *file;
 360         int len=1024, i;
 361
 362         if ((file = fopen(filename, "r")) == NULL)
 363                 err(1, "load_crom");
 364         for (i = 0; i < len/(4*8); i ++) {
 365                 fscanf(file, DUMP_FORMAT,
 366                         p, p+1, p+2, p+3, p+4, p+5, p+6, p+7);
 367                 p += 8;
 368         }
 369 }
 370
 371 static void
 372 show_topology_map(int fd)
 373 {
 374         struct fw_topology_map *tmap;
 375         union fw_self_id sid;
 376         int i;
 377         static char *port_status[] = {" ", "-", "P", "C"};
 378         static char *pwr_class[] = {" 0W", "15W", "30W", "45W",
 379                                         "-1W", "-2W", "-5W", "-9W"};
 380         static char *speed[] = {"S100", "S200", "S400", "S800"};
 381         tmap = malloc(sizeof(struct fw_topology_map));
 382         if (tmap == NULL)
 383                 return;
 384         if (ioctl(fd, FW_GTPMAP, tmap) < 0) {
 385                 err(1, "ioctl");
 386         }
 387         printf("crc_len: %d generation:%d node_count:%d sid_count:%d\n",
 388                 tmap->crc_len, tmap->generation,
 389                 tmap->node_count, tmap->self_id_count);
 390         printf("id link gap_cnt speed delay cIRM power port0 port1 port2"
 391                 " ini more\n");
 392         for (i = 0; i < tmap->crc_len - 2; i++) {
 393                 sid = tmap->self_id[i];
 394                 if (sid.p0.sequel) {
 395                         printf("%02d sequel packet\n", sid.p0.phy_id);
 396                         continue;
 397                 }
 398                 printf("%02d   %2d      %2d  %4s     %d    %d   %3s"
 399                                 "     %s     %s     %s   %d    %d\n",
 400                         sid.p0.phy_id,
 401                         sid.p0.link_active,
 402                         sid.p0.gap_count,
 403                         speed[sid.p0.phy_speed],
 404                         sid.p0.phy_delay,
 405                         sid.p0.contender,
 406                         pwr_class[sid.p0.power_class],
 407                         port_status[sid.p0.port0],
 408                         port_status[sid.p0.port1],
 409                         port_status[sid.p0.port2],
 410                         sid.p0.initiated_reset,
 411                         sid.p0.more_packets
 412                 );
 413         }
 414         free(tmap);
 415 }
 416
 417 int
 418 main(int argc, char **argv)
 419 {
 420         char devname[256];
 421         u_int32_t crom_buf[1024/4];
 422         int fd, i, tmp, ch, len=1024;
 423
 424         for (i = 0; i < 4; i++) {
 425                 snprintf(devname, sizeof(devname), "/dev/fw%d", i);
 426                 if ((fd = open(devname, O_RDWR)) >= 0)
 427                         break;
 428         }
 429         if (fd < 0)
 430                 err(1, "open");
 431
 432         if (argc < 2) {
 433                 list_dev(fd);
 434         }
 435
 436         while ((ch = getopt(argc, argv, "g:o:s:b:rtc:d:l:R:S:")) != -1)
 437                 switch(ch) {
 438                 case 'g':
 439                         tmp = strtol(optarg, NULL, 0);
 440                         send_phy_config(fd, -1, tmp);
 441                         break;
 442                 case 'o':
 443                         tmp = strtol(optarg, NULL, 0);
 444                         send_link_on(fd, tmp);
 445                         break;
 446                 case 's':
 447                         tmp = strtol(optarg, NULL, 0);
 448                         reset_start(fd, tmp);
 449                         break;
 450                 case 'b':
 451                         tmp = strtol(optarg, NULL, 0);
 452                         set_pri_req(fd, tmp);
 453                         break;
 454                 case 'r':
 455                         if(ioctl(fd, FW_IBUSRST, &tmp) < 0)
 456                                 err(1, "ioctl");
 457                         break;
 458                 case 't':
 459                         show_topology_map(fd);
 460                         break;
 461                 case 'c':
 462                         tmp = strtol(optarg, NULL, 0);
 463                         get_crom(fd, tmp, crom_buf, len);
 464                         show_crom(crom_buf);
 465                         break;
 466                 case 'd':
 467                         tmp = strtol(optarg, NULL, 0);
 468                         get_crom(fd, tmp, crom_buf, len);
 469                         dump_crom(crom_buf);
 470                         break;
 471                 case 'l':
 472                         load_crom(optarg, crom_buf);
 473                         show_crom(crom_buf);
 474                         break;
 475 #define TAG     (1<<6)
 476 #define CHANNEL 63
 477                 case 'R':
 478                         dvrecv(fd, optarg, TAG | CHANNEL, -1);
 479                         break;
 480                 case 'S':
 481                         dvsend(fd, optarg, TAG | CHANNEL, -1);
 482                         break;
 483                 default:
 484                         usage();
 485                 }
 486         return 0;
 487 }