nic_manager.c

#include "main-header.h"
#include "networkif.h"
#include "irq_router.h"
 
static void nic_set_status_bit(struct network_context *nir, int bit) {
  nir->status = nir->status | (1 << bit);
}
static void nic_clr_status_bit(struct network_context *nir, int bit) {
  nir->status = nir->status & ~(1 << bit);
}
 
static int nic_get_status_bit(struct network_context *nir, int bit) {
  return (nir->status & (1 << bit)) ? 1 : 0;
}
 
// display status of all nics
void print_all_nics() {
  int i = 0;
 
  // PROBE all nics
  printf("Network interfaces:\r\n");
  for (;;) {
    struct network_context *nir = nic_by_index(i);
    i++;
    if (nir == NULL) {
      break;
    }
    printf("  Network device %i (%s)\r\n", nir->source, command_get_source_name(nir->source));
    printf("    Flags: ");
    if (nic_get_status_bit(nir, STATUS_PROBED)) {
      printf("PROBED |");
    } else {
      printf("NOT PROBED |");
    }
    if (nic_get_status_bit(nir, STATUS_PROBE_SUCCESS)) {
      printf("PROBE_SUCCESS |");
    } else {
      printf("NOT PROBE_SUCCESS |");
    }
    if (nic_get_status_bit(nir, STATUS_INITIALISED)) {
      printf("INITIALISED |");
    } else {
      printf("NOT INITIALISED |");
    }
    if (nic_get_status_bit(nir, STATUS_READY_TO_TRANSMIT)) {
      printf("READY_TO_TRANSMIT");
    } else {
      printf("NOT READY_TO_TRANSMIT");
    }
    printf("\r\n");
 
    if (nir->nif->info == NULL) {
      printf("     no info available\r\n");
      continue;
    }
    nir->nif->info(nir);
  }
}
void init_all_nics() {
  int i = 0;
 
  if (config_get_ti1101disable()) {
    printf("NICs disabled\r\n");
    return;
  }
 
  // PROBE all nics
  for (;;) {
    struct network_context *nir = nic_by_index(i);
    i++;
    if (nir == NULL) {
      break;
    }
    printf("Probing network device %i (%s) (handle %i)\r\n", nir->source, command_get_source_name(nir->source), nir->mculib_handle);
    if (nir->nif->probe == NULL) {
      printf("Skipping network device %i (%s) - no probe()\r\n", nir->source, command_get_source_name(nir->source));
      continue;
    }
    int p = nir->nif->probe(nir);
    nic_set_status_bit(nir, STATUS_PROBED);
    release_irq_by_handle(nir->mculib_handle);
    mculib_release_by_handle(nir->mculib_handle);
    mculib_print_mappings(&printf);
    if (p != 0) {
      printf("Skipping network device %i (%s) - probe() failed, code=%i\r\n", nir->source, command_get_source_name(nir->source), p);
      continue;
    }
    nic_set_status_bit(nir, STATUS_PROBE_SUCCESS);
  }
  i = 0;
  for (;;) {
    struct network_context *nir = nic_by_index(i);
    i++;
    if (nir == NULL) {
      break;
    }
    if (nic_get_status_bit(nir, STATUS_PROBE_SUCCESS) == 0) {
      printf("Skipping network device %i (%s) - probe did not detect it\r\n", nir->source, command_get_source_name(nir->source));
      continue;
    }
    printf("Activating network device %i (%s)\r\n", nir->source, command_get_source_name(nir->source));
    if (nir->nif->init == NULL) {
      printf("Skipping network device %i (%s) - no init()\r\n", nir->source, command_get_source_name(nir->source));
      continue;
    }
 
    printf("Initialising network device %i (%s)\r\n", nir->source, command_get_source_name(nir->source));
    int p = nir->nif->init(nir);
    if (p != 0) {
      printf("Initialisation of network device %i (%s) failed with code %i\r\n", nir->source, command_get_source_name(nir->source), p);
      continue;
    }
    nic_set_status_bit(nir, STATUS_INITIALISED);
    printf("Started network device %i (%s)\r\n", nir->source, command_get_source_name(nir->source));
  }
}
// return 1 if it was enabled previously
int stop_nic_by_type(int source) {
  struct network_context *nc = nic_by_type(source);
 
  if (!nic_get_status_bit(nc, STATUS_INITIALISED)) {
    return 0;
  }
  if ((nc != NULL) && (nc->nif->stop != NULL)) {
    nc->nif->stop(nc);
  }
  return 1;
}
int start_nic_by_type(int source) {
  struct network_context *nc = nic_by_type(source);
 
  if ((nc != NULL) && (nc->nif->init != NULL)) {
    // was it initialised previously? (during boot)?
    if (nic_get_status_bit(nc, STATUS_INITIALISED)) {
      // yes was initialised, re initialise it
      int rc = nc->nif->init(nc);
      if (rc == 0) {
        nic_set_status_bit(nc, STATUS_INITIALISED);
      } else {
        nic_clr_status_bit(nc, STATUS_INITIALISED);
      }
    }
  }
  return 0;
}
static void announce(struct network_context *nctx) {
  struct command *com = alloc_command();
 
  if (com == NULL) {
    return;
  }
  com->sourcedev = nctx->source;
  com->com = 23;         // announce
  com->sender = get_my_node_id();
  com->target = 0xFFFFFFFF;
  com->recipient = 0xFFFFFFFF;
  com->flags = COMFLAGS_ACK | COMFLAGS_SUCCESS;
  if (config_get_flag(CONFIG_FLAGS_POWER_SAVE)) {
    com->flags |= COMFLAGS_POWERSAVE;
  }
  command_add_arg(com, "%i", (int)get_hops_to_server());
  command_add_arg(com, "1");
  int r = send_command(com);
 
  if (r != 0) {
    printf("nicmanager: failed to announce, reason: %i\r\n", r);
  }
  free_command(com);
}
// calls nic->busy()
int nic_is_busy(int source) {
  struct network_context *nctx = nic_by_type(source);
 
  if (nctx == NULL) {
    return 1;
  }
  if ((nctx->status & (1 << STATUS_PROBE_SUCCESS)) == 0) {
    // not probed successfully == always busy
    return 1;
  }
  if (nctx->nif->busy == NULL) {
    // no busy handler, assumed to be non-busy
    return 0;
  }
  return nctx->nif->busy(nctx);
}
 
