317 lines
11 KiB
C
317 lines
11 KiB
C
/*
|
|
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The OpenAirInterface Software Alliance licenses this file to You under
|
|
* the OAI Public License, Version 1.1 (the "License"); you may not use this file
|
|
* except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.openairinterface.org/?page_id=698
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*-------------------------------------------------------------------------------
|
|
* For more information about the OpenAirInterface (OAI) Software Alliance:
|
|
* contact@openairinterface.org
|
|
*/
|
|
|
|
/** iqplayer_lib.cpp
|
|
*
|
|
* \author:FrancoisTaburet: francois.taburet@nokia-bell-labs.com
|
|
*/
|
|
#define _LARGEFILE_SOURCE
|
|
#define _FILE_OFFSET_BITS 64
|
|
#include <string.h>
|
|
#include <pthread.h>
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <time.h>
|
|
#include <sys/resource.h>
|
|
#include <errno.h>
|
|
#include "common_lib.h"
|
|
#include "assertions.h"
|
|
#include "common/utils/LOG/log.h"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void parse_iqfile_header(openair0_device *device, iqfile_header_t *iq_fh) {
|
|
AssertFatal((memcmp(iq_fh->oaiid,OAIIQFILE_ID,sizeof(OAIIQFILE_ID)) == 0),
|
|
"iqfile doesn't seem to be compatible with oai (invalid id %.4s in header)\n",
|
|
iq_fh->oaiid);
|
|
device->type = iq_fh->devtype;
|
|
device->openair0_cfg[0].tx_sample_advance=iq_fh->tx_sample_advance;
|
|
device->openair0_cfg[0].tx_bw = device->openair0_cfg[0].rx_bw = iq_fh->bw;
|
|
LOG_UI(HW,"Replay iqs from %s device, bandwidth %e\n",get_devname(iq_fh->devtype),iq_fh->bw);
|
|
}
|
|
|
|
|
|
/*! \brief Called to start the iqplayer device. Return 0 if OK, < 0 if error
|
|
@param device pointer to the device structure specific to the RF hardware target
|
|
*/
|
|
static int iqplayer_loadfile(openair0_device *device, openair0_config_t *openair0_cfg) {
|
|
recplay_state_t *s = device->recplay_state;
|
|
recplay_conf_t *c = openair0_cfg->recplay_conf;
|
|
|
|
if (s->use_mmap) {
|
|
// use mmap
|
|
s->mmapfd = open(c->u_sf_filename, O_RDONLY );
|
|
|
|
if (s->mmapfd != 0) {
|
|
struct stat sb;
|
|
fstat(s->mmapfd, &sb);
|
|
s->mapsize=sb.st_size;
|
|
LOG_I(HW,"Loading subframes using mmap() from %s size=%lu bytes ...\n",c->u_sf_filename, (uint64_t)sb.st_size );
|
|
void *mptr = mmap(NULL, sb.st_size, PROT_WRITE, MAP_PRIVATE, s->mmapfd, 0) ;
|
|
s->ms_sample = (iqrec_t *) ( mmap(NULL, sb.st_size, PROT_WRITE, MAP_PRIVATE, s->mmapfd, 0) + sizeof(iqfile_header_t));
|
|
|
|
if (mptr != MAP_FAILED) {
|
|
parse_iqfile_header(device, (iqfile_header_t *)mptr);
|
|
s->ms_sample = (iqrec_t *)((char *)mptr + sizeof(iqfile_header_t));
|
|
s->nb_samples = ((sb.st_size-sizeof(iqfile_header_t)) / sizeof(iqrec_t));
|
|
int aligned = (((unsigned long)s->ms_sample & 31) == 0)? 1:0;
|
|
LOG_I(HW,"Loaded %u subframes.\n",s->nb_samples );
|
|
|
|
if (aligned == 0) {
|
|
LOG_E(HW, "mmap address is not 32 bytes aligned, exiting.\n" );
|
|
close(s->mmapfd);
|
|
exit(-1);
|
|
}
|
|
} else {
|
|
LOG_E(HW,"Cannot mmap file, exiting.\n");
|
|
close(s->mmapfd);
|
|
exit(-1);
|
|
}
|
|
} else {
|
|
LOG_E( HW,"Cannot open %s exiting.\n", c->u_sf_filename );
|
|
exit(-1);
|
|
}
|
|
} else {
|
|
s->iqfd = open(c->u_sf_filename, O_RDONLY);
|
|
|
|
if (s->iqfd != 0) {
|
|
struct stat sb;
|
|
iqfile_header_t fh;
|
|
size_t hs = read(s->iqfd,&fh,sizeof(fh));
|
|
|
|
if (hs == sizeof(fh)) {
|
|
parse_iqfile_header(device, &fh);
|
|
fstat(s->iqfd, &sb);
|
|
s->mapsize=sb.st_size;
|
|
s->nb_samples = ((sb.st_size-sizeof(iqfile_header_t))/ sizeof(iqrec_t));
|
|
LOG_I(HW, "Loading %u subframes from %s,size=%lu bytes ...\n",s->nb_samples, c->u_sf_filename,(uint64_t)sb.st_size);
|
|
// allocate buffer for 1 sample at a time
|
|
s->ms_sample = (iqrec_t *) malloc(sizeof(iqrec_t));
|
|
|
|
if (s->ms_sample == NULL) {
|
|
LOG_E(HW,"Memory allocation failed for individual subframe replay mode.\n" );
|
|
close(s->iqfd);
|
|
exit(-1);
|
|
}
|
|
|
|
memset(s->ms_sample, 0, sizeof(iqrec_t));
|
|
|
|
// point at beginning of iqs in file
|
|
if (lseek(s->iqfd,sizeof(iqfile_header_t), SEEK_SET) == 0) {
|
|
LOG_I(HW,"Initial seek at beginning of the file\n" );
|
|
} else {
|
|
LOG_I(HW,"Problem initial seek at beginning of the file\n");
|
|
}
|
|
} else {
|
|
LOG_E(HW,"Cannot read header in %s exiting.\n",c->u_sf_filename );
|
|
close(s->iqfd);
|
|
exit(-1);
|
|
}
|
|
} else {
|
|
LOG_E(HW,"Cannot open %s exiting.\n",c->u_sf_filename );
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief start the oai iq player
|
|
* \param device, the hardware used
|
|
*/
|
|
static int trx_iqplayer_start(openair0_device *device){
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief Terminate operation of the oai iq player
|
|
* \param device, the hardware used
|
|
*/
|
|
static void trx_iqplayer_end(openair0_device *device) {
|
|
if (device == NULL)
|
|
return;
|
|
|
|
if (device->recplay_state == NULL)
|
|
return;
|
|
|
|
if (device->recplay_state->use_mmap) {
|
|
if (device->recplay_state->ms_sample != MAP_FAILED) {
|
|
munmap(device->recplay_state->ms_sample, device->recplay_state->mapsize);
|
|
device->recplay_state->ms_sample = NULL;
|
|
}
|
|
|
|
if (device->recplay_state->mmapfd != 0) {
|
|
close(device->recplay_state->mmapfd);
|
|
device->recplay_state->mmapfd = 0;
|
|
}
|
|
} else {
|
|
if (device->recplay_state->ms_sample != NULL) {
|
|
free(device->recplay_state->ms_sample);
|
|
device->recplay_state->ms_sample = NULL;
|
|
}
|
|
|
|
if (device->recplay_state->iqfd != 0) {
|
|
close(device->recplay_state->iqfd);
|
|
device->recplay_state->iqfd = 0;
|
|
}
|
|
}
|
|
}
|
|
/*! \brief Write iqs function when in replay mode, just introduce a delay, as configured at init time,
|
|
@param device pointer to the device structure specific to the RF hardware target
|
|
@param timestamp The timestamp at which the first sample MUST be sent
|
|
@param buff Buffer which holds the samples
|
|
@param nsamps number of samples to be sent
|
|
@param antenna_id index of the antenna if the device has multiple antennas
|
|
@param flags flags must be set to TRUE if timestamp parameter needs to be applied
|
|
*/
|
|
static int trx_iqplayer_write(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags) {
|
|
struct timespec req;
|
|
req.tv_sec = 0;
|
|
req.tv_nsec = device->openair0_cfg->recplay_conf->u_sf_write_delay * 1000;
|
|
nanosleep(&req, NULL);
|
|
return nsamps;
|
|
}
|
|
|
|
/*! \brief Receive samples from iq file.
|
|
* Read \ref nsamps samples from each channel to buffers. buff[0] is the array for
|
|
* the first channel. *ptimestamp is the time at which the first sample
|
|
* was received.
|
|
* \param device the hardware to use
|
|
* \param[out] ptimestamp the time at which the first sample was received.
|
|
* \param[out] buff An array of pointers to buffers for received samples. The buffers must be large enough to hold the number of samples \ref nsamps.
|
|
* \param nsamps Number of samples. One sample is 2 byte I + 2 byte Q => 4 byte.
|
|
* \param antenna_id Index of antenna for which to receive samples
|
|
* \returns the number of sample read
|
|
*/
|
|
static int trx_iqplayer_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc) {
|
|
int samples_received=0;
|
|
static unsigned int cur_samples;
|
|
static int64_t wrap_count;
|
|
static int64_t wrap_ts;
|
|
recplay_state_t *s = device->recplay_state;
|
|
|
|
if (cur_samples == s->nb_samples) {
|
|
cur_samples = 0;
|
|
wrap_count++;
|
|
|
|
if (wrap_count == device->openair0_cfg->recplay_conf->u_sf_loops) {
|
|
LOG_W(HW, "iqplayer device terminating subframes replay after %u iteration\n",device->openair0_cfg->recplay_conf->u_sf_loops);
|
|
exit_function(__FILE__, __FUNCTION__, __LINE__,"replay ended, triggering process termination\n");
|
|
}
|
|
|
|
wrap_ts = wrap_count * (s->nb_samples * (((int)(device->openair0_cfg[0].sample_rate)) / 1000));
|
|
|
|
if (!device->recplay_state->use_mmap) {
|
|
if (lseek(device->recplay_state->iqfd, 0, SEEK_SET) == 0) {
|
|
LOG_I(HW,"Seeking at the beginning of IQ file");
|
|
} else {
|
|
LOG_I(HW, "Problem seeking at the beginning of IQ file");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (s->use_mmap) {
|
|
if (cur_samples < s->nb_samples) {
|
|
*ptimestamp = (s->ms_sample[0].ts + (cur_samples * (((int)(device->openair0_cfg[0].sample_rate)) / 1000))) + wrap_ts;
|
|
|
|
if (cur_samples == 0) {
|
|
LOG_I(HW,"starting subframes file with wrap_count=%lu wrap_ts=%lu ts=%lu\n", wrap_count,wrap_ts,*ptimestamp);
|
|
}
|
|
|
|
memcpy(buff[0], &s->ms_sample[cur_samples].samples[0], nsamps*4);
|
|
cur_samples++;
|
|
}
|
|
} else {
|
|
// read sample from file
|
|
if (read(s->iqfd, s->ms_sample, sizeof(iqrec_t)) != sizeof(iqrec_t)) {
|
|
LOG_E(HW,"pb reading iqfile at index %lu\n",sizeof(iqrec_t)*cur_samples );
|
|
close(s->iqfd);
|
|
free(s->ms_sample);
|
|
s->ms_sample = NULL;
|
|
s->iqfd = 0;
|
|
exit(-1);
|
|
}
|
|
|
|
if (cur_samples < s->nb_samples) {
|
|
static int64_t ts0 = 0;
|
|
|
|
if ((cur_samples == 0) && (wrap_count == 0)) {
|
|
ts0 = s->ms_sample->ts;
|
|
}
|
|
|
|
*ptimestamp = ts0 + (cur_samples * (((int)(device->openair0_cfg[0].sample_rate)) / 1000)) + wrap_ts;
|
|
|
|
if (cur_samples == 0) {
|
|
LOG_I(HW, "starting subframes file with wrap_count=%lu wrap_ts=%lu ts=%lu ",wrap_count,wrap_ts, *ptimestamp);
|
|
}
|
|
|
|
memcpy(buff[0], &s->ms_sample->samples[0], nsamps*4);
|
|
cur_samples++;
|
|
// Prepare for next read
|
|
off_t where = lseek(s->iqfd, cur_samples * sizeof(iqrec_t), SEEK_SET);
|
|
|
|
if (where < 0) {
|
|
LOG_E(HW,"Cannot lseek in iqfile: %s\n",strerror(errno));
|
|
exit(-1);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct timespec req;
|
|
|
|
req.tv_sec = 0;
|
|
|
|
req.tv_nsec = (device->openair0_cfg[0].recplay_conf->u_sf_read_delay) * 1000;
|
|
|
|
nanosleep(&req, NULL);
|
|
|
|
return nsamps;
|
|
|
|
return samples_received;
|
|
}
|
|
|
|
|
|
int device_init(openair0_device *device, openair0_config_t *openair0_cfg) {
|
|
device->openair0_cfg = openair0_cfg;
|
|
device->trx_start_func = trx_iqplayer_start;
|
|
device->trx_get_stats_func = NULL;
|
|
device->trx_reset_stats_func = NULL;
|
|
device->trx_end_func = trx_iqplayer_end;
|
|
device->trx_stop_func = NULL;
|
|
device->trx_set_freq_func = NULL;
|
|
device->trx_set_gains_func = NULL;
|
|
// Replay subframes from from file
|
|
// openair0_cfg[0].rx_gain_calib_table = calib_table_b210_38;
|
|
// bw_gain_adjust=1;
|
|
device->trx_write_func = trx_iqplayer_write;
|
|
device->trx_read_func = trx_iqplayer_read;
|
|
iqplayer_loadfile(device, openair0_cfg);
|
|
LOG_UI(HW,"iqplayer device initialized, replay %s for %i iterations",openair0_cfg->recplay_conf->u_sf_filename,openair0_cfg->recplay_conf->u_sf_loops);
|
|
return 0;
|
|
}
|
|
|
|
/*@}*/
|