ipc: fix driver test restart

Change-Id: Id21f773d365f2e70129e1d463cf87b1213718be7

.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,7 @@
 Transceiver52M/osmo-trx-uhd
 Transceiver52M/osmo-trx-usrp1
 Transceiver52M/osmo-trx-lms
+Transceiver52M/osmo-trx-ipc
 
 # tests
 tests/CommonLibs/BitVectorTest
@@ -19,6 +20,7 @@ tests/CommonLibs/VectorTest
 tests/CommonLibs/PRBSTest
 tests/Transceiver52M/convolve_test
 tests/Transceiver52M/LMSDeviceTest
+Transceiver52M/device/ipc/ipc-driver-test
 
 # automake/autoconf
 *.in
@@ -63,3 +65,8 @@ doc/manuals/generated/
 doc/manuals/osmomsc-usermanual.xml
 doc/manuals/common
 doc/manuals/build
+
+contrib/osmo-trx.spec
+!contrib/osmo-trx.spec.in
+
+utils/osmo-prbs-tool

CommonLibs/debug.c

@@ -73,7 +73,7 @@ static const struct log_info_cat default_categories[] = {
 		.name = "DDEV",
 		.description = "Device/Driver specific code",
 		.color = NULL,
-		.enabled = 1, .loglevel = LOGL_INFO,
+		.enabled = 1, .loglevel = LOGL_NOTICE,
 	},
 	[DDEVDRV] = {
 		.name = "DDEVDRV",
@@ -81,6 +81,12 @@ 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 = {

CommonLibs/debug.h

@@ -16,6 +16,7 @@ enum {
 	DTRXDUL,
 	DDEV,
 	DDEVDRV,
+	DCTR,
 };
 
 pid_t my_gettid(void);

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_ctrs[chan]->ctr[TRX_CTR_DEV_RX_OVERRUNS];
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].rx_overruns - ctr->current);
+		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_DEV_TX_UNDERRUNS];
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].tx_underruns - ctr->current);
+		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_DEV_RX_DROP_EV];
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].rx_dropped_events - ctr->current);
+		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_DEV_RX_DROP_SMPL];
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].rx_dropped_samples - ctr->current);
+		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_DEV_TX_DROP_EV];
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].tx_dropped_events - ctr->current);
+		ctr = &rate_ctrs[chan]->ctr[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_ctrs[chan]->ctr[TRX_CTR_TRX_TX_STALE_BURSTS];
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_stale_bursts - ctr->current);
+		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_TRX_TX_UNAVAILABLE_BURSTS];
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_unavailable_bursts - ctr->current);
+		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_TRX_TRXD_FN_REPEATED];
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_trxd_fn_repeated - ctr->current);
+		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_TRX_TRXD_FN_OUTOFORDER];
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_trxd_fn_outoforder - ctr->current);
+		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_TRX_TRXD_FN_SKIPPED];
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_trxd_fn_skipped - ctr->current);
+		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_TRX_RX_EMPTY_BURST];
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].rx_empty_burst - ctr->current);
+		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_TRX_RX_CLIPPING];
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].rx_clipping - ctr->current);
+		ctr = &rate_ctrs[chan]->ctr[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,7 +207,8 @@ 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};
@@ -163,14 +217,24 @@ static int device_sig_cb(unsigned int subsys, unsigned int signal,
 
 	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(errno);
 		}
-		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(errno);
+		}
+		trx_rate_ctr_mutex.unlock();
 		break;
 	default:
 		break;
@@ -195,15 +259,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)
+			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 +319,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 +336,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 +373,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 +388,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

@@ -291,7 +291,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 +299,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;
 }
@@ -390,7 +392,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 +400,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 \

Makefile.am

@@ -33,12 +33,16 @@ SUBDIRS = \
 	GSM \
 	Transceiver52M \
 	contrib \
-	tests
+	tests \
+	utils
 
 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)

TODO-RELEASE

@@ -0,0 +1,2 @@
+* update libosmocore dependency to > 1.3.x for osmo_sched_vty_init(), osmo_sched_vty_apply_localthread()
+* update osmo-gsm-manuals dependency to > 0.3.0 for vty_cpu_sched.adoc include.

Transceiver52M/Makefile.am

@@ -104,3 +104,10 @@ osmo_trx_lms_LDADD = \
 	$(LMS_LIBS)
 osmo_trx_lms_CPPFLAGS  = $(AM_CPPFLAGS) $(LMS_CFLAGS)
 endif
+
+bin_PROGRAMS += osmo-trx-ipc
+osmo_trx_ipc_SOURCES = osmo-trx.cpp
+osmo_trx_ipc_LDADD = \
+	$(builddir)/device/ipc/libdevice.la \
+	$(COMMON_LDADD)
+osmo_trx_ipc_CPPFLAGS  = $(AM_CPPFLAGS)

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
@@ -45,13 +46,23 @@ extern "C" {
 
 using namespace GSM;
 
+Transceiver *transceiver;
+
 #define USB_LATENCY_INTRVL		10,0
 
 /* 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)
 {
   for (int i = 0; i < 8; i++) {
     chanType[i] = Transceiver::NONE;
@@ -63,6 +74,7 @@ TransceiverState::TransceiverState()
     for (int n = 0; n < 102; n++)
       fillerTable[n][i] = NULL;
   }
+  memset(&ctrs, 0, sizeof(struct trx_counters));
 }
 
 TransceiverState::~TransceiverState()
@@ -84,6 +96,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) {
@@ -151,20 +165,30 @@ Transceiver::~Transceiver()
     close(mClockSocket);
 
   for (size_t i = 0; i < mChans; i++) {
-    if (mControlServiceLoopThreads[i]) {
-      mControlServiceLoopThreads[i]->cancel();
-      mControlServiceLoopThreads[i]->join();
-      delete mControlServiceLoopThreads[i];
-    }
-
     mTxPriorityQueues[i].clear();
-    if (mCtrlSockets[i] >= 0)
-      close(mCtrlSockets[i]);
     if (mDataSockets[i] >= 0)
       close(mDataSockets[i]);
   }
 }
 
+int Transceiver::ctrl_sock_cb(struct osmo_fd *bfd, unsigned int flags)
+{
+  int rc = 0;
+  int chan = static_cast<int>(reinterpret_cast<uintptr_t>(bfd->data));
+
+  if (flags & OSMO_FD_READ)
+    rc = transceiver->ctrl_sock_handle_rx(chan);
+  if (rc < 0)
+    osmo_signal_dispatch(SS_MAIN, S_MAIN_STOP_REQUIRED, NULL);
+
+  if (flags & OSMO_FD_WRITE)
+    rc = transceiver->ctrl_sock_write(chan);
+  if (rc < 0)
+    osmo_signal_dispatch(SS_MAIN, S_MAIN_STOP_REQUIRED, NULL);
+
+  return rc;
+}
+
 /*
  * Initialize transceiver
  *
@@ -193,8 +217,7 @@ bool Transceiver::init(FillerType filler, size_t rtsc, unsigned rach_delay,
   mEdge = edge;
 
   mDataSockets.resize(mChans, -1);
-  mCtrlSockets.resize(mChans, -1);
-  mControlServiceLoopThreads.resize(mChans);
+  mCtrlSockets.resize(mChans);
   mTxPriorityQueueServiceLoopThreads.resize(mChans);
   mRxServiceLoopThreads.resize(mChans);
 
@@ -216,24 +239,34 @@ bool Transceiver::init(FillerType filler, size_t rtsc, unsigned rach_delay,
     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;
 
-    mCtrlSockets[i] = osmo_sock_init2(AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP,
+    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,
 				      OSMO_SOCK_F_BIND | OSMO_SOCK_F_CONNECT);
-    if (mCtrlSockets[i] < 0)
+    if (rv < 0)
       return false;
 
+    mCtrlSockets[i].conn_bfd.cb = ctrl_sock_cb;
+    mCtrlSockets[i].conn_bfd.data = reinterpret_cast<void*>(i);
+
+
     mDataSockets[i] = osmo_sock_init2(AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP,
                                       mLocalAddr.c_str(), d_srcport,
                                       mRemoteAddr.c_str(), d_dstport,
 				      OSMO_SOCK_F_BIND | OSMO_SOCK_F_CONNECT);
-    if (mCtrlSockets[i] < 0)
+    if (mDataSockets[i] < 0)
       return false;
+
+    if (i && filler == FILLER_DUMMY)
+      filler = FILLER_ZERO;
+
+    mStates[i].init(filler, mSPSTx, txFullScale, rtsc, rach_delay);
   }
 
   /* Randomize the central clock */
@@ -243,21 +276,6 @@ bool Transceiver::init(FillerType filler, size_t rtsc, unsigned rach_delay,
   mLastClockUpdateTime = startTime;
   mLatencyUpdateTime = startTime;
 
-  /* Start control threads */
-  for (size_t i = 0; i < mChans; i++) {
-    TrxChanThParams *params = (TrxChanThParams *)malloc(sizeof(struct TrxChanThParams));
-    params->trx = this;
-    params->num = i;
-    mControlServiceLoopThreads[i] = new Thread(stackSize);
-    mControlServiceLoopThreads[i]->start((void * (*)(void*))
-                                 ControlServiceLoopAdapter, (void*) params);
-
-    if (i && filler == FILLER_DUMMY)
-      filler = FILLER_ZERO;
-
-    mStates[i].init(filler, mSPSTx, txFullScale, rtsc, rach_delay);
-  }
-
   return true;
 }
 
@@ -414,24 +432,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;
+
+    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();
 
@@ -443,7 +466,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);
@@ -602,6 +639,7 @@ 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;
 
   /* Blocking FIFO read */
   radioVector *radio_burst = mReceiveFIFO[chan]->read();
@@ -651,7 +689,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;
   }
 
@@ -677,10 +717,15 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
   /* Detect normal or RACH bursts */
   rc = detectAnyBurst(*burst, mTSC, BURST_THRESH, mSPSRx, 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;
   }
 
@@ -707,6 +752,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;
@@ -719,8 +766,6 @@ void Transceiver::reset()
 }
 
 
