antenna.c

软件无线电的平台

  // It will not run yet!
  pthread_mutex_lock( &disp_thread.mutex );
  PR_DBG( 4, "Putting into running state\n" );
  if ( disp_thread.state == STATE_RUNNING ) {
    pthread_mutex_unlock( &disp_thread.mutex );
    PR_DBG( 0, "Antenna already running\n" );
    return -1;
  }
  pthread_mutex_unlock( &disp_thread.mutex );
  disp_thread.state = STATE_RUNNING;

  // Initialise all antennas
  for ( nbr_ant=0; nbr_ant<initialised_antennas; nbr_ant++ ){
    PR_DBG( 4, "Working channel %i\n", nbr_ant );
    ant = &params[ nbr_ant ];
    ant->frame_blocks = blocks_per_frame;
 
    if ( disp_thread.state != STATE_EXIT ) {
      if ( !ant->addr_tx || !ant->addr_rx ) {
	if ( ( ant->flags & ANTENNA_ONLY_RX ) && ant->addr_rx ){
	  PR_DBG( 1, "Going into RX-only\n" );
	} else if ( ( ant->flags & ANTENNA_ONLY_TX ) && ant->addr_tx ){
	  PR_DBG( 1, "Going into TX-only\n" );
	} else {
	  // Either of the buffers is not allocated and no special state
	  PR_DBG( 0, "Buffers not allocates! Not starting DMA\n" );
	  return -1;
	}
      }
    
    }
    swr_ant_ch_reconfig( nbr_ant );
  }

  // Starting the hardware-transfer
  PR_DBG( 4, "Starting hardware\n" );
  swr_ant_ch_start( );

  // And let go off the dispatcher
  PR_DBG( 4, "Dispatcher starting\n" );
  if ( disp_thread.state == STATE_RUNNING ){
    PR_DBG( 4, "Signalling\n" );
    pthread_mutex_lock( &disp_thread.mutex );
    pthread_cond_signal( &disp_thread.cond );
    pthread_mutex_unlock( &disp_thread.mutex );
  }

  return 0;
}

/**
 * @short Stops all antennas
 */
int swr_ant_stop( void ) {

  pthread_mutex_lock( &disp_thread.mutex );
  if ( disp_thread.state == STATE_RUNNING ) {
    // Get the stop-mutex and stop the DMA
    PR_DBG( 1, "Stopping antennas\n" );
    disp_thread.state = STATE_STOPPED;
  }
  pthread_mutex_unlock( &disp_thread.mutex );
  
  swr_ant_ch_stop( );

  return 0;
}


/**
 * @short Sets the parameters of a frame
 */
int swr_ant_set_frame_params( int nbr_ant, void *rx_addr, void *tx_addr ) {

  if ( nbr_ant >= MAX_ANTENNAS ) {
    PR_DBG( 0, "Asked for antenna %i, but only %i are available\n",
            nbr_ant, MAX_ANTENNAS );
    return -1;
  }

  pthread_mutex_lock( &disp_thread.mutex );
  if ( disp_thread.state == STATE_RUNNING ) {
    pthread_mutex_unlock( &disp_thread.mutex );
    PR_DBG( 0, "Can't change address while running antenna!\n" );
    return -1;
  }
  params[ nbr_ant ].addr_rx = rx_addr;
  params[ nbr_ant ].addr_tx = tx_addr;

  swr_ant_ch_reconfig( nbr_ant );

  pthread_mutex_unlock( &disp_thread.mutex );
  return 0;
}

/**
 * @short Sets the number of DMA-blocks in a slot
 */
int swr_ant_set_slot_len( int nbr_ant, int len ) {

  if ( nbr_ant >= MAX_ANTENNAS ) {
    PR_DBG( 0, "Asked for antenna %i, but only %i are available\n",
            nbr_ant, MAX_ANTENNAS );
    return -1;
  }

  pthread_mutex_lock( &disp_thread.mutex );
  disp_thread.slot_len = len;
  pthread_mutex_unlock( &disp_thread.mutex );

  params[ nbr_ant ].slot_length = len;

  return 0;
}

/**
 * @short Sets the rx- and tx-gain
 */
int swr_ant_set_gains( int nbr_ant, float rx_gain, float tx_gain ) {
  
  swr_ant_set_gain_rx( nbr_ant, rx_gain ); 
  swr_ant_set_gain_tx( nbr_ant, tx_gain ); 
  return 0;
}

int swr_ant_set_attn( int nbr_ant, float rx_attn, float tx_attn ) {
  
  swr_ant_set_attn_rx( nbr_ant, rx_attn ); 
  swr_ant_set_attn_tx( nbr_ant, tx_attn ); 
  return 0;
}

/**
 * @short Sets the rx-gain
 */