// the device calls this to indicate wether or not it is ready to send outbound commands
// status == 0 (not ready), status == 1 (ready)
// if a nic goes to (ready) it will also send an "announce"
void nic_set_transmit_status(struct network_context *nctx, int status) {
  if (status) {
    if ((nctx->status & (1 << STATUS_PROBE_SUCCESS)) == 0) {
      // this thing has not even been successfully probed. so it is definitely NOT ready to transmit
      return;
    }
    nctx->status = nctx->status | (1 << STATUS_READY_TO_TRANSMIT);
    announce(nctx);
    // transmit stuff...
    //    char *txt = "foo hello world singingcat";
    //    nctx->nif->transmit(nctx,(const uint8_t *)txt,(uint16_t)strlen(txt));
  } else {
    nctx->status = nctx->status & ~(1 << STATUS_READY_TO_TRANSMIT);
  }
}
 
// returns true if the device is ready to transmit
int isready_by_type(int source) {
  struct network_context *nctx = nic_by_type(source);
 
  if (nctx == NULL) {
    return 0;
  }
  return nctx->status & (1 << STATUS_READY_TO_TRANSMIT);
}
 
// returns true if the device is ready to transmit or is expected to be able to transmit shortly
int isonline_by_type(int source) {
  struct network_context *nctx = nic_by_type(source);
 
  if (nctx == NULL) {
    return 0;
  }
  if ((nctx->status & (1 << STATUS_READY_TO_TRANSMIT)) || (nctx->status & (1 << STATUS_INITIALISED))) {
    return 1;
  }
  return 0;
}
 
 
void process_nic_event_loop() {
  int i = 0;
 
  for (;;) {
    struct network_context *nir = nic_by_index(i);
    i++;
    if (nir == NULL) {
      break;
    }
    if ((nir->nif->loop != NULL) && (nir->status & (1 << STATUS_INITIALISED))) {
      nir->nif->loop(nir);
    }
  }
}