1 
2 #include <string.h>
3 #include <stdint.h>
4 #include <stdbool.h>
5 #include "globdef.h"
6 #include "uidef.h"
7 #include "sdrdef.h"
8 #include "fft1def.h"
9 #include "screendef.h"
10 #include "rusage.h"
11 #include "thrdef.h"
12 #include "vernr.h"
13 #include "hwaredef.h"
14 
15 struct bladerf;
16 struct bladerf_stream;
17 
18 #define BLADERF_ERR_UNEXPECTED  (-1)  /**< An unexpected failure occurred */
19 #define BLADERF_ERR_RANGE       (-2)  /**< Provided parameter is out of range */
20 #define BLADERF_ERR_INVAL       (-3)  /**< Invalid operation/parameter */
21 #define BLADERF_ERR_MEM         (-4)  /**< Memory allocation error */
22 #define BLADERF_ERR_IO          (-5)  /**< File/Device I/O error */
23 #define BLADERF_ERR_TIMEOUT     (-6)  /**< Operation timed out */
24 #define BLADERF_ERR_NODEV       (-7)  /**< No device(s) available */
25 #define BLADERF_ERR_UNSUPPORTED (-8)  /**< Operation not supported */
26 #define BLADERF_ERR_MISALIGNED  (-9)  /**< Misaligned flash access */
27 #define BLADERF_ERR_CHECKSUM    (-10) /**< Invalid checksum */
28 
29 typedef enum {
30     BLADERF_BACKEND_ANY,    /**< "Don't Care" -- use any available backend */
31     BLADERF_BACKEND_LINUX,  /**< Linux kernel driver */
32     BLADERF_BACKEND_LIBUSB  /**< libusb */
33 } bladerf_backend;
34 
35 typedef enum {
36     BLADERF_DEVICE_SPEED_UNKNOWN,
37     BLADERF_DEVICE_SPEED_HIGH,
38     BLADERF_DEVICE_SPEED_SUPER,
39 } bladerf_dev_speed;
40 
41 #define BLADERF_SERIAL_LENGTH   33
42 
43 struct bladerf_devinfo {
44     bladerf_backend backend;    /**< Backend to use when connecting to device */
45     char serial[BLADERF_SERIAL_LENGTH]; /**< Device serial number string */
46     uint8_t usb_bus;            /**< Bus # device is attached to */
47     uint8_t usb_addr;           /**< Device address on bus */
48     unsigned int instance;      /**< Device instance or ID */
49 };
50 
51 struct bladerf_rational_rate {
52     uint64_t integer;           /**< Integer portion */
53     uint64_t num;               /**< Numerator in fractional portion */
54     uint64_t den;               /**< Denominator in fractional portion. This
55                                      must be > 0. */
56 };
57 
58 struct bladerf_stats {
59 
60     /** The number of times samples have been lost in the FPGA */
61     uint64_t rx_overruns;
62 
63     /** The overall throughput of the device in samples/second */
64     uint64_t rx_throughput;
65 
66     /**  Number of times samples have been too late to transmit to the FPGA */
67     uint64_t tx_underruns;
68 
69     /** The overall throughput of the device in samples/second */
70     uint64_t tx_throughput;
71 };
72 
73 struct bladerf_version {
74     uint16_t major;             /**< Major version */
75     uint16_t minor;             /**< Minor version */
76     uint16_t patch;             /**< Patch version */
77     const char *describe;       /**< Version string with any additional suffix
78                                  *   information.
79                                  *
80                                  *   @warning Do not attempt to modify or
81                                  *            free() this string. */
82 };
83 
84 typedef enum {
85     BLADERF_FORMAT_SC16_Q12, /**< Signed, Complex 16-bit Q12.
86                                *  This is the native format of the DAC data.
87                                *
88                                *  Samples are interleaved IQ value pairs, where
89                                *  each value in the pair is an int16_t. For each
90                                *  value, the data in the lower bits. The upper
91                                *  bits are reserved.
92                                *
93                                *  When using this format, note that buffers
94                                *  must be at least
95                                *       2 * num_samples * sizeof(int16_t)
96                                *  bytes large
97                                */
98 } bladerf_format;
99 
100 typedef enum {
101     BLADERF_FPGA_UNKNOWN = 0,   /**< Unable to determine FPGA variant */
102     BLADERF_FPGA_40KLE = 40,    /**< 40 kLE FPGA */
103     BLADERF_FPGA_115KLE = 115   /**< 115 kLE FPGA */
104 } bladerf_fpga_size;
105 
106 struct bladerf_metadata {
107     uint32_t version;       /**< Metadata format version */
108     uint64_t timestamp;     /**< Timestamp (TODO format TBD) */
109 };
110 
111 typedef enum {
112     BLADERF_SAMPLING_UNKNOWN,  /**< Unable to determine connection type */
113     BLADERF_SAMPLING_INTERNAL, /**< Sample from RX/TX connector */
114     BLADERF_SAMPLING_EXTERNAL  /**< Sample from J60 or J61 */
115 } bladerf_sampling;
116 
117 typedef enum {
118     BLADERF_LNA_GAIN_UNKNOWN,    /**< Invalid LNA gain */
119     BLADERF_LNA_GAIN_BYPASS,     /**< LNA bypassed - 0dB gain */
120     BLADERF_LNA_GAIN_MID,        /**< LNA Mid Gain (MAX-6dB) */
121     BLADERF_LNA_GAIN_MAX         /**< LNA Max Gain */
122 } bladerf_lna_gain;
123 
124 typedef enum {
125     BLADERF_LPF_NORMAL,     /**< LPF connected and enabled */
126     BLADERF_LPF_BYPASSED,   /**< LPF bypassed */
127     BLADERF_LPF_DISABLED    /**< LPF disabled */
128 } bladerf_lpf_mode;
129 
130 typedef enum
131 {
132     BLADERF_MODULE_RX,  /**< Receive Module */
133     BLADERF_MODULE_TX   /**< Transmit Module */
134 } bladerf_module;
135 
136 typedef enum
137 {
138     BLADERF_DC_CAL_LPF_TUNING,
139     BLADERF_DC_CAL_TX_LPF,
140     BLADERF_DC_CAL_RX_LPF,
141     BLADERF_DC_CAL_RXVGA2
142 } bladerf_cal_module;
143 
144 
145 typedef enum {
146     BLADERF_LOG_LEVEL_VERBOSE,  /**< Verbose level logging */
147     BLADERF_LOG_LEVEL_DEBUG,    /**< Debug level logging */
148     BLADERF_LOG_LEVEL_INFO,     /**< Information level logging */
149     BLADERF_LOG_LEVEL_WARNING,  /**< Warning level logging */
150     BLADERF_LOG_LEVEL_ERROR,    /**< Error level logging */
151     BLADERF_LOG_LEVEL_CRITICAL, /**< Fatal error level logging */
152     BLADERF_LOG_LEVEL_SILENT    /**< No output */
153 } bladerf_log_level;
154 
155 typedef void *(*bladerf_stream_cb)(struct bladerf *dev,
156                                    struct bladerf_stream *stream,
157                                    struct bladerf_metadata *meta,
158                                    void *samples,
159                                    size_t num_samples,
160                                    void *user_data);
161 
162 
163 #if(OSNUM == OSNUM_WINDOWS)
164 HANDLE bladerf_libhandle;
165 #endif
166 
167 #if(OSNUM == OSNUM_LINUX)
168 #include <dlfcn.h>
169 void *bladerf_libhandle;
170 #endif
171 
172 typedef int (*p_bladerf_get_device_list)(struct bladerf_devinfo **devices);
173 typedef void (*p_bladerf_free_device_list)(struct bladerf_devinfo *devices);
174 typedef int (*p_bladerf_open_with_devinfo)(struct bladerf **device,
175                                         struct bladerf_devinfo *devinfo);
176 typedef void (*p_bladerf_close)(struct bladerf *device);
177 typedef int (*p_bladerf_enable_module)(struct bladerf *dev,
178                                    bladerf_module m, bool enable);
179 typedef int (*p_bladerf_set_sample_rate)(struct bladerf *dev,
180                                       bladerf_module module,
181                                       unsigned int rate,
182                                       unsigned int *actual);
183 typedef int (*p_bladerf_set_sampling)(struct bladerf *dev,
184                                    bladerf_sampling sampling);
185 typedef int (*p_bladerf_set_lna_gain)(struct bladerf *dev, bladerf_lna_gain gain);
186 typedef int (*p_bladerf_set_rxvga1)(struct bladerf *dev, int gain);
187 typedef int (*p_bladerf_set_rxvga2)(struct bladerf *dev, int gain);
188 typedef int (*p_bladerf_set_bandwidth)(struct bladerf *dev, bladerf_module module,
189                                     unsigned int bandwidth,
190                                     unsigned int *actual);
191 typedef int (*p_bladerf_select_band)(struct bladerf *dev, bladerf_module module,
192                                   unsigned int frequency);
193 typedef int (*p_bladerf_set_lpf_mode)(struct bladerf *dev, bladerf_module module,
194                                    bladerf_lpf_mode mode);
195 typedef int (*p_bladerf_set_frequency)(struct bladerf *dev,
196                                     bladerf_module module,
197                                     unsigned int frequency);
198 typedef int (*p_bladerf_init_stream)(struct bladerf_stream **stream,
199                                   struct bladerf *dev,
200                                   bladerf_stream_cb callback,
201                                   void ***buffers,
202                                   size_t num_buffers,
203                                   bladerf_format format,
204                                   size_t num_samples,
205                                   size_t num_transfers,
206                                   void *user_data);
207 typedef int (*p_bladerf_stream)(struct bladerf_stream *stream,
208                              bladerf_module module);
209 typedef void (*p_bladerf_deinit_stream)(struct bladerf_stream *stream);
210 typedef int (*p_bladerf_get_fpga_size)(struct bladerf *dev,
211                                     bladerf_fpga_size *size);
212 typedef int (*p_bladerf_fw_version)(struct bladerf *dev,
213                                  struct bladerf_version *version);
214 typedef int (*p_bladerf_is_fpga_configured)(struct bladerf *dev);
215 typedef int (*p_bladerf_fpga_version)(struct bladerf *dev,
216                                    struct bladerf_version *version);
217 typedef const char * (*p_bladerf_strerror)(int error);
218 typedef void (*p_bladerf_version)(struct bladerf_version *version);
219 typedef int (*p_bladerf_calibrate_dc)(struct bladerf *dev,
220                                    bladerf_cal_module module);
221 
222 p_bladerf_get_device_list bladerf_get_device_list;
223 p_bladerf_free_device_list bladerf_free_device_list;
224 p_bladerf_open_with_devinfo bladerf_open_with_devinfo;
225 p_bladerf_close bladerf_close;
226 p_bladerf_enable_module bladerf_enable_module;
227 p_bladerf_set_sample_rate bladerf_set_sample_rate;
228 p_bladerf_set_sampling bladerf_set_sampling;
229 p_bladerf_set_lna_gain bladerf_set_lna_gain;
230 p_bladerf_set_rxvga1 bladerf_set_rxvga1;
231 p_bladerf_set_rxvga2 bladerf_set_rxvga2;
232 p_bladerf_set_bandwidth bladerf_set_bandwidth;
233 p_bladerf_select_band bladerf_select_band;
234 p_bladerf_set_lpf_mode bladerf_set_lpf_mode;
235 p_bladerf_set_frequency bladerf_set_frequency;
236 p_bladerf_init_stream bladerf_init_stream;
237 p_bladerf_stream bladerf_stream;
238 p_bladerf_deinit_stream bladerf_deinit_stream;
239 p_bladerf_get_fpga_size bladerf_get_fpga_size;
240 p_bladerf_fw_version bladerf_fw_version;
241 p_bladerf_is_fpga_configured bladerf_is_fpga_configured;
242 p_bladerf_fpga_version bladerf_fpga_version;
243 p_bladerf_strerror bladerf_strerror;
244 p_bladerf_version bladerf_version;
245 p_bladerf_calibrate_dc bladerf_calibrate_dc;
246 
247 
248 P_BLADERF bladerf;
249 
250 char *bladerf_parm_text[MAX_BLADERF_PARM]={"Rx sampling speed",
251                                      "Rx resampling factor",
252                                      "Serno1",
253                                      "Serno2",
254                                      "Serno3",
255                                      "Serno4",
256                                      "Serno5",
257                                      "Serno6",
258                                      "Serno7",
259                                      "Serno8",
260                                      "Freq adjust",
261                                      "Sampling",
262                                      "Bandwidth",
263                                      "Gain mode",
264                                      "Check"};
265 
266 char *bladerf_parfil_name="par_bladerf";
267 
268 #define MIN_BLADERF_SAMP_RATE 79000
269 #define MAX_BLADERF_SAMP_RATE 40000000
270 
271 struct bladerf *dev_bladerf;
272 int shutdown_rx_bladerf;
273 
274 
275 int usb_idx;
276 int usb_no_of_buffers;
277 void** usb_buffers;
278 
279 #ifndef BLADERF_FORMAT_SC16_Q11
280 #define BLADERF_FORMAT_SC16_Q11 BLADERF_FORMAT_SC16_Q12
281 #endif
282 
283 #if(OSNUM == OSNUM_LINUX)
load_bladerf_library(void)284 int load_bladerf_library(void)
285 {
286 int info;
287 info=0;
288 bladerf_libhandle=dlopen(BLADERF_LIBNAME, RTLD_LAZY);
289 if(bladerf_libhandle == NULL)goto load_error;
290 info=1;
291 bladerf_get_device_list=(p_bladerf_get_device_list)
292                           dlsym(bladerf_libhandle, "bladerf_get_device_list");
293 if(dlerror() != 0)goto sym_error;
294 bladerf_free_device_list=(p_bladerf_free_device_list)
295                          dlsym(bladerf_libhandle, "bladerf_free_device_list");
296 if(dlerror() != 0)goto sym_error;
297 bladerf_open_with_devinfo=(p_bladerf_open_with_devinfo)
298                         dlsym(bladerf_libhandle, "bladerf_open_with_devinfo");
299 if(dlerror() != 0)goto sym_error;
300 bladerf_close=(p_bladerf_close)dlsym(bladerf_libhandle, "bladerf_close");
301 if(dlerror() != 0)goto sym_error;
302 bladerf_enable_module=(p_bladerf_enable_module)
303                            dlsym(bladerf_libhandle, "bladerf_enable_module");
304 if(dlerror() != 0)goto sym_error;
305 bladerf_set_sample_rate=(p_bladerf_set_sample_rate)
306                         dlsym(bladerf_libhandle, "bladerf_set_sample_rate");
307 if(dlerror() != 0)goto sym_error;
308 bladerf_set_sampling=(p_bladerf_set_sampling)
309                              dlsym(bladerf_libhandle, "bladerf_set_sampling");
310 if(dlerror() != 0)goto sym_error;
311 bladerf_set_lna_gain=(p_bladerf_set_lna_gain)
312                             dlsym(bladerf_libhandle, "bladerf_set_lna_gain");
313 if(dlerror() != 0)goto sym_error;
314 bladerf_set_rxvga1=(p_bladerf_set_rxvga1)
315                              dlsym(bladerf_libhandle, "bladerf_set_rxvga1");
316 if(dlerror() != 0)goto sym_error;
317 bladerf_set_rxvga2=(p_bladerf_set_rxvga2)
318                             dlsym(bladerf_libhandle, "bladerf_set_rxvga2");
319 if(dlerror() != 0)goto sym_error;
320 bladerf_set_bandwidth=(p_bladerf_set_bandwidth)
321                             dlsym(bladerf_libhandle, "bladerf_set_bandwidth");
322 if(dlerror() != 0)goto sym_error;
323 bladerf_select_band=(p_bladerf_select_band)
324                              dlsym(bladerf_libhandle, "bladerf_select_band");
325 if(dlerror() != 0)goto sym_error;
326 bladerf_set_lpf_mode=(p_bladerf_set_lpf_mode)
327                             dlsym(bladerf_libhandle, "bladerf_set_lpf_mode");
328 if(dlerror() != 0)goto sym_error;
329 bladerf_set_frequency=(p_bladerf_set_frequency)
330                            dlsym(bladerf_libhandle, "bladerf_set_frequency");
331 if(dlerror() != 0)goto sym_error;
332 bladerf_init_stream=(p_bladerf_init_stream)dlsym
333                                   (bladerf_libhandle, "bladerf_init_stream");
334 if(dlerror() != 0)goto sym_error;
335 bladerf_stream=(p_bladerf_stream)dlsym(bladerf_libhandle, "bladerf_stream");
336 if(dlerror() != 0)goto sym_error;
337 bladerf_deinit_stream=(p_bladerf_deinit_stream)
338                             dlsym(bladerf_libhandle, "bladerf_deinit_stream");
339 if(dlerror() != 0)goto sym_error;
340 bladerf_get_fpga_size=(p_bladerf_get_fpga_size)dlsym
341                                   (bladerf_libhandle, "bladerf_get_fpga_size");
342 if(dlerror() != 0)goto sym_error;
343 bladerf_fw_version=(p_bladerf_fw_version)
344                             dlsym(bladerf_libhandle, "bladerf_fw_version");
345 if(dlerror() != 0)goto sym_error;
346 bladerf_is_fpga_configured=(p_bladerf_is_fpga_configured)
347                        dlsym(bladerf_libhandle, "bladerf_is_fpga_configured");
348 if(dlerror() != 0)goto sym_error;
349 bladerf_fpga_version=(p_bladerf_fpga_version)dlsym
350                                   (bladerf_libhandle, "bladerf_fpga_version");
351 if(dlerror() != 0)goto sym_error;
352 bladerf_strerror=(p_bladerf_strerror)
353                                   dlsym(bladerf_libhandle, "bladerf_strerror");
354 if(dlerror() != 0)goto sym_error;
355 bladerf_version=(p_bladerf_version)dlsym(bladerf_libhandle, "bladerf_version");
356 if(dlerror() != 0)goto sym_error;
357 bladerf_calibrate_dc=(p_bladerf_calibrate_dc)
358                               dlsym(bladerf_libhandle, "bladerf_calibrate_dc");
359 if(dlerror() != 0)goto sym_error;
360 return 0;
361 sym_error:;
362 dlclose(bladerf_libhandle);
363 load_error:;
364 library_error_screen(BLADERF_LIBNAME,info);
365 return -1;
366 }
367 
unload_bladerf_library(void)368 void unload_bladerf_library(void)
369 {
370 dlclose(bladerf_libhandle);
371 }
372 #endif
373 
374 
375 #if(OSNUM == OSNUM_WINDOWS)
load_bladerf_library(void)376 int load_bladerf_library(void)
377 {
378 int info;
379 info=0;
380 bladerf_libhandle=LoadLibrary("bladeRF.dll");
381 if(bladerf_libhandle == NULL)goto load_error;
382 info=1;
383 bladerf_get_device_list=(p_bladerf_get_device_list)
384                  GetProcAddress(bladerf_libhandle, "bladerf_get_device_list");
385 if(!bladerf_get_device_list)goto sym_error;
386 bladerf_free_device_list=(p_bladerf_free_device_list)
387                 GetProcAddress(bladerf_libhandle, "bladerf_free_device_list");
388 if(!bladerf_free_device_list)goto sym_error;
389 bladerf_open_with_devinfo=(p_bladerf_open_with_devinfo)
390                GetProcAddress(bladerf_libhandle, "bladerf_open_with_devinfo");
391 if(!bladerf_open_with_devinfo)goto sym_error;
392 bladerf_close=(p_bladerf_close)
393                           GetProcAddress(bladerf_libhandle, "bladerf_close");
394 if(!bladerf_close)goto sym_error;
395 bladerf_enable_module=(p_bladerf_enable_module)
396                    GetProcAddress(bladerf_libhandle, "bladerf_enable_module");
397 if(!bladerf_enable_module)goto sym_error;
398 bladerf_set_sample_rate=(p_bladerf_set_sample_rate)
399                  GetProcAddress(bladerf_libhandle, "bladerf_set_sample_rate");
400 if(!bladerf_set_sample_rate)goto sym_error;
401 bladerf_set_sampling=(p_bladerf_set_sampling)
402                     GetProcAddress(bladerf_libhandle, "bladerf_set_sampling");
403 if(!bladerf_set_sampling)goto sym_error;
404 bladerf_set_lna_gain=(p_bladerf_set_lna_gain)
405                     GetProcAddress(bladerf_libhandle, "bladerf_set_lna_gain");
406 if(!bladerf_set_lna_gain)goto sym_error;
407 bladerf_set_rxvga1=(p_bladerf_set_rxvga1)
408                      GetProcAddress(bladerf_libhandle, "bladerf_set_rxvga1");
409 if(!bladerf_set_rxvga1)goto sym_error;
410 bladerf_set_rxvga2=(p_bladerf_set_rxvga2)
411                     GetProcAddress(bladerf_libhandle, "bladerf_set_rxvga2");
412 if(!bladerf_set_rxvga2)goto sym_error;
413 bladerf_set_bandwidth=(p_bladerf_set_bandwidth)
414                     GetProcAddress(bladerf_libhandle, "bladerf_set_bandwidth");
415 if(!bladerf_set_bandwidth)goto sym_error;
416 bladerf_select_band=(p_bladerf_select_band)
417                      GetProcAddress(bladerf_libhandle, "bladerf_select_band");
418 if(!bladerf_select_band)goto sym_error;
419 bladerf_set_lpf_mode=(p_bladerf_set_lpf_mode)
420                     GetProcAddress(bladerf_libhandle, "bladerf_set_lpf_mode");
421 if(!bladerf_set_lpf_mode)goto sym_error;
422 bladerf_set_frequency=(p_bladerf_set_frequency)
423                    GetProcAddress(bladerf_libhandle, "bladerf_set_frequency");
424 if(!bladerf_set_frequency)goto sym_error;
425 bladerf_init_stream=(p_bladerf_init_stream)
426                      GetProcAddress(bladerf_libhandle, "bladerf_init_stream");
427 if(!bladerf_init_stream)goto sym_error;
428 bladerf_stream=(p_bladerf_stream)
429                          GetProcAddress(bladerf_libhandle, "bladerf_stream");
430 if(!bladerf_stream)goto sym_error;
431 bladerf_deinit_stream=(p_bladerf_deinit_stream)
432                   GetProcAddress(bladerf_libhandle, "bladerf_deinit_stream");
433 if(!bladerf_deinit_stream)goto sym_error;
434 bladerf_get_fpga_size=(p_bladerf_get_fpga_size)GetProcAddress
435                                 (bladerf_libhandle, "bladerf_get_fpga_size");
436 if(!bladerf_get_fpga_size)goto sym_error;
437 bladerf_fw_version=(p_bladerf_fw_version)
438                      GetProcAddress(bladerf_libhandle, "bladerf_fw_version");
439 if(!bladerf_fw_version)goto sym_error;
440 bladerf_is_fpga_configured=(p_bladerf_is_fpga_configured)
441              GetProcAddress(bladerf_libhandle, "bladerf_is_fpga_configured");
442 if(!bladerf_is_fpga_configured)goto sym_error;
443 bladerf_fpga_version=(p_bladerf_fpga_version)
444                    GetProcAddress(bladerf_libhandle, "bladerf_fpga_version");
445 if(!bladerf_fpga_version)goto sym_error;
446 bladerf_strerror=(p_bladerf_strerror)
447                        GetProcAddress(bladerf_libhandle, "bladerf_strerror");
448 if(!bladerf_strerror)goto sym_error;
449 bladerf_version=(p_bladerf_version)
450                         GetProcAddress(bladerf_libhandle, "bladerf_version");
451 if(!bladerf_version)goto sym_error;
452 bladerf_calibrate_dc=(p_bladerf_calibrate_dc)
453                   GetProcAddress(bladerf_libhandle, "bladerf_calibrate_dc");
454 if(!bladerf_calibrate_dc)goto sym_error;
455 CoInitialize(NULL);
456 return 0;
457 sym_error:;
458 FreeLibrary(bladerf_libhandle);
459 load_error:;
460 library_error_screen("bladeRF.dll",info);
461 return -1;
462 }
463 
unload_bladerf_library(void)464 void unload_bladerf_library(void)
465 {
466 FreeLibrary(bladerf_libhandle);
467 CoUninitialize();
468 }
469 #endif
470 
471 
bladerf_callback(struct bladerf * dev,struct bladerf_stream * stream,struct bladerf_metadata * metadata,void * samples,size_t num_samples,void * user_data)472 void *bladerf_callback(struct bladerf *dev,
473                       struct bladerf_stream *stream,
474                       struct bladerf_metadata *metadata,
475                       void *samples,
476                       size_t num_samples,
477                       void *user_data)
478 {
479 (void)dev;
480 (void) stream;
481 (void)metadata;
482 (void)num_samples;
483 (void)user_data;
484 short int *buf1, *buf2;
485 short int x[8];
486 unsigned int i, n;
487 buf1=(short int*)samples;
488 switch (bladerf.rx_resampling_factor)
489   {
490   case 0:
491   for(i=0; i<num_samples; i++)
492     {
493     buf2=(short int*)&timf1_char[timf1p_sdr];
494     buf2[0]=buf1[2*i];
495     buf2[1]=buf1[2*i+1];
496     buf2[0]-=0x8000;
497     buf2[1]-=0x8000;
498     buf2[0]<<=4;
499     buf2[1]<<=4;
500     timf1p_sdr=(timf1p_sdr+4)&timf1_bytemask;
501     }
502   break;
503 
504   case 1:
505   n=num_samples/2;
506   for(i=0; i<n; i++)
507     {
508     buf2=(short int*)&timf1_char[timf1p_sdr];
509     buf2[0]=buf1[4*i  ];
510     buf2[1]=buf1[4*i+1];
511     buf2[0]-=0x8000;
512     buf2[1]-=0x8000;
513     buf2[0]<<=4;
514     buf2[1]<<=4;
515     x[2]=buf1[4*i+2];
516     x[3]=buf1[4*i+3];
517     x[2]-=0x8000;
518     x[3]-=0x8000;
519     x[2]<<=4;
520     x[3]<<=4;
521     buf2[0]=buf2[0]/2+x[2]/2;
522     buf2[1]=buf2[1]/2+x[3]/2;
523     timf1p_sdr=(timf1p_sdr+4)&timf1_bytemask;
524     }
525   break;
526 
527   case 2:
528   n=num_samples/4;
529   for(i=0; i<n; i++)
530     {
531     buf2=(short int*)&timf1_char[timf1p_sdr];
532     buf2[0]=buf1[8*i  ];
533     buf2[1]=buf1[8*i+1];
534     buf2[0]-=0x8000;
535     buf2[1]-=0x8000;
536     buf2[0]<<=4;
537     buf2[1]<<=4;
538     x[2]=buf1[8*i+2];
539     x[3]=buf1[8*i+3];
540     x[2]-=0x8000;
541     x[3]-=0x8000;
542     x[2]<<=4;
543     x[3]<<=4;
544     x[4]=buf1[8*i+4];
545     x[5]=buf1[8*i+5];
546     x[4]-=0x8000;
547     x[5]-=0x8000;
548     x[4]<<=4;
549     x[5]<<=4;
550     x[6]=buf1[8*i+4];
551     x[7]=buf1[8*i+5];
552     x[6]-=0x8000;
553     x[7]-=0x8000;
554     x[6]<<=4;
555     x[7]<<=4;
556     buf2[0]=buf2[0]/4+x[2]/4+x[4]/4+x[6]/4;
557     buf2[1]=buf2[1]/2+x[3]/2+x[5]/4+x[7]/4;
558     timf1p_sdr=(timf1p_sdr+4)&timf1_bytemask;
559     }
560   break;
561 
562   }
563 if( ((timf1p_sdr-timf1p_pa+timf1_bytes)&timf1_bytemask) >=
564                                                      snd[RXAD].block_bytes)
565   {
566   lir_set_event(EVENT_HWARE1_RXREADY);
567   }
568 if(shutdown_rx_bladerf != 0)
569   {
570   shutdown_rx_bladerf=2;
571   return NULL;
572   }
573 usb_idx=(usb_idx+1)%usb_no_of_buffers;
574 return usb_buffers[usb_idx];;
575 }
576 
bladerf_starter(void)577 void bladerf_starter(void)
578 {
579 struct bladerf_stream * stream;
580 int i;
581 int k, no_of_buffers;
582 void **buffers;
583 k=snd[RXAD].block_bytes/4;
584 k=k<<bladerf.rx_resampling_factor;
585 if(k < 1024)k=1024;
586 // Allocate buffers for 50 ms minimum.
587 no_of_buffers=(int)((0.1*bladerf.rx_sampling_speed)/k);
588 // Never use less than 4 buffers.
589 if(no_of_buffers < 4)no_of_buffers=4;
590 while(thread_status_flag[THREAD_BLADERF_INPUT]!=THRFLAG_ACTIVE)
591   {
592   lir_sleep(10000);
593   if(kill_all_flag)return;
594   }
595 shutdown_rx_bladerf=0;
596 usb_idx=0;
597 usb_no_of_buffers=no_of_buffers;
598 bladerf_enable_module(dev_bladerf, BLADERF_MODULE_RX, true);
599 i=bladerf_init_stream(&stream,
600                       dev_bladerf,
601                       bladerf_callback,
602                       &buffers,
603                       no_of_buffers,
604                       BLADERF_FORMAT_SC16_Q11,
605                       k,
606                       no_of_buffers,
607                       NULL);
608 usb_buffers=buffers;
609 if(i<0)
610   {
611   lirerr(2376712);
612   return;
613   }
614 bladerf_stream(stream, BLADERF_MODULE_RX);
615 i=0;
616 while(i<50 && shutdown_rx_bladerf != 2)
617   {
618   lir_sleep(20000);
619   }
620 bladerf_deinit_stream(stream);
621 }
622 
calibrate_bladerf_rx(void)623 void calibrate_bladerf_rx(void)
624 {
625 
626 if(bladerf.bandwidth != 0)
627   {
628   bladerf_calibrate_dc(dev_bladerf, BLADERF_DC_CAL_RX_LPF);
629   bladerf_calibrate_dc(dev_bladerf, BLADERF_DC_CAL_LPF_TUNING);
630   }
631 //bladerf_calibrate_dc(dev_bladerf, BLADERF_DC_CAL_RXVGA2);
632 }
633 
set_bladerf_frequency(void)634 void set_bladerf_frequency(void)
635 {
636 uint32_t frequency;
637 if((bladerf_sampling)bladerf.sampling == BLADERF_SAMPLING_INTERNAL)
638   {
639   frequency=(fg.passband_center*(100000000-bladerf.freq_adjust))/100;
640   bladerf_set_frequency(dev_bladerf, BLADERF_MODULE_RX, frequency);
641   bladerf_select_band(dev_bladerf, BLADERF_MODULE_RX, frequency);
642   sys_func(THRFLAG_CALIBRATE_BLADERF_RX);
643   }
644 }
645 
set_bladerf_att(void)646 void set_bladerf_att(void)
647 {
648 bladerf_lna_gain lna;
649 int vga2, vga1;
650 vga1=24;
651 if(bladerf.gain_mode == 0)
652   {
653   lna=BLADERF_LNA_GAIN_BYPASS;
654   vga2=27;
655   switch (fg.gain)
656     {
657     case 21:
658     lna=BLADERF_LNA_GAIN_MAX;
659     vga1=16;
660     break;
661 
662     case 18:
663     lna=BLADERF_LNA_GAIN_MID;
664     vga1=24;
665     break;
666 
667     case 15:
668     lna=BLADERF_LNA_GAIN_MID;
669     vga1=19;
670     break;
671 
672     case 12:
673     lna=BLADERF_LNA_GAIN_MID;
674     vga1=14;
675     break;
676 
677     case 9:
678     vga1=30;
679     break;
680 
681     case 6:
682     vga1=28;
683     break;
684 
685     case 3:
686     vga1=28;
687     vga2=24;
688     break;
689 
690     case 0:
691     vga1=28;
692     vga2=21;
693     break;
694 
695     case -3:
696     vga1=26;
697     vga2=21;
698     break;
699 
700     case -6:
701     vga1=22;
702     vga2=21;
703     break;
704 
705     case -9:
706     vga1=17;
707     vga2=21;
708     break;
709 
710     case -12:
711     vga1=12;
712     vga2=21;
713     break;
714 
715     case -15:
716     vga1=7;
717     vga2=21;
718     break;
719 
720     case -18:
721     vga1=7;
722     vga2=18;
723     break;
724 
725     case -21:
726     vga1=7;
727     vga2=15;
728     break;
729     }
730   }
731 else
732   {
733   vga2=3;
734   lna=BLADERF_LNA_GAIN_MAX;
735   switch (fg.gain)
736     {
737     case 21:
738     vga2=18;
739     break;
740 
741     case 18:
742     vga2=15;
743     break;
744 
745     case 15:
746     vga2=12;
747     break;
748 
749     case 12:
750     vga2=9;
751     break;
752 
753     case 9:
754     vga2=6;
755     break;
756 
757     case 6:
758     break;
759 
760     case 3:
761     vga1=19;
762     break;
763 
764     case 0:
765     vga1=13;
766     break;
767 
768     case -3:
769     vga1=8;
770     break;
771 
772     case -6:
773     lna=BLADERF_LNA_GAIN_MID;
774     vga1=17;
775     break;
776 
777     case -9:
778     lna=BLADERF_LNA_GAIN_MID;
779     vga1=11;
780     break;
781 
782     case -12:
783     lna=BLADERF_LNA_GAIN_MID;
784     vga1=6;
785     break;
786 
787     case -15:
788     lna=BLADERF_LNA_GAIN_BYPASS;
789     vga1=28;
790     break;
791 
792     case -18:
793     lna=BLADERF_LNA_GAIN_BYPASS;
794     vga1=25;
795     break;
796 
797     case -21:
798     lna=BLADERF_LNA_GAIN_BYPASS;
799     vga1=21;
800     break;
801     }
802   }
803 bladerf_set_lna_gain(dev_bladerf, lna);
804 // vga1 range 5-33 step 1
805 bladerf_set_rxvga1(dev_bladerf, vga1);
806 // vga2 range 3-60 step 3 (above 30 not recommended.)
807 bladerf_set_rxvga2(dev_bladerf, vga2);
808 }
809 
810 
bladerf_input(void)811 void bladerf_input(void)
812 {
813 #if RUSAGE_OLD == TRUE
814 int local_workload_counter;
815 #endif
816 int i, j;
817 struct bladerf_devinfo *devices = NULL;
818 int rxin_local_workload_reset;
819 char s[128];
820 double dt1, read_start_time, total_reads;
821 int timing_loop_counter,timing_loop_counter_max,initial_skip_flag;
822 int local_att_counter;
823 int local_nco_counter;
824 int *ise;
825 int n_devices;
826 int idx;
827 lir_init_event(EVENT_HWARE1_RXREADY);
828 if(load_bladerf_library() != 0)goto await_exit;
829 ise=(int*)(void*)s;
830 #if OSNUM == OSNUM_LINUX
831 clear_thread_times(THREAD_BLADERF_INPUT);
832 #endif
833 #if RUSAGE_OLD == TRUE
834 local_workload_counter=workload_counter;
835 #endif
836 local_att_counter=sdr_att_counter;
837 local_nco_counter=sdr_nco_counter;
838 dt1=current_time();
839 i=read_sdrpar(bladerf_parfil_name, MAX_BLADERF_PARM,
840                                      bladerf_parm_text, (int*)((void*)&bladerf));
841 if(i != 0 || bladerf.check != BLADERFPAR_VERNR)
842   {
843   lirerr(1379);
844   goto bladerf_init_error_exit;
845   }
846 if((ui.rx_ad_speed << bladerf.rx_resampling_factor) !=
847               (int)((rint)((bladerf.rx_sampling_speed*
848                      (100000000L+(double)bladerf.freq_adjust))/100000000L)))
849   {
850   lirerr(1379);
851   goto bladerf_init_error_exit;
852   }
853 if( bladerf.check != BLADERFPAR_VERNR ||
854    bladerf.rx_resampling_factor < 0 ||
855    bladerf.rx_resampling_factor > 2 )
856   {
857   lirerr(1379);
858   goto bladerf_init_error_exit;
859   }
860 timf1p_sdr=timf1p_pa;
861 j=0;
862 
863 while(sdr == -1)
864   {
865   n_devices = bladerf_get_device_list(&devices);
866   for(idx=0; idx<n_devices; idx++)
867     {
868     if(devices == NULL || strlen(devices[idx].serial) > 33)
869       {
870       lirerr(1543962);
871       goto bladerf_init_error_exit;
872       }
873     sprintf(s,"%s",devices[idx].serial);
874     if( bladerf.sernum1 == ise[0] &&
875         bladerf.sernum2 == ise[1] &&
876         bladerf.sernum3 == ise[2] &&
877         bladerf.sernum4 == ise[3] &&
878         bladerf.sernum5 == ise[4] &&
879         bladerf.sernum6 == ise[5] &&
880         bladerf.sernum7 == ise[6] &&
881         bladerf.sernum8 == ise[7])
882       {
883       sdr=bladerf_open_with_devinfo(&dev_bladerf, &devices[idx]);
884       if(kill_all_flag)goto bladerf_init_error_exit;
885       if(sdr >= 0)
886         {
887         i=bladerf_is_fpga_configured(dev_bladerf);
888         if(i < 0)
889           {
890           lirerr(1380);
891 opnerr:;
892           bladerf_close(dev_bladerf);
893           goto bladerf_init_error_exit;
894           }
895         if(i == 0)
896           {
897           lirerr(1381);
898           goto opnerr;
899           }
900         i=bladerf_set_sampling(dev_bladerf,
901                                      (bladerf_sampling)bladerf.sampling);
902         if(i<0)
903           {
904           lirerr(1383);
905           goto opnerr;
906           }
907         i=bladerf_set_sample_rate(dev_bladerf, BLADERF_MODULE_RX,
908                  (unsigned int)bladerf.rx_sampling_speed, (unsigned int*)&j);
909         if(i<0)
910           {
911           lirerr(1385);
912           goto opnerr;
913           }
914         if(abs(bladerf.rx_sampling_speed-j) != 0)
915           {
916           lirerr(1386);
917           goto opnerr;
918           }
919         linrad_thread_create(THREAD_BLADERF_STARTER);
920         break;
921         }
922       else
923         {
924         if(j==0)
925           {
926           clear_screen();
927           j=1;
928           }
929         }
930       }
931     }
932   sprintf(s,"Waiting %.2f", current_time()-dt1);
933   lir_pixwrite(wg.xleft+4*text_width,wg.yborder-3*text_height,s);
934   lir_refresh_screen();
935   if(kill_all_flag)goto bladerf_init_error_exit;
936   lir_sleep(100000);
937   }
938 if((bladerf_sampling)bladerf.sampling == BLADERF_SAMPLING_INTERNAL)
939   {
940   if(bladerf.bandwidth == 0)
941     {
942     bladerf_set_lpf_mode(dev_bladerf, BLADERF_MODULE_RX, BLADERF_LPF_BYPASSED);
943 
944     bladerf_set_lpf_mode(dev_bladerf, BLADERF_MODULE_RX, BLADERF_LPF_DISABLED);
945     }
946   else
947     {
948     bladerf_set_lpf_mode(dev_bladerf, BLADERF_MODULE_RX, BLADERF_LPF_NORMAL);
949     bladerf_set_bandwidth(dev_bladerf, BLADERF_MODULE_RX,
950                           (unsigned int)bladerf.bandwidth, (unsigned int*)&i);
951     }
952   }
953 else
954   {
955   bladerf_set_lpf_mode(dev_bladerf, BLADERF_MODULE_RX, BLADERF_LPF_DISABLED);
956   }
957 if((bladerf_sampling)bladerf.sampling == BLADERF_SAMPLING_INTERNAL)
958   {
959   set_hardware_rx_gain();
960   set_bladerf_att();
961   set_bladerf_frequency();
962   }
963 fft1_block_timing();
964 if(thread_command_flag[THREAD_SCREEN]!=THRFLAG_NOT_ACTIVE)
965   {
966   while(thread_status_flag[THREAD_SCREEN]!=THRFLAG_ACTIVE &&
967         thread_status_flag[THREAD_SCREEN]!=THRFLAG_IDLE &&
968         thread_status_flag[THREAD_SCREEN]!=THRFLAG_SEM_WAIT)
969     {
970     if(thread_command_flag[THREAD_BLADERF_INPUT] ==
971                                            THRFLAG_KILL)goto bladerf_error_exit1;
972     lir_sleep(10000);
973     }
974   }
975 #include "timing_setup.c"
976 thread_status_flag[THREAD_BLADERF_INPUT]=THRFLAG_ACTIVE;
977 while(!kill_all_flag &&
978             thread_command_flag[THREAD_BLADERF_INPUT] == THRFLAG_ACTIVE)
979   {
980 #if RUSAGE_OLD == TRUE
981   if(local_workload_counter != workload_counter)
982     {
983     local_workload_counter=workload_counter;
984     make_thread_times(THREAD_BLADERF_INPUT);
985     }
986 #endif
987   if((bladerf_sampling)bladerf.sampling == BLADERF_SAMPLING_INTERNAL)
988     {
989     if(local_att_counter != sdr_att_counter)
990       {
991       local_att_counter=sdr_att_counter;
992       set_bladerf_att();
993       }
994     if(local_nco_counter != sdr_nco_counter)
995       {
996       local_nco_counter=sdr_nco_counter;
997       set_bladerf_frequency();
998       }
999     }
1000   lir_await_event(EVENT_HWARE1_RXREADY);
1001   if(kill_all_flag)goto bladerf_error_exit1;
1002   while (!kill_all_flag && timf1p_sdr != timf1p_pa)
1003     {
1004 #include "input_speed.c"
1005     finish_rx_read();
1006     workload_reset_flag++;
1007     }
1008   }
1009 bladerf_error_exit1:;
1010 shutdown_rx_bladerf=1;
1011 i=0;
1012 while(i<50 && shutdown_rx_bladerf != 2)
1013   {
1014   lir_sleep(20000);
1015   }
1016 lir_join(THREAD_BLADERF_STARTER);
1017 bladerf_close(dev_bladerf);
1018 bladerf_init_error_exit:;
1019 unload_bladerf_library();
1020 await_exit:;
1021 sdr=-1;
1022 thread_status_flag[THREAD_BLADERF_INPUT]=THRFLAG_RETURNED;
1023 while(thread_command_flag[THREAD_BLADERF_INPUT] != THRFLAG_NOT_ACTIVE)
1024   {
1025   lir_sleep(1000);
1026   }
1027 lir_close_event(EVENT_HWARE1_RXREADY);
1028 }
1029 
backend2str(bladerf_backend b)1030 static inline const char *backend2str(bladerf_backend b)
1031 {
1032 switch (b)
1033   {
1034   case BLADERF_BACKEND_LIBUSB:
1035   return "libusb";
1036 
1037   case BLADERF_BACKEND_LINUX:
1038   return "Linux kernel driver";
1039 
1040   default:
1041   return "Unknown";
1042   }
1043 }
1044 
fpga_size2str(bladerf_fpga_size b)1045 static inline const char *fpga_size2str(bladerf_fpga_size b)
1046 {
1047 switch (b)
1048   {
1049   case BLADERF_FPGA_40KLE:
1050   return "40k LE";
1051 
1052   case BLADERF_FPGA_115KLE:
1053   return "115 kLE";
1054 
1055   default:
1056   return "Unknown";
1057   }
1058 }
1059 
1060 
1061 
init_bladerf(void)1062 void init_bladerf(void)
1063 {
1064 FILE *bladerf_file;
1065 int i, err, n_devices, devno, line, line0;
1066 char s[120];
1067 int *ise, *sdr_pi;
1068 bladerf_fpga_size fpga_size;
1069 bladerf_sampling sampling;
1070 struct bladerf_version version, lib_version;
1071 struct bladerf_devinfo *devices;
1072 int j;
1073 if(load_bladerf_library() != 0)return;
1074 ise=(int*)(void*)s;
1075 devices=NULL;
1076 n_devices = bladerf_get_device_list(&devices);
1077 if (n_devices < 0)
1078   {
1079   if (n_devices == BLADERF_ERR_NODEV)
1080     {
1081     lir_text(5,5,"No bladeRF devices found.");
1082     }
1083   else
1084     {
1085     sprintf(s,"Failed to probe for devices: %s",bladerf_strerror(n_devices));
1086     lir_text(5,5,s);
1087     }
1088   lir_text(5,7,press_any_key);
1089   await_keyboard();
1090   goto unload_exit;
1091   }
1092 line=2;
1093 for(i = 0; i<n_devices; i++)
1094   {
1095   for(j=0; j<33; j++)
1096   sprintf(s,"%d BladeRF:%s Ser:%s Bus/Addr: %d/%d ",
1097      i, backend2str(devices[i].backend), devices[i].serial,
1098                                 devices[i].usb_bus,devices[i].usb_addr);
1099   lir_text(3,line,s);
1100   line++;
1101   }
1102 line++;
1103 if(n_devices == 1)
1104   {
1105   lir_text(3, line, "Device autoselected");
1106   devno=0;
1107   }
1108 else
1109   {
1110   lir_text(3, line, "Select device by line number:");
1111   devno=lir_get_integer(32,line,2,0,n_devices-1);
1112   }
1113 line++;
1114 if(kill_all_flag)goto unload_exit;;
1115 sprintf(s,"%s",devices[devno].serial);
1116 bladerf.sernum1=ise[0];
1117 bladerf.sernum2=ise[1];
1118 bladerf.sernum3=ise[2];
1119 bladerf.sernum4=ise[3];
1120 bladerf.sernum5=ise[4];
1121 bladerf.sernum6=ise[5];
1122 bladerf.sernum7=ise[6];
1123 bladerf.sernum8=ise[7];
1124 err=bladerf_open_with_devinfo(&dev_bladerf, &devices[devno]);
1125 bladerf_free_device_list(devices);
1126 if(err<0)
1127   {
1128 #if(OSNUM == OSNUM_WINDOWS)
1129   lirerr(1370);
1130 #else
1131   lirerr(1369);
1132 #endif
1133   goto unload_exit;;
1134   }
1135 i=bladerf_is_fpga_configured(dev_bladerf);
1136 err=bladerf_get_fpga_size(dev_bladerf, &fpga_size);
1137 if(err<0)
1138   {
1139   lirerr(1371);
1140   goto errexit;
1141   }
1142 if(i < 0)
1143   {
1144   lirerr(1373);
1145   goto errexit;
1146   }
1147 if(i == 0)
1148   {
1149   if(fpga_size == BLADERF_FPGA_40KLE)
1150     {
1151     lirerr(1374);
1152     goto errexit;
1153     }
1154   if(fpga_size == BLADERF_FPGA_115KLE)
1155     {
1156     lirerr(1387);
1157     goto errexit;
1158   }
1159   lirerr(1388);
1160   goto errexit;
1161   }
1162 err=bladerf_fpga_version(dev_bladerf, &version);
1163 if(err < 0)
1164   {
1165   lirerr(1375);
1166   goto errexit;
1167   }
1168 sprintf(s,"FPGA size: %s   FPGA version %d.%d.%d (%s),",
1169                       fpga_size2str(fpga_size), version.major,
1170                          version.minor, version.patch, version.describe);
1171 lir_text(3,line,s);
1172 line++;
1173 err=bladerf_fw_version(dev_bladerf, &version);
1174 if(err<0)
1175   {
1176   lirerr(1372);
1177   goto errexit;
1178   }
1179 sprintf(s,"FX3 firmware version %d.%d.%d (%s),", version.major,
1180                          version.minor, version.patch, version.describe);
1181 lir_text(3,line,s);
1182 line++;
1183 bladerf_version (&lib_version);
1184 sprintf(s,"libbladerf version %d.%d.%d (%s)",lib_version.major, lib_version.minor,
1185                                lib_version.patch,lib_version.describe);
1186 lir_text(3,line,s);
1187 line+=2;
1188 sprintf(s,"Input via J61 (Y/N)");
1189 lir_text(3,line,s);
1190 line+=2;
1191 getsamp:;
1192 await_processed_keyboard();
1193 if(kill_all_flag)goto errexit;
1194 if(lir_inkey == 'Y')
1195   {
1196   sampling=BLADERF_SAMPLING_EXTERNAL;
1197   }
1198 else
1199   {
1200   if(lir_inkey != 'N')goto getsamp;
1201   sampling=BLADERF_SAMPLING_INTERNAL;
1202   }
1203 bladerf.sampling=(int)sampling;
1204 err=bladerf_set_sampling(dev_bladerf, sampling);
1205 if(err<0)
1206   {
1207   lirerr(1382);
1208   goto errexit;
1209   }
1210 line0=line;
1211 enter_speed:;
1212 sprintf(s,"Set RX sampling speed in Hz %d to %d =>",
1213                                     MIN_BLADERF_SAMP_RATE,MAX_BLADERF_SAMP_RATE);
1214 lir_text(3,line,s);
1215 bladerf.rx_sampling_speed=lir_get_integer(4+strlen(s),line,8,
1216                                 MIN_BLADERF_SAMP_RATE, MAX_BLADERF_SAMP_RATE);
1217 line++;
1218 if(kill_all_flag)goto errexit;
1219 err=bladerf_set_sample_rate(dev_bladerf, BLADERF_MODULE_RX,
1220              (unsigned int)bladerf.rx_sampling_speed,
1221                                   (unsigned int*)&bladerf.rx_sampling_speed);
1222 if(err<0)
1223   {
1224   lirerr(1384);
1225   goto errexit;
1226   }
1227 sprintf(s,"Actual RX sampling rate=%d",bladerf.rx_sampling_speed);
1228 lir_text(3,line,s);
1229 line+=2;
1230 lir_text(3,line,"Enter resampling factor in powers of two (0-2) =>");
1231 bladerf.rx_resampling_factor=lir_get_integer(53,line,1,0,4);
1232 line+=2;
1233 sprintf(s,"FFT bandwidth in Linrad %d",
1234           bladerf.rx_sampling_speed/(1<<bladerf.rx_resampling_factor));
1235 lir_text(3,line,s);
1236 line+=2;
1237 if(sampling == BLADERF_SAMPLING_INTERNAL)
1238   {
1239 ask_filt:;
1240   lir_text(3,line,"Enable filter ? (Y/N) =>");
1241   await_processed_keyboard();
1242   line+=2;
1243   if(kill_all_flag)goto errexit;
1244   if(lir_inkey == 'N')
1245     {
1246     bladerf.bandwidth=0;
1247     }
1248   else
1249     {
1250     if(lir_inkey != 'Y')
1251       {
1252       goto ask_filt;
1253       }
1254     sprintf(s,"Set filter bandwidth in kHz (750 to 14000) =>");
1255     lir_text(3,line,s);
1256     bladerf.bandwidth=1000*lir_get_integer(4+strlen(s),line,6,750,14000);
1257     if(kill_all_flag)goto errexit;
1258     line++;
1259     bladerf_set_bandwidth(dev_bladerf, BLADERF_MODULE_RX, (unsigned int)bladerf.bandwidth,
1260                                             (unsigned int*)&bladerf.bandwidth);
1261     sprintf(s,"Actual bandwidth=%d",bladerf.bandwidth/1000);
1262     lir_text(3,line,s);
1263     line+=2;
1264 speed_ok:;
1265     lir_text(3,line,"Is this combination of rate and bandwidth OK? (Y/N) =>");
1266     await_processed_keyboard();
1267     line+=2;
1268     if(kill_all_flag)goto errexit;
1269     if(lir_inkey == 'N')
1270       {
1271       clear_lines(line0,line);
1272       line=line0;
1273       goto enter_speed;
1274       }
1275     else
1276       {
1277       if(lir_inkey != 'Y')
1278         {
1279         goto speed_ok;
1280         }
1281       }
1282     }
1283   lir_text(3,line,"Select gain mode.");
1284   line++;
1285   lir_text(3,line,"0=Linearity.");
1286   line++;
1287   lir_text(3,line,"1=Sensitivity.");
1288   line+=2;
1289   lir_text(3,line,"=>");
1290   bladerf.gain_mode=lir_get_integer(6,line,1,0,1);
1291   line+=2;
1292   }
1293 else
1294   {
1295   bladerf.bandwidth=0;
1296   bladerf.gain_mode=0;
1297   }
1298 lir_text(3,line,"Enter xtal error in ppb =>");
1299 bladerf.freq_adjust=0.1*lir_get_float(32,line,9,-300000.,300000.);
1300 bladerf_file=fopen(bladerf_parfil_name,"w");
1301 if(bladerf_file == NULL)
1302   {
1303   lirerr(381268);
1304   goto errexit;
1305   }
1306 bladerf.check=BLADERFPAR_VERNR;
1307 sdr_pi=(int*)(&bladerf);
1308 for(i=0; i<MAX_BLADERF_PARM; i++)
1309   {
1310   fprintf(bladerf_file,"%s [%d]\n",bladerf_parm_text[i],sdr_pi[i]);
1311   }
1312 parfile_end(bladerf_file);
1313 ui.rx_addev_no=BLADERF_DEVICE_CODE;
1314 ui.rx_ad_speed=(int)((rint)((bladerf.rx_sampling_speed*
1315                      (100000000L+(double)bladerf.freq_adjust))/100000000L));
1316 ui.rx_ad_speed>>=bladerf.rx_resampling_factor;
1317 if(sampling == BLADERF_SAMPLING_INTERNAL)
1318   {
1319   ui.rx_input_mode=IQ_DATA;
1320   ui.rx_rf_channels=1;
1321   }
1322 else
1323   {
1324   ui.rx_input_mode=0;
1325   ui.rx_rf_channels=2;
1326   }
1327 ui.rx_ad_channels=2;
1328 ui.rx_admode=0;
1329 errexit:;
1330 bladerf_close(dev_bladerf);
1331 unload_exit:;
1332 unload_bladerf_library();
1333 }
1334 
display_bladerf_parm_info(int * line)1335 int display_bladerf_parm_info(int *line)
1336 {
1337 char s[80], ss[80];
1338 char *conns[]={"Unknown","SMA and tuner","J61"};
1339 char *sp;
1340 int errcod;
1341 errcod=read_sdrpar(bladerf_parfil_name, MAX_BLADERF_PARM,
1342                             bladerf_parm_text, (int*)((void*)&bladerf));
1343 if(errcod == 0)
1344   {
1345   settextcolor(7);
1346   sprintf(s,"Sampling rate=%i Hz, Resampling=%d, FFT bandwidth=%.3f kHz  ",
1347             bladerf.rx_sampling_speed, bladerf.rx_resampling_factor,
1348         0.001*(bladerf.rx_sampling_speed/(1<<bladerf.rx_resampling_factor)));
1349   lir_text(24,line[0],s);
1350   line[0]++;
1351   SNDLOG"\n%s",s);
1352   sprintf(s,"Xtal adjust = %.0f ppb", 10.*bladerf.freq_adjust);
1353   lir_text(24,line[0],s);
1354   line[0]++;
1355   SNDLOG"\n%s",s);
1356   sprintf(s,"Connection via %s", conns[bladerf.sampling]);
1357   if(bladerf.sampling == BLADERF_SAMPLING_INTERNAL)
1358     {
1359     if(bladerf.bandwidth == 0)
1360       {
1361       sprintf(ss,"%s, Low pass filter bypaqssed.",s);
1362       }
1363     else
1364       {
1365       sprintf(ss,"%s, Low pass filter bandwidth %d kHz.",s,
1366                                                      bladerf.bandwidth/1000);
1367       }
1368     lir_text(24,line[0],ss);
1369     SNDLOG"\n%s",ss);
1370     line[0]++;
1371     if(bladerf.gain_mode == 0)
1372       {
1373       sp="linearity";
1374       }
1375     else
1376       {
1377       sp="sensitivity";
1378       }
1379     sprintf(s,"Gain mode = %s",sp);
1380     lir_text(24,line[0],s);
1381     SNDLOG"\n%s",s);
1382     line[0]++;
1383     }
1384   }
1385 return (errcod);
1386 }
1387 
1388