int swr_ant_set_gain_rx( int nbr_ant, float rx_gain ) {
  
  if ( nbr_ant >= MAX_ANTENNAS ) {
    PR_DBG( 0, "Asked for antenna %i, but only %i are available\n",
            nbr_ant, MAX_ANTENNAS );
    return -1;
  }
  
  params[ nbr_ant ].gain_rx = rx_gain;
  swr_ant_ch_reconfig( nbr_ant );
  
  return 0;
}
int swr_ant_set_attn_rx( int nbr_ant, float rx_attn ) {
  float gain_max_rx;
  
  if ( nbr_ant >= MAX_ANTENNAS ) {
    PR_DBG( 0, "Asked for antenna %i, but only %i are available\n",
            nbr_ant, MAX_ANTENNAS );
    return -1;
  }

  gain_max_rx = params[ nbr_ant ].gain_max_rx;
  if ( rx_attn < gain_max_rx ){
    swr_ant_set_gain_rx( nbr_ant, gain_max_rx - rx_attn );
  } else {
    swr_ant_set_gain_rx( nbr_ant, 0 );
  }
  
  return 0;
}

/**
 * @short Sets the tx-gain
 */
int swr_ant_set_gain_tx( int nbr_ant, float tx_gain ) {
  
  if ( nbr_ant >= MAX_ANTENNAS ) {
    PR_DBG( 0, "Asked for antenna %i, but only %i are available\n",
            nbr_ant, MAX_ANTENNAS );
    return -1;
  }
  
  params[ nbr_ant ].gain_tx = tx_gain;
  swr_ant_ch_reconfig( nbr_ant );
  
  return 0;
}
int swr_ant_set_attn_tx( int nbr_ant, float tx_attn ) {
  float gain_max_tx;
  
  if ( nbr_ant >= MAX_ANTENNAS ) {
    PR_DBG( 0, "Asked for antenna %i, but only %i are available\n",
            nbr_ant, MAX_ANTENNAS );
    return -1;
  }

  gain_max_tx = params[ nbr_ant ].gain_max_tx;
  if ( tx_attn < gain_max_tx ){
    swr_ant_set_gain_tx( nbr_ant, gain_max_tx - tx_attn );
  } else {
    swr_ant_set_gain_tx( nbr_ant, 0 );
  }
  return 0;
}


/**
 * @short Sets the flags
 */
int swr_ant_set_flags( int nbr_ant, int flags ) {
  
  if ( nbr_ant >= MAX_ANTENNAS ) {
    PR_DBG( 0, "Asked for antenna %i, but only %i are available\n",
            nbr_ant, MAX_ANTENNAS );
    return -1;
  }
  
  params[ nbr_ant ].flags = flags;
  swr_ant_ch_reconfig( nbr_ant );
  
  return 0;
}


/**
 * @short Adjusts the offset
 */
int swr_ant_adjust_offset( int nbr_ant, int offset ) {

  if ( nbr_ant >= MAX_ANTENNAS ) {
    PR_DBG( 0, "Asked for antenna %i, but only %i are available\n",
            nbr_ant, MAX_ANTENNAS );
    return -1;
  }
  
  if ( disp_thread.state == STATE_EXIT ) {
    PR_DBG( 0, "adjust_offset: Dispatcher %i not here\n", nbr_ant );
    return 0;
  }
  // We don't do any mutexes...
  disp_thread.offset = offset;
  return disp_thread.offset;
}



int swr_ant_get_rx_tx_delay( int nbr_ant ){

  if ( nbr_ant >= MAX_ANTENNAS ) {
    PR_DBG( 0, "Asked for antenna %i, but only %i are available\n",
            nbr_ant, MAX_ANTENNAS );
    return -1;
  }
  return params[nbr_ant].rx_tx_delay;
}

int swr_ant_get_rx_gain( int nbr_ant ){
  
  if ( nbr_ant >= MAX_ANTENNAS ) {
    PR_DBG( 0, "Asked for antenna %i, but only %i are available\n",
            nbr_ant, MAX_ANTENNAS );
    return -1;
  }
  return params[nbr_ant].gain_rx;
}

/**
 * Just a default handler
 */
int swr_antenna_init( void ) {

  PR_DBG( 2, "Starting antenna\n" );
  initialised_antennas = 0;
  return 0;
}

void swr_antenna_exit( void ) {

  PR_DBG( 2, "Antenna is exiting\n" );
}

module_init( swr_antenna_init );
module_exit( swr_antenna_exit );


EXPORT_SYMBOL(swr_ant_init);
EXPORT_SYMBOL(swr_ant_free);
EXPORT_SYMBOL(swr_ant_start);
EXPORT_SYMBOL(swr_ant_stop);
EXPORT_SYMBOL(swr_ant_set_frame_params);
EXPORT_SYMBOL(swr_ant_set_gains);
EXPORT_SYMBOL(swr_ant_set_gain_rx);
EXPORT_SYMBOL(swr_ant_set_gain_tx);
EXPORT_SYMBOL(swr_ant_get_rx_gain);
EXPORT_SYMBOL(swr_ant_set_slot_len);
EXPORT_SYMBOL(swr_ant_adjust_offset);
EXPORT_SYMBOL(swr_ant_set_flags);
EXPORT_SYMBOL(swr_ant_get_rx_tx_delay);
EXPORT_SYMBOL(swr_ant_set_attn);
EXPORT_SYMBOL(swr_ant_set_attn_rx);
EXPORT_SYMBOL(swr_ant_set_attn_tx);