-#define MAX_PACKET_LENGTH 100
-
 /**
  * Matches a buffer with a command.
  * @param  buf    a buffer to look command in
@@ -750,27 +795,77 @@ static bool match_cmd(char *buf,
   return true;
 }
 
-bool Transceiver::driveControl(size_t chan)
+void Transceiver::ctrl_sock_send(ctrl_msg& m, int chan)
 {
-  char buffer[MAX_PACKET_LENGTH + 1];
-  char response[MAX_PACKET_LENGTH + 1];
+  ctrl_sock_state& s = mCtrlSockets[chan];
+  struct osmo_fd *conn_bfd = &s.conn_bfd;
+
+  s.txmsgqueue.push_back(m);
+  conn_bfd->when |= OSMO_FD_WRITE;
+}
+
+int Transceiver::ctrl_sock_write(int chan)
+{
+  int rc;
+  ctrl_sock_state& s = mCtrlSockets[chan];
+
+  if (s.conn_bfd.fd < 0) {
+      return -EIO;
+  }
+
+  while (s.txmsgqueue.size()) {
+    const ctrl_msg m = s.txmsgqueue.front();
+
+    s.conn_bfd.when &= ~OSMO_FD_WRITE;
+
+    /* try to send it over the socket */
+    rc = write(s.conn_bfd.fd, m.data, strlen(m.data) + 1);
+    if (rc == 0)
+      goto close;
+    if (rc < 0) {
+      if (errno == EAGAIN) {
+        s.conn_bfd.when |= OSMO_FD_WRITE;
+        break;
+      }
+      goto close;
+    }
+
+      s.txmsgqueue.pop_front();
+  }
+  return 0;
+
+close:
+  LOGCHAN(chan, DTRXCTRL, NOTICE) << "mCtrlSockets write(" << s.conn_bfd.fd << ") failed: " << rc;
+  return -1;
+}
+
+int Transceiver::ctrl_sock_handle_rx(int chan)
+{
+  ctrl_msg cmd_received;
+  ctrl_msg cmd_to_send;
+  char *buffer = cmd_received.data;
+  char *response = cmd_to_send.data;
   char *command, *params;
   int msgLen;
+  ctrl_sock_state& s = mCtrlSockets[chan];
 
   /* Attempt to read from control socket */
-  msgLen = read(mCtrlSockets[chan], buffer, MAX_PACKET_LENGTH);
+  msgLen = read(s.conn_bfd.fd, buffer, sizeof(cmd_received.data)-1);
+  if (msgLen < 0 && errno == EAGAIN)
+      return 0; /* Try again later */
   if (msgLen <= 0) {
-    LOGCHAN(chan, DTRXCTRL, NOTICE) << "mCtrlSockets read(" << mCtrlSockets[chan] << ") failed: " << msgLen;
-    return false;
+    LOGCHAN(chan, DTRXCTRL, NOTICE) << "mCtrlSockets read(" << s.conn_bfd.fd << ") failed: " << msgLen;
+    return -EIO;
   }
 
+
   /* Zero-terminate received string */
   buffer[msgLen] = '\0';
 
   /* Verify a command signature */
   if (strncmp(buffer, "CMD ", 4)) {
     LOGCHAN(chan, DTRXCTRL, NOTICE) << "bogus message on control interface";
-    return false;
+    return -EIO;
   }
 
   /* Set command pointer */
@@ -833,7 +928,7 @@ bool Transceiver::driveControl(size_t 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;
@@ -848,6 +943,9 @@ bool Transceiver::driveControl(size_t 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;
@@ -889,7 +987,7 @@ bool Transceiver::driveControl(size_t chan)
     if ((timeslot < 0) || (timeslot > 7)) {
       LOGCHAN(chan, DTRXCTRL, NOTICE) << "bogus message on control interface";
       sprintf(response,"RSP SETSLOT 1 %d %d",timeslot,corrCode);
-      return true;
+      return 0;
     }
     mStates[chan].chanType[timeslot] = (ChannelCombination) corrCode;
     setModulus(timeslot, chan);
@@ -921,12 +1019,8 @@ bool Transceiver::driveControl(size_t chan)
   }
 
   LOGCHAN(chan, DTRXCTRL, INFO) << "response is '" << response << "'";
-  msgLen = write(mCtrlSockets[chan], response, strlen(response) + 1);
-  if (msgLen <= 0) {
-    LOGCHAN(chan, DTRXCTRL, NOTICE) << "mCtrlSockets write(" << mCtrlSockets[chan] << ") failed: " << msgLen;
-    return false;
-  }
-  return true;
+  transceiver->ctrl_sock_send(cmd_to_send, chan);
+  return 0;
 }
 
 bool Transceiver::driveTxPriorityQueue(size_t chan)
@@ -936,11 +1030,12 @@ 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));
   if (msgLen <= 0) {
-    LOGCHAN(chan, DTRXDDL, NOTICE) << "mDataSockets read(" << mCtrlSockets[chan] << ") failed: " << msgLen;
+    LOGCHAN(chan, DTRXDDL, NOTICE) << "mDataSockets read(" << mDataSockets[chan] << ") failed: " << msgLen;
     return false;
   }
 
@@ -964,6 +1059,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) {
@@ -977,7 +1073,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();
@@ -985,8 +1118,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;
@@ -1003,6 +1134,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();
   }
@@ -1043,7 +1176,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]) {
@@ -1141,6 +1274,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)) {
@@ -1156,6 +1290,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()) {
@@ -1171,6 +1306,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();
@@ -1179,28 +1315,6 @@ void *TxLowerLoopAdapter(Transceiver *transceiver)
   return NULL;
 }
 
-void *ControlServiceLoopAdapter(TrxChanThParams *params)
-{
-  char thread_name[16];
-  Transceiver *trx = params->trx;
-  size_t num = params->num;
-
-  free(params);
-
-  snprintf(thread_name, 16, "CtrlService%zu", num);
-  set_selfthread_name(thread_name);
-
-  while (1) {
-    if (!trx->driveControl(num)) {
-      LOGCHAN(num, DTRXCTRL, FATAL) << "Something went wrong in thread " << thread_name << ", requesting stop";
-      osmo_signal_dispatch(SS_MAIN, S_MAIN_STOP_REQUIRED, NULL);
-      break;
-    }
-    pthread_testcancel();
-  }
-  return NULL;
-}
-
 void *TxUpperLoopAdapter(TrxChanThParams *params)
 {
   char thread_name[16];
@@ -1211,6 +1325,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

@@ -33,11 +33,14 @@
 
 extern "C" {
 #include <osmocom/core/signal.h>
+#include <osmocom/core/select.h>
 #include "config_defs.h"
 }
 
 class Transceiver;
 
+extern Transceiver *transceiver;
+
 /** Channel descriptor for transceiver object and channel number pair */
 struct TrxChanThParams {
 	Transceiver *trx;
@@ -60,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 */
@@ -80,6 +84,13 @@ struct TransceiverState {
 
   /* Shadowed downlink attenuation */
   int mPower;
+
+  /* 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 */
@@ -142,12 +153,33 @@ public:
   } ChannelCombination;
 
 private:
+
+struct ctrl_msg {
+  char data[101];
+  ctrl_msg() {};
+};
+
+struct ctrl_sock_state {
+  osmo_fd conn_bfd;
+  std::deque<ctrl_msg> txmsgqueue;
+  ctrl_sock_state() {
+      conn_bfd.fd =  -1;
+  }
+  ~ctrl_sock_state() {
+      if(conn_bfd.fd >= 0) {
+          close(conn_bfd.fd);
+          conn_bfd.fd = -1;
+          osmo_fd_unregister(&conn_bfd);
+      }
+  }
+};
+
   int mBasePort;
   std::string mLocalAddr;
   std::string mRemoteAddr;
 
   std::vector<int> mDataSockets;  ///< socket for writing to/reading from GSM core
-  std::vector<int> mCtrlSockets;  ///< socket for writing/reading control commands 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
 
   std::vector<VectorQueue> mTxPriorityQueues;   ///< priority queue of transmit bursts received from GSM core
@@ -156,7 +188,6 @@ private:
   std::vector<Thread *> mRxServiceLoopThreads;  ///< thread to pull bursts into receive FIFO
   Thread *mRxLowerLoopThread;                   ///< thread to pull bursts into receive FIFO
   Thread *mTxLowerLoopThread;                   ///< thread to push bursts into transmit 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 mTransmitLatency;             ///< latency between basestation clock and transmit deadline clock
@@ -193,6 +224,12 @@ private:
   /** send messages over the clock socket */
   bool writeClockInterface(void);
 
+  static int ctrl_sock_cb(struct osmo_fd *bfd, unsigned int flags);
+  int ctrl_sock_write(int chan);
+  void ctrl_sock_send(ctrl_msg& m, int chan);
+  /** 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;
@@ -229,9 +266,6 @@ protected:
   /** drive transmission of GSM bursts */
   void driveTxFIFO();
 
-  /** drive handling of control messages from GSM core */
-  bool driveControl(size_t chan);
-
   /**
     drive modulation and sorting of GSM bursts from GSM core
     @return true if a burst was transferred successfully
@@ -242,7 +276,6 @@ protected:
   friend void *TxUpperLoopAdapter(TrxChanThParams *params);
   friend void *RxLowerLoopAdapter(Transceiver *transceiver);
   friend void *TxLowerLoopAdapter(Transceiver *transceiver);
-  friend void *ControlServiceLoopAdapter(TrxChanThParams *params);
 
 
   void reset();
@@ -256,8 +289,5 @@ void *RxUpperLoopAdapter(TrxChanThParams *params);
 void *RxLowerLoopAdapter(Transceiver *transceiver);
 void *TxLowerLoopAdapter(Transceiver *transceiver);
 
-/** control message handler thread loop */
-void *ControlServiceLoopAdapter(TrxChanThParams *params);
-
 /** transmit queueing thread loop */
 void *TxUpperLoopAdapter(TrxChanThParams *params);

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

Transceiver52M/device/common/radioDevice.h

@@ -125,17 +125,8 @@ 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;
-
-  /** 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 +151,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;

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,229 @@
+/*
+* 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 software is distributed under multiple licenses; see the COPYING file in
+* the main directory for licensing information for this specific distribution.
+*
+* This use of this software may be subject to additional restrictions.
+* See the LEGAL file in the main directory for details.
+
+    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.
+
+*/
+
+#ifndef _IPC_DEVICE_H_
+#define _IPC_DEVICE_H_
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+extern "C" {
+#include <osmocom/core/select.h>
+#include <osmocom/core/timer.h>
+#include <osmocom/core/utils.h>
+#include "shm.h"
+#include "ipc_shm.h"
+}
+
+#include "radioDevice.h"
+#include "smpl_buf.h"
+
+#include <sys/time.h>
+#include <math.h>
+#include <limits.h>
+#include <string>
+#include <iostream>
+
+struct ipc_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 */
+};
+#define IPC_MAX_NUM_TRX 8
+
+
+
+/** A class to handle a LimeSuite supported device */
+class IPCDevice : public RadioDevice {
+    protected:
+	struct ipc_sock_state master_sk_state;
+	/* FIXME: current limit IPC_MAX_NUM_TRX chans, make dynamic */
+	struct ipc_sock_state sk_chan_state[IPC_MAX_NUM_TRX];
+	bool trx_is_started[IPC_MAX_NUM_TRX];
+	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; ///< the actual USRP sampling rate
+
+	bool started; ///< flag indicates LMS has 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;
+
+	virtual 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();
+
+public:
+	virtual void ipc_sock_close(ipc_sock_state *state);
+	virtual int ipc_sock_read(struct osmo_fd *bfd);
+	virtual int ipc_sock_write(struct osmo_fd *bfd);
+	virtual int ipc_rx(uint8_t msg_type, struct ipc_sk_if *ipc_prim);
+	virtual int ipc_rx_greeting_cnf(const struct ipc_sk_if_greeting *greeting_cnf);
+	virtual int ipc_rx_info_cnf(const struct ipc_sk_if_info_cnf *info_cnf);
+	virtual int ipc_rx_open_cnf(const struct ipc_sk_if_open_cnf *open_cnf);
+	virtual int ipc_tx_open_req(struct ipc_sock_state *state, uint32_t num_chans, uint32_t ref);
+
+	/** 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 LMS */
+	virtual int open(const std::string &args, int ref, bool swap_channels) override;
+
+	/** Start the LMS */
+	virtual bool start() override;
+
+	/** Stop the LMS */
+	virtual bool stop() override;
+
+	/* FIXME: any != USRP1 will do for now... */
+	enum TxWindowType getWindowType() override
+	{
+		return TX_WINDOW_LMS1;
+	}
+
+	/**
+	Read samples from the LMS.
+	@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 LMS 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 LMS.
+	@param buf Contains the data to be written.
+	@param len number of samples to write.
+	@param underrun Set if LMS 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;
+
+	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;
+
+	/** 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;
+	}
+	int ipc_chan_sock_read(osmo_fd *bfd);
+	int ipc_chan_sock_write(osmo_fd *bfd);
+	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);
+};
+
+#endif // _IPC_DEVICE_H_

Transceiver52M/device/ipc/Makefile.am

@@ -0,0 +1,29 @@
+include $(top_srcdir)/Makefile.common
+
+AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/../common
+AM_CFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
+AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
+AM_LDFLAGS = -lpthread -lrt
+
+noinst_HEADERS = IPCDevice.h shm.h ../uhd/UHDDevice.h uhdwrap.h
+
+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
+
+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 ../uhd/UHDDevice.cpp
+ipc_driver_test_LDADD = \
+        shm.lo \
+	$(LIBOSMOCORE_LIBS) \
+	$(LIBOSMOCTRL_LIBS) \
+	$(LIBOSMOVTY_LIBS)
+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)
+ipc_driver_test_LDADD += $(top_builddir)/Transceiver52M/device/common/libdevice_common.la $(top_builddir)/CommonLibs/libcommon.la
+

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

@@ -0,0 +1,501 @@
+/*
+* 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.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#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"
+
+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;
+
+/* Debug Areas of the code */
+//enum { DMAIN,
+//};
+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),
+};
+#ifdef __cplusplus
+}
+#endif
+
+#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_%d", IPC_SOCK_PATH_PREFIX, 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;
+
+	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 (unsigned int 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 int ul_running = 0;
+volatile int dl_running = 0;
+
+void *uplink_thread(void *x_void_ptr)
+{
+	uint32_t chann = decoded_region->num_chans;
+	ul_running = 1;
+	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 = 1;
+	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;
+	}
+
+	bfd->when = BSC_FD_READ;
+	bfd->cb = sock_callback_fn;
+	bfd->data = state;
+	bfd->priv_nr = 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;
+	}
+
+	//osmo_signal_register_handler(SS_GLOBAL, IPC_if_signal_cb, NULL);
+
+	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"
+		" -n  --sock-num NR	Master socket suffix number NR\n"
+	      );
+}
+
+static int msocknum = 0;
+
+static void handle_options(int argc, char **argv)
+{
+	while (1) {
+		int option_index = 0, c;
+		const struct option long_options[] = {
+			{ "help", 0, 0, 'h' },
+			{ "sock-num", 1, 0, 'n' },
+			{0,0,0,0}
+		};
+
+		c = getopt_long(argc, argv, "hn:",
+				long_options, &option_index);
+		if (c == -1)
+			break;
+
+		switch (c) {
+		case 'h':
+			print_help();
+			exit(0);
+			break;
+		case 'n':
+			msocknum = atoi(optarg);
+			break;
+		default:
+			exit(2);
+			break;
+		}
+	}
+
+	if (argc > optind) {
+		fprintf(stderr, "Unsupported positional arguments on command line\n");
+		exit(2);
+	}
+}
+
+#if defined(IPCMAGIC) && defined(__cplusplus)
+extern "C" int osmo_ctx_init(const char *id);
+
+extern "C" int magicmain(int argc, char **argv)
+{
+	osmo_ctx_init("main");
+	osmo_select_init();
+
+#else
+int main(int argc, char **argv)
+{
+#endif
+	char ipc_msock_path[sizeof(IPC_SOCK_PATH_PREFIX)+3];
+	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);
+	snprintf(ipc_msock_path,sizeof(ipc_msock_path), "%s%d", IPC_SOCK_PATH_PREFIX, 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)
+		for (unsigned int i = 0; i < decoded_region->num_chans; i++)
+			uhdwrap_stop(global_dev, i);
+
+	//ipc_sock_close()
+	return 0;
+}

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

