new ms

Change-Id: I7c5abe57182e7ef508cac4068c0b41f905d39fd6

.clang-format

@@ -0,0 +1,521 @@
+# SPDX-License-Identifier: GPL-2.0
+#
+# clang-format configuration file. Intended for clang-format >= 4.
+#
+# For more information, see:
+#
+#   Documentation/process/clang-format.rst
+#   https://clang.llvm.org/docs/ClangFormat.html
+#   https://clang.llvm.org/docs/ClangFormatStyleOptions.html
+#
+---
+AccessModifierOffset: -4
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+#AlignEscapedNewlines: Left # Unknown to clang-format-4.0
+AlignOperands: true
+AlignTrailingComments: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: false
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterClass: false
+  AfterControlStatement: false
+  AfterEnum: false
+  AfterFunction: true
+  AfterNamespace: true
+  AfterObjCDeclaration: false
+  AfterStruct: false
+  AfterUnion: false
+  #AfterExternBlock: false # Unknown to clang-format-5.0
+  BeforeCatch: false
+  BeforeElse: false
+  IndentBraces: false
+  #SplitEmptyFunction: true # Unknown to clang-format-4.0
+  #SplitEmptyRecord: true # Unknown to clang-format-4.0
+  #SplitEmptyNamespace: true # Unknown to clang-format-4.0
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Custom
+#BreakBeforeInheritanceComma: false # Unknown to clang-format-4.0
+BreakBeforeTernaryOperators: false
+BreakConstructorInitializersBeforeComma: false
+#BreakConstructorInitializers: BeforeComma # Unknown to clang-format-4.0
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: false
+ColumnLimit: 120
+CommentPragmas: '^ IWYU pragma:'
+#CompactNamespaces: false # Unknown to clang-format-4.0
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 8
+ContinuationIndentWidth: 8
+Cpp11BracedListStyle: false
+DerivePointerAlignment: false
+DisableFormat: false
+ExperimentalAutoDetectBinPacking: false
+#FixNamespaceComments: false # Unknown to clang-format-4.0
+
+# Taken from:
+#   git grep -h '^#define [^[:space:]]*for_each[^[:space:]]*(' include/ \
+#   | sed "s,^#define \([^[:space:]]*for_each[^[:space:]]*\)(.*$,  - '\1'," \
+#   | sort | uniq
+ForEachMacros:
+  - 'apei_estatus_for_each_section'
+  - 'ata_for_each_dev'
+  - 'ata_for_each_link'
+  - '__ata_qc_for_each'
+  - 'ata_qc_for_each'
+  - 'ata_qc_for_each_raw'
+  - 'ata_qc_for_each_with_internal'
+  - 'ax25_for_each'
+  - 'ax25_uid_for_each'
+  - '__bio_for_each_bvec'
+  - 'bio_for_each_bvec'
+  - 'bio_for_each_integrity_vec'
+  - '__bio_for_each_segment'
+  - 'bio_for_each_segment'
+  - 'bio_for_each_segment_all'
+  - 'bio_list_for_each'
+  - 'bip_for_each_vec'
+  - 'bitmap_for_each_clear_region'
+  - 'bitmap_for_each_set_region'
+  - 'blkg_for_each_descendant_post'
+  - 'blkg_for_each_descendant_pre'
+  - 'blk_queue_for_each_rl'
+  - 'bond_for_each_slave'
+  - 'bond_for_each_slave_rcu'
+  - 'bpf_for_each_spilled_reg'
+  - 'btree_for_each_safe128'
+  - 'btree_for_each_safe32'
+  - 'btree_for_each_safe64'
+  - 'btree_for_each_safel'
+  - 'card_for_each_dev'
+  - 'cgroup_taskset_for_each'
+  - 'cgroup_taskset_for_each_leader'
+  - 'cpufreq_for_each_entry'
+  - 'cpufreq_for_each_entry_idx'
+  - 'cpufreq_for_each_valid_entry'
+  - 'cpufreq_for_each_valid_entry_idx'
+  - 'css_for_each_child'
+  - 'css_for_each_descendant_post'
+  - 'css_for_each_descendant_pre'
+  - 'device_for_each_child_node'
+  - 'dma_fence_chain_for_each'
+  - 'drm_atomic_crtc_for_each_plane'
+  - 'drm_atomic_crtc_state_for_each_plane'
+  - 'drm_atomic_crtc_state_for_each_plane_state'
+  - 'drm_atomic_for_each_plane_damage'
+  - 'drm_client_for_each_connector_iter'
+  - 'drm_client_for_each_modeset'
+  - 'drm_connector_for_each_possible_encoder'
+  - 'drm_for_each_bridge_in_chain'
+  - 'drm_for_each_connector_iter'
+  - 'drm_for_each_crtc'
+  - 'drm_for_each_encoder'
+  - 'drm_for_each_encoder_mask'
+  - 'drm_for_each_fb'
+  - 'drm_for_each_legacy_plane'
+  - 'drm_for_each_plane'
+  - 'drm_for_each_plane_mask'
+  - 'drm_for_each_privobj'
+  - 'drm_mm_for_each_hole'
+  - 'drm_mm_for_each_node'
+  - 'drm_mm_for_each_node_in_range'
+  - 'drm_mm_for_each_node_safe'
+  - 'flow_action_for_each'
+  - 'for_each_active_dev_scope'
+  - 'for_each_active_drhd_unit'
+  - 'for_each_active_iommu'
+  - 'for_each_available_child_of_node'
+  - 'for_each_bio'
+  - 'for_each_board_func_rsrc'
+  - 'for_each_bvec'
+  - 'for_each_card_auxs'
+  - 'for_each_card_auxs_safe'
+  - 'for_each_card_components'
+  - 'for_each_card_pre_auxs'
+  - 'for_each_card_prelinks'
+  - 'for_each_card_rtds'
+  - 'for_each_card_rtds_safe'
+  - 'for_each_cgroup_storage_type'
+  - 'for_each_child_of_node'
+  - 'for_each_clear_bit'
+  - 'for_each_clear_bit_from'
+  - 'for_each_cmsghdr'
+  - 'for_each_compatible_node'
+  - 'for_each_component_dais'
+  - 'for_each_component_dais_safe'
+  - 'for_each_comp_order'
+  - 'for_each_console'
+  - 'for_each_cpu'
+  - 'for_each_cpu_and'
+  - 'for_each_cpu_not'
+  - 'for_each_cpu_wrap'
+  - 'for_each_dev_addr'
+  - 'for_each_dev_scope'
+  - 'for_each_displayid_db'
+  - 'for_each_dma_cap_mask'
+  - 'for_each_dpcm_be'
+  - 'for_each_dpcm_be_rollback'
+  - 'for_each_dpcm_be_safe'
+  - 'for_each_dpcm_fe'
+  - 'for_each_drhd_unit'
+  - 'for_each_dss_dev'
+  - 'for_each_efi_handle'
+  - 'for_each_efi_memory_desc'
+  - 'for_each_efi_memory_desc_in_map'
+  - 'for_each_element'
+  - 'for_each_element_extid'
+  - 'for_each_element_id'
+  - 'for_each_endpoint_of_node'
+  - 'for_each_evictable_lru'
+  - 'for_each_fib6_node_rt_rcu'
+  - 'for_each_fib6_walker_rt'
+  - 'for_each_free_mem_pfn_range_in_zone'
+  - 'for_each_free_mem_pfn_range_in_zone_from'
+  - 'for_each_free_mem_range'
+  - 'for_each_free_mem_range_reverse'
+  - 'for_each_func_rsrc'
+  - 'for_each_hstate'
+  - 'for_each_if'
+  - 'for_each_iommu'
+  - 'for_each_ip_tunnel_rcu'
+  - 'for_each_irq_nr'
+  - 'for_each_link_codecs'
+  - 'for_each_link_platforms'
+  - 'for_each_lru'
+  - 'for_each_matching_node'
+  - 'for_each_matching_node_and_match'
+  - 'for_each_member'
+  - 'for_each_memblock'
+  - 'for_each_memblock_type'
+  - 'for_each_memcg_cache_index'
+  - 'for_each_mem_pfn_range'
+  - 'for_each_mem_range'
+  - 'for_each_mem_range_rev'
+  - 'for_each_migratetype_order'
+  - 'for_each_msi_entry'
+  - 'for_each_msi_entry_safe'
+  - 'for_each_net'
+  - 'for_each_net_continue_reverse'
+  - 'for_each_netdev'
+  - 'for_each_netdev_continue'
+  - 'for_each_netdev_continue_rcu'
+  - 'for_each_netdev_continue_reverse'
+  - 'for_each_netdev_feature'
+  - 'for_each_netdev_in_bond_rcu'
+  - 'for_each_netdev_rcu'
+  - 'for_each_netdev_reverse'
+  - 'for_each_netdev_safe'
+  - 'for_each_net_rcu'
+  - 'for_each_new_connector_in_state'
+  - 'for_each_new_crtc_in_state'
+  - 'for_each_new_mst_mgr_in_state'
+  - 'for_each_new_plane_in_state'
+  - 'for_each_new_private_obj_in_state'
+  - 'for_each_node'
+  - 'for_each_node_by_name'
+  - 'for_each_node_by_type'
+  - 'for_each_node_mask'
+  - 'for_each_node_state'
+  - 'for_each_node_with_cpus'
+  - 'for_each_node_with_property'
+  - 'for_each_of_allnodes'
+  - 'for_each_of_allnodes_from'
+  - 'for_each_of_cpu_node'
+  - 'for_each_of_pci_range'
+  - 'for_each_old_connector_in_state'
+  - 'for_each_old_crtc_in_state'
+  - 'for_each_old_mst_mgr_in_state'
+  - 'for_each_oldnew_connector_in_state'
+  - 'for_each_oldnew_crtc_in_state'
+  - 'for_each_oldnew_mst_mgr_in_state'
+  - 'for_each_oldnew_plane_in_state'
+  - 'for_each_oldnew_plane_in_state_reverse'
+  - 'for_each_oldnew_private_obj_in_state'
+  - 'for_each_old_plane_in_state'
+  - 'for_each_old_private_obj_in_state'
+  - 'for_each_online_cpu'
+  - 'for_each_online_node'
+  - 'for_each_online_pgdat'
+  - 'for_each_pci_bridge'
+  - 'for_each_pci_dev'
+  - 'for_each_pci_msi_entry'
+  - 'for_each_populated_zone'
+  - 'for_each_possible_cpu'
+  - 'for_each_present_cpu'
+  - 'for_each_prime_number'
+  - 'for_each_prime_number_from'
+  - 'for_each_process'
+  - 'for_each_process_thread'
+  - 'for_each_property_of_node'
+  - 'for_each_registered_fb'
+  - 'for_each_reserved_mem_region'
+  - 'for_each_rtd_codec_dai'
+  - 'for_each_rtd_codec_dai_rollback'
+  - 'for_each_rtd_components'
+  - 'for_each_set_bit'
+  - 'for_each_set_bit_from'
+  - 'for_each_set_clump8'
+  - 'for_each_sg'
+  - 'for_each_sg_dma_page'
+  - 'for_each_sg_page'
+  - 'for_each_sibling_event'
+  - 'for_each_subelement'
+  - 'for_each_subelement_extid'
+  - 'for_each_subelement_id'
+  - '__for_each_thread'
+  - 'for_each_thread'
+  - 'for_each_wakeup_source'
+  - 'for_each_zone'
+  - 'for_each_zone_zonelist'
+  - 'for_each_zone_zonelist_nodemask'
+  - 'fwnode_for_each_available_child_node'
+  - 'fwnode_for_each_child_node'
+  - 'fwnode_graph_for_each_endpoint'
+  - 'gadget_for_each_ep'
+  - 'genradix_for_each'
+  - 'genradix_for_each_from'
+  - 'hash_for_each'
+  - 'hash_for_each_possible'
+  - 'hash_for_each_possible_rcu'
+  - 'hash_for_each_possible_rcu_notrace'
+  - 'hash_for_each_possible_safe'
+  - 'hash_for_each_rcu'
+  - 'hash_for_each_safe'
+  - 'hctx_for_each_ctx'
+  - 'hlist_bl_for_each_entry'
+  - 'hlist_bl_for_each_entry_rcu'
+  - 'hlist_bl_for_each_entry_safe'
+  - 'hlist_for_each'
+  - 'hlist_for_each_entry'
+  - 'hlist_for_each_entry_continue'
+  - 'hlist_for_each_entry_continue_rcu'
+  - 'hlist_for_each_entry_continue_rcu_bh'
+  - 'hlist_for_each_entry_from'
+  - 'hlist_for_each_entry_from_rcu'
+  - 'hlist_for_each_entry_rcu'
+  - 'hlist_for_each_entry_rcu_bh'
+  - 'hlist_for_each_entry_rcu_notrace'
+  - 'hlist_for_each_entry_safe'
+  - '__hlist_for_each_rcu'
+  - 'hlist_for_each_safe'
+  - 'hlist_nulls_for_each_entry'
+  - 'hlist_nulls_for_each_entry_from'
+  - 'hlist_nulls_for_each_entry_rcu'
+  - 'hlist_nulls_for_each_entry_safe'
+  - 'i3c_bus_for_each_i2cdev'
+  - 'i3c_bus_for_each_i3cdev'
+  - 'ide_host_for_each_port'
+  - 'ide_port_for_each_dev'
+  - 'ide_port_for_each_present_dev'
+  - 'idr_for_each_entry'
+  - 'idr_for_each_entry_continue'
+  - 'idr_for_each_entry_continue_ul'
+  - 'idr_for_each_entry_ul'
+  - 'in_dev_for_each_ifa_rcu'
+  - 'in_dev_for_each_ifa_rtnl'
+  - 'inet_bind_bucket_for_each'
+  - 'inet_lhash2_for_each_icsk_rcu'
+  - 'key_for_each'
+  - 'key_for_each_safe'
+  - 'klp_for_each_func'
+  - 'klp_for_each_func_safe'
+  - 'klp_for_each_func_static'
+  - 'klp_for_each_object'
+  - 'klp_for_each_object_safe'
+  - 'klp_for_each_object_static'
+  - 'kvm_for_each_memslot'
+  - 'kvm_for_each_vcpu'
+  - 'list_for_each'
+  - 'list_for_each_codec'
+  - 'list_for_each_codec_safe'
+  - 'list_for_each_continue'
+  - 'list_for_each_entry'
+  - 'list_for_each_entry_continue'
+  - 'list_for_each_entry_continue_rcu'
+  - 'list_for_each_entry_continue_reverse'
+  - 'list_for_each_entry_from'
+  - 'list_for_each_entry_from_rcu'
+  - 'list_for_each_entry_from_reverse'
+  - 'list_for_each_entry_lockless'
+  - 'list_for_each_entry_rcu'
+  - 'list_for_each_entry_reverse'
+  - 'list_for_each_entry_safe'
+  - 'list_for_each_entry_safe_continue'
+  - 'list_for_each_entry_safe_from'
+  - 'list_for_each_entry_safe_reverse'
+  - 'list_for_each_prev'
+  - 'list_for_each_prev_safe'
+  - 'list_for_each_safe'
+  - 'llist_for_each'
+  - 'llist_for_each_entry'
+  - 'llist_for_each_entry_safe'
+  - 'llist_for_each_safe'
+  - 'mci_for_each_dimm'
+  - 'media_device_for_each_entity'
+  - 'media_device_for_each_intf'
+  - 'media_device_for_each_link'
+  - 'media_device_for_each_pad'
+  - 'nanddev_io_for_each_page'
+  - 'netdev_for_each_lower_dev'
+  - 'netdev_for_each_lower_private'
+  - 'netdev_for_each_lower_private_rcu'
+  - 'netdev_for_each_mc_addr'
+  - 'netdev_for_each_uc_addr'
+  - 'netdev_for_each_upper_dev_rcu'
+  - 'netdev_hw_addr_list_for_each'
+  - 'nft_rule_for_each_expr'
+  - 'nla_for_each_attr'
+  - 'nla_for_each_nested'
+  - 'nlmsg_for_each_attr'
+  - 'nlmsg_for_each_msg'
+  - 'nr_neigh_for_each'
+  - 'nr_neigh_for_each_safe'
+  - 'nr_node_for_each'
+  - 'nr_node_for_each_safe'
+  - 'of_for_each_phandle'
+  - 'of_property_for_each_string'
+  - 'of_property_for_each_u32'
+  - 'pci_bus_for_each_resource'
+  - 'ping_portaddr_for_each_entry'
+  - 'plist_for_each'
+  - 'plist_for_each_continue'
+  - 'plist_for_each_entry'
+  - 'plist_for_each_entry_continue'
+  - 'plist_for_each_entry_safe'
+  - 'plist_for_each_safe'
+  - 'pnp_for_each_card'
+  - 'pnp_for_each_dev'
+  - 'protocol_for_each_card'
+  - 'protocol_for_each_dev'
+  - 'queue_for_each_hw_ctx'
+  - 'radix_tree_for_each_slot'
+  - 'radix_tree_for_each_tagged'
+  - 'rbtree_postorder_for_each_entry_safe'
+  - 'rdma_for_each_block'
+  - 'rdma_for_each_port'
+  - 'resource_list_for_each_entry'
+  - 'resource_list_for_each_entry_safe'
+  - 'rhl_for_each_entry_rcu'
+  - 'rhl_for_each_rcu'
+  - 'rht_for_each'
+  - 'rht_for_each_entry'
+  - 'rht_for_each_entry_from'
+  - 'rht_for_each_entry_rcu'
+  - 'rht_for_each_entry_rcu_from'
+  - 'rht_for_each_entry_safe'
+  - 'rht_for_each_from'
+  - 'rht_for_each_rcu'
+  - 'rht_for_each_rcu_from'
+  - '__rq_for_each_bio'
+  - 'rq_for_each_bvec'
+  - 'rq_for_each_segment'
+  - 'scsi_for_each_prot_sg'
+  - 'scsi_for_each_sg'
+  - 'sctp_for_each_hentry'
+  - 'sctp_skb_for_each'
+  - 'shdma_for_each_chan'
+  - '__shost_for_each_device'
+  - 'shost_for_each_device'
+  - 'sk_for_each'
+  - 'sk_for_each_bound'
+  - 'sk_for_each_entry_offset_rcu'
+  - 'sk_for_each_from'
+  - 'sk_for_each_rcu'
+  - 'sk_for_each_safe'
+  - 'sk_nulls_for_each'
+  - 'sk_nulls_for_each_from'
+  - 'sk_nulls_for_each_rcu'
+  - 'snd_array_for_each'
+  - 'snd_pcm_group_for_each_entry'
+  - 'snd_soc_dapm_widget_for_each_path'
+  - 'snd_soc_dapm_widget_for_each_path_safe'
+  - 'snd_soc_dapm_widget_for_each_sink_path'
+  - 'snd_soc_dapm_widget_for_each_source_path'
+  - 'tb_property_for_each'
+  - 'tcf_exts_for_each_action'
+  - 'udp_portaddr_for_each_entry'
+  - 'udp_portaddr_for_each_entry_rcu'
+  - 'usb_hub_for_each_child'
+  - 'v4l2_device_for_each_subdev'
+  - 'v4l2_m2m_for_each_dst_buf'
+  - 'v4l2_m2m_for_each_dst_buf_safe'
+  - 'v4l2_m2m_for_each_src_buf'
+  - 'v4l2_m2m_for_each_src_buf_safe'
+  - 'virtio_device_for_each_vq'
+  - 'xa_for_each'
+  - 'xa_for_each_marked'
+  - 'xa_for_each_range'
+  - 'xa_for_each_start'
+  - 'xas_for_each'
+  - 'xas_for_each_conflict'
+  - 'xas_for_each_marked'
+  - 'xbc_array_for_each_value'
+  - 'xbc_for_each_key_value'
+  - 'xbc_node_for_each_array_value'
+  - 'xbc_node_for_each_child'
+  - 'xbc_node_for_each_key_value'
+  - 'zorro_for_each_dev'
+
+#IncludeBlocks: Preserve # Unknown to clang-format-5.0
+IncludeCategories:
+  - Regex: '.*'
+    Priority: 1
+IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: false
+#IndentPPDirectives: None # Unknown to clang-format-5.0
+IndentWidth: 8
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: Inner
+#ObjCBinPackProtocolList: Auto # Unknown to clang-format-5.0
+ObjCBlockIndentWidth: 8
+ObjCSpaceAfterProperty: true
+ObjCSpaceBeforeProtocolList: true
+
+# Taken from git's rules
+#PenaltyBreakAssignment: 10 # Unknown to clang-format-4.0
+PenaltyBreakBeforeFirstCallParameter: 30
+PenaltyBreakComment: 10
+PenaltyBreakFirstLessLess: 0
+PenaltyBreakString: 10
+PenaltyExcessCharacter: 100
+PenaltyReturnTypeOnItsOwnLine: 60
+
+PointerAlignment: Right
+ReflowComments: false
+SortIncludes: false
+#SortUsingDeclarations: false # Unknown to clang-format-4.0
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+#SpaceBeforeCtorInitializerColon: true # Unknown to clang-format-5.0
+#SpaceBeforeInheritanceColon: true # Unknown to clang-format-5.0
+SpaceBeforeParens: ControlStatements
+#SpaceBeforeRangeBasedForLoopColon: true # Unknown to clang-format-5.0
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles: false
+SpacesInContainerLiterals: false
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: Cpp03
+TabWidth: 8
+UseTab: Always
+...

.gitignore

@@ -5,6 +5,15 @@
 Transceiver52M/osmo-trx-uhd
 Transceiver52M/osmo-trx-usrp1
 Transceiver52M/osmo-trx-lms
+Transceiver52M/osmo-trx-ipc
+Transceiver52M/osmo-trx-blade
+Transceiver52M/osmo-trx-syncthing-blade
+Transceiver52M/osmo-trx-syncthing-uhd
+Transceiver52M/osmo-trx-ms-blade
+Transceiver52M/osmo-trx-ms-uhd
+
+
+.clang-format
 
 # tests
 tests/CommonLibs/BitVectorTest
@@ -19,6 +28,7 @@ tests/CommonLibs/VectorTest
 tests/CommonLibs/PRBSTest
 tests/Transceiver52M/convolve_test
 tests/Transceiver52M/LMSDeviceTest
+Transceiver52M/device/ipc/ipc-driver-test
 
 # automake/autoconf
 *.in
@@ -60,6 +70,16 @@ doc/manuals/*.pdf
 doc/manuals/*__*.png
 doc/manuals/*.check
 doc/manuals/generated/
-doc/manuals/osmomsc-usermanual.xml
+doc/manuals/vty/osmotrx-*-vty-reference.xml
+doc/manuals/vty/osmotrx-*-vty-reference.xml.inc.gen
+doc/manuals/vty/osmotrx-*-vty-reference.xml.inc.merged
 doc/manuals/common
 doc/manuals/build
+
+contrib/osmo-trx.spec
+!contrib/osmo-trx.spec.in
+
+utils/osmo-prbs-tool
+/.qtc_clangd/*
+/.cache/*
+/.vscode/*

CommonLibs/Interthread.h

@@ -517,7 +517,7 @@ public:
 		@param timeout The blocking timeout in ms.
 		@return Pointer at key or NULL on timeout.
 	*/
-	D* read(const K &key, unsigned timeout) const
+	D* read(const K &key, unsigned timeout)
 	{
 		if (timeout==0) return readNoBlock(key);
 		ScopedLock lock(mLock);
@@ -537,7 +537,7 @@ public:
 		@param key The key to read from.
 		@return Pointer at key.
 	*/
-	D* read(const K &key) const
+	D* read(const K &key)
 	{
 		ScopedLock lock(mLock);
 		typename Map::const_iterator iter = mMap.find(key);

CommonLibs/Logger.h

@@ -50,19 +50,19 @@ extern "C" {
 #endif
 
 #define LOG(level) \
-	Log(DMAIN, LOGL_##level, __BASE_FILE__, __LINE__).get() <<  "[tid=" << pthread_self() << "] "
+	Log(DMAIN, LOGL_##level, __BASE_FILE__, __LINE__).get()
 
 #define LOGC(category, level) \
-	Log(category, LOGL_##level, __BASE_FILE__, __LINE__).get() <<  "[tid=" << pthread_self() << "] "
+	Log(category, LOGL_##level, __BASE_FILE__, __LINE__).get()
 
 #define LOGLV(category, level) \
-	Log(category, level, __BASE_FILE__, __LINE__).get() <<  "[tid=" << pthread_self() << "] "
+	Log(category, level, __BASE_FILE__, __LINE__).get()
 
 #define LOGSRC(category, level, file, line) \
-	Log(category, level, file, line).get() <<  "[tid=" << pthread_self() << "] "
+	Log(category, level, file, line).get()
 
 #define LOGCHAN(chan, category, level) \
-	Log(category, LOGL_##level, __BASE_FILE__, __LINE__).get() <<  "[tid=" << pthread_self() << "][chan=" << chan << "] "
+	Log(category, LOGL_##level, __BASE_FILE__, __LINE__).get() <<  "[chan=" << chan << "] "
 
 /**
 	A C++ stream-based thread-safe logger.

CommonLibs/PRBS.h

@@ -12,10 +12,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #ifndef PRBS_H

CommonLibs/Threads.cpp

@@ -32,11 +32,9 @@
 #include "Timeval.h"
 #include "Logger.h"
 
-#ifndef gettid
-#include <sys/syscall.h>
-#define gettid() syscall(SYS_gettid)
-#endif
-
+extern "C" {
+#include <osmocom/core/thread.h>
+}
 
 using namespace std;
 
@@ -45,76 +43,11 @@ using namespace std;
 #endif
 
 
-Mutex gStreamLock;		///< Global lock to control access to cout and cerr.
-
-void lockCout()
-{
-	gStreamLock.lock();
-	Timeval entryTime;
-	cout << entryTime << " " << pthread_self() << ": ";
-}
-
-
-void unlockCout()
-{
-	cout << dec << endl << flush;
-	gStreamLock.unlock();
-}
-
-
-void lockCerr()
-{
-	gStreamLock.lock();
-	Timeval entryTime;
-	cerr << entryTime << " " << pthread_self() << ": ";
-}
-
-void unlockCerr()
-{
-	cerr << dec << endl << flush;
-	gStreamLock.unlock();
-}
-
-
-
-
-
-
-
-Mutex::Mutex()
-{
-	bool res;
-	res = pthread_mutexattr_init(&mAttribs);
-	assert(!res);
-	res = pthread_mutexattr_settype(&mAttribs,PTHREAD_MUTEX_RECURSIVE);
-	assert(!res);
-	res = pthread_mutex_init(&mMutex,&mAttribs);
-	assert(!res);
-}
-
-
-Mutex::~Mutex()
-{
-	pthread_mutex_destroy(&mMutex);
-	bool res = pthread_mutexattr_destroy(&mAttribs);
-	assert(!res);
-}
-
-
-
-
-/** Block for the signal up to the cancellation timeout. */
-void Signal::wait(Mutex& wMutex, unsigned timeout) const
-{
-	Timeval then(timeout);
-	struct timespec waitTime = then.timespec();
-	pthread_cond_timedwait(&mSignal,&wMutex.mMutex,&waitTime);
-}
 
 void set_selfthread_name(const char *name)
 {
 	pthread_t selfid = pthread_self();
-	pid_t tid = gettid();
+	pid_t tid = osmo_gettid();
 	if (pthread_setname_np(selfid, name) == 0) {
 		LOG(INFO) << "Thread "<< selfid << " (task " << tid << ") set name: " << name;
 	} else {

CommonLibs/Threads.h

@@ -28,143 +28,96 @@
 #ifndef THREADS_H
 #define THREADS_H
 
-#include "config.h"
-
+#include <chrono>
+#include <mutex>
+#include <condition_variable>
 #include <pthread.h>
 #include <iostream>
-#include <assert.h>
+#include <cassert>
 #include <unistd.h>
 
+#include "config.h"
+#include "Timeval.h"
+
 class Mutex;
 
-
-/**@name Multithreaded access for standard streams. */
-//@{
-
-/**@name Functions for gStreamLock. */
-//@{
-extern Mutex gStreamLock;	///< global lock for cout and cerr
-void lockCerr();		///< call prior to writing cerr
-void unlockCerr();		///< call after writing cerr
-void lockCout();		///< call prior to writing cout
-void unlockCout();		///< call after writing cout
-//@}
-
-/**@name Macros for standard messages. */
-//@{
-#define COUT(text) { lockCout(); std::cout << text; unlockCout(); }
-#define CERR(text) { lockCerr(); std::cerr << __FILE__ << ":" << __LINE__ << ": " << text; unlockCerr(); }
-#ifdef NDEBUG
-#define DCOUT(text) {}
-#define OBJDCOUT(text) {}
-#else
-#define DCOUT(text) { COUT(__FILE__ << ":" << __LINE__ << " " << text); }
-#define OBJDCOUT(text) { DCOUT(this << " " << text); }
-#endif
-//@}
-//@}
-
-
-
 /**@defgroup C++ wrappers for pthread mechanisms. */
 //@{
 
-/** A class for recursive mutexes based on pthread_mutex. */
+/** A class for recursive mutexes. */
 class Mutex {
+	std::recursive_mutex m;
 
-	private:
+    public:
 
-	pthread_mutex_t mMutex;
-	pthread_mutexattr_t mAttribs;
+	void lock() {
+		m.lock();
+	}
 
-	public:
+	bool trylock() {
+		return m.try_lock();
+	}
 
-	Mutex();
-
-	~Mutex();
-
-	void lock() { pthread_mutex_lock(&mMutex); }
-
-	bool trylock() { return pthread_mutex_trylock(&mMutex)==0; }
-
-	void unlock() { pthread_mutex_unlock(&mMutex); }
+	void unlock() {
+		m.unlock();
+	}
 
 	friend class Signal;
-
 };
 
-
 class ScopedLock {
+	Mutex &mMutex;
 
-	private:
-	Mutex& mMutex;
-
-	public:
-	ScopedLock(Mutex& wMutex) :mMutex(wMutex) { mMutex.lock(); }
-	~ScopedLock() { mMutex.unlock(); }
-
+    public:
+	ScopedLock(Mutex &wMutex) : mMutex(wMutex) {
+		mMutex.lock();
+	}
+	~ScopedLock() {
+		mMutex.unlock();
+	}
 };
 
-
-
-
-/** A C++ interthread signal based on pthread condition variables. */
+/** A C++ interthread signal. */
 class Signal {
+	/* any, because for some reason our mutex is recursive... */
+	std::condition_variable_any mSignal;
 
-	private:
+    public:
 
-	mutable pthread_cond_t mSignal;
+	void wait(Mutex &wMutex, unsigned timeout) {
+		mSignal.wait_for(wMutex.m, std::chrono::milliseconds(timeout));
+	}
 
-	public:
+	void wait(Mutex &wMutex) {
+		mSignal.wait(wMutex.m);
+	}
 
-	Signal() { int s = pthread_cond_init(&mSignal,NULL); assert(!s); }
-
-	~Signal() { pthread_cond_destroy(&mSignal); }
-
-	/**
-		Block for the signal up to the cancellation timeout.
-		Under Linux, spurious returns are possible.
-	*/
-	void wait(Mutex& wMutex, unsigned timeout) const;
-
-	/**
-		Block for the signal.
-		Under Linux, spurious returns are possible.
-	*/
-	void wait(Mutex& wMutex) const
-		{ pthread_cond_wait(&mSignal,&wMutex.mMutex); }
-
-	void signal() { pthread_cond_signal(&mSignal); }
-
-	void broadcast() { pthread_cond_broadcast(&mSignal); }
+	void signal() {
+		mSignal.notify_one();
+	}
 
+	void broadcast() {
+		mSignal.notify_all();
+	}
 };
 
-
-
-#define START_THREAD(thread,function,argument) \
-	thread.start((void *(*)(void*))function, (void*)argument);
-
 void set_selfthread_name(const char *name);
 void thread_enable_cancel(bool cancel);
 
 /** A C++ wrapper for pthread threads.  */
 class Thread {
-
-	private:
-
+    private:
 	pthread_t mThread;
 	pthread_attr_t mAttrib;
 	// FIXME -- Can this be reduced now?
 	size_t mStackSize;
 
-
-	public:
-
+    public:
 	/** Create a thread in a non-running state. */
-	Thread(size_t wStackSize = 0):mThread((pthread_t)0) {
-		pthread_attr_init(&mAttrib);	// (pat) moved this here.
-		mStackSize=wStackSize;
+	Thread(size_t wStackSize = 0) : mThread((pthread_t)0)
+	{
+		pthread_attr_init(&mAttrib); // (pat) moved this here.
+		mStackSize = wStackSize;
 	}
 
 	/**
@@ -172,14 +125,17 @@ class Thread {
 		It should be stopped and joined.
 	*/
 	// (pat) If the Thread is destroyed without being started, then mAttrib is undefined.  Oops.
-	~Thread() { pthread_attr_destroy(&mAttrib); }
-
+	~Thread()
+	{
+		pthread_attr_destroy(&mAttrib);
+	}
 
 	/** Start the thread on a task. */
-	void start(void *(*task)(void*), void *arg);
+	void start(void *(*task)(void *), void *arg);
 
 	/** Join a thread that will stop on its own. */
-	void join() {
+	void join()
+	{
 		if (mThread) {
 			int s = pthread_join(mThread, NULL);
 			assert(!s);
@@ -187,7 +143,10 @@ class Thread {
 	}
 
 	/** Send cancellation to thread */
-	void cancel() { pthread_cancel(mThread); }
+	void cancel()
+	{
+		pthread_cancel(mThread);
+	}
 };
 
 #ifdef HAVE_ATOMIC_OPS

CommonLibs/Utils.cpp

@@ -12,10 +12,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <vector>

CommonLibs/Utils.h

@@ -12,10 +12,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #pragma once

CommonLibs/Vector.h

@@ -36,6 +36,11 @@
 #include <assert.h>
 #include <stdlib.h>
 
+#ifndef __OPTIMIZE__
+#define assert_no_opt(x) assert(x)
+#else
+#define assert_no_opt(x)
+#endif
 // We can't use Logger.h in this file...
 extern int gVectorDebug;
 #define BVDEBUG(msg) if (gVectorDebug) {std::cout << msg;}
@@ -81,8 +86,8 @@ template <class T> class Vector {
 	/** Return the size of the Vector. */
 	size_t size() const
 	{
-		assert(mStart>=mData);
-		assert(mEnd>=mStart);
+		assert_no_opt(mStart>=mData);
+		assert_no_opt(mEnd>=mStart);
 		return mEnd - mStart;
 	}
 
@@ -112,7 +117,7 @@ template <class T> class Vector {
 	/** Reduce addressable size of the Vector, keeping content. */
 	void shrink(size_t newSize)
 	{
-		assert(newSize <= mEnd - mStart);
+		assert_no_opt(newSize <= mEnd - mStart);
 		mEnd = mStart + newSize;
 	}
 
@@ -199,7 +204,7 @@ template <class T> class Vector {
 	{
 		T* wStart = mStart + start;
 		T* wEnd = wStart + span;
-		assert(wEnd<=mEnd);
+		assert_no_opt(wEnd<=mEnd);
 		return Vector<T>(NULL,wStart,wEnd);
 	}
 
@@ -208,7 +213,7 @@ template <class T> class Vector {
 	{
 		T* wStart = mStart + start;
 		T* wEnd = wStart + span;
-		assert(wEnd<=mEnd);
+		assert_no_opt(wEnd<=mEnd);
 		return Vector<T>(NULL,wStart,wEnd);
 	}
 
@@ -228,8 +233,8 @@ template <class T> class Vector {
 		unsigned int i;
 		T* dst = other.mStart + start;
 		T* src = mStart;
-		assert(dst+span<=other.mEnd);
-		assert(mStart+span<=mEnd);
+		assert_no_opt(dst+span<=other.mEnd);
+		assert_no_opt(mStart+span<=mEnd);
 		for (i = 0; i < span; i++, src++, dst++)
 			*dst = *src;
 		/*TODO if not non-trivially copiable type class, optimize:
@@ -250,8 +255,8 @@ template <class T> class Vector {
 	void segmentCopyTo(Vector<T>& other, size_t start, size_t span) const
 	{
 		const T* base = mStart + start;
-		assert(base+span<=mEnd);
-		assert(other.mStart+span<=other.mEnd);
+		assert_no_opt(base+span<=mEnd);
+		assert_no_opt(other.mStart+span<=other.mEnd);
 		memcpy(other.mStart,base,span*sizeof(T));
 	}
 
@@ -265,8 +270,8 @@ template <class T> class Vector {
 	{
 		const T* baseFrom = mStart + from;
 		T* baseTo = mStart + to;
-		assert(baseFrom+span<=mEnd);
-		assert(baseTo+span<=mEnd);
+		assert_no_opt(baseFrom+span<=mEnd);
+		assert_no_opt(baseTo+span<=mEnd);
 		memmove(baseTo,baseFrom,span*sizeof(T));
 	}
 
@@ -280,7 +285,7 @@ template <class T> class Vector {
 	{
 		T* dp=mStart+start;
 		T* end=dp+length;
-		assert(end<=mEnd);
+		assert_no_opt(end<=mEnd);
 		while (dp<end) *dp++=val;
 	}
 
@@ -292,13 +297,13 @@ template <class T> class Vector {
 
 	T& operator[](size_t index)
 	{
-		assert(mStart+index<mEnd);
+		assert_no_opt(mStart+index<mEnd);
 		return mStart[index];
 	}
 
 	const T& operator[](size_t index) const
 	{
-		assert(mStart+index<mEnd);
+		assert_no_opt(mStart+index<mEnd);
 		return mStart[index];
 	}
 

CommonLibs/config_defs.h

@@ -5,6 +5,8 @@
  * osmo-trx (CXX, dir Transceiver52)
  */
 
+#include <stdbool.h>
+
 enum FillerType {
   FILLER_DUMMY,
   FILLER_ZERO,
@@ -18,3 +20,42 @@ enum ReferenceType {
   REF_EXTERNAL,
   REF_GPS,
 };
+
+/* Maximum number of physical RF channels */
+#define TRX_CHAN_MAX 8
+
+struct trx_ctx;
+
+struct trx_chan {
+	struct trx_ctx *trx; /* backpointer */
+	unsigned int idx; /* channel index */
+	char *rx_path;
+	char *tx_path;
+};
+
+struct trx_cfg {
+	char *bind_addr;
+	char *remote_addr;
+	char *dev_args;
+	unsigned int base_port;
+	unsigned int tx_sps;
+	unsigned int rx_sps;
+	unsigned int rtsc;
+	unsigned int rach_delay;
+	enum ReferenceType clock_ref;
+	enum FillerType filler;
+	bool multi_arfcn;
+	bool ms;
+	double offset;
+	double freq_offset_khz;
+	double rssi_offset;
+	int ul_fn_offset;
+	bool force_rssi_offset; /* Force value set in VTY? */
+	bool swap_channels;
+	bool ext_rach;
+	bool egprs;
+	unsigned int sched_rr;
+	unsigned int stack_size;
+	unsigned int num_chans;
+	struct trx_chan chans[TRX_CHAN_MAX];
+};

CommonLibs/debug.c

@@ -21,18 +21,6 @@
  * See the COPYING file in the main directory for details.
  */
 
-#include "config.h"
-
-/* If HAVE_GETTID, then "_GNU_SOURCE" may need to be defined to use gettid() */
-#if HAVE_GETTID
-#define _GNU_SOURCE
-#endif
-
-#include <sys/types.h>
-#include <unistd.h>
-#include <sys/syscall.h>
-#include "config.h"
-
 #include <osmocom/core/logging.h>
 #include <osmocom/core/utils.h>
 #include "debug.h"
@@ -81,21 +69,15 @@ static const struct log_info_cat default_categories[] = {
 		.color = NULL,
 		.enabled = 1, .loglevel = LOGL_NOTICE,
 	},
+	[DCTR] = {
+		.name = "DCTR",
+		.description = "Rate counter related logging",
+		.color = NULL,
+		.enabled = 1, .loglevel = LOGL_NOTICE,
+	},
 };
 
 const struct log_info log_info = {
 	.cat = default_categories,
 	.num_cat = ARRAY_SIZE(default_categories),
 };
-
-pid_t my_gettid(void)
-{
-#if HAVE_GETTID
-	return gettid();
-#elif defined(LINUX) && defined(__NR_gettid)
-	return (pid_t) syscall(__NR_gettid);
-#else
-	#pragma message ("use pid as tid")
-	return getpid();
-#endif
-}

CommonLibs/debug.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <stdbool.h>
-#include <sys/types.h>
 
 #include <osmocom/core/logging.h>
 
@@ -16,14 +15,9 @@ enum {
 	DTRXDUL,
 	DDEV,
 	DDEVDRV,
+	DCTR,
 };
 
-pid_t my_gettid(void);
-
-#define CLOGC(category, level, fmt, args...) do { \
-	LOGP(category, level, "[tid=%ld] " fmt, (long int) my_gettid(), ##args);  \
-} while(0)
-
 #define CLOGCHAN(chan, category, level, fmt, args...) do { \
-	LOGP(category, level, "[tid=%ld][chan=%zu] " fmt, (long int) my_gettid(), chan, ##args);  \
+	LOGP(category, level, "[chan=%zu] " fmt, chan, ##args);  \
 } while(0)

CommonLibs/osmo_signal.h

@@ -43,6 +43,7 @@ enum SS_DEVICE {
 	   (struct device_counters). Must be sent with PTHREAD_CANCEL_DISABLE
 	   to avoid deadlocks in case osmo-trx process is asked to exit. */
 	S_DEVICE_COUNTER_CHANGE,
+	S_TRX_COUNTER_CHANGE, /* same, but for Transceiver class */
 };
 
 /* signal cb for signal <SS_DEVICE,S_DEVICE_COUNTER_CHANGE> */
@@ -55,3 +56,16 @@ struct device_counters {
 	unsigned int tx_dropped_events;
 	unsigned int tx_dropped_samples;
 };
+
+/* signal cb for signal <SS_DEVICE,S_TRX_COUNTER_CHANGE> */
+struct trx_counters {
+	size_t chan;
+	unsigned int tx_stale_bursts;
+	unsigned int tx_unavailable_bursts;
+	unsigned int tx_trxd_fn_repeated;
+	unsigned int tx_trxd_fn_outoforder;
+	unsigned int tx_trxd_fn_skipped;
+	unsigned int rx_empty_burst;
+	unsigned int rx_clipping;
+	unsigned int rx_no_burst_detected;
+};

CommonLibs/trx_rate_ctr.cpp

@@ -67,21 +67,24 @@ extern "C" {
 #include "Threads.h"
 #include "Logger.h"
 
-/* Used in ctrs_pending, when set it means that channel slot contains unused
+/* Used in dev_ctrs_pending, when set it means that channel slot contains unused
    (non-pending) counter data */
 #define PENDING_CHAN_NONE SIZE_MAX
 
 static void *trx_rate_ctr_ctx;
 
 static struct rate_ctr_group** rate_ctrs;
-static struct device_counters* ctrs_pending;
+static struct device_counters* dev_ctrs_pending;
+static struct trx_counters* trx_ctrs_pending;
 static size_t chan_len;
-static struct osmo_fd rate_ctr_timerfd;
-static Mutex rate_ctr_mutex;
+static struct osmo_fd dev_rate_ctr_timerfd;
+static struct osmo_fd trx_rate_ctr_timerfd;
+static Mutex dev_rate_ctr_mutex;
+static Mutex trx_rate_ctr_mutex;
 
 struct osmo_timer_list threshold_timer;
 static LLIST_HEAD(threshold_list);
-static int threshold_timer_sched_secs;
+static unsigned int threshold_timer_sched_secs;
 static bool threshold_initied;
 
 const struct value_string rate_ctr_intv[] = {
@@ -93,22 +96,38 @@ const struct value_string rate_ctr_intv[] = {
 };
 
 const struct value_string trx_chan_ctr_names[] = {
-	{ TRX_CTR_RX_OVERRUNS,	"rx_overruns" },
-	{ TRX_CTR_TX_UNDERRUNS,	"tx_underruns" },
-	{ TRX_CTR_RX_DROP_EV,	"rx_drop_events" },
-	{ TRX_CTR_RX_DROP_SMPL,	"rx_drop_samples" },
-	{ TRX_CTR_TX_DROP_EV,	"tx_drop_events" },
-	{ TRX_CTR_TX_DROP_SMPL,	"tx_drop_samples" },
+	{ TRX_CTR_DEV_RX_OVERRUNS,	"rx_overruns" },
+	{ TRX_CTR_DEV_TX_UNDERRUNS,	"tx_underruns" },
+	{ TRX_CTR_DEV_RX_DROP_EV,	"rx_drop_events" },
+	{ TRX_CTR_DEV_RX_DROP_SMPL,	"rx_drop_samples" },
+	{ TRX_CTR_DEV_TX_DROP_EV,	"tx_drop_events" },
+	{ TRX_CTR_DEV_TX_DROP_SMPL,	"tx_drop_samples" },
+	{ TRX_CTR_TRX_TX_STALE_BURSTS,	"tx_stale_bursts" },
+	{ TRX_CTR_TRX_TX_UNAVAILABLE_BURSTS, "tx_unavailable_bursts" },
+	{ TRX_CTR_TRX_TRXD_FN_REPEATED,	"tx_trxd_fn_repeated" },
+	{ TRX_CTR_TRX_TRXD_FN_OUTOFORDER, "tx_trxd_fn_outoforder" },
+	{ TRX_CTR_TRX_TRXD_FN_SKIPPED,	"tx_trxd_fn_skipped" },
+	{ TRX_CTR_TRX_RX_EMPTY_BURST,	"rx_empty_burst" },
+	{ TRX_CTR_TRX_RX_CLIPPING,	"rx_clipping" },
+	{ TRX_CTR_TRX_RX_NO_BURST_DETECTED, "rx_no_burst_detected" },
 	{ 0, NULL }
 };
 
 static const struct rate_ctr_desc trx_chan_ctr_desc[] = {
-	[TRX_CTR_RX_OVERRUNS]		= { "device:rx_overruns",	"Number of Rx overruns in FIFO queue" },
-	[TRX_CTR_TX_UNDERRUNS]		= { "device:tx_underruns",	"Number of Tx underruns in FIFO queue" },
-	[TRX_CTR_RX_DROP_EV]		= { "device:rx_drop_events",	"Number of times Rx samples were dropped by HW" },
-	[TRX_CTR_RX_DROP_SMPL]		= { "device:rx_drop_samples",	"Number of Rx samples dropped by HW" },
-	[TRX_CTR_TX_DROP_EV]		= { "device:tx_drop_events",	"Number of times Tx samples were dropped by HW" },
-	[TRX_CTR_TX_DROP_SMPL]		= { "device:tx_drop_samples",	"Number of Tx samples dropped by HW" }
+	[TRX_CTR_DEV_RX_OVERRUNS]		= { "device:rx_overruns",	"Number of Rx overruns in FIFO queue" },
+	[TRX_CTR_DEV_TX_UNDERRUNS]		= { "device:tx_underruns",	"Number of Tx underruns in FIFO queue" },
+	[TRX_CTR_DEV_RX_DROP_EV]		= { "device:rx_drop_events",	"Number of times Rx samples were dropped by HW" },
+	[TRX_CTR_DEV_RX_DROP_SMPL]		= { "device:rx_drop_samples",	"Number of Rx samples dropped by HW" },
+	[TRX_CTR_DEV_TX_DROP_EV]		= { "device:tx_drop_events",	"Number of times Tx samples were dropped by HW" },
+	[TRX_CTR_DEV_TX_DROP_SMPL]		= { "device:tx_drop_samples",	"Number of Tx samples dropped by HW" },
+	[TRX_CTR_TRX_TX_STALE_BURSTS]		= { "trx:tx_stale_bursts",	"Number of Tx burts dropped by TRX due to arriving too late" },
+	[TRX_CTR_TRX_TX_UNAVAILABLE_BURSTS]	= { "trx:tx_unavailable_bursts","Number of Tx burts unavailable (not enqueued) at the time they should be transmitted" },
+	[TRX_CTR_TRX_TRXD_FN_REPEATED]		= { "trx:tx_trxd_fn_repeated",	"Number of Tx burts received from TRXD with repeated FN" },
+	[TRX_CTR_TRX_TRXD_FN_OUTOFORDER]	= { "trx:tx_trxd_fn_outoforder","Number of Tx burts received from TRXD with a past FN" },
+	[TRX_CTR_TRX_TRXD_FN_SKIPPED]		= { "trx:tx_trxd_fn_skipped",	"Number of Tx burts potentially skipped due to FN jumps" },
+	[TRX_CTR_TRX_RX_EMPTY_BURST]		= { "trx:rx_empty_burst",	"Number of Rx bursts empty" },
+	[TRX_CTR_TRX_RX_CLIPPING]		= { "trx:rx_clipping",		"Number of Rx bursts discarded due to clipping" },
+	[TRX_CTR_TRX_RX_NO_BURST_DETECTED]	= { "trx:rx_no_burst_detected",	"Number of Rx burts discarded due to burst detection error" },
 };
 
 static const struct rate_ctr_group_desc trx_chan_ctr_group_desc = {
@@ -119,34 +138,68 @@ static const struct rate_ctr_group_desc trx_chan_ctr_group_desc = {
 	.ctr_desc			= trx_chan_ctr_desc,
 };
 
-static int rate_ctr_timerfd_cb(struct osmo_fd *ofd, unsigned int what) {
+static int dev_rate_ctr_timerfd_cb(struct osmo_fd *ofd, unsigned int what) {
 	size_t chan;
 	struct rate_ctr *ctr;
-	LOGC(DMAIN, NOTICE) << "Main thread is updating counters";
-	rate_ctr_mutex.lock();
+	LOGC(DCTR, INFO) << "Main thread is updating Device counters";
+	dev_rate_ctr_mutex.lock();
 	for (chan = 0; chan < chan_len; chan++) {
-		if (ctrs_pending[chan].chan == PENDING_CHAN_NONE)
+		if (dev_ctrs_pending[chan].chan == PENDING_CHAN_NONE)
 			continue;
-		LOGCHAN(chan, DMAIN, INFO) << "rate_ctr update";
-		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_RX_OVERRUNS];
-		rate_ctr_add(ctr, ctrs_pending[chan].rx_overruns - ctr->current);
-		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_TX_UNDERRUNS];
-		rate_ctr_add(ctr, ctrs_pending[chan].tx_underruns - ctr->current);
-		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_RX_DROP_EV];
-		rate_ctr_add(ctr, ctrs_pending[chan].rx_dropped_events - ctr->current);
-		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_RX_DROP_SMPL];
-		rate_ctr_add(ctr, ctrs_pending[chan].rx_dropped_samples - ctr->current);
-		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_TX_DROP_EV];
-		rate_ctr_add(ctr, ctrs_pending[chan].tx_dropped_events - ctr->current);
-		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_TX_DROP_SMPL];
-		rate_ctr_add(ctr, ctrs_pending[chan].tx_dropped_samples - ctr->current);
+		LOGCHAN(chan, DCTR, DEBUG) << "rate_ctr update";
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_RX_OVERRUNS);
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].rx_overruns - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_TX_UNDERRUNS);
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].tx_underruns - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_RX_DROP_EV);
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].rx_dropped_events - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_RX_DROP_SMPL);
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].rx_dropped_samples - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_TX_DROP_EV);
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].tx_dropped_events - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_TX_DROP_SMPL);
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].tx_dropped_samples - ctr->current);
 
 		/* Mark as done */
-		ctrs_pending[chan].chan = PENDING_CHAN_NONE;
+		dev_ctrs_pending[chan].chan = PENDING_CHAN_NONE;
 	}
-	if (osmo_timerfd_disable(&rate_ctr_timerfd) < 0)
-		LOGC(DMAIN, ERROR) << "Failed to disable timerfd";
-	rate_ctr_mutex.unlock();
+	if (osmo_timerfd_disable(&dev_rate_ctr_timerfd) < 0)
+		LOGC(DCTR, ERROR) << "Failed to disable timerfd";
+	dev_rate_ctr_mutex.unlock();
+	return 0;
+}
+
+static int trx_rate_ctr_timerfd_cb(struct osmo_fd *ofd, unsigned int what) {
+	size_t chan;
+	struct rate_ctr *ctr;
+	LOGC(DCTR, INFO) << "Main thread is updating Transceiver counters";
+	trx_rate_ctr_mutex.lock();
+	for (chan = 0; chan < chan_len; chan++) {
+		if (trx_ctrs_pending[chan].chan == PENDING_CHAN_NONE)
+			continue;
+		LOGCHAN(chan, DCTR, DEBUG) << "rate_ctr update";
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TX_STALE_BURSTS);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_stale_bursts - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TX_UNAVAILABLE_BURSTS);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_unavailable_bursts - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TRXD_FN_REPEATED);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_trxd_fn_repeated - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TRXD_FN_OUTOFORDER);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_trxd_fn_outoforder - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TRXD_FN_SKIPPED);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_trxd_fn_skipped - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_RX_EMPTY_BURST);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].rx_empty_burst - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_RX_CLIPPING);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].rx_clipping - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_RX_NO_BURST_DETECTED);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].rx_no_burst_detected - ctr->current);
+		/* Mark as done */
+		trx_ctrs_pending[chan].chan = PENDING_CHAN_NONE;
+	}
+	if (osmo_timerfd_disable(&trx_rate_ctr_timerfd) < 0)
+		LOGC(DCTR, ERROR) << "Failed to disable timerfd";
+	trx_rate_ctr_mutex.unlock();
 	return 0;
 }
 
@@ -154,23 +207,37 @@ static int rate_ctr_timerfd_cb(struct osmo_fd *ofd, unsigned int what) {
 static int device_sig_cb(unsigned int subsys, unsigned int signal,
 			 void *handler_data, void *signal_data)
 {
-	struct device_counters *ctr;
+	struct device_counters *dev_ctr;
+	struct trx_counters *trx_ctr;
 	/* Delay sched around 20 ms, in case we receive several calls from several
 	 * channels batched */
 	struct timespec next_sched = {.tv_sec = 0, .tv_nsec = 20*1000*1000};
 	/* no automatic re-trigger */
 	struct timespec intv_sched = {.tv_sec = 0, .tv_nsec = 0};
+	char err_buf[256];
 
 	switch (signal) {
 	case S_DEVICE_COUNTER_CHANGE:
-		ctr = (struct device_counters *)signal_data;
-		LOGCHAN(ctr->chan, DMAIN, NOTICE) << "Received counter change from radioDevice";
-		rate_ctr_mutex.lock();
-		ctrs_pending[ctr->chan] = *ctr;
-		if (osmo_timerfd_schedule(&rate_ctr_timerfd, &next_sched, &intv_sched) < 0) {
-			LOGC(DMAIN, ERROR) << "Failed to schedule timerfd: " << errno << " = "<< strerror(errno);
+		dev_ctr = (struct device_counters *)signal_data;
+		LOGCHAN(dev_ctr->chan, DCTR, INFO) << "Received counter change from radioDevice";
+		dev_rate_ctr_mutex.lock();
+		dev_ctrs_pending[dev_ctr->chan] = *dev_ctr;
+		if (osmo_timerfd_schedule(&dev_rate_ctr_timerfd, &next_sched, &intv_sched) < 0) {
+			LOGC(DCTR, ERROR) << "Failed to schedule timerfd: " << errno
+					  << " = "<< strerror_r(errno, err_buf, sizeof(err_buf));
 		}
-		rate_ctr_mutex.unlock();
+		dev_rate_ctr_mutex.unlock();
+		break;
+	case S_TRX_COUNTER_CHANGE:
+		trx_ctr = (struct trx_counters *)signal_data;
+		LOGCHAN(trx_ctr->chan, DCTR, INFO) << "Received counter change from Transceiver";
+		trx_rate_ctr_mutex.lock();
+		trx_ctrs_pending[trx_ctr->chan] = *trx_ctr;
+		if (osmo_timerfd_schedule(&trx_rate_ctr_timerfd, &next_sched, &intv_sched) < 0) {
+			LOGC(DCTR, ERROR) << "Failed to schedule timerfd: " << errno
+					  << " = "<< strerror_r(errno, err_buf, sizeof(err_buf));
+		}
+		trx_rate_ctr_mutex.unlock();
 		break;
 	default:
 		break;
@@ -195,15 +262,15 @@ static void threshold_timer_cb(void *data)
 	struct ctr_threshold *ctr_thr;
 	struct rate_ctr *rate_ctr;
 	size_t chan;
-	LOGC(DMAIN, DEBUG) << "threshold_timer_cb fired!";
+	LOGC(DCTR, DEBUG) << "threshold_timer_cb fired!";
 
 	llist_for_each_entry(ctr_thr, &threshold_list, list) {
 		for (chan = 0; chan < chan_len; chan++) {
-			rate_ctr = &rate_ctrs[chan]->ctr[ctr_thr->ctr_id];
-			LOGCHAN(chan, DMAIN, INFO) << "checking threshold: " << ctr_threshold_2_vty_str(ctr_thr)
+			rate_ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], ctr_thr->ctr_id);
+			LOGCHAN(chan, DCTR, INFO) << "checking threshold: " << ctr_threshold_2_vty_str(ctr_thr)
 						   << " ("<< rate_ctr->intv[ctr_thr->intv].rate << " vs " << ctr_thr->val << ")";
 			if (rate_ctr->intv[ctr_thr->intv].rate >= ctr_thr->val) {
-				LOGCHAN(chan, DMAIN, FATAL) << "threshold reached, stopping! " << ctr_threshold_2_vty_str(ctr_thr)
+				LOGCHAN(chan, DCTR, FATAL) << "threshold reached, stopping! " << ctr_threshold_2_vty_str(ctr_thr)
 							   << " ("<< rate_ctr->intv[ctr_thr->intv].rate << " vs " << ctr_thr->val << ")";
 				osmo_signal_dispatch(SS_MAIN, S_MAIN_STOP_REQUIRED, NULL);
 				return;
@@ -255,13 +322,13 @@ static void threshold_timer_update_intv() {
 
 	llist_for_each_entry(ctr, &threshold_list, list) {
 		secs = ctr_threshold_2_seconds(ctr);
-		if( min_secs > secs)
+		if (min_secs > secs)
 			min_secs = secs;
 	}
 
 
-	threshold_timer_sched_secs = OSMO_MAX(min_secs / 2 - 1, 1);
-	LOGC(DMAIN, INFO) << "New ctr-error-threshold check interval: "
+	threshold_timer_sched_secs = OSMO_MAX((int)(min_secs / 2 - 1), 1);
+	LOGC(DCTR, INFO) << "New ctr-error-threshold check interval: "
 			  << threshold_timer_sched_secs << " seconds";
 	osmo_timer_schedule(&threshold_timer, threshold_timer_sched_secs, 0);
 }
@@ -272,20 +339,27 @@ void trx_rate_ctr_init(void *ctx, struct trx_ctx* trx_ctx)
 	size_t  i;
 	trx_rate_ctr_ctx = ctx;
 	chan_len = trx_ctx->cfg.num_chans;
-	ctrs_pending = (struct device_counters*) talloc_zero_size(ctx, chan_len * sizeof(struct device_counters));
+	dev_ctrs_pending = (struct device_counters*) talloc_zero_size(ctx, chan_len * sizeof(struct device_counters));
+	trx_ctrs_pending = (struct trx_counters*) talloc_zero_size(ctx, chan_len * sizeof(struct trx_counters));
 	rate_ctrs = (struct rate_ctr_group**) talloc_zero_size(ctx, chan_len * sizeof(struct rate_ctr_group*));
 
 	for (i = 0; i < chan_len; i++) {
-		ctrs_pending[i].chan = PENDING_CHAN_NONE;
+		dev_ctrs_pending[i].chan = PENDING_CHAN_NONE;
+		trx_ctrs_pending[i].chan = PENDING_CHAN_NONE;
 		rate_ctrs[i] = rate_ctr_group_alloc(ctx, &trx_chan_ctr_group_desc, i);
 		if (!rate_ctrs[i]) {
-			LOGCHAN(i, DMAIN, ERROR) << "Failed to allocate rate ctr";
+			LOGCHAN(i, DCTR, ERROR) << "Failed to allocate rate ctr";
 			exit(1);
 		}
 	}
-	rate_ctr_timerfd.fd = -1;
-	if (osmo_timerfd_setup(&rate_ctr_timerfd, rate_ctr_timerfd_cb, NULL) < 0) {
-		LOGC(DMAIN, ERROR) << "Failed to setup timerfd";
+	dev_rate_ctr_timerfd.fd = -1;
+	if (osmo_timerfd_setup(&dev_rate_ctr_timerfd, dev_rate_ctr_timerfd_cb, NULL) < 0) {
+		LOGC(DCTR, ERROR) << "Failed to setup timerfd";
+		exit(1);
+	}
+	trx_rate_ctr_timerfd.fd = -1;
+	if (osmo_timerfd_setup(&trx_rate_ctr_timerfd, trx_rate_ctr_timerfd_cb, NULL) < 0) {
+		LOGC(DCTR, ERROR) << "Failed to setup timerfd";
 		exit(1);
 	}
 	osmo_signal_register_handler(SS_DEVICE, device_sig_cb, NULL);
@@ -302,7 +376,7 @@ void trx_rate_ctr_threshold_add(struct ctr_threshold *ctr)
 
 	new_ctr = talloc_zero(trx_rate_ctr_ctx, struct ctr_threshold);
 	*new_ctr = *ctr;
-	LOGC(DMAIN, NOTICE) << "Adding new threshold check: " << ctr_threshold_2_vty_str(new_ctr);
+	LOGC(DCTR, NOTICE) << "Adding new threshold check: " << ctr_threshold_2_vty_str(new_ctr);
 	llist_add(&new_ctr->list, &threshold_list);
 	threshold_timer_update_intv();
 }
@@ -317,7 +391,7 @@ int trx_rate_ctr_threshold_del(struct ctr_threshold *del_ctr)
 		    ctr->val != del_ctr->val)
 			continue;
 
-		LOGC(DMAIN, NOTICE) << "Deleting threshold check: " << ctr_threshold_2_vty_str(del_ctr);
+		LOGC(DCTR, NOTICE) << "Deleting threshold check: " << ctr_threshold_2_vty_str(del_ctr);
 		llist_del(&ctr->list);
 		talloc_free(ctr);
 		threshold_timer_update_intv();

CommonLibs/trx_rate_ctr.h

@@ -4,12 +4,20 @@
 #include <osmocom/vty/command.h>
 
 enum TrxCtr {
-	TRX_CTR_RX_OVERRUNS,
-	TRX_CTR_TX_UNDERRUNS,
-	TRX_CTR_RX_DROP_EV,
-	TRX_CTR_RX_DROP_SMPL,
-	TRX_CTR_TX_DROP_EV,
-	TRX_CTR_TX_DROP_SMPL,
+	TRX_CTR_DEV_RX_OVERRUNS,
+	TRX_CTR_DEV_TX_UNDERRUNS,
+	TRX_CTR_DEV_RX_DROP_EV,
+	TRX_CTR_DEV_RX_DROP_SMPL,
+	TRX_CTR_DEV_TX_DROP_EV,
+	TRX_CTR_DEV_TX_DROP_SMPL,
+	TRX_CTR_TRX_TX_STALE_BURSTS,
+	TRX_CTR_TRX_TX_UNAVAILABLE_BURSTS,
+	TRX_CTR_TRX_TRXD_FN_REPEATED,
+	TRX_CTR_TRX_TRXD_FN_OUTOFORDER,
+	TRX_CTR_TRX_TRXD_FN_SKIPPED,
+	TRX_CTR_TRX_RX_EMPTY_BURST,
+	TRX_CTR_TRX_RX_CLIPPING,
+	TRX_CTR_TRX_RX_NO_BURST_DETECTED,
 };
 
 struct ctr_threshold {

CommonLibs/trx_vty.c

@@ -67,6 +67,15 @@ static const struct value_string filler_types[] = {
 	{ 0,			NULL }
 };
 
+static const struct value_string filler_docs[] = {
+	{ FILLER_DUMMY,		"Send a Dummy Burst on C0 (TRX0) and empty burst on other channels" },
+	{ FILLER_ZERO,		"Send an empty burst (default)" },
+	{ FILLER_NORM_RAND,	"Send a GMSK modulated Normal Burst with random bits (spectrum mask testing)" },
+	{ FILLER_EDGE_RAND,	"Send an 8-PSK modulated Normal Burst with random bits (spectrum mask testing)" },
+	{ FILLER_ACCESS_RAND,	"Send an Access Burst with random bits (Rx/Tx alignment testing)" },
+	{ 0,			NULL }
+};
+
 
 struct trx_ctx *trx_from_vty(struct vty *v)
 {
@@ -112,7 +121,7 @@ DEFUN(cfg_trx, cfg_trx_cmd,
 }
 
 DEFUN(cfg_bind_ip, cfg_bind_ip_cmd,
-	"bind-ip A.B.C.D",
+	"bind-ip " VTY_IPV4_CMD,
 	"Set the IP address for the local bind\n"
 	"IPv4 Address\n")
 {
@@ -124,7 +133,7 @@ DEFUN(cfg_bind_ip, cfg_bind_ip_cmd,
 }
 
 DEFUN(cfg_remote_ip, cfg_remote_ip_cmd,
-	"remote-ip A.B.C.D",
+	"remote-ip " VTY_IPV4_CMD,
 	"Set the IP address for the remote BTS\n"
 	"IPv4 Address\n")
 {
@@ -162,7 +171,9 @@ DEFUN(cfg_dev_args, cfg_dev_args_cmd,
 DEFUN(cfg_tx_sps, cfg_tx_sps_cmd,
 	"tx-sps (1|4)",
 	"Set the Tx Samples-per-Symbol\n"
-	"Tx Samples-per-Symbol\n")
+	"Tx Samples-per-Symbol\n"
+	"1 Sample-per-Symbol\n"
+	"4 Samples-per-Symbol\n")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 
@@ -174,7 +185,9 @@ DEFUN(cfg_tx_sps, cfg_tx_sps_cmd,
 DEFUN(cfg_rx_sps, cfg_rx_sps_cmd,
 	"rx-sps (1|4)",
 	"Set the Rx Samples-per-Symbol\n"
-	"Rx Samples-per-Symbol\n")
+	"Rx Samples-per-Symbol\n"
+	"1 Sample-per-Symbol\n"
+	"4 Samples-per-Symbol\n")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 
@@ -199,7 +212,8 @@ DEFUN(cfg_clock_ref, cfg_clock_ref_cmd,
 
 DEFUN(cfg_multi_arfcn, cfg_multi_arfcn_cmd,
 	"multi-arfcn (disable|enable)",
-	"Enable multi-ARFCN transceiver (default=disable)\n")
+	"Multi-ARFCN transceiver mode (default=disable)\n"
+	"Enable multi-ARFCN mode\n" "Disable multi-ARFCN mode\n")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 
@@ -230,21 +244,52 @@ DEFUN(cfg_offset, cfg_offset_cmd,
 	return CMD_SUCCESS;
 }
 
+DEFUN_ATTR(cfg_freq_offset, cfg_freq_offset_cmd,
+	   "freq-offset FLOAT",
+	   "Apply an artificial offset to Rx/Tx carrier frequency\n"
+	   "Frequency offset in kHz (e.g. -145300)\n",
+	   CMD_ATTR_HIDDEN)
+{
+	struct trx_ctx *trx = trx_from_vty(vty);
+
+	trx->cfg.freq_offset_khz = atof(argv[0]);
+
+	return CMD_SUCCESS;
+}
+
 DEFUN(cfg_rssi_offset, cfg_rssi_offset_cmd,
-	"rssi-offset FLOAT",
+	"rssi-offset FLOAT [relative]",
 	"Set the RSSI to dBm offset in dB (default=0)\n"
-	"RSSI to dBm offset in dB\n")
+	"RSSI to dBm offset in dB\n"
+	"Add to the default rssi-offset value instead of completely replacing it\n")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 
 	trx->cfg.rssi_offset = atof(argv[0]);
+	trx->cfg.force_rssi_offset = (argc == 1);
+
+	return CMD_SUCCESS;
+}
+
+
+DEFUN_ATTR(cfg_ul_fn_offset, cfg_ul_fn_offset_cmd,
+	"ul-fn-offset <-10-10>",
+	"Adjusts the uplink frame FN by the specified amount\n"
+	"Frame Number offset\n",
+	CMD_ATTR_HIDDEN)
+{
+	struct trx_ctx *trx = trx_from_vty(vty);
+
+	trx->cfg.ul_fn_offset = atoi(argv[0]);
 
 	return CMD_SUCCESS;
 }
 
 DEFUN(cfg_swap_channels, cfg_swap_channels_cmd,
 	"swap-channels (disable|enable)",
-	"Swap channels (default=disable)\n")
+	"Swap primary and secondary channels of the PHY (if any)\n"
+	"Do not swap primary and secondary channels (default)\n"
+	"Swap primary and secondary channels\n")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 
@@ -261,7 +306,9 @@ DEFUN(cfg_swap_channels, cfg_swap_channels_cmd,
 
 DEFUN(cfg_egprs, cfg_egprs_cmd,
 	"egprs (disable|enable)",
-	"Enable EDGE receiver (default=disable)\n")
+	"EGPRS (8-PSK demodulation) support (default=disable)\n"
+	"Disable EGPRS (8-PSK demodulation) support\n"
+	"Enable EGPRS (8-PSK demodulation) support\n")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 
@@ -278,7 +325,9 @@ DEFUN(cfg_egprs, cfg_egprs_cmd,
 
 DEFUN(cfg_ext_rach, cfg_ext_rach_cmd,
 	"ext-rach (disable|enable)",
-	"Enable extended (11-bit) RACH (default=disable)\n")
+	"11-bit Access Burst correlation support (default=disable)\n"
+	"Disable 11-bit Access Burst (TS1 & TS2) correlation\n"
+	"Enable 11-bit Access Burst (TS1 & TS2) correlation\n")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 
@@ -291,7 +340,7 @@ DEFUN(cfg_ext_rach, cfg_ext_rach_cmd,
 	return CMD_SUCCESS;
 }
 
-DEFUN(cfg_rt_prio, cfg_rt_prio_cmd,
+DEFUN_DEPRECATED(cfg_rt_prio, cfg_rt_prio_cmd,
 	"rt-prio <1-32>",
 	"Set the SCHED_RR real-time priority\n"
 	"Real time priority\n")
@@ -299,6 +348,8 @@ DEFUN(cfg_rt_prio, cfg_rt_prio_cmd,
 	struct trx_ctx *trx = trx_from_vty(vty);
 
 	trx->cfg.sched_rr = atoi(argv[0]);
+	vty_out (vty, "%% 'rt-prio %u' is deprecated, use 'policy rr %u' under 'sched' node instead%s",
+		 trx->cfg.sched_rr, trx->cfg.sched_rr, VTY_NEWLINE);
 
 	return CMD_SUCCESS;
 }
@@ -315,20 +366,11 @@ DEFUN(cfg_stack_size, cfg_stack_size_cmd,
 	return CMD_SUCCESS;
 }
 
-DEFUN(cfg_filler, cfg_filler_type_cmd,
-	"filler type (zero|dummy|random-nb-gmsk|random-nb-8psk|random-ab)",
+#define CFG_FILLER_DOC_STR \
 	"Filler burst settings\n"
-	"Filler burst type (default=zero)\n"
-	"Send an empty burst when there is nothing to send (default)\n"
-	"Send a dummy burst when there is nothing to send on C0 (TRX0) and empty burst on other channels."
-	" Use for OpenBTS compatibility only, don't use with OsmoBTS as it breaks encryption.\n"
-	"Send a GMSK modulated Normal Burst with random bits when there is nothing to send."
-	" Use for spectrum mask testing. Configure 'filler tsc' to set training sequence.\n"
-	"Send an 8-PSK modulated Normal Burst with random bits when there is nothing to send."
-	" Use for spectrum mask testing. Configure 'filler tsc' to set training sequence.\n"
-	"Send an Access Burst with random bits when there is nothing to send. Use for Rx/Tx alignment."
-	" Configure 'filler access-burst-delay' to introduce artificial delay.\n"
-)
+
+DEFUN(cfg_filler, cfg_filler_type_cmd,
+      "AUTO-GENERATED", "AUTO-GENERATED")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 	// trx->cfg.filler is unsigned, so we need an interim int var to detect errors
@@ -345,7 +387,7 @@ DEFUN(cfg_filler, cfg_filler_type_cmd,
 
 DEFUN(cfg_test_rtsc, cfg_filler_tsc_cmd,
 	"filler tsc <0-7>",
-	"Filler burst settings\n"
+	CFG_FILLER_DOC_STR
 	"Set the TSC for GMSK/8-PSK Normal Burst random fillers. Used only with 'random-nb-gmsk' and"
 	" 'random-nb-8psk' filler types. (default=0)\n"
 	"TSC\n")
@@ -359,7 +401,7 @@ DEFUN(cfg_test_rtsc, cfg_filler_tsc_cmd,
 
 DEFUN(cfg_test_rach_delay, cfg_filler_rach_delay_cmd,
 	"filler access-burst-delay <0-68>",
-	"Filler burst settings\n"
+	CFG_FILLER_DOC_STR
 	"Set the delay for Access Burst random fillers. Used only with 'random-ab' filler type. (default=0)\n"
 	"RACH delay in symbols\n")
 {
@@ -390,7 +432,7 @@ static int vty_intv_name_2_id(const char* str) {
 	return -1;
 }
 
-#define THRESHOLD_ARGS "(rx_overruns|tx_underruns|rx_drop_events|rx_drop_samples|tx_drop_events|tx_drop_samples)"
+#define THRESHOLD_ARGS "(rx_overruns|tx_underruns|rx_drop_events|rx_drop_samples|tx_drop_events|tx_drop_samples|tx_stale_bursts|tx_unavailable_bursts|tx_trxd_fn_repeated|tx_trxd_fn_outoforder|tx_trxd_fn_skipped)"
 #define THRESHOLD_STR_VAL(s) "Set threshold value for rate_ctr device:" OSMO_STRINGIFY_VAL(s) "\n"
 #define THRESHOLD_STRS \
 	THRESHOLD_STR_VAL(rx_overruns) \
@@ -398,7 +440,13 @@ static int vty_intv_name_2_id(const char* str) {
 	THRESHOLD_STR_VAL(rx_drop_events) \
 	THRESHOLD_STR_VAL(rx_drop_samples) \
 	THRESHOLD_STR_VAL(tx_drop_events) \
-	THRESHOLD_STR_VAL(tx_drop_samples)
+	THRESHOLD_STR_VAL(tx_drop_samples) \
+	THRESHOLD_STR_VAL(tx_stale_bursts) \
+	THRESHOLD_STR_VAL(tx_unavailable_bursts) \
+	THRESHOLD_STR_VAL(tx_trxd_fn_repeated) \
+	THRESHOLD_STR_VAL(tx_trxd_fn_outoforder) \
+	THRESHOLD_STR_VAL(tx_trxd_fn_skipped) \
+	""
 #define INTV_ARGS "(per-second|per-minute|per-hour|per-day)"
 #define INTV_STR_VAL(s) "Threshold value sampled " OSMO_STRINGIFY_VAL(s) "\n"
 #define INTV_STRS \
@@ -407,12 +455,13 @@ static int vty_intv_name_2_id(const char* str) {
 	INTV_STR_VAL(per-hour) \
 	INTV_STR_VAL(per-day)
 
-DEFUN(cfg_ctr_error_threshold, cfg_ctr_error_threshold_cmd,
-	"ctr-error-threshold " THRESHOLD_ARGS " <0-65535> " INTV_ARGS,
-	"Threshold rate for error counter\n"
-	THRESHOLD_STRS
-	"Value to set for threshold\n"
-	INTV_STRS)
+DEFUN_ATTR(cfg_ctr_error_threshold, cfg_ctr_error_threshold_cmd,
+	   "ctr-error-threshold " THRESHOLD_ARGS " <0-65535> " INTV_ARGS,
+	   "Threshold rate for error counter\n"
+	   THRESHOLD_STRS
+	   "Value to set for threshold\n"
+	   INTV_STRS,
+	   CMD_ATTR_IMMEDIATE)
 {
 	int rc;
 	struct ctr_threshold ctr;
@@ -438,12 +487,13 @@ DEFUN(cfg_ctr_error_threshold, cfg_ctr_error_threshold_cmd,
 	return CMD_SUCCESS;
 }
 
-DEFUN(cfg_no_ctr_error_threshold, cfg_no_ctr_error_threshold_cmd,
-	"no ctr-error-threshold " THRESHOLD_ARGS " <0-65535> " INTV_ARGS,
-	NO_STR "Threshold rate for error counter\n"
-	THRESHOLD_STRS
-	"Value to set for threshold\n"
-	INTV_STRS)
+DEFUN_ATTR(cfg_no_ctr_error_threshold, cfg_no_ctr_error_threshold_cmd,
+	   "no ctr-error-threshold " THRESHOLD_ARGS " <0-65535> " INTV_ARGS,
+	   NO_STR "Threshold rate for error counter\n"
+	   THRESHOLD_STRS
+	   "Value to set for threshold\n"
+	   INTV_STRS,
+	   CMD_ATTR_IMMEDIATE)
 {
 	int rc;
 	struct ctr_threshold ctr;
@@ -512,6 +562,12 @@ DEFUN(cfg_chan_rx_path, cfg_chan_rx_path_cmd,
 {
 	struct trx_chan *chan = vty->index;
 
+	if (chan->trx->cfg.multi_arfcn && chan->idx > 0) {
+		vty_out(vty, "%% Setting 'rx-path' for chan %u in multi-ARFCN mode "
+			     "does not make sense, because only chan 0 is used%s",
+			chan->idx, VTY_NEWLINE);
+	}
+
 	osmo_talloc_replace_string(chan->trx, &chan->rx_path, argv[0]);
 
 	return CMD_SUCCESS;
@@ -524,6 +580,12 @@ DEFUN(cfg_chan_tx_path, cfg_chan_tx_path_cmd,
 {
 	struct trx_chan *chan = vty->index;
 
+	if (chan->trx->cfg.multi_arfcn && chan->idx > 0) {
+		vty_out(vty, "%% Setting 'tx-path' for chan %u in multi-ARFCN mode "
+			     "does not make sense, because only chan 0 is used%s",
+			chan->idx, VTY_NEWLINE);
+	}
+
 	osmo_talloc_replace_string(chan->trx, &chan->tx_path, argv[0]);
 
 	return CMD_SUCCESS;
@@ -558,8 +620,11 @@ static int config_write_trx(struct vty *vty)
 	vty_out(vty, " multi-arfcn %s%s", trx->cfg.multi_arfcn ? "enable" : "disable", VTY_NEWLINE);
 	if (trx->cfg.offset != 0)
 		vty_out(vty, " offset %f%s", trx->cfg.offset, VTY_NEWLINE);
-	if (trx->cfg.rssi_offset != 0)
-		vty_out(vty, " rssi-offset %f%s", trx->cfg.rssi_offset, VTY_NEWLINE);
+	if (trx->cfg.freq_offset_khz != 0)
+		vty_out(vty, " freq-offset %f%s", trx->cfg.freq_offset_khz, VTY_NEWLINE);
+	if (!(trx->cfg.rssi_offset == 0 && !trx->cfg.force_rssi_offset))
+		vty_out(vty, " rssi-offset %f%s%s", trx->cfg.rssi_offset,
+			trx->cfg.force_rssi_offset ? " relative": "", VTY_NEWLINE);
 	vty_out(vty, " swap-channels %s%s", trx->cfg.swap_channels ? "enable" : "disable", VTY_NEWLINE);
 	vty_out(vty, " egprs %s%s", trx->cfg.egprs ? "enable" : "disable", VTY_NEWLINE);
 	vty_out(vty, " ext-rach %s%s", trx->cfg.ext_rach ? "enable" : "disable", VTY_NEWLINE);
@@ -573,6 +638,8 @@ static int config_write_trx(struct vty *vty)
 		vty_out(vty, " filler access-burst-delay %u%s", trx->cfg.rach_delay, VTY_NEWLINE);
 	if (trx->cfg.stack_size != 0)
 		vty_out(vty, " stack-size %u%s", trx->cfg.stack_size, VTY_NEWLINE);
+	if (trx->cfg.ul_fn_offset != 0)
+		vty_out(vty, " ul-fn-offset %d%s", trx->cfg.ul_fn_offset, VTY_NEWLINE);
 	trx_rate_ctr_threshold_write_config(vty, " ");
 
 	for (i = 0; i < trx->cfg.num_chans; i++) {
@@ -694,12 +761,19 @@ struct trx_ctx *vty_trx_ctx_alloc(void *talloc_ctx)
 	trx->cfg.tx_sps = DEFAULT_TX_SPS;
 	trx->cfg.rx_sps = DEFAULT_RX_SPS;
 	trx->cfg.filler = FILLER_ZERO;
+	trx->cfg.rssi_offset = 0.0f;
 
 	return trx;
 }
 
 int trx_vty_init(struct trx_ctx* trx)
 {
+	cfg_filler_type_cmd.string = vty_cmd_string_from_valstr(trx, filler_types,
+		"filler type (", "|", ")", 0);
+	cfg_filler_type_cmd.doc = vty_cmd_string_from_valstr(trx, filler_docs,
+		CFG_FILLER_DOC_STR "What to do when there is nothing to send "
+		"(filler type, default=zero)\n", "\n", "", 0);
+
 	g_trx_ctx = trx;
 	install_element_ve(&show_trx_cmd);
 
@@ -715,6 +789,7 @@ int trx_vty_init(struct trx_ctx* trx)
 	install_element(TRX_NODE, &cfg_clock_ref_cmd);
 	install_element(TRX_NODE, &cfg_multi_arfcn_cmd);
 	install_element(TRX_NODE, &cfg_offset_cmd);
+	install_element(TRX_NODE, &cfg_freq_offset_cmd);
 	install_element(TRX_NODE, &cfg_rssi_offset_cmd);
 	install_element(TRX_NODE, &cfg_swap_channels_cmd);
 	install_element(TRX_NODE, &cfg_egprs_cmd);
@@ -728,6 +803,7 @@ int trx_vty_init(struct trx_ctx* trx)
 	install_element(TRX_NODE, &cfg_stack_size_cmd);
 
 	install_element(TRX_NODE, &cfg_chan_cmd);
+	install_element(TRX_NODE, &cfg_ul_fn_offset_cmd);
 	install_node(&chan_node, dummy_config_write);
 	install_element(CHAN_NODE, &cfg_chan_rx_path_cmd);
 	install_element(CHAN_NODE, &cfg_chan_tx_path_cmd);

CommonLibs/trx_vty.h

@@ -8,8 +8,6 @@ extern struct vty_app_info g_vty_info;
 extern const struct value_string clock_ref_names[];
 extern const struct value_string filler_names[];
 
-/* Maximum number of physical RF channels */
-#define TRX_CHAN_MAX 8
 /* Maximum number of carriers in multi-ARFCN mode */
 #define TRX_MCHAN_MAX 3
 
@@ -35,38 +33,8 @@ extern const struct value_string filler_names[];
 #define DEFAULT_TRX_IP		"127.0.0.1"
 #define DEFAULT_CHANS		1
 
-struct trx_ctx;
-
-struct trx_chan {
-	struct trx_ctx *trx; /* backpointer */
-	unsigned int idx; /* channel index */
-	char *rx_path;
-	char *tx_path;
-};
-
 struct trx_ctx {
-	struct {
-		char *bind_addr;
-		char *remote_addr;
-		char *dev_args;
-		unsigned int base_port;
-		unsigned int tx_sps;
-		unsigned int rx_sps;
-		unsigned int rtsc;
-		unsigned int rach_delay;
-		enum ReferenceType clock_ref;
-		enum FillerType filler;
-		bool multi_arfcn;
-		double offset;
-		double rssi_offset;
-		bool swap_channels;
-		bool ext_rach;
-		bool egprs;
-		unsigned int sched_rr;
-		unsigned int stack_size;
-		unsigned int num_chans;
-		struct trx_chan chans[TRX_CHAN_MAX];
-	} cfg;
+	struct trx_cfg cfg;
 };
 
 int trx_vty_init(struct trx_ctx* trx);

GSM/GSMCommon.cpp

@@ -55,12 +55,15 @@ const BitVector GSM::gEdgeTrainingSequence[] = {
 };
 
 const BitVector GSM::gDummyBurst("0001111101101110110000010100100111000001001000100000001111100011100010111000101110001010111010010100011001100111001111010011111000100101111101010000");
+const BitVector GSM::gDummyBurstTSC("01110001011100010111000101");
 
 /* 3GPP TS 05.02, section 5.2.7 "Access burst (AB)", synch. sequence bits */
 const BitVector GSM::gRACHSynchSequenceTS0("01001011011111111001100110101010001111000");  /* GSM, GMSK (default) */
 const BitVector GSM::gRACHSynchSequenceTS1("01010100111110001000011000101111001001101");  /* EGPRS, 8-PSK */
 const BitVector GSM::gRACHSynchSequenceTS2("11101111001001110101011000001101101110111");  /* EGPRS, GMSK */
 
+const BitVector GSM::gSCHSynchSequence("1011100101100010000001000000111100101101010001010111011000011011");
+
 //                               |-head-||---------midamble----------------------||--------------data----------------||t|
 const BitVector GSM::gRACHBurst("0011101001001011011111111001100110101010001111000110111101111110000111001001010110011000");
 

GSM/GSMCommon.h

@@ -52,11 +52,16 @@ extern const BitVector gEdgeTrainingSequence[];
 
 /** C0T0 filler burst, GSM 05.02, 5.2.6 */
 extern const BitVector gDummyBurst;
+extern const BitVector gDummyBurstTSC;
 
 /** Random access burst synch. sequence */
 extern const BitVector gRACHSynchSequenceTS0;
 extern const BitVector gRACHSynchSequenceTS1;
 extern const BitVector gRACHSynchSequenceTS2;
+
+/** Synchronization burst sync sequence */
+extern const BitVector gSCHSynchSequence;
+
 /** Random access burst synch. sequence, GSM 05.02 5.2.7 */
 extern const BitVector gRACHBurst;
 

Makefile.am

@@ -28,17 +28,23 @@ AM_CXXFLAGS = -Wall -pthread
 
 # Order must be preserved
 SUBDIRS = \
-	doc \
+	trxcon \
 	CommonLibs \
 	GSM \
 	Transceiver52M \
 	contrib \
-	tests
+	tests \
+	utils \
+	doc \
+	$(NULL)
 
 EXTRA_DIST = \
 	LEGAL \
 	COPYING \
-	README.md
+	README.md \
+	contrib/osmo-trx.spec.in \
+	debian \
+	$(NULL)
 
 AM_DISTCHECK_CONFIGURE_FLAGS = \
 	--with-systemdsystemunitdir=$$dc_install_base/$(systemdsystemunitdir)

Makefile.common

@@ -28,6 +28,7 @@ STD_DEFINES_AND_INCLUDES = \
 
 COMMON_LA = $(top_builddir)/CommonLibs/libcommon.la
 GSM_LA = $(top_builddir)/GSM/libGSM.la
+TRXCON_LA = $(top_builddir)/trxcon/libtrxcon.la
 
 if ARCH_ARM
 ARCH_LA = $(top_builddir)/Transceiver52M/arch/arm/libarch.la

README.md

@@ -1,5 +1,5 @@
-About OsmTRX
-============
+About OsmoTRX
+=============
 
 OsmoTRX is a software-defined radio transceiver that implements the Layer 1
 physical layer of a BTS comprising the following 3GPP specifications:
@@ -9,14 +9,12 @@ physical layer of a BTS comprising the following 3GPP specifications:
 * TS 05.04 "Modulation"
 * TS 05.10 "Radio subsystem synchronization"
 
-OsmoTRX is based on the transceiver code from the
+OsmoTRX is originally based on the transceiver code from the
 [OpenBTS](https://osmocom.org/projects/osmobts/wiki/OpenBTS) project, but setup
 to operate independently with the purpose of using with non-OpenBTS software and
-projects, while still maintaining backwards compatibility with OpenBTS when
-possible. Currently there are numerous features contained in OsmoTRX that extend
-the functionality of the OpenBTS transceiver. These features include enhanced
-support for various embedded platforms - notably ARM - and dual channel
-diversity support for the Fairwaves umtrx.
+projects, specifically within the Osmocom stack.  Used together with
+[OsmoBTS](https://osmocom.org/projects/osmobts/wiki) you can get a pretty
+standard GSM BTS with Abis interface as per the relevant 3GPP specifications.
 
 Homepage
 --------
@@ -31,7 +29,7 @@ You can clone from the official osmo-trx.git repository using
 
         git clone git://git.osmocom.org/osmo-trx.git
 
-There is a cgit interface at <http://git.osmocom.org/osmo-trx/>
+There is a cgit interface at <https://git.osmocom.org/osmo-trx/>
 
 Documentation
 -------------
@@ -39,7 +37,7 @@ Documentation
 Doxygen-generated API documentation is generated during the build process, but
 also available online for each of the sub-libraries at User Manual for OsmoTRX
 can be generated during the build process, and is also available online at
-<http://ftp.osmocom.org/docs/latest/osmotrx-usermanual.pdf>.
+<https://ftp.osmocom.org/docs/latest/osmotrx-usermanual.pdf>.
 
 Mailing List
 ------------

Transceiver52M/ChannelizerBase.cpp

@@ -244,6 +244,7 @@ ChannelizerBase::~ChannelizerBase()
 		free(subFilters[i]);
 		delete[] hist[i];
 	}
+	free(subFilters);
 
 	fft_free(fftInput);
 	fft_free(fftOutput);

Transceiver52M/Makefile.am

@@ -24,23 +24,27 @@ include $(top_srcdir)/Makefile.common
 SUBDIRS = arch device
 
 AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/arch/common -I${srcdir}/device/common
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
-AM_CFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
+AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS) -mcpu=cortex-a72 -mfloat-abi=hard -mfpu=neon-fp-armv8
+AM_CFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS) -mcpu=cortex-a72 -mfloat-abi=hard -mfpu=neon-fp-armv8
 
 noinst_LTLIBRARIES = libtransceiver_common.la
 
 COMMON_SOURCES = \
+	fbsb.cpp \
+	l1if.cpp \
 	radioInterface.cpp \
 	radioVector.cpp \
 	radioClock.cpp \
 	radioBuffer.cpp \
 	sigProcLib.cpp \
 	signalVector.cpp \
-	Transceiver.cpp \
 	ChannelizerBase.cpp \
 	Channelizer.cpp \
 	Synthesis.cpp \
-	proto_trxd.c
+	proto_trxd.c \
+	sch.c \
+	grgsm_vitac/grgsm_vitac.cpp \
+	grgsm_vitac/viterbi_detector.cc
 
 libtransceiver_common_la_SOURCES = \
 	$(COMMON_SOURCES) \
@@ -57,17 +61,21 @@ noinst_HEADERS = \
 	sigProcLib.h \
 	signalVector.h \
 	Transceiver.h \
+	Transceiver2.h \
 	Resampler.h \
 	ChannelizerBase.h \
 	Channelizer.h \
 	Synthesis.h \
-	proto_trxd.h
+	proto_trxd.h \
+	grgsm_vitac/viterbi_detector.h \
+	grgsm_vitac/constants.h
 
 COMMON_LDADD = \
 	libtransceiver_common.la \
 	$(ARCH_LA) \
 	$(GSM_LA) \
 	$(COMMON_LA) \
+	$(TRXCON_LA) \
 	$(FFTWF_LIBS) \
 	$(LIBOSMOCORE_LIBS) \
 	$(LIBOSMOCTRL_LIBS) \
@@ -76,31 +84,47 @@ COMMON_LDADD = \
 bin_PROGRAMS =
 
 if DEVICE_UHD
-bin_PROGRAMS += osmo-trx-uhd
-osmo_trx_uhd_SOURCES = osmo-trx.cpp
-osmo_trx_uhd_LDADD = \
-	$(builddir)/device/uhd/libdevice.la \
+bin_PROGRAMS += osmo-trx-ms-uhd
+osmo_trx_ms_uhd_SOURCES = ms/syncthing.cpp ms/ms_rx_lower.cpp ms/ms_rx_upper.cpp ms/ms_commandhandler.cpp
+osmo_trx_ms_uhd_LDADD = \
+	$(builddir)/device/bladerf/libdevice.la \
 	$(COMMON_LDADD) \
-	$(UHD_LIBS)
-osmo_trx_uhd_CPPFLAGS  = $(AM_CPPFLAGS) $(UHD_CFLAGS)
+	$(UHD_LIBS) \
+	$(TRXCON_LA)
+osmo_trx_ms_uhd_CPPFLAGS  = $(AM_CPPFLAGS) $(UHD_CFLAGS) -DBUILDUHD
+
+bin_PROGRAMS += osmo-trx-syncthing-uhd
+osmo_trx_syncthing_uhd_SOURCES = $(osmo_trx_ms_uhd_SOURCES) ms/ms_rx_burst.cpp
+osmo_trx_syncthing_uhd_LDADD =  $(osmo_trx_ms_uhd_LDADD)
+osmo_trx_syncthing_uhd_CPPFLAGS  = $(AM_CPPFLAGS) $(UHD_CFLAGS) -DSYNCTHINGONLY -DBUILDUHD
+#osmo_trx_syncthing_LDFLAGS  = -fsanitize=address,undefined -shared-libsan
+
 endif
 
-if DEVICE_USRP1
-bin_PROGRAMS += osmo-trx-usrp1
-osmo_trx_usrp1_SOURCES = osmo-trx.cpp
-osmo_trx_usrp1_LDADD = \
-	$(builddir)/device/usrp1/libdevice.la \
+if DEVICE_BLADE
+bin_PROGRAMS += osmo-trx-ms-blade
+osmo_trx_ms_blade_SOURCES = ms/syncthing.cpp ms/ms_rx_lower.cpp ms/ms_rx_upper.cpp ms/ms_commandhandler.cpp
+osmo_trx_ms_blade_LDADD = \
+	$(builddir)/device/bladerf/libdevice.la \
 	$(COMMON_LDADD) \
-	$(USRP_LIBS)
-osmo_trx_usrp1_CPPFLAGS  = $(AM_CPPFLAGS) $(USRP_CFLAGS)
+	$(BLADE_LIBS) \
+	$(TRXCON_LA)
+osmo_trx_ms_blade_CPPFLAGS  = $(AM_CPPFLAGS) $(BLADE_CFLAGS) -DBUILDBLADE
+
+bin_PROGRAMS += osmo-trx-syncthing-blade
+osmo_trx_syncthing_blade_SOURCES = $(osmo_trx_ms_blade_SOURCES) ms/ms_rx_burst.cpp
+osmo_trx_syncthing_blade_LDADD =  $(osmo_trx_ms_blade_LDADD)
+osmo_trx_syncthing_blade_CPPFLAGS  = $(AM_CPPFLAGS) $(BLADE_CFLAGS) -DSYNCTHINGONLY -DBUILDBLADE -mcpu=cortex-a72 -mfloat-abi=hard -mfpu=neon-fp-armv8
+#osmo_trx_syncthing_LDFLAGS  = -fsanitize=address,undefined -shared-libsan
 endif
 
-if DEVICE_LMS
-bin_PROGRAMS += osmo-trx-lms
-osmo_trx_lms_SOURCES = osmo-trx.cpp
-osmo_trx_lms_LDADD = \
-	$(builddir)/device/lms/libdevice.la \
-	$(COMMON_LDADD) \
-	$(LMS_LIBS)
-osmo_trx_lms_CPPFLAGS  = $(AM_CPPFLAGS) $(LMS_CFLAGS)
-endif
+
+noinst_HEADERS += \
+	ms/syncthing.h \
+	ms/bladerf_specific.h \
+	ms/uhd_specific.h \
+	ms/ms_rx_upper.h \
+	ms/ms_state.h \
+	itrq.h
+# -fsanitize=address,undefined -shared-libsan -O0
+#

Transceiver52M/Resampler.cpp

@@ -13,10 +13,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <stdlib.h>
@@ -36,7 +32,7 @@ extern "C" {
 #define M_PI			3.14159265358979323846264338327f
 #endif
 
-#define MAX_OUTPUT_LEN		4096
+#define MAX_OUTPUT_LEN 4096 * 4
 
 using namespace std;
 
@@ -99,6 +95,7 @@ void Resampler::initFilters(float bw)
 		reverse(&part[0], &part[filt_len]);
 }
 
+#ifndef __OPTIMIZE__
 static bool check_vec_len(int in_len, int out_len, int p, int q)
 {
 	if (in_len % q) {
@@ -129,14 +126,15 @@ static bool check_vec_len(int in_len, int out_len, int p, int q)
 
 	return true;
 }
+#endif
 
 int Resampler::rotate(const float *in, size_t in_len, float *out, size_t out_len)
 {
 	int n, path;
-
+#ifndef __OPTIMIZE__
 	if (!check_vec_len(in_len, out_len, p, q))
 		return -1;
-
+#endif
 	/* Generate output from precomputed input/output paths */
 	for (size_t i = 0; i < out_len; i++) {
 		n = in_index[i];

Transceiver52M/Resampler.h

@@ -13,10 +13,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #ifndef _RESAMPLER_H_

Transceiver52M/Transceiver.cpp

@@ -37,6 +37,7 @@ extern "C" {
 #include <osmocom/core/utils.h>
 #include <osmocom/core/socket.h>
 #include <osmocom/core/bits.h>
+#include <osmocom/vty/cpu_sched_vty.h>
 }
 
 #ifdef HAVE_CONFIG_H
@@ -52,8 +53,17 @@ Transceiver *transceiver;
 /* Number of running values use in noise average */
 #define NOISE_CNT			20
 
+
+static void dispatch_trx_rate_ctr_change(TransceiverState *state, unsigned int chan) {
+        thread_enable_cancel(false);
+        state->ctrs.chan = chan;
+        osmo_signal_dispatch(SS_DEVICE, S_TRX_COUNTER_CHANGE, &state->ctrs);
+        thread_enable_cancel(true);
+}
+
 TransceiverState::TransceiverState()
-  : mRetrans(false), mNoiseLev(0.0), mNoises(NOISE_CNT), mPower(0.0)
+  : mFiller(FILLER_ZERO), mRetrans(false), mNoiseLev(0.0), mNoises(NOISE_CNT),
+    mPower(0.0), mMuted(false), first_dl_fn_rcv()
 {
   for (int i = 0; i < 8; i++) {
     chanType[i] = Transceiver::NONE;
@@ -65,6 +75,7 @@ TransceiverState::TransceiverState()
     for (int n = 0; n < 102; n++)
       fillerTable[n][i] = NULL;
   }
+  memset(&ctrs, 0, sizeof(struct trx_counters));
 }
 
 TransceiverState::~TransceiverState()
@@ -86,6 +97,8 @@ bool TransceiverState::init(FillerType filler, size_t sps, float scale, size_t r
   if ((sps != 1) && (sps != 4))
     return false;
 
+  mFiller = filler;
+
   for (size_t n = 0; n < 8; n++) {
     for (size_t i = 0; i < 102; i++) {
       switch (filler) {
@@ -119,26 +132,22 @@ bool TransceiverState::init(FillerType filler, size_t sps, float scale, size_t r
   return false;
 }
 
-Transceiver::Transceiver(int wBasePort,
-                         const char *TRXAddress,
-                         const char *GSMcoreAddress,
-                         size_t tx_sps, size_t rx_sps, size_t chans,
+Transceiver::Transceiver(const struct trx_cfg *cfg,
                          GSM::Time wTransmitLatency,
-                         RadioInterface *wRadioInterface,
-                         double wRssiOffset, int wStackSize)
-  : mBasePort(wBasePort), mLocalAddr(TRXAddress), mRemoteAddr(GSMcoreAddress),
-    mClockSocket(-1), mTransmitLatency(wTransmitLatency), mRadioInterface(wRadioInterface),
-    rssiOffset(wRssiOffset), stackSize(wStackSize),
-    mSPSTx(tx_sps), mSPSRx(rx_sps), mChans(chans), mExtRACH(false), mEdge(false),
-    mOn(false), mForceClockInterface(false),
-    mTxFreq(0.0), mRxFreq(0.0), mTSC(0), mMaxExpectedDelayAB(0), mMaxExpectedDelayNB(0),
-    mWriteBurstToDiskMask(0)
+                         RadioInterface *wRadioInterface)
+  : mChans(cfg->num_chans), cfg(cfg),
+    mCtrlSockets(mChans), mClockSocket(-1),
+    mTxPriorityQueues(mChans), mReceiveFIFO(mChans),
+    mRxServiceLoopThreads(mChans), mRxLowerLoopThread(nullptr), mTxLowerLoopThread(nullptr),
+    mTxPriorityQueueServiceLoopThreads(mChans), mTransmitLatency(wTransmitLatency), mRadioInterface(wRadioInterface),
+    mOn(false),mForceClockInterface(false), mTxFreq(0.0), mRxFreq(0.0), mTSC(0), mMaxExpectedDelayAB(0),
+    mMaxExpectedDelayNB(0), mWriteBurstToDiskMask(0), mVersionTRXD(mChans), mStates(mChans)
 {
   txFullScale = mRadioInterface->fullScaleInputValue();
   rxFullScale = mRadioInterface->fullScaleOutputValue();
 
-  for (int i = 0; i < 8; i++) {
-    for (int j = 0; j < 8; j++)
+  for (size_t i = 0; i < ARRAY_SIZE(mHandover); i++) {
+    for (size_t j = 0; j < ARRAY_SIZE(mHandover[i]); j++)
       mHandover[i][j] = false;
   }
 }
@@ -186,11 +195,9 @@ int Transceiver::ctrl_sock_cb(struct osmo_fd *bfd, unsigned int flags)
  * are still expected to report clock indications through control channel
  * activity.
  */
-bool Transceiver::init(FillerType filler, size_t rtsc, unsigned rach_delay,
-                       bool edge, bool ext_rach)
+bool Transceiver::init()
 {
   int d_srcport, d_dstport, c_srcport, c_dstport;
-
   if (!mChans) {
     LOG(FATAL) << "No channels assigned";
     return false;
@@ -201,41 +208,32 @@ bool Transceiver::init(FillerType filler, size_t rtsc, unsigned rach_delay,
     return false;
   }
 
-  mExtRACH = ext_rach;
-  mEdge = edge;
-
   mDataSockets.resize(mChans, -1);
-  mCtrlSockets.resize(mChans);
-  mTxPriorityQueueServiceLoopThreads.resize(mChans);
-  mRxServiceLoopThreads.resize(mChans);
-
-  mTxPriorityQueues.resize(mChans);
-  mReceiveFIFO.resize(mChans);
-  mStates.resize(mChans);
-  mVersionTRXD.resize(mChans);
+  
 
   /* Filler table retransmissions - support only on channel 0 */
-  if (filler == FILLER_DUMMY)
+  if (cfg->filler == FILLER_DUMMY)
     mStates[0].mRetrans = true;
 
   /* Setup sockets */
   mClockSocket = osmo_sock_init2(AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP,
-				    mLocalAddr.c_str(), mBasePort,
-				    mRemoteAddr.c_str(), mBasePort + 100,
+				    cfg->bind_addr, cfg->base_port,
+				    cfg->remote_addr, cfg->base_port + 100,
 				    OSMO_SOCK_F_BIND | OSMO_SOCK_F_CONNECT);
   if (mClockSocket < 0)
     return false;
 
   for (size_t i = 0; i < mChans; i++) {
     int rv;
-    c_srcport = mBasePort + 2 * i + 1;
-    c_dstport = mBasePort + 2 * i + 101;
-    d_srcport = mBasePort + 2 * i + 2;
-    d_dstport = mBasePort + 2 * i + 102;
+    FillerType filler = cfg->filler;
+    c_srcport = cfg->base_port + 2 * i + 1;
+    c_dstport = cfg->base_port + 2 * i + 101;
+    d_srcport = cfg->base_port + 2 * i + 2;
+    d_dstport = cfg->base_port + 2 * i + 102;
 
     rv = osmo_sock_init2_ofd(&mCtrlSockets[i].conn_bfd, AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP,
-                                      mLocalAddr.c_str(), c_srcport,
-                                      mRemoteAddr.c_str(), c_dstport,
+                                      cfg->bind_addr, c_srcport,
+                                      cfg->remote_addr, c_dstport,
 				      OSMO_SOCK_F_BIND | OSMO_SOCK_F_CONNECT);
     if (rv < 0)
       return false;
@@ -245,8 +243,8 @@ bool Transceiver::init(FillerType filler, size_t rtsc, unsigned rach_delay,
 
 
     mDataSockets[i] = osmo_sock_init2(AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP,
-                                      mLocalAddr.c_str(), d_srcport,
-                                      mRemoteAddr.c_str(), d_dstport,
+                                      cfg->bind_addr, d_srcport,
+                                      cfg->remote_addr, d_dstport,
 				      OSMO_SOCK_F_BIND | OSMO_SOCK_F_CONNECT);
     if (mDataSockets[i] < 0)
       return false;
@@ -254,7 +252,7 @@ bool Transceiver::init(FillerType filler, size_t rtsc, unsigned rach_delay,
     if (i && filler == FILLER_DUMMY)
       filler = FILLER_ZERO;
 
-    mStates[i].init(filler, mSPSTx, txFullScale, rtsc, rach_delay);
+    mStates[i].init(filler, cfg->tx_sps, txFullScale, cfg->rtsc, cfg->rach_delay);
   }
 
   /* Randomize the central clock */
@@ -296,8 +294,8 @@ bool Transceiver::start()
   }
 
   /* Device is running - launch I/O threads */
-  mRxLowerLoopThread = new Thread(stackSize);
-  mTxLowerLoopThread = new Thread(stackSize);
+  mRxLowerLoopThread = new Thread(cfg->stack_size);
+  mTxLowerLoopThread = new Thread(cfg->stack_size);
   mTxLowerLoopThread->start((void * (*)(void*))
                             TxLowerLoopAdapter,(void*) this);
   mRxLowerLoopThread->start((void * (*)(void*))
@@ -308,14 +306,14 @@ bool Transceiver::start()
     TrxChanThParams *params = (TrxChanThParams *)malloc(sizeof(struct TrxChanThParams));
     params->trx = this;
     params->num = i;
-    mRxServiceLoopThreads[i] = new Thread(stackSize);
+    mRxServiceLoopThreads[i] = new Thread(cfg->stack_size);
     mRxServiceLoopThreads[i]->start((void * (*)(void*))
                             RxUpperLoopAdapter, (void*) params);
 
     params = (TrxChanThParams *)malloc(sizeof(struct TrxChanThParams));
     params->trx = this;
     params->num = i;
-    mTxPriorityQueueServiceLoopThreads[i] = new Thread(stackSize);
+    mTxPriorityQueueServiceLoopThreads[i] = new Thread(cfg->stack_size);
     mTxPriorityQueueServiceLoopThreads[i]->start((void * (*)(void*))
                             TxUpperLoopAdapter, (void*) params);
   }
@@ -388,11 +386,11 @@ void Transceiver::addRadioVector(size_t chan, BitVector &bits,
 
   /* Use the number of bits as the EDGE burst indicator */
   if (bits.size() == EDGE_BURST_NBITS)
-    burst = modulateEdgeBurst(bits, mSPSTx);
+    burst = modulateEdgeBurst(bits, cfg->tx_sps);
   else
-    burst = modulateBurst(bits, 8 + (wTime.TN() % 4 == 0), mSPSTx);
+    burst = modulateBurst(bits, 8 + (wTime.TN() % 4 == 0), cfg->tx_sps);
 
-  scaleVector(*burst, txFullScale * pow(10, -RSSI / 10));
+  scaleVector(*burst, txFullScale * pow(10, (double) -RSSI / 20));
 
   radio_burst = new radioVector(wTime, burst);
 
@@ -420,24 +418,29 @@ void Transceiver::pushRadioVector(GSM::Time &nowTime)
   std::vector<signalVector *> bursts(mChans);
   std::vector<bool> zeros(mChans);
   std::vector<bool> filler(mChans, true);
+  bool ratectr_changed;
+
+  TN = nowTime.TN();
 
   for (size_t i = 0; i < mChans; i ++) {
     state = &mStates[i];
+    ratectr_changed = false;
+
+    zeros[i] = state->chanType[TN] == NONE || state->mMuted;
+
+    Mutex *mtx = mTxPriorityQueues[i].getMutex();
+    mtx->lock();
 
     while ((burst = mTxPriorityQueues[i].getStaleBurst(nowTime))) {
-      LOGCHAN(i, DTRXDDL, NOTICE) << "dumping STALE burst in TRX->SDR interface ("
+      LOGCHAN(i, DTRXDDL, INFO) << "dumping STALE burst in TRX->SDR interface ("
                   << burst->getTime() <<" vs " << nowTime << "), retrans=" << state->mRetrans;
+      state->ctrs.tx_stale_bursts++;
+      ratectr_changed = true;
       if (state->mRetrans)
         updateFillerTable(i, burst);
       delete burst;
     }
 
-    TN = nowTime.TN();
-    modFN = nowTime.FN() % state->fillerModulus[TN];
-
-    bursts[i] = state->fillerTable[modFN][TN];
-    zeros[i] = state->chanType[TN] == NONE;
-
     if ((burst = mTxPriorityQueues[i].getCurrentBurst(nowTime))) {
       bursts[i] = burst->getVector();
 
@@ -449,7 +452,21 @@ void Transceiver::pushRadioVector(GSM::Time &nowTime)
       }
 
       delete burst;
+    } else {
+      modFN = nowTime.FN() % state->fillerModulus[TN];
+      bursts[i] = state->fillerTable[modFN][TN];
+      if (i == 0 && state->mFiller == FILLER_ZERO) {
+        LOGCHAN(i, DTRXDDL, INFO) << "No Tx burst available for " << nowTime
+                                    << ", retrans=" << state->mRetrans;
+        state->ctrs.tx_unavailable_bursts++;
+        ratectr_changed = true;
+      }
     }
+
+    mtx->unlock();
+
+    if (ratectr_changed)
+      dispatch_trx_rate_ctr_change(state, i);
   }
 
   mRadioInterface->driveTransmitRadio(bursts, zeros);
@@ -534,16 +551,16 @@ CorrType Transceiver::expectedCorrType(GSM::Time currTime,
     break;
   case IV:
   case VI:
-    return mExtRACH ? EXT_RACH : RACH;
+    return cfg->ext_rach ? EXT_RACH : RACH;
     break;
   case V: {
     int mod51 = burstFN % 51;
     if ((mod51 <= 36) && (mod51 >= 14))
-      return mExtRACH ? EXT_RACH : RACH;
+      return cfg->ext_rach ? EXT_RACH : RACH;
     else if ((mod51 == 4) || (mod51 == 5))
-      return mExtRACH ? EXT_RACH : RACH;
+      return cfg->ext_rach ? EXT_RACH : RACH;
     else if ((mod51 == 45) || (mod51 == 46))
-      return mExtRACH ? EXT_RACH : RACH;
+      return cfg->ext_rach ? EXT_RACH : RACH;
     else if (mHandover[burstTN][sdcch4_subslot[burstFN % 102]])
       return RACH;
     else
@@ -561,11 +578,11 @@ CorrType Transceiver::expectedCorrType(GSM::Time currTime,
   case XIII: {
     int mod52 = burstFN % 52;
     if ((mod52 == 12) || (mod52 == 38))
-      return mExtRACH ? EXT_RACH : RACH;
+      return cfg->ext_rach ? EXT_RACH : RACH;
     else if ((mod52 == 25) || (mod52 == 51))
       return IDLE;
     else /* Enable 8-PSK burst detection if EDGE is enabled */
-      return mEdge ? EDGE : TSC;
+      return cfg->egprs ? EDGE : TSC;
     break;
   }
   case LOOPBACK:
@@ -590,6 +607,13 @@ void writeToFile(radioVector *radio_burst, size_t chan)
   outfile.close();
 }
 
+double Transceiver::rssiOffset(size_t chan)
+{
+  if (cfg->force_rssi_offset)
+        return cfg->rssi_offset;
+  return mRadioInterface->rssiOffset(chan) + cfg->rssi_offset;
+}
+
 /*
  * Pull bursts from the FIFO and handle according to the slot
  * and burst correlation type. Equalzation is currently disabled.
@@ -608,6 +632,8 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
   GSM::Time burstTime;
   SoftVector *rxBurst;
   TransceiverState *state = &mStates[chan];
+  bool ctr_changed = false;
+  double rssi_offset;
 
   /* Blocking FIFO read */
   radioVector *radio_burst = mReceiveFIFO[chan]->read();
@@ -617,7 +643,7 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
   }
 
   /* Set time and determine correlation type */
-  burstTime = radio_burst->getTime();
+  burstTime = radio_burst->getTime() + cfg->ul_fn_offset;
   CorrType type = expectedCorrType(burstTime, chan);
 
   /* Initialize struct bi */
@@ -646,9 +672,13 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
     return -ENOENT;
   }
 
+  /* If TRX RF is locked/muted by BTS, send idle burst indications */
+  if (state->mMuted)
+    goto ret_idle;
+
   /* Select the diversity channel with highest energy */
   for (size_t i = 0; i < radio_burst->chans(); i++) {
-    float pow = energyDetect(*radio_burst->getVector(i), 20 * mSPSRx);
+    float pow = energyDetect(*radio_burst->getVector(i), 20 * cfg->rx_sps);
     if (pow > max) {
       max = pow;
       max_i = i;
@@ -657,7 +687,9 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
   }
 
   if (max_i < 0) {
-    LOGCHAN(chan, DTRXDUL, FATAL) << "Received empty burst";
+    LOGCHAN(chan, DTRXDUL, INFO) << "Received empty burst";
+    state->ctrs.rx_empty_burst++;
+    ctr_changed = true;
     goto ret_idle;
   }
 
@@ -671,8 +703,9 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
     state->mNoiseLev = state->mNoises.avg();
   }
 
-  bi->rssi = 20.0 * log10(rxFullScale / avg) + rssiOffset;
-  bi->noise = 20.0 * log10(rxFullScale / state->mNoiseLev) + rssiOffset;
+  rssi_offset = rssiOffset(chan);
+  bi->rssi = 20.0 * log10(rxFullScale / avg) + rssi_offset;
+  bi->noise = 20.0 * log10(rxFullScale / state->mNoiseLev) + rssi_offset;
 
   if (type == IDLE)
     goto ret_idle;
@@ -681,20 +714,24 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
             mMaxExpectedDelayAB : mMaxExpectedDelayNB;
 
   /* Detect normal or RACH bursts */
-  rc = detectAnyBurst(*burst, mTSC, BURST_THRESH, mSPSRx, type, max_toa, &ebp);
+  rc = detectAnyBurst(*burst, mTSC, BURST_THRESH, cfg->rx_sps, type, max_toa, &ebp);
   if (rc <= 0) {
-    if (rc == -SIGERR_CLIP)
-      LOGCHAN(chan, DTRXDUL, NOTICE) << "Clipping detected on received RACH or Normal Burst";
-    else if (rc != SIGERR_NONE)
-      LOGCHAN(chan, DTRXDUL, NOTICE) << "Unhandled RACH or Normal Burst detection error";
+    if (rc == -SIGERR_CLIP) {
+      LOGCHAN(chan, DTRXDUL, INFO) << "Clipping detected on received RACH or Normal Burst";
+      state->ctrs.rx_clipping++;
+      ctr_changed = true;
+    } else if (rc != SIGERR_NONE) {
+      LOGCHAN(chan, DTRXDUL, INFO) << "Unhandled RACH or Normal Burst detection error";
+      state->ctrs.rx_no_burst_detected++;
+      ctr_changed = true;
+    }
     goto ret_idle;
   }
 
-  type = (CorrType) rc;
+  rxBurst = demodAnyBurst(*burst, (CorrType) rc, cfg->rx_sps, &ebp);
   bi->toa = ebp.toa;
   bi->tsc = ebp.tsc;
   bi->ci = ebp.ci;
-  rxBurst = demodAnyBurst(*burst, mSPSRx, ebp.amp, ebp.toa, type);
 
   /* EDGE demodulator returns 444 (gSlotLen * 3) bits */
   if (rxBurst->size() == EDGE_BURST_NBITS) {
@@ -713,6 +750,8 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
   return 0;
 
 ret_idle:
+  if (ctr_changed)
+    dispatch_trx_rate_ctr_change(state, chan);
   bi->idle = true;
   delete radio_burst;
   return 0;
@@ -760,7 +799,7 @@ void Transceiver::ctrl_sock_send(ctrl_msg& m, int chan)
   struct osmo_fd *conn_bfd = &s.conn_bfd;
 
   s.txmsgqueue.push_back(m);
-  conn_bfd->when |= OSMO_FD_WRITE;
+  osmo_fd_write_enable(conn_bfd);
 }
 
 int Transceiver::ctrl_sock_write(int chan)
@@ -775,7 +814,7 @@ int Transceiver::ctrl_sock_write(int chan)
   while (s.txmsgqueue.size()) {
     const ctrl_msg m = s.txmsgqueue.front();
 
-    s.conn_bfd.when &= ~OSMO_FD_WRITE;
+    osmo_fd_write_disable(&s.conn_bfd);
 
     /* try to send it over the socket */
     rc = write(s.conn_bfd.fd, m.data, strlen(m.data) + 1);
@@ -783,7 +822,7 @@ int Transceiver::ctrl_sock_write(int chan)
       goto close;
     if (rc < 0) {
       if (errno == EAGAIN) {
-        s.conn_bfd.when |= OSMO_FD_WRITE;
+        osmo_fd_write_enable(&s.conn_bfd);
         break;
       }
       goto close;
@@ -887,7 +926,7 @@ int Transceiver::ctrl_sock_handle_rx(int chan)
               (int) round(20.0 * log10(rxFullScale / lev)));
     }
     else {
-      sprintf(response,"RSP NOISELEV 1  0");
+      sprintf(response,"RSP NOISELEV 1 0");
     }
   } else if (match_cmd(command, "SETPOWER", &params)) {
     int power;
@@ -902,11 +941,14 @@ int Transceiver::ctrl_sock_handle_rx(int chan)
     power = mRadioInterface->setPowerAttenuation(power, chan);
     mStates[chan].mPower = power;
     sprintf(response, "RSP ADJPOWER 0 %d", power);
+} else if (match_cmd(command, "NOMTXPOWER", NULL)) {
+    int power = mRadioInterface->getNominalTxPower(chan);
+    sprintf(response, "RSP NOMTXPOWER 0 %d", power);
   } else if (match_cmd(command, "RXTUNE", &params)) {
     // tune receiver
     int freqKhz;
     sscanf(params, "%d", &freqKhz);
-    mRxFreq = freqKhz * 1e3;
+    mRxFreq = (freqKhz + cfg->freq_offset_khz) * 1e3;
     if (!mRadioInterface->tuneRx(mRxFreq, chan)) {
        LOGCHAN(chan, DTRXCTRL, FATAL) << "RX failed to tune";
        sprintf(response,"RSP RXTUNE 1 %d",freqKhz);
@@ -917,7 +959,7 @@ int Transceiver::ctrl_sock_handle_rx(int chan)
     // tune txmtr
     int freqKhz;
     sscanf(params, "%d", &freqKhz);
-    mTxFreq = freqKhz * 1e3;
+    mTxFreq = (freqKhz + cfg->freq_offset_khz) * 1e3;
     if (!mRadioInterface->tuneTx(mTxFreq, chan)) {
        LOGCHAN(chan, DTRXCTRL, FATAL) << "TX failed to tune";
        sprintf(response,"RSP TXTUNE 1 %d",freqKhz);
@@ -955,13 +997,19 @@ int Transceiver::ctrl_sock_handle_rx(int chan)
     LOGCHAN(chan, DTRXCTRL, INFO) << "BTS requests TRXD version switch: " << version_recv;
     if (version_recv > TRX_DATA_FORMAT_VER) {
       LOGCHAN(chan, DTRXCTRL, INFO) << "rejecting TRXD version " << version_recv
-                                    << "in favor of " <<  TRX_DATA_FORMAT_VER;
+                                    << " in favor of " <<  TRX_DATA_FORMAT_VER;
       sprintf(response, "RSP SETFORMAT %u %u", TRX_DATA_FORMAT_VER, version_recv);
     } else {
       LOGCHAN(chan, DTRXCTRL, NOTICE) << "switching to TRXD version " << version_recv;
       mVersionTRXD[chan] = version_recv;
       sprintf(response, "RSP SETFORMAT %u %u", version_recv, version_recv);
     }
+  } else if (match_cmd(command, "RFMUTE", &params)) {
+    // (Un)mute RF TX and RX
+    unsigned mute;
+    sscanf(params, "%u", &mute);
+    mStates[chan].mMuted = mute ? true : false;
+    sprintf(response, "RSP RFMUTE 0 %u", mute);
   } else if (match_cmd(command, "_SETBURSTTODISKMASK", &params)) {
     // debug command! may change or disappear without notice
     // set a mask which bursts to dump to disk
@@ -986,6 +1034,7 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
   struct trxd_hdr_v01_dl *dl;
   char buffer[sizeof(*dl) + EDGE_BURST_NBITS];
   uint32_t fn;
+  uint8_t tn;
 
   // check data socket
   msgLen = read(mDataSockets[chan], buffer, sizeof(buffer));
@@ -999,8 +1048,8 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
       burstLen = gSlotLen;
       break;
     case sizeof(*dl) + EDGE_BURST_NBITS: /* EDGE burst */
-      if (mSPSTx != 4) {
-        LOGCHAN(chan, DTRXDDL, ERROR) << "EDGE burst received but SPS is set to " << mSPSTx;
+      if (cfg->tx_sps != 4) {
+        LOGCHAN(chan, DTRXDDL, ERROR) << "EDGE burst received but SPS is set to " << cfg->tx_sps;
         return false;
       }
       burstLen = EDGE_BURST_NBITS;
@@ -1014,6 +1063,7 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
 
   /* Convert TDMA FN to the host endianness */
   fn = osmo_load32be(&dl->common.fn);
+  tn = dl->common.tn;
 
   /* Make sure we support the received header format */
   switch (dl->common.version) {
@@ -1027,7 +1077,44 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
   }
 
   LOGCHAN(chan, DTRXDDL, DEBUG) << "Rx TRXD message (hdr_ver=" << unsigned(dl->common.version)
-    << "): fn=" << fn << ", tn=" << unsigned(dl->common.tn) << ", burst_len=" << burstLen;
+    << "): fn=" << fn << ", tn=" << unsigned(tn) << ", burst_len=" << burstLen;
+
+  TransceiverState *state = &mStates[chan];
+  GSM::Time currTime = GSM::Time(fn, tn);
+
+  /* Verify proper FN order in DL stream */
+  if (state->first_dl_fn_rcv[tn]) {
+    int32_t delta = GSM::FNDelta(currTime.FN(), state->last_dl_time_rcv[tn].FN());
+    if (delta == 1) {
+        /* usual expected scenario, continue code flow */
+    } else if (delta == 0) {
+      LOGCHAN(chan, DTRXDDL, INFO) << "Rx TRXD msg with repeated FN " << currTime;
+      state->ctrs.tx_trxd_fn_repeated++;
+      dispatch_trx_rate_ctr_change(state, chan);
+      return true;
+    } else if (delta < 0) {
+      LOGCHAN(chan, DTRXDDL, INFO) << "Rx TRXD msg with previous FN " << currTime
+                                     << " vs last " << state->last_dl_time_rcv[tn];
+       state->ctrs.tx_trxd_fn_outoforder++;
+       dispatch_trx_rate_ctr_change(state, chan);
+       /* Allow adding radio vector below, since it gets sorted in the queue */
+    } else if (chan == 0 && state->mFiller == FILLER_ZERO) {
+        /* delta > 1. Some FN was lost in the middle. We can only easily rely
+         * on consecutive FNs in TRX0 since it must transmit continuously in all
+         * setups. Also, osmo-trx supports optionally filling empty bursts on
+         * its own. In that case bts-trx is not obliged to submit all bursts. */
+      LOGCHAN(chan, DTRXDDL, INFO) << "Rx TRXD msg with future FN " << currTime
+                                     << " vs last " << state->last_dl_time_rcv[tn]
+                                     << ", " << delta - 1 << " FN lost";
+      state->ctrs.tx_trxd_fn_skipped += delta - 1;
+      dispatch_trx_rate_ctr_change(state, chan);
+    }
+    if (delta > 0)
+      state->last_dl_time_rcv[tn] = currTime;
+  } else { /* Initial check, simply store state */
+    state->first_dl_fn_rcv[tn] = true;
+    state->last_dl_time_rcv[tn] = currTime;
+  }
 
   BitVector newBurst(burstLen);
   BitVector::iterator itr = newBurst.begin();
@@ -1035,8 +1122,6 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
   while (itr < newBurst.end())
     *itr++ = *bufferItr++;
 
-  GSM::Time currTime = GSM::Time(fn, dl->common.tn);
-
   addRadioVector(chan, newBurst, dl->tx_att, currTime);
 
   return true;
@@ -1053,6 +1138,8 @@ bool Transceiver::driveReceiveRadio()
     return false;
 
   if (mForceClockInterface || mTransmitDeadlineClock > mLastClockUpdateTime + GSM::Time(216,0)) {
+    if (mForceClockInterface)
+      LOGC(DTRXCLK, NOTICE) << "Sending CLOCK indications";
     mForceClockInterface = false;
     return writeClockInterface();
   }
@@ -1069,11 +1156,13 @@ void Transceiver::logRxBurst(size_t chan, const struct trx_ul_burst_ind *bi)
     else os << "-";
   }
 
+  double rssi_offset = rssiOffset(chan);
+
   LOGCHAN(chan, DTRXDUL, DEBUG) << std::fixed << std::right
     << " time: "   << unsigned(bi->tn) << ":" << bi->fn
-    << " RSSI: "   << std::setw(5) << std::setprecision(1) << (bi->rssi - rssiOffset)
+    << " RSSI: "   << std::setw(5) << std::setprecision(1) << (bi->rssi - rssi_offset)
                    << "dBFS/" << std::setw(6) << -bi->rssi << "dBm"
-    << " noise: "  << std::setw(5) << std::setprecision(1) << (bi->noise - rssiOffset)
+    << " noise: "  << std::setw(5) << std::setprecision(1) << (bi->noise - rssi_offset)
                    << "dBFS/" << std::setw(6) << -bi->noise << "dBm"
     << " TOA: "    << std::setw(5) << std::setprecision(2) << bi->toa
     << " C/I: "    << std::setw(5) << std::setprecision(2) << bi->ci << "dB"
@@ -1093,7 +1182,7 @@ bool Transceiver::driveReceiveFIFO(size_t chan)
     return false; /* other errors: we want to stop the process */
   }
 
-  if (!bi.idle)
+  if (!bi.idle && log_check_level(DTRXDUL, LOGL_DEBUG))
     logRxBurst(chan, &bi);
 
   switch (mVersionTRXD[chan]) {
@@ -1191,6 +1280,7 @@ void *RxUpperLoopAdapter(TrxChanThParams *params)
 
   snprintf(thread_name, 16, "RxUpper%zu", num);
   set_selfthread_name(thread_name);
+  OSMO_ASSERT(osmo_cpu_sched_vty_apply_localthread() == 0);
 
   while (1) {
     if (!trx->driveReceiveFIFO(num)) {
@@ -1206,6 +1296,7 @@ void *RxUpperLoopAdapter(TrxChanThParams *params)
 void *RxLowerLoopAdapter(Transceiver *transceiver)
 {
   set_selfthread_name("RxLower");
+  OSMO_ASSERT(osmo_cpu_sched_vty_apply_localthread() == 0);
 
   while (1) {
     if (!transceiver->driveReceiveRadio()) {
@@ -1221,6 +1312,7 @@ void *RxLowerLoopAdapter(Transceiver *transceiver)
 void *TxLowerLoopAdapter(Transceiver *transceiver)
 {
   set_selfthread_name("TxLower");
+  OSMO_ASSERT(osmo_cpu_sched_vty_apply_localthread() == 0);
 
   while (1) {
     transceiver->driveTxFIFO();
@@ -1239,6 +1331,7 @@ void *TxUpperLoopAdapter(TrxChanThParams *params)
 
   snprintf(thread_name, 16, "TxUpper%zu", num);
   set_selfthread_name(thread_name);
+  OSMO_ASSERT(osmo_cpu_sched_vty_apply_localthread() == 0);
 
   while (1) {
     if (!trx->driveTxPriorityQueue(num)) {

Transceiver52M/Transceiver.h

@@ -63,6 +63,7 @@ struct TransceiverState {
   /* The filler table */
   signalVector *fillerTable[102][8];
   int fillerModulus[8];
+  FillerType mFiller;
   bool mRetrans;
 
   /* Most recent channel estimate of all timeslots */
@@ -79,37 +80,39 @@ struct TransceiverState {
 
   /* Received noise energy levels */
   float mNoiseLev;
-  noiseVector mNoises;
+  avgVector mNoises;
 
   /* Shadowed downlink attenuation */
   int mPower;
+
+  /* RF emission and reception disabled, as per NM Administrative State Locked */
+  bool mMuted;
+
+  /* counters */
+  struct trx_counters ctrs;
+
+  /* Used to keep track of lost and out of order frames */
+  bool first_dl_fn_rcv[8];
+  GSM::Time last_dl_time_rcv[8];
 };
 
 /** The Transceiver class, responsible for physical layer of basestation */
 class Transceiver {
 public:
   /** Transceiver constructor
-      @param wBasePort base port number of UDP sockets
-      @param TRXAddress IP address of the TRX, as a string
-      @param GSMcoreAddress IP address of the GSM core, as a string
-      @param wSPS number of samples per GSM symbol
+      @param cfg VTY populated config
       @param wTransmitLatency initial setting of transmit latency
       @param radioInterface associated radioInterface object
   */
-  Transceiver(int wBasePort,
-              const char *TRXAddress,
-              const char *GSMcoreAddress,
-              size_t tx_sps, size_t rx_sps, size_t chans,
+  Transceiver(const struct trx_cfg *cfg,
               GSM::Time wTransmitLatency,
-              RadioInterface *wRadioInterface,
-              double wRssiOffset, int stackSize);
+              RadioInterface *wRadioInterface);
 
   /** Destructor */
   ~Transceiver();
 
   /** Start the control loop */
-  bool init(FillerType filler, size_t rtsc, unsigned rach_delay,
-            bool edge, bool ext_rach);
+  bool init(void);
 
   /** attach the radioInterface receive FIFO */
   bool receiveFIFO(VectorFIFO *wFIFO, size_t chan)
@@ -122,7 +125,7 @@ public:
   }
 
   /** accessor for number of channels */
-  size_t numChans() const { return mChans; };
+  size_t numChans() const { return cfg->num_chans; };
 
   /** Codes for channel combinations */
   typedef enum {
@@ -145,7 +148,7 @@ public:
   } ChannelCombination;
 
 private:
-
+  size_t mChans;
 struct ctrl_msg {
   char data[101];
   ctrl_msg() {};
@@ -166,10 +169,7 @@ struct ctrl_sock_state {
   }
 };
 
-  int mBasePort;
-  std::string mLocalAddr;
-  std::string mRemoteAddr;
-
+  const struct trx_cfg *cfg;	///< VTY populated config
   std::vector<int> mDataSockets;  ///< socket for writing to/reading from GSM core
   std::vector<ctrl_sock_state> mCtrlSockets;  ///< socket for writing/reading control commands from GSM core
   int mClockSocket;               ///< socket for writing clock updates to GSM core
@@ -191,9 +191,6 @@ struct ctrl_sock_state {
   double txFullScale;                     ///< full scale input to radio
   double rxFullScale;                     ///< full scale output to radio
 
-  double rssiOffset;                      ///< RSSI to dBm conversion offset
-  int stackSize;                      ///< stack size for threads, 0 = OS default
-
   /** modulate and add a burst to the transmit queue */
   void addRadioVector(size_t chan, BitVector &bits,
                       int RSSI, GSM::Time &wTime);
@@ -222,12 +219,7 @@ struct ctrl_sock_state {
   /** drive handling of control messages from GSM core */
   int ctrl_sock_handle_rx(int chan);
 
-  int mSPSTx;                          ///< number of samples per Tx symbol
-  int mSPSRx;                          ///< number of samples per Rx symbol
-  size_t mChans;
 
-  bool mExtRACH;
-  bool mEdge;
   bool mOn;	                           ///< flag to indicate that transceiver is powered on
   bool mForceClockInterface;           ///< flag to indicate whether IND CLOCK shall be sent unconditionally after transceiver is started
   bool mHandover[8][8];                ///< expect handover to the timeslot/subslot
@@ -269,7 +261,7 @@ protected:
   friend void *RxLowerLoopAdapter(Transceiver *transceiver);
   friend void *TxLowerLoopAdapter(Transceiver *transceiver);
 
-
+  double rssiOffset(size_t chan);
   void reset();
 
   void logRxBurst(size_t chan, const struct trx_ul_burst_ind *bi);

Transceiver52M/Transceiver2.h

@@ -0,0 +1,258 @@
+/*
+* Copyright 2008 Free Software Foundation, Inc.
+*
+* This software is distributed under the terms of the GNU Public License.
+* See the COPYING file in the main directory for details.
+*
+* This use of this software may be subject to additional restrictions.
+* See the LEGAL file in the main directory for details.
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "radioInterface.h"
+#include "Interthread.h"
+#include "GSMCommon.h"
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+extern "C" {
+#include <osmocom/core/signal.h>
+#include <osmocom/core/select.h>
+#include "config_defs.h"
+}
+
+class Transceiver2;
+
+/** Channel descriptor for transceiver object and channel number pair */
+struct TransceiverChannel {
+  TransceiverChannel(Transceiver2 *trx, int num)
+  {
+    this->trx = trx;
+    this->num = num;
+  }
+
+  ~TransceiverChannel()
+  {
+  }
+
+  Transceiver2 *trx;
+  size_t num;
+};
+
+/** Internal transceiver state variables */
+struct TransceiverState {
+  TransceiverState();
+  ~TransceiverState();
+
+  /* Initialize a multiframe slot in the filler table */
+  void init(size_t slot, signalVector *burst, bool fill);
+
+  int chanType[8];
+
+  /* The filler table */
+  signalVector *fillerTable[102][8];
+  int fillerModulus[8];
+  bool mRetrans;
+
+  /* Received noise energy levels */
+  avgVector mFreqOffsets;
+
+  /* Store pointers to previous frame */
+  radioVector *prevFrame[8];
+
+  /* Transceiver mode */
+  int mode;
+};
+
+/** The Transceiver class, responsible for physical layer of basestation */
+class Transceiver2 {
+private:
+  size_t mChans;
+  int rx_sps, tx_sps;
+  std::string mAddr;
+  GSM::Time mTransmitLatency;     ///< latency between basestation clock and transmit deadline clock
+  GSM::Time mLatencyUpdateTime;   ///< last time latency was updated
+
+  std::vector<VectorQueue> mTxPriorityQueues;   ///< priority queue of transmit bursts received from GSM core
+  std::vector<VectorFIFO *>  mReceiveFIFO;      ///< radioInterface FIFO of receive bursts
+
+  std::vector<Thread *> mRxServiceLoopThreads;  ///< thread to pull bursts into receive FIFO
+  Thread *mLowerLoopThread;                   ///< thread to pull bursts into receive FIFO
+  std::vector<Thread *> mControlServiceLoopThreads;         ///< thread to process control messages from GSM core
+  std::vector<Thread *> mTxPriorityQueueServiceLoopThreads; ///< thread to process transmit bursts from GSM core
+
+  GSM::Time mTransmitDeadlineClock;       ///< deadline for pushing bursts into transmit FIFO 
+  GSM::Time mLastClockUpdateTime;         ///< last time clock update was sent up to core
+
+  RadioInterface *mRadioInterface;	  ///< associated radioInterface object
+  double txFullScale;                     ///< full scale input to radio
+  double rxFullScale;                     ///< full scale output to radio
+
+  /** modulate and add a burst to the transmit queue */
+  void addRadioVector(size_t chan, BitVector &bits,
+                      int RSSI, GSM::Time &wTime);
+
+  /** Update filler table */
+  void updateFillerTable(size_t chan, radioVector *burst);
+
+  /** Push modulated burst into transmit FIFO corresponding to a particular timestamp */
+  void pushRadioVector(GSM::Time &nowTime);
+
+  /** Pull and demodulate a burst from the receive FIFO */
+  SoftVector *pullRadioVector(GSM::Time &wTime, int &RSSI,
+                              int &timingOffset, size_t chan = 0);
+
+  /** Set modulus for specific timeslot */
+  void setModulus(size_t timeslot, size_t chan);
+
+  /** return the expected burst type for the specified timestamp */
+  CorrType expectedCorrType(GSM::Time currTime, size_t chan);
+
+  /** send messages over the clock socket */
+  void writeClockInterface(void);
+
+
+  bool detectSCH(TransceiverState *state,
+                  signalVector &burst,
+                  struct estim_burst_params *ebp);
+
+  bool decodeSCH(SoftVector *burst, GSM::Time *time);
+  bool correctFCCH(TransceiverState *state, signalVector *burst);
+
+
+
+  bool mOn;			       ///< flag to indicate that transceiver is powered on
+  double mTxFreq;                      ///< the transmit frequency
+  double mRxFreq;                      ///< the receive frequency
+  int mPower;                          ///< the transmit power in dB
+  unsigned mTSC;                       ///< the midamble sequence code
+  unsigned mMaxExpectedDelay;          ///< maximum TOA offset in GSM symbols
+  unsigned long long mRxSlotMask[8];   ///< MS - enabled multiframe slot mask
+  int mBSIC;                           ///< MS - detected BSIC
+
+  std::vector<TransceiverState> mStates;
+
+public:
+
+  /** Transceiver constructor 
+      @param wBasePort base port number of UDP sockets
+      @param TRXAddress IP address of the TRX manager, as a string
+      @param wSPS number of samples per GSM symbol
+      @param wTransmitLatency initial setting of transmit latency
+      @param radioInterface associated radioInterface object
+  */
+  Transceiver2(int wBasePort,
+	      const char *TRXAddress,
+	      size_t wSPS, size_t chans,
+	      GSM::Time wTransmitLatency,
+	      RadioInterface *wRadioInterface);
+
+  /** Destructor */
+  ~Transceiver2();
+
+  /** start the Transceiver */
+  void start();
+  bool init(bool filler);
+
+  /** attach the radioInterface receive FIFO */
+  bool receiveFIFO(VectorFIFO *wFIFO, size_t chan)
+  {
+    if (chan >= mReceiveFIFO.size())
+      return false;
+
+    mReceiveFIFO[chan] = wFIFO;
+    return true;
+  }
+
+  /** accessor for number of channels */
+  size_t numChans() const { return mChans; };
+
+  /** Codes for channel combinations */
+  typedef enum {
+    FILL,               ///< Channel is transmitted, but unused
+    I,                  ///< TCH/FS
+    II,                 ///< TCH/HS, idle every other slot
+    III,                ///< TCH/HS
+    IV,                 ///< FCCH+SCH+CCCH+BCCH, uplink RACH
+    V,                  ///< FCCH+SCH+CCCH+BCCH+SDCCH/4+SACCH/4, uplink RACH+SDCCH/4
+    VI,                 ///< CCCH+BCCH, uplink RACH
+    VII,                ///< SDCCH/8 + SACCH/8
+    VIII,               ///< TCH/F + FACCH/F + SACCH/M
+    IX,                 ///< TCH/F + SACCH/M
+    X,                  ///< TCH/FD + SACCH/MD
+    XI,                 ///< PBCCH+PCCCH+PDTCH+PACCH+PTCCH
+    XII,                ///< PCCCH+PDTCH+PACCH+PTCCH
+    XIII,               ///< PDTCH+PACCH+PTCCH
+    NONE,               ///< Channel is inactive, default
+    LOOPBACK            ///< similar go VII, used in loopback testing
+  } ChannelCombination;
+
+  enum {
+    TRX_MODE_OFF,
+    TRX_MODE_BTS,
+    TRX_MODE_MS_ACQUIRE,
+    TRX_MODE_MS_TRACK,
+  };
+
+  void commandhandler(char *buffer, char *response, int chan);
+  void stop();
+protected:
+  /** drive lower receive I/O and burst generation */
+  void driveReceiveRadio();
+
+  /** drive demodulation of GSM bursts */
+  void driveReceiveFIFO(size_t chan);
+
+  /** drive transmission of GSM bursts */
+  void driveTxFIFO();
+
+  /** drive handling of control messages from GSM core */
+  void driveControl(size_t chan);
+
+  /**
+    drive modulation and sorting of GSM bursts from GSM core
+    @return true if a burst was transferred successfully
+  */
+  bool driveTxPriorityQueue(size_t chan);
+
+  friend void *RxUpperLoopAdapter(TransceiverChannel *);
+
+  friend void *TxUpperLoopAdapter(TransceiverChannel *);
+
+  friend void *LowerLoopAdapter(Transceiver2 *);
+
+  friend void *ControlServiceLoopAdapter(TransceiverChannel *);
+
+
+  void reset();
+
+  /** set priority on current thread */
+  //void setPriority(float prio = 0.5) { mRadioInterface->setPriority(prio); }
+
+};
+
+void *RxUpperLoopAdapter(TransceiverChannel *);
+
+/** Main drive threads */
+void *LowerLoopAdapter(Transceiver2 *);
+
+/** control message handler thread loop */
+void *ControlServiceLoopAdapter(TransceiverChannel *);
+
+/** transmit queueing thread loop */
+void *TxUpperLoopAdapter(TransceiverChannel *);
+

Transceiver52M/arch/arm/convert.c

@@ -13,10 +13,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>

Transceiver52M/arch/arm/convert_neon.S

@@ -13,10 +13,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 	.syntax unified

Transceiver52M/arch/arm/convolve.c

@@ -13,10 +13,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>

Transceiver52M/arch/arm/convolve_neon.S

@@ -13,10 +13,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #ifdef HAVE_CONFIG_H

Transceiver52M/arch/arm/mult.c

@@ -13,10 +13,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>

Transceiver52M/arch/arm/mult_neon.S

@@ -13,10 +13,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 	.syntax unified

Transceiver52M/arch/arm/scale.c

@@ -13,10 +13,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>

Transceiver52M/arch/arm/scale_neon.S

@@ -13,10 +13,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 	.syntax unified

Transceiver52M/arch/common/convert_base.c

@@ -13,14 +13,11 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include "convert.h"
 
+__attribute__((xray_never_instrument))
 void base_convert_float_short(short *out, const float *in,
 			      float scale, int len)
 {
@@ -28,6 +25,7 @@ void base_convert_float_short(short *out, const float *in,
 		out[i] = in[i] * scale;
 }
 
+__attribute__((xray_never_instrument))
 void base_convert_short_float(float *out, const short *in, int len)
 {
 	for (int i = 0; i < len; i++)

Transceiver52M/arch/common/convolve_base.c

@@ -13,10 +13,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>
@@ -28,6 +24,7 @@
 #endif
 
 /* Base multiply and accumulate complex-real */
+__attribute__((xray_never_instrument))
 static void mac_real(const float *x, const float *h, float *y)
 {
 	y[0] += x[0] * h[0];
@@ -35,6 +32,7 @@ static void mac_real(const float *x, const float *h, float *y)
 }
 
 /* Base multiply and accumulate complex-complex */
+__attribute__((xray_never_instrument))
 static void mac_cmplx(const float *x, const float *h, float *y)
 {
 	y[0] += x[0] * h[0] - x[1] * h[1];
@@ -42,6 +40,7 @@ static void mac_cmplx(const float *x, const float *h, float *y)
 }
 
 /* Base vector complex-complex multiply and accumulate */
+__attribute__((xray_never_instrument))
 static void mac_real_vec_n(const float *x, const float *h, float *y,
 			   int len)
 {
@@ -50,6 +49,7 @@ static void mac_real_vec_n(const float *x, const float *h, float *y,
 }
 
 /* Base vector complex-complex multiply and accumulate */
+__attribute__((xray_never_instrument))
 static void mac_cmplx_vec_n(const float *x, const float *h, float *y,
 			    int len)
 {
@@ -58,6 +58,7 @@ static void mac_cmplx_vec_n(const float *x, const float *h, float *y,
 }
 
 /* Base complex-real convolution */
+__attribute__((xray_never_instrument))
 int _base_convolve_real(const float *x, int x_len,
 			const float *h, int h_len,
 			float *y, int y_len,
@@ -73,6 +74,7 @@ int _base_convolve_real(const float *x, int x_len,
 }
 
 /* Base complex-complex convolution */
+__attribute__((xray_never_instrument))
 int _base_convolve_complex(const float *x, int x_len,
 			   const float *h, int h_len,
 			   float *y, int y_len,
@@ -89,6 +91,7 @@ int _base_convolve_complex(const float *x, int x_len,
 }
 
 /* Buffer validity checks */
+__attribute__((xray_never_instrument))
 int bounds_check(int x_len, int h_len, int y_len,
 		 int start, int len)
 {
@@ -109,6 +112,7 @@ int bounds_check(int x_len, int h_len, int y_len,
 }
 
 /* API: Non-aligned (no SSE) complex-real */
+__attribute__((xray_never_instrument))
 int base_convolve_real(const float *x, int x_len,
 		       const float *h, int h_len,
 		       float *y, int y_len,
@@ -126,6 +130,7 @@ int base_convolve_real(const float *x, int x_len,
 }
 
 /* API: Non-aligned (no SSE) complex-complex */
+__attribute__((xray_never_instrument))
 int base_convolve_complex(const float *x, int x_len,
 			  const float *h, int h_len,
 			  float *y, int y_len,
@@ -143,6 +148,7 @@ int base_convolve_complex(const float *x, int x_len,
 }
 
 /* Aligned filter tap allocation */
+__attribute__((xray_never_instrument))
 void *convolve_h_alloc(size_t len)
 {
 #ifdef HAVE_SSE3

Transceiver52M/arch/x86/convert.c

@@ -11,10 +11,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>
@@ -64,6 +60,7 @@ void convert_init(void)
 #endif
 }
 
+__attribute__((xray_never_instrument))
 void convert_float_short(short *out, const float *in, float scale, int len)
 {
 	if (!(len % 16))
@@ -74,6 +71,7 @@ void convert_float_short(short *out, const float *in, float scale, int len)
 		c.convert_scale_ps_si16(out, in, scale, len);
 }
 
+__attribute__((xray_never_instrument))
 void convert_short_float(float *out, const short *in, int len)
 {
 	if (!(len % 16))

Transceiver52M/arch/x86/convert_sse_3.c

@@ -11,10 +11,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>
@@ -30,6 +26,7 @@
 #include <emmintrin.h>
 
 /* 8*N single precision floats scaled and converted to 16-bit signed integer */
+__attribute__((xray_never_instrument))
 void _sse_convert_scale_ps_si16_8n(short *restrict out,
 				   const float *restrict in,
 				   float scale, int len)
@@ -58,6 +55,7 @@ void _sse_convert_scale_ps_si16_8n(short *restrict out,
 }
 
 /* 8*N single precision floats scaled and converted with remainder */
+__attribute__((xray_never_instrument))
 void _sse_convert_scale_ps_si16(short *restrict out,
 				const float *restrict in, float scale, int len)
 {
@@ -70,6 +68,7 @@ void _sse_convert_scale_ps_si16(short *restrict out,
 }
 
 /* 16*N single precision floats scaled and converted to 16-bit signed integer */
+__attribute__((xray_never_instrument))
 void _sse_convert_scale_ps_si16_16n(short *restrict out,
 				    const float *restrict in,
 				    float scale, int len)

Transceiver52M/arch/x86/convert_sse_3.h

@@ -11,10 +11,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #pragma once

Transceiver52M/arch/x86/convert_sse_4_1.c

@@ -11,10 +11,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>
@@ -29,6 +25,7 @@
 #include <smmintrin.h>
 
 /* 16*N 16-bit signed integer converted to single precision floats */
+__attribute__((xray_never_instrument))
 void _sse_convert_si16_ps_16n(float *restrict out,
 			      const short *restrict in, int len)
 {
@@ -63,6 +60,7 @@ void _sse_convert_si16_ps_16n(float *restrict out,
 }
 
 /* 16*N 16-bit signed integer conversion with remainder */
+__attribute__((xray_never_instrument))
 void _sse_convert_si16_ps(float *restrict out,
 			  const short *restrict in, int len)
 {

Transceiver52M/arch/x86/convert_sse_4_1.h

@@ -11,10 +11,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #pragma once

Transceiver52M/arch/x86/convolve.c

@@ -11,10 +11,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>
@@ -95,13 +91,15 @@ void convolve_init(void)
 }
 
 /* API: Aligned complex-real */
+__attribute__((xray_never_instrument))
 int convolve_real(const float *x, int x_len,
 		  const float *h, int h_len,
 		  float *y, int y_len, int start, int len)
 {
+#ifndef __OPTIMIZE__
 	if (bounds_check(x_len, h_len, y_len, start, len) < 0)
 		return -1;
-
+#endif
 	memset(y, 0, len * 2 * sizeof(float));
 
 	switch (h_len) {
@@ -133,14 +131,16 @@ int convolve_real(const float *x, int x_len,
 }
 
 /* API: Aligned complex-complex */
+__attribute__((xray_never_instrument))
 int convolve_complex(const float *x, int x_len,
 		     const float *h, int h_len,
 		     float *y, int y_len,
 		     int start, int len)
 {
+#ifndef __OPTIMIZE__
 	if (bounds_check(x_len, h_len, y_len, start, len) < 0)
 		return -1;
-
+#endif
 	memset(y, 0, len * 2 * sizeof(float));
 
 	if (!(h_len % 8))

Transceiver52M/arch/x86/convolve_sse_3.c

@@ -11,10 +11,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>
@@ -31,6 +27,7 @@
 #include <pmmintrin.h>
 
 /* 4-tap SSE complex-real convolution */
+__attribute__((xray_never_instrument))
 void sse_conv_real4(const float *x, int x_len,
 		    const float *h, int h_len,
 		    float *y, int y_len,
@@ -72,6 +69,7 @@ void sse_conv_real4(const float *x, int x_len,
 }
 
 /* 8-tap SSE complex-real convolution */
+__attribute__((xray_never_instrument))
 void sse_conv_real8(const float *x, int x_len,
 		    const float *h, int h_len,
 		    float *y, int y_len,
@@ -123,6 +121,7 @@ void sse_conv_real8(const float *x, int x_len,
 }
 
 /* 12-tap SSE complex-real convolution */
+__attribute__((xray_never_instrument))
 void sse_conv_real12(const float *x, int x_len,
 		     const float *h, int h_len,
 		     float *y, int y_len,
@@ -189,6 +188,7 @@ void sse_conv_real12(const float *x, int x_len,
 }
 
 /* 16-tap SSE complex-real convolution */
+__attribute__((xray_never_instrument))
 void sse_conv_real16(const float *x, int x_len,
 		     const float *h, int h_len,
 		     float *y, int y_len,
@@ -268,6 +268,7 @@ void sse_conv_real16(const float *x, int x_len,
 }
 
 /* 20-tap SSE complex-real convolution */
+__attribute__((xray_never_instrument))
 void sse_conv_real20(const float *x, int x_len,
 		     const float *h, int h_len,
 		     float *y, int y_len,
@@ -358,6 +359,7 @@ void sse_conv_real20(const float *x, int x_len,
 }
 
 /* 4*N-tap SSE complex-real convolution */
+__attribute__((xray_never_instrument))
 void sse_conv_real4n(const float *x, int x_len,
 		     const float *h, int h_len,
 		     float *y, int y_len,
@@ -405,6 +407,7 @@ void sse_conv_real4n(const float *x, int x_len,
 }
 
 /* 4*N-tap SSE complex-complex convolution */
+__attribute__((xray_never_instrument))
 void sse_conv_cmplx_4n(const float *x, int x_len,
 		       const float *h, int h_len,
 		       float *y, int y_len,
@@ -463,6 +466,7 @@ void sse_conv_cmplx_4n(const float *x, int x_len,
 }
 
 /* 8*N-tap SSE complex-complex convolution */
+__attribute__((xray_never_instrument))
 void sse_conv_cmplx_8n(const float *x, int x_len,
 		       const float *h, int h_len,
 		       float *y, int y_len,

Transceiver52M/arch/x86/convolve_sse_3.h

@@ -11,10 +11,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #pragma once

Transceiver52M/device/Makefile.am

@@ -2,6 +2,10 @@ include $(top_srcdir)/Makefile.common
 
 SUBDIRS = common
 
+if DEVICE_IPC
+SUBDIRS += ipc
+endif
+
 if DEVICE_USRP1
 SUBDIRS += usrp1
 endif
@@ -13,3 +17,7 @@ endif
 if DEVICE_LMS
 SUBDIRS += lms
 endif
+
+if DEVICE_BLADE
+SUBDIRS += bladerf
+endif

Transceiver52M/device/bladerf/Makefile.am

@@ -0,0 +1,11 @@
+include $(top_srcdir)/Makefile.common
+
+AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/../common
+AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOVTY_CFLAGS) $(BLADE_CFLAGS)
+
+noinst_HEADERS = bladerf.h
+
+noinst_LTLIBRARIES = libdevice.la
+
+libdevice_la_SOURCES = bladerf.cpp
+libdevice_la_LIBADD = $(top_builddir)/Transceiver52M/device/common/libdevice_common.la

Transceiver52M/device/bladerf/bladerf.cpp

@@ -0,0 +1,783 @@
+/*
+ * Copyright 2022 sysmocom - s.f.m.c. GmbH
+ *
+ * Author: Eric Wild <ewild@sysmocom.de>
+ *
+ * SPDX-License-Identifier: AGPL-3.0+
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * See the COPYING file in the main directory for details.
+ */
+
+#include <map>
+#include <libbladeRF.h>
+#include "radioDevice.h"
+#include "bladerf.h"
+#include "Threads.h"
+#include "Logger.h"
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+extern "C" {
+#include <osmocom/core/utils.h>
+#include <osmocom/gsm/gsm_utils.h>
+#include <osmocom/vty/cpu_sched_vty.h>
+}
+
+#define USRP_TX_AMPL     0.3
+#define UMTRX_TX_AMPL    0.7
+#define LIMESDR_TX_AMPL  0.3
+#define SAMPLE_BUF_SZ    (1 << 20)
+
+/*
+ * UHD timeout value on streaming (re)start
+ *
+ * Allow some time for streaming to commence after the start command is issued,
+ * but consider a wait beyond one second to be a definite error condition.
+ */
+#define UHD_RESTART_TIMEOUT     1.0
+
+/*
+ * UmTRX specific settings
+ */
+#define UMTRX_VGA1_DEF   -18
+
+/*
+ * USRP version dependent device timings
+ */
+
+#define B2XX_TIMING_1SPS	1.7153e-4
+#define B2XX_TIMING_4SPS	1.1696e-4
+#define B2XX_TIMING_4_4SPS	6.18462e-5
+#define B2XX_TIMING_MCBTS	7e-5
+
+#define CHKRET() { \
+	if(status !=0) \
+	fprintf(stderr, "%s:%s:%d %s\n", __FILE__,__FUNCTION__, __LINE__, bladerf_strerror(status)); \
+	}
+
+/*
+ * Tx / Rx sample offset values. In a perfect world, there is no group delay
+ * though analog components, and behaviour through digital filters exactly
+ * matches calculated values. In reality, there are unaccounted factors,
+ * which are captured in these empirically measured (using a loopback test)
+ * timing correction values.
+ *
+ * Notes:
+ *   USRP1 with timestamps is not supported by UHD.
+ */
+
+/* Device Type, Tx-SPS, Rx-SPS */
+typedef std::tuple<blade_dev_type, int, int> dev_key;
+
+/* Device parameter descriptor */
+struct dev_desc {
+	unsigned channels;
+	double mcr;
+	double rate;
+	double offset;
+	std::string str;
+};
+
+static const std::map<dev_key, dev_desc> dev_param_map {
+	{ std::make_tuple(blade_dev_type::BLADE2,  1, 1), { 1, 26e6, GSMRATE, B2XX_TIMING_1SPS, "B200 1 SPS"   } },
+	{ std::make_tuple(blade_dev_type::BLADE2,  4, 1), { 1, 26e6, GSMRATE, B2XX_TIMING_4SPS, "B200 4/1 Tx/Rx SPS" } },
+	{ std::make_tuple(blade_dev_type::BLADE2,  4, 4), { 1, 26e6, GSMRATE, B2XX_TIMING_4_4SPS, "B200 4 SPS" } },
+};
+
+typedef std::tuple<blade_dev_type, enum gsm_band> dev_band_key;
+typedef std::map<dev_band_key, dev_band_desc>::const_iterator dev_band_map_it;
+static const std::map<dev_band_key, dev_band_desc> dev_band_nom_power_param_map {
+	{ std::make_tuple(blade_dev_type::BLADE2, GSM_BAND_850),	{ 89.75, 13.3, -7.5  } },
+	{ std::make_tuple(blade_dev_type::BLADE2, GSM_BAND_900),	{ 89.75, 13.3, -7.5  } },
+	{ std::make_tuple(blade_dev_type::BLADE2, GSM_BAND_1800),	{ 89.75, 7.5,  -11.0 } },
+	{ std::make_tuple(blade_dev_type::BLADE2, GSM_BAND_1900),	{ 89.75, 7.7,  -11.0 } },
+};
+
+
+/* So far measurements done for B210 show really close to linear relationship
+ * between gain and real output power, so we simply adjust the measured offset
+ */
+static double TxGain2TxPower(const dev_band_desc &desc, double tx_gain_db)
+{
+	return desc.nom_out_tx_power - (desc.nom_uhd_tx_gain - tx_gain_db);
+}
+static double TxPower2TxGain(const dev_band_desc &desc, double tx_power_dbm)
+{
+	return desc.nom_uhd_tx_gain - (desc.nom_out_tx_power - tx_power_dbm);
+}
+
+blade_device::blade_device(size_t tx_sps, size_t rx_sps,
+		       InterfaceType iface, size_t chan_num, double lo_offset,
+		       const std::vector<std::string>& tx_paths,
+		       const std::vector<std::string>& rx_paths)
+	: RadioDevice(tx_sps, rx_sps, iface, chan_num, lo_offset, tx_paths, rx_paths),
+	  dev(nullptr), rx_gain_min(0.0), rx_gain_max(0.0),
+	  band_ass_curr_sess(false), band((enum gsm_band)0), tx_spp(0),
+	  rx_spp(0), started(false), aligned(false),
+	  drop_cnt(0), prev_ts(0), ts_initial(0), ts_offset(0), async_event_thrd(NULL)
+{
+}
+
+blade_device::~blade_device()
+{
+	if(dev) {
+		bladerf_enable_module(dev, BLADERF_CHANNEL_RX(0), false);
+		bladerf_enable_module(dev, BLADERF_CHANNEL_TX(0), false);
+	}
+
+	stop();
+
+	for (size_t i = 0; i < rx_buffers.size(); i++)
+		delete rx_buffers[i];
+}
+
+void blade_device::assign_band_desc(enum gsm_band req_band)
+{
+	dev_band_map_it it;
+
+	it = dev_band_nom_power_param_map.find(dev_band_key(dev_type, req_band));
+	if (it == dev_band_nom_power_param_map.end()) {
+		dev_desc desc = dev_param_map.at(dev_key(dev_type, tx_sps, rx_sps));
+		LOGC(DDEV, ERROR) << "No Power parameters exist for device "
+				    << desc.str << " on band " << gsm_band_name(req_band)
+				    << ", using B210 ones as fallback";
+		it = dev_band_nom_power_param_map.find(dev_band_key(blade_dev_type::BLADE2, req_band));
+	}
+	OSMO_ASSERT(it != dev_band_nom_power_param_map.end())
+	band_desc = it->second;
+}
+
+bool blade_device::set_band(enum gsm_band req_band)
+{
+	if (band_ass_curr_sess && req_band != band) {
+		LOGC(DDEV, ALERT) << "Requesting band " << gsm_band_name(req_band)
+				  << " different from previous band " << gsm_band_name(band);
+		return false;
+	}
+
+	if (req_band != band) {
+		band = req_band;
+		assign_band_desc(band);
+	}
+	band_ass_curr_sess = true;
+	return true;
+}
+
+void blade_device::get_dev_band_desc(dev_band_desc& desc)
+{
+	if (band == 0) {
+		LOGC(DDEV, ERROR) << "Power parameters requested before Tx Frequency was set! Providing band 900 by default...";
+		assign_band_desc(GSM_BAND_900);
+	}
+	desc = band_desc;
+}
+
+void blade_device::init_gains()
+{
+	double tx_gain_min, tx_gain_max;
+	int status;
+
+	
+	const struct bladerf_range* r;
+	bladerf_get_gain_range(dev, BLADERF_RX, &r);
+
+
+	rx_gain_min = r->min;
+	rx_gain_max = r->max;
+	LOGC(DDEV, INFO) << "Supported Rx gain range [" << rx_gain_min << "; " << rx_gain_max << "]";
+
+	for (size_t i = 0; i < rx_gains.size(); i++) {
+		double gain = (rx_gain_min + rx_gain_max) / 2;
+		status = bladerf_set_gain_mode(dev, BLADERF_CHANNEL_RX(i), BLADERF_GAIN_MGC );
+		CHKRET()
+		bladerf_gain_mode m;
+		bladerf_get_gain_mode(dev, BLADERF_CHANNEL_RX(i), &m);
+		LOGC(DDEV, INFO) << (m == BLADERF_GAIN_MANUAL ? "gain manual" : "gain AUTO") ;
+
+		status = bladerf_set_gain(dev, BLADERF_CHANNEL_RX(i), 0);//gain);
+		CHKRET()
+		int actual_gain;
+		status = bladerf_get_gain(dev, BLADERF_CHANNEL_RX(i), &actual_gain);
+		CHKRET()
+		LOGC(DDEV, INFO) << "Default setting Rx gain for channel " << i << " to " << gain << " scale " << r->scale << " actual " << actual_gain;
+		rx_gains[i] = actual_gain;
+
+		status = bladerf_set_gain(dev, BLADERF_CHANNEL_RX(i), 0);//gain);
+		CHKRET()
+		status = bladerf_get_gain(dev, BLADERF_CHANNEL_RX(i), &actual_gain);
+		CHKRET()
+		LOGC(DDEV, INFO) << "Default setting Rx gain for channel " << i << " to " << gain << " scale " << r->scale << " actual " << actual_gain;
+		rx_gains[i] = actual_gain;
+	}
+
+	status = bladerf_get_gain_range(dev, BLADERF_TX, &r);
+	CHKRET()
+	tx_gain_min = r->min;
+	tx_gain_max = r->max;
+	LOGC(DDEV, INFO) << "Supported Tx gain range [" << tx_gain_min << "; " << tx_gain_max << "]";
+
+	for (size_t i = 0; i < tx_gains.size(); i++) {
+		double gain = (tx_gain_min + tx_gain_max) / 2;
+		status = bladerf_set_gain(dev, BLADERF_CHANNEL_TX(i), 30);//gain);
+		CHKRET()
+		int actual_gain;
+		status = bladerf_get_gain(dev, BLADERF_CHANNEL_TX(i), &actual_gain);
+		CHKRET()
+		LOGC(DDEV, INFO) << "Default setting Tx gain for channel " << i << " to " << gain << " scale " << r->scale << " actual " << actual_gain;
+		tx_gains[i] = actual_gain;
+	}
+
+	return;
+
+}
+
+void blade_device::set_rates()
+{
+	//dev_desc desc = dev_param_map.at(dev_key(dev_type, tx_sps, rx_sps));
+
+	struct bladerf_rational_rate rate = {0, static_cast<uint64_t>((1625e3 * 4))*64, 6*64}, actual;
+	auto status = bladerf_set_rational_sample_rate(dev, BLADERF_CHANNEL_RX(0), &rate, &actual);
+	CHKRET()
+	status = bladerf_set_rational_sample_rate(dev, BLADERF_CHANNEL_TX(0), &rate, &actual);
+	CHKRET()
+
+
+	tx_rate = rx_rate = (double)rate.num/(double)rate.den;
+
+	LOGC(DDEV, INFO) << "Rates set to" << tx_rate << " / " << rx_rate;
+
+
+    bladerf_set_bandwidth(dev, BLADERF_CHANNEL_RX(0), (bladerf_bandwidth)2e6, (bladerf_bandwidth*)NULL);
+    bladerf_set_bandwidth(dev, BLADERF_CHANNEL_TX(0), (bladerf_bandwidth)2e6, (bladerf_bandwidth*)NULL);
+
+	ts_offset = 60;//static_cast<TIMESTAMP>(desc.offset * rx_rate);
+	//LOGC(DDEV, INFO) << "Rates configured for " << desc.str;
+}
+
+double blade_device::setRxGain(double db, size_t chan)
+{
+	if (chan >= rx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return 0.0f;
+	}
+
+	bladerf_set_gain(dev, BLADERF_CHANNEL_RX(chan), 30);//db);
+	int actual_gain;
+	bladerf_get_gain(dev, BLADERF_CHANNEL_RX(chan), &actual_gain);
+
+	rx_gains[chan] = actual_gain;
+
+	LOGC(DDEV, INFO) << "Set RX gain to " << rx_gains[chan] << "dB (asked for " << db << "dB)";
+
+	return rx_gains[chan];
+}
+
+double blade_device::getRxGain(size_t chan)
+{
+	if (chan >= rx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return 0.0f;
+	}
+
+	return rx_gains[chan];
+}
+
+double blade_device::rssiOffset(size_t chan)
+{
+	double rssiOffset;
+	dev_band_desc desc;
+
+	if (chan >= rx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return 0.0f;
+	}
+
+	get_dev_band_desc(desc);
+	rssiOffset = rx_gains[chan] + desc.rxgain2rssioffset_rel;
+	return rssiOffset;
+}
+
+double blade_device::setPowerAttenuation(int atten, size_t chan) {
+	double tx_power, db;
+	dev_band_desc desc;
+
+	if (chan >= tx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel" << chan;
+		return 0.0f;
+	}
+
+	get_dev_band_desc(desc);
+	tx_power = desc.nom_out_tx_power - atten;
+	db = TxPower2TxGain(desc, tx_power);
+
+	bladerf_set_gain(dev, BLADERF_CHANNEL_TX(chan), 30);//db);
+	int actual_gain;
+	bladerf_get_gain(dev, BLADERF_CHANNEL_RX(chan), &actual_gain);
+
+	tx_gains[chan] = actual_gain;
+
+	LOGC(DDEV, INFO) << "Set TX gain to " << tx_gains[chan] << "dB, ~"
+			 <<  TxGain2TxPower(desc, tx_gains[chan]) << " dBm "
+			 << "(asked for " << db << " dB, ~" << tx_power << " dBm)";
+
+	return desc.nom_out_tx_power - TxGain2TxPower(desc, tx_gains[chan]);
+}
+double blade_device::getPowerAttenuation(size_t chan) {
+	dev_band_desc desc;
+	if (chan >= tx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return 0.0f;
+	}
+
+	get_dev_band_desc(desc);
+	return desc.nom_out_tx_power - TxGain2TxPower(desc, tx_gains[chan]);
+}
+
+int blade_device::getNominalTxPower(size_t chan)
+{
+	dev_band_desc desc;
+	get_dev_band_desc(desc);
+
+	return desc.nom_out_tx_power;
+}
+
+
+int blade_device::open(const std::string &args, int ref, bool swap_channels)
+{
+
+	bladerf_log_set_verbosity(BLADERF_LOG_LEVEL_VERBOSE);
+	bladerf_set_usb_reset_on_open(true);
+	auto success = bladerf_open(&dev, args.c_str());
+	if(success != 0) {
+		struct bladerf_devinfo* info;
+		auto num_devs = bladerf_get_device_list(&info);
+		LOGC(DDEV, ALERT) << "No bladerf devices found with identifier '" << args << "'";
+		if(num_devs) {
+			for(int i=0; i < num_devs; i++)
+				LOGC(DDEV, ALERT) << "Found device:" << info[i].product << " serial " << info[i].serial;
+		}
+
+		return -1;
+	}
+	if(strcmp("bladerf2", bladerf_get_board_name(dev))) {
+		LOGC(DDEV, ALERT) << "Only BladeRF2 supported! found:" << bladerf_get_board_name(dev) ;
+		return -1;
+	}
+
+	dev_type = blade_dev_type::BLADE2;
+	tx_window = TX_WINDOW_FIXED;
+	
+	struct bladerf_devinfo info;
+	bladerf_get_devinfo(dev, &info);
+	// Use the first found device
+	LOGC(DDEV, INFO) << "Using discovered bladerf device " << info.serial;
+
+
+	tx_freqs.resize(chans);
+	rx_freqs.resize(chans);
+	tx_gains.resize(chans);
+	rx_gains.resize(chans);
+	rx_buffers.resize(chans);
+
+	switch (ref) {
+	case REF_INTERNAL:
+	case REF_EXTERNAL:
+		break;
+	default:
+		LOGC(DDEV, ALERT) << "Invalid reference type";
+		return -1;
+	}
+
+	if(ref == REF_EXTERNAL) {
+		bool is_locked;
+		int status = bladerf_set_pll_enable(dev, true);
+		CHKRET()
+		status = bladerf_set_pll_refclk(dev, 10000000);
+		CHKRET()
+		for(int i=0; i < 20; i++) {
+			usleep(50*1000);
+			status = bladerf_get_pll_lock_state(dev, &is_locked);
+			CHKRET()
+			if(is_locked)
+				break;
+		}
+		if(!is_locked) {
+			LOGC(DDEV, ALERT) << "unable to lock refclk!";
+			return -1;
+		}
+	}
+
+	LOGC(DDEV, INFO) << "Selected clock source is " << ((ref == REF_INTERNAL) ? "internal" : "external 10Mhz");
+
+	bladerf_set_tuning_mode(dev, BLADERF_TUNING_MODE_FPGA);
+	set_rates();
+
+/*
+	1ts = 3/5200s
+	1024*2 = small gap(~180us) every 9.23ms = every 16 ts? -> every 2 frames
+	1024*1 = large gap(~627us) every 9.23ms = every 16 ts? -> every 2 frames
+
+	rif convertbuffer = 625*4 = 2500 -> 4 ts
+	rif rxtxbuf = 4 * segment(625*4) = 10000 -> 16 ts
+*/
+    const unsigned int num_buffers   = 256;
+    const unsigned int buffer_size   = 1024*4; /* Must be a multiple of 1024 */
+    const unsigned int num_transfers = 32;
+    const unsigned int timeout_ms    = 3500;
+
+
+    bladerf_sync_config(dev, BLADERF_RX_X1, BLADERF_FORMAT_SC16_Q11_META,
+                                 num_buffers, buffer_size, num_transfers,
+                                 timeout_ms);
+
+    bladerf_sync_config(dev, BLADERF_TX_X1, BLADERF_FORMAT_SC16_Q11_META,
+                                 num_buffers, buffer_size, num_transfers,
+                                 timeout_ms);
+
+
+
+
+	/* Number of samples per over-the-wire packet */
+	tx_spp = rx_spp = buffer_size;
+
+	// Create receive buffer
+	size_t buf_len = SAMPLE_BUF_SZ / sizeof(uint32_t);
+	for (size_t i = 0; i < rx_buffers.size(); i++)
+		rx_buffers[i] = new smpl_buf(buf_len);
+
+	// Create vector buffer
+	pkt_bufs = std::vector<std::vector<short> >(chans, std::vector<short>(2 * rx_spp));
+	for (size_t i = 0; i < pkt_bufs.size(); i++)
+		pkt_ptrs.push_back(&pkt_bufs[i].front());
+
+	// Initialize and shadow gain values
+	init_gains();
+
+	return NORMAL;
+}
+
+
+bool blade_device::restart()
+{
+	/* Allow 100 ms delay to align multi-channel streams */
+	double delay = 0.2;
+	int status;
+
+	status = bladerf_enable_module(dev, BLADERF_CHANNEL_RX(0), true);
+	CHKRET()
+	status = bladerf_enable_module(dev, BLADERF_CHANNEL_TX(0), true);
+	CHKRET()
+
+	bladerf_timestamp now;
+	status = bladerf_get_timestamp(dev, BLADERF_RX, &now);
+	ts_initial = now + rx_rate * delay;
+	LOGC(DDEV, INFO) << "Initial timestamp " << ts_initial << std::endl;
+
+	return true;
+}
+
+bool blade_device::start()
+{
+	LOGC(DDEV, INFO) << "Starting USRP...";
+
+	if (started) {
+		LOGC(DDEV, ERROR) << "Device already started";
+		return false;
+	}
+
+	// Start streaming
+	if (!restart())
+		return false;
+
+
+	started = true;
+	return true;
+}
+
+bool blade_device::stop()
+{
+	if (!started)
+		return false;
+
+	/* reset internal buffer timestamps */
+	for (size_t i = 0; i < rx_buffers.size(); i++)
+		rx_buffers[i]->reset();
+
+	band_ass_curr_sess = false;
+
+	started = false;
+	return true;
+}
+
+int blade_device::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
+			    TIMESTAMP timestamp, bool *underrun)
+{
+	ssize_t rc;
+	uint64_t ts;
+
+	if (bufs.size() != chans) {
+		LOGC(DDEV, ALERT) << "Invalid channel combination " << bufs.size();
+		return -1;
+	}
+
+	*overrun = false;
+	*underrun = false;
+
+	// Shift read time with respect to transmit clock
+	timestamp += ts_offset;
+
+	ts = timestamp;
+	LOGC(DDEV, DEBUG) << "Requested timestamp = " << ts;
+
+	// Check that timestamp is valid
+	rc = rx_buffers[0]->avail_smpls(timestamp);
+	if (rc < 0) {
+		LOGC(DDEV, ERROR) << rx_buffers[0]->str_code(rc);
+		LOGC(DDEV, ERROR) << rx_buffers[0]->str_status(timestamp);
+		return len;
+	}
+
+	
+	struct bladerf_metadata meta = {};
+	meta.timestamp = ts;
+	//static bool first_rx = true;
+	// meta.timestamp = (first_rx) ? ts : 0;
+	// meta.flags = (!first_rx) ? 0:BLADERF_META_FLAG_RX_NOW;
+	// if(first_rx)
+	// 	first_rx = false;
+
+	// Receive samples from the usrp until we have enough
+	while (rx_buffers[0]->avail_smpls(timestamp) < len) {
+		thread_enable_cancel(false);
+		int status = bladerf_sync_rx(dev, pkt_ptrs[0], len, &meta, 200U);
+		thread_enable_cancel(true);
+
+		if(status != 0)
+			std::cerr << "RX fucked: " << bladerf_strerror(status);
+		if(meta.flags & BLADERF_META_STATUS_OVERRUN )
+			std::cerr << "RX fucked OVER: " << bladerf_strerror(status);
+
+		size_t num_smpls = meta.actual_count;
+;		ts = meta.timestamp;
+
+		for (size_t i = 0; i < rx_buffers.size(); i++) {
+			rc = rx_buffers[i]->write((short *) &pkt_bufs[i].front(),
+						  num_smpls,
+						  ts);
+
+			// Continue on local overrun, exit on other errors
+			if ((rc < 0)) {
+				LOGC(DDEV, ERROR) << rx_buffers[i]->str_code(rc);
+				LOGC(DDEV, ERROR) << rx_buffers[i]->str_status(timestamp);
+				if (rc != smpl_buf::ERROR_OVERFLOW)
+					return 0;
+			}
+		}
+		meta = {};
+		meta.timestamp = ts+num_smpls;
+	}
+
+	// We have enough samples
+	for (size_t i = 0; i < rx_buffers.size(); i++) {
+		rc = rx_buffers[i]->read(bufs[i], len, timestamp);
+		if ((rc < 0) || (rc != len)) {
+			LOGC(DDEV, ERROR) << rx_buffers[i]->str_code(rc);
+			LOGC(DDEV, ERROR) << rx_buffers[i]->str_status(timestamp);
+			return 0;
+		}
+	}
+
+	return len;
+}
+
+int blade_device::writeSamples(std::vector<short *> &bufs, int len, bool *underrun,
+			     unsigned long long timestamp)
+{
+	*underrun = false;
+	static bool first_tx = true;
+	struct bladerf_metadata meta = {};
+	if(first_tx) {
+		meta.timestamp = timestamp;
+		meta.flags = BLADERF_META_FLAG_TX_BURST_START;
+		first_tx = false;
+	}
+
+	thread_enable_cancel(false);
+	int status = bladerf_sync_tx(dev, (const void*)bufs[0], len, &meta, 200U);
+	//size_t num_smpls = tx_stream->send(bufs, len, metadata);
+	thread_enable_cancel(true);
+
+	if(status != 0)
+		std::cerr << "TX fucked: " << bladerf_strerror(status);
+
+	// LOGCHAN(0, DDEV, INFO) << "tx " << timestamp << " " << len << " t+l: "<< timestamp+len << std::endl;
+
+	return len;
+}
+
+bool blade_device::updateAlignment(TIMESTAMP timestamp)
+{
+	return true;
+}
+
+bool blade_device::set_freq(double freq, size_t chan, bool tx)
+{
+
+	if (tx) {
+		bladerf_set_frequency(dev, BLADERF_CHANNEL_TX(chan), freq);
+		bladerf_frequency f;
+		bladerf_get_frequency(dev,BLADERF_CHANNEL_TX(chan), &f);
+		tx_freqs[chan] = f;
+	} else {
+		bladerf_set_frequency(dev, BLADERF_CHANNEL_RX(chan), freq);
+		bladerf_frequency f;
+		bladerf_get_frequency(dev,BLADERF_CHANNEL_RX(chan), &f);
+		rx_freqs[chan] = f;
+	}
+	LOGCHAN(chan, DDEV, INFO) << "set_freq(" << freq << ", " << (tx  ? "TX" : "RX") << "): "  << std::endl;
+
+
+	return true;
+}
+
+bool blade_device::setTxFreq(double wFreq, size_t chan)
+{
+	uint16_t req_arfcn;
+	enum gsm_band req_band;
+
+	if (chan >= tx_freqs.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return false;
+	}
+	ScopedLock lock(tune_lock);
+
+	req_arfcn = gsm_freq102arfcn(wFreq / 1000 / 100 , 0);
+	if (req_arfcn == 0xffff) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown ARFCN for Tx Frequency " << wFreq / 1000 << " kHz";
+		return false;
+	}
+	if (gsm_arfcn2band_rc(req_arfcn, &req_band) < 0) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown GSM band for Tx Frequency " << wFreq
+					   << " Hz (ARFCN " << req_arfcn << " )";
+		return false;
+	}
+
+	if (!set_band(req_band))
+		return false;
+
+	if (!set_freq(wFreq, chan, true))
+		return false;
+
+	return true;
+}
+
+bool blade_device::setRxOffset(double wOffset, size_t chan)
+{
+	return true;
+}
+
+bool blade_device::setRxFreq(double wFreq, size_t chan)
+{
+	// uint16_t req_arfcn;
+	// enum gsm_band req_band;
+
+	// if (chan >= rx_freqs.size()) {
+	// 	LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+	// 	return false;
+	// }
+	// ScopedLock lock(tune_lock);
+
+	// req_arfcn = gsm_freq102arfcn(wFreq / 1000 / 100, 1);
+	// if (req_arfcn == 0xffff) {
+	// 	LOGCHAN(chan, DDEV, ALERT) << "Unknown ARFCN for Rx Frequency " << wFreq / 1000 << " kHz";
+	// 	return false;
+	// }
+	// if (gsm_arfcn2band_rc(req_arfcn, &req_band) < 0) {
+	// 	LOGCHAN(chan, DDEV, ALERT) << "Unknown GSM band for Rx Frequency " << wFreq
+	// 				   << " Hz (ARFCN " << req_arfcn << " )";
+	// 	return false;
+	// }
+
+	// if (!set_band(req_band))
+	// 	return false;
+
+	return set_freq(wFreq, chan, false);
+}
+
+double blade_device::getTxFreq(size_t chan)
+{
+	if (chan >= tx_freqs.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return 0.0;
+	}
+
+	return tx_freqs[chan];
+}
+
+double blade_device::getRxFreq(size_t chan)
+{
+	if (chan >= rx_freqs.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return 0.0;
+	}
+
+	return rx_freqs[chan];
+}
+
+bool blade_device::requiresRadioAlign()
+{
+	return false;
+}
+
+GSM::Time blade_device::minLatency() {
+	/* Empirical data from a handful of
+	relatively recent machines shows that the B100 will underrun when
+	the transmit threshold is reduced to a time of 6 and a half frames,
+	so we set a minimum 7 frame threshold. */
+	return GSM::Time(6,7);
+}
+
+TIMESTAMP blade_device::initialWriteTimestamp()
+{
+	return ts_initial;
+}
+
+TIMESTAMP blade_device::initialReadTimestamp()
+{
+	return ts_initial;
+}
+
+double blade_device::fullScaleInputValue()
+{
+		return (double) 2047;
+}
+
+double blade_device::fullScaleOutputValue()
+{
+	return (double) 2047;
+}
+
+
+#ifndef IPCMAGIC
+RadioDevice *RadioDevice::make(size_t tx_sps, size_t rx_sps,
+			       InterfaceType iface, size_t chans, double lo_offset,
+			       const std::vector<std::string>& tx_paths,
+			       const std::vector<std::string>& rx_paths)
+{
+	return new blade_device(tx_sps, rx_sps, iface, chans, lo_offset, tx_paths, rx_paths);
+}
+#endif

Transceiver52M/device/bladerf/bladerf.h

@@ -0,0 +1,172 @@
+/*
+ * Copyright 2022 sysmocom - s.f.m.c. GmbH
+ *
+ * Author: Eric Wild <ewild@sysmocom.de>
+ *
+ * SPDX-License-Identifier: AGPL-3.0+
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * See the COPYING file in the main directory for details.
+ */
+
+#pragma once
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "radioDevice.h"
+#include "smpl_buf.h"
+
+extern "C" {
+#include <osmocom/gsm/gsm_utils.h>
+}
+
+#include <bladerf.h>
+
+enum class blade_dev_type {
+	BLADE1,
+	BLADE2
+};
+
+struct dev_band_desc {
+	/* Maximum UHD Tx Gain which can be set/used without distorting the
+	   output signal, and the resulting real output power measured when that
+	   gain is used. Correct measured values only provided for B210 so far. */
+	double nom_uhd_tx_gain;  /* dB */
+	double nom_out_tx_power; /* dBm */
+	/* Factor used to infer base real RSSI offset on the Rx path based on current
+	   configured RxGain. The resulting rssiOffset is added to the per burst
+	   calculated energy in upper layers. These values were empirically
+	   found and may change based on multiple factors, see OS#4468.
+	   rssiOffset = rxGain + rxgain2rssioffset_rel;
+	*/
+	double rxgain2rssioffset_rel; /* dB */
+};
+
+class blade_device : public RadioDevice {
+public:
+	blade_device(size_t tx_sps, size_t rx_sps, InterfaceType type,
+		   size_t chan_num, double offset,
+		   const std::vector<std::string>& tx_paths,
+		   const std::vector<std::string>& rx_paths);
+	~blade_device();
+
+	int open(const std::string &args, int ref, bool swap_channels);
+	bool start();
+	bool stop();
+	bool restart();
+	enum TxWindowType getWindowType() { return tx_window; }
+
+	int readSamples(std::vector<short *> &bufs, int len, bool *overrun,
+			TIMESTAMP timestamp, bool *underrun);
+
+	int writeSamples(std::vector<short *> &bufs, int len, bool *underrun,
+			 TIMESTAMP timestamp);
+
+	bool updateAlignment(TIMESTAMP timestamp);
+
+	bool setTxFreq(double wFreq, size_t chan);
+	bool setRxFreq(double wFreq, size_t chan);
+
+	TIMESTAMP initialWriteTimestamp();
+	TIMESTAMP initialReadTimestamp();
+
+	double fullScaleInputValue();
+	double fullScaleOutputValue();
+
+	double setRxGain(double db, size_t chan);
+	double getRxGain(size_t chan);
+	double maxRxGain(void) { return rx_gain_max; }
+	double minRxGain(void) { return rx_gain_min; }
+	double rssiOffset(size_t chan);
+
+	double setPowerAttenuation(int atten, size_t chan);
+	double getPowerAttenuation(size_t chan = 0);
+
+	int getNominalTxPower(size_t chan = 0);
+
+	bool setRxOffset(double wOffset, size_t chan);
+	double getTxFreq(size_t chan);
+	double getRxFreq(size_t chan);
+	double getRxFreq();
+
+	bool setRxAntenna(const std::string &ant, size_t chan) { return {};};
+	std::string getRxAntenna(size_t chan) { return {};};
+	bool setTxAntenna(const std::string &ant, size_t chan) { return {};};
+	std::string getTxAntenna(size_t chan) { return {};};
+
+	bool requiresRadioAlign();
+
+	GSM::Time minLatency();
+
+	inline double getSampleRate() { return tx_rate; }
+
+	/** Receive and process asynchronous message
+	    @return true if message received or false on timeout or error
+	*/
+	bool recv_async_msg();
+
+	enum err_code {
+		ERROR_TIMING = -1,
+		ERROR_TIMEOUT = -2,
+		ERROR_UNRECOVERABLE = -3,
+		ERROR_UNHANDLED = -4,
+	};
+
+protected:
+	struct bladerf* dev;
+	void* usrp_dev;
+
+	enum TxWindowType tx_window;
+	enum blade_dev_type dev_type;
+
+	double tx_rate, rx_rate;
+
+	double rx_gain_min, rx_gain_max;
+
+	std::vector<double> tx_gains, rx_gains;
+	std::vector<double> tx_freqs, rx_freqs;
+	bool band_ass_curr_sess; /* true if  "band" was set after last POWEROFF */
+	enum gsm_band band;
+	struct dev_band_desc band_desc;
+	size_t tx_spp, rx_spp;
+
+	bool started;
+	bool aligned;
+
+	size_t drop_cnt;
+	uint64_t prev_ts;
+
+	TIMESTAMP ts_initial, ts_offset;
+	std::vector<smpl_buf *> rx_buffers;
+	/* Sample buffers used to receive samples: */
+	std::vector<std::vector<short> > pkt_bufs;
+	/* Used to call UHD API: Buffer pointer of each elem in pkt_ptrs will
+	   point to corresponding buffer of vector pkt_bufs. */
+	std::vector<short *> pkt_ptrs;
+
+	void init_gains();
+	void set_channels(bool swap);
+	void set_rates();
+	bool flush_recv(size_t num_pkts);
+
+	bool set_freq(double freq, size_t chan, bool tx);
+	void get_dev_band_desc(dev_band_desc& desc);
+	bool set_band(enum gsm_band req_band);
+	void assign_band_desc(enum gsm_band req_band);
+
+	Thread *async_event_thrd;
+	Mutex tune_lock;
+};

Transceiver52M/device/common/Makefile.am

@@ -1,7 +1,7 @@
 include $(top_srcdir)/Makefile.common
 
 AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES)
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS) $(LMS_CFLAGS)
+AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS)
 
 
 noinst_HEADERS = radioDevice.h smpl_buf.h

Transceiver52M/device/common/radioDevice.h

@@ -101,6 +101,9 @@ class RadioDevice {
   /** Set the receiver frequency */
   virtual bool setRxFreq(double wFreq, size_t chan = 0) = 0;
 
+  /** Adjust the receiver offset */
+  virtual bool setRxOffset(double wOffset, size_t chan = 0) = 0;
+
   /** Returns the starting write Timestamp*/
   virtual TIMESTAMP initialWriteTimestamp(void)=0;
 
@@ -125,17 +128,11 @@ class RadioDevice {
   /** return minimum Rx Gain **/
   virtual double minRxGain(void) = 0;
 
-  /** sets the transmit chan gain, returns the gain setting **/
-  virtual double setTxGain(double dB, size_t chan = 0) = 0;
+  /** return base RSSI offset to apply for received samples **/
+  virtual double rssiOffset(size_t chan) = 0;
 
-  /** get transmit gain */
-  virtual double getTxGain(size_t chan = 0) = 0;
-
-  /** return maximum Tx Gain **/
-  virtual double maxTxGain(void) = 0;
-
-  /** return minimum Tx Gain **/
-  virtual double minTxGain(void) = 0;
+  /** returns the Nominal transmit output power of the transceiver in dBm, negative on error **/
+  virtual int getNominalTxPower(size_t chan = 0) = 0;
 
   /** sets the RX path to use, returns true if successful and false otherwise */
   virtual bool setRxAntenna(const std::string &ant, size_t chan = 0) = 0;
@@ -160,6 +157,9 @@ class RadioDevice {
   virtual double getRxFreq(size_t chan = 0) = 0;
   virtual double getSampleRate()=0;
 
+  virtual double setPowerAttenuation(int atten, size_t chan) = 0;
+  virtual double getPowerAttenuation(size_t chan=0) = 0;
+
   protected:
   size_t tx_sps, rx_sps;
   InterfaceType iface;
@@ -172,14 +172,13 @@ class RadioDevice {
               const std::vector<std::string>& tx_paths,
               const std::vector<std::string>& rx_paths):
 		tx_sps(tx_sps), rx_sps(rx_sps), iface(type), chans(chan_num), lo_offset(offset),
-		tx_paths(tx_paths), rx_paths(rx_paths)
+		tx_paths(tx_paths), rx_paths(rx_paths), m_ctr(chans)
 	{
 		if (iface == MULTI_ARFCN) {
 			LOGC(DDEV, INFO) << "Multi-ARFCN: "<< chan_num << " logical chans -> 1 physical chans";
 			chans = 1;
 		}
 
-		m_ctr.resize(chans);
 		for (size_t i = 0; i < chans; i++) {
 			memset(&m_ctr[i], 0, sizeof(m_ctr[i]));
 			m_ctr[i].chan = i;
@@ -192,6 +191,13 @@ class RadioDevice {
 	for (i = 0; i < tx_paths.size(); i++) {
 		if (tx_paths[i] == "")
 			continue;
+		if (iface == MULTI_ARFCN && i > 0) {
+			LOGCHAN(i, DDEV, NOTICE) << "Not setting Tx antenna "
+						 << tx_paths[i]
+						 << " for a logical channel";
+			continue;
+		}
+
 		LOGCHAN(i, DDEV, DEBUG) << "Configuring Tx antenna " << tx_paths[i];
 		if (!setTxAntenna(tx_paths[i], i)) {
 			LOGCHAN(i, DDEV, ALERT) << "Failed configuring Tx antenna " << tx_paths[i];
@@ -202,6 +208,13 @@ class RadioDevice {
 	for (i = 0; i < rx_paths.size(); i++) {
 		if (rx_paths[i] == "")
 			continue;
+		if (iface == MULTI_ARFCN && i > 0) {
+			LOGCHAN(i, DDEV, NOTICE) << "Not setting Rx antenna "
+						 << rx_paths[i]
+						 << " for a logical channel";
+			continue;
+		}
+
 		LOGCHAN(i, DDEV, DEBUG) << "Configuring Rx antenna " << rx_paths[i];
 		if (!setRxAntenna(rx_paths[i], i)) {
 			LOGCHAN(i, DDEV, ALERT) << "Failed configuring Rx antenna " << rx_paths[i];

Transceiver52M/device/common/smpl_buf.cpp

@@ -28,9 +28,9 @@
 #include <inttypes.h>
 
 smpl_buf::smpl_buf(size_t len)
-	: buf_len(len), time_start(0), time_end(0),
-	  data_start(0), data_end(0)
+	: buf_len(len)
 {
+	reset();
 	data = new uint32_t[len];
 }
 
@@ -39,6 +39,14 @@ smpl_buf::~smpl_buf()
 	delete[] data;
 }
 
+void smpl_buf::reset()
+{
+	time_start = 0;
+	time_end = 0;
+	data_start = 0;
+	data_end = 0;
+}
+
 ssize_t smpl_buf::avail_smpls(TIMESTAMP timestamp) const
 {
 	if (timestamp < time_start)

Transceiver52M/device/common/smpl_buf.h

@@ -44,6 +44,10 @@ public:
 	smpl_buf(size_t len);
 	~smpl_buf();
 
+	/** Reset this buffer, keeps the size
+	*/
+	void reset();
+
 	/** Query number of samples available for reading
 	    @param timestamp time of first sample
 	    @return number of available samples or error

Transceiver52M/device/ipc/IPCDevice.h

@@ -0,0 +1,244 @@
+/*
+* Copyright 2020 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+* Author: Pau Espin Pedrol <pespin@sysmocom.de>
+*
+* SPDX-License-Identifier: AGPL-3.0+
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Affero General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Affero General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* See the COPYING file in the main directory for details.
+*/
+
+#ifndef _IPC_DEVICE_H_
+#define _IPC_DEVICE_H_
+
+#include <cstdint>
+#include <cstddef>
+#include <climits>
+#include <string>
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+extern "C" {
+#include <osmocom/core/select.h>
+#include <osmocom/core/timer.h>
+#include "shm.h"
+}
+
+#include "radioDevice.h"
+
+class smpl_buf;
+
+#define IPC_MAX_NUM_TRX 8
+
+struct ipc_per_trx_sock_state {
+	struct osmo_fd conn_bfd; /* fd for connection to the BTS */
+	struct osmo_timer_list timer; /* socket connect retry timer */
+	struct llist_head upqueue; /* queue for sending messages */
+	uint32_t messages_processed_mask; // (=| IPC_IF_MSG_xxx-IPC_IF_CHAN_MSG_OFFSET) bitmask
+	ipc_per_trx_sock_state() : conn_bfd(), timer(), upqueue(), messages_processed_mask()
+	{
+		conn_bfd.fd = -1;
+	}
+};
+
+class IPCDevice : public RadioDevice {
+    protected:
+	struct ipc_per_trx_sock_state master_sk_state;
+
+	std::vector<struct ipc_per_trx_sock_state> sk_chan_state;
+
+	uint32_t tx_attenuation[IPC_MAX_NUM_TRX];
+	uint8_t tmp_state;
+	char shm_name[SHM_NAME_MAX];
+	int ipc_shm_connect(const char *shm_name);
+	void *shm;
+	struct ipc_shm_region *shm_dec;
+
+	std::vector<smpl_buf *> rx_buffers;
+	double actualSampleRate;
+
+	bool started;
+
+	TIMESTAMP ts_initial, ts_offset;
+
+	std::vector<double> tx_gains, rx_gains;
+
+	struct ipc_sk_if_info_req current_info_req;
+	struct ipc_sk_if_info_cnf current_info_cnf;
+	struct ipc_sk_if_open_cnf current_open_cnf;
+
+	std::vector<struct ipc_shm_io *> shm_io_rx_streams;
+	std::vector<struct ipc_shm_io *> shm_io_tx_streams;
+
+	bool flush_recv(size_t num_pkts);
+	void update_stream_stats_rx(size_t chan, bool *overrun);
+	void update_stream_stats_tx(size_t chan, bool *underrun);
+	void manually_poll_sock_fds();
+
+	void ipc_sock_close(ipc_per_trx_sock_state *state);
+
+	int ipc_rx(uint8_t msg_type, struct ipc_sk_if *ipc_prim);
+	int ipc_rx_greeting_cnf(const struct ipc_sk_if_greeting *greeting_cnf);
+	int ipc_rx_info_cnf(const struct ipc_sk_if_info_cnf *info_cnf);
+	int ipc_rx_open_cnf(const struct ipc_sk_if_open_cnf *open_cnf);
+	int ipc_tx_open_req(struct ipc_per_trx_sock_state *state, uint32_t num_chans, uint32_t ref);
+
+	int ipc_chan_rx(uint8_t msg_type, ipc_sk_chan_if *ipc_prim, uint8_t chan_nr);
+	int ipc_rx_chan_start_cnf(ipc_sk_chan_if_op_rc *ret, uint8_t chan_nr);
+	int ipc_rx_chan_stop_cnf(ipc_sk_chan_if_op_rc *ret, uint8_t chan_nr);
+	int ipc_rx_chan_setgain_cnf(ipc_sk_chan_if_gain *ret, uint8_t chan_nr);
+	int ipc_rx_chan_setfreq_cnf(ipc_sk_chan_if_freq_cnf *ret, uint8_t chan_nr);
+	int ipc_rx_chan_notify_underflow(ipc_sk_chan_if_notfiy *ret, uint8_t chan_nr);
+	int ipc_rx_chan_notify_overflow(ipc_sk_chan_if_notfiy *ret, uint8_t chan_nr);
+	int ipc_rx_chan_settxattn_cnf(ipc_sk_chan_if_tx_attenuation *ret, uint8_t chan_nr);
+
+	bool send_chan_wait_rsp(uint32_t chan, struct msgb *msg_to_send, uint32_t expected_rsp_msg_id);
+	bool send_all_chan_wait_rsp(uint32_t msgid_to_send, uint32_t msgid_to_expect);
+
+    public:
+	int ipc_sock_read(struct osmo_fd *bfd);
+	int ipc_sock_write(struct osmo_fd *bfd);
+	int ipc_chan_sock_read(osmo_fd *bfd);
+	int ipc_chan_sock_write(osmo_fd *bfd);
+
+	/** Object constructor */
+	IPCDevice(size_t tx_sps, size_t rx_sps, InterfaceType iface, size_t chan_num, double lo_offset,
+		  const std::vector<std::string> &tx_paths, const std::vector<std::string> &rx_paths);
+	virtual ~IPCDevice() override;
+
+	/** Instantiate the IPC */
+	virtual int open(const std::string &args, int ref, bool swap_channels) override;
+
+	/** Start the IPC */
+	virtual bool start() override;
+
+	/** Stop the IPC */
+	virtual bool stop() override;
+
+	/* FIXME: any != USRP1 will do for now... */
+	enum TxWindowType getWindowType() override
+	{
+		return TX_WINDOW_LMS1;
+	}
+
+	/**
+	Read samples from the IPC.
+	@param buf preallocated buf to contain read result
+	@param len number of samples desired
+	@param overrun Set if read buffer has been overrun, e.g. data not being read fast enough
+	@param timestamp The timestamp of the first samples to be read
+	@param underrun Set if IPC does not have data to transmit, e.g. data not being sent fast enough
+	@return The number of samples actually read
+	*/
+	virtual int readSamples(std::vector<short *> &buf, int len, bool *overrun, TIMESTAMP timestamp = 0xffffffff,
+				bool *underrun = NULL) override;
+	/**
+	Write samples to the IPC.
+	@param buf Contains the data to be written.
+	@param len number of samples to write.
+	@param underrun Set if IPC does not have data to transmit, e.g. data not being sent fast enough
+	@param timestamp The timestamp of the first sample of the data buffer.
+	@return The number of samples actually written
+	*/
+	virtual int writeSamples(std::vector<short *> &bufs, int len, bool *underrun,
+				 TIMESTAMP timestamp = 0xffffffff) override;
+
+	/** Update the alignment between the read and write timestamps */
+	virtual bool updateAlignment(TIMESTAMP timestamp) override;
+
+	/** Set the transmitter frequency */
+	virtual bool setTxFreq(double wFreq, size_t chan = 0) override;
+
+	/** Set the receiver frequency */
+	virtual bool setRxFreq(double wFreq, size_t chan = 0) override;
+
+	/** Returns the starting write Timestamp*/
+	virtual TIMESTAMP initialWriteTimestamp(void) override;
+
+	/** Returns the starting read Timestamp*/
+	virtual TIMESTAMP initialReadTimestamp(void) override;
+
+	/** returns the full-scale transmit amplitude **/
+	virtual double fullScaleInputValue() override
+	{
+		return (double)SHRT_MAX * current_info_cnf.iq_scaling_val_rx;
+	}
+
+	/** returns the full-scale receive amplitude **/
+	virtual double fullScaleOutputValue() override
+	{
+		return (double)SHRT_MAX * current_info_cnf.iq_scaling_val_tx;
+	}
+
+	/** sets the receive chan gain, returns the gain setting **/
+	virtual double setRxGain(double dB, size_t chan = 0) override;
+
+	/** get the current receive gain */
+	virtual double getRxGain(size_t chan = 0) override
+	{
+		return rx_gains[chan];
+	}
+
+	/** return maximum Rx Gain **/
+	virtual double maxRxGain(void) override;
+
+	/** return minimum Rx Gain **/
+	virtual double minRxGain(void) override;
+
+	/* FIXME: return rx_gains[chan] ? receive factor from IPC Driver? */
+	double rssiOffset(size_t chan) { return 0.0f; };
+
+	double setPowerAttenuation(int atten, size_t chan) override;
+	double getPowerAttenuation(size_t chan = 0) override;
+
+	virtual int getNominalTxPower(size_t chan = 0) override;
+
+	/** sets the RX path to use, returns true if successful and false otherwise */
+	virtual bool setRxAntenna(const std::string &ant, size_t chan = 0) override;
+
+	/* return the used RX path */
+	virtual std::string getRxAntenna(size_t chan = 0) override;
+
+	/** sets the RX path to use, returns true if successful and false otherwise */
+	virtual bool setTxAntenna(const std::string &ant, size_t chan = 0) override;
+
+	/* return the used RX path */
+	virtual std::string getTxAntenna(size_t chan = 0) override;
+
+	/** return whether user drives synchronization of Tx/Rx of USRP */
+	virtual bool requiresRadioAlign() override;
+
+	/** return whether user drives synchronization of Tx/Rx of USRP */
+	virtual GSM::Time minLatency() override;
+
+	bool setRxOffset(double wOffset, size_t chan = 0) override {return true;}
+
+	/** Return internal status values */
+	virtual inline double getTxFreq(size_t chan = 0) override
+	{
+		return 0;
+	}
+	virtual inline double getRxFreq(size_t chan = 0) override
+	{
+		return 0;
+	}
+	virtual inline double getSampleRate() override
+	{
+		return actualSampleRate;
+	}
+};
+
+#endif // _IPC_DEVICE_H_

Transceiver52M/device/ipc/Makefile.am

@@ -0,0 +1,43 @@
+include $(top_srcdir)/Makefile.common
+
+AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/../common
+AM_CFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS)
+AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS)
+AM_LDFLAGS = -lpthread -lrt
+
+noinst_HEADERS = IPCDevice.h shm.h ipc_shm.h ipc_chan.h ipc_sock.h
+
+if DEVICE_UHD
+noinst_HEADERS += ../uhd/UHDDevice.h uhdwrap.h ipc-driver-test.h
+endif
+
+noinst_LTLIBRARIES = libdevice.la
+
+libdevice_la_SOURCES = IPCDevice.cpp shm.c ipc_shm.c ipc_chan.c ipc_sock.c
+libdevice_la_LIBADD = $(top_builddir)/Transceiver52M/device/common/libdevice_common.la
+libdevice_la_CXXFLAGS = $(AM_CXXFLAGS) -DIPCMAGIC
+
+#work around distclean issue on older autotools vers:
+#a direct build of ../uhd/UHDDevice.cpp tries to clean
+#../uhd/.dep/UHDDevice.Plo twice and fails
+uhddev_ipc.cpp:
+	echo "#include \"../uhd/UHDDevice.cpp\"" >$@
+CLEANFILES= uhddev_ipc.cpp
+BUILT_SOURCES = uhddev_ipc.cpp
+
+if DEVICE_UHD
+
+bin_PROGRAMS = ipc-driver-test
+#ipc_driver_test_SHORTNAME = drvt
+ipc_driver_test_SOURCES = ipc-driver-test.c uhdwrap.cpp ipc_shm.c ipc_chan.c ipc_sock.c uhddev_ipc.cpp
+ipc_driver_test_LDADD = \
+        shm.lo \
+	$(top_builddir)/Transceiver52M/device/common/libdevice_common.la \
+	$(COMMON_LA)
+	$(LIBOSMOCORE_LIBS) \
+	$(NULL)
+ipc_driver_test_CXXFLAGS = $(AM_CXXFLAGS) $(UHD_CFLAGS)
+ipc_driver_test_CPPFLAGS  = $(AM_CPPFLAGS) $(UHD_CFLAGS)
+ipc_driver_test_CFLAGS  = $(AM_CFLAGS) $(UHD_CFLAGS)
+ipc_driver_test_LDFLAGS  = $(AM_LDFLAGS) $(UHD_LIBS)
+endif

Transceiver52M/device/ipc/ipc-driver-test.c

@@ -0,0 +1,492 @@
+/*
+* Copyright 2020 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+* Author: Pau Espin Pedrol <pespin@sysmocom.de>
+*
+* SPDX-License-Identifier: 0BSD
+*
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#define _GNU_SOURCE
+#include <pthread.h>
+
+#include <debug.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <inttypes.h>
+#include <sys/mman.h>
+#include <sys/stat.h> /* For mode constants */
+#include <fcntl.h> /* For O_* constants */
+#include <getopt.h>
+
+#include <osmocom/core/application.h>
+#include <osmocom/core/talloc.h>
+#include <osmocom/core/select.h>
+#include <osmocom/core/socket.h>
+#include <osmocom/core/logging.h>
+#include <osmocom/core/utils.h>
+#include <osmocom/core/msgb.h>
+#include <osmocom/core/select.h>
+#include <osmocom/core/timer.h>
+
+#include "shm.h"
+#include "ipc_shm.h"
+#include "ipc_chan.h"
+#include "ipc_sock.h"
+
+#define DEFAULT_SHM_NAME "/osmo-trx-ipc-driver-shm2"
+#define IPC_SOCK_PATH_PREFIX "/tmp"
+
+static void *tall_ctx;
+struct ipc_sock_state *global_ipc_sock_state;
+
+/* 8 channels are plenty */
+struct ipc_sock_state *global_ctrl_socks[8];
+struct ipc_shm_io *ios_tx_to_device[8];
+struct ipc_shm_io *ios_rx_from_device[8];
+
+void *shm;
+void *global_dev;
+
+static struct ipc_shm_region *decoded_region;
+
+static struct {
+	int msocknum;
+	char *ud_prefix_dir;
+} cmdline_cfg;
+
+static const struct log_info_cat default_categories[] = {
+	[DMAIN] = {
+		.name = "DMAIN",
+		.color = NULL,
+		.description = "Main generic category",
+		.loglevel = LOGL_DEBUG,.enabled = 1,
+	},
+	[DDEV] = {
+		.name = "DDEV",
+		.description = "Device/Driver specific code",
+		.color = NULL,
+		.enabled = 1, .loglevel = LOGL_DEBUG,
+	},
+};
+
+const struct log_info log_infox = {
+	.cat = default_categories,
+	.num_cat = ARRAY_SIZE(default_categories),
+};
+
+#include "uhdwrap.h"
+
+volatile int ipc_exit_requested = 0;
+
+static int ipc_shm_setup(const char *shm_name, size_t shm_len)
+{
+	int fd;
+	int rc;
+
+	LOGP(DMAIN, LOGL_NOTICE, "Opening shm path %s\n", shm_name);
+	if ((fd = shm_open(shm_name, O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR)) < 0) {
+		LOGP(DMAIN, LOGL_ERROR, "shm_open %d: %s\n", errno, strerror(errno));
+		rc = -errno;
+		goto err_shm_open;
+	}
+
+	LOGP(DMAIN, LOGL_NOTICE, "Truncating %d to size %zu\n", fd, shm_len);
+	if (ftruncate(fd, shm_len) < 0) {
+		LOGP(DMAIN, LOGL_ERROR, "ftruncate %d: %s\n", errno, strerror(errno));
+		rc = -errno;
+		goto err_mmap;
+	}
+
+	LOGP(DMAIN, LOGL_NOTICE, "mmaping shared memory fd %d\n", fd);
+	if ((shm = mmap(NULL, shm_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+		LOGP(DMAIN, LOGL_ERROR, "mmap %d: %s\n", errno, strerror(errno));
+		rc = -errno;
+		goto err_mmap;
+	}
+
+	LOGP(DMAIN, LOGL_NOTICE, "mmap'ed shared memory at addr %p\n", shm);
+	/* After a call to mmap(2) the file descriptor may be closed without affecting the memory mapping. */
+	close(fd);
+	return 0;
+err_mmap:
+	shm_unlink(shm_name);
+	close(fd);
+err_shm_open:
+	return rc;
+}
+
+struct msgb *ipc_msgb_alloc(uint8_t msg_type)
+{
+	struct msgb *msg;
+	struct ipc_sk_if *ipc_prim;
+
+	msg = msgb_alloc(sizeof(struct ipc_sk_if) + 1000, "ipc_sock_tx");
+	if (!msg)
+		return NULL;
+	msgb_put(msg, sizeof(struct ipc_sk_if) + 1000);
+	ipc_prim = (struct ipc_sk_if *)msg->data;
+	ipc_prim->msg_type = msg_type;
+
+	return msg;
+}
+
+static int ipc_tx_greeting_cnf(uint8_t req_version)
+{
+	struct msgb *msg;
+	struct ipc_sk_if *ipc_prim;
+
+	msg = ipc_msgb_alloc(IPC_IF_MSG_GREETING_CNF);
+	if (!msg)
+		return -ENOMEM;
+	ipc_prim = (struct ipc_sk_if *)msg->data;
+	ipc_prim->u.greeting_cnf.req_version = req_version;
+
+	return ipc_sock_send(msg);
+}
+
+static int ipc_tx_info_cnf()
+{
+	struct msgb *msg;
+	struct ipc_sk_if *ipc_prim;
+
+	msg = ipc_msgb_alloc(IPC_IF_MSG_INFO_CNF);
+	if (!msg)
+		return -ENOMEM;
+	ipc_prim = (struct ipc_sk_if *)msg->data;
+
+	uhdwrap_fill_info_cnf(ipc_prim);
+
+	return ipc_sock_send(msg);
+}
+
+static int ipc_tx_open_cnf(int rc, uint32_t num_chans, int32_t timingoffset)
+{
+	struct msgb *msg;
+	struct ipc_sk_if *ipc_prim;
+	struct ipc_sk_if_open_cnf_chan *chan_info;
+	unsigned int i;
+
+	msg = ipc_msgb_alloc(IPC_IF_MSG_OPEN_CNF);
+	if (!msg)
+		return -ENOMEM;
+	ipc_prim = (struct ipc_sk_if *)msg->data;
+	ipc_prim->u.open_cnf.return_code = rc;
+	ipc_prim->u.open_cnf.path_delay = timingoffset; // 6.18462e-5 * 1625e3 / 6;
+	OSMO_STRLCPY_ARRAY(ipc_prim->u.open_cnf.shm_name, DEFAULT_SHM_NAME);
+
+	chan_info = ipc_prim->u.open_cnf.chan_info;
+	for (i = 0; i < num_chans; i++) {
+		snprintf(chan_info->chan_ipc_sk_path, sizeof(chan_info->chan_ipc_sk_path),"%s/ipc_sock%d_%d",
+			 cmdline_cfg.ud_prefix_dir, cmdline_cfg.msocknum, i);
+		/* FIXME: dynamc chan limit, currently 8 */
+		if (i < 8)
+			ipc_sock_init(chan_info->chan_ipc_sk_path, &global_ctrl_socks[i], ipc_chan_sock_accept, i);
+		chan_info++;
+	}
+
+	return ipc_sock_send(msg);
+}
+
+int ipc_rx_greeting_req(struct ipc_sk_if_greeting *greeting_req)
+{
+	if (greeting_req->req_version == IPC_SOCK_API_VERSION)
+		ipc_tx_greeting_cnf(IPC_SOCK_API_VERSION);
+	else
+		ipc_tx_greeting_cnf(0);
+	return 0;
+}
+
+int ipc_rx_info_req(struct ipc_sk_if_info_req *info_req)
+{
+	ipc_tx_info_cnf();
+	return 0;
+}
+
+int ipc_rx_open_req(struct ipc_sk_if_open_req *open_req)
+{
+	/* calculate size needed */
+	unsigned int len;
+	unsigned int i;
+
+	global_dev = uhdwrap_open(open_req);
+
+	/* b210 packet size is 2040, but our tx size is 2500, so just do *2 */
+	int shmbuflen = uhdwrap_get_bufsizerx(global_dev) * 2;
+
+	len = ipc_shm_encode_region(NULL, open_req->num_chans, 4, shmbuflen);
+	/* Here we verify num_chans, rx_path, tx_path, clockref, etc. */
+	int rc = ipc_shm_setup(DEFAULT_SHM_NAME, len);
+	len = ipc_shm_encode_region((struct ipc_shm_raw_region *)shm, open_req->num_chans, 4, shmbuflen);
+	//	LOGP(DMAIN, LOGL_NOTICE, "%s\n", osmo_hexdump((const unsigned char *)shm, 80));
+
+	/* set up our own copy of the decoded area, we have to do it here,
+	* since the uhd wrapper does not allow starting single channels
+	* additionally go for the producer init for both, so only we are responsible for the init, instead
+	* of splitting it with the client and causing potential races if one side uses it too early */
+	decoded_region = ipc_shm_decode_region(0, (struct ipc_shm_raw_region *)shm);
+	for (i = 0; i < open_req->num_chans; i++) {
+		//		ios_tx_to_device[i] = ipc_shm_init_consumer(decoded_region->channels[i]->dl_stream);
+		ios_tx_to_device[i] = ipc_shm_init_producer(decoded_region->channels[i]->dl_stream);
+		ios_rx_from_device[i] = ipc_shm_init_producer(decoded_region->channels[i]->ul_stream);
+	}
+
+	ipc_tx_open_cnf(-rc, open_req->num_chans, uhdwrap_get_timingoffset(global_dev));
+	return 0;
+}
+
+volatile bool ul_running = false;
+volatile bool dl_running = false;
+
+void *uplink_thread(void *x_void_ptr)
+{
+	uint32_t chann = decoded_region->num_chans;
+	ul_running = true;
+	pthread_setname_np(pthread_self(), "uplink_rx");
+
+	while (!ipc_exit_requested) {
+		int32_t read = uhdwrap_read(global_dev, chann);
+		if (read < 0)
+			return 0;
+	}
+	return 0;
+}
+
+void *downlink_thread(void *x_void_ptr)
+{
+	int chann = decoded_region->num_chans;
+	dl_running = true;
+	pthread_setname_np(pthread_self(), "downlink_tx");
+
+	while (!ipc_exit_requested) {
+		bool underrun;
+		uhdwrap_write(global_dev, chann, &underrun);
+	}
+	return 0;
+}
+
+int ipc_rx_chan_start_req(struct ipc_sk_chan_if_op_void *req, uint8_t chan_nr)
+{
+	struct msgb *msg;
+	struct ipc_sk_chan_if *ipc_prim;
+	int rc = 0;
+
+	rc = uhdwrap_start(global_dev, chan_nr);
+
+	/* no per-chan start/stop */
+	if (!dl_running || !ul_running) {
+		/* chan != first chan start will "fail", which is fine, usrp can't start/stop chans independently */
+		if (rc) {
+			LOGP(DMAIN, LOGL_INFO, "starting rx/tx threads.. req for chan:%d\n", chan_nr);
+			pthread_t rx, tx;
+			pthread_create(&rx, NULL, uplink_thread, 0);
+			pthread_create(&tx, NULL, downlink_thread, 0);
+		}
+	} else
+		LOGP(DMAIN, LOGL_INFO, "starting rx/tx threads request ignored.. req for chan:%d\n", chan_nr);
+
+	msg = ipc_msgb_alloc(IPC_IF_MSG_START_CNF);
+	if (!msg)
+		return -ENOMEM;
+	ipc_prim = (struct ipc_sk_chan_if *)msg->data;
+	ipc_prim->u.start_cnf.return_code = rc ? 0 : -1;
+
+	return ipc_chan_sock_send(msg, chan_nr);
+}
+int ipc_rx_chan_stop_req(struct ipc_sk_chan_if_op_void *req, uint8_t chan_nr)
+{
+	struct msgb *msg;
+	struct ipc_sk_chan_if *ipc_prim;
+	int rc;
+
+	/* no per-chan start/stop */
+	rc = uhdwrap_stop(global_dev, chan_nr);
+
+	msg = ipc_msgb_alloc(IPC_IF_MSG_STOP_CNF);
+	if (!msg)
+		return -ENOMEM;
+	ipc_prim = (struct ipc_sk_chan_if *)msg->data;
+	ipc_prim->u.stop_cnf.return_code = rc ? 0 : -1;
+
+	return ipc_chan_sock_send(msg, chan_nr);
+}
+int ipc_rx_chan_setgain_req(struct ipc_sk_chan_if_gain *req, uint8_t chan_nr)
+{
+	struct msgb *msg;
+	struct ipc_sk_chan_if *ipc_prim;
+	double rv;
+
+	rv = uhdwrap_set_gain(global_dev, req->gain, chan_nr, req->is_tx);
+
+	msg = ipc_msgb_alloc(IPC_IF_MSG_SETGAIN_CNF);
+	if (!msg)
+		return -ENOMEM;
+	ipc_prim = (struct ipc_sk_chan_if *)msg->data;
+	ipc_prim->u.set_gain_cnf.is_tx = req->is_tx;
+	ipc_prim->u.set_gain_cnf.gain = rv;
+
+	return ipc_chan_sock_send(msg, chan_nr);
+}
+
+int ipc_rx_chan_setfreq_req(struct ipc_sk_chan_if_freq_req *req, uint8_t chan_nr)
+{
+	struct msgb *msg;
+	struct ipc_sk_chan_if *ipc_prim;
+	bool rv;
+
+	rv = uhdwrap_set_freq(global_dev, req->freq, chan_nr, req->is_tx);
+
+	msg = ipc_msgb_alloc(IPC_IF_MSG_SETFREQ_CNF);
+	if (!msg)
+		return -ENOMEM;
+	ipc_prim = (struct ipc_sk_chan_if *)msg->data;
+	ipc_prim->u.set_freq_cnf.return_code = rv ? 0 : 1;
+
+	return ipc_chan_sock_send(msg, chan_nr);
+}
+
+int ipc_rx_chan_settxatten_req(struct ipc_sk_chan_if_tx_attenuation *req, uint8_t chan_nr)
+{
+	struct msgb *msg;
+	struct ipc_sk_chan_if *ipc_prim;
+	double rv;
+
+	rv = uhdwrap_set_txatt(global_dev, req->attenuation, chan_nr);
+
+	msg = ipc_msgb_alloc(IPC_IF_MSG_SETTXATTN_CNF);
+	if (!msg)
+		return -ENOMEM;
+	ipc_prim = (struct ipc_sk_chan_if *)msg->data;
+	ipc_prim->u.txatten_cnf.attenuation = rv;
+
+	return ipc_chan_sock_send(msg, chan_nr);
+}
+
+int ipc_sock_init(const char *path, struct ipc_sock_state **global_state_var,
+		  int (*sock_callback_fn)(struct osmo_fd *fd, unsigned int what), int n)
+{
+	struct ipc_sock_state *state;
+	struct osmo_fd *bfd;
+	int rc;
+
+	state = talloc_zero(NULL, struct ipc_sock_state);
+	if (!state)
+		return -ENOMEM;
+	*global_state_var = state;
+
+	INIT_LLIST_HEAD(&state->upqueue);
+	state->conn_bfd.fd = -1;
+
+	bfd = &state->listen_bfd;
+
+	bfd->fd = osmo_sock_unix_init(SOCK_SEQPACKET, 0, path, OSMO_SOCK_F_BIND);
+	if (bfd->fd < 0) {
+		LOGP(DMAIN, LOGL_ERROR, "Could not create %s unix socket: %s\n", path, strerror(errno));
+		talloc_free(state);
+		return -1;
+	}
+
+	osmo_fd_setup(bfd, bfd->fd, OSMO_FD_READ, sock_callback_fn, state, n);
+
+	rc = osmo_fd_register(bfd);
+	if (rc < 0) {
+		LOGP(DMAIN, LOGL_ERROR, "Could not register listen fd: %d\n", rc);
+		close(bfd->fd);
+		talloc_free(state);
+		return rc;
+	}
+
+	LOGP(DMAIN, LOGL_INFO, "Started listening on IPC socket: %s\n", path);
+
+	return 0;
+}
+
+static void print_help(void)
+{
+	printf("ipc-driver-test Usage:\n"
+	       " -h  --help		This message\n"
+	       " -u  --unix-sk-dir DIR	Existing directory where to create the Master socket\n"
+	       " -n  --sock-num NR	Master socket suffix number NR\n");
+}
+
+static void handle_options(int argc, char **argv)
+{
+	while (1) {
+		int option_index = 0, c;
+		const struct option long_options[] = { { "help", 0, 0, 'h' },
+						       { "unix-sk-dir", 1, 0, 'u' },
+						       { "sock-num", 1, 0, 'n' },
+						       { 0, 0, 0, 0 } };
+
+		c = getopt_long(argc, argv, "hu:n:", long_options, &option_index);
+		if (c == -1)
+			break;
+
+		switch (c) {
+		case 'h':
+			print_help();
+			exit(0);
+			break;
+		case 'u':
+			cmdline_cfg.ud_prefix_dir = talloc_strdup(tall_ctx, optarg);
+			break;
+		case 'n':
+			cmdline_cfg.msocknum = atoi(optarg);
+			break;
+
+		default:
+			exit(2);
+			break;
+		}
+	}
+
+	if (argc > optind) {
+		fprintf(stderr, "Unsupported positional arguments on command line\n");
+		exit(2);
+	}
+}
+
+int main(int argc, char **argv)
+{
+	char ipc_msock_path[128];
+	tall_ctx = talloc_named_const(NULL, 0, "OsmoTRX");
+	msgb_talloc_ctx_init(tall_ctx, 0);
+	osmo_init_logging2(tall_ctx, &log_infox);
+	log_enable_multithread();
+
+	handle_options(argc, argv);
+
+	if (!cmdline_cfg.ud_prefix_dir)
+		cmdline_cfg.ud_prefix_dir = talloc_strdup(tall_ctx, IPC_SOCK_PATH_PREFIX);
+
+
+	snprintf(ipc_msock_path, sizeof(ipc_msock_path), "%s/ipc_sock%d", cmdline_cfg.ud_prefix_dir, cmdline_cfg.msocknum);
+
+	LOGP(DMAIN, LOGL_INFO, "Starting %s\n", argv[0]);
+	ipc_sock_init(ipc_msock_path, &global_ipc_sock_state, ipc_sock_accept, 0);
+	while (!ipc_exit_requested)
+		osmo_select_main(0);
+
+	if (global_dev) {
+		unsigned int i;
+		for (i = 0; i < decoded_region->num_chans; i++)
+			uhdwrap_stop(global_dev, i);
+	}
+
+	ipc_sock_close(global_ipc_sock_state);
+	return 0;
+}

Transceiver52M/device/ipc/ipc-driver-test.h

@@ -0,0 +1,45 @@
+/*
+* Copyright 2020 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+* Author: Pau Espin Pedrol <pespin@sysmocom.de>
+*
+* SPDX-License-Identifier: 0BSD
+*
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+#pragma once
+
+#include <osmocom/core/select.h>
+#include "shm.h"
+
+extern struct ipc_sock_state *global_ipc_sock_state;
+
+/* 8 channels are plenty */
+extern struct ipc_sock_state *global_ctrl_socks[8];
+extern struct ipc_shm_io *ios_tx_to_device[8];
+extern struct ipc_shm_io *ios_rx_from_device[8];
+
+struct ipc_sock_state {
+	struct osmo_fd listen_bfd; /* fd for listen socket */
+	struct osmo_fd conn_bfd; /* fd for connection */
+	struct llist_head upqueue; /* queue for sending messages */
+};
+
+int ipc_sock_init(const char *path, struct ipc_sock_state **global_state_var,
+		  int (*sock_callback_fn)(struct osmo_fd *fd, unsigned int what), int n);
+
+int ipc_rx_greeting_req(struct ipc_sk_if_greeting *greeting_req);
+int ipc_rx_info_req(struct ipc_sk_if_info_req *info_req);
+int ipc_rx_open_req(struct ipc_sk_if_open_req *open_req);
+
+int ipc_rx_chan_start_req(struct ipc_sk_chan_if_op_void *req, uint8_t chan_nr);
+int ipc_rx_chan_stop_req(struct ipc_sk_chan_if_op_void *req, uint8_t chan_nr);
+int ipc_rx_chan_setgain_req(struct ipc_sk_chan_if_gain *req, uint8_t chan_nr);
+int ipc_rx_chan_setfreq_req(struct ipc_sk_chan_if_freq_req *req, uint8_t chan_nr);
+int ipc_rx_chan_settxatten_req(struct ipc_sk_chan_if_tx_attenuation *req, uint8_t chan_nr);

Transceiver52M/device/ipc/ipc_chan.c

@@ -0,0 +1,254 @@
+/*
+* Copyright 2020 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+* Author: Pau Espin Pedrol <pespin@sysmocom.de>
+*
+* SPDX-License-Identifier: 0BSD
+*
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <inttypes.h>
+#include <sys/mman.h>
+#include <sys/stat.h> /* For mode constants */
+#include <fcntl.h> /* For O_* constants */
+
+#include <debug.h>
+#include <osmocom/core/application.h>
+#include <osmocom/core/talloc.h>
+#include <osmocom/core/select.h>
+#include <osmocom/core/socket.h>
+#include <osmocom/core/logging.h>
+#include <osmocom/core/utils.h>
+#include <osmocom/core/msgb.h>
+#include <osmocom/core/select.h>
+#include <osmocom/core/timer.h>
+
+#include "shm.h"
+#include "ipc-driver-test.h"
+#include "ipc_chan.h"
+#include "ipc_sock.h"
+
+static int ipc_chan_rx(uint8_t msg_type, struct ipc_sk_chan_if *ipc_prim, uint8_t chan_nr)
+{
+	int rc = 0;
+
+	switch (msg_type) {
+	case IPC_IF_MSG_START_REQ:
+		rc = ipc_rx_chan_start_req(&ipc_prim->u.start_req, chan_nr);
+		break;
+	case IPC_IF_MSG_STOP_REQ:
+		rc = ipc_rx_chan_stop_req(&ipc_prim->u.stop_req, chan_nr);
+		break;
+	case IPC_IF_MSG_SETGAIN_REQ:
+		rc = ipc_rx_chan_setgain_req(&ipc_prim->u.set_gain_req, chan_nr);
+		break;
+	case IPC_IF_MSG_SETFREQ_REQ:
+		rc = ipc_rx_chan_setfreq_req(&ipc_prim->u.set_freq_req, chan_nr);
+		break;
+	case IPC_IF_MSG_SETTXATTN_REQ:
+		rc = ipc_rx_chan_settxatten_req(&ipc_prim->u.txatten_req, chan_nr);
+		break;
+	default:
+		LOGP(DDEV, LOGL_ERROR, "Received unknown IPC msg type 0x%02x on chan %d\n", msg_type, chan_nr);
+		rc = -EINVAL;
+	}
+
+	return rc;
+}
+
+static int ipc_chan_sock_read(struct osmo_fd *bfd)
+{
+	struct ipc_sock_state *state = (struct ipc_sock_state *)bfd->data;
+	struct ipc_sk_chan_if *ipc_prim;
+	struct msgb *msg;
+	int rc;
+
+	msg = msgb_alloc(sizeof(*ipc_prim) + 1000, "ipc_chan_sock_rx");
+	if (!msg)
+		return -ENOMEM;
+
+	ipc_prim = (struct ipc_sk_chan_if *)msg->tail;
+
+	rc = recv(bfd->fd, msg->tail, msgb_tailroom(msg), 0);
+	if (rc == 0)
+		goto close;
+
+	if (rc < 0) {
+		if (errno == EAGAIN) {
+			msgb_free(msg);
+			return 0;
+		}
+		goto close;
+	}
+
+	if (rc < (int)sizeof(*ipc_prim)) {
+		LOGP(DDEV, LOGL_ERROR,
+		     "Received %d bytes on Unix Socket, but primitive size "
+		     "is %zu, discarding\n",
+		     rc, sizeof(*ipc_prim));
+		msgb_free(msg);
+		return 0;
+	}
+
+	rc = ipc_chan_rx(ipc_prim->msg_type, ipc_prim, bfd->priv_nr);
+
+	/* as we always synchronously process the message in IPC_rx() and
+	 * its callbacks, we can free the message here. */
+	msgb_free(msg);
+
+	return rc;
+
+close:
+	msgb_free(msg);
+	ipc_sock_close(state);
+	return -1;
+}
+
+int ipc_chan_sock_send(struct msgb *msg, uint8_t chan_nr)
+{
+	struct ipc_sock_state *state = global_ctrl_socks[chan_nr];
+	struct osmo_fd *conn_bfd;
+
+	if (!state)
+		return -EINVAL;
+
+	if (!state) {
+		LOGP(DDEV, LOGL_INFO,
+		     "IPC socket not created, "
+		     "dropping message\n");
+		msgb_free(msg);
+		return -EINVAL;
+	}
+	conn_bfd = &state->conn_bfd;
+	if (conn_bfd->fd <= 0) {
+		LOGP(DDEV, LOGL_NOTICE,
+		     "IPC socket not connected, "
+		     "dropping message\n");
+		msgb_free(msg);
+		return -EIO;
+	}
+	msgb_enqueue(&state->upqueue, msg);
+	osmo_fd_write_enable(conn_bfd);
+
+	return 0;
+}
+
+static int ipc_chan_sock_write(struct osmo_fd *bfd)
+{
+	struct ipc_sock_state *state = (struct ipc_sock_state *)bfd->data;
+	int rc;
+
+	while (!llist_empty(&state->upqueue)) {
+		struct msgb *msg, *msg2;
+		struct ipc_sk_chan_if *ipc_prim;
+
+		/* peek at the beginning of the queue */
+		msg = llist_entry(state->upqueue.next, struct msgb, list);
+		ipc_prim = (struct ipc_sk_chan_if *)msg->data;
+
+		osmo_fd_write_disable(bfd);
+
+		/* bug hunter 8-): maybe someone forgot msgb_put(...) ? */
+		if (!msgb_length(msg)) {
+			LOGP(DDEV, LOGL_ERROR,
+			     "message type (%d) with ZERO "
+			     "bytes!\n",
+			     ipc_prim->msg_type);
+			goto dontsend;
+		}
+
+		/* try to send it over the socket */
+		rc = write(bfd->fd, msgb_data(msg), msgb_length(msg));
+		if (rc == 0)
+			goto close;
+		if (rc < 0) {
+			if (errno == EAGAIN) {
+				osmo_fd_write_enable(bfd);
+				break;
+			}
+			goto close;
+		}
+
+	dontsend:
+		/* _after_ we send it, we can dequeue */
+		msg2 = msgb_dequeue(&state->upqueue);
+		assert(msg == msg2);
+		msgb_free(msg);
+	}
+	return 0;
+
+close:
+	ipc_sock_close(state);
+	return -1;
+}
+
+static int ipc_chan_sock_cb(struct osmo_fd *bfd, unsigned int flags)
+{
+	int rc = 0;
+
+	if (flags & OSMO_FD_READ)
+		rc = ipc_chan_sock_read(bfd);
+	if (rc < 0)
+		return rc;
+
+	if (flags & OSMO_FD_WRITE)
+		rc = ipc_chan_sock_write(bfd);
+
+	return rc;
+}
+
+int ipc_chan_sock_accept(struct osmo_fd *bfd, unsigned int flags)
+{
+	struct ipc_sock_state *state = (struct ipc_sock_state *)bfd->data;
+	struct osmo_fd *conn_bfd = &state->conn_bfd;
+	struct sockaddr_un un_addr;
+	socklen_t len;
+	int rc;
+
+	len = sizeof(un_addr);
+	rc = accept(bfd->fd, (struct sockaddr *)&un_addr, &len);
+	if (rc < 0) {
+		LOGP(DDEV, LOGL_ERROR, "Failed to accept a new connection\n");
+		return -1;
+	}
+
+	if (conn_bfd->fd >= 0) {
+		LOGP(DDEV, LOGL_NOTICE,
+		     "osmo-trx connects but we already have "
+		     "another active connection ?!?\n");
+		/* We already have one IPC connected, this is all we support */
+		osmo_fd_read_disable(&state->listen_bfd);
+		close(rc);
+		return 0;
+	}
+
+	/* copy chan nr, required for proper bfd<->chan # mapping */
+	osmo_fd_setup(conn_bfd, rc, OSMO_FD_READ, ipc_chan_sock_cb, state, bfd->priv_nr);
+
+	if (osmo_fd_register(conn_bfd) != 0) {
+		LOGP(DDEV, LOGL_ERROR,
+		     "Failed to register new connection "
+		     "fd\n");
+		close(conn_bfd->fd);
+		conn_bfd->fd = -1;
+		return -1;
+	}
+
+	LOGP(DDEV, LOGL_NOTICE, "Unix socket connected to external osmo-trx\n");
+
+	return 0;
+}

Transceiver52M/device/ipc/ipc_chan.h

@@ -0,0 +1,25 @@
+/*
+* Copyright 2020 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+* Author: Pau Espin Pedrol <pespin@sysmocom.de>
+*
+* SPDX-License-Identifier: 0BSD
+*
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+#ifndef IPC_CHAN_H
+#define IPC_CHAN_H
+
+#include "shm.h"
+#include "ipc-driver-test.h"
+
+int ipc_chan_sock_send(struct msgb *msg, uint8_t chan_nr);
+int ipc_chan_sock_accept(struct osmo_fd *bfd, unsigned int flags);
+
+#endif // IPC_CHAN_H

Transceiver52M/device/ipc/ipc_shm.c

@@ -0,0 +1,200 @@
+/*
+* Copyright 2020 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+* Author: Eric Wild <ewild@sysmocom.de>
+*
+* SPDX-License-Identifier: 0BSD
+*
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <shm.h>
+#include "ipc_shm.h"
+#include <pthread.h>
+#include <semaphore.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <osmocom/core/panic.h>
+
+#include <debug.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#define SAMPLE_SIZE_BYTE (sizeof(uint16_t) * 2)
+
+struct ipc_shm_io *ipc_shm_init_consumer(struct ipc_shm_stream *s)
+{
+	unsigned int i;
+
+	struct ipc_shm_io *r = (struct ipc_shm_io *)malloc(sizeof(struct ipc_shm_io));
+	r->this_stream = s->raw;
+	r->buf_ptrs =
+		(volatile struct ipc_shm_raw_smpl_buf **)malloc(sizeof(struct ipc_shm_raw_smpl_buf *) * s->num_buffers);
+
+	/* save actual ptrs */
+	for (i = 0; i < s->num_buffers; i++)
+		r->buf_ptrs[i] = s->buffers[i];
+
+	r->partial_read_begin_ptr = 0;
+	return r;
+}
+
+struct ipc_shm_io *ipc_shm_init_producer(struct ipc_shm_stream *s)
+{
+	int rv;
+	pthread_mutexattr_t att;
+	pthread_condattr_t t1, t2;
+	struct ipc_shm_io *r = ipc_shm_init_consumer(s);
+	rv = pthread_mutexattr_init(&att);
+	if (rv != 0) {
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
+	}
+
+	rv = pthread_mutexattr_setrobust(&att, PTHREAD_MUTEX_ROBUST);
+	if (rv != 0) {
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
+	}
+
+	rv = pthread_mutexattr_setpshared(&att, PTHREAD_PROCESS_SHARED);
+	if (rv != 0) {
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
+	}
+
+	rv = pthread_mutex_init((pthread_mutex_t *)&r->this_stream->lock, &att);
+	if (rv != 0) {
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
+	}
+
+	pthread_mutexattr_destroy(&att);
+
+	rv = pthread_condattr_setpshared(&t1, PTHREAD_PROCESS_SHARED);
+	if (rv != 0) {
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
+	}
+
+	rv = pthread_condattr_setpshared(&t2, PTHREAD_PROCESS_SHARED);
+	if (rv != 0) {
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
+	}
+
+	rv = pthread_cond_init((pthread_cond_t *)&r->this_stream->cf, &t1);
+	if (rv != 0) {
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
+	}
+
+	rv = pthread_cond_init((pthread_cond_t *)&r->this_stream->ce, &t2);
+	if (rv != 0) {
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
+	}
+
+	pthread_condattr_destroy(&t1);
+	pthread_condattr_destroy(&t2);
+
+	r->this_stream->read_next = 0;
+	r->this_stream->write_next = 0;
+	return r;
+}
+
+void ipc_shm_close(struct ipc_shm_io *r)
+{
+	if (r) {
+		free(r->buf_ptrs);
+		free(r);
+	}
+}
+
+int32_t ipc_shm_enqueue(struct ipc_shm_io *r, uint64_t timestamp, uint32_t len_in_sps, uint16_t *data)
+{
+	volatile struct ipc_shm_raw_smpl_buf *buf;
+	int32_t rv;
+	struct timespec tv;
+	clock_gettime(CLOCK_REALTIME, &tv);
+	tv.tv_sec += 1;
+
+	rv = pthread_mutex_timedlock((pthread_mutex_t *)&r->this_stream->lock, &tv);
+	if (rv != 0)
+		return -rv;
+
+	while (((r->this_stream->write_next + 1) & (r->this_stream->num_buffers - 1)) == r->this_stream->read_next &&
+	       rv == 0)
+		rv = pthread_cond_timedwait((pthread_cond_t *)&r->this_stream->ce,
+					    (pthread_mutex_t *)&r->this_stream->lock, &tv);
+	if (rv != 0)
+		return -rv;
+
+	buf = r->buf_ptrs[r->this_stream->write_next];
+	buf->timestamp = timestamp;
+
+	rv = len_in_sps <= r->this_stream->buffer_size ? len_in_sps : r->this_stream->buffer_size;
+
+	memcpy((void *)buf->samples, data, SAMPLE_SIZE_BYTE * rv);
+	buf->data_len = rv;
+
+	r->this_stream->write_next = (r->this_stream->write_next + 1) & (r->this_stream->num_buffers - 1);
+
+	pthread_cond_signal((pthread_cond_t *)&r->this_stream->cf);
+	pthread_mutex_unlock((pthread_mutex_t *)&r->this_stream->lock);
+
+	return rv;
+}
+
+int32_t ipc_shm_read(struct ipc_shm_io *r, uint16_t *out_buf, uint32_t num_samples, uint64_t *timestamp,
+		     uint32_t timeout_seconds)
+{
+	volatile struct ipc_shm_raw_smpl_buf *buf;
+	int32_t rv;
+	uint8_t freeflag = 0;
+	struct timespec tv;
+	clock_gettime(CLOCK_REALTIME, &tv);
+	tv.tv_sec += timeout_seconds;
+
+	rv = pthread_mutex_timedlock((pthread_mutex_t *)&r->this_stream->lock, &tv);
+	if (rv != 0)
+		return -rv;
+
+	while (r->this_stream->write_next == r->this_stream->read_next && rv == 0)
+		rv = pthread_cond_timedwait((pthread_cond_t *)&r->this_stream->cf,
+					    (pthread_mutex_t *)&r->this_stream->lock, &tv);
+	if (rv != 0)
+		return -rv;
+
+	buf = r->buf_ptrs[r->this_stream->read_next];
+	if (buf->data_len <= num_samples) {
+		memcpy(out_buf, (void *)&buf->samples[r->partial_read_begin_ptr * 2], SAMPLE_SIZE_BYTE * buf->data_len);
+		r->partial_read_begin_ptr = 0;
+		rv = buf->data_len;
+		buf->data_len = 0;
+		r->this_stream->read_next = (r->this_stream->read_next + 1) & (r->this_stream->num_buffers - 1);
+		freeflag = 1;
+
+	} else /*if (buf->data_len > num_samples)*/ {
+		memcpy(out_buf, (void *)&buf->samples[r->partial_read_begin_ptr * 2], SAMPLE_SIZE_BYTE * num_samples);
+		r->partial_read_begin_ptr += num_samples;
+		buf->data_len -= num_samples;
+		rv = num_samples;
+	}
+
+	*timestamp = buf->timestamp;
+	buf->timestamp += rv;
+
+	if (freeflag)
+		pthread_cond_signal((pthread_cond_t *)&r->this_stream->ce);
+
+	pthread_mutex_unlock((pthread_mutex_t *)&r->this_stream->lock);
+
+	return rv;
+}

Transceiver52M/device/ipc/ipc_shm.h

@@ -0,0 +1,45 @@
+/*
+* Copyright 2020 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+* Author: Eric Wild <ewild@sysmocom.de>
+*
+* SPDX-License-Identifier: 0BSD
+*
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+#ifndef IPC_SHM_H
+#define IPC_SHM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <shm.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+struct ipc_shm_io {
+	volatile struct ipc_shm_raw_stream *this_stream;
+	volatile struct ipc_shm_raw_smpl_buf **volatile buf_ptrs;
+	uint32_t partial_read_begin_ptr;
+};
+
+struct ipc_shm_io *ipc_shm_init_consumer(struct ipc_shm_stream *s);
+struct ipc_shm_io *ipc_shm_init_producer(struct ipc_shm_stream *s);
+void ipc_shm_close(struct ipc_shm_io *r);
+int32_t ipc_shm_enqueue(struct ipc_shm_io *r, uint64_t timestamp, uint32_t len_in_sps, uint16_t *data);
+int32_t ipc_shm_tryenqueue(struct ipc_shm_io *r, uint64_t timestamp, uint32_t len_in_sps, uint16_t *data);
+volatile struct ipc_shm_raw_smpl_buf *ipc_shm_dequeue(struct ipc_shm_io *r);
+int32_t ipc_shm_read(struct ipc_shm_io *r, uint16_t *out_buf, uint32_t num_samples, uint64_t *timestamp,
+		     uint32_t timeout_seconds);
+
+#endif // IPC_SHM_H

Transceiver52M/device/ipc/ipc_sock.c

@@ -0,0 +1,266 @@
+/*
+* Copyright 2020 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+* Author: Pau Espin Pedrol <pespin@sysmocom.de>
+*
+* SPDX-License-Identifier: 0BSD
+*
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <inttypes.h>
+#include <sys/mman.h>
+#include <sys/stat.h> /* For mode constants */
+#include <fcntl.h> /* For O_* constants */
+
+#include <debug.h>
+#include <osmocom/core/application.h>
+#include <osmocom/core/talloc.h>
+#include <osmocom/core/select.h>
+#include <osmocom/core/socket.h>
+#include <osmocom/core/logging.h>
+#include <osmocom/core/utils.h>
+#include <osmocom/core/msgb.h>
+#include <osmocom/core/select.h>
+#include <osmocom/core/timer.h>
+
+#include "shm.h"
+#include "ipc-driver-test.h"
+
+extern volatile int ipc_exit_requested;
+static int ipc_rx(uint8_t msg_type, struct ipc_sk_if *ipc_prim)
+{
+	int rc = 0;
+
+	switch (msg_type) {
+	case IPC_IF_MSG_GREETING_REQ:
+		rc = ipc_rx_greeting_req(&ipc_prim->u.greeting_req);
+		break;
+	case IPC_IF_MSG_INFO_REQ:
+		rc = ipc_rx_info_req(&ipc_prim->u.info_req);
+		break;
+	case IPC_IF_MSG_OPEN_REQ:
+		rc = ipc_rx_open_req(&ipc_prim->u.open_req);
+		break;
+	default:
+		LOGP(DDEV, LOGL_ERROR, "Received unknown IPC msg type 0x%02x\n", msg_type);
+		rc = -EINVAL;
+	}
+
+	return rc;
+}
+
+int ipc_sock_send(struct msgb *msg)
+{
+	struct ipc_sock_state *state = global_ipc_sock_state;
+	struct osmo_fd *conn_bfd;
+
+	if (!state) {
+		LOGP(DDEV, LOGL_INFO,
+		     "IPC socket not created, "
+		     "dropping message\n");
+		msgb_free(msg);
+		return -EINVAL;
+	}
+	conn_bfd = &state->conn_bfd;
+	if (conn_bfd->fd <= 0) {
+		LOGP(DDEV, LOGL_NOTICE,
+		     "IPC socket not connected, "
+		     "dropping message\n");
+		msgb_free(msg);
+		return -EIO;
+	}
+	msgb_enqueue(&state->upqueue, msg);
+	osmo_fd_write_enable(conn_bfd);
+
+	return 0;
+}
+
+void ipc_sock_close(struct ipc_sock_state *state)
+{
+	struct osmo_fd *bfd = &state->conn_bfd;
+
+	LOGP(DDEV, LOGL_NOTICE, "IPC socket has LOST connection\n");
+
+	ipc_exit_requested = 1;
+
+	close(bfd->fd);
+	bfd->fd = -1;
+	osmo_fd_unregister(bfd);
+
+	/* re-enable the generation of ACCEPT for new connections */
+	osmo_fd_read_enable(&state->listen_bfd);
+
+	/* flush the queue */
+	while (!llist_empty(&state->upqueue)) {
+		struct msgb *msg = msgb_dequeue(&state->upqueue);
+		msgb_free(msg);
+	}
+}
+
+int ipc_sock_read(struct osmo_fd *bfd)
+{
+	struct ipc_sock_state *state = (struct ipc_sock_state *)bfd->data;
+	struct ipc_sk_if *ipc_prim;
+	struct msgb *msg;
+	int rc;
+
+	msg = msgb_alloc(sizeof(*ipc_prim) + 1000, "ipc_sock_rx");
+	if (!msg)
+		return -ENOMEM;
+
+	ipc_prim = (struct ipc_sk_if *)msg->tail;
+
+	rc = recv(bfd->fd, msg->tail, msgb_tailroom(msg), 0);
+	if (rc == 0)
+		goto close;
+
+	if (rc < 0) {
+		if (errno == EAGAIN) {
+			msgb_free(msg);
+			return 0;
+		}
+		goto close;
+	}
+
+	if (rc < (int)sizeof(*ipc_prim)) {
+		LOGP(DDEV, LOGL_ERROR,
+		     "Received %d bytes on Unix Socket, but primitive size "
+		     "is %zu, discarding\n",
+		     rc, sizeof(*ipc_prim));
+		msgb_free(msg);
+		return 0;
+	}
+
+	rc = ipc_rx(ipc_prim->msg_type, ipc_prim);
+
+	/* as we always synchronously process the message in IPC_rx() and
+	 * its callbacks, we can free the message here. */
+	msgb_free(msg);
+
+	return rc;
+
+close:
+	msgb_free(msg);
+	ipc_sock_close(state);
+	return -1;
+}
+
+static int ipc_sock_write(struct osmo_fd *bfd)
+{
+	struct ipc_sock_state *state = (struct ipc_sock_state *)bfd->data;
+	int rc;
+
+	while (!llist_empty(&state->upqueue)) {
+		struct msgb *msg, *msg2;
+		struct ipc_sk_if *ipc_prim;
+
+		/* peek at the beginning of the queue */
+		msg = llist_entry(state->upqueue.next, struct msgb, list);
+		ipc_prim = (struct ipc_sk_if *)msg->data;
+
+		osmo_fd_write_disable(bfd);
+
+		/* bug hunter 8-): maybe someone forgot msgb_put(...) ? */
+		if (!msgb_length(msg)) {
+			LOGP(DDEV, LOGL_ERROR,
+			     "message type (%d) with ZERO "
+			     "bytes!\n",
+			     ipc_prim->msg_type);
+			goto dontsend;
+		}
+
+		/* try to send it over the socket */
+		rc = write(bfd->fd, msgb_data(msg), msgb_length(msg));
+		if (rc == 0)
+			goto close;
+		if (rc < 0) {
+			if (errno == EAGAIN) {
+				osmo_fd_write_enable(bfd);
+				break;
+			}
+			goto close;
+		}
+
+	dontsend:
+		/* _after_ we send it, we can deueue */
+		msg2 = msgb_dequeue(&state->upqueue);
+		assert(msg == msg2);
+		msgb_free(msg);
+	}
+	return 0;
+
+close:
+	ipc_sock_close(state);
+	return -1;
+}
+
+static int ipc_sock_cb(struct osmo_fd *bfd, unsigned int flags)
+{
+	int rc = 0;
+
+	if (flags & OSMO_FD_READ)
+		rc = ipc_sock_read(bfd);
+	if (rc < 0)
+		return rc;
+
+	if (flags & OSMO_FD_WRITE)
+		rc = ipc_sock_write(bfd);
+
+	return rc;
+}
+
+/* accept connection coming from IPC */
+int ipc_sock_accept(struct osmo_fd *bfd, unsigned int flags)
+{
+	struct ipc_sock_state *state = (struct ipc_sock_state *)bfd->data;
+	struct osmo_fd *conn_bfd = &state->conn_bfd;
+	struct sockaddr_un un_addr;
+	socklen_t len;
+	int rc;
+
+	len = sizeof(un_addr);
+	rc = accept(bfd->fd, (struct sockaddr *)&un_addr, &len);
+	if (rc < 0) {
+		LOGP(DDEV, LOGL_ERROR, "Failed to accept a new connection\n");
+		return -1;
+	}
+
+	if (conn_bfd->fd >= 0) {
+		LOGP(DDEV, LOGL_NOTICE,
+		     "ip clent connects but we already have "
+		     "another active connection ?!?\n");
+		/* We already have one IPC connected, this is all we support */
+		osmo_fd_read_disable(&state->listen_bfd);
+		close(rc);
+		return 0;
+	}
+
+	osmo_fd_setup(conn_bfd, rc, OSMO_FD_READ, ipc_sock_cb, state, 0);
+
+	if (osmo_fd_register(conn_bfd) != 0) {
+		LOGP(DDEV, LOGL_ERROR,
+		     "Failed to register new connection "
+		     "fd\n");
+		close(conn_bfd->fd);
+		conn_bfd->fd = -1;
+		return -1;
+	}
+
+	LOGP(DDEV, LOGL_NOTICE, "Unix socket connected to external osmo-trx\n");
+
+	return 0;
+}

Transceiver52M/device/ipc/ipc_sock.h

@@ -0,0 +1,26 @@
+/*
+* Copyright 2020 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+* Author: Pau Espin Pedrol <pespin@sysmocom.de>
+*
+* SPDX-License-Identifier: 0BSD
+*
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+#ifndef IPC_SOCK_H
+#define IPC_SOCK_H
+
+#include "shm.h"
+#include "ipc-driver-test.h"
+
+int ipc_sock_send(struct msgb *msg);
+int ipc_sock_accept(struct osmo_fd *bfd, unsigned int flags);
+void ipc_sock_close(struct ipc_sock_state *state);
+
+#endif // IPC_SOCK_H

Transceiver52M/device/ipc/shm.c

@@ -0,0 +1,149 @@
+/*
+* Copyright 2020 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+* Author: Pau Espin Pedrol <pespin@sysmocom.de>
+*
+* SPDX-License-Identifier: 0BSD
+*
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <stdint.h>
+#include <stddef.h>
+#include <osmocom/core/talloc.h>
+
+#include "shm.h"
+
+#define ENCDECDEBUG(...) //fprintf(stderr, __VA_ARGS__)
+
+/* Convert offsets to pointers */
+struct ipc_shm_stream *ipc_shm_decode_stream(void *tall_ctx, struct ipc_shm_raw_region *root_raw,
+					     struct ipc_shm_raw_stream *stream_raw)
+{
+	unsigned int i;
+	struct ipc_shm_stream *stream;
+	stream = talloc_zero(tall_ctx, struct ipc_shm_stream);
+	stream = talloc_zero_size(tall_ctx, sizeof(struct ipc_shm_stream) +
+						    sizeof(struct ipc_shm_raw_smpl_buf *) * stream_raw->num_buffers);
+	if (!stream)
+		return NULL;
+	stream->num_buffers = stream_raw->num_buffers;
+	stream->buffer_size = stream_raw->buffer_size;
+	stream->raw = stream_raw;
+	for (i = 0; i < stream->num_buffers; i++) {
+		ENCDECDEBUG("decode: smpl_buf %d at offset %u\n", i, stream_raw->buffer_offset[i]);
+		stream->buffers[i] =
+			(struct ipc_shm_raw_smpl_buf *)(((uint8_t *)root_raw) + stream_raw->buffer_offset[i]);
+	}
+	return stream;
+}
+
+struct ipc_shm_channel *ipc_shm_decode_channel(void *tall_ctx, struct ipc_shm_raw_region *root_raw,
+					       struct ipc_shm_raw_channel *chan_raw)
+{
+	struct ipc_shm_channel *chan;
+	chan = talloc_zero(tall_ctx, struct ipc_shm_channel);
+	if (!chan)
+		return NULL;
+	ENCDECDEBUG("decode: streams at offset %u and %u\n", chan_raw->dl_buf_offset, chan_raw->ul_buf_offset);
+	chan->dl_stream = ipc_shm_decode_stream(
+		chan, root_raw, (struct ipc_shm_raw_stream *)(((uint8_t *)root_raw) + chan_raw->dl_buf_offset));
+	chan->ul_stream = ipc_shm_decode_stream(
+		chan, root_raw, (struct ipc_shm_raw_stream *)(((uint8_t *)root_raw) + chan_raw->ul_buf_offset));
+	return chan;
+}
+struct ipc_shm_region *ipc_shm_decode_region(void *tall_ctx, struct ipc_shm_raw_region *root_raw)
+{
+	unsigned int i;
+	struct ipc_shm_region *root;
+	root = talloc_zero_size(tall_ctx,
+				sizeof(struct ipc_shm_region) + sizeof(struct ipc_shm_channel *) * root_raw->num_chans);
+	if (!root)
+		return NULL;
+
+	root->num_chans = root_raw->num_chans;
+	for (i = 0; i < root->num_chans; i++) {
+		ENCDECDEBUG("decode: channel %d at offset %u\n", i, root_raw->chan_offset[i]);
+		root->channels[i] = ipc_shm_decode_channel(
+			root, root_raw,
+			(struct ipc_shm_raw_channel *)(((uint8_t *)root_raw) + root_raw->chan_offset[i]));
+	}
+	return root;
+}
+
+unsigned int ipc_shm_encode_smpl_buf(struct ipc_shm_raw_region *root_raw, struct ipc_shm_raw_smpl_buf *smpl_buf_raw,
+				     uint32_t buffer_size)
+{
+	unsigned int offset = sizeof(struct ipc_shm_raw_smpl_buf);
+	offset = (((uintptr_t)offset + 7) & ~0x07ULL);
+	ENCDECDEBUG("encode: smpl_buf at offset %u\n", offset);
+	offset += buffer_size * sizeof(uint16_t) * 2; /* samples */
+	return offset;
+}
+
+unsigned int ipc_shm_encode_stream(struct ipc_shm_raw_region *root_raw, struct ipc_shm_raw_stream *stream_raw,
+				   uint32_t num_buffers, uint32_t buffer_size)
+{
+	unsigned int i;
+	ptrdiff_t start = (ptrdiff_t)stream_raw;
+	unsigned int offset = sizeof(struct ipc_shm_raw_stream) + sizeof(uint32_t) * num_buffers;
+	offset = (((uintptr_t)offset + 7) & ~0x07ULL);
+	ENCDECDEBUG("encode: stream at offset %lu\n", (start - (ptrdiff_t)root_raw));
+	if (root_raw) {
+		stream_raw->num_buffers = num_buffers;
+		stream_raw->buffer_size = buffer_size;
+		stream_raw->read_next = 0;
+		stream_raw->write_next = 0;
+	}
+	for (i = 0; i < num_buffers; i++) {
+		if (root_raw)
+			stream_raw->buffer_offset[i] = (start + offset - (ptrdiff_t)root_raw);
+		offset +=
+			ipc_shm_encode_smpl_buf(root_raw, (struct ipc_shm_raw_smpl_buf *)(start + offset), buffer_size);
+	}
+	return offset;
+}
+unsigned int ipc_shm_encode_channel(struct ipc_shm_raw_region *root_raw, struct ipc_shm_raw_channel *chan_raw,
+				    uint32_t num_buffers, uint32_t buffer_size)
+{
+	uint8_t *start = (uint8_t *)chan_raw;
+	unsigned int offset = sizeof(struct ipc_shm_raw_channel);
+	offset = (((uintptr_t)offset + 7) & ~0x07ULL);
+	ENCDECDEBUG("encode: channel at offset %lu\n", (start - (uint8_t *)root_raw));
+	if (root_raw)
+		chan_raw->dl_buf_offset = (start + offset - (uint8_t *)root_raw);
+	offset += ipc_shm_encode_stream(root_raw, (struct ipc_shm_raw_stream *)(start + offset), num_buffers,
+					buffer_size);
+	if (root_raw)
+		chan_raw->ul_buf_offset = (start + offset - (uint8_t *)root_raw);
+	offset += ipc_shm_encode_stream(root_raw, (struct ipc_shm_raw_stream *)(start + offset), num_buffers,
+					buffer_size);
+	return offset;
+}
+/* if root_raw is NULL, then do a dry run, aka only calculate final offset */
+unsigned int ipc_shm_encode_region(struct ipc_shm_raw_region *root_raw, uint32_t num_chans, uint32_t num_buffers,
+				   uint32_t buffer_size)
+{
+	unsigned i;
+	uintptr_t start = (uintptr_t)root_raw;
+	unsigned int offset = sizeof(struct ipc_shm_raw_region) + sizeof(uint32_t) * num_chans;
+	offset = (((uintptr_t)offset + 7) & ~0x07ULL);
+
+	if (root_raw)
+		root_raw->num_chans = num_chans;
+	for (i = 0; i < num_chans; i++) {
+		if (root_raw)
+			root_raw->chan_offset[i] = (start + offset - (uintptr_t)root_raw);
+		ENCDECDEBUG("encode: channel %d chan_offset[i]=%lu\n", i, start + offset - (uintptr_t)root_raw);
+		offset += ipc_shm_encode_channel(root_raw, (struct ipc_shm_raw_channel *)(start + offset), num_buffers,
+						 buffer_size);
+	}
+	//TODO: pass maximum size and verify we didn't go through
+	return offset;
+}

Transceiver52M/device/ipc/shm.h

@@ -0,0 +1,234 @@
+/*
+* Copyright 2020 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+* Author: Pau Espin Pedrol <pespin@sysmocom.de>
+*
+* SPDX-License-Identifier: 0BSD
+*
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+#pragma once
+
+#include <stdint.h>
+#include <unistd.h>
+#include <limits.h>
+#include <pthread.h>
+#include <semaphore.h>
+
+/* RAW structures */
+struct ipc_shm_raw_smpl_buf {
+	uint64_t timestamp;
+	uint32_t data_len; /* In samples */
+	uint16_t samples[0];
+};
+
+struct ipc_shm_raw_stream {
+	pthread_mutex_t lock; /* protects this struct */
+	pthread_cond_t cf; /* signals fill to reader */
+	pthread_cond_t ce; /* signals empty nbuf to writer */
+	uint32_t num_buffers;
+	uint32_t buffer_size; /* In samples */
+	uint32_t read_next;
+	uint32_t write_next;
+	uint32_t buffer_offset[0];
+	//struct ipc_shm_smpl_buf buffers[0];
+};
+
+struct ipc_shm_raw_channel {
+	uint32_t dl_buf_offset;
+	uint32_t ul_buf_offset;
+};
+
+struct ipc_shm_raw_region {
+	uint32_t num_chans;
+	uint32_t chan_offset[0];
+};
+
+/* non-raw, Pointer converted structures */
+struct ipc_shm_stream {
+	uint32_t num_buffers;
+	uint32_t buffer_size;
+	volatile struct ipc_shm_raw_stream *raw;
+	volatile struct ipc_shm_raw_smpl_buf *buffers[0];
+};
+
+struct ipc_shm_channel {
+	struct ipc_shm_stream *dl_stream;
+	struct ipc_shm_stream *ul_stream;
+};
+
+/* Pointer converted structures */
+struct ipc_shm_region {
+	uint32_t num_chans;
+	struct ipc_shm_channel *channels[0];
+};
+
+unsigned int ipc_shm_encode_region(struct ipc_shm_raw_region *root_raw, uint32_t num_chans, uint32_t num_buffers,
+				   uint32_t buffer_size);
+struct ipc_shm_region *ipc_shm_decode_region(void *tall_ctx, struct ipc_shm_raw_region *root_raw);
+/****************************************/
+/* UNIX SOCKET API                      */
+/****************************************/
+
+//////////////////
+// Master socket
+//////////////////
+#define IPC_SOCK_API_VERSION 1
+
+/* msg_type */
+#define IPC_IF_MSG_GREETING_REQ 0x00
+#define IPC_IF_MSG_GREETING_CNF 0x01
+#define IPC_IF_MSG_INFO_REQ 0x02
+#define IPC_IF_MSG_INFO_CNF 0x03
+#define IPC_IF_MSG_OPEN_REQ 0x04
+#define IPC_IF_MSG_OPEN_CNF 0x05
+
+#define MAX_NUM_CHANS 30
+#define RF_PATH_NAME_SIZE 25
+#define MAX_NUM_RF_PATHS 10
+#define SHM_NAME_MAX NAME_MAX /* 255 */
+
+#define FEATURE_MASK_CLOCKREF_INTERNAL (0x1 << 0)
+#define FEATURE_MASK_CLOCKREF_EXTERNAL (0x1 << 1)
+struct ipc_sk_if_info_chan {
+	char tx_path[MAX_NUM_RF_PATHS][RF_PATH_NAME_SIZE];
+	char rx_path[MAX_NUM_RF_PATHS][RF_PATH_NAME_SIZE];
+	double min_rx_gain;
+	double max_rx_gain;
+	double min_tx_gain;
+	double max_tx_gain;
+	double nominal_tx_power; /* dBm */
+} __attribute__((packed));
+
+struct ipc_sk_if_open_req_chan {
+	char tx_path[RF_PATH_NAME_SIZE];
+	char rx_path[RF_PATH_NAME_SIZE];
+} __attribute__((packed));
+
+struct ipc_sk_if_open_cnf_chan {
+	char chan_ipc_sk_path[108];
+} __attribute__((packed));
+
+struct ipc_sk_if_greeting {
+	uint8_t req_version;
+} __attribute__((packed));
+
+struct ipc_sk_if_info_req {
+	uint8_t spare;
+} __attribute__((packed));
+
+struct ipc_sk_if_info_cnf {
+	uint32_t feature_mask;
+	double iq_scaling_val_rx; /* for scaling, sample format is 16 bit, but adc/dac might be less */
+	double iq_scaling_val_tx;
+	uint32_t max_num_chans;
+	char dev_desc[200];
+	struct ipc_sk_if_info_chan chan_info[MAX_NUM_CHANS];
+} __attribute__((packed));
+
+struct ipc_sk_if_open_req {
+	uint32_t num_chans;
+	uint32_t clockref; /* One of FEATUER_MASK_CLOCKREF_* */
+	uint32_t rx_sample_freq_num;
+	uint32_t rx_sample_freq_den;
+	uint32_t tx_sample_freq_num;
+	uint32_t tx_sample_freq_den;
+	uint32_t bandwidth;
+	struct ipc_sk_if_open_req_chan chan_info[MAX_NUM_CHANS];
+} __attribute__((packed));
+
+struct ipc_sk_if_open_cnf {
+	uint8_t return_code;
+	uint32_t path_delay;
+	char shm_name[SHM_NAME_MAX];
+	struct ipc_sk_if_open_cnf_chan chan_info[MAX_NUM_CHANS];
+} __attribute__((packed));
+
+struct ipc_sk_if {
+	uint8_t msg_type; /* message type */
+	uint8_t spare[2];
+
+	union {
+		struct ipc_sk_if_greeting greeting_req;
+		struct ipc_sk_if_greeting greeting_cnf;
+		struct ipc_sk_if_info_req info_req;
+		struct ipc_sk_if_info_cnf info_cnf;
+		struct ipc_sk_if_open_req open_req;
+		struct ipc_sk_if_open_cnf open_cnf;
+	} u;
+} __attribute__((packed));
+
+//////////////////
+// Channel socket
+//////////////////
+#define IPC_IF_CHAN_MSG_OFFSET 50
+#define IPC_IF_MSG_START_REQ IPC_IF_CHAN_MSG_OFFSET + 0
+#define IPC_IF_MSG_START_CNF IPC_IF_CHAN_MSG_OFFSET + 1
+#define IPC_IF_MSG_STOP_REQ IPC_IF_CHAN_MSG_OFFSET + 2
+#define IPC_IF_MSG_STOP_CNF IPC_IF_CHAN_MSG_OFFSET + 3
+#define IPC_IF_MSG_SETGAIN_REQ IPC_IF_CHAN_MSG_OFFSET + 4
+#define IPC_IF_MSG_SETGAIN_CNF IPC_IF_CHAN_MSG_OFFSET + 5
+#define IPC_IF_MSG_SETFREQ_REQ IPC_IF_CHAN_MSG_OFFSET + 6
+#define IPC_IF_MSG_SETFREQ_CNF IPC_IF_CHAN_MSG_OFFSET + 7
+
+#define IPC_IF_NOTIFY_UNDERFLOW IPC_IF_CHAN_MSG_OFFSET + 8
+#define IPC_IF_NOTIFY_OVERFLOW IPC_IF_CHAN_MSG_OFFSET + 9
+
+#define IPC_IF_MSG_SETTXATTN_REQ IPC_IF_CHAN_MSG_OFFSET + 10
+#define IPC_IF_MSG_SETTXATTN_CNF IPC_IF_CHAN_MSG_OFFSET + 11
+
+struct ipc_sk_chan_if_op_void {
+	// at least one dummy byte, to allow c/c++ compatibility
+	uint8_t dummy;
+} __attribute__((packed));
+
+struct ipc_sk_chan_if_op_rc {
+	uint8_t return_code;
+} __attribute__((packed));
+
+struct ipc_sk_chan_if_gain {
+	double gain;
+	uint8_t is_tx;
+} __attribute__((packed));
+
+struct ipc_sk_chan_if_freq_req {
+	double freq;
+	uint8_t is_tx;
+} __attribute__((packed));
+
+struct ipc_sk_chan_if_freq_cnf {
+	uint8_t return_code;
+} __attribute__((packed));
+
+struct ipc_sk_chan_if_notfiy {
+	uint8_t dummy;
+} __attribute__((packed));
+
+struct ipc_sk_chan_if_tx_attenuation {
+	double attenuation;
+} __attribute__((packed));
+
+struct ipc_sk_chan_if {
+	uint8_t msg_type; /* message type */
+	uint8_t spare[2];
+
+	union {
+		struct ipc_sk_chan_if_op_void start_req;
+		struct ipc_sk_chan_if_op_rc start_cnf;
+		struct ipc_sk_chan_if_op_void stop_req;
+		struct ipc_sk_chan_if_op_rc stop_cnf;
+		struct ipc_sk_chan_if_gain set_gain_req;
+		struct ipc_sk_chan_if_gain set_gain_cnf;
+		struct ipc_sk_chan_if_freq_req set_freq_req;
+		struct ipc_sk_chan_if_freq_cnf set_freq_cnf;
+		struct ipc_sk_chan_if_notfiy notify;
+		struct ipc_sk_chan_if_tx_attenuation txatten_req;
+		struct ipc_sk_chan_if_tx_attenuation txatten_cnf;
+	} u;
+} __attribute__((packed));

Transceiver52M/device/ipc/uhdwrap.cpp

@@ -0,0 +1,255 @@
+/*
+* Copyright 2020 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+* Author: Eric Wild <ewild@sysmocom.de>
+*
+* SPDX-License-Identifier: 0BSD
+*
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+extern "C" {
+#include <osmocom/core/application.h>
+#include <osmocom/core/talloc.h>
+#include <osmocom/core/select.h>
+#include <osmocom/core/socket.h>
+#include <osmocom/core/logging.h>
+#include <osmocom/core/utils.h>
+#include <osmocom/core/msgb.h>
+#include <osmocom/core/select.h>
+#include <osmocom/core/timer.h>
+
+#include "shm.h"
+#include "ipc_shm.h"
+#include "ipc-driver-test.h"
+}
+#include "../uhd/UHDDevice.h"
+#include "uhdwrap.h"
+
+#include "Logger.h"
+#include "Threads.h"
+#include "Utils.h"
+
+int uhd_wrap::open(const std::string &args, int ref, bool swap_channels)
+{
+	int rv = uhd_device::open(args, ref, swap_channels);
+	samps_per_buff_rx = rx_stream->get_max_num_samps();
+	samps_per_buff_tx = tx_stream->get_max_num_samps();
+	channel_count = usrp_dev->get_rx_num_channels();
+
+	wrap_rx_buffs = std::vector<std::vector<short> >(channel_count, std::vector<short>(2 * samps_per_buff_rx));
+	for (size_t i = 0; i < wrap_rx_buffs.size(); i++)
+		wrap_rx_buf_ptrs.push_back(&wrap_rx_buffs[i].front());
+
+	wrap_tx_buffs = std::vector<std::vector<short> >(channel_count, std::vector<short>(2 * 5000));
+	for (size_t i = 0; i < wrap_tx_buffs.size(); i++)
+		wrap_tx_buf_ptrs.push_back(&wrap_tx_buffs[i].front());
+
+	return rv;
+}
+
+uhd_wrap::~uhd_wrap()
+{
+	//	drvtest::gshutdown = 1;
+	//t->join();
+}
+
+size_t uhd_wrap::bufsizerx()
+{
+	return samps_per_buff_rx;
+}
+
+size_t uhd_wrap::bufsizetx()
+{
+	return samps_per_buff_tx;
+}
+
+int uhd_wrap::chancount()
+{
+	return channel_count;
+}
+
+int uhd_wrap::wrap_read(TIMESTAMP *timestamp)
+{
+	uhd::rx_metadata_t md;
+	size_t num_rx_samps = rx_stream->recv(wrap_rx_buf_ptrs, samps_per_buff_rx, md, 0.1, true);
+	*timestamp = md.time_spec.to_ticks(rx_rate);
+	return num_rx_samps; //uhd_device::readSamples(bufs, len, overrun, timestamp, underrun);
+}
+
+extern "C" void *uhdwrap_open(struct ipc_sk_if_open_req *open_req)
+{
+	unsigned int rx_sps, tx_sps;
+
+	/* FIXME: dev arg string* */
+	/* FIXME: rx frontend bw? */
+	/* FIXME: tx frontend bw? */
+	ReferenceType cref;
+	switch (open_req->clockref) {
+	case FEATURE_MASK_CLOCKREF_EXTERNAL:
+		cref = ReferenceType::REF_EXTERNAL;
+		break;
+	case FEATURE_MASK_CLOCKREF_INTERNAL:
+	default:
+		cref = ReferenceType::REF_INTERNAL;
+		break;
+	}
+
+	std::vector<std::string> tx_paths;
+	std::vector<std::string> rx_paths;
+	for (unsigned int i = 0; i < open_req->num_chans; i++) {
+		tx_paths.push_back(open_req->chan_info[i].tx_path);
+		rx_paths.push_back(open_req->chan_info[i].rx_path);
+	}
+
+	/* FIXME: this is actually the sps value, not the sample rate!
+	 * sample rate is looked up according to the sps rate by uhd backend */
+	rx_sps = open_req->rx_sample_freq_num / open_req->rx_sample_freq_den;
+	tx_sps = open_req->tx_sample_freq_num / open_req->tx_sample_freq_den;
+	uhd_wrap *uhd_wrap_dev =
+		new uhd_wrap(tx_sps, rx_sps, RadioDevice::NORMAL, open_req->num_chans, 0.0, tx_paths, rx_paths);
+	uhd_wrap_dev->open("", cref, false);
+
+	return uhd_wrap_dev;
+}
+extern "C" int32_t uhdwrap_get_bufsizerx(void *dev)
+{
+	uhd_wrap *d = (uhd_wrap *)dev;
+	return d->bufsizerx();
+}
+
+extern "C" int32_t uhdwrap_get_timingoffset(void *dev)
+{
+	uhd_wrap *d = (uhd_wrap *)dev;
+	return d->getTimingOffset();
+}
+
+extern "C" int32_t uhdwrap_read(void *dev, uint32_t num_chans)
+{
+	TIMESTAMP t;
+	uhd_wrap *d = (uhd_wrap *)dev;
+
+	if (num_chans != d->wrap_rx_buf_ptrs.size()) {
+		perror("omg chans?!");
+	}
+
+	int32_t read = d->wrap_read(&t);
+
+	/* multi channel rx on b210 will return 0 due to alignment adventures, do not put 0 samples into a ipc buffer... */
+	if (read <= 0)
+		return read;
+
+	for (uint32_t i = 0; i < num_chans; i++) {
+		ipc_shm_enqueue(ios_rx_from_device[i], t, read, (uint16_t *)&d->wrap_rx_buffs[i].front());
+	}
+	return read;
+}
+
+extern "C" int32_t uhdwrap_write(void *dev, uint32_t num_chans, bool *underrun)
+{
+	uhd_wrap *d = (uhd_wrap *)dev;
+
+	uint64_t timestamp;
+	int32_t len = -1;
+	for (uint32_t i = 0; i < num_chans; i++) {
+		len = ipc_shm_read(ios_tx_to_device[i], (uint16_t *)&d->wrap_tx_buffs[i].front(), 5000, &timestamp, 1);
+		if (len < 0)
+			return 0;
+	}
+
+	return d->writeSamples(d->wrap_tx_buf_ptrs, len, underrun, timestamp);
+}
+
+extern "C" double uhdwrap_set_freq(void *dev, double f, size_t chan, bool for_tx)
+{
+	uhd_wrap *d = (uhd_wrap *)dev;
+	if (for_tx)
+		return d->setTxFreq(f, chan);
+	else
+		return d->setRxFreq(f, chan);
+}
+
+extern "C" double uhdwrap_set_gain(void *dev, double f, size_t chan, bool for_tx)
+{
+	uhd_wrap *d = (uhd_wrap *)dev;
+	//	if (for_tx)
+	//		return d->setTxGain(f, chan);
+	//	else
+	return d->setRxGain(f, chan);
+}
+
+extern "C" double uhdwrap_set_txatt(void *dev, double a, size_t chan)
+{
+	uhd_wrap *d = (uhd_wrap *)dev;
+	return d->setPowerAttenuation(a, chan);
+}
+
+extern "C" int32_t uhdwrap_start(void *dev, int chan)
+{
+	uhd_wrap *d = (uhd_wrap *)dev;
+	return d->start();
+}
+
+extern "C" int32_t uhdwrap_stop(void *dev, int chan)
+{
+	uhd_wrap *d = (uhd_wrap *)dev;
+	return d->stop();
+}
+
+extern "C" void uhdwrap_fill_info_cnf(struct ipc_sk_if *ipc_prim)
+{
+	struct ipc_sk_if_info_chan *chan_info;
+
+	uhd::device_addr_t args("");
+	uhd::device_addrs_t devs_found = uhd::device::find(args);
+	if (devs_found.size() < 1) {
+		std::cout << "\n No device found!";
+		exit(0);
+	}
+
+	uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(devs_found[0]);
+	auto rxchans = usrp->get_rx_num_channels();
+	auto txchans = usrp->get_tx_num_channels();
+	auto rx_range = usrp->get_rx_gain_range();
+	auto tx_range = usrp->get_tx_gain_range();
+
+	//auto nboards = usrp->get_num_mboards();
+	auto refs = usrp->get_clock_sources(0);
+	auto devname = usrp->get_mboard_name(0);
+
+	ipc_prim->u.info_cnf.feature_mask = 0;
+	if (std::find(refs.begin(), refs.end(), "internal") != refs.end())
+		ipc_prim->u.info_cnf.feature_mask |= FEATURE_MASK_CLOCKREF_INTERNAL;
+	if (std::find(refs.begin(), refs.end(), "external") != refs.end())
+		ipc_prim->u.info_cnf.feature_mask |= FEATURE_MASK_CLOCKREF_EXTERNAL;
+
+	// at least one duplex channel
+	auto num_chans = rxchans == txchans ? txchans : 1;
+
+	ipc_prim->u.info_cnf.iq_scaling_val_rx = 0.3;
+	ipc_prim->u.info_cnf.iq_scaling_val_tx = 1;
+	ipc_prim->u.info_cnf.max_num_chans = num_chans;
+	OSMO_STRLCPY_ARRAY(ipc_prim->u.info_cnf.dev_desc, devname.c_str());
+	chan_info = ipc_prim->u.info_cnf.chan_info;
+	for (unsigned int i = 0; i < ipc_prim->u.info_cnf.max_num_chans; i++) {
+		auto rxant = usrp->get_rx_antennas(i);
+		auto txant = usrp->get_tx_antennas(i);
+		for (unsigned int j = 0; j < txant.size(); j++) {
+			OSMO_STRLCPY_ARRAY(chan_info->tx_path[j], txant[j].c_str());
+		}
+		for (unsigned int j = 0; j < rxant.size(); j++) {
+			OSMO_STRLCPY_ARRAY(chan_info->rx_path[j], rxant[j].c_str());
+		}
+		chan_info->min_rx_gain = rx_range.start();
+		chan_info->max_rx_gain = rx_range.stop();
+		chan_info->min_tx_gain = tx_range.start();
+		chan_info->max_tx_gain = tx_range.stop();
+		chan_info->nominal_tx_power = 7.5; // FIXME: would require uhd dev + freq info
+		chan_info++;
+	}
+}

Transceiver52M/device/ipc/uhdwrap.h

@@ -0,0 +1,83 @@
+/*
+* Copyright 2020 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+* Author: Eric Wild <ewild@sysmocom.de>
+*
+* SPDX-License-Identifier: 0BSD
+*
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+#ifndef IPC_UHDWRAP_H
+#define IPC_UHDWRAP_H
+
+#ifdef __cplusplus
+#include "../uhd/UHDDevice.h"
+
+class uhd_wrap : public uhd_device {
+    public:
+	//	std::thread *t;
+	size_t samps_per_buff_rx;
+	size_t samps_per_buff_tx;
+	int channel_count;
+
+	std::vector<std::vector<short> > wrap_rx_buffs;
+	std::vector<std::vector<short> > wrap_tx_buffs;
+	std::vector<short *> wrap_rx_buf_ptrs;
+	std::vector<short *> wrap_tx_buf_ptrs;
+
+	template <typename... Args> uhd_wrap(Args... args) : uhd_device(args...)
+	{
+		//	t = new std::thread(magicthread);
+		// give the thread some time to start and set up
+		//	std::this_thread::sleep_for(std::chrono::seconds(1));
+	}
+	virtual ~uhd_wrap();
+
+	//    void ipc_sock_close() override {};
+	int wrap_read(TIMESTAMP *timestamp);
+	virtual int open(const std::string &args, int ref, bool swap_channels) override;
+
+	//	bool start() override;
+	//	bool stop() override;
+	//	virtual TIMESTAMP initialWriteTimestamp() override;
+	//	virtual TIMESTAMP initialReadTimestamp() override;
+
+	int getTimingOffset()
+	{
+		return ts_offset;
+	}
+	size_t bufsizerx();
+	size_t bufsizetx();
+	int chancount();
+};
+#else
+void *uhdwrap_open(struct ipc_sk_if_open_req *open_req);
+
+int32_t uhdwrap_get_bufsizerx(void *dev);
+
+int32_t uhdwrap_get_timingoffset(void *dev);
+
+int32_t uhdwrap_read(void *dev, uint32_t num_chans);
+
+int32_t uhdwrap_write(void *dev, uint32_t num_chans, bool *underrun);
+
+double uhdwrap_set_freq(void *dev, double f, size_t chan, bool for_tx);
+
+double uhdwrap_set_gain(void *dev, double f, size_t chan, bool for_tx);
+
+int32_t uhdwrap_start(void *dev, int chan);
+
+int32_t uhdwrap_stop(void *dev, int chan);
+
+void uhdwrap_fill_info_cnf(struct ipc_sk_if *ipc_prim);
+
+double uhdwrap_set_txatt(void *dev, double a, size_t chan);
+#endif
+
+#endif // IPC_B210_H

Transceiver52M/device/lms/LMSDevice.cpp

@@ -23,7 +23,6 @@
 
 #include <map>
 
-#include "trx_vty.h"
 #include "Logger.h"
 #include "Threads.h"
 #include "LMSDevice.h"
@@ -32,6 +31,7 @@
 #include <lime/LimeSuite.h>
 
 extern "C" {
+#include "trx_vty.h"
 #include "osmo_signal.h"
 #include <osmocom/core/utils.h>
 }
@@ -40,8 +40,6 @@ extern "C" {
 #include "config.h"
 #endif
 
-using namespace std;
-
 #define MAX_ANTENNA_LIST_SIZE 10
 #define GSM_CARRIER_BW 270000.0 /* 270kHz */
 #define LMS_MIN_BW_SUPPORTED 2.5e6 /* 2.5mHz, minimum supported by LMS */
@@ -65,8 +63,6 @@ struct dev_desc {
 	 * LimeNET-Micro does not like selecting internal clock
 	 */
 	bool clock_src_int_usable;
-	/* Device specific maximum tx levels selected by phasenoise measurements, in dB */
-	double max_tx_gain;
 	/* Sample rate coef (without having TX/RX samples per symbol into account) */
 	double rate;
 	/* Sample rate coef (without having TX/RX samples per symbol into account), if multi-arfcn is enabled */
@@ -80,12 +76,41 @@ struct dev_desc {
 };
 
 static const std::map<enum lms_dev_type, struct dev_desc> dev_param_map {
-	{ LMS_DEV_SDR_USB,   { true,  true,  73.0, GSMRATE, MCBTS_SPACING, 8.9e-5, 7.9e-5, LMS_DEV_SDR_USB_PREFIX_NAME } },
-	{ LMS_DEV_SDR_MINI,  { false, true,  66.0, GSMRATE, MCBTS_SPACING, 8.9e-5, 8.2e-5, LMS_DEV_SDR_MINI_PREFIX_NAME } },
-	{ LMS_DEV_NET_MICRO, { true,  false, 71.0, GSMRATE, MCBTS_SPACING, 8.9e-5, 7.9e-5, LMS_DEV_NET_MICRO_PREFIX_NAME } },
-	{ LMS_DEV_UNKNOWN,   { true,  true,  73.0, GSMRATE, MCBTS_SPACING, 8.9e-5, 7.9e-5, "UNKNOWN" } },
+	{ LMS_DEV_SDR_USB,   { true,  true,  GSMRATE, MCBTS_SPACING, 8.9e-5, 7.9e-5, LMS_DEV_SDR_USB_PREFIX_NAME } },
+	{ LMS_DEV_SDR_MINI,  { false, true,  GSMRATE, MCBTS_SPACING, 8.9e-5, 8.2e-5, LMS_DEV_SDR_MINI_PREFIX_NAME } },
+	{ LMS_DEV_NET_MICRO, { true,  false, GSMRATE, MCBTS_SPACING, 8.9e-5, 7.9e-5, LMS_DEV_NET_MICRO_PREFIX_NAME } },
+	{ LMS_DEV_UNKNOWN,   { true,  true,  GSMRATE, MCBTS_SPACING, 8.9e-5, 7.9e-5, "UNKNOWN" } },
 };
 
+typedef std::tuple<lms_dev_type, enum gsm_band> dev_band_key;
+typedef std::map<dev_band_key, dev_band_desc>::const_iterator dev_band_map_it;
+static const std::map<dev_band_key, dev_band_desc> dev_band_nom_power_param_map {
+	{ std::make_tuple(LMS_DEV_SDR_USB, GSM_BAND_850),	{ 73.0, 11.2,  -6.0  } },
+	{ std::make_tuple(LMS_DEV_SDR_USB, GSM_BAND_900),	{ 73.0, 10.8,  -6.0  } },
+	{ std::make_tuple(LMS_DEV_SDR_USB, GSM_BAND_1800),	{ 65.0, -3.5,  -17.0 } }, /* FIXME: OS#4583: 1800Mhz is failing above TxGain=65, which is around -3.5dBm (already < 0 dBm) */
+	{ std::make_tuple(LMS_DEV_SDR_USB, GSM_BAND_1900),	{ 73.0, 1.7,   -17.0 } }, /* FIXME: OS#4583: 1900MHz is failing in all TxGain values */
+	{ std::make_tuple(LMS_DEV_SDR_MINI, GSM_BAND_850),	{ 66.0, 3.1,   -6.0  } }, /* FIXME: OS#4583: Ensure BAND2 is used at startup */
+	{ std::make_tuple(LMS_DEV_SDR_MINI, GSM_BAND_900),	{ 66.0, 2.8,   -6.0  } }, /* FIXME: OS#4583: Ensure BAND2 is used at startup */
+	{ std::make_tuple(LMS_DEV_SDR_MINI, GSM_BAND_1800),	{ 66.0, -11.6, -17.0 } }, /* OS#4583: Any of BAND1 or BAND2 is fine */
+	{ std::make_tuple(LMS_DEV_SDR_MINI, GSM_BAND_1900),	{ 66.0, -9.2,  -17.0 } }, /* FIXME: OS#4583: Ensure BAND1 is used at startup */
+	{ std::make_tuple(LMS_DEV_NET_MICRO, GSM_BAND_850),	{ 71.0, 6.8,   -6.0  } },
+	{ std::make_tuple(LMS_DEV_NET_MICRO, GSM_BAND_900),	{ 71.0, 6.8,   -6.0  } },
+	{ std::make_tuple(LMS_DEV_NET_MICRO, GSM_BAND_1800),	{ 65.0, -10.5, -17.0 } }, /* OS#4583: TxGain=71 (-4.4dBm) FAIL rms phase errors ~10° */
+	{ std::make_tuple(LMS_DEV_NET_MICRO, GSM_BAND_1900),	{ 71.0, -6.3,  -17.0 } }, /* FIXME: OS#4583: all FAIL, BAND1/BAND2 rms phase errors >23° */
+};
+
+/* So far measurements done for B210 show really close to linear relationship
+ * between gain and real output power, so we simply adjust the measured offset
+ */
+static double TxGain2TxPower(const dev_band_desc &desc, double tx_gain_db)
+{
+	return desc.nom_out_tx_power - (desc.nom_lms_tx_gain - tx_gain_db);
+}
+static double TxPower2TxGain(const dev_band_desc &desc, double tx_power_dbm)
+{
+	return desc.nom_lms_tx_gain - (desc.nom_out_tx_power - tx_power_dbm);
+}
+
 static enum lms_dev_type parse_dev_type(lms_device_t *m_lms_dev)
 {
 	std::map<enum lms_dev_type, struct dev_desc>::const_iterator it = dev_param_map.begin();
@@ -109,8 +134,9 @@ static enum lms_dev_type parse_dev_type(lms_device_t *m_lms_dev)
 LMSDevice::LMSDevice(size_t tx_sps, size_t rx_sps, InterfaceType iface, size_t chan_num, double lo_offset,
 		     const std::vector<std::string>& tx_paths,
 		     const std::vector<std::string>& rx_paths):
-	RadioDevice(tx_sps, rx_sps, iface, chan_num, lo_offset, tx_paths, rx_paths),
-	m_lms_dev(NULL), started(false), m_dev_type(LMS_DEV_UNKNOWN)
+		     RadioDevice(tx_sps, rx_sps, iface, chan_num, lo_offset, tx_paths, rx_paths),
+		     m_lms_dev(NULL), started(false), band_ass_curr_sess(false), band((enum gsm_band)0),
+		     m_dev_type(LMS_DEV_UNKNOWN)
 {
 	LOGC(DDEV, INFO) << "creating LMS device...";
 
@@ -176,7 +202,7 @@ static void print_range(const char* name, lms_range_t *range)
 int info_list_find(lms_info_str_t* info_list, unsigned int count, const std::string &args)
 {
 	unsigned int i, j;
-	std::vector<string> filters;
+	std::vector<std::string> filters;
 
 	filters = comma_delimited_to_vector(args.c_str());
 
@@ -197,6 +223,47 @@ int info_list_find(lms_info_str_t* info_list, unsigned int count, const std::str
 	return -1;
 }
 
+void LMSDevice::assign_band_desc(enum gsm_band req_band)
+{
+	dev_band_map_it it;
+
+	it = dev_band_nom_power_param_map.find(dev_band_key(m_dev_type, req_band));
+	if (it == dev_band_nom_power_param_map.end()) {
+		dev_desc desc = dev_param_map.at(m_dev_type);
+		LOGC(DDEV, ERROR) << "No Tx Power measurements exist for device "
+				    << desc.name_prefix << " on band " << gsm_band_name(req_band)
+				    << ", using LimeSDR-USB ones as fallback";
+		it = dev_band_nom_power_param_map.find(dev_band_key(LMS_DEV_SDR_USB, req_band));
+	}
+	OSMO_ASSERT(it != dev_band_nom_power_param_map.end());
+	band_desc = it->second;
+}
+
+bool LMSDevice::set_band(enum gsm_band req_band)
+{
+	if (band_ass_curr_sess && req_band != band) {
+		LOGC(DDEV, ALERT) << "Requesting band " << gsm_band_name(req_band)
+				  << " different from previous band " << gsm_band_name(band);
+		return false;
+	}
+
+	if (req_band != band) {
+		band = req_band;
+		assign_band_desc(band);
+	}
+	band_ass_curr_sess = true;
+	return true;
+}
+
+void LMSDevice::get_dev_band_desc(dev_band_desc& desc)
+{
+	if (band == 0) {
+		LOGC(DDEV, ERROR) << "Power parameters requested before Tx Frequency was set! Providing band 900 by default...";
+		assign_band_desc(GSM_BAND_900);
+	}
+	desc = band_desc;
+}
+
 int LMSDevice::open(const std::string &args, int ref, bool swap_channels)
 {
 	lms_info_str_t* info_list;
@@ -210,11 +277,12 @@ int LMSDevice::open(const std::string &args, int ref, bool swap_channels)
 
 	LMS_RegisterLogHandler(&lms_log_callback);
 
-	if ((n = LMS_GetDeviceList(NULL)) < 0)
+	if ((rc = LMS_GetDeviceList(NULL)) < 0)
 		LOGC(DDEV, ERROR) << "LMS_GetDeviceList(NULL) failed";
-	LOGC(DDEV, INFO) << "Devices found: " << n;
-	if (n < 1)
+	LOGC(DDEV, INFO) << "Devices found: " << rc;
+	if (rc < 1)
 	    return -1;
+	n = rc;
 
 	info_list = new lms_info_str_t[n];
 
@@ -322,17 +390,20 @@ bool LMSDevice::start()
 	LOGC(DDEV, INFO) << "starting LMS...";
 
 	unsigned int i;
+	dev_band_desc desc;
 
 	if (started) {
 		LOGC(DDEV, ERR) << "Device already started";
 		return false;
 	}
 
+	get_dev_band_desc(desc);
+
 	/* configure the channels/streams */
 	for (i=0; i<chans; i++) {
 		/* Set gains for calibration/filter setup */
 		/* TX gain to maximum */
-		setTxGain(maxTxGain(), i);
+		LMS_SetGaindB(m_lms_dev, LMS_CH_TX, i, TxPower2TxGain(desc, desc.nom_out_tx_power));
 		/* RX gain to midpoint */
 		setRxGain((minRxGain() + maxRxGain()) / 2, i);
 
@@ -398,6 +469,8 @@ bool LMSDevice::stop()
 		LMS_DestroyStream(m_lms_dev, &m_lms_stream_rx[i]);
 	}
 
+	band_ass_curr_sess = false;
+
 	started = false;
 	return true;
 }
@@ -477,17 +550,6 @@ bool LMSDevice::do_filters(size_t chan)
 	return true;
 }
 
-
-double LMSDevice::maxTxGain()
-{
-	return dev_param_map.at(m_dev_type).max_tx_gain;
-}
-
-double LMSDevice::minTxGain()
-{
-	return 0.0;
-}
-
 double LMSDevice::maxRxGain()
 {
 	return 73.0;
@@ -498,22 +560,6 @@ double LMSDevice::minRxGain()
 	return 0.0;
 }
 
-double LMSDevice::setTxGain(double dB, size_t chan)
-{
-	if (dB > maxTxGain())
-		dB = maxTxGain();
-	if (dB < minTxGain())
-		dB = minTxGain();
-
-	LOGCHAN(chan, DDEV, NOTICE) << "Setting TX gain to " << dB << " dB";
-
-	if (LMS_SetGaindB(m_lms_dev, LMS_CH_TX, chan, dB) < 0)
-		LOGCHAN(chan, DDEV, ERR) << "Error setting TX gain to " << dB << " dB";
-	else
-		tx_gains[chan] = dB;
-	return tx_gains[chan];
-}
-
 double LMSDevice::setRxGain(double dB, size_t chan)
 {
 	if (dB > maxRxGain())
@@ -530,6 +576,63 @@ double LMSDevice::setRxGain(double dB, size_t chan)
 	return rx_gains[chan];
 }
 
+double LMSDevice::rssiOffset(size_t chan)
+{
+	double rssiOffset;
+	dev_band_desc desc;
+
+	if (chan >= rx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return 0.0f;
+	}
+
+	get_dev_band_desc(desc);
+	rssiOffset = rx_gains[chan] + desc.rxgain2rssioffset_rel;
+	return rssiOffset;
+}
+
+double LMSDevice::setPowerAttenuation(int atten, size_t chan)
+{
+	double tx_power, dB;
+	dev_band_desc desc;
+
+	if (chan >= tx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return 0.0f;
+	}
+
+	get_dev_band_desc(desc);
+	tx_power = desc.nom_out_tx_power - atten;
+	dB = TxPower2TxGain(desc, tx_power);
+
+	LOGCHAN(chan, DDEV, NOTICE) << "Setting TX gain to " << dB << " dB (~" << tx_power << " dBm)";
+
+	if (LMS_SetGaindB(m_lms_dev, LMS_CH_TX, chan, dB) < 0)
+		LOGCHAN(chan, DDEV, ERR) << "Error setting TX gain to " << dB << " dB (~" << tx_power << " dBm)";
+	else
+		tx_gains[chan] = dB;
+	return desc.nom_out_tx_power - TxGain2TxPower(desc, tx_gains[chan]);
+}
+
+double LMSDevice::getPowerAttenuation(size_t chan) {
+	dev_band_desc desc;
+	if (chan >= tx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return 0.0f;
+	}
+
+	get_dev_band_desc(desc);
+	return desc.nom_out_tx_power - TxGain2TxPower(desc, tx_gains[chan]);
+}
+
+int LMSDevice::getNominalTxPower(size_t chan)
+{
+	dev_band_desc desc;
+	get_dev_band_desc(desc);
+
+	return desc.nom_out_tx_power;
+}
+
 void LMSDevice::log_ant_list(bool dir_tx, size_t chan, std::ostringstream& os)
 {
 	lms_name_t name_list[MAX_ANTENNA_LIST_SIZE]; /* large enough list for antenna names. */
@@ -896,8 +999,30 @@ bool LMSDevice::updateAlignment(TIMESTAMP timestamp)
 
 bool LMSDevice::setTxFreq(double wFreq, size_t chan)
 {
+	uint16_t req_arfcn;
+	enum gsm_band req_band;
+
+	if (chan >= chans) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return false;
+	}
+
 	LOGCHAN(chan, DDEV, NOTICE) << "Setting Tx Freq to " << wFreq << " Hz";
 
+	req_arfcn = gsm_freq102arfcn(wFreq / 1000 / 100 , 0);
+	if (req_arfcn == 0xffff) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown ARFCN for Tx Frequency " << wFreq / 1000 << " kHz";
+		return false;
+	}
+	if (gsm_arfcn2band_rc(req_arfcn, &req_band) < 0) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown GSM band for Tx Frequency " << wFreq
+					   << " Hz (ARFCN " << req_arfcn << " )";
+		return false;
+	}
+
+	if (!set_band(req_band))
+		return false;
+
 	if (LMS_SetLOFrequency(m_lms_dev, LMS_CH_TX, chan, wFreq) < 0) {
 		LOGCHAN(chan, DDEV, ERROR) << "Error setting Tx Freq to " << wFreq << " Hz";
 		return false;
@@ -908,8 +1033,25 @@ bool LMSDevice::setTxFreq(double wFreq, size_t chan)
 
 bool LMSDevice::setRxFreq(double wFreq, size_t chan)
 {
+	uint16_t req_arfcn;
+	enum gsm_band req_band;
+
 	LOGCHAN(chan, DDEV, NOTICE) << "Setting Rx Freq to " << wFreq << " Hz";
 
+	req_arfcn = gsm_freq102arfcn(wFreq / 1000 / 100, 1);
+	if (req_arfcn == 0xffff) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown ARFCN for Rx Frequency " << wFreq / 1000 << " kHz";
+		return false;
+	}
+	if (gsm_arfcn2band_rc(req_arfcn, &req_band) < 0) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown GSM band for Rx Frequency " << wFreq
+					   << " Hz (ARFCN " << req_arfcn << " )";
+		return false;
+	}
+
+	if (!set_band(req_band))
+		return false;
+
 	if (LMS_SetLOFrequency(m_lms_dev, LMS_CH_RX, chan, wFreq) < 0) {
 		LOGCHAN(chan, DDEV, ERROR) << "Error setting Rx Freq to " << wFreq << " Hz";
 		return false;

Transceiver52M/device/lms/LMSDevice.h

@@ -32,6 +32,10 @@
 #include <iostream>
 #include <lime/LimeSuite.h>
 
+extern "C" {
+#include <osmocom/gsm/gsm_utils.h>
+}
+
 /* Definition of LIMESDR_TX_AMPL limits maximum amplitude of I and Q
  * channels separately. Hence LIMESDR_TX_AMPL value must be 1/sqrt(2) =
  * 0.7071.... to get an amplitude of 1 of the complex signal:
@@ -48,6 +52,23 @@ enum lms_dev_type {
 	LMS_DEV_UNKNOWN,
 };
 
+struct dev_band_desc {
+	/* Maximum LimeSuite Tx Gain which can be set/used without distorting
+	   the output * signal, and the resulting real output power measured
+	   when that gain is used.
+	 */
+	double nom_lms_tx_gain;  /* dB */
+	double nom_out_tx_power; /* dBm */
+	/* Factor used to infer base real RSSI offset on the Rx path based on current
+	   configured RxGain. The resulting rssiOffset is added to the per burst
+	   calculated energy in upper layers. These values were empirically
+	   found and may change based on multiple factors, see OS#4468.
+	   Correct measured values only provided for LimeSDR-USB so far.
+	   rssiOffset = rxGain + rxgain2rssioffset_rel;
+	*/
+	double rxgain2rssioffset_rel; /* dB */
+};
+
 /** A class to handle a LimeSuite supported device */
 class LMSDevice:public RadioDevice {
 
@@ -66,6 +87,9 @@ private:
 	TIMESTAMP ts_initial, ts_offset;
 
 	std::vector<double> tx_gains, rx_gains;
+	bool band_ass_curr_sess; /* true if  "band" was set after last POWEROFF */
+	enum gsm_band band;
+	struct dev_band_desc band_desc;
 
 	enum lms_dev_type m_dev_type;
 
@@ -77,7 +101,9 @@ private:
 	void update_stream_stats_rx(size_t chan, bool *overrun);
 	void update_stream_stats_tx(size_t chan, bool *underrun);
 	bool do_clock_src_freq(enum ReferenceType ref, double freq);
-
+	void get_dev_band_desc(dev_band_desc& desc);
+	bool set_band(enum gsm_band req_band);
+	void assign_band_desc(enum gsm_band req_band);
 public:
 
 	/** Object constructor */
@@ -165,19 +191,12 @@ public:
 	/** return minimum Rx Gain **/
 	double minRxGain(void);
 
-	/** sets the transmit chan gain, returns the gain setting **/
-	double setTxGain(double dB, size_t chan = 0);
+	double rssiOffset(size_t chan);
 
-	/** get transmit gain */
-	double getTxGain(size_t chan = 0) {
-		return tx_gains[chan];
-	}
+	double setPowerAttenuation(int atten, size_t chan);
+	double getPowerAttenuation(size_t chan = 0);
 
-	/** return maximum Tx Gain **/
-	double maxTxGain(void);
-
-	/** return minimum Rx Gain **/
-	double minTxGain(void);
+	int getNominalTxPower(size_t chan = 0);
 
 	/** sets the RX path to use, returns true if successful and false otherwise */
 	bool setRxAntenna(const std::string & ant, size_t chan = 0);

Transceiver52M/device/lms/Makefile.am

@@ -1,7 +1,7 @@
 include $(top_srcdir)/Makefile.common
 
 AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/../common
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS) $(LMS_CFLAGS)
+AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LMS_CFLAGS)
 
 noinst_HEADERS = LMSDevice.h
 

Transceiver52M/device/uhd/Makefile.am

@@ -1,7 +1,7 @@
 include $(top_srcdir)/Makefile.common
 
 AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/../common
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS) $(UHD_CFLAGS)
+AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOVTY_CFLAGS) $(UHD_CFLAGS)
 
 noinst_HEADERS = UHDDevice.h
 

Transceiver52M/device/uhd/UHDDevice.cpp

@@ -33,6 +33,12 @@
 #include "config.h"
 #endif
 
+extern "C" {
+#include <osmocom/core/utils.h>
+#include <osmocom/gsm/gsm_utils.h>
+#include <osmocom/vty/cpu_sched_vty.h>
+}
+
 #ifdef USE_UHD_3_11
 #include <uhd/utils/log_add.hpp>
 #include <uhd/utils/thread.hpp>
@@ -123,9 +129,23 @@ static const std::map<dev_key, dev_desc> dev_param_map {
 	{ std::make_tuple(B2XX_MCBTS, 4, 4), { 1, 51.2e6, MCBTS_SPACING*4, B2XX_TIMING_MCBTS, "B200/B210 4 SPS Multi-ARFCN" } },
 };
 
+typedef std::tuple<uhd_dev_type, enum gsm_band> dev_band_key;
+typedef std::map<dev_band_key, dev_band_desc>::const_iterator dev_band_map_it;
+static const std::map<dev_band_key, dev_band_desc> dev_band_nom_power_param_map {
+	{ std::make_tuple(B200, GSM_BAND_850),	{ 89.75, 13.3, -7.5  } },
+	{ std::make_tuple(B200, GSM_BAND_900),	{ 89.75, 13.3, -7.5  } },
+	{ std::make_tuple(B200, GSM_BAND_1800),	{ 89.75, 7.5,  -11.0 } },
+	{ std::make_tuple(B200, GSM_BAND_1900),	{ 89.75, 7.7,  -11.0 } },
+	{ std::make_tuple(B210, GSM_BAND_850),	{ 89.75, 13.3, -7.5  } },
+	{ std::make_tuple(B210, GSM_BAND_900),	{ 89.75, 13.3, -7.5  } },
+	{ std::make_tuple(B210, GSM_BAND_1800),	{ 89.75, 7.5,  -11.0 } },
+	{ std::make_tuple(B210, GSM_BAND_1900),	{ 89.75, 7.7,  -11.0 } },
+};
+
 void *async_event_loop(uhd_device *dev)
 {
 	set_selfthread_name("UHDAsyncEvent");
+	osmo_cpu_sched_vty_apply_localthread();
 
 	while (1) {
 		dev->recv_async_msg();
@@ -188,14 +208,25 @@ static void uhd_msg_handler(uhd::msg::type_t type, const std::string &msg)
 }
 #endif
 
+/* So far measurements done for B210 show really close to linear relationship
+ * between gain and real output power, so we simply adjust the measured offset
+ */
+static double TxGain2TxPower(const dev_band_desc &desc, double tx_gain_db)
+{
+	return desc.nom_out_tx_power - (desc.nom_uhd_tx_gain - tx_gain_db);
+}
+static double TxPower2TxGain(const dev_band_desc &desc, double tx_power_dbm)
+{
+	return desc.nom_uhd_tx_gain - (desc.nom_out_tx_power - tx_power_dbm);
+}
+
 uhd_device::uhd_device(size_t tx_sps, size_t rx_sps,
 		       InterfaceType iface, size_t chan_num, double lo_offset,
 		       const std::vector<std::string>& tx_paths,
 		       const std::vector<std::string>& rx_paths)
 	: RadioDevice(tx_sps, rx_sps, iface, chan_num, lo_offset, tx_paths, rx_paths),
-	  tx_gain_min(0.0), tx_gain_max(0.0),
-	  rx_gain_min(0.0), rx_gain_max(0.0),
-	  tx_spp(0), rx_spp(0),
+	  rx_gain_min(0.0), rx_gain_max(0.0), band_ass_curr_sess(false),
+	  band((enum gsm_band)0), tx_spp(0), rx_spp(0),
 	  started(false), aligned(false), drop_cnt(0),
 	  prev_ts(0,0), ts_initial(0), ts_offset(0), async_event_thrd(NULL)
 {
@@ -209,8 +240,50 @@ uhd_device::~uhd_device()
 		delete rx_buffers[i];
 }
 
+void uhd_device::assign_band_desc(enum gsm_band req_band)
+{
+	dev_band_map_it it;
+
+	it = dev_band_nom_power_param_map.find(dev_band_key(dev_type, req_band));
+	if (it == dev_band_nom_power_param_map.end()) {
+		dev_desc desc = dev_param_map.at(dev_key(dev_type, tx_sps, rx_sps));
+		LOGC(DDEV, ERROR) << "No Power parameters exist for device "
+				    << desc.str << " on band " << gsm_band_name(req_band)
+				    << ", using B210 ones as fallback";
+		it = dev_band_nom_power_param_map.find(dev_band_key(B210, req_band));
+	}
+	OSMO_ASSERT(it != dev_band_nom_power_param_map.end())
+	band_desc = it->second;
+}
+
+bool uhd_device::set_band(enum gsm_band req_band)
+{
+	if (band_ass_curr_sess && req_band != band) {
+		LOGC(DDEV, ALERT) << "Requesting band " << gsm_band_name(req_band)
+				  << " different from previous band " << gsm_band_name(band);
+		return false;
+	}
+
+	if (req_band != band) {
+		band = req_band;
+		assign_band_desc(band);
+	}
+	band_ass_curr_sess = true;
+	return true;
+}
+
+void uhd_device::get_dev_band_desc(dev_band_desc& desc)
+{
+	if (band == 0) {
+		LOGC(DDEV, ERROR) << "Power parameters requested before Tx Frequency was set! Providing band 900 by default...";
+		assign_band_desc(GSM_BAND_900);
+	}
+	desc = band_desc;
+}
+
 void uhd_device::init_gains()
 {
+	double tx_gain_min, tx_gain_max;
 	uhd::gain_range_t range;
 
 	if (dev_type == UMTRX) {
@@ -275,37 +348,6 @@ void uhd_device::set_rates()
 	LOGC(DDEV, INFO) << "Rates configured for " << desc.str;
 }
 
-double uhd_device::setTxGain(double db, size_t chan)
-{
-	if (chan >= tx_gains.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel" << chan;
-		return 0.0f;
-	}
-
-	if (dev_type == UMTRX) {
-		std::vector<std::string> gain_stages = usrp_dev->get_tx_gain_names(0);
-		if (gain_stages[0] == "VGA" || gain_stages[0] == "PA") {
-			usrp_dev->set_tx_gain(db, chan);
-		} else {
-			// New UHD versions support split configuration of
-			// Tx gain stages. We utilize this to set the gain
-			// configuration, optimal for the Tx signal quality.
-			// From our measurements, VGA1 must be 18dB plus-minus
-			// one and VGA2 is the best when 23dB or lower.
-			usrp_dev->set_tx_gain(UMTRX_VGA1_DEF, "VGA1", chan);
-			usrp_dev->set_tx_gain(db-UMTRX_VGA1_DEF, "VGA2", chan);
-		}
-	} else {
-		usrp_dev->set_tx_gain(db, chan);
-	}
-
-	tx_gains[chan] = usrp_dev->get_tx_gain(chan);
-
-	LOGC(DDEV, INFO) << "Set TX gain to " << tx_gains[chan] << "dB (asked for " << db << "dB)";
-
-	return tx_gains[chan];
-}
-
 double uhd_device::setRxGain(double db, size_t chan)
 {
 	if (chan >= rx_gains.size()) {
@@ -331,14 +373,76 @@ double uhd_device::getRxGain(size_t chan)
 	return rx_gains[chan];
 }
 
-double uhd_device::getTxGain(size_t chan)
+double uhd_device::rssiOffset(size_t chan)
 {
+	double rssiOffset;
+	dev_band_desc desc;
+
+	if (chan >= rx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return 0.0f;
+	}
+
+	get_dev_band_desc(desc);
+	rssiOffset = rx_gains[chan] + desc.rxgain2rssioffset_rel;
+	return rssiOffset;
+}
+
+double uhd_device::setPowerAttenuation(int atten, size_t chan) {
+	double tx_power, db;
+	dev_band_desc desc;
+
+	if (chan >= tx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel" << chan;
+		return 0.0f;
+	}
+
+	get_dev_band_desc(desc);
+	tx_power = desc.nom_out_tx_power - atten;
+	db = TxPower2TxGain(desc, tx_power);
+
+	if (dev_type == UMTRX) {
+		std::vector<std::string> gain_stages = usrp_dev->get_tx_gain_names(0);
+		if (gain_stages[0] == "VGA" || gain_stages[0] == "PA") {
+			usrp_dev->set_tx_gain(db, chan);
+		} else {
+			// New UHD versions support split configuration of
+			// Tx gain stages. We utilize this to set the gain
+			// configuration, optimal for the Tx signal quality.
+			// From our measurements, VGA1 must be 18dB plus-minus
+			// one and VGA2 is the best when 23dB or lower.
+			usrp_dev->set_tx_gain(UMTRX_VGA1_DEF, "VGA1", chan);
+			usrp_dev->set_tx_gain(db-UMTRX_VGA1_DEF, "VGA2", chan);
+		}
+	} else {
+		usrp_dev->set_tx_gain(db, chan);
+	}
+
+	tx_gains[chan] = usrp_dev->get_tx_gain(chan);
+
+	LOGC(DDEV, INFO) << "Set TX gain to " << tx_gains[chan] << "dB, ~"
+			 <<  TxGain2TxPower(desc, tx_gains[chan]) << " dBm "
+			 << "(asked for " << db << " dB, ~" << tx_power << " dBm)";
+
+	return desc.nom_out_tx_power - TxGain2TxPower(desc, tx_gains[chan]);
+}
+double uhd_device::getPowerAttenuation(size_t chan) {
+	dev_band_desc desc;
 	if (chan >= tx_gains.size()) {
 		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
 		return 0.0f;
 	}
 
-	return tx_gains[chan];
+	get_dev_band_desc(desc);
+	return desc.nom_out_tx_power - TxGain2TxPower(desc, tx_gains[chan]);
+}
+
+int uhd_device::getNominalTxPower(size_t chan)
+{
+	dev_band_desc desc;
+	get_dev_band_desc(desc);
+
+	return desc.nom_out_tx_power;
 }
 
 /*
@@ -447,12 +551,13 @@ void uhd_device::set_channels(bool swap)
 int uhd_device::open(const std::string &args, int ref, bool swap_channels)
 {
 	const char *refstr;
+	int clock_lock_attempts = 15;
 
 	/* Register msg handler. Different APIs depending on UHD version */
 #ifdef USE_UHD_3_11
 	uhd::log::add_logger("OsmoTRX", &uhd_log_handler);
 	uhd::log::set_log_level(uhd::log::debug);
-	uhd::log::set_console_level(uhd::log::off);
+	uhd::log::set_console_level(uhd::log::debug);
 	uhd::log::set_logger_level("OsmoTRX", uhd::log::debug);
 #else
 	uhd::msg::register_handler(&uhd_msg_handler);
@@ -519,6 +624,19 @@ int uhd_device::open(const std::string &args, int ref, bool swap_channels)
 
 	usrp_dev->set_clock_source(refstr);
 
+	std::vector<std::string> sensor_names = usrp_dev->get_mboard_sensor_names();
+	if (std::find(sensor_names.begin(), sensor_names.end(), "ref_locked") != sensor_names.end()) {
+		LOGC(DDEV, INFO) << "Waiting for clock reference lock (max " << clock_lock_attempts << "s)..." << std::flush;
+		while (!usrp_dev->get_mboard_sensor("ref_locked", 0).to_bool() && clock_lock_attempts--)
+			sleep(1);
+
+		if (!clock_lock_attempts) {
+			LOGC(DDEV, ALERT) << "Locking to external 10Mhz failed!";
+			return -1;
+		}
+	}
+	LOGC(DDEV, INFO) << "Selected clock source is " << usrp_dev->get_clock_source(0);
+
 	try {
 		set_rates();
         } catch (const std::exception &e) {
@@ -674,6 +792,12 @@ bool uhd_device::stop()
 	async_event_thrd->join();
 	delete async_event_thrd;
 
+	/* reset internal buffer timestamps */
+	for (size_t i = 0; i < rx_buffers.size(); i++)
+		rx_buffers[i]->reset();
+
+	band_ass_curr_sess = false;
+
 	started = false;
 	return true;
 }
@@ -746,7 +870,7 @@ int uhd_device::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
 	if (rc < 0) {
 		LOGC(DDEV, ERROR) << rx_buffers[0]->str_code(rc);
 		LOGC(DDEV, ERROR) << rx_buffers[0]->str_status(timestamp);
-		return 0;
+		return len;
 	}
 
 	// Receive samples from the usrp until we have enough
@@ -851,13 +975,14 @@ int uhd_device::writeSamples(std::vector<short *> &bufs, int len, bool *underrun
 
 bool uhd_device::updateAlignment(TIMESTAMP timestamp)
 {
+	aligned = false;
 	return true;
 }
 
 uhd::tune_request_t uhd_device::select_freq(double freq, size_t chan, bool tx)
 {
 	double rf_spread, rf_freq;
-	std::vector<double> freqs;
+	std::vector<tune_result> freqs;
 	uhd::tune_request_t treq(freq);
 
 	if (dev_type == UMTRX) {
@@ -889,17 +1014,17 @@ uhd::tune_request_t uhd_device::select_freq(double freq, size_t chan, bool tx)
 		freqs = rx_freqs;
 
 	/* Tune directly if other channel isn't tuned */
-	if (freqs[!chan] < 10.0)
+	if (freqs[!chan].freq < 10.0)
 		return treq;
 
 	/* Find center frequency between channels */
-	rf_spread = fabs(freqs[!chan] - freq);
+	rf_spread = fabs(freqs[!chan].freq - freq);
 	if (rf_spread > dev_param_map.at(dev_key(B210, tx_sps, rx_sps)).mcr) {
 		LOGC(DDEV, ALERT) << rf_spread << "Hz tuning spread not supported\n";
 		return treq;
 	}
 
-	rf_freq = (freqs[!chan] + freq) / 2.0f;
+	rf_freq = (freqs[!chan].freq + freq) / 2.0f;
 
 	treq.rf_freq_policy = uhd::tune_request_t::POLICY_MANUAL;
 	treq.target_freq = freq;
@@ -917,11 +1042,13 @@ bool uhd_device::set_freq(double freq, size_t chan, bool tx)
 
 	if (tx) {
 		tres = usrp_dev->set_tx_freq(treq, chan);
-		tx_freqs[chan] = usrp_dev->get_tx_freq(chan);
+		tx_freqs[chan].uhd = tres;
+		tx_freqs[chan].freq = usrp_dev->get_tx_freq(chan);
 		str_dir = "Tx";
 	} else {
 		tres = usrp_dev->set_rx_freq(treq, chan);
-		rx_freqs[chan] = usrp_dev->get_rx_freq(chan);
+		rx_freqs[chan].uhd = tres;
+		rx_freqs[chan].freq = usrp_dev->get_rx_freq(chan);
 		str_dir = "Rx";
 	}
 	LOGCHAN(chan, DDEV, INFO) << "set_freq(" << freq << ", " << str_dir << "): " << tres.to_pp_string() << std::endl;
@@ -935,13 +1062,15 @@ bool uhd_device::set_freq(double freq, size_t chan, bool tx)
 	 */
 	if (treq.rf_freq_policy == uhd::tune_request_t::POLICY_MANUAL) {
 		if (tx) {
-			treq = select_freq(tx_freqs[!chan], !chan, true);
+			treq = select_freq(tx_freqs[!chan].freq, !chan, true);
 			tres = usrp_dev->set_tx_freq(treq, !chan);
-			tx_freqs[!chan] = usrp_dev->get_tx_freq(!chan);
+			tx_freqs[chan].uhd = tres;
+			tx_freqs[!chan].freq = usrp_dev->get_tx_freq(!chan);
 		} else {
-			treq = select_freq(rx_freqs[!chan], !chan, false);
+			treq = select_freq(rx_freqs[!chan].freq, !chan, false);
 			tres = usrp_dev->set_rx_freq(treq, !chan);
-			rx_freqs[!chan] = usrp_dev->get_rx_freq(!chan);
+			tx_freqs[chan].uhd = tres;
+			rx_freqs[!chan].freq = usrp_dev->get_rx_freq(!chan);
 
 		}
 		LOGCHAN(chan, DDEV, INFO) << "set_freq(" << freq << ", " << str_dir << "): " << tres.to_pp_string() << std::endl;
@@ -952,23 +1081,74 @@ bool uhd_device::set_freq(double freq, size_t chan, bool tx)
 
 bool uhd_device::setTxFreq(double wFreq, size_t chan)
 {
+	uint16_t req_arfcn;
+	enum gsm_band req_band;
+
 	if (chan >= tx_freqs.size()) {
 		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
 		return false;
 	}
 	ScopedLock lock(tune_lock);
 
-	return set_freq(wFreq, chan, true);
+	req_arfcn = gsm_freq102arfcn(wFreq / 1000 / 100 , 0);
+	if (req_arfcn == 0xffff) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown ARFCN for Tx Frequency " << wFreq / 1000 << " kHz";
+		return false;
+	}
+	if (gsm_arfcn2band_rc(req_arfcn, &req_band) < 0) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown GSM band for Tx Frequency " << wFreq
+					   << " Hz (ARFCN " << req_arfcn << " )";
+		return false;
+	}
+
+	if (!set_band(req_band))
+		return false;
+
+	if (!set_freq(wFreq, chan, true))
+		return false;
+
+	return true;
+}
+
+bool uhd_device::setRxOffset(double wOffset, size_t chan)
+{
+	uhd::tune_result_t tres;
+	uhd::tune_request_t treq(rx_freqs[chan].freq - wOffset);
+
+	treq.rf_freq_policy = uhd::tune_request_t::POLICY_MANUAL;
+	treq.rf_freq = rx_freqs[chan].uhd.actual_rf_freq;
+
+	tres = usrp_dev->set_rx_freq(treq, chan);
+	rx_freqs[chan].freq = usrp_dev->get_rx_freq(chan);
+
+	return true;
 }
 
 bool uhd_device::setRxFreq(double wFreq, size_t chan)
 {
+	uint16_t req_arfcn;
+	enum gsm_band req_band;
+
 	if (chan >= rx_freqs.size()) {
 		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
 		return false;
 	}
 	ScopedLock lock(tune_lock);
 
+	// req_arfcn = gsm_freq102arfcn(wFreq / 1000 / 100, 1);
+	// if (req_arfcn == 0xffff) {
+	// 	LOGCHAN(chan, DDEV, ALERT) << "Unknown ARFCN for Rx Frequency " << wFreq / 1000 << " kHz";
+	// 	return false;
+	// }
+	// if (gsm_arfcn2band_rc(req_arfcn, &req_band) < 0) {
+	// 	LOGCHAN(chan, DDEV, ALERT) << "Unknown GSM band for Rx Frequency " << wFreq
+	// 				   << " Hz (ARFCN " << req_arfcn << " )";
+	// 	return false;
+	// }
+
+	// if (!set_band(req_band))
+	// 	return false;
+
 	return set_freq(wFreq, chan, false);
 }
 
@@ -979,7 +1159,7 @@ double uhd_device::getTxFreq(size_t chan)
 		return 0.0;
 	}
 
-	return tx_freqs[chan];
+	return tx_freqs[chan].freq;
 }
 
 double uhd_device::getRxFreq(size_t chan)
@@ -989,7 +1169,7 @@ double uhd_device::getRxFreq(size_t chan)
 		return 0.0;
 	}
 
-	return rx_freqs[chan];
+	return rx_freqs[chan].freq;
 }
 
 bool uhd_device::setRxAntenna(const std::string &ant, size_t chan)
@@ -1000,7 +1180,14 @@ bool uhd_device::setRxAntenna(const std::string &ant, size_t chan)
 		return false;
 	}
 
-	avail = usrp_dev->get_rx_antennas(chan);
+	/* UHD may throw a LookupError/IndexError here (see OS#4636) */
+	try {
+		avail = usrp_dev->get_rx_antennas(chan);
+	} catch (const uhd::index_error &e) {
+		LOGC(DDEV, ALERT) << "UHD Error: " << e.what();
+		return false;
+	}
+
 	if (std::find(avail.begin(), avail.end(), ant) == avail.end()) {
 		LOGC(DDEV, ALERT) << "Requested non-existent Rx antenna " << ant << " on channel " << chan;
 		LOGC(DDEV, INFO) << "Available Rx antennas: ";
@@ -1036,7 +1223,14 @@ bool uhd_device::setTxAntenna(const std::string &ant, size_t chan)
 		return false;
 	}
 
-	avail = usrp_dev->get_tx_antennas(chan);
+	/* UHD may throw a LookupError/IndexError here (see OS#4636) */
+	try {
+		avail = usrp_dev->get_tx_antennas(chan);
+	} catch (const uhd::index_error &e) {
+		LOGC(DDEV, ALERT) << "UHD Error: " << e.what();
+		return false;
+	}
+
 	if (std::find(avail.begin(), avail.end(), ant) == avail.end()) {
 		LOGC(DDEV, ALERT) << "Requested non-existent Tx antenna " << ant << " on channel " << chan;
 		LOGC(DDEV, INFO) << "Available Tx antennas: ";
@@ -1202,6 +1396,7 @@ std::string uhd_device::str_code(uhd::async_metadata_t metadata)
 	return ost.str();
 }
 
+#ifndef IPCMAGIC
 RadioDevice *RadioDevice::make(size_t tx_sps, size_t rx_sps,
 			       InterfaceType iface, size_t chans, double lo_offset,
 			       const std::vector<std::string>& tx_paths,
@@ -1209,3 +1404,4 @@ RadioDevice *RadioDevice::make(size_t tx_sps, size_t rx_sps,
 {
 	return new uhd_device(tx_sps, rx_sps, iface, chans, lo_offset, tx_paths, rx_paths);
 }
+#endif

Transceiver52M/device/uhd/UHDDevice.h

@@ -37,6 +37,10 @@
 #include <uhd/property_tree.hpp>
 #include <uhd/usrp/multi_usrp.hpp>
 
+extern "C" {
+#include <osmocom/gsm/gsm_utils.h>
+}
+
 
 enum uhd_dev_type {
 	USRP1,
@@ -52,6 +56,21 @@ enum uhd_dev_type {
 	LIMESDR,
 };
 
+struct dev_band_desc {
+	/* Maximum UHD Tx Gain which can be set/used without distorting the
+	   output signal, and the resulting real output power measured when that
+	   gain is used. Correct measured values only provided for B210 so far. */
+	double nom_uhd_tx_gain;  /* dB */
+	double nom_out_tx_power; /* dBm */
+	/* Factor used to infer base real RSSI offset on the Rx path based on current
+	   configured RxGain. The resulting rssiOffset is added to the per burst
+	   calculated energy in upper layers. These values were empirically
+	   found and may change based on multiple factors, see OS#4468.
+	   rssiOffset = rxGain + rxgain2rssioffset_rel;
+	*/
+	double rxgain2rssioffset_rel; /* dB */
+};
+
 /*
     uhd_device - UHD implementation of the Device interface. Timestamped samples
                 are sent to and received from the device. An intermediate buffer
@@ -61,6 +80,12 @@ enum uhd_dev_type {
 */
 class uhd_device : public RadioDevice {
 public:
+
+	struct tune_result {
+		uhd::tune_result_t uhd;
+		double freq;
+	};
+
 	uhd_device(size_t tx_sps, size_t rx_sps, InterfaceType type,
 		   size_t chan_num, double offset,
 		   const std::vector<std::string>& tx_paths,
@@ -83,6 +108,7 @@ public:
 
 	bool setTxFreq(double wFreq, size_t chan);
 	bool setRxFreq(double wFreq, size_t chan);
+	bool setRxOffset(double wOffset, size_t chan);
 
 	TIMESTAMP initialWriteTimestamp();
 	TIMESTAMP initialReadTimestamp();
@@ -94,11 +120,12 @@ public:
 	double getRxGain(size_t chan);
 	double maxRxGain(void) { return rx_gain_max; }
 	double minRxGain(void) { return rx_gain_min; }
+	double rssiOffset(size_t chan);
 
-	double setTxGain(double db, size_t chan);
-	double getTxGain(size_t chan = 0);
-	double maxTxGain(void) { return tx_gain_max; }
-	double minTxGain(void) { return tx_gain_min; }
+	double setPowerAttenuation(int atten, size_t chan);
+	double getPowerAttenuation(size_t chan = 0);
+
+	int getNominalTxPower(size_t chan = 0);
 
 	double getTxFreq(size_t chan);
 	double getRxFreq(size_t chan);
@@ -127,7 +154,7 @@ public:
 		ERROR_UNHANDLED = -4,
 	};
 
-private:
+protected:
 	uhd::usrp::multi_usrp::sptr usrp_dev;
 	uhd::tx_streamer::sptr tx_stream;
 	uhd::rx_streamer::sptr rx_stream;
@@ -136,11 +163,13 @@ private:
 
 	double tx_rate, rx_rate;
 
-	double tx_gain_min, tx_gain_max;
 	double rx_gain_min, rx_gain_max;
 
 	std::vector<double> tx_gains, rx_gains;
-	std::vector<double> tx_freqs, rx_freqs;
+	std::vector<tune_result> tx_freqs, rx_freqs;
+	bool band_ass_curr_sess; /* true if  "band" was set after last POWEROFF */
+	enum gsm_band band;
+	struct dev_band_desc band_desc;
 	size_t tx_spp, rx_spp;
 
 	bool started;
@@ -169,6 +198,9 @@ private:
 
 	uhd::tune_request_t select_freq(double wFreq, size_t chan, bool tx);
 	bool set_freq(double freq, size_t chan, bool tx);
+	void get_dev_band_desc(dev_band_desc& desc);
+	bool set_band(enum gsm_band req_band);
+	void assign_band_desc(enum gsm_band req_band);
 
 	Thread *async_event_thrd;
 	Mutex tune_lock;

Transceiver52M/device/usrp1/Makefile.am

@@ -1,7 +1,7 @@
 include $(top_srcdir)/Makefile.common
 
 AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/../common
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS) $(USRP_CFLAGS)
+AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(USRP_CFLAGS)
 
 rev2dir = $(datadir)/usrp/rev2
 rev4dir = $(datadir)/usrp/rev4

Transceiver52M/device/usrp1/USRPDevice.cpp

@@ -205,8 +205,8 @@ bool USRPDevice::start()
   writeLock.unlock();
 
   // Set gains to midpoint
-  setTxGain((minTxGain() + maxTxGain()) / 2);
-  setRxGain((minRxGain() + maxRxGain()) / 2);
+  setTxGain((m_dbTx->gain_min() + m_dbTx->gain_max()) / 2);
+  setRxGain((m_dbTx->gain_min() + m_dbTx->gain_max()) / 2);
 
   data = new short[currDataSize];
   dataStart = 0;
@@ -243,16 +243,6 @@ bool USRPDevice::stop()
 #endif
 }
 
-double USRPDevice::maxTxGain()
-{
-  return m_dbTx->gain_max();
-}
-
-double USRPDevice::minTxGain()
-{
-  return m_dbTx->gain_min();
-}
-
 double USRPDevice::maxRxGain()
 {
   return m_dbRx->gain_max();
@@ -271,10 +261,10 @@ double USRPDevice::setTxGain(double dB, size_t chan)
   }
 
   writeLock.lock();
-  if (dB > maxTxGain())
-    dB = maxTxGain();
-  if (dB < minTxGain())
-    dB = minTxGain();
+  if (dB > m_dbTx->gain_max())
+    dB = m_dbTx->gain_max();
+  if (dB < m_dbTx->gain_min())
+    dB = m_dbTx->gain_min();
 
   LOGC(DDEV, NOTICE) << "Setting TX gain to " << dB << " dB.";
 
@@ -314,6 +304,23 @@ double USRPDevice::setRxGain(double dB, size_t chan)
   return rxGain;
 }
 
+double USRPDevice::setPowerAttenuation(int atten, size_t chan) {
+      double rfGain;
+      rfGain = setTxGain(m_dbTx->gain_max() - atten, chan);
+      return m_dbTx->gain_max() - rfGain;
+}
+double USRPDevice::getPowerAttenuation(size_t chan) {
+      return m_dbTx->gain_max() - getTxGain(chan);
+}
+
+int USRPDevice::getNominalTxPower(size_t chan)
+{
+	/* TODO: return value based on some experimentally generated table depending on
+	 * band/arfcn, which is known here thanks to TXTUNE
+	 */
+	return 23;
+}
+
 bool USRPDevice::setRxAntenna(const std::string &ant, size_t chan)
 {
 	if (chan >= rx_paths.size()) {

Transceiver52M/device/usrp1/USRPDevice.h

@@ -85,6 +85,12 @@ private:
   int writeSamplesControl(std::vector<short *> &bufs, int len, bool *underrun,
                    TIMESTAMP timestamp = 0xffffffff, bool isControl = false);
 
+  /** sets the transmit chan gain, returns the gain setting **/
+  double setTxGain(double dB, size_t chan = 0);
+
+  /** get transmit gain */
+  double getTxGain(size_t chan = 0) { return txGain; }
+
 #ifdef SWLOOPBACK
   short loopbackBuffer[1000000];
   int loopbackBufferSize;
@@ -168,17 +174,12 @@ private:
   /** return minimum Rx Gain **/
   double minRxGain(void);
 
-  /** sets the transmit chan gain, returns the gain setting **/
-  double setTxGain(double dB, size_t chan = 0);
+  double rssiOffset(size_t chan) { return 0.0f;  } /* FIXME: not implemented */
 
-  /** get transmit gain */
-  double getTxGain(size_t chan = 0) { return txGain; }
+  double setPowerAttenuation(int atten, size_t chan);
+  double getPowerAttenuation(size_t chan=0);
 
-  /** return maximum Tx Gain **/
-  double maxTxGain(void);
-
-  /** return minimum Rx Gain **/
-  double minTxGain(void);
+  int getNominalTxPower(size_t chan = 0);
 
   /** sets the RX path to use, returns true if successful and false otherwise */
   bool setRxAntenna(const std::string &ant, size_t chan = 0);

Transceiver52M/fbsb.cpp

@@ -0,0 +1,148 @@
+#include <atomic>
+#include "radioInterface.h"
+#include "Interthread.h"
+#include "GSMCommon.h"
+//#include "Sockets.h"
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+
+static const auto tssize = 156.25;
+static const auto framee_to_read = 12;
+static const auto ts_to_read = framee_to_read * 8;
+static const int fbsb_chunk_len = ts_to_read * 2 * tssize; // contiguous fcch+sch guaranteed
+static const auto corr_offset = 0;
+
+struct fbsb_par {
+
+    enum class fbsb_state {
+	IDLE,
+	INIT,
+        ACQ,
+        WAIT,
+	ACQ_COMPL,
+        DONE
+    };
+
+    int pos;
+    int time_idx;
+    std::atomic<fbsb_state> s;
+    GSM::Time rcvClock[ts_to_read];
+    complex fbsb_buf[fbsb_chunk_len+corr_offset];
+    complex conjbuf[fbsb_chunk_len+corr_offset];
+    complex avgbuf[fbsb_chunk_len+corr_offset];
+    void addclk(GSM::Time c) { rcvClock[time_idx] = c; time_idx++; return;}
+public:
+    fbsb_par() : s(fbsb_state::IDLE) {
+	reset();
+    };
+    bool done() {return !(time_idx < ts_to_read);}
+    void take(void* addr, int num_cplx_sps, GSM::Time c) {
+        memcpy(fbsb_buf+pos+corr_offset,addr, num_cplx_sps * sizeof(complex));
+	pos += num_cplx_sps;
+	assert(pos < fbsb_chunk_len);
+	rcvClock[time_idx] = c;
+	time_idx++;
+    }
+    void reset() {pos = 0;
+		  time_idx = 0;
+//		s = fbsb_state::IDLE;
+		  memset(fbsb_buf, 0, sizeof(fbsb_buf));
+		  memset(conjbuf, 0, sizeof(conjbuf));
+		  memset(avgbuf, 0, sizeof(avgbuf));
+		 }
+    int sz () {return fbsb_chunk_len;}
+    int off () {return corr_offset;}
+
+    // from osmotrx sigproc
+    complex fastPeakDetect(complex* rxBurst, float* index, int N)
+    {
+	    float val, max = 0.0f;
+	    complex amp;
+	    int _index = -1;
+
+	    for (size_t i = 0; i < N; i++) {
+		    val = rxBurst[i].abs();
+		    if (val > max) {
+			    max = val;
+			    _index = i;
+			    amp = rxBurst[i];
+		    }
+	    }
+
+	    if (index)
+		    *index = (float)_index;
+
+	    return amp;
+    }
+
+    void conj_with_lag(complex* in, complex* out, int lag, int offset, int N) {
+	    int total_offset = offset + lag;
+	    for (int s = 0; s < N; s++)
+		    out[s] = in[s + total_offset] * in[s + total_offset - lag].conj();
+    }
+
+    auto ac_sum_with_lag(complex* in, int lag, int offset, int N) {
+	    complex v(0,0);
+	    auto total_offset = offset + lag;
+	    for (auto s = 0; s < N; s++)
+		    v += in[s + total_offset] * in[s + total_offset - lag].conj();
+	    return atan2(v.imag(), v.real());
+    }
+
+
+    bool running_avg_opt(complex* in, complex* out, int avg_window, int val_to_find, int* idx, int N) {
+	    bool found = false;
+	    complex avg0 = 0;
+	    complex scale(avg_window, avg_window);
+	    for (auto i = 0; i < avg_window; i++)
+		    avg0 += in[i];
+	    out[0] = avg0 / scale;
+
+	    //skip first
+	    for (auto i = 1; i < N - avg_window; i++) {
+		    avg0 += in[i-1] - in[i+avg_window];
+		    auto tmp = avg0 / scale;
+		    out[i] = tmp;
+		    if (!found && tmp.abs() > val_to_find) {
+			    found = !found;
+			    *idx = i;
+			    return true;
+		    }
+	    }
+	    return false;
+    }
+
+    int fcch(complex* amp, int* found_idx, bool dump) {
+	conj_with_lag(fbsb_buf, conjbuf, 3, off(), sz());
+
+	running_avg_opt(conjbuf, avgbuf, 48, 1.5e6, found_idx, sz()-off());
+	float pos;
+	auto r = fastPeakDetect(avgbuf, &pos, sz()-off());
+	*found_idx = *found_idx+off();
+	std::cerr << "fcch found at " << pos << " amp: " << r.abs() << std::endl;
+	*amp = r;
+
+	if(dump) {
+		{
+		    auto f = fopen("inbuf.cfile", "wb");
+		    fwrite(fbsb_buf, sz(), 1, f);
+		    fclose(f);
+		}
+		{
+		    auto f = fopen("conjbuf.cfile", "wb");
+		    fwrite(conjbuf, sz(), 1, f);
+		    fclose(f);
+		}
+		{
+		    auto f = fopen("schfcch.cfile", "wb");
+		    fwrite(avgbuf, sz(), 1, f);
+		    fclose(f);
+		}
+		exit(0);
+	    }
+	return pos;
+    }
+};
+

Transceiver52M/grgsm_vitac/constants.h

@@ -0,0 +1,121 @@
+#pragma once
+
+#include <complex>
+
+#define gr_complex std::complex<float>
+
+
+#define GSM_SYMBOL_RATE  (1625000.0/6.0) //symbols per second
+#define GSM_SYMBOL_PERIOD (1.0/GSM_SYMBOL_RATE) //seconds per symbol
+
+//Burst timing
+#define TAIL_BITS         3
+#define GUARD_BITS        8
+#define GUARD_FRACTIONAL  0.25 //fractional part of guard period
+#define GUARD_PERIOD      GUARD_BITS + GUARD_FRACTIONAL
+#define DATA_BITS         57   //size of 1 data block in normal burst
+#define STEALING_BIT      1
+#define N_TRAIN_BITS      26
+#define N_SYNC_BITS       64
+#define USEFUL_BITS       142  //(2*(DATA_BITS+STEALING_BIT) + N_TRAIN_BITS )
+#define FCCH_BITS         USEFUL_BITS
+#define BURST_SIZE        (USEFUL_BITS+2*TAIL_BITS)
+#define ACCESS_BURST_SIZE 88
+#define PROCESSED_CHUNK   BURST_SIZE+2*GUARD_PERIOD
+
+#define SCH_DATA_LEN      39
+#define TS_BITS           (TAIL_BITS+USEFUL_BITS+TAIL_BITS+GUARD_BITS)  //a full TS (156 bits)
+#define TS_PER_FRAME      8
+#define FRAME_BITS        (TS_PER_FRAME * TS_BITS + 2) // 156.25 * 8
+#define FCCH_POS          TAIL_BITS
+#define SYNC_POS          (TAIL_BITS + 39)
+#define TRAIN_POS         ( TAIL_BITS + (DATA_BITS+STEALING_BIT) + 5) //first 5 bits of a training sequence
+													   //aren't used for channel impulse response estimation
+#define TRAIN_BEGINNING   5
+#define SAFETY_MARGIN     6   //
+
+#define FCCH_HITS_NEEDED        (USEFUL_BITS - 4)
+#define FCCH_MAX_MISSES         1
+#define FCCH_MAX_FREQ_OFFSET    100
+
+#define CHAN_IMP_RESP_LENGTH  5
+
+#define MAX_SCH_ERRORS    10  //maximum number of subsequent sch errors after which gsm receiver goes to find_next_fcch state
+
+typedef enum { empty, fcch_burst, sch_burst, normal_burst, rach_burst, dummy, dummy_or_normal, normal_or_noise } burst_type;
+typedef enum { unknown, multiframe_26, multiframe_51 } multiframe_type;
+
+static const unsigned char SYNC_BITS[] = {
+  1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0,
+  0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
+  0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1,
+  0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1
+};
+
+const unsigned FCCH_FRAMES[] = { 0, 10, 20, 30, 40 };
+const unsigned SCH_FRAMES[] = { 1, 11, 21, 31, 41 };
+
+const unsigned BCCH_FRAMES[] = { 2, 3, 4, 5 };          //!!the receiver shouldn't care about logical
+													  //!!channels so this will be removed from this header
+const unsigned TEST_CCH_FRAMES[] = { 2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 24, 25, 26, 27, 28, 29, 32, 33, 34, 35, 36, 37, 38, 39, 42, 43, 44, 45, 46, 47, 48, 49 };
+const unsigned TRAFFIC_CHANNEL_F[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 };
+const unsigned TEST51[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50 };
+
+
+#define TSC0  0
+#define TSC1  1
+#define TSC2  2
+#define TSC3  3
+#define TSC4  4
+#define TSC5  5
+#define TSC6  6
+#define TSC7  7
+#define TS_DUMMY 8
+
+#define TRAIN_SEQ_NUM 9
+
+#define TIMESLOT0  0
+#define TIMESLOT1  1
+#define TIMESLOT2  2
+#define TIMESLOT3  3
+#define TIMESLOT4  4
+#define TIMESLOT5  5
+#define TIMESLOT6  6
+#define TIMESLOT7  7
+
+
+static const unsigned char train_seq[TRAIN_SEQ_NUM][N_TRAIN_BITS] = {
+  {0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1},
+  {0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1},
+  {0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0},
+  {0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0},
+  {0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1},
+  {0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0},
+  {1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1},
+  {1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0},
+  {0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1} // DUMMY
+};
+
+
+//Dummy burst 0xFB 76 0A 4E 09 10 1F 1C 5C 5C 57 4A 33 39 E9 F1 2F A8
+static const unsigned char dummy_burst[] = {
+  0, 0, 0,
+  1, 1, 1, 1, 1, 0, 1, 1, 0, 1,
+  1, 1, 0, 1, 1, 0, 0, 0, 0, 0,
+  1, 0, 1, 0, 0, 1, 0, 0, 1, 1,
+  1, 0, 0, 0, 0, 0, 1, 0, 0, 1,
+  0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+  0, 1, 1, 1, 1, 1, 0, 0,
+
+  0, 1, 1, 1, 0, 0, 0, 1, 0, 1,
+  1, 1, 0, 0, 0, 1, 0, 1, 1, 1,
+  0, 0, 0, 1, 0, 1,
+
+  0, 1, 1, 1, 0, 1, 0, 0, 1, 0,
+  1, 0, 0, 0, 1, 1, 0, 0, 1, 1,
+  0, 0, 1, 1, 1, 0, 0, 1, 1, 1,
+  1, 0, 1, 0, 0, 1, 1, 1, 1, 1,
+  0, 0, 0, 1, 0, 0, 1, 0, 1, 1,
+  1, 1, 1, 0, 1, 0, 1, 0,
+  0, 0, 0
+};

Transceiver52M/grgsm_vitac/grgsm_vitac.cpp

@@ -0,0 +1,331 @@
+/* -*- c++ -*- */
+/*
+ * @file
+ * @author (C) 2009-2017  by Piotr Krysik <ptrkrysik@gmail.com>
+ * @section LICENSE
+ *
+ * Gr-gsm is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * Gr-gsm is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with gr-gsm; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "constants.h"
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <complex>
+
+
+#include <algorithm>
+#include <string.h>
+#include <iostream>
+#include <numeric>
+#include <vector>
+#include <fstream>
+
+#include "viterbi_detector.h"
+#include "grgsm_vitac.h"
+
+//signalVector mChanResp;
+gr_complex d_sch_training_seq[N_SYNC_BITS]; ///<encoded training sequence of a SCH burst
+gr_complex d_norm_training_seq[TRAIN_SEQ_NUM][N_TRAIN_BITS]; ///<encoded training sequences of a normal and dummy burst
+const int d_chan_imp_length = CHAN_IMP_RESP_LENGTH;
+
+void initvita() {
+
+	/**
+	 * Prepare SCH sequence bits
+	 *
+	 * (TS_BITS + 2 * GUARD_PERIOD)
+	 * Burst and two guard periods
+	 * (one guard period is an arbitrary overlap)
+	 */
+	gmsk_mapper(SYNC_BITS, N_SYNC_BITS,
+		d_sch_training_seq, gr_complex(0.0, -1.0));
+	for (auto &i : d_sch_training_seq)
+		i = conj(i);
+
+	/* Prepare bits of training sequences */
+	for (int i = 0; i < TRAIN_SEQ_NUM; i++) {
+		/**
+		 * If first bit of the sequence is 0
+		 * => first symbol is 1, else -1
+		 */
+		gr_complex startpoint = train_seq[i][0] == 0 ?
+			gr_complex(1.0, 0.0) : gr_complex(-1.0, 0.0);
+		gmsk_mapper(train_seq[i], N_TRAIN_BITS,
+			d_norm_training_seq[i], startpoint);
+		for (auto &i : d_norm_training_seq[i])
+			i = conj(i);
+	}
+
+}
+
+MULTI_VER_TARGET_ATTR
+void
+detect_burst(const gr_complex* input,
+	gr_complex* chan_imp_resp, int burst_start,
+	unsigned char* output_binary)
+{
+	std::vector<gr_complex> rhh_temp(CHAN_IMP_RESP_LENGTH * d_OSR);
+	unsigned int stop_states[2] = { 4, 12 };
+	gr_complex filtered_burst[BURST_SIZE];
+	gr_complex rhh[CHAN_IMP_RESP_LENGTH];
+	float output[BURST_SIZE];
+	int start_state = 3;
+
+	autocorrelation(chan_imp_resp, &rhh_temp[0], d_chan_imp_length * d_OSR);
+	for (int ii = 0; ii < d_chan_imp_length; ii++)
+		rhh[ii] = conj(rhh_temp[ii * d_OSR]);
+
+	mafi(&input[burst_start], BURST_SIZE, chan_imp_resp,
+		d_chan_imp_length * d_OSR, filtered_burst);
+
+	viterbi_detector(filtered_burst, BURST_SIZE, rhh,
+		start_state, stop_states, 2, output);
+
+	for (int i = 0; i < BURST_SIZE; i++)
+		output_binary[i] = output[i] > 0;
+}
+
+int process_vita_burst(gr_complex* input, int tsc, unsigned char* output_binary) {
+	gr_complex channel_imp_resp[CHAN_IMP_RESP_LENGTH * d_OSR];
+	int normal_burst_start, dummy_burst_start;
+	float dummy_corr_max, normal_corr_max;
+
+	dummy_burst_start = get_norm_chan_imp_resp(input,
+		&channel_imp_resp[0], &dummy_corr_max, TS_DUMMY);
+	normal_burst_start = get_norm_chan_imp_resp(input,
+		&channel_imp_resp[0], &normal_corr_max, tsc);
+
+	if (normal_corr_max > dummy_corr_max) {
+		/* Perform MLSE detection */
+		detect_burst(input, &channel_imp_resp[0],
+			normal_burst_start, output_binary);
+		
+		return 0;
+
+	} else {
+		memcpy(output_binary, dummy_burst, 148);
+		//std::cerr << std::endl << "#NOPE#" << dd.fpath << std::endl << std::endl;
+		return -1;
+	}
+}
+
+int process_vita_sc_burst(gr_complex* input, int tsc, unsigned char* output_binary, int* offset) {
+	gr_complex channel_imp_resp[CHAN_IMP_RESP_LENGTH * d_OSR];
+
+	/* Get channel impulse response */
+	int d_c0_burst_start = get_sch_chan_imp_resp(input, &channel_imp_resp[0]);
+	//	*offset = d_c0_burst_start;
+	/* Perform MLSE detection */
+	detect_burst(input, &channel_imp_resp[0],
+	d_c0_burst_start, output_binary);
+
+	return 0;
+}
+
+void
+gmsk_mapper(const unsigned char* input,
+	int nitems, gr_complex* gmsk_output, gr_complex start_point)
+{
+	gr_complex j = gr_complex(0.0, 1.0);
+	gmsk_output[0] = start_point;
+
+	int previous_symbol = 2 * input[0] - 1;
+	int current_symbol;
+	int encoded_symbol;
+
+	for (int i = 1; i < nitems; i++) {
+		/* Change bits representation to NRZ */
+		current_symbol = 2 * input[i] - 1;
+
+		/* Differentially encode */
+		encoded_symbol = current_symbol * previous_symbol;
+
+		/* And do GMSK mapping */
+		gmsk_output[i] = j * gr_complex(encoded_symbol, 0.0)
+			* gmsk_output[i - 1];
+
+		previous_symbol = current_symbol;
+	}
+}
+
+gr_complex
+correlate_sequence(const gr_complex* sequence,
+	int length, const gr_complex* input)
+{
+	gr_complex result(0.0, 0.0);
+
+	for (int ii = 0; ii < length; ii++)
+		result += sequence[ii] * input[ii * d_OSR];
+
+	return conj(result) / gr_complex(length, 0);
+}
+
+/* Computes autocorrelation for positive arguments */
+inline void
+autocorrelation(const gr_complex* input,
+	gr_complex* out, int nitems)
+{
+	for (int k = nitems - 1; k >= 0; k--) {
+		out[k] = gr_complex(0, 0);
+		for (int i = k; i < nitems; i++)
+			out[k] += input[i] * conj(input[i - k]);
+	}
+}
+
+inline void
+mafi(const gr_complex* input, int nitems,
+	gr_complex* filter, int filter_length, gr_complex* output)
+{
+	for (int n = 0; n < nitems; n++) {
+		int a = n * d_OSR;
+		output[n] = 0;
+
+		for (int ii = 0; ii < filter_length; ii++) {
+			if ((a + ii) >= nitems * d_OSR)
+				break;
+
+			output[n] += input[a + ii] * filter[ii];
+		}
+	}
+}
+
+int get_chan_imp_resp(const gr_complex *input, gr_complex *chan_imp_resp, int search_center, int search_start_pos,
+		      int search_stop_pos, gr_complex *tseq, int tseqlen, float *corr_max)
+{
+	std::vector<gr_complex> correlation_buffer;
+	std::vector<float> window_energy_buffer;
+	std::vector<float> power_buffer;
+
+	for (int ii = search_start_pos; ii < search_stop_pos; ii++) {
+		gr_complex correlation = correlate_sequence(tseq, tseqlen, &input[ii]);
+		correlation_buffer.push_back(correlation);
+		power_buffer.push_back(std::pow(abs(correlation), 2));
+	}
+
+	int strongest_corr_nr = max_element(power_buffer.begin(), power_buffer.end()) - power_buffer.begin();
+
+	/* Compute window energies */
+	auto window_energy_start_offset = strongest_corr_nr - 6 * d_OSR;
+	auto window_energy_end_offset = strongest_corr_nr + 6 * d_OSR + d_chan_imp_length * d_OSR;
+	auto iter = power_buffer.begin() + window_energy_start_offset;
+	auto iter_end = power_buffer.begin() + window_energy_end_offset;
+	while (iter != iter_end) {
+		std::vector<float>::iterator iter_ii = iter;
+		bool loop_end = false;
+		float energy = 0;
+
+		int len = d_chan_imp_length * d_OSR;
+		for (int ii = 0; ii < len; ii++, iter_ii++) {
+			if (iter_ii == power_buffer.end()) {
+				loop_end = true;
+				break;
+			}
+
+			energy += (*iter_ii);
+		}
+
+		if (loop_end)
+			break;
+
+		window_energy_buffer.push_back(energy);
+		iter++;
+	}
+
+	/* Calculate the strongest window number */
+	int strongest_window_nr = window_energy_start_offset +
+				  max_element(window_energy_buffer.begin(), window_energy_buffer.end()) -
+				  window_energy_buffer.begin();
+
+	// auto window_search_start = window_energy_buffer.begin() + strongest_corr_nr - 5* d_OSR;
+	// auto window_search_end = window_energy_buffer.begin() + strongest_corr_nr + 10* d_OSR;
+	// window_search_end = window_search_end >= window_energy_buffer.end() ? window_energy_buffer.end() : window_search_end;
+
+	// /* Calculate the strongest window number */
+	// int strongest_window_nr = max_element(window_search_start, window_search_end /* - d_chan_imp_length * d_OSR*/) - window_energy_buffer.begin();
+
+	// if (strongest_window_nr < 0)
+	// 	strongest_window_nr = 0;
+
+	float max_correlation = 0;
+	for (int ii = 0; ii < d_chan_imp_length * d_OSR; ii++) {
+		gr_complex correlation = correlation_buffer[strongest_window_nr + ii];
+		if (abs(correlation) > max_correlation)
+			max_correlation = abs(correlation);
+		chan_imp_resp[ii] = correlation;
+	}
+
+	*corr_max = max_correlation;
+
+	/**
+	 * Compute first sample position, which corresponds
+	 * to the first sample of the impulse response
+	 */
+	return search_start_pos + strongest_window_nr - search_center * d_OSR;
+}
+
+/*
+
+3 + 57 + 1 + 26 + 1 + 57 + 3 + 8.25
+
+search center = 3 + 57 + 1 + 5 (due to tsc 5+16+5 split)
+this is +-5 samples around (+5 beginning) of truncated t16 tsc
+
+*/
+int get_norm_chan_imp_resp(const gr_complex *input, gr_complex *chan_imp_resp, float *corr_max, int bcc)
+{
+	const int search_center = TRAIN_POS;
+	const int search_start_pos = (search_center - 5) * d_OSR + 1;
+	const int search_stop_pos = (search_center + 5 + d_chan_imp_length) * d_OSR;
+	const auto tseq = &d_norm_training_seq[bcc][TRAIN_BEGINNING];
+	const auto tseqlen = N_TRAIN_BITS - (2 * TRAIN_BEGINNING);
+	return get_chan_imp_resp(input, chan_imp_resp, search_center, search_start_pos, search_stop_pos, tseq, tseqlen,
+				 corr_max);
+}
+
+/*
+
+3 tail | 39 data | 64 tsc | 39 data | 3 tail | 8.25 guard
+start 3+39 - 10
+end 3+39 + SYNC_SEARCH_RANGE
+
+*/
+int get_sch_chan_imp_resp(const gr_complex *input, gr_complex *chan_imp_resp)
+{
+	const int search_center = SYNC_POS + TRAIN_BEGINNING;
+	const int search_start_pos = (search_center - 10) * d_OSR;
+	const int search_stop_pos = (search_center + SYNC_SEARCH_RANGE) * d_OSR;
+	const auto tseq = &d_sch_training_seq[TRAIN_BEGINNING];
+	const auto tseqlen = N_SYNC_BITS - (2 * TRAIN_BEGINNING);
+
+	// strongest_window_nr + chan_imp_resp_center + SYNC_POS *d_OSR - 48 * d_OSR - 2 * d_OSR + 2 ;
+	float corr_max;
+	return get_chan_imp_resp(input, chan_imp_resp, search_center, search_start_pos, search_stop_pos, tseq, tseqlen,
+				 &corr_max);
+}
+
+int get_sch_buffer_chan_imp_resp(const gr_complex *input, gr_complex *chan_imp_resp, unsigned int len, float *corr_max)
+{
+	const auto tseqlen = N_SYNC_BITS - (2 * TRAIN_BEGINNING);
+	const int search_center = SYNC_POS + TRAIN_BEGINNING;
+	const int search_start_pos = 0;
+	const int search_stop_pos = len - tseqlen;
+	auto tseq = &d_sch_training_seq[TRAIN_BEGINNING];
+
+	return get_chan_imp_resp(input, chan_imp_resp, search_center, search_start_pos, search_stop_pos, tseq, tseqlen,
+				 corr_max);
+}

Transceiver52M/grgsm_vitac/grgsm_vitac.h

@@ -0,0 +1,42 @@
+
+#pragma once
+
+#include <vector>
+#include "constants.h"
+
+#if defined(__has_attribute)
+#if __has_attribute(target_clones) && defined(__x86_64) && false
+#define MULTI_VER_TARGET_ATTR __attribute__((target_clones("avx", "sse4.2", "sse3", "sse2", "sse", "default")))
+#else
+#define MULTI_VER_TARGET_ATTR
+#endif
+#endif
+
+#define SYNC_SEARCH_RANGE 30
+const int d_OSR(4);
+
+void initvita();
+
+int process_vita_burst(gr_complex *input, int tsc, unsigned char *output_binary);
+int process_vita_sc_burst(gr_complex *input, int tsc, unsigned char *output_binary, int *offset);
+
+MULTI_VER_TARGET_ATTR
+void detect_burst(const gr_complex *input, gr_complex *chan_imp_resp, int burst_start, unsigned char *output_binary);
+void gmsk_mapper(const unsigned char *input, int nitems, gr_complex *gmsk_output, gr_complex start_point);
+gr_complex correlate_sequence(const gr_complex *sequence, int length, const gr_complex *input);
+inline void autocorrelation(const gr_complex *input, gr_complex *out, int nitems);
+inline void mafi(const gr_complex *input, int nitems, gr_complex *filter, int filter_length, gr_complex *output);
+int get_sch_chan_imp_resp(const gr_complex *input, gr_complex *chan_imp_resp);
+int get_norm_chan_imp_resp(const gr_complex *input, gr_complex *chan_imp_resp, float *corr_max, int bcc);
+int get_sch_buffer_chan_imp_resp(const gr_complex *input, gr_complex *chan_imp_resp, unsigned int len, float *corr_max);
+
+enum class btype { NB, SCH };
+struct fdata {
+	btype t;
+	unsigned int fn;
+	int tn;
+	int bcc;
+	std::string fpath;
+	std::vector<gr_complex> data;
+	unsigned int data_start_offset;
+};

Transceiver52M/grgsm_vitac/viterbi_detector.cc

@@ -0,0 +1,392 @@
+/* -*- c++ -*- */
+/*
+ * @file
+ * @author (C) 2009 by Piotr Krysik <ptrkrysik@gmail.com>
+ * @section LICENSE
+ *
+ * Gr-gsm is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * Gr-gsm is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with gr-gsm; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+/*
+ * viterbi_detector:
+ *           This part does the detection of received sequnece.
+ *           Employed algorithm is viterbi Maximum Likehood Sequence Estimation.
+ *           At this moment it gives hard decisions on the output, but
+ *           it was designed with soft decisions in mind.
+ *
+ * SYNTAX:   void viterbi_detector(
+ *                                  const gr_complex * input, 
+ *                                  unsigned int samples_num, 
+ *                                  gr_complex * rhh, 
+ *                                  unsigned int start_state, 
+ *                                  const unsigned int * stop_states, 
+ *                                  unsigned int stops_num, 
+ *                                  float * output)
+ *
+ * INPUT:    input:       Complex received signal afted matched filtering.
+ *           samples_num: Number of samples in the input table.
+ *           rhh:         The autocorrelation of the estimated channel 
+ *                        impulse response.
+ *           start_state: Number of the start point. In GSM each burst 
+ *                        starts with sequence of three bits (0,0,0) which 
+ *                        indicates start point of the algorithm.
+ *           stop_states: Table with numbers of possible stop states.
+ *           stops_num:   Number of possible stop states
+ *                     
+ *
+ * OUTPUT:   output:      Differentially decoded hard output of the algorithm: 
+ *                        -1 for logical "0" and 1 for logical "1"
+ *
+ * SUB_FUNC: none
+ *
+ * TEST(S):  Tested with real world normal burst.
+ */
+
+#include "constants.h"
+#include <cmath>
+
+#define PATHS_NUM (1 << (CHAN_IMP_RESP_LENGTH-1))
+
+void viterbi_detector(const gr_complex * input, unsigned int samples_num, gr_complex * rhh, unsigned int start_state, const unsigned int * stop_states, unsigned int stops_num, float * output)
+{
+   float increment[8];
+   float path_metrics1[16];
+   float path_metrics2[16];
+   float paths_difference;
+   float * new_path_metrics;
+   float * old_path_metrics;
+   float * tmp;
+   float trans_table[BURST_SIZE][16];
+   float pm_candidate1, pm_candidate2;
+   bool real_imag;
+   float input_symbol_real, input_symbol_imag;
+   unsigned int i, sample_nr;
+
+/*
+* Setup first path metrics, so only state pointed by start_state is possible.
+* Start_state metric is equal to zero, the rest is written with some very low value,
+* which makes them practically impossible to occur.
+*/
+   for(i=0; i<PATHS_NUM; i++){
+      path_metrics1[i]=(-10e30);
+   }
+   path_metrics1[start_state]=0;
+
+/*
+* Compute Increment - a table of values which does not change for subsequent input samples.
+* Increment is table of reference levels for computation of branch metrics:
+*    branch metric = (+/-)received_sample (+/-) reference_level
+*/
+   increment[0] = -rhh[1].imag() -rhh[2].real() -rhh[3].imag() +rhh[4].real();
+   increment[1] = rhh[1].imag() -rhh[2].real() -rhh[3].imag() +rhh[4].real();
+   increment[2] = -rhh[1].imag() +rhh[2].real() -rhh[3].imag() +rhh[4].real();
+   increment[3] = rhh[1].imag() +rhh[2].real() -rhh[3].imag() +rhh[4].real();
+   increment[4] = -rhh[1].imag() -rhh[2].real() +rhh[3].imag() +rhh[4].real();
+   increment[5] = rhh[1].imag() -rhh[2].real() +rhh[3].imag() +rhh[4].real();
+   increment[6] = -rhh[1].imag() +rhh[2].real() +rhh[3].imag() +rhh[4].real();
+   increment[7] = rhh[1].imag() +rhh[2].real() +rhh[3].imag() +rhh[4].real();
+
+
+/*
+* Computation of path metrics and decisions (Add-Compare-Select).
+* It's composed of two parts: one for odd input samples (imaginary numbers)
+* and one for even samples (real numbers).
+* Each part is composed of independent (parallelisable) statements like  
+* this one:
+*      pm_candidate1 = old_path_metrics[0] -input_symbol_imag +increment[2];
+*      pm_candidate2 = old_path_metrics[8] -input_symbol_imag -increment[5];
+*      paths_difference=pm_candidate2-pm_candidate1;
+*      new_path_metrics[1]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+*      trans_table[sample_nr][1] = paths_difference;
+* This is very good point for optimisations (SIMD or OpenMP) as it's most time 
+* consuming part of this function. 
+*/
+   sample_nr=0;
+   old_path_metrics=path_metrics1;
+   new_path_metrics=path_metrics2;
+   while(sample_nr<samples_num){
+      //Processing imag states
+      real_imag=1;
+      input_symbol_imag = input[sample_nr].imag();
+
+      pm_candidate1 = old_path_metrics[0] +input_symbol_imag -increment[2];
+      pm_candidate2 = old_path_metrics[8] +input_symbol_imag +increment[5];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[0]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][0] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[0] -input_symbol_imag +increment[2];
+      pm_candidate2 = old_path_metrics[8] -input_symbol_imag -increment[5];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[1]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][1] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[1] +input_symbol_imag -increment[3];
+      pm_candidate2 = old_path_metrics[9] +input_symbol_imag +increment[4];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[2]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][2] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[1] -input_symbol_imag +increment[3];
+      pm_candidate2 = old_path_metrics[9] -input_symbol_imag -increment[4];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[3]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][3] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[2] +input_symbol_imag -increment[0];
+      pm_candidate2 = old_path_metrics[10] +input_symbol_imag +increment[7];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[4]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][4] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[2] -input_symbol_imag +increment[0];
+      pm_candidate2 = old_path_metrics[10] -input_symbol_imag -increment[7];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[5]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][5] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[3] +input_symbol_imag -increment[1];
+      pm_candidate2 = old_path_metrics[11] +input_symbol_imag +increment[6];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[6]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][6] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[3] -input_symbol_imag +increment[1];
+      pm_candidate2 = old_path_metrics[11] -input_symbol_imag -increment[6];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[7]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][7] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[4] +input_symbol_imag -increment[6];
+      pm_candidate2 = old_path_metrics[12] +input_symbol_imag +increment[1];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[8]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][8] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[4] -input_symbol_imag +increment[6];
+      pm_candidate2 = old_path_metrics[12] -input_symbol_imag -increment[1];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[9]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][9] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[5] +input_symbol_imag -increment[7];
+      pm_candidate2 = old_path_metrics[13] +input_symbol_imag +increment[0];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[10]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][10] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[5] -input_symbol_imag +increment[7];
+      pm_candidate2 = old_path_metrics[13] -input_symbol_imag -increment[0];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[11]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][11] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[6] +input_symbol_imag -increment[4];
+      pm_candidate2 = old_path_metrics[14] +input_symbol_imag +increment[3];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[12]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][12] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[6] -input_symbol_imag +increment[4];
+      pm_candidate2 = old_path_metrics[14] -input_symbol_imag -increment[3];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[13]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][13] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[7] +input_symbol_imag -increment[5];
+      pm_candidate2 = old_path_metrics[15] +input_symbol_imag +increment[2];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[14]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][14] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[7] -input_symbol_imag +increment[5];
+      pm_candidate2 = old_path_metrics[15] -input_symbol_imag -increment[2];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[15]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][15] = paths_difference;
+      tmp=old_path_metrics;
+      old_path_metrics=new_path_metrics;
+      new_path_metrics=tmp;
+
+      sample_nr++;
+      if(sample_nr==samples_num)
+         break;
+
+      //Processing real states
+      real_imag=0;
+      input_symbol_real = input[sample_nr].real();
+
+      pm_candidate1 = old_path_metrics[0] -input_symbol_real -increment[7];
+      pm_candidate2 = old_path_metrics[8] -input_symbol_real +increment[0];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[0]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][0] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[0] +input_symbol_real +increment[7];
+      pm_candidate2 = old_path_metrics[8] +input_symbol_real -increment[0];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[1]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][1] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[1] -input_symbol_real -increment[6];
+      pm_candidate2 = old_path_metrics[9] -input_symbol_real +increment[1];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[2]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][2] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[1] +input_symbol_real +increment[6];
+      pm_candidate2 = old_path_metrics[9] +input_symbol_real -increment[1];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[3]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][3] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[2] -input_symbol_real -increment[5];
+      pm_candidate2 = old_path_metrics[10] -input_symbol_real +increment[2];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[4]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][4] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[2] +input_symbol_real +increment[5];
+      pm_candidate2 = old_path_metrics[10] +input_symbol_real -increment[2];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[5]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][5] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[3] -input_symbol_real -increment[4];
+      pm_candidate2 = old_path_metrics[11] -input_symbol_real +increment[3];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[6]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][6] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[3] +input_symbol_real +increment[4];
+      pm_candidate2 = old_path_metrics[11] +input_symbol_real -increment[3];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[7]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][7] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[4] -input_symbol_real -increment[3];
+      pm_candidate2 = old_path_metrics[12] -input_symbol_real +increment[4];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[8]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][8] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[4] +input_symbol_real +increment[3];
+      pm_candidate2 = old_path_metrics[12] +input_symbol_real -increment[4];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[9]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][9] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[5] -input_symbol_real -increment[2];
+      pm_candidate2 = old_path_metrics[13] -input_symbol_real +increment[5];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[10]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][10] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[5] +input_symbol_real +increment[2];
+      pm_candidate2 = old_path_metrics[13] +input_symbol_real -increment[5];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[11]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][11] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[6] -input_symbol_real -increment[1];
+      pm_candidate2 = old_path_metrics[14] -input_symbol_real +increment[6];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[12]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][12] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[6] +input_symbol_real +increment[1];
+      pm_candidate2 = old_path_metrics[14] +input_symbol_real -increment[6];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[13]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][13] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[7] -input_symbol_real -increment[0];
+      pm_candidate2 = old_path_metrics[15] -input_symbol_real +increment[7];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[14]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][14] = paths_difference;
+
+      pm_candidate1 = old_path_metrics[7] +input_symbol_real +increment[0];
+      pm_candidate2 = old_path_metrics[15] +input_symbol_real -increment[7];
+      paths_difference=pm_candidate2-pm_candidate1;
+      new_path_metrics[15]=(paths_difference<0) ? pm_candidate1 : pm_candidate2;
+      trans_table[sample_nr][15] = paths_difference;
+
+      tmp=old_path_metrics;
+      old_path_metrics=new_path_metrics;
+      new_path_metrics=tmp;
+
+      sample_nr++;
+   }
+
+/*
+* Find the best from the stop states by comparing their path metrics.
+* Not every stop state is always possible, so we are searching in
+* a subset of them.
+*/
+   unsigned int best_stop_state;
+   float stop_state_metric, max_stop_state_metric;
+   best_stop_state = stop_states[0];
+   max_stop_state_metric = old_path_metrics[best_stop_state];
+   for(i=1; i< stops_num; i++){
+      stop_state_metric = old_path_metrics[stop_states[i]];
+      if(stop_state_metric > max_stop_state_metric){
+         max_stop_state_metric = stop_state_metric;
+         best_stop_state = stop_states[i];
+      }
+   }
+
+/*
+* This table was generated with hope that it gives a litle speedup during
+* traceback stage. 
+* Received bit is related to the number of state in the trellis.
+* I've numbered states so their parity (number of ones) is related
+* to a received bit. 
+*/
+   static const unsigned int parity_table[PATHS_NUM] = { 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0,  };
+
+/*
+* Table of previous states in the trellis diagram.
+* For GMSK modulation every state has two previous states.
+* Example:
+*   previous_state_nr1 = prev_table[current_state_nr][0]
+*   previous_state_nr2 = prev_table[current_state_nr][1]
+*/
+   static const unsigned int prev_table[PATHS_NUM][2] = { {0,8}, {0,8}, {1,9}, {1,9}, {2,10}, {2,10}, {3,11}, {3,11}, {4,12}, {4,12}, {5,13}, {5,13}, {6,14}, {6,14}, {7,15}, {7,15},  };
+
+/*
+* Traceback and differential decoding of received sequence.
+* Decisions stored in trans_table are used to restore best path in the trellis.
+*/
+   sample_nr=samples_num;
+   unsigned int state_nr=best_stop_state;
+   unsigned int decision;
+   bool out_bit=0;
+
+   while(sample_nr>0){
+      sample_nr--;
+      decision = (trans_table[sample_nr][state_nr]>0);
+
+      if(decision != out_bit)
+         output[sample_nr]=-trans_table[sample_nr][state_nr];
+      else
+         output[sample_nr]=trans_table[sample_nr][state_nr];
+
+      out_bit = out_bit ^ real_imag ^ parity_table[state_nr];
+      state_nr = prev_table[state_nr][decision];
+      real_imag = !real_imag;
+   }
+}

Transceiver52M/grgsm_vitac/viterbi_detector.h

@@ -0,0 +1,64 @@
+/* -*- c++ -*- */
+/*
+ * @file
+ * @author (C) 2009 Piotr Krysik <ptrkrysik@gmail.com>
+ * @section LICENSE
+ *
+ * Gr-gsm is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * Gr-gsm is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with gr-gsm; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+/*
+ * viterbi_detector:
+ *           This part does the detection of received sequnece.
+ *           Employed algorithm is viterbi Maximum Likehood Sequence Estimation.
+ *           At this moment it gives hard decisions on the output, but
+ *           it was designed with soft decisions in mind.
+ *
+ * SYNTAX:   void viterbi_detector(
+ *                                  const gr_complex * input, 
+ *                                  unsigned int samples_num, 
+ *                                  gr_complex * rhh, 
+ *                                  unsigned int start_state, 
+ *                                  const unsigned int * stop_states, 
+ *                                  unsigned int stops_num, 
+ *                                  float * output)
+ *
+ * INPUT:    input:       Complex received signal afted matched filtering.
+ *           samples_num: Number of samples in the input table.
+ *           rhh:         The autocorrelation of the estimated channel 
+ *                        impulse response.
+ *           start_state: Number of the start point. In GSM each burst 
+ *                        starts with sequence of three bits (0,0,0) which 
+ *                        indicates start point of the algorithm.
+ *           stop_states: Table with numbers of possible stop states.
+ *           stops_num:   Number of possible stop states
+ *                     
+ *
+ * OUTPUT:   output:      Differentially decoded hard output of the algorithm: 
+ *                        -1 for logical "0" and 1 for logical "1"
+ *
+ * SUB_FUNC: none
+ *
+ * TEST(S):  Tested with real world normal burst.
+ */
+
+#ifndef INCLUDED_VITERBI_DETECTOR_H
+#define INCLUDED_VITERBI_DETECTOR_H
+#include "constants.h"
+
+void viterbi_detector(const gr_complex * input, unsigned int samples_num, gr_complex * rhh, unsigned int start_state, const unsigned int * stop_states, unsigned int stops_num, float * output);
+
+#endif /* INCLUDED_VITERBI_DETECTOR_H */

Transceiver52M/itrq.h

@@ -0,0 +1,204 @@
+#pragma once
+/*
+ * (C) 2022 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
+ * All Rights Reserved
+ *
+ * Author: Eric Wild <ewild@sysmocom.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <atomic>
+
+#include <condition_variable>
+#include <mutex>
+#include <sys/eventfd.h>
+#include <unistd.h>
+
+#include <stdatomic.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+/*
+classic lamport circular lockfree spsc queue:
+every "side" only writes its own ptr, but may read the other sides ptr
+
+notify reader using eventfd as soon as element is added, reader then reads until
+read fails
+-> reader pops in a loop until FALSE and might get spurious events because it
+read before it was notified, which is fine
+-> writing pushes *the same data* in a loop until TRUE, blocks
+
+shutting this down requires
+1) to stop reading and pushing
+2) ONE side to take care of the eventfds
+*/
+
+namespace spsc_detail
+{
+template <bool block_read, bool block_write> class spsc_cond_detail {
+	std::condition_variable cond_r, cond_w;
+	std::mutex l;
+
+    public:
+	explicit spsc_cond_detail()
+	{
+	}
+
+	~spsc_cond_detail()
+	{
+	}
+
+	ssize_t spsc_check_r()
+	{
+		std::unique_lock<std::mutex> lk(l);
+		cond_r.wait(lk);
+		return 1;
+	}
+	ssize_t spsc_check_w()
+	{
+		std::unique_lock<std::mutex> lk(l);
+		cond_w.wait(lk);
+		return 1;
+	}
+	void spsc_notify_r()
+	{
+		cond_r.notify_one();
+	}
+	void spsc_notify_w()
+	{
+		cond_w.notify_one();
+	}
+};
+
+// originally designed for select loop integration
+template <bool block_read, bool block_write> class spsc_efd_detail {
+	int efd_r, efd_w; /* eventfds used to block/notify readers/writers */
+
+    public:
+	explicit spsc_efd_detail()
+		: efd_r(eventfd(0, block_read ? 0 : EFD_NONBLOCK)), efd_w(eventfd(1, block_write ? 0 : EFD_NONBLOCK))
+	{
+	}
+
+	~spsc_efd_detail()
+	{
+		close(efd_r);
+		close(efd_w);
+	}
+
+	ssize_t spsc_check_r()
+	{
+		uint64_t efdr;
+		return read(efd_r, &efdr, sizeof(uint64_t));
+	}
+	ssize_t spsc_check_w()
+	{
+		uint64_t efdr;
+		return read(efd_w, &efdr, sizeof(uint64_t));
+	}
+	void spsc_notify_r()
+	{
+		uint64_t efdu = 1;
+		write(efd_r, &efdu, sizeof(uint64_t));
+	}
+	void spsc_notify_w()
+	{
+		uint64_t efdu = 1;
+		write(efd_w, &efdu, sizeof(uint64_t));
+	}
+	int get_r_efd()
+	{
+		return efd_r;
+	}
+	int get_w_efd()
+	{
+		return efd_w;
+	}
+};
+
+template <unsigned int SZ, typename ELEM, bool block_read, bool block_write, template <bool, bool> class T>
+class spsc : public T<block_read, block_write> {
+	static_assert(SZ > 0, "queues need a size...");
+	std::atomic<unsigned int> readptr;
+	std::atomic<unsigned int> writeptr;
+
+	ELEM buf[SZ];
+
+    public:
+	using base_t = T<block_read, block_write>;
+	using elem_t = ELEM;
+	explicit spsc() : readptr(0), writeptr(0)
+	{
+	}
+
+	~spsc()
+	{
+	}
+
+	/*! Adds element to the queue by copying the data.
+ *  \param[in] elem input buffer, must match the originally configured queue buffer size!.
+ *  \returns true if queue was not full and element was successfully pushed */
+	bool spsc_push(ELEM *elem)
+	{
+		size_t cur_wp, cur_rp;
+		cur_wp = writeptr.load(std::memory_order_relaxed);
+		cur_rp = readptr.load(std::memory_order_acquire);
+		if ((cur_wp + 1) % SZ == cur_rp) {
+			if (block_write)
+				base_t::spsc_check_w(); /* blocks, ensures next (!) call succeeds */
+			return false;
+		}
+		buf[cur_wp] = *elem;
+		writeptr.store((cur_wp + 1) % SZ, std::memory_order_release);
+		if (block_read)
+			base_t::spsc_notify_r(); /* fine after release */
+		return true;
+	}
+
+	/*! Removes element from the queue by copying the data.
+ *  \param[in] elem output buffer, must match the originally configured queue buffer size!.
+ *  \returns true if queue was not empty and element was successfully removed */
+	bool spsc_pop(ELEM *elem)
+	{
+		size_t cur_wp, cur_rp;
+		cur_wp = writeptr.load(std::memory_order_acquire);
+		cur_rp = readptr.load(std::memory_order_relaxed);
+
+		if (cur_wp == cur_rp) /* blocks via prep_pop */
+			return false;
+
+		*elem = buf[cur_rp];
+		readptr.store((cur_rp + 1) % SZ, std::memory_order_release);
+		if (block_write)
+			base_t::spsc_notify_w();
+		return true;
+	}
+
+	/*! Reads the read-fd of the queue, which, depending on settings passed on queue creation, blocks.
+    * This function can be used to deliberately wait for a non-empty queue on the read side.
+    *  \returns result of reading the fd. */
+	ssize_t spsc_prep_pop()
+	{
+		return base_t::spsc_check_r();
+	}
+};
+
+} // namespace spsc_detail
+
+template <unsigned int SZ, typename ELEM, bool block_read, bool block_write>
+class spsc_evfd : public spsc_detail::spsc<SZ, ELEM, block_read, block_write, spsc_detail::spsc_efd_detail> {};
+template <unsigned int SZ, typename ELEM, bool block_read, bool block_write>
+class spsc_cond : public spsc_detail::spsc<SZ, ELEM, block_read, block_write, spsc_detail::spsc_cond_detail> {};

Transceiver52M/l1if.cpp

@@ -0,0 +1,124 @@
+#include <mutex>
+#include <queue>
+#include <deque>
+#include <condition_variable>
+#include <iostream>
+
+extern "C" {
+
+#include <unistd.h>
+#include <sys/eventfd.h>
+
+#include <osmocom/core/utils.h>
+#include <osmocom/core/select.h>
+}
+#include "l1if.h"
+
+using namespace std;
+using namespace std::chrono_literals;
+
+template<typename Data>
+class spsc_q{
+
+    std::queue<Data> m_q;
+    std::mutex m_mtx;
+    std::condition_variable m_cond;
+    bool killme;
+
+public:
+    spsc_q() : killme{ false } { }
+
+    void push(Data i){
+        std::unique_lock<std::mutex> lock(m_mtx);
+        m_q.push(i);
+        m_cond.notify_one();
+    }
+
+    Data pop(){
+        std::unique_lock<std::mutex> lock(m_mtx);
+        m_cond.wait_for(lock, 100ms, [&](){ return !m_q.empty() || killme; });
+
+        if (killme || m_q.empty()){
+                return {};
+            }
+
+        Data x = m_q.front();
+        m_q.pop();
+
+        return x;
+    }
+
+    void stop(){
+        killme = true;
+        m_cond.notify_all();
+    }
+
+    auto sz() { return m_q.size(); }
+};
+
+
+/*
+ * trxif_from_trx_c <-> push_c
+ * trxif_to_trx_c <-> pop_c
+ * trxif_from_trx_d <-> push_d
+ * trxif_to_trx_d <-> pop_d
+ * ...
+ *
+ *
+ */
+class trxl1if {
+public:
+    spsc_q<TRX_C*> c_to_trx;
+    spsc_q<TRX_C*> c_from_trx;
+
+    spsc_q<trxd_to_trx*> d_to_trx;
+    spsc_q<trxd_from_trx*> d_from_trx;
+
+    struct osmo_fd g_event_ofd_C;
+    struct osmo_fd g_event_ofd_D;
+};
+
+trxl1if trxif;
+
+void push_c(TRX_C* i) {
+	uint64_t one = 1;
+	int rc;
+	trxif.c_from_trx.push(i);
+	// std::clog << trxif.c_from_trx.sz() << std::endl;
+	rc = ::write(trxif.g_event_ofd_C.fd, &one, sizeof(one));
+	return;
+};
+TRX_C* pop_c() {
+	return trxif.c_to_trx.pop();
+};
+void push_d(trxd_from_trx* i) {
+	uint64_t one = 1;
+	int rc;
+	trxif.d_from_trx.push(i);
+	rc = ::write(trxif.g_event_ofd_D.fd, &one, sizeof(one));
+	return;
+};
+trxd_to_trx* pop_d() {
+	return trxif.d_to_trx.pop();
+};
+
+extern "C" {
+char* trxif_from_trx_c() {
+    uint64_t one = 1;
+    ::read(trxif.g_event_ofd_C.fd, &one, sizeof(one));
+    return (char*)trxif.c_from_trx.pop();
+}
+void trxif_to_trx_c(char* msg) {
+    trxif.c_to_trx.push((TRX_C*)msg);
+}
+trxd_from_trx* trxif_from_trx_d() {
+    uint64_t one = 1;
+    ::read(trxif.g_event_ofd_D.fd, &one, sizeof(one));
+    return trxif.d_from_trx.pop();
+}
+void trxif_to_trx_d(trxd_to_trx* msg) {
+    trxif.d_to_trx.push(msg);
+}
+struct osmo_fd* get_c_fd() { return &trxif.g_event_ofd_C;}
+struct osmo_fd* get_d_fd() { return &trxif.g_event_ofd_D;}
+}

Transceiver52M/l1if.h

@@ -0,0 +1,74 @@
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <stdint.h>
+#ifdef __cplusplus
+}
+#endif
+
+/* ------------------------------------------------------------------------ */
+/* Data interface handlers                                                  */
+/* ------------------------------------------------------------------------ */
+/* DATA interface                                                           */
+/*                                                                          */
+/* Messages on the data interface carry one radio burst per UDP message.    */
+/*                                                                          */
+/* Received Data Burst:                                                     */
+/* 1 byte timeslot index                                                    */
+/* 4 bytes GSM frame number, BE                                             */
+/* 1 byte RSSI in -dBm                                                      */
+/* 2 bytes correlator timing offset in 1/256 symbol steps, 2's-comp, BE     */
+/* 148 bytes soft symbol estimates, 0 -> definite "0", 255 -> definite "1"  */
+/* 2 bytes are not used, but being sent by OsmoTRX                          */
+/*                                                                          */
+/* Transmit Data Burst:                                                     */
+/* 1 byte timeslot index                                                    */
+/* 4 bytes GSM frame number, BE                                             */
+/* 1 byte transmit level wrt ARFCN max, -dB (attenuation)                   */
+/* 148 bytes output symbol values, 0 & 1                                    */
+/* ------------------------------------------------------------------------ */
+
+struct __attribute__((packed)) trxd_to_trx {
+	uint8_t ts;
+	uint32_t fn;
+	uint8_t txlev;
+	uint8_t symbols[148];
+};
+
+struct __attribute__((packed)) trxd_from_trx {
+	uint8_t ts;
+	uint32_t fn;
+	uint8_t rssi;
+	uint16_t toa;
+	uint8_t symbols[148];
+	uint8_t pad[2];
+};
+
+#define TRXC_BUF_SIZE	1024
+
+struct TRX_C {
+    char cmd[TRXC_BUF_SIZE];
+};
+
+#ifdef __cplusplus
+void push_c(TRX_C* i);
+TRX_C* pop_c();
+
+void push_d(trxd_from_trx* i);
+trxd_to_trx* pop_d();
+
+#else
+
+
+char* trxif_from_trx_c();
+void trxif_to_trx_c(char* msg);
+
+struct trxd_from_trx* trxif_from_trx_d();
+void trxif_to_trx_d(struct trxd_to_trx* msg);
+
+struct osmo_fd* get_c_fd();
+struct osmo_fd* get_d_fd();
+
+#endif
+

Transceiver52M/ms/bladerf_specific.h

@@ -0,0 +1,482 @@
+#pragma once
+
+/*
+ * (C) 2022 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
+ * All Rights Reserved
+ *
+ * Author: Eric Wild <ewild@sysmocom.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "itrq.h"
+#include <atomic>
+#include <complex>
+#include <cstdint>
+#include <functional>
+#include <iostream>
+#include <cassert>
+#include <cstring>
+
+#include <libbladeRF.h>
+#include <Timeval.h>
+#include <unistd.h>
+
+const size_t BLADE_BUFFER_SIZE = 1024 * 1;
+const size_t BLADE_NUM_BUFFERS = 32 * 1;
+const size_t NUM_TRANSFERS = 16 * 2;
+const int SAMPLE_SCALE_FACTOR = 15; // actually 16 but sigproc complains about clipping..
+
+template <typename Arg, typename... Args> void doPrint(std::ostream &out, Arg &&arg, Args &&...args)
+{
+	out << '(' << std::forward<Arg>(arg);
+	using expander = int[];
+	(void)expander{ 0, (void(out << ',' << std::forward<Args>(args)), 0)... };
+	out << ')' << std::endl;
+}
+
+template <class R, class... Args> using RvalFunc = R (*)(Args...);
+
+// specialisation for funcs which return a value
+template <class R, class... Args>
+R exec_and_check(RvalFunc<R, Args...> func, const char *fname, const char *finame, const char *funcname, int line,
+		 Args... args)
+{
+	R rval = func(std::forward<Args>(args)...);
+	if (rval != 0) {
+		std::cerr << ((rval >= 0) ? "OK:" : bladerf_strerror(rval)) << ':' << finame << ':' << line << ':'
+			  << funcname << ':' << fname;
+		doPrint(std::cerr, args...);
+	}
+	return rval;
+}
+
+// only macros can pass a func name string
+#define blade_check(func, ...) exec_and_check(func, #func, __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__)
+
+#pragma pack(push, 1)
+using blade_sample_type = std::complex<int16_t>;
+enum class blade_speed_buffer_type { HS, SS };
+template <blade_speed_buffer_type T> struct blade_usb_message {
+	uint32_t reserved;
+	uint64_t ts;
+	uint32_t meta_flags;
+	blade_sample_type d[(T == blade_speed_buffer_type::SS ? 512 : 256) - 4];
+};
+
+static_assert(sizeof(blade_usb_message<blade_speed_buffer_type::SS>) == 2048, "blade buffer mismatch!");
+static_assert(sizeof(blade_usb_message<blade_speed_buffer_type::HS>) == 1024, "blade buffer mismatch!");
+template <unsigned int SZ, blade_speed_buffer_type T> struct blade_otw_buffer {
+	static_assert((SZ >= 2 && !(SZ % 2)), "min size is 2x usb buffer!");
+	blade_usb_message<T> m[SZ];
+	int actual_samples_per_msg()
+	{
+		return sizeof(blade_usb_message<T>::d) / sizeof(typeof(blade_usb_message<T>::d[0]));
+	}
+	int actual_samples_per_buffer()
+	{
+		return SZ * actual_samples_per_msg();
+	}
+	int samples_per_buffer()
+	{
+		return SZ * sizeof(blade_usb_message<T>) / sizeof(typeof(blade_usb_message<T>::d[0]));
+	}
+	int num_msgs_per_buffer()
+	{
+		return SZ;
+	}
+	auto get_first_ts()
+	{
+		return m[0].ts;
+	}
+	constexpr auto *getsampleoffset(int ofs)
+	{
+		auto full = ofs / actual_samples_per_msg();
+		auto rem = ofs % actual_samples_per_msg();
+		return &m[full].d[rem];
+	}
+	int readall(blade_sample_type *outaddr)
+	{
+		blade_sample_type *addr = outaddr;
+		for (int i = 0; i < SZ; i++) {
+			memcpy(addr, &m[i].d[0], actual_samples_per_msg() * sizeof(blade_sample_type));
+			addr += actual_samples_per_msg();
+		}
+		return actual_samples_per_buffer();
+	}
+	int read_n(blade_sample_type *outaddr, int start, int num)
+	{
+		assert((start + num) <= actual_samples_per_buffer());
+		assert(start >= 0);
+
+		if (!num)
+			return 0;
+
+		// which buffer?
+		int start_buf_idx = (start > 0) ? start / actual_samples_per_msg() : 0;
+		// offset from actual buffer start
+		auto start_offset_in_buf = (start - (start_buf_idx * actual_samples_per_msg()));
+		auto samp_rem_in_first_buf = actual_samples_per_msg() - start_offset_in_buf;
+		auto remaining_first_buf = num > samp_rem_in_first_buf ? samp_rem_in_first_buf : num;
+
+		memcpy(outaddr, &m[start_buf_idx].d[start_offset_in_buf],
+		       remaining_first_buf * sizeof(blade_sample_type));
+		outaddr += remaining_first_buf;
+
+		auto remaining = num - remaining_first_buf;
+
+		if (!remaining)
+			return num;
+
+		start_buf_idx++;
+
+		auto rem_full_bufs = remaining / actual_samples_per_msg();
+		remaining -= rem_full_bufs * actual_samples_per_msg();
+
+		for (int i = 0; i < rem_full_bufs; i++) {
+			memcpy(outaddr, &m[start_buf_idx++].d[0], actual_samples_per_msg() * sizeof(blade_sample_type));
+			outaddr += actual_samples_per_msg();
+		}
+
+		if (remaining)
+			memcpy(outaddr, &m[start_buf_idx].d[0], remaining * sizeof(blade_sample_type));
+		return num;
+	}
+	int write_n_burst(blade_sample_type *in, int num, uint64_t first_ts)
+	{
+		assert(num <= actual_samples_per_buffer());
+		int len_rem = num;
+		for (int i = 0; i < SZ; i++) {
+			m[i] = {};
+			m[i].ts = first_ts + i * actual_samples_per_msg();
+			if (len_rem) {
+				int max_to_copy =
+					len_rem > actual_samples_per_msg() ? actual_samples_per_msg() : len_rem;
+				memcpy(&m[i].d[0], in, max_to_copy * sizeof(blade_sample_type));
+				len_rem -= max_to_copy;
+				in += actual_samples_per_msg();
+			}
+		}
+		return num;
+	}
+};
+#pragma pack(pop)
+
+template <unsigned int SZ, blade_speed_buffer_type T> struct blade_otw_buffer_helper {
+	static_assert((SZ >= 1024 && ((SZ & (SZ - 1)) == 0)), "only buffer size multiples of 1024 allowed!");
+	static blade_otw_buffer<SZ / 512, T> x;
+};
+
+using dev_buf_t = typeof(blade_otw_buffer_helper<BLADE_BUFFER_SIZE, blade_speed_buffer_type::SS>::x);
+// using buf_in_use = blade_otw_buffer<2, blade_speed_buffer_type::SS>;
+using bh_fn_t = std::function<int(dev_buf_t *)>;
+
+template <typename T> struct blade_hw {
+	struct bladerf *dev;
+	struct bladerf_stream *rx_stream;
+	struct bladerf_stream *tx_stream;
+	// using pkt2buf = blade_otw_buffer<2, blade_speed_buffer_type::SS>;
+	using tx_buf_q_type = spsc_cond<BLADE_NUM_BUFFERS, dev_buf_t *, true, false>;
+	unsigned int rxFullScale, txFullScale;
+	int rxtxdelay;
+
+	float rxgain, txgain;
+
+	struct ms_trx_config {
+		int tx_freq;
+		int rx_freq;
+		int sample_rate;
+		int bandwidth;
+
+	    public:
+		ms_trx_config() : tx_freq(881e6), rx_freq(926e6), sample_rate(((1625e3 / 6) * 4)), bandwidth(1e6)
+		{
+		}
+	} cfg;
+
+	struct buf_mgmt {
+		void **rx_samples;
+		void **tx_samples;
+		tx_buf_q_type bufptrqueue;
+
+	} buf_mgmt;
+
+	virtual ~blade_hw()
+	{
+		close_device();
+	}
+	blade_hw() : rxFullScale(2047), txFullScale(2047), rxtxdelay(-60)
+	{
+	}
+
+	void close_device()
+	{
+		if (dev) {
+			if (rx_stream) {
+				bladerf_deinit_stream(rx_stream);
+			}
+
+			if (tx_stream) {
+				bladerf_deinit_stream(tx_stream);
+			}
+
+			bladerf_enable_module(dev, BLADERF_MODULE_RX, false);
+			bladerf_enable_module(dev, BLADERF_MODULE_TX, false);
+
+			bladerf_close(dev);
+			dev = NULL;
+		}
+	}
+
+	int init_device(bh_fn_t rxh, bh_fn_t txh)
+	{
+		struct bladerf_rational_rate rate = { 0, static_cast<uint64_t>((1625e3 * 4)) * 64, 6 * 64 }, actual;
+
+		bladerf_log_set_verbosity(BLADERF_LOG_LEVEL_DEBUG);
+		bladerf_set_usb_reset_on_open(true);
+		blade_check(bladerf_open, &dev, "");
+		if (!dev) {
+			std::cerr << "open failed, device missing?" << std::endl;
+			return -1;
+		}
+		if (bladerf_device_speed(dev) != bladerf_dev_speed::BLADERF_DEVICE_SPEED_SUPER) {
+			std::cerr << "open failed, only superspeed (usb3) supported!" << std::endl;
+			return -1;
+		}
+
+		blade_check(bladerf_set_tuning_mode, dev, bladerf_tuning_mode::BLADERF_TUNING_MODE_FPGA);
+
+		bool is_locked;
+		blade_check(bladerf_set_pll_enable, dev, true);
+		blade_check(bladerf_set_pll_refclk, dev, 10000000UL);
+		for (int i = 0; i < 20; i++) {
+			usleep(50 * 1000);
+			bladerf_get_pll_lock_state(dev, &is_locked);
+
+			if (is_locked)
+				break;
+		}
+		if (!is_locked) {
+			std::cerr << "unable to lock refclk!" << std::endl;
+			return -1;
+		}
+
+		// bladerf_sample_rate r = (1625e3 * 4)/6, act;
+		// blade_check(bladerf_set_sample_rate,dev, BLADERF_CHANNEL_RX(0), r, &act);
+		// blade_check(bladerf_set_sample_rate,dev, BLADERF_CHANNEL_TX(0), r, &act);
+
+		// auto ratrate = (1625e3 * 4) / 6;
+		// rate.integer = (uint32_t)ratrate;
+		// rate.den = 10000;
+		// rate.num = (ratrate - rate.integer) * rate.den;
+
+		blade_check(bladerf_set_rational_sample_rate, dev, BLADERF_CHANNEL_RX(0), &rate, &actual);
+		blade_check(bladerf_set_rational_sample_rate, dev, BLADERF_CHANNEL_TX(0), &rate, &actual);
+
+		blade_check(bladerf_set_frequency, dev, BLADERF_CHANNEL_RX(0), (bladerf_frequency)cfg.rx_freq);
+		blade_check(bladerf_set_frequency, dev, BLADERF_CHANNEL_TX(0), (bladerf_frequency)cfg.tx_freq);
+
+		blade_check(bladerf_set_bandwidth, dev, BLADERF_CHANNEL_RX(0), (bladerf_bandwidth)cfg.bandwidth,
+			    (bladerf_bandwidth *)NULL);
+		blade_check(bladerf_set_bandwidth, dev, BLADERF_CHANNEL_TX(0), (bladerf_bandwidth)cfg.bandwidth,
+			    (bladerf_bandwidth *)NULL);
+
+		blade_check(bladerf_set_gain_mode, dev, BLADERF_CHANNEL_RX(0), BLADERF_GAIN_MGC);
+		// blade_check(bladerf_set_gain, dev, BLADERF_CHANNEL_RX(0), (bladerf_gain)30);
+		// blade_check(bladerf_set_gain, dev, BLADERF_CHANNEL_TX(0), (bladerf_gain)50);
+		usleep(1000);
+		blade_check(bladerf_enable_module, dev, BLADERF_MODULE_RX, true);
+		usleep(1000);
+		blade_check(bladerf_enable_module, dev, BLADERF_MODULE_TX, true);
+		usleep(1000);
+		blade_check(bladerf_init_stream, &rx_stream, dev, getrxcb(rxh), &buf_mgmt.rx_samples, BLADE_NUM_BUFFERS,
+			    BLADERF_FORMAT_SC16_Q11_META, BLADE_BUFFER_SIZE, NUM_TRANSFERS, (void *)this);
+
+		blade_check(bladerf_init_stream, &tx_stream, dev, gettxcb(txh), &buf_mgmt.tx_samples, BLADE_NUM_BUFFERS,
+			    BLADERF_FORMAT_SC16_Q11_META, BLADE_BUFFER_SIZE, NUM_TRANSFERS, (void *)this);
+
+		for (int i = 0; i < BLADE_NUM_BUFFERS; i++) {
+			auto cur_buffer = reinterpret_cast<tx_buf_q_type::elem_t *>(buf_mgmt.tx_samples);
+			buf_mgmt.bufptrqueue.spsc_push(&cur_buffer[i]);
+		}
+
+		setRxGain(20);
+		setTxGain(30);
+
+		usleep(1000);
+
+		// bladerf_set_stream_timeout(dev, BLADERF_TX, 4);
+		// bladerf_set_stream_timeout(dev, BLADERF_RX, 4);
+
+		return 0;
+	}
+
+	bool tuneTx(double freq, size_t chan = 0)
+	{
+		msleep(15);
+		blade_check(bladerf_set_frequency, dev, BLADERF_CHANNEL_TX(0), (bladerf_frequency)freq);
+		msleep(15);
+		return true;
+	};
+	bool tuneRx(double freq, size_t chan = 0)
+	{
+		msleep(15);
+		blade_check(bladerf_set_frequency, dev, BLADERF_CHANNEL_RX(0), (bladerf_frequency)freq);
+		msleep(15);
+		return true;
+	};
+	bool tuneRxOffset(double offset, size_t chan = 0)
+	{
+		return true;
+	};
+
+	double setRxGain(double dB, size_t chan = 0)
+	{
+		rxgain = dB;
+		msleep(15);
+		blade_check(bladerf_set_gain, dev, BLADERF_CHANNEL_RX(0), (bladerf_gain)dB);
+		msleep(15);
+		return dB;
+	};
+	double setTxGain(double dB, size_t chan = 0)
+	{
+		txgain = dB;
+		msleep(15);
+		blade_check(bladerf_set_gain, dev, BLADERF_CHANNEL_TX(0), (bladerf_gain)dB);
+		msleep(15);
+		return dB;
+	};
+	int setPowerAttenuation(int atten, size_t chan = 0)
+	{
+		return atten;
+	};
+
+	static void check_timestamp(dev_buf_t *rcd)
+	{
+		static bool first = true;
+		static uint64_t last_ts;
+		if (first) {
+			first = false;
+			last_ts = rcd->m[0].ts;
+		} else if (last_ts + rcd->actual_samples_per_buffer() != rcd->m[0].ts) {
+			std::cerr << "RX Overrun!" << last_ts << " " << rcd->actual_samples_per_buffer() << " "
+				  << last_ts + rcd->actual_samples_per_buffer() << " " << rcd->m[0].ts << std::endl;
+			last_ts = rcd->m[0].ts;
+		} else {
+			last_ts = rcd->m[0].ts;
+		}
+	}
+
+	bladerf_stream_cb getrxcb(bh_fn_t rxbh)
+	{
+		// C cb -> no capture!
+		static auto rxbhfn = rxbh;
+		return [](struct bladerf *dev, struct bladerf_stream *stream, struct bladerf_metadata *meta,
+			  void *samples, size_t num_samples, void *user_data) -> void * {
+			// struct blade_hw *trx = (struct blade_hw *)user_data;
+			static int to_skip = 0;
+			dev_buf_t *rcd = (dev_buf_t *)samples;
+
+			if (to_skip < 120) // prevents weird overflows on startup
+				to_skip++;
+			else {
+				check_timestamp(rcd);
+				rxbhfn(rcd);
+			}
+
+			return samples;
+		};
+	}
+	bladerf_stream_cb gettxcb(bh_fn_t txbh)
+	{
+		// C cb -> no capture!
+		static auto txbhfn = txbh;
+		return [](struct bladerf *dev, struct bladerf_stream *stream, struct bladerf_metadata *meta,
+			  void *samples, size_t num_samples, void *user_data) -> void * {
+			struct blade_hw *trx = (struct blade_hw *)user_data;
+			auto ptr = reinterpret_cast<tx_buf_q_type::elem_t>(samples);
+
+			if (samples) // put buffer address back into queue, ready to be reused
+				trx->buf_mgmt.bufptrqueue.spsc_push(&ptr);
+
+			return BLADERF_STREAM_NO_DATA;
+		};
+	}
+
+	auto get_rx_burst_handler_fn(bh_fn_t burst_handler)
+	{
+		auto fn = [this] {
+			int status;
+			set_name_aff_sched("rxrun", 2, SCHED_FIFO, sched_get_priority_max(SCHED_FIFO) - 2);
+			status = bladerf_stream(rx_stream, BLADERF_RX_X1);
+			if (status < 0)
+				std::cerr << "rx stream error! " << bladerf_strerror(status) << std::endl;
+
+			return NULL;
+		};
+		return fn;
+	}
+	auto get_tx_burst_handler_fn(bh_fn_t burst_handler)
+	{
+		auto fn = [this] {
+			int status;
+			set_name_aff_sched("txrun", 2, SCHED_FIFO, sched_get_priority_max(SCHED_FIFO) - 1);
+			status = bladerf_stream(tx_stream, BLADERF_TX_X1);
+			if (status < 0)
+				std::cerr << "rx stream error! " << bladerf_strerror(status) << std::endl;
+
+			return NULL;
+		};
+		return fn;
+	}
+
+	void submit_burst_ts(blade_sample_type *buffer, int len, uint64_t ts)
+	{
+		//get empty bufer from list
+		tx_buf_q_type::elem_t rcd;
+
+		while (!buf_mgmt.bufptrqueue.spsc_pop(&rcd))
+			buf_mgmt.bufptrqueue.spsc_prep_pop();
+		assert(rcd != nullptr);
+
+		rcd->write_n_burst(buffer, len, ts + rxtxdelay); // blade xa4 specific delay!
+		// blade_check(bladerf_submit_stream_buffer_nb, tx_stream, (void *)rcd, 100U);
+		blade_check(bladerf_submit_stream_buffer_nb, tx_stream, (void *)rcd);
+	}
+
+	void set_name_aff_sched(const char *name, int cpunum, int schedtype, int prio)
+	{
+		pthread_setname_np(pthread_self(), name);
+
+		cpu_set_t cpuset;
+
+		CPU_ZERO(&cpuset);
+		CPU_SET(cpunum, &cpuset);
+
+		auto rv = pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);
+		if (rv < 0) {
+			std::cerr << name << " affinity: errreur! " << std::strerror(errno);
+			return exit(0);
+		}
+
+		sched_param sch_params;
+		sch_params.sched_priority = prio;
+		rv = pthread_setschedparam(pthread_self(), schedtype, &sch_params);
+		if (rv < 0) {
+			std::cerr << name << " sched: errreur! " << std::strerror(errno);
+			return exit(0);
+		}
+	}
+};

Transceiver52M/ms/ms_commandhandler.cpp

@@ -0,0 +1,229 @@
+/*
+ * (C) 2022 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
+ * All Rights Reserved
+ *
+ * Author: Eric Wild <ewild@sysmocom.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <radioInterface.h>
+#include "l1if.h"
+#include "ms_rx_upper.h"
+#include "syncthing.h"
+#include "ms_state.h"
+
+void upper_trx::driveControl()
+{
+#ifdef IPCIF
+	auto m = pop_c();
+	if (!m)
+		return;
+#else
+	TRX_C cmd;
+
+	socklen_t addr_len = sizeof(ctrlsrc);
+	int rdln = recvfrom(mCtrlSockets, (void *)cmd.cmd, sizeof(cmd) - 1, 0, &ctrlsrc, &addr_len);
+	if (rdln < 0 && errno == EAGAIN) {
+		std::cerr << "fuck, send ctrl?" << std::endl;
+		exit(0);
+	}
+
+	TRX_C *m = &cmd;
+#endif
+
+	auto response = (TRX_C *)malloc(sizeof(TRX_C));
+	response->cmd[0] = '\0';
+	commandhandler(m->cmd, response->cmd);
+#ifdef IPCIF
+	free(m);
+#endif
+	std::clog << "response is " << response->cmd << std::endl;
+#ifdef IPCIF
+	push_c(response);
+#else
+
+	int rv = sendto(mCtrlSockets, response, strlen(response->cmd) + 1, 0, &ctrlsrc, sizeof(struct sockaddr_in));
+	if (rv < 0) {
+		std::cerr << "fuck, rcv ctrl?" << std::endl;
+		exit(0);
+	}
+	free(response);
+
+#endif
+}
+
+void upper_trx::commandhandler(char *buffer, char *response)
+{
+	int MAX_PACKET_LENGTH = TRXC_BUF_SIZE;
+
+	char cmdcheck[4];
+	char command[MAX_PACKET_LENGTH];
+
+	sscanf(buffer, "%3s %s", cmdcheck, command);
+
+	if (strcmp(cmdcheck, "CMD") != 0) {
+		LOG(WARNING) << "bogus message on control interface";
+		return;
+	}
+	std::clog << "command is " << buffer << std::endl << std::flush;
+
+	if (strcmp(command, "MEASURE") == 0) {
+		msleep(100);
+		int freq;
+		sscanf(buffer, "%3s %s %d", cmdcheck, command, &freq);
+		sprintf(response, "RSP MEASURE 0 %d -80", freq);
+	} else if (strcmp(command, "ECHO") == 0) {
+		msleep(100);
+		sprintf(response, "RSP ECHO 0");
+	} else if (strcmp(command, "POWEROFF") == 0) {
+		set_ta(0);
+		// turn off transmitter/demod
+		sprintf(response, "RSP POWEROFF 0");
+	} else if (strcmp(command, "POWERON") == 0) {
+		// turn on transmitter/demod
+		if (!mTxFreq || !mRxFreq)
+			sprintf(response, "RSP POWERON 1");
+		else {
+			sprintf(response, "RSP POWERON 0");
+			if (!mOn) {
+				// Prepare for thread start
+				mPower = -20;
+				start_ms();
+
+				writeClockInterface();
+				mOn = true;
+			}
+		}
+	} else if (strcmp(command, "SETMAXDLY") == 0) {
+		//set expected maximum time-of-arrival
+		int maxDelay;
+		sscanf(buffer, "%3s %s %d", cmdcheck, command, &maxDelay);
+		mMaxExpectedDelay = maxDelay; // 1 GSM symbol is approx. 1 km
+		sprintf(response, "RSP SETMAXDLY 0 %d", maxDelay);
+	} else if (strcmp(command, "SETRXGAIN") == 0) {
+		//set expected maximum time-of-arrival
+		int newGain;
+		sscanf(buffer, "%3s %s %d", cmdcheck, command, &newGain);
+		newGain = setRxGain(newGain);
+		sprintf(response, "RSP SETRXGAIN 0 %d", newGain);
+	} else if (strcmp(command, "NOISELEV") == 0) {
+		if (mOn) {
+			float lev = 0; //mStates[chan].mNoiseLev;
+			sprintf(response, "RSP NOISELEV 0 %d", (int)round(20.0 * log10(rxFullScale / lev)));
+		} else {
+			sprintf(response, "RSP NOISELEV 1  0");
+		}
+	} else if (!strcmp(command, "SETPOWER")) {
+		// set output power in dB
+		int dbPwr;
+		sscanf(buffer, "%3s %s %d", cmdcheck, command, &dbPwr);
+		if (!mOn)
+			sprintf(response, "RSP SETPOWER 1 %d", dbPwr);
+		else {
+			mPower = dbPwr;
+			setPowerAttenuation(mPower);
+			sprintf(response, "RSP SETPOWER 0 %d", dbPwr);
+		}
+	} else if (!strcmp(command, "ADJPOWER")) {
+		// adjust power in dB steps
+		int dbStep;
+		sscanf(buffer, "%3s %s %d", cmdcheck, command, &dbStep);
+		if (!mOn)
+			sprintf(response, "RSP ADJPOWER 1 %d", mPower);
+		else {
+			mPower += dbStep;
+			setPowerAttenuation(mPower);
+			sprintf(response, "RSP ADJPOWER 0 %d", mPower);
+		}
+	} else if (strcmp(command, "RXTUNE") == 0) {
+		// tune receiver
+		int freqKhz;
+		sscanf(buffer, "%3s %s %d", cmdcheck, command, &freqKhz);
+		mRxFreq = freqKhz * 1e3;
+		if (!tuneRx(mRxFreq)) {
+			LOG(ALERT) << "RX failed to tune";
+			sprintf(response, "RSP RXTUNE 1 %d", freqKhz);
+		} else
+			sprintf(response, "RSP RXTUNE 0 %d", freqKhz);
+	} else if (strcmp(command, "TXTUNE") == 0) {
+		// tune txmtr
+		int freqKhz;
+		sscanf(buffer, "%3s %s %d", cmdcheck, command, &freqKhz);
+		mTxFreq = freqKhz * 1e3;
+		if (!tuneTx(mTxFreq)) {
+			LOG(ALERT) << "TX failed to tune";
+			sprintf(response, "RSP TXTUNE 1 %d", freqKhz);
+		} else
+			sprintf(response, "RSP TXTUNE 0 %d", freqKhz);
+	} else if (!strcmp(command, "SETTSC")) {
+		// set TSC
+		unsigned TSC;
+		sscanf(buffer, "%3s %s %d", cmdcheck, command, &TSC);
+		if (mOn)
+			sprintf(response, "RSP SETTSC 1 %d", TSC);
+		// else if (chan && (TSC != mTSC))
+		// 	sprintf(response, "RSP SETTSC 1 %d", TSC);
+		else {
+			mTSC = TSC;
+			//generateMidamble(rx_sps, TSC);
+			sprintf(response, "RSP SETTSC 0 %d", TSC);
+		}
+	} else if (!strcmp(command, "GETBSIC")) {
+		if (mBSIC < 0)
+			sprintf(response, "RSP GETBSIC 1");
+		else
+			sprintf(response, "RSP GETBSIC 0 %d", mBSIC);
+	} else if (strcmp(command, "SETSLOT") == 0) {
+		// set TSC
+		int corrCode;
+		int timeslot;
+		sscanf(buffer, "%3s %s %d %d", cmdcheck, command, &timeslot, &corrCode);
+		if ((timeslot < 0) || (timeslot > 7)) {
+			LOG(WARNING) << "bogus message on control interface";
+			sprintf(response, "RSP SETSLOT 1 %d %d", timeslot, corrCode);
+			return;
+		}
+		mStates.chanType[timeslot] = (ChannelCombination)corrCode;
+		mStates.setModulus(timeslot);
+		sprintf(response, "RSP SETSLOT 0 %d %d", timeslot, corrCode);
+	} else if (!strcmp(command, "SETRXMASK")) {
+		int slot;
+		unsigned long long mask;
+		sscanf(buffer, "%3s %s %d 0x%llx", cmdcheck, command, &slot, &mask);
+		if ((slot < 0) || (slot > 7)) {
+			sprintf(response, "RSP SETRXMASK 1");
+		} else {
+			mRxSlotMask[slot] = mask;
+			sprintf(response, "RSP SETRXMASK 0 %d 0x%llx", slot, mask);
+		}
+	} else if (!strcmp(command, "SYNC")) {
+		// msleep(10);
+		mStates.mode = trx_mode::TRX_MODE_MS_TRACK;
+		sprintf(response, "RSP SYNC 0");
+		mMaxExpectedDelay = 48;
+		// setRxGain(30);
+		// msleep(10);
+	} else if (!strcmp(command, "SETTA")) {
+		int ta;
+		sscanf(buffer, "%3s %s %d", cmdcheck, command, &ta);
+		set_ta(ta);
+		sprintf(response, "RSP SETTA 0 %d", ta);
+	} else {
+		LOG(WARNING) << "bogus command " << command << " on control interface.";
+	}
+
+	//mCtrlSockets[chan]->write(response, strlen(response) + 1);
+}

Transceiver52M/ms/ms_rx_burst.cpp

@@ -0,0 +1,211 @@
+/*
+ * (C) 2022 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
+ * All Rights Reserved
+ *
+ * Author: Eric Wild <ewild@sysmocom.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#include "syncthing.h"
+#include "sigProcLib.h"
+#include "signalVector.h"
+#include "grgsm_vitac/grgsm_vitac.h"
+extern "C" {
+#include "sch.h"
+}
+
+#if !defined(SYNCTHINGONLY) || !defined(NODAMNLOG)
+#define DBGLG(...) ms_trx::dummy_log()
+#else
+#define DBGLG(...) std::cerr
+#endif
+
+#if !defined(SYNCTHINGONLY)
+#define DBGLG2(...) ms_trx::dummy_log()
+#else
+#define DBGLG2(...) std::cerr
+#endif
+
+__attribute__((xray_always_instrument)) __attribute__((noinline)) static bool decode_sch(float *bits,
+											 bool update_global_clock)
+{
+	struct sch_info sch;
+	ubit_t info[GSM_SCH_INFO_LEN];
+	sbit_t data[GSM_SCH_CODED_LEN];
+
+	float_to_sbit(&bits[3], &data[0], 62, 39);
+	float_to_sbit(&bits[106], &data[39], 62, 39);
+
+	if (!gsm_sch_decode(info, data)) {
+		gsm_sch_parse(info, &sch);
+
+		DBGLG() << "SCH : Decoded values" << std::endl;
+		DBGLG() << "    BSIC: " << sch.bsic << std::endl;
+		DBGLG() << "    TSC: " << (sch.bsic & 0x7) << std::endl;
+		DBGLG() << "    T1  : " << sch.t1 << std::endl;
+		DBGLG() << "    T2  : " << sch.t2 << std::endl;
+		DBGLG() << "    T3p : " << sch.t3p << std::endl;
+		DBGLG() << "    FN  : " << gsm_sch_to_fn(&sch) << std::endl;
+		return true;
+	}
+	return false;
+}
+
+static void check_rcv_fn(GSM::Time t, bool first, unsigned int &lastfn, unsigned int &fnbm)
+{
+	if (first && t.TN() == 0) {
+		lastfn = t.FN();
+		fnbm = 1 << 0;
+		first = false;
+	}
+	if (!first && t.FN() != lastfn) {
+		if (fnbm != 255)
+			std::cerr << "rx " << lastfn << ":" << fnbm << " " << __builtin_popcount(fnbm) << std::endl;
+		lastfn = t.FN();
+		fnbm = 1 << t.TN();
+	}
+
+	fnbm |= 1 << t.TN();
+}
+
+__attribute__((xray_always_instrument)) __attribute__((noinline)) static void
+handle_it(one_burst &e, signalVector &burst, unsigned int tsc)
+{
+	memset(burst.begin(), 0, burst.size() * sizeof(std::complex<float>));
+	auto is_sch = gsm_sch_check_fn(e.gsmts.FN()) && e.gsmts.TN() == 0;
+	auto is_fcch = gsm_fcch_check_fn(e.gsmts.FN()) && e.gsmts.TN() == 0;
+
+	// if (is_sch)
+	// 	return;
+
+	if (is_fcch)
+		return;
+
+	if (is_sch) {
+		unsigned char outbin[148];
+		convert_and_scale_default<float, int16_t>(burst.begin(), e.burst, ONE_TS_BURST_LEN * 2);
+		std::stringstream dbgout;
+#if 0
+		{
+			struct estim_burst_params ebp;
+			auto rv2 = detectSCHBurst(burst, 4, 4, sch_detect_type::SCH_DETECT_FULL, &ebp);
+			auto bits = demodAnyBurst(burst, SCH, 4, &ebp);
+			// clamp_array(bits->begin(), 148, 1.5f);
+			for (auto &i : *bits)
+				i = (i > 0 ? 1 : -1);
+
+			auto rv = decode_sch(bits->begin(), false);
+			dbgout << "U DET@" << (rv2 ? "yes " : "   ") << "Timing offset     " << ebp.toa
+			       << " symbols, DECODE: " << (rv ? "yes" : "---") << " ";
+
+			delete bits;
+		}
+#endif
+		{
+			convert_and_scale<float, float>(burst.begin(), burst.begin(), ONE_TS_BURST_LEN * 2,
+							1.f / 32767.f);
+
+			std::complex<float> channel_imp_resp[CHAN_IMP_RESP_LENGTH * d_OSR];
+			auto ss = reinterpret_cast<std::complex<float> *>(burst.begin());
+			int d_c0_burst_start = get_sch_chan_imp_resp(ss, &channel_imp_resp[0]);
+			detect_burst(ss, &channel_imp_resp[0], d_c0_burst_start, outbin);
+
+			SoftVector bits;
+			bits.resize(148);
+			for (int i = 0; i < 148; i++) {
+				bits[i] = (!outbin[i]) < 1 ? -1 : 1;
+			}
+
+			auto rv = decode_sch(bits.begin(), false);
+			dbgout << "U SCH@"
+			       << " " << e.gsmts.FN() << ":" << e.gsmts.TN() << " " << d_c0_burst_start
+			       << " DECODE:" << (rv ? "yes" : "---") << std::endl;
+		}
+
+		DBGLG() << dbgout.str();
+		return;
+	}
+#if 1
+	convert_and_scale<float, int16_t>(burst.begin(), e.burst, ONE_TS_BURST_LEN * 2, 1.f / 2047.f);
+	// std::cerr << "@" << tsc << " " << e.gsmts.FN() << ":" << e.gsmts.TN() << " " << ebp.toa << " "
+	// 	  << std::endl;
+
+	unsigned char outbin[148];
+	auto ss = reinterpret_cast<std::complex<float> *>(burst.begin());
+	float ncmax, dcmax;
+	std::complex<float> chan_imp_resp[CHAN_IMP_RESP_LENGTH * d_OSR], chan_imp_resp2[CHAN_IMP_RESP_LENGTH * d_OSR];
+	auto normal_burst_start = get_norm_chan_imp_resp(ss, &chan_imp_resp[0], &ncmax, tsc);
+	auto dummy_burst_start = get_norm_chan_imp_resp(ss, &chan_imp_resp2[0], &dcmax, TS_DUMMY);
+	auto is_nb = ncmax > dcmax;
+
+	DBGLG() << " U " << (is_nb ? "NB" : "DB") << "@ o nb: " << normal_burst_start << " o db: " << dummy_burst_start
+		<< std::endl;
+
+	if (is_nb)
+		detect_burst(ss, &chan_imp_resp[0], normal_burst_start, outbin);
+	else
+		detect_burst(ss, &chan_imp_resp2[0], dummy_burst_start, outbin);
+	;
+
+	auto bits = SoftVector(148);
+	for (int i = 0; i < 148; i++)
+		(bits)[i] = outbin[i] < 1 ? -1 : 1;
+
+#endif
+}
+
+__attribute__((xray_always_instrument)) __attribute__((noinline)) void rcv_bursts_test(rx_queue_t *q, unsigned int *tsc)
+{
+	static bool first = true;
+	unsigned int lastfn = 0;
+	unsigned int fnbm = 0;
+	signalVector burst(ONE_TS_BURST_LEN, 100, 100);
+
+	cpu_set_t cpuset;
+
+	CPU_ZERO(&cpuset);
+	CPU_SET(1, &cpuset);
+
+	auto rv = pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);
+	if (rv < 0) {
+		std::cerr << "affinity: errreur! " << std::strerror(errno);
+		exit(0);
+	}
+
+	int prio = sched_get_priority_max(SCHED_RR);
+	struct sched_param param;
+	param.sched_priority = prio;
+	rv = sched_setscheduler(0, SCHED_RR, &param);
+	if (rv < 0) {
+		std::cerr << "scheduler: errreur! " << std::strerror(errno);
+		exit(0);
+	}
+
+	while (1) {
+		one_burst e;
+		while (!q->spsc_pop(&e)) {
+			q->spsc_prep_pop();
+		}
+
+		check_rcv_fn(e.gsmts, first, lastfn, fnbm);
+
+		handle_it(e, burst, *tsc);
+
+		// rv = detectSCHBurst(*burst, 4, 4, sch_detect_type::SCH_DETECT_FULL, &ebp);
+		// if (rv > 0)
+		// 	std::cerr << "#" << e.gsmts.FN() << ":" << e.gsmts.TN() << " " << ebp.toa << std::endl;
+		// sched_yield();
+	}
+}

Transceiver52M/ms/ms_rx_burst.h

@@ -0,0 +1,25 @@
+#pragma once
+/*
+ * (C) 2022 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
+ * All Rights Reserved
+ *
+ * Author: Eric Wild <ewild@sysmocom.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "syncthing.h"
+
+void rcv_bursts_test(rx_queue_t *q, unsigned int *tsc);

Transceiver52M/ms/ms_rx_lower.cpp

@@ -0,0 +1,330 @@
+/*
+ * (C) 2022 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
+ * All Rights Reserved
+ *
+ * Author: Eric Wild <ewild@sysmocom.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "sigProcLib.h"
+#include "signalVector.h"
+#include <atomic>
+#include <cassert>
+#include <complex>
+#include <iostream>
+#include <future>
+
+#include "syncthing.h"
+#include "grgsm_vitac/grgsm_vitac.h"
+
+extern "C" {
+#include "sch.h"
+}
+
+#ifdef LOG
+#undef LOG
+#endif
+
+#if !defined(SYNCTHINGONLY) //|| !defined(NODAMNLOG)
+#define DBGLG(...) ms_trx::dummy_log()
+#else
+#define DBGLG(...) std::cerr
+#endif
+
+#if !defined(SYNCTHINGONLY) || !defined(NODAMNLOG)
+#define DBGLG2(...) ms_trx::dummy_log()
+#else
+#define DBGLG2(...) std::cerr
+#endif
+
+#define PRINT_Q_OVERFLOW
+__attribute__((xray_always_instrument)) __attribute__((noinline)) bool ms_trx::decode_sch(float *bits,
+											  bool update_global_clock)
+{
+	int fn;
+	struct sch_info sch;
+	ubit_t info[GSM_SCH_INFO_LEN];
+	sbit_t data[GSM_SCH_CODED_LEN];
+
+	float_to_sbit(&bits[3], &data[0], 62, 39);
+	float_to_sbit(&bits[106], &data[39], 62, 39);
+
+	if (!gsm_sch_decode(info, data)) {
+		gsm_sch_parse(info, &sch);
+
+		if (update_global_clock) {
+			DBGLG() << "SCH : Decoded values" << std::endl;
+			DBGLG() << "    BSIC: " << sch.bsic << std::endl;
+			DBGLG() << "    TSC: " << (sch.bsic & 0x7) << std::endl;
+			DBGLG() << "    T1  : " << sch.t1 << std::endl;
+			DBGLG() << "    T2  : " << sch.t2 << std::endl;
+			DBGLG() << "    T3p : " << sch.t3p << std::endl;
+			DBGLG() << "    FN  : " << gsm_sch_to_fn(&sch) << std::endl;
+		}
+
+		fn = gsm_sch_to_fn(&sch);
+		if (fn < 0) { // how? wh?
+			DBGLG() << "SCH : Failed to convert FN " << std::endl;
+			return false;
+		}
+
+		if (update_global_clock) {
+			mBSIC = sch.bsic;
+			mTSC = sch.bsic & 0x7;
+			timekeeper.set(fn, 0);
+			// global_time_keeper.FN(fn);
+			// global_time_keeper.TN(0);
+		}
+#ifdef SYNCTHINGONLY
+		else {
+			int t3 = sch.t3p * 10 + 1;
+			if (t3 == 11) {
+				// timeslot hitter attempt @ fn 21 in mf
+				DBGLG2() << "sch @ " << t3 << std::endl;
+				auto e = GSM::Time(fn, 0);
+				e += 10;
+				ts_hitter_q.spsc_push(&e);
+			}
+		}
+#endif
+		// auto sch11 = gsm_sch_check_fn(fn + 11);
+		// DBGLG() << "next sch: "<< (sch11 ? "11":"10")<<" first ts " << first_sch_buf_rcv_ts << std::endl;
+		return true;
+	}
+	return false;
+}
+
+void ms_trx::maybe_update_gain(one_burst &brst)
+{
+	static_assert((sizeof(brst.burst) / sizeof(brst.burst[0])) == ONE_TS_BURST_LEN, "wtf, buffer size mismatch?");
+	const int avgburst_num = 8 * 20; // ~ 50*4.5ms = 90ms?
+	static_assert(avgburst_num * 577 > (50 * 1000), "can't update faster then blade wait time?");
+	const unsigned int rx_max_cutoff = (rxFullScale * 2) / 3;
+	static int gain_check = 0;
+	static float runmean = 0;
+	float sum = 0;
+	for (auto i : brst.burst)
+		sum += abs(i.real()) + abs(i.imag());
+	sum /= ONE_TS_BURST_LEN * 2;
+
+	runmean = gain_check ? (runmean * (gain_check + 2) - 1 + sum) / (gain_check + 2) : sum;
+
+	if (gain_check == avgburst_num - 1) {
+		DBGLG2() << "\x1B[32m #RXG \033[0m" << rxgain << " " << runmean << " " << sum << std::endl;
+		auto gainoffset = runmean < (rxFullScale / 4 ? 4 : 2);
+		gainoffset = runmean < (rxFullScale / 2 ? 2 : 1);
+		float newgain = runmean < rx_max_cutoff ? rxgain + gainoffset : rxgain - gainoffset;
+		// FIXME: gian cutoff
+		if (newgain != rxgain && newgain <= 60)
+			std::thread([this, newgain] { setRxGain(newgain); }).detach();
+		runmean = 0;
+	}
+	gain_check = (gain_check + 1) % avgburst_num;
+}
+
+bool ms_trx::handle_sch_or_nb(bool get_first_sch)
+{
+	one_burst brst;
+	auto current_gsm_time = timekeeper.gsmtime();
+	brst.gsmts = current_gsm_time;
+	memcpy(brst.burst, burst_copy_buffer, sizeof(blade_sample_type) * ONE_TS_BURST_LEN);
+	auto pushok = rxqueue.spsc_push(&brst);
+#ifdef PRINT_Q_OVERFLOW
+	if (!pushok)
+		std::cout << "F" << std::endl;
+#endif
+	if (do_auto_gain)
+		maybe_update_gain(brst);
+
+	// only continue for SCH, don't touch FCCH
+	auto is_sch = gsm_sch_check_fn(current_gsm_time.FN()) && current_gsm_time.TN() == 0;
+	auto is_fcch = gsm_fcch_check_fn(current_gsm_time.FN()) && current_gsm_time.TN() == 0;
+#pragma unused(is_fcch)
+
+	if (!is_sch) {
+		// sched_yield();
+		return false;
+	}
+	auto rv = handle_sch(false);
+	// sched_yield();
+	return rv;
+}
+
+float bernd[SCH_LEN_SPS * 2];
+
+bool ms_trx::handle_sch(bool is_first_sch_acq)
+{
+	struct estim_burst_params ebp;
+	auto current_gsm_time = timekeeper.gsmtime();
+	const auto buf_len = is_first_sch_acq ? SCH_LEN_SPS : ONE_TS_BURST_LEN;
+	const auto which_buffer = is_first_sch_acq ? first_sch_buf : burst_copy_buffer;
+
+	std::complex<float> channel_imp_resp[CHAN_IMP_RESP_LENGTH * d_OSR];
+	unsigned char outbin[148];
+	float max_corr = 0;
+	const auto ss = reinterpret_cast<std::complex<float> *>(&bernd[0]);
+	convert_and_scale<float, int16_t>(bernd, which_buffer, buf_len * 2, 1.f / 2047.f);
+
+	auto start = is_first_sch_acq ? get_sch_buffer_chan_imp_resp(ss, &channel_imp_resp[0], buf_len, &max_corr) :
+					get_sch_chan_imp_resp(ss, channel_imp_resp);
+	detect_burst(&ss[start], &channel_imp_resp[0], 0, outbin);
+
+	SoftVector bitss(148);
+	for (int i = 0; i < 148; i++) {
+		bitss[i] = (!outbin[i]) < 1 ? -1 : 1;
+	}
+
+	auto sch_decode_success = decode_sch(bitss.begin(), is_first_sch_acq);
+
+	if (sch_decode_success) {
+		const auto ts_offset_symb = 0;
+		if (is_first_sch_acq) {
+			// update ts to first sample in sch buffer, to allow delay calc for current ts
+			first_sch_ts_start = first_sch_buf_rcv_ts + start - (ts_offset_symb * 4);
+		} else if (abs(start) > 1) {
+			// continuous sch tracking, only update if off too much
+			temp_ts_corr_offset += -start;
+			std::cerr << "offs: " << start << " " << temp_ts_corr_offset << std::endl;
+		}
+
+		return true;
+	} else {
+		DBGLG2() << "L SCH : \x1B[31m decode fail \033[0m @ toa:" << start << " " << current_gsm_time.FN()
+			 << ":" << current_gsm_time.TN() << std::endl;
+	}
+	return false;
+}
+
+__attribute__((xray_never_instrument)) SCH_STATE ms_trx::search_for_sch(dev_buf_t *rcd)
+{
+	static unsigned int sch_pos = 0;
+	if (sch_thread_done)
+		return SCH_STATE::FOUND;
+
+	if (rcv_done)
+		return SCH_STATE::SEARCHING;
+
+	auto to_copy = SCH_LEN_SPS - sch_pos;
+
+	if (SCH_LEN_SPS == to_copy) // first time
+		first_sch_buf_rcv_ts = rcd->get_first_ts();
+
+	if (!to_copy) {
+		sch_pos = 0;
+		rcv_done = true;
+		std::thread([this] {
+			set_name_aff_sched("sch_search", 1, SCHED_FIFO, sched_get_priority_max(SCHED_FIFO) - 5);
+
+			auto ptr = reinterpret_cast<const int16_t *>(first_sch_buf);
+			const auto target_val = rxFullScale / 8;
+			float sum = 0;
+			for (int i = 0; i < SCH_LEN_SPS * 2; i++)
+				sum += std::abs(ptr[i]);
+			sum /= SCH_LEN_SPS * 2;
+
+			//FIXME: arbitrary value, gain cutoff
+			if (sum > target_val || rxgain >= 60) // enough ?
+				sch_thread_done = this->handle_sch(true);
+			else {
+				std::cerr << "\x1B[32m #RXG \033[0m gain " << rxgain << " -> " << rxgain + 4
+					  << " sample avg:" << sum << " target: >=" << target_val << std::endl;
+				setRxGain(rxgain + 4);
+			}
+
+			if (!sch_thread_done)
+				rcv_done = false; // retry!
+			return (bool)sch_thread_done;
+		}).detach();
+	}
+
+	auto spsmax = rcd->actual_samples_per_buffer();
+	if (to_copy > spsmax)
+		sch_pos += rcd->readall(first_sch_buf + sch_pos);
+	else
+		sch_pos += rcd->read_n(first_sch_buf + sch_pos, 0, to_copy);
+
+	return SCH_STATE::SEARCHING;
+}
+__attribute__((optnone)) void ms_trx::grab_bursts(dev_buf_t *rcd)
+{
+	// partial burst samples read from the last buffer
+	static int partial_rdofs = 0;
+	static bool first_call = true;
+	int to_skip = 0;
+
+	// round up to next burst by calculating the time between sch detection and now
+	if (first_call) {
+		const auto next_burst_start = rcd->get_first_ts() - first_sch_ts_start;
+		const auto fullts = next_burst_start / ONE_TS_BURST_LEN;
+		const auto fracts = next_burst_start % ONE_TS_BURST_LEN;
+		to_skip = ONE_TS_BURST_LEN - fracts;
+
+		for (int i = 0; i < fullts; i++)
+			timekeeper.inc_and_update(first_sch_ts_start + i * ONE_TS_BURST_LEN);
+
+		if (fracts)
+			timekeeper.inc_both();
+		// timekeeper.inc_and_update(first_sch_ts_start + 1 * ONE_TS_BURST_LEN);
+
+		timekeeper.dec_by_one(); // oops, off by one?
+
+		timekeeper.set(timekeeper.gsmtime(), rcd->get_first_ts() - ONE_TS_BURST_LEN + to_skip);
+
+		DBGLG() << "this ts: " << rcd->get_first_ts() << " diff full TN: " << fullts << " frac TN: " << fracts
+			<< " GSM now: " << timekeeper.gsmtime().FN() << ":" << timekeeper.gsmtime().TN() << " is sch? "
+			<< gsm_sch_check_fn(timekeeper.gsmtime().FN()) << std::endl;
+		first_call = false;
+	}
+
+	if (partial_rdofs) {
+		auto first_remaining = ONE_TS_BURST_LEN - partial_rdofs;
+		// memcpy(burst_copy_buffer, partial_buf, partial_rdofs * sizeof(blade_sample_type));
+		auto rd = rcd->read_n(burst_copy_buffer + partial_rdofs, 0, first_remaining);
+		if (rd != first_remaining) {
+			partial_rdofs += rd;
+			return;
+		}
+
+		timekeeper.inc_and_update_safe(rcd->get_first_ts() - partial_rdofs);
+		handle_sch_or_nb();
+		to_skip = first_remaining;
+	}
+
+	// apply sample rate slippage compensation
+	to_skip -= temp_ts_corr_offset;
+
+	// FIXME: happens rarely, read_n start -1 blows up
+	// this is fine: will just be corrected one buffer later
+	if (to_skip < 0)
+		to_skip = 0;
+	else
+		temp_ts_corr_offset = 0;
+
+	const auto left_after_burst = rcd->actual_samples_per_buffer() - to_skip;
+
+	const int full = left_after_burst / ONE_TS_BURST_LEN;
+	const int frac = left_after_burst % ONE_TS_BURST_LEN;
+
+	for (int i = 0; i < full; i++) {
+		rcd->read_n(burst_copy_buffer, to_skip + i * ONE_TS_BURST_LEN, ONE_TS_BURST_LEN);
+		timekeeper.inc_and_update_safe(rcd->get_first_ts() + to_skip + i * ONE_TS_BURST_LEN);
+		handle_sch_or_nb();
+	}
+
+	if (frac)
+		rcd->read_n(burst_copy_buffer, to_skip + full * ONE_TS_BURST_LEN, frac);
+	partial_rdofs = frac;
+}

Transceiver52M/ms/ms_rx_upper.cpp

@@ -0,0 +1,364 @@
+/*
+ * (C) 2022 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
+ * All Rights Reserved
+ *
+ * Author: Eric Wild <ewild@sysmocom.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "sigProcLib.h"
+#include "syncthing.h"
+#include "l1if.h"
+#include <signalVector.h>
+#include <radioVector.h>
+#include <radioInterface.h>
+#include "grgsm_vitac/grgsm_vitac.h"
+#include "ms_state.h"
+#include "ms_rx_upper.h"
+
+extern "C" {
+#include "sch.h"
+#include "convolve.h"
+#include "convert.h"
+#include "proto_trxd.h"
+}
+
+#ifdef LOG
+#undef LOG
+#define LOG(...) upper_trx::dummy_log()
+#endif
+
+void upper_trx::start_threads()
+{
+	thr_rx = std::thread([this] {
+		set_name_aff_sched("upper_rx", 1, SCHED_FIFO, sched_get_priority_max(SCHED_FIFO) - 5);
+		while (1) {
+			driveReceiveFIFO();
+			pthread_testcancel();
+		}
+	});
+	msleep(1);
+
+	thr_control = std::thread([this] {
+		set_name_aff_sched("upper_ctrl", 1, SCHED_RR, sched_get_priority_max(SCHED_RR));
+		while (1) {
+			driveControl();
+			pthread_testcancel();
+		}
+	});
+	msleep(1);
+	thr_tx = std::thread([this] {
+		set_name_aff_sched("upper_tx", 1, SCHED_FIFO, sched_get_priority_max(SCHED_FIFO) - 1);
+
+		while (1) {
+			driveTx();
+			pthread_testcancel();
+		}
+	});
+}
+
+void upper_trx::start_ms()
+{
+	ms_trx::start();
+}
+
+/* Detect SCH synchronization sequence within a burst */
+bool upper_trx::detectSCH(ms_TransceiverState *state, signalVector &burst, struct estim_burst_params *ebp)
+{
+	int shift;
+	sch_detect_type full;
+	float mag, threshold = 4.0;
+
+	full = (state->mode == trx_mode::TRX_MODE_MS_TRACK) ? sch_detect_type::SCH_DETECT_NARROW :
+							      sch_detect_type::SCH_DETECT_FULL;
+
+	if (!detectSCHBurst(burst, threshold, rx_sps, full, ebp))
+		return false;
+
+	std::clog << "SCH : Timing offset     " << ebp->toa << " symbols" << std::endl;
+
+	mag = fabsf(ebp->toa);
+	if (mag < 1.0f)
+		return true;
+
+	shift = (int)(mag / 2.0f);
+	if (!shift)
+		shift++;
+
+	shift = ebp->toa > 0 ? shift : -shift;
+	std::clog << "SCH : shift ->     " << shift << " symbols" << std::endl;
+	// mRadioInterface->applyOffset(shift);
+	return false;
+}
+
+SoftVector *upper_trx::pullRadioVector(GSM::Time &wTime, int &RSSI, int &timingOffset) __attribute__((optnone))
+{
+	float pow, avg = 1.0;
+	signalVector *burst;
+	SoftVector *bits = new SoftVector(148);
+	GSM::Time burst_time;
+
+	one_burst e;
+	unsigned char outbin[148];
+	std::complex<float> chan_imp_resp[CHAN_IMP_RESP_LENGTH * d_OSR];
+	std::stringstream dbgout;
+
+	while (!rxqueue.spsc_pop(&e)) {
+		rxqueue.spsc_prep_pop();
+	}
+
+	auto sv = signalVector(625, 40);
+	burst = &sv;
+	auto ss = reinterpret_cast<std::complex<float> *>(burst->begin());
+
+	convert_and_scale<float, int16_t>(burst->begin(), e.burst, ONE_TS_BURST_LEN * 2, 1.f / 2047.f);
+
+	/* Set time and determine correlation type */
+	burst_time = e.gsmts;
+
+	wTime = burst_time;
+
+	CorrType type = mStates.expectedCorrType(burst_time, mRxSlotMask);
+
+	switch (mStates.mode) {
+	case trx_mode::TRX_MODE_MS_TRACK:
+		if (gsm_sch_check_fn(burst_time.FN()) && burst_time.TN() == 0)
+			type = SCH;
+		else if (burst_time.TN() == 0 && !gsm_fcch_check_fn(burst_time.FN())) // all ts0, but not fcch or sch..
+			type = TSC;
+		else if (type == OFF)
+			goto release;
+		break;
+
+	case trx_mode::TRX_MODE_OFF:
+	default:
+		goto release;
+	}
+
+	pow = energyDetect(*burst, 20 * rx_sps);
+	if (pow < -1) {
+		LOG(ALERT) << "Received empty burst";
+		goto release;
+	}
+
+	avg = sqrt(pow);
+
+	if (type == SCH) {
+		int d_c0_burst_start = get_sch_chan_imp_resp(ss, &chan_imp_resp[0]);
+		detect_burst(ss, &chan_imp_resp[0], d_c0_burst_start, outbin);
+
+		for (int i = 0; i < 148; i++)
+			(*bits)[i] = (!outbin[i]) < 1 ? -1 : 1;
+
+		// auto rv = decode_sch(bits->begin(), false);
+		// dbgout << "U SCH@"
+		//        << " " << e.gsmts.FN() << ":" << e.gsmts.TN() << " " << d_c0_burst_start
+		//        << " DECODE:" << (rv ? "yes" : "---") << std::endl;
+
+		// std::cerr << dbgout.str();
+	} else {
+		float ncmax, dcmax;
+		std::complex<float> chan_imp_resp2[CHAN_IMP_RESP_LENGTH * d_OSR];
+		auto normal_burst_start = get_norm_chan_imp_resp(ss, &chan_imp_resp[0], &ncmax, mTSC);
+		auto dummy_burst_start = get_norm_chan_imp_resp(ss, &chan_imp_resp2[0], &dcmax, TS_DUMMY);
+		auto is_nb = ncmax > dcmax;
+
+		// std::cerr << " U " << (is_nb ? "NB" : "DB") << "@ o nb: " << normal_burst_start
+		// 	  << " o db: " << dummy_burst_start << std::endl;
+
+		if (is_nb)
+			detect_burst(ss, &chan_imp_resp[0], normal_burst_start, outbin);
+		else
+			detect_burst(ss, &chan_imp_resp2[0], dummy_burst_start, outbin);
+
+		for (int i = 0; i < 148; i++)
+			(*bits)[i] = (outbin[i]) < 1 ? -1 : 1;
+	}
+
+	RSSI = (int)floor(20.0 * log10(rxFullScale / avg));
+	timingOffset = (int)round(0);
+
+	return bits;
+
+release:
+
+	delete bits;
+	return NULL;
+}
+
+void upper_trx::driveReceiveFIFO()
+{
+	SoftVector *rxBurst = NULL;
+	int RSSI;
+	int TOA; // in 1/256 of a symbol
+	GSM::Time burstTime;
+
+	rxBurst = pullRadioVector(burstTime, RSSI, TOA);
+	if (!mOn)
+		return;
+
+	// _only_ return useless fcch trash to tickle trxcons tx path
+	// auto is_fcch = [&burstTime]{ return burstTime.TN() == 0 && gsm_fcch_check_fn(burstTime.FN());};
+	// if(!rxBurst && !is_fcch())
+	// 	return;
+
+	auto response = (trxd_from_trx *)calloc(1, sizeof(trxd_from_trx));
+
+	response->ts = burstTime.TN();
+	response->fn = htonl(burstTime.FN());
+	response->rssi = RSSI;
+	response->toa = htons(TOA);
+	if (rxBurst) {
+		SoftVector::const_iterator burstItr = rxBurst->begin();
+		if (gsm_sch_check_fn(burstTime.FN())) {
+			clamp_array(rxBurst->begin(), 148, 1.5f);
+			for (unsigned int i = 0; i < gSlotLen; i++) {
+				auto val = *burstItr++;
+				auto vval = isnan(val) ? 0 : val;
+				((int8_t *)response->symbols)[i] = round((vval - 0.5) * 64.0);
+			}
+		} else {
+			// invert and fix to +-127 sbits
+			for (int i = 0; i < 148; i++)
+				((int8_t *)response->symbols)[i] = *burstItr++ > 0.0f ? -127 : 127;
+		}
+
+		delete rxBurst;
+	}
+
+#ifdef IPCIF
+	push_d(response);
+#else
+	int rv = sendto(mDataSockets, response, sizeof(trxd_from_trx), 0, (struct sockaddr *)&datadest,
+			sizeof(struct sockaddr_in));
+	if (rv < 0) {
+		std::cerr << "fuck, send?" << std::endl;
+		exit(0);
+	}
+	free(response);
+
+#endif
+}
+
+void upper_trx::driveTx()
+{
+#ifdef IPCIF
+	auto burst = pop_d();
+	if (!burst) {
+		// std::cerr << "wtf no tx burst?" << std::endl;
+		// exit(0);
+		continue;
+	}
+#else
+	trxd_to_trx buffer;
+
+	socklen_t addr_len = sizeof(datasrc);
+	int rdln = recvfrom(mDataSockets, (void *)&buffer, sizeof(trxd_to_trx), 0, &datasrc, &addr_len);
+	if (rdln < 0 && errno == EAGAIN) {
+		std::cerr << "fuck, rcv?" << std::endl;
+		exit(0);
+	}
+
+	trxd_to_trx *burst = &buffer;
+#endif
+	auto proper_fn = ntohl(burst->fn);
+	// std::cerr << "got burst!" << proper_fn << ":" << burst->ts
+	// 	  << " current: " << timekeeper.gsmtime().FN()
+	// 	  << " dff: " << (int64_t)((int64_t)timekeeper.gsmtime().FN() - (int64_t)proper_fn)
+	// 	  << std::endl;
+
+	auto currTime = GSM::Time(proper_fn, burst->ts);
+	int RSSI = (int)burst->txlev;
+
+	static BitVector newBurst(gSlotLen);
+	BitVector::iterator itr = newBurst.begin();
+	auto *bufferItr = burst->symbols;
+	while (itr < newBurst.end())
+		*itr++ = *bufferItr++;
+
+	auto txburst = modulateBurst(newBurst, 8 + (currTime.TN() % 4 == 0), 4);
+	scaleVector(*txburst, txFullScale * 0.7 /* * pow(10, -RSSI / 10)*/);
+
+	// float -> int16
+	blade_sample_type burst_buf[txburst->size()];
+	convert_and_scale<int16_t, float>(burst_buf, txburst->begin(), txburst->size() * 2, 1);
+
+	// auto check = signalVector(txburst->size(), 40);
+	// convert_and_scale<float, int16_t, 1>(check.begin(), burst_buf, txburst->size() * 2);
+	// estim_burst_params ebp;
+	// auto d = detectAnyBurst(check, 2, 4, 4, CorrType::RACH, 40, &ebp);
+	// if(d)
+	// 	std::cerr << "RACH D! " << ebp.toa << std::endl;
+	// else
+	// 	std::cerr << "RACH NOOOOOOOOOO D! " << ebp.toa << std::endl;
+
+	// memory read --binary --outfile /tmp/mem.bin &burst_buf[0] --count 2500 --force
+
+	submit_burst(burst_buf, txburst->size(), currTime);
+
+#ifdef IPCIF
+	free(burst);
+#endif
+}
+
+// __attribute__((xray_always_instrument)) static void *rx_stream_callback(struct bladerf *dev,
+// 									struct bladerf_stream *stream,
+// 									struct bladerf_metadata *meta, void *samples,
+// 									size_t num_samples, void *user_data)
+// {
+// 	struct ms_trx *trx = (struct ms_trx *)user_data;
+// 	return trx->rx_cb(dev, stream, meta, samples, num_samples, user_data);
+// }
+
+// __attribute__((xray_always_instrument)) static void *tx_stream_callback(struct bladerf *dev,
+// 									struct bladerf_stream *stream,
+// 									struct bladerf_metadata *meta, void *samples,
+// 									size_t num_samples, void *user_data)
+// {
+// 	struct ms_trx *trx = (struct ms_trx *)user_data;
+// 	return BLADERF_STREAM_NO_DATA;
+// }
+
+int trxc_main(int argc, char *argv[])
+{
+	pthread_setname_np(pthread_self(), "main_trxc");
+
+	convolve_init();
+	convert_init();
+	sigProcLibSetup();
+	initvita();
+
+	int status = 0;
+	auto trx = new upper_trx();
+	trx->do_auto_gain = true;
+
+	status = trx->init_dev_and_streams(0, 0);
+	trx->start_threads();
+
+	return status;
+}
+
+extern "C" volatile bool gshutdown = false;
+extern "C" void init_external_transceiver(int argc, char **argv)
+{
+	std::cout << "init?" << std::endl;
+	trxc_main(argc, argv);
+}
+
+extern "C" void stop_trx()
+{
+	std::cout << "Shutting down transceiver..." << std::endl;
+}

Transceiver52M/ms/ms_rx_upper.h

@@ -0,0 +1,121 @@
+
+#pragma once
+
+/*
+ * (C) 2022 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
+ * All Rights Reserved
+ *
+ * Author: Eric Wild <ewild@sysmocom.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#include <netdb.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+
+#include "GSMCommon.h"
+#include "radioClock.h"
+#include "syncthing.h"
+#include "ms_state.h"
+
+class upper_trx : public ms_trx {
+	int rx_sps, tx_sps;
+
+	ms_TransceiverState mStates;
+
+	bool mOn; ///< flag to indicate that transceiver is powered on
+	double mTxFreq; ///< the transmit frequency
+	double mRxFreq; ///< the receive frequency
+	int mPower; ///< the transmit power in dB
+	unsigned mMaxExpectedDelay; ///< maximum TOA offset in GSM symbols
+	unsigned long long mRxSlotMask[8]; ///< MS - enabled multiframe slot mask
+
+	int mDataSockets;
+	sockaddr_in datadest;
+	sockaddr datasrc;
+	int mCtrlSockets;
+	sockaddr_in ctrldest;
+	sockaddr ctrlsrc;
+
+	void openudp(int *mSocketFD, unsigned short localPort, const char *wlocalIP)
+	{
+		*mSocketFD = socket(AF_INET, SOCK_DGRAM, 0);
+		int on = 1;
+		setsockopt(*mSocketFD, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
+
+		struct sockaddr_in address;
+		size_t length = sizeof(address);
+		bzero(&address, length);
+		address.sin_family = AF_INET;
+		address.sin_addr.s_addr = inet_addr(wlocalIP);
+		address.sin_port = htons(localPort);
+		if (bind(*mSocketFD, (struct sockaddr *)&address, length) < 0) {
+			std::cerr << "bind fail!" << std::endl;
+			exit(0);
+		}
+	}
+
+	bool resolveAddress(struct sockaddr_in *address, const char *host, unsigned short port)
+	{
+		struct hostent *hp;
+		int h_errno_local;
+
+		struct hostent hostData;
+		char tmpBuffer[2048];
+
+		auto rc = gethostbyname2_r(host, AF_INET, &hostData, tmpBuffer, sizeof(tmpBuffer), &hp, &h_errno_local);
+		if (hp == NULL || hp->h_addrtype != AF_INET || rc != 0) {
+			std::cerr << "WARNING -- gethostbyname() failed for " << host << ", "
+				  << hstrerror(h_errno_local);
+			exit(0);
+			return false;
+		}
+
+		address->sin_family = hp->h_addrtype;
+		assert(sizeof(address->sin_addr) == hp->h_length);
+		memcpy(&(address->sin_addr), hp->h_addr_list[0], hp->h_length);
+		address->sin_port = htons(port);
+		return true;
+	}
+
+	void driveControl();
+	void driveReceiveFIFO();
+	void driveTx();
+	void commandhandler(char *buffer, char *response);
+	void writeClockInterface(){};
+
+	SoftVector *pullRadioVector(GSM::Time &wTime, int &RSSI, int &timingOffset);
+
+	bool detectSCH(ms_TransceiverState *state, signalVector &burst, struct estim_burst_params *ebp);
+
+	std::thread thr_control, thr_rx, thr_tx;
+
+    public:
+	void start_threads();
+	void start_ms();
+
+	upper_trx() : rx_sps(4), tx_sps(4)
+	{
+		auto c_srcport = 6700 + 2 * 0 + 1;
+		auto c_dstport = 6700 + 2 * 0 + 101;
+		auto d_srcport = 6700 + 2 * 0 + 2;
+		auto d_dstport = 6700 + 2 * 0 + 102;
+
+		openudp(&mCtrlSockets, c_srcport, "127.0.0.1");
+		openudp(&mDataSockets, d_srcport, "127.0.0.1");
+		resolveAddress(&ctrldest, "127.0.0.1", c_dstport);
+		resolveAddress(&datadest, "127.0.0.1", d_dstport);
+	};
+};

Transceiver52M/ms/ms_state.h

@@ -0,0 +1,175 @@
+#pragma once
+
+#include <radioVector.h>
+#include <signalVector.h>
+
+enum class trx_mode {
+	TRX_MODE_OFF,
+	TRX_MODE_BTS,
+	TRX_MODE_MS_ACQUIRE,
+	TRX_MODE_MS_TRACK,
+};
+
+enum class ChannelCombination {
+	FILL, ///< Channel is transmitted, but unused
+	I, ///< TCH/FS
+	II, ///< TCH/HS, idle every other slot
+	III, ///< TCH/HS
+	IV, ///< FCCH+SCH+CCCH+BCCH, uplink RACH
+	V, ///< FCCH+SCH+CCCH+BCCH+SDCCH/4+SACCH/4, uplink RACH+SDCCH/4
+	VI, ///< CCCH+BCCH, uplink RACH
+	VII, ///< SDCCH/8 + SACCH/8
+	VIII, ///< TCH/F + FACCH/F + SACCH/M
+	IX, ///< TCH/F + SACCH/M
+	X, ///< TCH/FD + SACCH/MD
+	XI, ///< PBCCH+PCCCH+PDTCH+PACCH+PTCCH
+	XII, ///< PCCCH+PDTCH+PACCH+PTCCH
+	XIII, ///< PDTCH+PACCH+PTCCH
+	NONE_INACTIVE, ///< Channel is inactive, default
+	LOOPBACK ///< similar go VII, used in loopback testing
+};
+
+struct ms_TransceiverState {
+	ms_TransceiverState() : mFreqOffsets(10), mode(trx_mode::TRX_MODE_OFF)
+	{
+		for (int i = 0; i < 8; i++) {
+			chanType[i] = ChannelCombination::NONE_INACTIVE;
+			fillerModulus[i] = 26;
+
+			for (int n = 0; n < 102; n++)
+				fillerTable[n][i] = nullptr;
+		}
+	}
+
+	~ms_TransceiverState()
+	{
+		for (int i = 0; i < 8; i++) {
+			for (int n = 0; n < 102; n++)
+				delete fillerTable[n][i];
+		}
+	}
+
+	void setModulus(size_t timeslot)
+	{
+		switch (chanType[timeslot]) {
+		case ChannelCombination::NONE_INACTIVE:
+		case ChannelCombination::I:
+		case ChannelCombination::II:
+		case ChannelCombination::III:
+		case ChannelCombination::FILL:
+			fillerModulus[timeslot] = 26;
+			break;
+		case ChannelCombination::IV:
+		case ChannelCombination::VI:
+		case ChannelCombination::V:
+			fillerModulus[timeslot] = 51;
+			break;
+			//case V:
+		case ChannelCombination::VII:
+			fillerModulus[timeslot] = 102;
+			break;
+		case ChannelCombination::XIII:
+			fillerModulus[timeslot] = 52;
+			break;
+		default:
+			break;
+		}
+	}
+
+	CorrType expectedCorrType(GSM::Time currTime, unsigned long long *mRxSlotMask)
+	{
+		unsigned burstTN = currTime.TN();
+		unsigned burstFN = currTime.FN();
+
+		if (mode == trx_mode::TRX_MODE_MS_TRACK) {
+			/* 102 modulus case currently unhandled */
+			if (fillerModulus[burstTN] > 52)
+				return OFF;
+
+			int modFN = burstFN % fillerModulus[burstTN];
+			unsigned long long reg = (unsigned long long)1 << modFN;
+			if (reg & mRxSlotMask[burstTN])
+				return TSC;
+			else
+				return OFF;
+		}
+
+		switch (chanType[burstTN]) {
+		case ChannelCombination::NONE_INACTIVE:
+			return OFF;
+			break;
+		case ChannelCombination::FILL:
+			return IDLE;
+			break;
+		case ChannelCombination::I:
+			return TSC;
+			/*if (burstFN % 26 == 25) 
+      return IDLE;
+    else
+      return TSC;*/
+			break;
+		case ChannelCombination::II:
+			return TSC;
+			break;
+		case ChannelCombination::III:
+			return TSC;
+			break;
+		case ChannelCombination::IV:
+		case ChannelCombination::VI:
+			return RACH;
+			break;
+		case ChannelCombination::V: {
+			int mod51 = burstFN % 51;
+			if ((mod51 <= 36) && (mod51 >= 14))
+				return RACH;
+			else if ((mod51 == 4) || (mod51 == 5))
+				return RACH;
+			else if ((mod51 == 45) || (mod51 == 46))
+				return RACH;
+			else
+				return TSC;
+			break;
+		}
+		case ChannelCombination::VII:
+			if ((burstFN % 51 <= 14) && (burstFN % 51 >= 12))
+				return IDLE;
+			else
+				return TSC;
+			break;
+		case ChannelCombination::XIII: {
+			int mod52 = burstFN % 52;
+			if ((mod52 == 12) || (mod52 == 38))
+				return RACH;
+			else if ((mod52 == 25) || (mod52 == 51))
+				return IDLE;
+			else
+				return TSC;
+			break;
+		}
+		case ChannelCombination::LOOPBACK:
+			if ((burstFN % 51 <= 50) && (burstFN % 51 >= 48))
+				return IDLE;
+			else
+				return TSC;
+			break;
+		default:
+			return OFF;
+			break;
+		}
+	}
+
+	/* Initialize a multiframe slot in the filler table */
+	void init(size_t slot, signalVector *burst, bool fill);
+
+	ChannelCombination chanType[8];
+
+	/* The filler table */
+	signalVector *fillerTable[102][8];
+	int fillerModulus[8];
+
+	/* Received noise energy levels */
+	avgVector mFreqOffsets;
+
+	/* Transceiver mode */
+	trx_mode mode;
+};