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