@@ -0,0 +1,44 @@
+/*
+* 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 to lcr */
+	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,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"
+#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);
+		fprintf(stderr, "%s:%d: IPC_IF_MSG_START_REQ chan priv no %d\n", __FILE__, __LINE__, chan_nr);
+		break;
+	case IPC_IF_MSG_STOP_REQ:
+		rc = ipc_rx_chan_stop_req(&ipc_prim->u.stop_req, chan_nr);
+		fprintf(stderr, "%s:%d: IPC_IF_MSG_STOP_REQ chan priv no %d\n", __FILE__, __LINE__, chan_nr);
+		break;
+	case IPC_IF_MSG_SETGAIN_REQ:
+		rc = ipc_rx_chan_setgain_req(&ipc_prim->u.set_gain_req, chan_nr);
+		fprintf(stderr, "%s:%d: IPC_IF_MSG_SETGAIN_REQ chan priv no %d\n", __FILE__, __LINE__, chan_nr);
+		break;
+	case IPC_IF_MSG_SETFREQ_REQ:
+		rc = ipc_rx_chan_setfreq_req(&ipc_prim->u.set_freq_req, chan_nr);
+		fprintf(stderr, "%s:%d: IPC_IF_MSG_SETFREQ_REQ chan priv no %d\n", __FILE__, __LINE__, chan_nr);
+		break;
+	case IPC_IF_MSG_SETTXATTN_REQ:
+		rc = ipc_rx_chan_settxatten_req(&ipc_prim->u.txatten_req, chan_nr);
+		fprintf(stderr, "%s:%d: IPC_IF_MSG_SETTXATTN_REQ chan priv no %d\n", __FILE__, __LINE__, chan_nr);
+		break;
+	default:
+		fprintf(stderr, "Received unknown IPC msg type %d\n", msg_type);
+		rc = -EINVAL;
+	}
+	fflush(stderr);
+
+	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(DMAIN, 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(DMAIN, 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(DMAIN, LOGL_NOTICE,
+		     "IPC socket not connected, "
+		     "dropping message\n");
+		msgb_free(msg);
+		return -EIO;
+	}
+	msgb_enqueue(&state->upqueue, msg);
+	conn_bfd->when |= BSC_FD_WRITE;
+
+	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;
+
+		bfd->when &= ~BSC_FD_WRITE;
+
+		/* bug hunter 8-): maybe someone forgot msgb_put(...) ? */
+		if (!msgb_length(msg)) {
+			LOGP(DMAIN, 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) {
+				bfd->when |= BSC_FD_WRITE;
+				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_chan_sock_cb(struct osmo_fd *bfd, unsigned int flags)
+{
+	int rc = 0;
+
+	if (flags & BSC_FD_READ)
+		rc = ipc_chan_sock_read(bfd);
+	if (rc < 0)
+		return rc;
+
+	if (flags & BSC_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(DMAIN, LOGL_ERROR, "Failed to accept a new connection\n");
+		return -1;
+	}
+
+	if (conn_bfd->fd >= 0) {
+		LOGP(DMAIN, LOGL_NOTICE,
+		     "osmo-trx connects but we already have "
+		     "another active connection ?!?\n");
+		/* We already have one IPC connected, this is all we support */
+		state->listen_bfd.when &= ~BSC_FD_READ;
+		close(rc);
+		return 0;
+	}
+
+	conn_bfd->fd = rc;
+	conn_bfd->when = BSC_FD_READ;
+	conn_bfd->cb = ipc_chan_sock_cb;
+	conn_bfd->data = state;
+
+	/* copy chan nr, required for proper bfd<->chan # mapping */
+	conn_bfd->priv_nr = bfd->priv_nr;
+
+	if (osmo_fd_register(conn_bfd) != 0) {
+		LOGP(DMAIN, LOGL_ERROR,
+		     "Failed to register new connection "
+		     "fd\n");
+		close(conn_bfd->fd);
+		conn_bfd->fd = -1;
+		return -1;
+	}
+
+	LOGP(DMAIN, LOGL_NOTICE, "Unix socket connected to external osmo-trx\n");
+
+	/* send current info */
+	//IPC_tx_info_ind();
+
+	return 0;
+}

Transceiver52M/device/ipc/ipc_chan.h

@@ -0,0 +1,23 @@
+/*
+* 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,204 @@
+/*
+* 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>
+
+#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) {
+		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
+		exit(EXIT_FAILURE);
+	}
+
+	rv = pthread_mutexattr_setrobust(&att, PTHREAD_MUTEX_ROBUST);
+	if (rv != 0) {
+		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
+		exit(EXIT_FAILURE);
+	}
+
+	rv = pthread_mutexattr_setpshared(&att, PTHREAD_PROCESS_SHARED);
+	if (rv != 0) {
+		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
+		exit(EXIT_FAILURE);
+	}
+
+	rv = pthread_mutex_init((pthread_mutex_t *)&r->this_stream->lock, &att);
+	if (rv != 0) {
+		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
+		exit(EXIT_FAILURE);
+	}
+
+	pthread_mutexattr_destroy(&att);
+
+	rv = pthread_condattr_setpshared(&t1, PTHREAD_PROCESS_SHARED);
+	if (rv != 0) {
+		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
+		exit(EXIT_FAILURE);
+	}
+
+	rv = pthread_condattr_setpshared(&t2, PTHREAD_PROCESS_SHARED);
+	if (rv != 0) {
+		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
+		exit(EXIT_FAILURE);
+	}
+
+	rv = pthread_cond_init((pthread_cond_t *)&r->this_stream->cf, &t1);
+	if (rv != 0) {
+		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
+		exit(EXIT_FAILURE);
+	}
+
+	rv = pthread_cond_init((pthread_cond_t *)&r->this_stream->ce, &t2);
+	if (rv != 0) {
+		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
+		exit(EXIT_FAILURE);
+	}
+
+	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) {
+		if (r->buf_ptrs)
+			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,43 @@
+/*
+* 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; // plus num_buffers at end
+	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,271 @@
+/*
+* 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(DMAIN, LOGL_ERROR, "Received unknown IPC msg type %d\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;
+	//struct ipc_sk_if *ipc_prim = (struct ipc_sk_if *) msg->data;
+
+	if (!state) {
+		LOGP(DMAIN, 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(DMAIN, LOGL_NOTICE,
+		     "IPC socket not connected, "
+		     "dropping message\n");
+		msgb_free(msg);
+		return -EIO;
+	}
+	msgb_enqueue(&state->upqueue, msg);
+	conn_bfd->when |= BSC_FD_WRITE;
+
+	return 0;
+}
+
+void ipc_sock_close(struct ipc_sock_state *state)
+{
+	struct osmo_fd *bfd = &state->conn_bfd;
+
+	LOGP(DMAIN, 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 */
+	state->listen_bfd.when |= BSC_FD_READ;
+
+	/* 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(DMAIN, 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;
+
+		bfd->when &= ~BSC_FD_WRITE;
+
+		/* bug hunter 8-): maybe someone forgot msgb_put(...) ? */
+		if (!msgb_length(msg)) {
+			LOGP(DMAIN, 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) {
+				bfd->when |= BSC_FD_WRITE;
+				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 & BSC_FD_READ)
+		rc = ipc_sock_read(bfd);
+	if (rc < 0)
+		return rc;
+
+	if (flags & BSC_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(DMAIN, LOGL_ERROR, "Failed to accept a new connection\n");
+		return -1;
+	}
+
+	if (conn_bfd->fd >= 0) {
+		LOGP(DMAIN, LOGL_NOTICE,
+		     "ip clent connects but we already have "
+		     "another active connection ?!?\n");
+		/* We already have one IPC connected, this is all we support */
+		state->listen_bfd.when &= ~BSC_FD_READ;
+		close(rc);
+		return 0;
+	}
+
+	conn_bfd->fd = rc;
+	conn_bfd->when = BSC_FD_READ;
+	conn_bfd->cb = ipc_sock_cb;
+	conn_bfd->data = state;
+
+	if (osmo_fd_register(conn_bfd) != 0) {
+		LOGP(DMAIN, LOGL_ERROR,
+		     "Failed to register new connection "
+		     "fd\n");
+		close(conn_bfd->fd);
+		conn_bfd->fd = -1;
+		return -1;
+	}
+
+	LOGP(DMAIN, LOGL_NOTICE, "Unix socket connected to external osmo-trx\n");
+
+	/* send current info */
+	//IPC_tx_info_ind();
+
+	return 0;
+}

Transceiver52M/device/ipc/ipc_sock.h

@@ -0,0 +1,24 @@
+/*
+* 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,163 @@
+/*
+* 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 <string.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <osmocom/core/talloc.h>
+
+#include "shm.h"
+
+//#define ENCDECDEBUG
+
+/* 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++) {
+#ifdef ENCDECDEBUG
+		fprintf(stderr, "decode: smpl_buf %d at offset %u\n", i, stream_raw->buffer_offset[i]);
+#endif
+		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;
+#ifdef ENCDECDEBUG
+	fprintf(stderr, "decode: streams at offset %u and %u\n", chan_raw->dl_buf_offset, chan_raw->ul_buf_offset);
+#endif
+	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++) {
+#ifdef ENCDECDEBUG
+		fprintf(stderr, "decode: channel %d at offset %u\n", i, root_raw->chan_offset[i]);
+#endif
+		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);
+#ifdef ENCDECDEBUG
+	fprintf(stderr, "encode: smpl_buf at offset %lu\n", (start - (uint8_t *)root_raw));
+#endif
+	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);
+#ifdef ENCDECDEBUG
+	fprintf(stderr, "encode: stream at offset %lu\n", (start - (ptrdiff_t)root_raw));
+#endif
+	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);
+#ifdef ENCDECDEBUG
+	fprintf(stderr, "encode: channel at offset %lu\n", (start - (uint8_t *)root_raw));
+#endif
+	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);
+#ifdef ENCDECDEBUG
+		fprintf(stderr, "encode: channel %d chan_offset[i]=%u\n", i, ofs);
+#endif
+		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;
+	pthread_cond_t cf;
+	pthread_cond_t ce;
+	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_PATH_PREFIX "/tmp/ipc_sock"
+#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,254 @@
+/*
+* 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 "trx_vty.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;
+	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,81 @@
+/*
+* 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

@@ -65,8 +65,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 +78,48 @@ 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;
+/* 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.
+ */
+struct dev_band_desc {
+	double nom_lms_tx_gain;  /* dB */
+	double nom_out_tx_power; /* dBm */
+};
+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 } },
+	{ std::make_tuple(LMS_DEV_SDR_USB, GSM_BAND_900),	{ 73.0, 10.8 } },
+	{ std::make_tuple(LMS_DEV_SDR_USB, GSM_BAND_1800),	{ 65.0, -3.5 } }, /* 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 } }, /* FIXME: OS#4583: 1900MHz is failing in all TxGain values */
+	{ std::make_tuple(LMS_DEV_SDR_MINI, GSM_BAND_850),	{ 66.0, 3.1 } }, /* FIXME: OS#4583: Ensure BAND2 is used at startup */
+	{ std::make_tuple(LMS_DEV_SDR_MINI, GSM_BAND_900),	{ 66.0, 2.8 } }, /* FIXME: OS#4583: Ensure BAND2 is used at startup */
+	{ std::make_tuple(LMS_DEV_SDR_MINI, GSM_BAND_1800),	{ 66.0, -11.6 } }, /* OS#4583: Any of BAND1 or BAND2 is fine */
+	{ std::make_tuple(LMS_DEV_SDR_MINI, GSM_BAND_1900),	{ 66.0, -9.2 } }, /* FIXME: OS#4583: Ensure BAND1 is used at startup */
+	{ std::make_tuple(LMS_DEV_NET_MICRO, GSM_BAND_850),	{ 71.0, 6.8 } },
+	{ std::make_tuple(LMS_DEV_NET_MICRO, GSM_BAND_900),	{ 71.0, 6.8 } },
+	{ std::make_tuple(LMS_DEV_NET_MICRO, GSM_BAND_1800),	{ 65.0, -10.5 } }, /* 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 } }, /* 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();
@@ -110,7 +144,7 @@ LMSDevice::LMSDevice(size_t tx_sps, size_t rx_sps, InterfaceType iface, size_t c
 		     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)
+	m_lms_dev(NULL), started(false), band((enum gsm_band)0), m_dev_type(LMS_DEV_UNKNOWN)
 {
 	LOGC(DDEV, INFO) << "creating LMS device...";
 
@@ -197,6 +231,27 @@ int info_list_find(lms_info_str_t* info_list, unsigned int count, const std::str
 	return -1;
 }
 
+void LMSDevice::get_dev_band_desc(dev_band_desc& desc)
+{
+	dev_band_map_it it;
+	enum gsm_band req_band = band;
+
+	if (req_band == 0) {
+		LOGC(DDEV, ERROR) << "Nominal Tx Power requested before Tx Frequency was set! Providing band 900 by default... ";
+		req_band = GSM_BAND_900;
+	}
+	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())
+	desc = it->second;
+}
+
 int LMSDevice::open(const std::string &args, int ref, bool swap_channels)
 {
 	lms_info_str_t* info_list;
@@ -322,17 +377,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);
 
@@ -477,17 +535,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 +545,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 +561,48 @@ double LMSDevice::setRxGain(double dB, size_t chan)
 	return rx_gains[chan];
 }
 
+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,13 +969,39 @@ 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 (band != 0 && req_band != band) {
+		LOGCHAN(chan, DDEV, ALERT) << "Requesting Tx Frequency " << wFreq
+					   << " Hz different from previous band " << gsm_band_name(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;
 	}
 
+	band = req_band;
 	return true;
 }
 

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,8 @@ enum lms_dev_type {
 	LMS_DEV_UNKNOWN,
 };
 
+struct dev_band_desc;
+
 /** A class to handle a LimeSuite supported device */
 class LMSDevice:public RadioDevice {
 
@@ -66,6 +72,7 @@ private:
 	TIMESTAMP ts_initial, ts_offset;
 
 	std::vector<double> tx_gains, rx_gains;
+	enum gsm_band band;
 
 	enum lms_dev_type m_dev_type;
 
@@ -77,6 +84,7 @@ 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);
 
 public:
 
@@ -165,19 +173,11 @@ 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);
 
