git.gag.com Git - debian/gnuradio/blob - usrp2/firmware/apps/app_common_v2.c

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2007,2008,2009 Free Software Foundation, Inc.
   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 3 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, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 #include "config.h"
  21 #endif
  22
  23 #include "app_common_v2.h"
  24 #include "buffer_pool.h"
  25 #include "memcpy_wa.h"
  26 #include "ethernet.h"
  27 #include "nonstdio.h"
  28 #include "print_rmon_regs.h"
  29 #include "db.h"
  30 #include "db_base.h"
  31 #include "clocks.h"
  32 #include "u2_init.h"
  33 #include <string.h>
  34 #include "usrp2_i2c_addr.h"
  35
  36 volatile bool link_is_up = false;       // eth handler sets this
  37 int cpu_tx_buf_dest_port = PORT_ETH;
  38
  39 // If this is non-zero, this dbsm could be writing to the ethernet
  40 dbsm_t *ac_could_be_sending_to_eth;
  41
  42 static unsigned char exp_seqno __attribute__((unused)) = 0;
  43
  44 static inline bool
  45 sync_to_pps(const op_generic_t *p)
  46 {
  47   timesync_regs->sync_on_next_pps = 1;
  48   //putstr("SYNC to PPS\n");
  49   return true;
  50 }
  51
  52 static bool
  53 sync_every_pps(const op_generic_t *p)
  54 {
  55   if (p->ok)
  56     timesync_regs->tick_control |= TSC_TRIGGER_EVERYPPS;
  57   else
  58     timesync_regs->tick_control &= ~TSC_TRIGGER_EVERYPPS;
  59
  60   return true;
  61 }
  62
  63 static inline bool
  64 config_mimo_cmd(const op_config_mimo_t *p)
  65 {
  66   clocks_mimo_config(p->flags);
  67   return true;
  68 }
  69
  70 void
  71 set_reply_hdr(u2_eth_packet_t *reply_pkt, u2_eth_packet_t const *cmd_pkt)
  72 {
  73   reply_pkt->ehdr.dst = cmd_pkt->ehdr.src;
  74   reply_pkt->ehdr.src = *ethernet_mac_addr();
  75   reply_pkt->ehdr.ethertype = U2_ETHERTYPE;
  76   reply_pkt->thdr.flags = 0;
  77   reply_pkt->thdr.fifo_status = 0;      // written by protocol engine
  78   reply_pkt->thdr.seqno = 0;            // written by protocol engine
  79   reply_pkt->thdr.ack = 0;              // written by protocol engine
  80   u2p_set_word0(&reply_pkt->fixed, 0, CONTROL_CHAN);
  81   reply_pkt->fixed.timestamp = timer_regs->time;
  82 }
  83
  84 static void
  85 send_reply(unsigned char *reply, size_t reply_len)
  86 {
  87   if (reply_len < 64)
  88     reply_len = 64;
  89
  90   // wait for buffer to become idle
  91   hal_set_leds(0x4, 0x4);
  92   while((buffer_pool_status->status & BPS_IDLE(CPU_TX_BUF)) == 0)
  93     ;
  94   hal_set_leds(0x0, 0x4);
  95
  96   // copy reply into CPU_TX_BUF
  97   memcpy_wa(buffer_ram(CPU_TX_BUF), reply, reply_len);
  98
  99   // wait until nobody else is sending to the ethernet
 100   if (ac_could_be_sending_to_eth){
 101     hal_set_leds(0x8, 0x8);
 102     dbsm_wait_for_opening(ac_could_be_sending_to_eth);
 103     hal_set_leds(0x0, 0x8);
 104   }
 105
 106   if (0){
 107     printf("sending_reply to port %d, len = %d\n", cpu_tx_buf_dest_port, (int)reply_len);
 108     print_buffer(buffer_ram(CPU_TX_BUF), reply_len/4);
 109   }
 110
 111   // fire it off
 112   bp_send_from_buf(CPU_TX_BUF, cpu_tx_buf_dest_port, 1, 0, reply_len/4);
 113
 114   // wait for it to complete (not long, it's a small pkt)
 115   while((buffer_pool_status->status & (BPS_DONE(CPU_TX_BUF) | BPS_ERROR(CPU_TX_BUF))) == 0)
 116     ;
 117
 118   bp_clear_buf(CPU_TX_BUF);
 119 }
 120
 121
 122 static size_t
 123 op_id_cmd(const op_generic_t *p,
 124           void *reply_payload, size_t reply_payload_space)
 125 {
 126   op_id_reply_t *r = (op_id_reply_t *) reply_payload;
 127   if (reply_payload_space < sizeof(*r)) // no room
 128     return 0;
 129
 130   // Build reply subpacket
 131
 132   r->opcode = OP_ID_REPLY;
 133   r->len = sizeof(op_id_reply_t);
 134   r->rid = p->rid;
 135   r->addr = *ethernet_mac_addr();
 136   r->hw_rev = (u2_hw_rev_major << 8) | u2_hw_rev_minor;
 137   // r->fpga_md5sum = ; // FIXME
 138   // r->sw_md5sum = ;   // FIXME
 139
 140   return r->len;
 141 }
 142
 143
 144 static size_t
 145 config_tx_v2_cmd(const op_config_tx_v2_t *p,
 146                  void *reply_payload, size_t reply_payload_space)
 147 {
 148   op_config_tx_reply_v2_t *r = (op_config_tx_reply_v2_t *) reply_payload;
 149   if (reply_payload_space < sizeof(*r))
 150     return 0;                                   // no room
 151
 152   struct tune_result    tune_result;
 153   memset(&tune_result, 0, sizeof(tune_result));
 154
 155   bool ok = true;
 156
 157   if (p->valid & CFGV_GAIN){
 158     ok &= db_set_gain(tx_dboard, p->gain);
 159   }
 160
 161   if (p->valid & CFGV_FREQ){
 162     bool was_streaming = is_streaming();
 163     if (was_streaming)
 164       stop_rx_cmd();
 165
 166     u2_fxpt_freq_t f = u2_fxpt_freq_from_hilo(p->freq_hi, p->freq_lo);
 167     bool tune_ok = db_tune(tx_dboard, f, &tune_result);
 168     ok &= tune_ok;
 169     print_tune_result("Tx", tune_ok, f, &tune_result);
 170
 171     if (was_streaming)
 172       restart_streaming();
 173   }
 174
 175   if (p->valid & CFGV_INTERP_DECIM){
 176     int interp = p->interp;
 177     int hb1 = 0;
 178     int hb2 = 0;
 179
 180     if (!(interp & 1)){
 181       hb2 = 1;
 182       interp = interp >> 1;
 183     }
 184
 185     if (!(interp & 1)){
 186       hb1 = 1;
 187       interp = interp >> 1;
 188     }
 189
 190     if (interp < MIN_CIC_INTERP || interp > MAX_CIC_INTERP)
 191       ok = false;
 192     else {
 193       dsp_tx_regs->interp_rate = (hb1<<9) | (hb2<<8) | interp;
 194       // printf("Interp: %d, register %d\n", p->interp, (hb1<<9) | (hb2<<8) | interp);
 195     }
 196   }
 197
 198   if (p->valid & CFGV_SCALE_IQ){
 199     dsp_tx_regs->scale_iq = p->scale_iq;
 200   }
 201
 202   // Build reply subpacket
 203
 204   r->opcode = OP_CONFIG_TX_REPLY_V2;
 205   r->len = sizeof(*r);
 206   r->rid = p->rid;
 207   r->ok = ok;
 208   r->inverted = tune_result.inverted;
 209   r->baseband_freq_hi = u2_fxpt_freq_hi(tune_result.baseband_freq);
 210   r->baseband_freq_lo = u2_fxpt_freq_lo(tune_result.baseband_freq);
 211   r->duc_freq_hi = u2_fxpt_freq_hi(tune_result.dxc_freq);
 212   r->duc_freq_lo = u2_fxpt_freq_lo(tune_result.dxc_freq);
 213   r->residual_freq_hi = u2_fxpt_freq_hi(tune_result.residual_freq);
 214   r->residual_freq_lo = u2_fxpt_freq_lo(tune_result.residual_freq);
 215   return r->len;
 216 }
 217
 218 static size_t
 219 config_rx_v2_cmd(const op_config_rx_v2_t *p,
 220                  void *reply_payload, size_t reply_payload_space)
 221 {
 222   op_config_rx_reply_v2_t *r = (op_config_rx_reply_v2_t *) reply_payload;
 223   if (reply_payload_space < sizeof(*r))
 224     return 0;                           // no room
 225
 226   struct tune_result    tune_result;
 227   memset(&tune_result, 0, sizeof(tune_result));
 228
 229   bool ok = true;
 230
 231   if (p->valid & CFGV_GAIN){
 232     ok &= db_set_gain(rx_dboard, p->gain);
 233   }
 234
 235   if (p->valid & CFGV_FREQ){
 236     bool was_streaming = is_streaming();
 237     if (was_streaming)
 238       stop_rx_cmd();
 239
 240     u2_fxpt_freq_t f = u2_fxpt_freq_from_hilo(p->freq_hi, p->freq_lo);
 241     bool tune_ok = db_tune(rx_dboard, f, &tune_result);
 242     ok &= tune_ok;
 243     print_tune_result("Rx", tune_ok, f, &tune_result);
 244
 245     if (was_streaming)
 246       restart_streaming();
 247   }
 248
 249   if (p->valid & CFGV_INTERP_DECIM){
 250     int decim = p->decim;
 251     int hb1 = 0;
 252     int hb2 = 0;
 253
 254     if(!(decim & 1)) {
 255       hb2 = 1;
 256       decim = decim >> 1;
 257     }
 258
 259     if(!(decim & 1)) {
 260       hb1 = 1;
 261       decim = decim >> 1;
 262     }
 263
 264     if (decim < MIN_CIC_DECIM || decim > MAX_CIC_DECIM)
 265       ok = false;
 266     else {
 267       dsp_rx_regs->decim_rate = (hb1<<9) | (hb2<<8) | decim;
 268       // printf("Decim: %d, register %d\n", p->decim, (hb1<<9) | (hb2<<8) | decim);
 269     }
 270   }
 271
 272   if (p->valid & CFGV_SCALE_IQ){
 273     dsp_rx_regs->scale_iq = p->scale_iq;
 274   }
 275
 276   // Build reply subpacket
 277
 278   r->opcode = OP_CONFIG_RX_REPLY_V2;
 279   r->len = sizeof(*r);
 280   r->rid = p->rid;
 281   r->ok = ok;
 282   r->inverted = tune_result.inverted;
 283   r->baseband_freq_hi = u2_fxpt_freq_hi(tune_result.baseband_freq);
 284   r->baseband_freq_lo = u2_fxpt_freq_lo(tune_result.baseband_freq);
 285   r->ddc_freq_hi = u2_fxpt_freq_hi(tune_result.dxc_freq);
 286   r->ddc_freq_lo = u2_fxpt_freq_lo(tune_result.dxc_freq);
 287   r->residual_freq_hi = u2_fxpt_freq_hi(tune_result.residual_freq);
 288   r->residual_freq_lo = u2_fxpt_freq_lo(tune_result.residual_freq);
 289
 290   return r->len;
 291 }
 292
 293 static size_t
 294 read_time_cmd(const op_generic_t *p,
 295               void *reply_payload, size_t reply_payload_space)
 296 {
 297   op_read_time_reply_t *r = (op_read_time_reply_t *) reply_payload;
 298   if (reply_payload_space < sizeof(*r))
 299     return 0;                                   // no room
 300
 301   r->opcode = OP_READ_TIME_REPLY;
 302   r->len = sizeof(*r);
 303   r->rid = p->rid;
 304   r->time = timer_regs->time;
 305
 306   return r->len;
 307 }
 308
 309 static void
 310 fill_db_info(u2_db_info_t *p, const struct db_base *db)
 311 {
 312   //p->dbid = db->dbid;
 313   p->freq_min_hi = u2_fxpt_freq_hi(db->freq_min);
 314   p->freq_min_lo = u2_fxpt_freq_lo(db->freq_min);
 315   p->freq_max_hi = u2_fxpt_freq_hi(db->freq_max);
 316   p->freq_max_lo = u2_fxpt_freq_lo(db->freq_max);
 317   p->gain_min = db->gain_min;
 318   p->gain_max = db->gain_max;
 319   p->gain_step_size = db->gain_step_size;
 320 }
 321
 322 static size_t
 323 dboard_info_cmd(const op_generic_t *p,
 324                 void *reply_payload, size_t reply_payload_space)
 325 {
 326   op_dboard_info_reply_t *r = (op_dboard_info_reply_t *) reply_payload;
 327   if (reply_payload_space < sizeof(*r))
 328     return 0;                                   // no room
 329
 330   r->opcode = OP_DBOARD_INFO_REPLY;
 331   r->len = sizeof(*r);
 332   r->rid = p->rid;
 333   r->ok = true;
 334
 335   fill_db_info(&r->tx_db_info, tx_dboard);
 336   fill_db_info(&r->rx_db_info, rx_dboard);
 337
 338   r->tx_db_info.dbid = read_dboard_eeprom(I2C_ADDR_TX_A);
 339   r->rx_db_info.dbid = read_dboard_eeprom(I2C_ADDR_RX_A);
 340
 341   return r->len;
 342 }
 343
 344 static size_t
 345 peek_cmd(const op_peek_t *p,
 346          void *reply_payload, size_t reply_payload_space)
 347 {
 348   op_generic_t *r = (op_generic_t *) reply_payload;
 349
 350   //putstr("peek: addr="); puthex32(p->addr);
 351   //printf(" bytes=%u\n", p->bytes);
 352
 353   if ((reply_payload_space < (sizeof(*r) + p->bytes)) ||
 354       p->bytes > MAX_SUBPKT_LEN - sizeof(op_generic_t)) {
 355     putstr("peek: insufficient reply packet space\n");
 356     return 0;                   // FIXME do partial read?
 357   }
 358
 359   r->opcode = OP_PEEK_REPLY;
 360   r->len = sizeof(*r)+p->bytes;
 361   r->rid = p->rid;
 362   r->ok = true;
 363
 364   memcpy_wa(reply_payload+sizeof(*r), (void *)p->addr, p->bytes);
 365
 366   return r->len;
 367 }
 368
 369 static bool
 370 poke_cmd(const op_poke_t *p)
 371 {
 372   int bytes = p->len - sizeof(*p);
 373   //putstr("poke: addr="); puthex32(p->addr);
 374   //printf(" bytes=%u\n", bytes);
 375
 376   uint8_t *src = (uint8_t *)p + sizeof(*p);
 377   memcpy_wa((void *)p->addr, src, bytes);
 378
 379   return true;
 380 }
 381
 382 static bool
 383 set_lo_offset_cmd(const op_freq_t *p)
 384 {
 385   u2_fxpt_freq_t f = u2_fxpt_freq_from_hilo(p->freq_hi, p->freq_lo);
 386   if (p->opcode == OP_SET_TX_LO_OFFSET)
 387     return db_set_lo_offset(tx_dboard, f);
 388   else
 389     return db_set_lo_offset(rx_dboard, f);
 390 }
 391
 392 static size_t
 393 gpio_read_cmd(const op_gpio_t *p,
 394               void *reply_payload, size_t reply_payload_space)
 395 {
 396   op_gpio_read_reply_t *r = (op_gpio_read_reply_t *) reply_payload;
 397   if (reply_payload_space < sizeof(*r)) // no room
 398     return 0;
 399
 400  // Build reply subpacket
 401
 402   r->opcode = OP_GPIO_READ_REPLY;
 403   r->len = sizeof(op_gpio_read_reply_t);
 404   r->rid = p->rid;
 405   r->ok = true;
 406   r->mbz = 0;
 407   r->value = hal_gpio_read(p->bank);
 408
 409   return r->len;
 410 }
 411
 412 static size_t
 413 generic_reply(const op_generic_t *p,
 414               void *reply_payload, size_t reply_payload_space,
 415               bool ok)
 416 {
 417   op_generic_t *r = (op_generic_t *) reply_payload;
 418   if (reply_payload_space < sizeof(*r))
 419     return 0;                                   // no room
 420
 421   r->opcode = p->opcode | OP_REPLY_BIT;
 422   r->len = sizeof(*r);
 423   r->rid = p->rid;
 424   r->ok = ok;
 425
 426   return r->len;
 427 }
 428
 429 static size_t
 430 add_eop(void *reply_payload, size_t reply_payload_space)
 431 {
 432   op_generic_t *r = (op_generic_t *) reply_payload;
 433   if (reply_payload_space < sizeof(*r))
 434     return 0;                                   // no room
 435
 436   r->opcode = OP_EOP;
 437   r->len = sizeof(*r);
 438   r->rid = 0;
 439   r->ok =  0;
 440
 441   return r->len;
 442 }
 443
 444 void
 445 handle_control_chan_frame(u2_eth_packet_t *pkt, size_t len)
 446 {
 447   unsigned char reply[sizeof(u2_eth_packet_t) + 4 * sizeof(u2_subpkt_t)] _AL4;
 448   unsigned char *reply_payload = &reply[sizeof(u2_eth_packet_t)];
 449   int reply_payload_space = sizeof(reply) - sizeof(u2_eth_packet_t);
 450
 451   // initialize reply
 452   memset(reply, 0, sizeof(reply));
 453   set_reply_hdr((u2_eth_packet_t *) reply, pkt);
 454
 455   // point to beginning of payload (subpackets)
 456   unsigned char *payload = ((unsigned char *) pkt) + sizeof(u2_eth_packet_t);
 457   int payload_len = len - sizeof(u2_eth_packet_t);
 458
 459   size_t subpktlen = 0;
 460   bool ok = false;
 461
 462   while (payload_len >= sizeof(op_generic_t)){
 463     const op_generic_t *gp = (const op_generic_t *) payload;
 464     subpktlen = 0;
 465
 466     // printf("\nopcode = %d\n", gp->opcode);
 467
 468     switch(gp->opcode){
 469     case OP_EOP:                // end of subpackets
 470       goto end_of_subpackets;
 471
 472     case OP_ID:
 473       subpktlen = op_id_cmd(gp, reply_payload, reply_payload_space);
 474       break;
 475
 476     case OP_CONFIG_TX_V2:
 477       subpktlen = config_tx_v2_cmd((op_config_tx_v2_t *) payload, reply_payload, reply_payload_space);
 478       break;
 479
 480     case OP_CONFIG_RX_V2:
 481       subpktlen = config_rx_v2_cmd((op_config_rx_v2_t *) payload, reply_payload, reply_payload_space);
 482       break;
 483
 484     case OP_START_RX_STREAMING:
 485       if (pkt->fixed.timestamp == -1) // Start now (default)
 486         start_rx_streaming_cmd(&pkt->ehdr.src, (op_start_rx_streaming_t *) payload);
 487       else
 488         start_rx_streaming_at_cmd(&pkt->ehdr.src, (op_start_rx_streaming_t *)payload, pkt->fixed.timestamp);
 489       ok = true;
 490       goto generic_reply;
 491
 492     case OP_STOP_RX:
 493       stop_rx_cmd();
 494       ok = true;
 495       goto generic_reply;
 496
 497     case OP_RX_ANTENNA:
 498         ok = db_set_antenna(rx_dboard, ((op_config_mimo_t *)payload)->flags);
 499         goto generic_reply;
 500
 501     case OP_TX_ANTENNA:
 502         ok = db_set_antenna(tx_dboard, ((op_config_mimo_t *)payload)->flags);
 503         goto generic_reply;
 504
 505     case OP_BURN_MAC_ADDR:
 506       ok = ethernet_set_mac_addr(&((op_burn_mac_addr_t *)payload)->addr);
 507       goto generic_reply;
 508
 509     case OP_CONFIG_MIMO:
 510       ok = config_mimo_cmd((op_config_mimo_t *) payload);
 511       goto generic_reply;
 512
 513     case OP_READ_TIME:
 514       subpktlen = read_time_cmd(gp, reply_payload, reply_payload_space);
 515       break;
 516
 517     case OP_DBOARD_INFO:
 518       subpktlen = dboard_info_cmd(gp, reply_payload, reply_payload_space);
 519       break;
 520
 521     case OP_SYNC_TO_PPS:
 522       sync_to_pps((op_generic_t *) payload);
 523       ok = true;
 524       goto generic_reply;
 525
 526     case OP_PEEK:
 527       subpktlen = peek_cmd((op_peek_t *)payload, reply_payload, reply_payload_space);
 528       break;
 529
 530     case OP_POKE:
 531       ok = poke_cmd((op_poke_t *)payload);
 532       goto generic_reply;
 533
 534     case OP_SET_TX_LO_OFFSET:
 535     case OP_SET_RX_LO_OFFSET:
 536       ok = set_lo_offset_cmd((op_freq_t *)payload);
 537       goto generic_reply;
 538
 539     case OP_RESET_DB:
 540       db_init();
 541       ok = true;
 542       goto generic_reply;
 543
 544     case OP_SYNC_EVERY_PPS:
 545       ok = sync_every_pps((op_generic_t *) payload);
 546       goto generic_reply;
 547
 548     case OP_GPIO_SET_DDR:
 549       ok = true;
 550       hal_gpio_set_ddr(((op_gpio_t *)payload)->bank,
 551                        ((op_gpio_t *)payload)->value,
 552                        ((op_gpio_t *)payload)->mask);
 553       goto generic_reply;
 554
 555     case OP_GPIO_SET_SELS:
 556       ok = true;
 557       hal_gpio_set_sels(((op_gpio_set_sels_t *)payload)->bank,
 558                         (char *)(&((op_gpio_set_sels_t *)payload)->sels));
 559       goto generic_reply;
 560
 561     case OP_GPIO_READ:
 562       subpktlen = gpio_read_cmd((op_gpio_t *) payload, reply_payload, reply_payload_space);
 563       break;
 564
 565     case OP_GPIO_WRITE:
 566       ok = true;
 567       hal_gpio_write(((op_gpio_t *)payload)->bank,
 568                      ((op_gpio_t *)payload)->value,
 569                      ((op_gpio_t *)payload)->mask);
 570       goto generic_reply;
 571
 572     case OP_GPIO_STREAM:
 573       ok = true;
 574       dsp_rx_regs->gpio_stream_enable = (uint32_t)((op_gpio_t *)payload)->value;
 575       goto generic_reply;
 576
 577     // Add new opcode handlers here
 578
 579     generic_reply:
 580       subpktlen = generic_reply(gp, reply_payload, reply_payload_space, ok);
 581       break;
 582
 583     default:
 584       printf("app_common_v2: unhandled opcode = %d\n", gp->opcode);
 585       break;
 586     }
 587
 588     int t = (gp->len + 3) & ~3;         // bump to a multiple of 4
 589     payload += t;
 590     payload_len -= t;
 591
 592     subpktlen = (subpktlen + 3) & ~3;   // bump to a multiple of 4
 593     reply_payload += subpktlen;
 594     reply_payload_space -= subpktlen;
 595   }
 596
 597  end_of_subpackets:
 598
 599   // add the EOP marker
 600   subpktlen = add_eop(reply_payload, reply_payload_space);
 601   subpktlen = (subpktlen + 3) & ~3;     // bump to a multiple of 4
 602   reply_payload += subpktlen;
 603   reply_payload_space -= subpktlen;
 604
 605   send_reply(reply, reply_payload - reply);
 606 }
 607
 608
 609 /*
 610  * Called when an ethernet packet is received.
 611  * Return true if we handled it here, otherwise
 612  * it'll be passed on to the DSP Tx pipe
 613  */
 614 bool
 615 eth_pkt_inspector(dbsm_t *sm, int bufno)
 616 {
 617   u2_eth_packet_t *pkt = (u2_eth_packet_t *) buffer_ram(bufno);
 618   size_t byte_len = (buffer_pool_status->last_line[bufno] - 1) * 4;
 619
 620   //static size_t last_len = 0;
 621
 622   // hal_toggle_leds(0x1);
 623
 624   // inspect rcvd frame and figure out what do do.
 625
 626   if (pkt->ehdr.ethertype != U2_ETHERTYPE)
 627     return true;        // ignore, probably bogus PAUSE frame from MAC
 628
 629   int chan = u2p_chan(&pkt->fixed);
 630
 631   switch (chan){
 632   case CONTROL_CHAN:
 633     handle_control_chan_frame(pkt, byte_len);
 634     return true;        // we handled the packet
 635     break;
 636
 637   case 0:
 638   default:
 639 #if 0
 640     if (last_len != 0){
 641       if (byte_len != last_len){
 642         printf("Len: %d last: %d\n", byte_len, last_len);
 643       }
 644     }
 645     last_len = byte_len;
 646
 647     if((pkt->thdr.seqno) == exp_seqno){
 648       exp_seqno++;
 649       //putchar('.');
 650     }
 651     else {
 652       // putchar('S');
 653       //printf("S%d %d ",exp_seqno,pkt->thdr.seqno);
 654       exp_seqno = pkt->thdr.seqno + 1;
 655     }
 656 #endif
 657     return false;       // pass it on to Tx DSP
 658     break;
 659   }
 660 }
 661
 662 /*
 663  * Called when eth phy state changes (w/ interrupts disabled)
 664  */
 665 void
 666 link_changed_callback(int speed)
 667 {
 668   link_is_up = speed != 0;
 669   hal_set_leds(link_is_up ? LED_RJ45 : 0x0, LED_RJ45);
 670   printf("\neth link changed: speed = %d\n", speed);
 671 }
 672
 673
 674 void
 675 print_tune_result(char *msg, bool tune_ok,
 676                   u2_fxpt_freq_t target_freq, struct tune_result *r)
 677 {
 678 #if 0
 679   printf("db_tune %s %s\n", msg, tune_ok ? "true" : "false");
 680   putstr("  target_freq   "); print_fxpt_freq(target_freq); newline();
 681   putstr("  baseband_freq "); print_fxpt_freq(r->baseband_freq); newline();
 682   putstr("  dxc_freq      "); print_fxpt_freq(r->dxc_freq); newline();
 683   putstr("  residual_freq "); print_fxpt_freq(r->residual_freq); newline();
 684   printf("  inverted      %s\n", r->inverted ? "true" : "false");
 685 #endif
 686 }