-	/** 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/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>
@@ -121,13 +127,32 @@ static const std::map<dev_key, dev_desc> dev_param_map {
 	{ std::make_tuple(UMTRX, 4, 4), { 2, 0.0,  GSMRATE, 5.1503e-5,  "UmTRX 4 SPS"        } },
 	{ std::make_tuple(LIMESDR, 4, 4), { 1, GSMRATE*32, GSMRATE, 8.9e-5, "LimeSDR 4 SPS"  } },
 	{ std::make_tuple(B2XX_MCBTS, 4, 4), { 1, 51.2e6, MCBTS_SPACING*4, B2XX_TIMING_MCBTS, "B200/B210 4 SPS Multi-ARFCN" } },
-	{ std::make_tuple(OCR01, 4, 1), { 2, 26e6, GSMRATE, B2XX_TIMING_4SPS, "OCR01 4/1 Tx/Rx SPS"} },
-	{ std::make_tuple(OCR01, 4, 4), { 2, 26e6, GSMRATE, B2XX_TIMING_4_4SPS, "OCR01 4/4 Tx/Rx SPS"} },
+};
+
+typedef std::tuple<uhd_dev_type, enum gsm_band> dev_band_key;
+/* 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. */
+struct dev_band_desc {
+	double nom_uhd_tx_gain;  /* dB */
+	double nom_out_tx_power; /* dBm */
+};
+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 } },
+	{ std::make_tuple(B200, GSM_BAND_900),	{ 89.75, 13.3 } },
+	{ std::make_tuple(B200, GSM_BAND_1800),	{ 89.75, 7.5 } },
+	{ std::make_tuple(B200, GSM_BAND_1900),	{ 89.75, 7.7 } },
+	{ std::make_tuple(B210, GSM_BAND_850),	{ 89.75, 13.3 } },
+	{ std::make_tuple(B210, GSM_BAND_900),	{ 89.75, 13.3 } },
+	{ std::make_tuple(B210, GSM_BAND_1800),	{ 89.75, 7.5 } },
+	{ std::make_tuple(B210, GSM_BAND_1900),	{ 89.75, 7.7 } },
 };
 
 void *async_event_loop(uhd_device *dev)
 {
 	set_selfthread_name("UHDAsyncEvent");
+	OSMO_ASSERT(osmo_cpu_sched_vty_apply_localthread() == 0);
 
 	while (1) {
 		dev->recv_async_msg();
@@ -190,14 +215,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),
+	  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)
 {
@@ -211,8 +247,30 @@ uhd_device::~uhd_device()
 		delete rx_buffers[i];
 }
 
+void uhd_device::get_dev_band_desc(dev_band_desc& desc)
+{
+	dev_band_map_it it;
+	enum gsm_band req_band = band;
+
+	if (req_band == 0) {
+		LOGC(DDEV, ERROR) << "Nominal Tx Power requested before Tx Frequency was set! Providing band 900 by default... ";
+		req_band = GSM_BAND_900;
+	}
+	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 Tx Power measurements 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())
+	desc = it->second;
+}
+
 void uhd_device::init_gains()
 {
+	double tx_gain_min, tx_gain_max;
 	uhd::gain_range_t range;
 
 	if (dev_type == UMTRX) {
@@ -277,37 +335,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()) {
@@ -333,14 +360,61 @@ double uhd_device::getRxGain(size_t chan)
 	return rx_gains[chan];
 }
 
-double uhd_device::getTxGain(size_t chan)
-{
+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;
 }
 
 /*
@@ -370,7 +444,6 @@ bool uhd_device::parse_dev_type()
 		{ "USRP2",    { USRP2,   TX_WINDOW_FIXED } },
 		{ "UmTRX",    { UMTRX,   TX_WINDOW_FIXED } },
 		{ "LimeSDR",  { LIMESDR, TX_WINDOW_FIXED } },
-		{ "OCR01",    { OCR01,   TX_WINDOW_USRP1 } },
 	};
 
 	// Compare UHD motherboard and device strings */
@@ -412,7 +485,7 @@ static bool uhd_e3xx_version_chk()
 void uhd_device::set_channels(bool swap)
 {
 	if (iface == MULTI_ARFCN) {
-		if (dev_type != B200 && dev_type != B210 && dev_type != OCR01)
+		if (dev_type != B200 && dev_type != B210)
 			throw std::invalid_argument("Device does not support MCBTS");
 		dev_type = B2XX_MCBTS;
 	}
@@ -424,7 +497,6 @@ void uhd_device::set_channels(bool swap)
 	switch (dev_type) {
 	case B210:
 	case E3XX:
-	case OCR01:
 		if (chans == 1)
 			subdev_string = swap ? "A:B" : "A:A";
 		else if (chans == 2)
@@ -586,7 +658,6 @@ int uhd_device::open(const std::string &args, int ref, bool swap_channels)
 	case E1XX:
 	case E3XX:
 	case LIMESDR:
-	case OCR01:
 	default:
 		break;
 	}
@@ -679,6 +750,10 @@ 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();
+
 	started = false;
 	return true;
 }
@@ -957,13 +1032,37 @@ 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 (band != 0 && req_band != band) {
+		LOGCHAN(chan, DDEV, ALERT) << "Requesting Tx Frequency " << wFreq
+					   << " Hz different from previous band " << gsm_band_name(band);
+		return false;
+	}
+
+	if (!set_freq(wFreq, chan, true))
+		return false;
+
+	band = req_band;
+	return true;
 }
 
 bool uhd_device::setRxFreq(double wFreq, size_t chan)
@@ -1005,7 +1104,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: ";
@@ -1041,7 +1147,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: ";
@@ -1207,6 +1320,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,
@@ -1214,3 +1328,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,
@@ -50,9 +54,10 @@ enum uhd_dev_type {
 	X3XX,
 	UMTRX,
 	LIMESDR,
-	OCR01,
 };
 
+struct dev_band_desc;
+
 /*
     uhd_device - UHD implementation of the Device interface. Timestamped samples
                 are sent to and received from the device. An intermediate buffer
@@ -96,10 +101,10 @@ public:
 	double maxRxGain(void) { return rx_gain_max; }
 	double minRxGain(void) { return rx_gain_min; }
 
-	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);
@@ -128,7 +133,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;
@@ -137,11 +142,11 @@ 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;
+	enum gsm_band band;
 	size_t tx_spp, rx_spp;
 
 	bool started;
@@ -170,6 +175,7 @@ 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);
 
 	Thread *async_event_thrd;
 	Mutex tune_lock;

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,10 @@ 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 setPowerAttenuation(int atten, size_t chan);
+  double getPowerAttenuation(size_t chan=0);
 
-  /** get transmit gain */
-  double getTxGain(size_t chan = 0) { return txGain; }
-
-  /** 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/osmo-trx.cpp

@@ -55,6 +55,7 @@ extern "C" {
 #include <osmocom/ctrl/control_if.h>
 #include <osmocom/vty/stats.h>
 #include <osmocom/vty/command.h>
+#include <osmocom/vty/cpu_sched_vty.h>
 
 #include "convolve.h"
 #include "convert.h"
@@ -79,7 +80,6 @@ static struct ctrl_handle *g_ctrlh;
 
 static RadioDevice *usrp;
 static RadioInterface *radio;
-static Transceiver *transceiver;
 
 /* Create radio interface
  *     The interface consists of sample rate changes, frequency shifts,
@@ -237,7 +237,7 @@ static void setup_signal_handlers()
 		exit(EXIT_FAILURE);
 	}
 
-	osmo_fd_setup(&signal_ofd, sfd, BSC_FD_READ, signalfd_callback, NULL, 0);
+	osmo_fd_setup(&signal_ofd, sfd, OSMO_FD_READ, signalfd_callback, NULL, 0);
 	if (osmo_fd_register(&signal_ofd) < 0) {
 		fprintf(stderr, "osmo_fd_register() failed.\n");
 		exit(EXIT_FAILURE);
@@ -436,7 +436,9 @@ static int set_sched_rr(unsigned int prio)
 	int rc;
 	memset(&param, 0, sizeof(param));
 	param.sched_priority = prio;
-	LOG(INFO) << "Setting SCHED_RR priority " << param.sched_priority;
+	LOG(INFO) << "Setting SCHED_RR priority " << param.sched_priority
+		  << ". This setting is DEPRECATED, please use 'policy rr " << param.sched_priority
+		  << "' under the 'sched' VTY node instead.";
 	rc = sched_setscheduler(getpid(), SCHED_RR, &param);
 	if (rc != 0) {
 		LOG(ERROR) << "Config: Setting SCHED_RR failed";
@@ -590,6 +592,7 @@ int main(int argc, char *argv[])
 	vty_init(&g_vty_info);
 	logging_vty_add_cmds();
 	ctrl_vty_init(tall_trx_ctx);
+	osmo_cpu_sched_vty_init(tall_trx_ctx);
 	trx_vty_init(g_trx_ctx);
 
 	osmo_talloc_vty_add_cmds();

Transceiver52M/proto_trxd.c

@@ -62,7 +62,7 @@ static void trxd_fill_burst_normalized255(uint8_t* soft_bits, const struct trx_u
 {
 	unsigned i;
 	for (i = 0; i < bi->nbits; i++)
-		soft_bits[i] = (char) round(bi->rx_burst[i] * 255.0);
+		soft_bits[i] = (uint8_t) round(bi->rx_burst[i] * 255.0);
 }
 
 bool trxd_send_burst_ind_v0(size_t chan, int fd, const struct trx_ul_burst_ind *bi) {

Transceiver52M/radioInterface.cpp

@@ -27,6 +27,9 @@
 #include <Threads.h>
 
 extern "C" {
+#include <osmocom/core/utils.h>
+#include <osmocom/vty/cpu_sched_vty.h>
+
 #include "convert.h"
 }
 
@@ -103,7 +106,7 @@ double RadioInterface::fullScaleOutputValue(void) {
 
 int RadioInterface::setPowerAttenuation(int atten, size_t chan)
 {
-  double rfGain, digAtten;
+  double rfAtten, digAtten;
 
   if (chan >= mChans) {
     LOG(ALERT) << "Invalid channel requested";
@@ -113,8 +116,8 @@ int RadioInterface::setPowerAttenuation(int atten, size_t chan)
   if (atten < 0.0)
     atten = 0.0;
 
-  rfGain = setTxGain(mDevice->maxTxGain() - (double) atten, chan);
-  digAtten = (double) atten - mDevice->maxTxGain() + rfGain;
+  rfAtten = mDevice->setPowerAttenuation((double) atten, chan);
+  digAtten = (double) atten - rfAtten;
 
   if (digAtten < 1.0)
     powerScaling[chan] = 1.0;
@@ -124,6 +127,16 @@ int RadioInterface::setPowerAttenuation(int atten, size_t chan)
   return atten;
 }
 
+int RadioInterface::getNominalTxPower(size_t chan)
+{
+  if (chan >= mChans) {
+    LOG(ALERT) << "Invalid channel requested";
+    return -1;
+  }
+
+    return mDevice->getNominalTxPower(chan);
+}
+
 int RadioInterface::radioifyVector(signalVector &wVector,
                                    size_t chan, bool zero)
 {
@@ -161,6 +174,7 @@ bool RadioInterface::tuneRx(double freq, size_t chan)
 void *AlignRadioServiceLoopAdapter(RadioInterface *radioInterface)
 {
   set_selfthread_name("AlignRadio");
+  OSMO_ASSERT(osmo_cpu_sched_vty_apply_localthread() == 0);
   while (1) {
     sleep(60);
     radioInterface->alignRadio();
@@ -308,11 +322,6 @@ double RadioInterface::setRxGain(double dB, size_t chan)
   return mDevice->setRxGain(dB, chan);
 }
 
-double RadioInterface::setTxGain(double dB, size_t chan)
-{
-  return mDevice->setTxGain(dB, chan);
-}
-
 /* Receive a timestamped chunk from the device */
 int RadioInterface::pullBuffer()
 {

Transceiver52M/radioInterface.h

@@ -116,7 +116,9 @@ public:
   /** drive reception of GSM bursts. -1: Error. 0: Radio off. 1: Received something. */
   int driveReceiveRadio();
 
-  int setPowerAttenuation(int atten, size_t chan = 0);
+  /** set transmit power attenuation */
+  virtual int setPowerAttenuation(int atten, size_t chan = 0);
+  int getNominalTxPower(size_t chan = 0);
 
   /** returns the full-scale transmit amplitude **/
   double fullScaleInputValue();
@@ -134,9 +136,6 @@ protected:
   /** drive synchronization of Tx/Rx of USRP */
   void alignRadio();
 
-  /** set transmit gain */
-  virtual double setTxGain(double dB, size_t chan = 0);
-
   friend void *AlignRadioServiceLoopAdapter(RadioInterface*);
 };
 
@@ -166,7 +165,7 @@ private:
   bool pushBuffer();
   int pullBuffer();
   bool verify_arfcn_consistency(double freq, size_t chan, bool tx);
-  virtual double setTxGain(double dB, size_t chan);
+  virtual int setPowerAttenuation(int atten, size_t chan = 0);
 
   signalVector *outerSendBuffer;
   signalVector *outerRecvBuffer;

Transceiver52M/radioInterfaceMulti.cpp

@@ -437,11 +437,8 @@ double RadioInterfaceMulti::setRxGain(double db, size_t chan)
     return mDevice->getRxGain();
 }
 
-double RadioInterfaceMulti::setTxGain(double dB, size_t chan)
+int RadioInterfaceMulti::setPowerAttenuation(int atten, size_t chan)
 {
-	if (chan == 0)
-		return mDevice->setTxGain(dB);
-	else
-		return mDevice->getTxGain();
+		return RadioInterface::setPowerAttenuation(atten, 0);
 
 }

Transceiver52M/radioVector.cpp

@@ -120,38 +120,26 @@ GSM::Time VectorQueue::nextTime() const
 
 radioVector* VectorQueue::getStaleBurst(const GSM::Time& targTime)
 {
-	mLock.lock();
-	if ((mQ.size()==0)) {
-		mLock.unlock();
+	if ((mQ.size()==0))
 		return NULL;
-	}
 
 	if (mQ.top()->getTime() < targTime) {
 		radioVector* retVal = mQ.top();
 		mQ.pop();
-		mLock.unlock();
 		return retVal;
 	}
-	mLock.unlock();
-
 	return NULL;
 }
 
 radioVector* VectorQueue::getCurrentBurst(const GSM::Time& targTime)
 {
-	mLock.lock();
-	if ((mQ.size()==0)) {
-		mLock.unlock();
+	if ((mQ.size()==0))
 		return NULL;
-	}
 
 	if (mQ.top()->getTime() == targTime) {
 		radioVector* retVal = mQ.top();
 		mQ.pop();
-		mLock.unlock();
 		return retVal;
 	}
-	mLock.unlock();
-
 	return NULL;
 }

Transceiver52M/radioVector.h

@@ -65,6 +65,7 @@ public:
 	GSM::Time nextTime() const;
 	radioVector* getStaleBurst(const GSM::Time& targTime);
 	radioVector* getCurrentBurst(const GSM::Time& targTime);
+	Mutex *getMutex() const { return &mLock; };
 };
 
 #endif /* RADIOVECTOR_H */

configure.ac

@@ -51,6 +51,11 @@ AC_PROG_INSTALL
 AC_PATH_PROG([RM_PROG], [rm])
 AC_LANG([C++])
 
+dnl patching ${archive_cmds} to affect generation of file "libtool" to fix linking with clang
+AS_CASE(["$LD"],[*clang*],
+  [AS_CASE(["${host_os}"],
+     [*linux*],[archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'])])
+
 dnl check for pkg-config (explained in detail in libosmocore/configure.ac)
 AC_PATH_PROG(PKG_CONFIG_INSTALLED, pkg-config, no)
 if test "x$PKG_CONFIG_INSTALLED" = "xno"; then
@@ -87,6 +92,7 @@ CPPFLAGS=$save_CPPFLAGS
 PKG_CHECK_MODULES(LIBOSMOCORE, libosmocore >= 1.3.0)
 PKG_CHECK_MODULES(LIBOSMOVTY, libosmovty >= 1.3.0)
 PKG_CHECK_MODULES(LIBOSMOCTRL, libosmoctrl >= 1.3.0)
+PKG_CHECK_MODULES(LIBOSMOCODING, libosmocoding >= 1.3.0)
 
 AC_ARG_ENABLE(sanitize,
 	[AS_HELP_STRING(
@@ -134,6 +140,11 @@ AC_ARG_WITH(lms, [
         [enable LimeSuite based transceiver])
 ])
 
+AC_ARG_WITH(ipc, [
+    AS_HELP_STRING([--with-ipc],
+        [enable IPC])
+])
+
 AC_ARG_WITH(singledb, [
     AS_HELP_STRING([--with-singledb],
         [enable single daughterboard use on USRP1])
@@ -235,6 +246,7 @@ AS_IF([test "x$osmo_cv_cc_has___sync_fetch_and_and" = "xyes" && test "x$osmo_cv_
 AM_CONDITIONAL(DEVICE_UHD, [test "x$with_uhd" != "xno"])
 AM_CONDITIONAL(DEVICE_USRP1, [test "x$with_usrp1" = "xyes"])
 AM_CONDITIONAL(DEVICE_LMS, [test "x$with_lms" = "xyes"])
+AM_CONDITIONAL(DEVICE_IPC, [test "x$with_ipc" = "xyes"])
 AM_CONDITIONAL(ARCH_ARM, [test "x$with_neon" = "xyes" || test "x$with_neon_vfpv4" = "xyes"])
 AM_CONDITIONAL(ARCH_ARM_A15, [test "x$with_neon_vfpv4" = "xyes"])
 
@@ -319,9 +331,11 @@ AC_CONFIG_FILES([\
     Transceiver52M/device/uhd/Makefile \
     Transceiver52M/device/usrp1/Makefile \
     Transceiver52M/device/lms/Makefile \
+    Transceiver52M/device/ipc/Makefile \
     tests/Makefile \
     tests/CommonLibs/Makefile \
     tests/Transceiver52M/Makefile \
+    utils/Makefile \
     doc/Makefile \
     doc/examples/Makefile \
     contrib/Makefile \
@@ -329,4 +343,5 @@ AC_CONFIG_FILES([\
 ])
 
 AC_OUTPUT(
-	doc/manuals/Makefile)
+	doc/manuals/Makefile
+	contrib/osmo-trx.spec)

contrib/osmo-trx.spec.in

@@ -0,0 +1,242 @@
+#
+# spec file for package osmo-trx
+#
+# Copyright (c) 2017, Martin Hauke <mardnh@gmx.de>
+#
+# All modifications and additions to the file contributed by third parties
+# remain the property of their copyright owners, unless otherwise agreed
+# upon. The license for this file, and modifications and additions to the
+# file, is the same license as for the pristine package itself (unless the
+# license for the pristine package is not an Open Source License, in which
+# case the license is the MIT License). An "Open Source License" is a
+# license that conforms to the Open Source Definition (Version 1.9)
+# published by the Open Source Initiative.
+
+Name:           osmo-trx
+Version:        @VERSION@
+Release:        0
+Summary:        SDR transceiver that implements Layer 1 of a GSM BTS
+License:        AGPL-3.0-or-later
+Group:          Productivity/Telephony/Servers
+URL:            https://osmocom.org/projects/osmotrx
+Source:         %{name}-%{version}.tar.xz
+BuildRequires:  autoconf
+BuildRequires:  automake
+BuildRequires:  fdupes
+BuildRequires:  gcc-c++
+BuildRequires:  libtool
+BuildRequires:  pkgconfig >= 0.20
+%if 0%{?suse_version}
+BuildRequires:  systemd-rpm-macros
+%endif
+%if ! 0%{?centos_ver}
+BuildRequires:  pkgconfig(LimeSuite)
+BuildRequires:  pkgconfig(usrp) >= 3.3
+%endif
+BuildRequires:  pkgconfig(fftw3f)
+BuildRequires:  pkgconfig(libosmocoding) >= 1.3.0
+BuildRequires:  pkgconfig(libosmocore) >= 0.12.0
+BuildRequires:  pkgconfig(libosmoctrl) >= 0.12.0
+BuildRequires:  pkgconfig(libosmovty) >= 0.12.0
+BuildRequires:  pkgconfig(libusb-1.0)
+BuildRequires:  pkgconfig(uhd)
+%{?systemd_requires}
+%if 0%{?suse_version} > 1325
+BuildRequires:  libboost_program_options-devel
+BuildRequires:  libboost_system-devel
+BuildRequires:  libboost_test-devel
+BuildRequires:  libboost_thread-devel
+%else
+BuildRequires:  boost-devel
+%endif
+
+%description
+OsmoTRX is a software-defined radio transceiver that implements the Layer 1
+physical layer of a BTS comprising the following 3GPP specifications:
+
+TS 05.01 "Physical layer on the radio path"
+TS 05.02 "Multiplexing and Multiple Access on the Radio Path"
+TS 05.04 "Modulation"
+TS 05.10 "Radio subsystem synchronization"
+
+In this context, BTS is "Base transceiver station". It's the stations that
+connect mobile phones to the mobile network.
+
+3GPP is the "3rd Generation Partnership Project" which is the collaboration
+between different telecommunication associations for developing new
+generations of mobile phone networks. (post-2G/GSM)
+
+%package uhd
+Summary:        SDR transceiver that implements Layer 1 of a GSM BTS (UHD)
+Group:          Productivity/Telephony/Servers
+Requires:       uhd-firmware
+
+%description uhd
+OsmoTRX is a software-defined radio transceiver that implements the Layer 1
+physical layer of a BTS comprising the following 3GPP specifications:
+
+TS 05.01 "Physical layer on the radio path"
+TS 05.02 "Multiplexing and Multiple Access on the Radio Path"
+TS 05.04 "Modulation"
+TS 05.10 "Radio subsystem synchronization"
+
+In this context, BTS is "Base transceiver station". It's the stations that
+connect mobile phones to the mobile network.
+
+3GPP is the "3rd Generation Partnership Project" which is the collaboration
+between different telecommunication associations for developing new
+generations of mobile phone networks. (post-2G/GSM)
+
+%if ! 0%{?centos_ver}
+%package usrp1
+Summary:        SDR transceiver that implements Layer 1 of a GSM BTS (USRP1)
+Group:          Productivity/Telephony/Servers
+
+%description usrp1
+OsmoTRX is a software-defined radio transceiver that implements the Layer 1
+physical layer of a BTS comprising the following 3GPP specifications:
+
+TS 05.01 "Physical layer on the radio path"
+TS 05.02 "Multiplexing and Multiple Access on the Radio Path"
+TS 05.04 "Modulation"
+TS 05.10 "Radio subsystem synchronization"
+
+In this context, BTS is "Base transceiver station". It's the stations that
+connect mobile phones to the mobile network.
+
+3GPP is the "3rd Generation Partnership Project" which is the collaboration
+between different telecommunication associations for developing new
+generations of mobile phone networks. (post-2G/GSM)
+
+%package lms
+Summary:        SDR transceiver that implements Layer 1 of a GSM BTS (LimeSuite)
+Group:          Productivity/Telephony/Servers
+
+%description lms
+OsmoTRX is a software-defined radio transceiver that implements the Layer 1
+physical layer of a BTS comprising the following 3GPP specifications:
+
+TS 05.01 "Physical layer on the radio path"
+TS 05.02 "Multiplexing and Multiple Access on the Radio Path"
+TS 05.04 "Modulation"
+TS 05.10 "Radio subsystem synchronization"
+
+In this context, BTS is "Base transceiver station". It's the stations that
+connect mobile phones to the mobile network.
+
+3GPP is the "3rd Generation Partnership Project" which is the collaboration
+between different telecommunication associations for developing new
+generations of mobile phone networks. (post-2G/GSM)
+%endif
+
+%package ipc
+Summary:        SDR transceiver that implements Layer 1 of a GSM BTS (IPC)
+Group:          Productivity/Telephony/Servers
+
+%description ipc
+OsmoTRX is a software-defined radio transceiver that implements the Layer 1
+physical layer of a BTS comprising the following 3GPP specifications:
+
+TS 05.01 "Physical layer on the radio path"
+TS 05.02 "Multiplexing and Multiple Access on the Radio Path"
+TS 05.04 "Modulation"
+TS 05.10 "Radio subsystem synchronization"
+
+In this context, BTS is "Base transceiver station". It's the stations that
+connect mobile phones to the mobile network.
+
+3GPP is the "3rd Generation Partnership Project" which is the collaboration
+between different telecommunication associations for developing new
+generations of mobile phone networks. (post-2G/GSM)
+
+%prep
+%setup -q
+
+%build
+echo "%{version}" >.tarball-version
+autoreconf -fi
+
+%if 0%{?centos_ver}
+%configure \
+  --docdir=%{_docdir}/%{name} \
+  --with-systemdsystemunitdir=%{_unitdir} \
+  --without-lms \
+  --with-uhd \
+  --without-usrp1 \
+  --with-ipc
+%else
+%configure \
+  --docdir=%{_docdir}/%{name} \
+  --with-systemdsystemunitdir=%{_unitdir} \
+  --with-lms \
+  --with-uhd \
+  --with-usrp1 \
+  --with-ipc
+%endif
+
+make %{?_smp_mflags} V=1
+
+%check
+make %{?_smp_mflags} check || (find . -name testsuite.log -exec cat {} +)
+
+%install
+%make_install
+%fdupes -s %{buildroot}/%{_datadir}
+
+%if 0%{?suse_version}
+%pre    lms %service_add_pre    osmo-trx-lms.service
+%post   lms %service_add_post   osmo-trx-lms.service
+%preun  lms %service_del_preun  osmo-trx-lms.service
+%postun lms %service_del_postun osmo-trx-lms.service
+%pre    uhd %service_add_pre    osmo-trx-uhd.service
+%post   uhd %service_add_post   osmo-trx-uhd.service
+%preun  uhd %service_del_preun  osmo-trx-uhd.service
+%postun uhd %service_del_postun osmo-trx-uhd.service
+%pre    usrp1 %service_add_pre    osmo-trx-usrp1.service
+%post   usrp1 %service_add_post   osmo-trx-usrp1.service
+%preun  usrp1 %service_del_preun  osmo-trx-usrp1.service
+%postun usrp1 %service_del_postun osmo-trx-usrp1.service
+%pre    ipc %service_add_pre    osmo-trx-ipc.service
+%post   ipc %service_add_post   osmo-trx-ipc.service
+%preun  ipc %service_del_preun  osmo-trx-ipc.service
+%postun ipc %service_del_postun osmo-trx-ipc.service
+%endif
+
+%files
+%license COPYING
+%doc README.md
+%doc %{_docdir}/%{name}/examples
+
+%if ! 0%{?centos_ver}
+%files lms
+%{_bindir}/osmo-trx-lms
+%dir %{_sysconfdir}/osmocom
+%config(noreplace) %{_sysconfdir}/osmocom/osmo-trx-lms.cfg
+%{_unitdir}/osmo-trx-lms.service
+%endif
+
+%files uhd
+%{_bindir}/osmo-trx-uhd
+%dir %{_sysconfdir}/osmocom
+%config(noreplace) %{_sysconfdir}/osmocom/osmo-trx-uhd.cfg
+%{_unitdir}/osmo-trx-uhd.service
+
+%if ! 0%{?centos_ver}
+%files usrp1
+%{_bindir}/osmo-trx-usrp1
+%dir %{_datadir}/usrp
+%dir %{_datadir}/usrp/rev2
+%dir %{_datadir}/usrp/rev4
+%{_datadir}/usrp/rev2/std_inband.rbf
+%{_datadir}/usrp/rev4/std_inband.rbf
+%{_unitdir}/osmo-trx-usrp1.service
+%endif
+
+%files ipc
+%{_bindir}/osmo-trx-ipc
+%{_bindir}/ipc-driver-test
+%dir %{_sysconfdir}/osmocom
+# FIXME: missing: osmo-trx-ipc.cfg
+%{_unitdir}/osmo-trx-ipc.service
+
+%changelog

contrib/systemd/Makefile.am

@@ -1,7 +1,8 @@
 EXTRA_DIST = \
   osmo-trx-lms.service \
   osmo-trx-uhd.service \
-  osmo-trx-usrp1.service
+  osmo-trx-usrp1.service \
+  osmo-trx-ipc.service
 
 if HAVE_SYSTEMD
 SYSTEMD_SERVICES =
@@ -18,5 +19,9 @@ if DEVICE_LMS
 SYSTEMD_SERVICES += osmo-trx-lms.service
 endif
 
+if DEVICE_IPC
+SYSTEMD_SERVICES += osmo-trx-ipc.service
+endif
+
 systemdsystemunit_DATA = $(SYSTEMD_SERVICES)
 endif # HAVE_SYSTEMD

contrib/systemd/osmo-trx-ipc.service

@@ -0,0 +1,11 @@
+[Unit]
+Description=Osmocom SDR BTS L1 Transceiver (IPC Backend)
+
+[Service]
+Type=simple
+Restart=always
+ExecStart=/usr/bin/osmo-trx-ipc -C /etc/osmocom/osmo-trx-ipc.cfg
+RestartSec=2
+
+[Install]
+WantedBy=multi-user.target

debian/control

@@ -1,7 +1,7 @@
 Source: osmo-trx
 Section: net
 Priority: optional
-Maintainer: Ivan Klyuchnikov <ivan.kluchnikov@fairwaves.ru>
+Maintainer: Osmocom team <openbsc@lists.osmocom.org>
 Build-Depends: debhelper (>= 9),
                autotools-dev,
                autoconf-archive,

doc/examples/osmo-trx-lms/osmo-trx-limesdr.cfg

@@ -4,19 +4,19 @@ log stderr
  logging print category 1
  logging timestamp 1
  logging print file basename
- logging level set-all info
+ logging level set-all notice
 !
 line vty
  no login
 !
+cpu-sched
+ policy rr 18
 trx
  bind-ip 127.0.0.1
  remote-ip 127.0.0.1
- base-port 5700
  egprs disable
  tx-sps 4
  rx-sps 4
- rt-prio 18
  chan 0
   tx-path BAND1
   rx-path LNAW

doc/examples/osmo-trx-uhd/osmo-trx-limesdr.cfg

@@ -4,19 +4,19 @@ log stderr
  logging print category 1
  logging timestamp 1
  logging print file basename
- logging level set-all info
+ logging level set-all notice
 !
 line vty
  no login
 !
+cpu-sched
+ policy rr 18
 trx
  bind-ip 127.0.0.1
  remote-ip 127.0.0.1
- base-port 5700
  egprs disable
  tx-sps 4
  rx-sps 4
- rt-prio 18
  chan 0
   tx-path BAND1
   rx-path LNAW

doc/examples/osmo-trx-uhd/osmo-trx-umtrx.cfg

@@ -4,20 +4,20 @@ log stderr
  logging print category 1
  logging timestamp 1
  logging print file basename
- logging level set-all info
+ logging level set-all notice
 !
 line vty
  no login
 !
+cpu-sched
+ policy rr 18
 trx
  bind-ip 127.0.0.1
  remote-ip 127.0.0.1
- base-port 5700
  dev-args addr=192.168.10.2,pa=NONE,pa_power_max_dbm=23,fifo_ctrl_window=0,status_port=12345
  egprs disable
  tx-sps 4
  rx-sps 4
  rssi-offset 38
- rt-prio 18
  chan 0
  chan 1

doc/examples/osmo-trx-uhd/osmo-trx-usrp_b200.cfg

@@ -4,19 +4,21 @@ log stderr
  logging print category 1
  logging timestamp 1
  logging print file basename
- logging level set-all info
+ logging level set-all notice
 !
 line vty
  no login
 !
+cpu-sched
+ policy rr 18
 trx
  bind-ip 127.0.0.1
  remote-ip 127.0.0.1
- base-port 5700
  egprs disable
+ ! 28 dB offset below is valid only for the B2xx in 1800 MHz band, see
+ ! https://osmocom.org/issues/4468 for more details
+ rssi-offset 28.000000
  tx-sps 4
  rx-sps 4
  clock-ref external
- rt-prio 18
  chan 0
-

doc/manuals/chapters/code-architecture.adoc

@@ -39,8 +39,7 @@ trans [label="Transceiver"];
 radioiface [label="RadioInterface"];
 radiodev [label="RadioDevice"];
 
-trans:nw->trans:ne [label="Trx.ControlServiceLoop_0"];
-trans:nw->trans:ne [label="Trx.ControlServiceLoop_1"];
+trans:nw->trans:ne [label="Main"];
 trans:w->radioiface:w [label="Trx.TxPriorityQueueServiceLoop_0"];
 trans:w->radioiface:w [label="Trx.TxPriorityQueueServiceLoop_1"];
 radioiface:e->trans:e [label="Trx.RxServiceLoop_0"];
@@ -92,14 +91,6 @@ Static amount of Threads (1 per `Transceiver` instance):
 
 Dynamic amount of Threads (1 per RF logical channel on the `Transceiver` instance):
 
-* `ControlServiceLoop`: Handles commands from the Per-ARFCN Control Interface
-  socket (<<trx_if_control>>). Each thread is responsible for managing one
-  socket related to one ARFCN or which is the same, to one RF logical channel.
-  These are the only threads expected to use the private `start()` and `stop()`
-  methods of the `Transceiver()` class, since those methods don't stop any of
-  the `ControlServiceLoop` threads as they must keep running to handle new
-  commands (for instance, to re-start processing samples with the _POWERON_
-  command).
 * `RxServiceLoop`: Each thread of this type pulls bursts from the
   `RadioInterface` FIFO for one specific logical RF channel and handles it
   according to the slot and burst correlation type, finally sending proper data
@@ -108,6 +99,10 @@ Dynamic amount of Threads (1 per RF logical channel on the `Transceiver` instanc
   Manager UDP socket (<<trx_if>>), and fills the `RadioInterface` with it
   setting clock related information.
 
+All the Per-ARFCN Control Interface socket (<<trx_if_control>>) commands are
+handled by the event loop runnnig on the main thread. This is the only thread
+expected to use the private `start()` and `stop()` methods.
+
 [[code_component_radioiface]]
 === RadioInterface
 

doc/manuals/osmotrx-usermanual.adoc

@@ -31,6 +31,8 @@ include::{srcdir}/chapters/trx-backends.adoc[]
 
 include::{srcdir}/chapters/code-architecture.adoc[]
 
+include::./common/chapters/vty_cpu_sched.adoc[]
+
 include::./common/chapters/trx_if.adoc[]
 
 include::./common/chapters/port_numbers.adoc[]

utils/Makefile.am

@@ -0,0 +1,9 @@
+AM_CPPFLAGS = $(LIBOSMOCODING_CFLAGS)
+AM_CFLAGS = -Wall
+
+EXTRA_DIST = clockdump.sh matlab
+
+noinst_PROGRAMS = osmo-prbs-tool
+
+osmo_prbs_tool_SOURCES = prbs-tool.c
+osmo_prbs_tool_LDADD = $(LIBOSMOCODING_LIBS)

utils/prbs-tool.c

@@ -0,0 +1,386 @@
+/* Dummy TRX for sening PRBS test sequences into osmo-bts-trx to test
+ * the decoder/receiver processing in osmo-bts-trx as well as any
+ * additional PRBS testing code.
+ *
+ * The purpose of this program is to use it as a mock dummy MS-side
+ * transmitter of GSM bursts that contain encoded PRBS sequences,
+ * similar to what one would normally do with an arbitrary
+ * function/waveform generator or BERT tester in hardware.
+ *
+ * (C) 2017 by Harald Welte <laforge@gnumonks.org>
+ * All Rights Reserved
+ *
+ * Licensed under terms of the GNU Generral Public License, Version 2,
+ * or (at your option) any later version.
+ */
+
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+
+#include <netinet/in.h>
+
+#include <osmocom/core/bits.h>
+#include <osmocom/core/utils.h>
+#include <osmocom/core/prbs.h>
+#include <osmocom/core/socket.h>
+#include <osmocom/gsm/gsm_utils.h>
+#include <osmocom/coding/gsm0503_coding.h>
+
+/***********************************************************************
+ * GSM Constants
+ ***********************************************************************/
+
+#define GSM_FR_BYTES	33
+#define GSM_BURST_BITS	116
+#define GSM_4BURST_BITS	(GSM_BURST_BITS*4)
+#define GSM_BURST_LEN	148
+
+
+/***********************************************************************
+ * TRX Interface / Protocol
+ ***********************************************************************/
+
+#define TRX_BASE_PORT	5700
+/* DATA port on the TRX side */
+#define	TRX_PORT_CTRL_TRX(C) 	(TRX_BASE_PORT+(2*(C))+1)
+#define	TRX_PORT_DATA_TRX(C) 	(TRX_BASE_PORT+(2*(C))+2)
+#define	TRX_PORT_CTRL_BTS(C) 	(TRX_PORT_CTRL_TRX(C)+100)
+#define	TRX_PORT_DATA_BTS(C) 	(TRX_PORT_DATA_TRX(C)+100)
+
+struct trx_ul_msg {
+	uint8_t		ts;
+	uint32_t	fn;
+	uint8_t		rssi;
+	uint16_t	t_offs;
+	uint8_t		bits[148];	/* 0..255, *NOT* sbit_t */
+} __attribute__((packed));
+
+struct trx_dl_msg {
+	uint8_t		ts;
+	uint32_t	fn;
+	uint8_t		att_db;
+	ubit_t		bits[148];
+} __attribute__((packed));
+
+
+/***********************************************************************
+ * Helper Functions
+ ***********************************************************************/
+
+static int ubits2trxbits(uint8_t *sbits, const ubit_t *ubits, unsigned int count)
+{
+	unsigned int i;
+
+	for (i = 0; i < count; i++) {
+		if ((*ubits++) & 1) {
+			*sbits++ = 255;
+		} else {
+			*sbits++ = 0;
+		}
+	}
+
+	return count;
+}
+
+static int __attribute__((__unused__)) dec(const ubit_t *bursts_u)
+{
+	sbit_t bursts_s[GSM_4BURST_BITS*2];
+	uint8_t dec_tch_data[GSM_FR_BYTES];
+	int n_errors, n_bits_total;
+	int rc;
+
+	/* convert from u_bit (tx) to s_bit (rx)  */
+	osmo_ubit2sbit(bursts_s, bursts_u, sizeof(bursts_s));
+
+	rc = gsm0503_tch_fr_decode(dec_tch_data, bursts_s, 1, 0, &n_errors, &n_bits_total);
+	printf("rc=%d, n_errors=%d, n_bits_total=%d: %s\n", rc, n_errors, n_bits_total,
+		osmo_hexdump(dec_tch_data, sizeof(dec_tch_data)));
+
+	return rc;
+}
+
+/*! \brief Training Sequences (TS 05.02 Chapter 5.2.3) */
+static const ubit_t _sched_tsc[8][26] = {
+	{ 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,1,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, },
+};
+
+/***********************************************************************
+ * state + processing functions
+ ***********************************************************************/
+
+/* state we have to keep for one physical channel */
+struct pchan_data {
+	/* PRBS state */
+	struct osmo_prbs_state st;
+	/* unpacked PRBS bits, generated from PRBS */
+	ubit_t prbs_u[4+260];
+	/* packed frame (to be sent) */
+	uint8_t tch_data[GSM_FR_BYTES];
+	/* burst bits (ubit) to be transmitted */
+	ubit_t bursts[GSM_4BURST_BITS*2]; /* 116 * 8 */
+	/* burst bits (sbit) 'as if received' */
+	sbit_t bursts_s[GSM_4BURST_BITS*2];
+	/* next to-be transmitted burst number */
+	unsigned int burst_nr;
+	/* training sequence code */
+	unsigned int tsc;
+
+	/* loose 'count' bursts every 'nth_mframe' on TRX-BTS interface */
+	struct {
+		unsigned int count;
+		unsigned int nth_mframe;
+	} sim_lost_bursts;
+
+	/* zero 'count' bursts every 'nth_mframe' on TRX-BTS interface */
+	struct {
+		unsigned int count;
+		unsigned int nth_mframe;
+	} sim_zero_bursts;
+
+	/* flip every 'nth_bit' of the PRNG oudput before encoding */
+	struct {
+		unsigned int nth_bit;
+		unsigned int i;
+	} sim_flip_codec_bits;
+
+	unsigned int i;
+};
+
+struct ts_data {
+	struct pchan_data pchan[2];
+};
+
+struct trx_data {
+	struct ts_data ts[8];
+};
+
+static struct trx_data g_trx_data;
+
+/* initialize the state for one TRX */
+static void trx_data_init(struct trx_data *trx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(trx->ts); i++) {
+		struct ts_data *ts = &trx->ts[i];
+		int j;
+		for (j = 0; j < ARRAY_SIZE(ts->pchan); j++) {
+			struct pchan_data *pchan = &ts->pchan[j];
+
+			memset(pchan, 0, sizeof(*pchan));
+			osmo_prbs_state_init(&pchan->st, &osmo_prbs9);
+			pchan->tsc = 7;
+		}
+	}
+}
+
+/* apply any intentional errors to the output of the PRBS sequence */
+static void apply_errors_prbs(struct pchan_data *pchan)
+{
+	int i;
+
+	for (i = 0; i < sizeof(pchan->prbs_u)-4; i++) {
+		pchan->sim_flip_codec_bits.i++;
+		if (pchan->sim_flip_codec_bits.i == pchan->sim_flip_codec_bits.nth_bit) {
+			pchan->sim_flip_codec_bits.i = 0;
+			pchan->prbs_u[4+i] ^= 0x01;
+		}
+	}
+}
+
+/*! obtain the next to-be-transmitted burst for the given pchan
+ *  \param pchan physical channel on which we operate
+ *  \param[in] fn frame number
+ *  \param[out] burst_out caller-provided buffer for 148 unpacked output bits
+ *  \retruns number of bits stored in \a burst_out */
+static int pchan_get_next_burst(struct pchan_data *pchan, uint32_t fn, ubit_t *burst_out)
+{
+	uint32_t fn26 = fn % 26;
+	int rc;
+
+	if (fn26 == 0 || fn26 == 4 || fn26 == 8 || fn26 == 13 || fn26 == 17 || fn26 == 21)
+		pchan->burst_nr = 0;
+
+	if (fn26 == 12 || fn26 == 25) {
+		memset(burst_out, 0, GSM_BURST_LEN);
+		return GSM_BURST_LEN;
+	}
+
+	if (pchan->burst_nr == 0) {
+		/* generate PRBS output in ubit format, skipping first nibble for 260-264 padding */
+		const uint8_t prefix[] = { 0xd0 };
+		osmo_pbit2ubit(pchan->prbs_u, prefix, 4);
+		rc = osmo_prbs_get_ubits(pchan->prbs_u+4, sizeof(pchan->prbs_u)-4, &pchan->st);
+		OSMO_ASSERT(rc == sizeof(pchan->prbs_u)-4);
+
+		apply_errors_prbs(pchan);
+
+		/* pack to PBIT format */
+		rc = osmo_ubit2pbit(pchan->tch_data, pchan->prbs_u, sizeof(pchan->prbs_u));
+		//memset(pchan->tch_data, 0xff, sizeof(pchan->tch_data));
+
+		printf("%s\n", osmo_hexdump(pchan->tch_data, GSM_FR_BYTES));
+
+		/* shift buffer by 4 bursts for interleaving */
+		memcpy(pchan->bursts, pchan->bursts + GSM_4BURST_BITS, GSM_4BURST_BITS);
+		memset(pchan->bursts + GSM_4BURST_BITS, 0, GSM_4BURST_BITS);
+
+		/* encode block (codec frame) into four bursts */
+		rc = gsm0503_tch_fr_encode(pchan->bursts, pchan->tch_data, GSM_FR_BYTES, 1);
+		OSMO_ASSERT(rc == 0);
+#if 0
+		int i;
+		for (i = 0; i < sizeof(pchan->bursts); i += GSM_BURST_BITS)
+			printf("\t%s\n", osmo_ubit_dump(pchan->bursts + i, GSM_BURST_BITS));
+
+		dec(pchan->bursts);
+#endif
+	}
+
+	/* for all bursts: format 148 symbols from 116 input bits */
+	ubit_t *burst = pchan->bursts  + pchan->burst_nr * GSM_BURST_BITS;
+//	printf("TX(%u): %s\n", pchan->burst_nr, osmo_ubit_dump(burst, GSM_BURST_BITS));
+	memset(burst_out, 0, 3);		/* guard bits */
+	memcpy(burst_out+3, burst, 58);		/* firrst half */
+	memcpy(burst_out+61, _sched_tsc[pchan->tsc], 26);	/* midamble */
+	memcpy(burst_out+87, burst+58, 58);	/* second half */
+	memset(burst_out+145, 0, 3);		/* guard bits */
+
+	/* increment burst number for next call */
+	pchan->burst_nr += 1;
+
+	return GSM_BURST_LEN;
+}
+
+static int pchan_process_ts_fn(struct pchan_data *pchan, uint32_t fn, uint8_t *burst_t)
+{
+	ubit_t burst_u[GSM_BURST_LEN];
+	int rc;
+
+	rc = pchan_get_next_burst(pchan, fn, burst_u);
+	OSMO_ASSERT(rc == sizeof(burst_u));
+
+	/* convert from u_bit (tx) to s_bit (rx)  */
+	ubits2trxbits(burst_t, burst_u, GSM_BURST_LEN);
+
+	return GSM_BURST_LEN;
+}
+
+/* read TRX DL data from BTS, write TRX UL data to BTS */
+static int read_and_process(int fd)
+{
+	/* receive (downlink) buffer */
+	uint8_t rx_dl_buf[1024];
+	struct trx_dl_msg *dl_msg = (struct trx_dl_msg *) rx_dl_buf;
+	/* transmit (uplink) buffer */
+	uint8_t tx_ul_buf[1024];
+	struct trx_ul_msg *ul_msg = (struct trx_ul_msg *) tx_ul_buf;
+	/* other variables */
+	struct pchan_data *pchan;
+	uint32_t fn;
+	uint8_t rc;
+
+	/* do a blocking read on the socket and receive DL from BTS */
+	rc = read(fd, rx_dl_buf, sizeof(rx_dl_buf));
+	if (rc < sizeof(*dl_msg))
+		return rc;
+
+	fn = ntohl(dl_msg->fn);
+
+	if (dl_msg->ts >= ARRAY_SIZE(g_trx_data.ts))
+		return -ENODEV;
+
+	if (dl_msg->ts != 2)
+		return 0;
+
+	printf("FN=%s TS=%u\n", gsm_fn_as_gsmtime_str(fn), dl_msg->ts);
+
+	/* FIXME: second pchan for TCH/H */
+	pchan = &g_trx_data.ts[dl_msg->ts].pchan[0];
+
+	rc = pchan_process_ts_fn(pchan, fn, (uint8_t *) ul_msg->bits);
+	OSMO_ASSERT(rc == sizeof(ul_msg->bits));
+
+	/* copy over timeslot and frame number */
+	ul_msg->fn = htonl(fn);
+	ul_msg->ts = dl_msg->ts;
+
+	/* simulate lost frames on TRX <-> BTS interface */
+	if (pchan->sim_lost_bursts.count) {
+		/* count number of 26-multiframes */
+		static int count = 0;
+		if (fn % 26 == 0)
+			count++;
+
+		/* every 10th multiframe, drop two entire block of 8 bursts */
+		if (count % pchan->sim_lost_bursts.nth_mframe == 0 &&
+		    (fn % 26) <= pchan->sim_lost_bursts.count) {
+			printf("===> SKIPPING BURST\n");
+			return 0;
+		}
+	}
+
+	/* simulate zero-ed frames on TRX <-> BTS interface */
+	if (pchan->sim_zero_bursts.count) {
+		/* count number of 26-multiframes */
+		static int count = 0;
+		if (fn % 26 == 0)
+			count++;
+
+		/* every 10th multiframe, drop two entire block of 8 bursts */
+		if (count % pchan->sim_zero_bursts.nth_mframe == 0 &&
+		    (fn % 26) <= pchan->sim_zero_bursts.count) {
+			memset(ul_msg->bits, 0, sizeof(ul_msg->bits));
+			printf("===> ZEROING BURST\n");
+		}
+	}
+
+	/* write uplink message towards BTS */
+	rc = write(fd, tx_ul_buf, sizeof(*ul_msg));
+	if (rc < sizeof(*ul_msg))
+		return -EIO;
+
+	return 0;
+}
+
+static int open_trx_data_sock(unsigned int trx_nr, const char *bts_host)
+{
+	int rc;
+
+	rc = osmo_sock_init2(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, TRX_PORT_DATA_TRX(trx_nr),
+				bts_host, TRX_PORT_DATA_BTS(trx_nr),
+				OSMO_SOCK_F_CONNECT | OSMO_SOCK_F_BIND);
+	return rc;
+}
+
+
+int main(int argc, char **argv)
+{
+	int fd;
+
+	trx_data_init(&g_trx_data);
+
+	//g_trx_data.ts[2].pchan[0].sim_zero_bursts.count = 8;
+	//g_trx_data.ts[2].pchan[0].sim_zero_bursts.nth_mframe = 10;
+	g_trx_data.ts[2].pchan[0].sim_flip_codec_bits.nth_bit = 260*4;
+
+	fd = open_trx_data_sock(0, "127.0.0.1");
+	if (fd < 0)
+		exit(1);
+
+	while (1) {
+		read_and_process(fd);
+	}
+
+	return 0;
+}