Bump version: 0.2.0 → 0.3.0

Change-Id: I4dad76ed95dc585acfbd52d7eed4f2e6f9f5fd1f

.checkpatch.conf

@@ -1,5 +0,0 @@
---exclude osmocom-bb/.*
---exclude .*h
---exclude Transceiver52M/grgsm_vitac/.*
---exclude utils/va-test/.*
---ignore FUNCTION_WITHOUT_ARGS

.clang-format

@@ -1,521 +0,0 @@
-# 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: true
-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: Cpp11
-TabWidth: 8
-UseTab: Always
-...

.github/FUNDING.yml

@@ -1 +0,0 @@
-open_collective: osmocom

.gitignore

@@ -2,21 +2,7 @@
 *.o
 *.lo
 *.la
-Transceiver52M/osmo-trx-uhd
-Transceiver52M/osmo-trx-usrp1
-Transceiver52M/osmo-trx-lms
-Transceiver52M/osmo-trx-ipc
-Transceiver52M/osmo-trx-blade
-Transceiver52M/osmo-trx-ipc2
-Transceiver52M/osmo-trx-syncthing-blade
-Transceiver52M/osmo-trx-syncthing-uhd
-Transceiver52M/osmo-trx-syncthing-ipc
-Transceiver52M/osmo-trx-ms-blade
-Transceiver52M/osmo-trx-ms-uhd
-Transceiver52M/osmo-trx-ms-ipc
-Transceiver52M/device/ipc/uhddev_ipc.cpp
-
-.clang-format
+Transceiver52M/osmo-trx
 
 # tests
 tests/CommonLibs/BitVectorTest
@@ -30,15 +16,12 @@ tests/CommonLibs/URLEncodeTest
 tests/CommonLibs/VectorTest
 tests/CommonLibs/PRBSTest
 tests/Transceiver52M/convolve_test
-tests/Transceiver52M/LMSDeviceTest
-Transceiver52M/device/ipc/ipc-driver-test
 
 # automake/autoconf
 *.in
 .deps
 .libs
 .dirstamp
-.version
 *~
 Makefile
 config.log
@@ -66,25 +49,3 @@ tests/testsuite.log
 
 # vim
 *.sw?
-
-# manuals
-doc/manuals/*.html
-doc/manuals/*.svg
-doc/manuals/*.pdf
-doc/manuals/*__*.png
-doc/manuals/*.check
-doc/manuals/generated/
-doc/manuals/vty/osmotrx-*-vty-reference.xml
-doc/manuals/vty/osmotrx-*-vty-reference.xml.inc.gen
-doc/manuals/vty/osmotrx-*-vty-reference.xml.inc.merged
-doc/manuals/common
-doc/manuals/build
-
-contrib/osmo-trx.spec
-!contrib/osmo-trx.spec.in
-
-utils/osmo-prbs-tool
-utils/va-test/osmo-burst-gen
-/.qtc_clangd/*
-/.cache/*
-/.vscode/*

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "osmocom-bb"]
-	path = osmocom-bb
-	url = https://gitea.osmocom.org/phone-side/osmocom-bb.git

AUTHORS

@@ -0,0 +1,127 @@
+#
+# Copyright 2008, 2009 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+
+David A. Burgess, dburgess@kestrelsp.com:
+    CLI/CLI.cpp
+    CLI/CLI.h
+    CommonLibs/Assert.h
+    CommonLibs/BitVector.cpp
+    CommonLibs/Interthread.h
+    CommonLibs/LinkedLists.cpp
+    CommonLibs/LinkedLists.h
+    CommonLibs/Regexp.h
+    CommonLibs/Sockets.cpp
+    CommonLibs/Sockets.h
+    CommonLibs/Threads.cpp
+    CommonLibs/Threads.h
+    CommonLibs/Timeval.cpp
+    CommonLibs/Timeval.h
+    CommonLibs/Vector.h
+    GSM/GSM610Tables.cpp
+    GSM/GSM610Tables.h
+    GSM/GSMCommon.cpp
+    GSM/GSMCommon.h
+    GSM/GSMConfig.h
+    GSM/GSML1FEC.cpp
+    GSM/GSML1FEC.h
+    GSM/GSML2LAPDm.cpp
+    GSM/GSML2LAPDm.h
+    GSM/GSML3CCElements.cpp
+    GSM/GSML3CCElements.h
+    GSM/GSML3CCMessages.cpp
+    GSM/GSML3CCMessages.h
+    GSM/GSML3CommonElements.cpp
+    GSM/GSML3CommonElements.h
+    GSM/GSML3MMElements.cpp
+    GSM/GSML3MMElements.h
+    GSM/GSML3MMMessages.cpp
+    GSM/GSML3MMMessages.h
+    GSM/GSML3Message.cpp
+    GSM/GSML3Message.h
+    GSM/GSML3RRElements.cpp
+    GSM/GSML3RRElements.h
+    GSM/GSML3RRMessages.cpp
+    GSM/GSML3RRMessages.h
+    GSM/GSMLogicalChannel.h
+    GSM/GSMTDMA.cpp
+    GSM/GSMTDMA.h
+    GSM/GSMTransfer.cpp
+    GSM/GSMTransfer.h
+    LICENSEBLOCK
+    TRXManager/TRXManager.cpp
+    Transceiver/Complex.h
+    tests/CommonLibs/BitVectorTest.cpp
+    tests/CommonLibs/InterthreadTest.cpp
+    tests/CommonLibs/SocketsTest.cpp
+    tests/CommonLibs/TimevalTest.cpp
+    tests/CommonLibs/VectorTest.cpp
+
+Harvind S. Samra, hssamra@kestrelsp.com:
+    GSM/GSMConfig.h
+    GSM/GSMTransfer.h
+    LICENSEBLOCK
+    Transceiver/ComplexTest.cpp
+    Transceiver/Transceiver.cpp
+    Transceiver/Transceiver.h
+    Transceiver/USRPDevice.cpp
+    Transceiver/USRPDevice.h
+    Transceiver/USRPping.cpp
+    Transceiver/radioInterface.cpp
+    Transceiver/radioInterface.h
+    Transceiver/rcvLPF_651.h
+    Transceiver/runTransceiver.cpp
+    Transceiver/sendLPF_961.h
+    Transceiver/sigProcLib.cpp
+    Transceiver/sigProcLib.h
+    Transceiver/sigProcLibTest.cpp
+    Transceiver/sweepGenerator.cpp
+    Transceiver/testRadio.cpp
+
+Raffi Sevlian, raffisev@gmail.com:
+    GSM/GSMCommon.h
+    GSM/GSMConfig.h
+    GSM/GSML1FEC.h
+    GSM/GSML3CCElements.cpp
+    GSM/GSML3CCElements.h
+    GSM/GSML3CCMessages.cpp
+    GSM/GSML3CCMessages.h
+    GSM/GSML3CommonElements.cpp
+    GSM/GSML3CommonElements.h
+    GSM/GSML3MMElements.cpp
+    GSM/GSML3MMElements.h
+    GSM/GSML3MMMessages.cpp
+    GSM/GSML3MMMessages.h
+    GSM/GSML3Message.cpp
+    GSM/GSML3Message.h
+    GSM/GSML3RRElements.cpp
+    GSM/GSML3RRElements.h
+    GSM/GSML3RRMessages.cpp
+    GSM/GSML3RRMessages.h
+    GSM/GSMLogicalChannel.h
+    GSM/GSMSAPMux.cpp
+    GSM/GSMSAPMux.h
+    GSM/GSMTransfer.h
+    LICENSEBLOCK
+    TRXManager/TRXManager.h
+
+Alon Levy, alonlevy1@gmail.com
+    RRLPMessages.cpp
+    RRLPMessages.h
+    RRLPTest.cpp

COPYING

@@ -666,7 +666,7 @@ For more information on this, and how to apply and follow the GNU AGPL, see
 =========================================================================
 
 This marks the end of the AGPLv3 text.  The following text is appended to the
-same file for convenience but constituting a distinct document, not part of the
+same file for convience but constituting a distinct document, not part of the
 actual AGPL text and not part of an attempt to create a deriviative work based
 on the AGPLv3 text.
 

CommonLibs/BitVector.cpp

@@ -1,7 +1,6 @@
 /*
 * Copyright 2008, 2009 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
 *
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
@@ -37,7 +36,7 @@ using namespace std;
 
 
 /**
-  Apply a Galois polymonial to a binary sequence.
+  Apply a Galois polymonial to a binary seqeunce.
   @param val The input sequence.
   @param poly The polynomial.
   @param order The order of the polynomial.

CommonLibs/BitVector.h

@@ -1,8 +1,6 @@
 /*
 * Copyright 2008, 2009 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *

CommonLibs/Interthread.h

@@ -1,8 +1,6 @@
 /*
 * Copyright 2008, 2011 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -47,7 +45,7 @@
 // (pat) The elements in the queue are type T*, and
 // the Fifo class implements the underlying queue.
 // The default is class PointerFIFO, which does not place any restrictions on the type of T,
-// and is implemented by allocating auxiliary structures for the queue,
+// and is implemented by allocating auxilliary structures for the queue,
 // or SingleLinkedList, which implements the queue using an internal pointer in type T,
 // which must implement the functional interface of class SingleLinkListNode,
 // namely: functions T*next() and void setNext(T*).
@@ -517,7 +515,7 @@ public:
 		@param timeout The blocking timeout in ms.
 		@return Pointer at key or NULL on timeout.
 	*/
-	D* read(const K &key, unsigned timeout)
+	D* read(const K &key, unsigned timeout) const
 	{
 		if (timeout==0) return readNoBlock(key);
 		ScopedLock lock(mLock);
@@ -537,7 +535,7 @@ public:
 		@param key The key to read from.
 		@return Pointer at key.
 	*/
-	D* read(const K &key)
+	D* read(const K &key) const
 	{
 		ScopedLock lock(mLock);
 		typename Map::const_iterator iter = mMap.find(key);

CommonLibs/LinkedLists.cpp

@@ -1,7 +1,6 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
 *
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
@@ -30,25 +29,6 @@
 #include "LinkedLists.h"
 
 
-PointerFIFO::~PointerFIFO()
-{
-	ListNode *node, *next;
-
-	node = mHead;
-	while (node != NULL) {
-		next = node->next();
-		delete node;
-		node = next;
-	}
-
-	node = mFreeList;
-	while (node != NULL) {
-		next = node->next();
-		delete node;
-		node = next;
-	}
-}
-
 void PointerFIFO::push_front(void* val)	// by pat
 {
 	// Pat added this routine for completeness, but never used or tested.

CommonLibs/LinkedLists.h

@@ -1,10 +1,7 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* 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 software is distributed under multiple licenses; see the COPYING file in the main directory for licensing information for this specific distribuion.
 *
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
@@ -73,7 +70,6 @@ class PointerFIFO {
 		:mHead(NULL),mTail(NULL),mFreeList(NULL),
 		mSize(0)
 	{}
-	~PointerFIFO();
 
 	unsigned size() const { return mSize; }
 	unsigned totalSize() const { return 0; }	// Not used in this version.

CommonLibs/Logger.cpp

@@ -1,7 +1,8 @@
 /*
-* Copyright (C) 2018 sysmocom - s.f.m.c. GmbH
+* Copyright 2009, 2010 Free Software Foundation, Inc.
+* Copyright 2010 Kestrel Signal Processing, Inc.
+* Copyright 2011, 2012 Range Networks, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
 *
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
@@ -36,6 +37,57 @@
 
 using namespace std;
 
+Mutex gLogToLock;
+
+// Global log level threshold:
+int config_log_level;
+
+/** Names of the logging levels. */
+const char *levelNames[] = {
+	"EMERG", "ALERT", "CRIT", "ERR", "WARNING", "NOTICE", "INFO", "DEBUG"
+};
+int numLevels = 8;
+
+
+int levelStringToInt(const string& name)
+{
+	// Reverse search, since the numerically larger levels are more common.
+	for (int i=numLevels-1; i>=0; i--) {
+		if (name == levelNames[i]) return i;
+	}
+
+	// Common substitutions.
+	if (name=="INFORMATION") return 6;
+	if (name=="WARN") return 4;
+	if (name=="ERROR") return 3;
+	if (name=="CRITICAL") return 2;
+	if (name=="EMERGENCY") return 0;
+
+	// Unknown level.
+	return -1;
+}
+
+static std::string format(const char *fmt, ...)
+{
+	va_list ap;
+	char buf[300];
+	va_start(ap,fmt);
+	int n = vsnprintf(buf,300,fmt,ap);
+	va_end(ap);
+	if (n >= (300-4)) { strcpy(&buf[(300-4)],"..."); }
+	return std::string(buf);
+}
+
+const std::string timestr()
+{
+	struct timeval tv;
+	struct tm tm;
+	gettimeofday(&tv,NULL);
+	localtime_r(&tv.tv_sec,&tm);
+	unsigned tenths = tv.tv_usec / 100000;	// Rounding down is ok.
+	return format(" %02d:%02d:%02d.%1d",tm.tm_hour,tm.tm_min,tm.tm_sec,tenths);
+}
+
 std::ostream& operator<<(std::ostream& os, std::ostringstream& ss)
 {
 	return os << ss.str();
@@ -43,21 +95,34 @@ std::ostream& operator<<(std::ostream& os, std::ostringstream& ss)
 
 Log::~Log()
 {
-	int old_state;
+	// Anything at or above LOG_CRIT is an "alarm".
+	if (mPriority <= LOG_ERR) {
+		cerr << mStream.str() << endl;
+	}
+
 	int mlen = mStream.str().size();
 	int neednl = (mlen==0 || mStream.str()[mlen-1] != '\n');
-	const char *fmt = neednl ? "%s\n" : "%s";
-
-	/* print related function called inside a C++ destructor, use pthread_setcancelstate() APIs.
-	   See osmo-trx commit 86be40b4eb762d5c12e8e3f7388ca9f254e77b36 for more information */
-	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_state);
-	LOGPSRC(mCategory, mPriority, filename, line, fmt, mStream.str().c_str());
-	pthread_setcancelstate(old_state, NULL);
+	ScopedLock lock(gLogToLock);
+	// The COUT() macro prevents messages from stomping each other but adds uninteresting thread numbers,
+	// so just use std::cout.
+	std::cout << mStream.str();
+	if (neednl) std::cout<<"\n";
 }
 
 ostringstream& Log::get()
 {
+	assert(mPriority<numLevels);
+	mStream << levelNames[mPriority] <<  ' ';
 	return mStream;
 }
 
+
+
+void gLogInit(const char* level, char *fn)
+{
+	// Set the level if one has been specified.
+	if (level)
+		config_log_level = levelStringToInt(level);
+}
+
 // vim: ts=4 sw=4

CommonLibs/Logger.h

@@ -2,8 +2,6 @@
 * Copyright 2009, 2010 Free Software Foundation, Inc.
 * Copyright 2010 Kestrel Signal Processing, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -25,6 +23,12 @@
 
 */
 
+// (pat) WARNING is stupidly defined in /usr/local/include/osipparser2/osip_const.h.
+// This must be outside the #ifndef LOGGER_H to fix it as long as Logger.h included after the above file.
+#ifdef WARNING
+#undef WARNING
+#endif
+
 #ifndef LOGGER_H
 #define LOGGER_H
 
@@ -33,36 +37,30 @@
 #include <sstream>
 #include <string>
 
-extern "C" {
-#include <osmocom/core/logging.h>
-#include "debug.h"
-}
+extern int config_log_level;
 
-/* Translation for old log statements */
-#ifndef LOGL_ALERT
-#define LOGL_ALERT LOGL_FATAL
+#define LOG_EMERG       0       /* system is unusable */
+#define LOG_ALERT       1       /* action must be taken immediately */
+#define LOG_CRIT        2       /* critical conditions */
+#define LOG_ERR         3       /* error conditions */
+#define LOG_WARNING     4       /* warning conditions */
+#define LOG_NOTICE      5       /* normal but significant condition */
+#define LOG_INFO        6       /* informational */
+#define LOG_DEBUG       7       /* debug-level messages */
+
+#define _LOG(level) \
+	Log(LOG_##level).get() << pthread_self() \
+	<< timestr() << " " __FILE__  ":"  << __LINE__ << ":" << __FUNCTION__ << ": "
+
+#define IS_LOG_LEVEL(wLevel) (config_log_level>=LOG_##wLevel)
+
+#ifdef NDEBUG
+#define LOG(wLevel) \
+	if (LOG_##wLevel!=LOG_DEBUG && IS_LOG_LEVEL(wLevel)) _LOG(wLevel)
+#else
+#define LOG(wLevel) \
+	if (IS_LOG_LEVEL(wLevel)) _LOG(wLevel)
 #endif
-#ifndef LOGL_ERR
-#define LOGL_ERR LOGL_ERROR
-#endif
-#ifndef LOGL_WARNING
-#define LOGL_WARNING LOGL_NOTICE
-#endif
-
-#define LOG(level) \
-	Log(DMAIN, LOGL_##level, __BASE_FILE__, __LINE__).get()
-
-#define LOGC(category, level) \
-	Log(category, LOGL_##level, __BASE_FILE__, __LINE__).get()
-
-#define LOGLV(category, level) \
-	Log(category, level, __BASE_FILE__, __LINE__).get()
-
-#define LOGSRC(category, level, file, line) \
-	Log(category, level, file, line).get()
-
-#define LOGCHAN(chan, category, level) \
-	Log(category, LOGL_##level, __BASE_FILE__, __LINE__).get() <<  "[chan=" << chan << "] "
 
 /**
 	A C++ stream-based thread-safe logger.
@@ -75,17 +73,13 @@ class Log {
 
 	protected:
 
-	std::ostringstream mStream;	///< This is where we buffer up the log entry.
-	int mCategory;			///< Priority of current report.
-	int mPriority;			///< Category of current report.
-	const char *filename;		///< Source File Name of current report.
-	int line;			///< Line number in source file of current report.
+	std::ostringstream mStream;		///< This is where we buffer up the log entry.
+	int mPriority;					///< Priority of current report.
 
 	public:
 
-	Log(int wCategory, int wPriority, const char* filename, int line)
-		: mCategory(wCategory), mPriority(wPriority),
-		  filename(filename), line(line)
+	Log(int wPriority)
+		:mPriority(wPriority)
 	{ }
 
 	// Most of the work is in the destructor.
@@ -95,8 +89,16 @@ class Log {
 	std::ostringstream& get();
 };
 
+const std::string timestr();		// A timestamp to print in messages.
 std::ostream& operator<<(std::ostream& os, std::ostringstream& ss);
 
+/**@ Global control and initialization of the logging system. */
+//@{
+/** Initialize the global logging system. */
+void gLogInit(const char* level=NULL, char* fn=NULL);
+//@}
+
+
 #endif
 
 // vim: ts=4 sw=4

CommonLibs/Makefile.am

@@ -22,40 +22,29 @@
 include $(top_srcdir)/Makefile.common
 
 AM_CPPFLAGS = $(STD_DEFINES_AND_INCLUDES)
-AM_CXXFLAGS = -Wall $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
-AM_CFLAGS = -Wall $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
+AM_CXXFLAGS = -Wall -O3 -g -lpthread
+
+EXTRA_DIST = \
+	example.config \
+	README.common
 
 noinst_LTLIBRARIES = libcommon.la
 
 libcommon_la_SOURCES = \
 	BitVector.cpp \
 	LinkedLists.cpp \
+	Sockets.cpp \
 	Threads.cpp \
 	Timeval.cpp \
-	Logger.cpp \
-	Utils.cpp \
-	trx_rate_ctr.cpp \
-	trx_vty.c \
-	debug.c
-libcommon_la_LIBADD = \
-	$(LIBOSMOCORE_LIBS) \
-	$(LIBOSMOCTRL_LIBS) \
-	$(LIBOSMOVTY_LIBS) \
-	-lpthread \
-	$(NULL)
+	Logger.cpp
 
 noinst_HEADERS = \
 	BitVector.h \
 	PRBS.h \
 	Interthread.h \
 	LinkedLists.h \
+	Sockets.h \
 	Threads.h \
 	Timeval.h \
 	Vector.h \
-	Logger.h \
-	Utils.h \
-	trx_rate_ctr.h \
-	trx_vty.h \
-	debug.h \
-	osmo_signal.h \
-	config_defs.h
+	Logger.h

CommonLibs/PRBS.h

@@ -1,8 +1,6 @@
 /*
  * Copyright (C) 2017 Alexander Chemeris <Alexander.Chemeris@fairwaves.co>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -12,6 +10,10 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #ifndef PRBS_H

CommonLibs/Sockets.cpp

@@ -0,0 +1,287 @@
+/*
+* Copyright 2008, 2010 Free Software Foundation, Inc.
+*
+*
+* This software is distributed under the terms of the GNU Affero Public License.
+* See the COPYING file in the main directory for details.
+*
+* This use of this software may be subject to additional restrictions.
+* See the LEGAL file in the main directory for details.
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Affero General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Affero General Public License for more details.
+
+	You should have received a copy of the GNU Affero General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+
+
+#include <config.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <cstdio>
+#include <sys/select.h>
+
+#include "Threads.h"
+#include "Sockets.h"
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <string.h>
+#include <stdlib.h>
+
+
+
+
+
+
+bool resolveAddress(struct sockaddr_in *address, const char *hostAndPort)
+{
+	assert(address);
+	assert(hostAndPort);
+	char *copy = strdup(hostAndPort);
+	char *colon = strchr(copy,':');
+	if (!colon) return false;
+	*colon = '\0';
+	char *host = copy;
+	unsigned port = strtol(colon+1,NULL,10);
+	bool retVal = resolveAddress(address,host,port);
+	free(copy);
+	return retVal;
+}
+
+bool resolveAddress(struct sockaddr_in *address, const char *host, unsigned short port)
+{
+	assert(address);
+	assert(host);
+	// FIXME -- Need to ignore leading/trailing spaces in hostname.
+	struct hostent *hp;
+	int h_errno_local;
+#ifdef HAVE_GETHOSTBYNAME2_R
+	struct hostent hostData;
+	char tmpBuffer[2048];
+
+	// There are different flavors of gethostbyname_r(), but
+	// latest Linux use the following form:
+	if (gethostbyname2_r(host, AF_INET, &hostData, tmpBuffer, sizeof(tmpBuffer), &hp, &h_errno_local)!=0) {
+		CERR("WARNING -- gethostbyname2_r() failed for " << host << ", " << hstrerror(h_errno_local));
+		return false;
+	}
+#else
+	static Mutex sGethostbynameMutex;
+	// gethostbyname() is NOT thread-safe, so we should use a mutex here.
+	// Ideally it should be a global mutex for all non thread-safe socket
+	// operations and it should protect access to variables such as
+	// global h_errno.
+	sGethostbynameMutex.lock();
+	hp = gethostbyname(host);
+	h_errno_local = h_errno;
+	sGethostbynameMutex.unlock();
+#endif
+ 	if (hp==NULL) {
+		CERR("WARNING -- gethostbyname() failed for " << host << ", " << hstrerror(h_errno_local));
+		return false;
+	}
+	if (hp->h_addrtype != AF_INET) {
+		CERR("WARNING -- gethostbyname() resolved " << host << " to something other then AF_INET");
+ 		return false;
+ 	}
+	address->sin_family = hp->h_addrtype;
+	assert(sizeof(address->sin_addr) == hp->h_length);
+	memcpy(&(address->sin_addr), hp->h_addr_list[0], hp->h_length);
+	address->sin_port = htons(port);
+	return true;
+}
+
+
+
+DatagramSocket::DatagramSocket()
+{
+	memset(mDestination, 0, sizeof(mDestination));
+}
+
+
+
+
+
+void DatagramSocket::nonblocking()
+{
+	fcntl(mSocketFD,F_SETFL,O_NONBLOCK);
+}
+
+void DatagramSocket::blocking()
+{
+	fcntl(mSocketFD,F_SETFL,0);
+}
+
+void DatagramSocket::close()
+{
+	::close(mSocketFD);
+}
+
+
+DatagramSocket::~DatagramSocket()
+{
+	close();
+}
+
+
+
+
+
+int DatagramSocket::write( const char * message, size_t length )
+{
+	assert(length<=MAX_UDP_LENGTH);
+	int retVal = sendto(mSocketFD, message, length, 0,
+		(struct sockaddr *)mDestination, addressSize());
+	if (retVal == -1 ) perror("DatagramSocket::write() failed");
+	return retVal;
+}
+
+int DatagramSocket::writeBack( const char * message, size_t length )
+{
+	assert(length<=MAX_UDP_LENGTH);
+	int retVal = sendto(mSocketFD, message, length, 0,
+		(struct sockaddr *)mSource, addressSize());
+	if (retVal == -1 ) perror("DatagramSocket::write() failed");
+	return retVal;
+}
+
+
+
+int DatagramSocket::write( const char * message)
+{
+	size_t length=strlen(message)+1;
+	return write(message,length);
+}
+
+int DatagramSocket::writeBack( const char * message)
+{
+	size_t length=strlen(message)+1;
+	return writeBack(message,length);
+}
+
+
+
+int DatagramSocket::send(const struct sockaddr* dest, const char * message, size_t length )
+{
+	assert(length<=MAX_UDP_LENGTH);
+	int retVal = sendto(mSocketFD, message, length, 0, dest, addressSize());
+	if (retVal == -1 ) perror("DatagramSocket::send() failed");
+	return retVal;
+}
+
+int DatagramSocket::send(const struct sockaddr* dest, const char * message)
+{
+	size_t length=strlen(message)+1;
+	return send(dest,message,length);
+}
+
+int DatagramSocket::read(char* buffer, size_t length)
+{
+	socklen_t addr_len = sizeof(mSource);
+	int rd_length = recvfrom(mSocketFD, (void *) buffer, length, 0,
+		(struct sockaddr*) &mSource, &addr_len);
+
+	if ((rd_length==-1) && (errno!=EAGAIN)) {
+		perror("DatagramSocket::read() failed");
+		throw SocketError();
+	}
+	return rd_length;
+}
+
+int DatagramSocket::read(char* buffer, size_t length, unsigned timeout)
+{
+	fd_set fds;
+	FD_ZERO(&fds);
+	FD_SET(mSocketFD,&fds);
+	struct timeval tv;
+	tv.tv_sec = timeout/1000;
+	tv.tv_usec = (timeout%1000)*1000;
+	int sel = select(mSocketFD+1,&fds,NULL,NULL,&tv);
+	if (sel<0) {
+		perror("DatagramSocket::read() select() failed");
+		throw SocketError();
+	}
+	if (sel==0) return -1;
+	if (FD_ISSET(mSocketFD,&fds)) return read(buffer, length);
+	return -1;
+}
+
+
+
+
+
+
+UDPSocket::UDPSocket(const char *wSrcIP, unsigned short wSrcPort)
+	:DatagramSocket()
+{
+	open(wSrcPort, wSrcIP);
+}
+
+
+UDPSocket::UDPSocket(const char *wSrcIP, unsigned short wSrcPort,
+		     const char *wDestIP, unsigned short wDestPort)
+	:DatagramSocket()
+{
+	open(wSrcPort, wSrcIP);
+	destination(wDestPort, wDestIP);
+}
+
+
+
+void UDPSocket::destination( unsigned short wDestPort, const char * wDestIP )
+{
+	resolveAddress((sockaddr_in*)mDestination, wDestIP, wDestPort );
+}
+
+
+void UDPSocket::open(unsigned short localPort, const char *wlocalIP)
+{
+	// create
+	mSocketFD = socket(AF_INET,SOCK_DGRAM,0);
+	if (mSocketFD<0) {
+		perror("socket() failed");
+		throw SocketError();
+	}
+
+	// pat added: This lets the socket be reused immediately, which is needed if OpenBTS crashes.
+	int on = 1;
+	setsockopt(mSocketFD, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
+
+
+	// bind
+	struct sockaddr_in address;
+	size_t length = sizeof(address);
+	bzero(&address,length);
+	address.sin_family = AF_INET;
+	address.sin_addr.s_addr = inet_addr(wlocalIP);
+	address.sin_port = htons(localPort);
+	if (bind(mSocketFD,(struct sockaddr*)&address,length)<0) {
+		perror("bind() failed");
+		throw SocketError();
+	}
+}
+
+
+
+unsigned short UDPSocket::port() const
+{
+	struct sockaddr_in name;
+	socklen_t nameSize = sizeof(name);
+	int retVal = getsockname(mSocketFD, (struct sockaddr*)&name, &nameSize);
+	if (retVal==-1) throw SocketError();
+	return ntohs(name.sin_port);
+}
+
+// vim:ts=4:sw=4

CommonLibs/Sockets.h

@@ -0,0 +1,173 @@
+/*
+* Copyright 2008, 2010 Free Software Foundation, Inc.
+*
+* This software is distributed under the terms of the GNU Affero Public License.
+* See the COPYING file in the main directory for details.
+*
+* This use of this software may be subject to additional restrictions.
+* See the LEGAL file in the main directory for details.
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Affero General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Affero General Public License for more details.
+
+	You should have received a copy of the GNU Affero General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+
+#ifndef SOCKETS_H
+#define SOCKETS_H
+
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <errno.h>
+#include <list>
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+
+
+
+
+
+#define MAX_UDP_LENGTH 1500
+
+/** A function to resolve IP host names. */
+bool resolveAddress(struct sockaddr_in *address, const char *host, unsigned short port);
+
+/** Resolve an address of the form "<host>:<port>". */
+bool resolveAddress(struct sockaddr_in *address, const char *hostAndPort);
+
+/** An exception to throw when a critical socket operation fails. */
+class SocketError {};
+#define SOCKET_ERROR {throw SocketError(); }
+
+/** Abstract class for connectionless sockets. */
+class DatagramSocket {
+
+protected:
+
+	int mSocketFD;				///< underlying file descriptor
+	char mDestination[256];		///< address to which packets are sent
+	char mSource[256];		///< return address of most recent received packet
+
+public:
+
+	/** An almost-does-nothing constructor. */
+	DatagramSocket();
+
+	virtual ~DatagramSocket();
+
+	/** Return the address structure size for this socket type. */
+	virtual size_t addressSize() const = 0;
+
+	/**
+		Send a binary packet.
+		@param buffer The data bytes to send to mDestination.
+		@param length Number of bytes to send, or strlen(buffer) if defaulted to -1.
+		@return number of bytes written, or -1 on error.
+	*/
+	int write( const char * buffer, size_t length);
+
+	/**
+		Send a C-style string packet.
+		@param buffer The data bytes to send to mDestination.
+		@return number of bytes written, or -1 on error.
+	*/
+	int write( const char * buffer);
+
+	/**
+		Send a binary packet.
+		@param buffer The data bytes to send to mSource.
+		@param length Number of bytes to send, or strlen(buffer) if defaulted to -1.
+		@return number of bytes written, or -1 on error.
+	*/
+	int writeBack(const char * buffer, size_t length);
+
+	/**
+		Send a C-style string packet.
+		@param buffer The data bytes to send to mSource.
+		@return number of bytes written, or -1 on error.
+	*/
+	int writeBack(const char * buffer);
+
+
+	/**
+		Receive a packet.
+		@param buffer A char[MAX_UDP_LENGTH] procured by the caller.
+		@return The number of bytes received or -1 on non-blocking pass.
+	*/
+	int read(char* buffer, size_t length);
+
+	/**
+		Receive a packet with a timeout.
+		@param buffer A char[MAX_UDP_LENGTH] procured by the caller.
+		@param maximum wait time in milliseconds
+		@return The number of bytes received or -1 on timeout.
+	*/
+	int read(char* buffer, size_t length, unsigned timeout);
+
+
+	/** Send a packet to a given destination, other than the default. */
+	int send(const struct sockaddr *dest, const char * buffer, size_t length);
+
+	/** Send a C-style string to a given destination, other than the default. */
+	int send(const struct sockaddr *dest, const char * buffer);
+
+	/** Make the socket non-blocking. */
+	void nonblocking();
+
+	/** Make the socket blocking (the default). */
+	void blocking();
+
+	/** Close the socket. */
+	void close();
+
+};
+
+
+
+/** UDP/IP User Datagram Socket */
+class UDPSocket : public DatagramSocket {
+
+public:
+
+	/** Open a USP socket with an OS-assigned port and no default destination. */
+	UDPSocket(const char *localIP, unsigned short localPort);
+
+	/** Given a full specification, open the socket and set the dest address. */
+	UDPSocket(const char *localIP, unsigned short localPort,
+		  const char *remoteIP, unsigned short remotePort);
+
+	/** Set the destination port. */
+	void destination( unsigned short wDestPort, const char * wDestIP );
+
+	/** Return the actual port number in use. */
+	unsigned short port() const;
+
+	/** Open and bind the UDP socket to a local port. */
+	void open(unsigned short localPort=0, const char *wlocalIP="127.0.0.1");
+
+	/** Give the return address of the most recently received packet. */
+	const struct sockaddr_in* source() const { return (const struct sockaddr_in*)mSource; }
+
+	size_t addressSize() const { return sizeof(struct sockaddr_in); }
+
+};
+
+#endif
+
+
+
+// vim:ts=4:sw=4

CommonLibs/Threads.cpp

@@ -1,7 +1,6 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
 *
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
@@ -25,45 +24,85 @@
 */
 
 
-#include <string.h>
-#include <sys/types.h>
+
+
 
 #include "Threads.h"
 #include "Timeval.h"
-#include "Logger.h"
 
-extern "C" {
-#include <osmocom/core/thread.h>
-}
 
 using namespace std;
 
-#ifndef HAVE_ATOMIC_OPS
-	pthread_mutex_t atomic_ops_mutex = PTHREAD_MUTEX_INITIALIZER;
-#endif
 
 
 
-void set_selfthread_name(const char *name)
+Mutex gStreamLock;		///< Global lock to control access to cout and cerr.
+
+void lockCout()
 {
-	pthread_t selfid = pthread_self();
-	pid_t tid = osmo_gettid();
-	if (pthread_setname_np(selfid, name) == 0) {
-		LOG(INFO) << "Thread "<< selfid << " (task " << tid << ") set name: " << name;
-	} else {
-		char buf[256];
-		int err = errno;
-		char* err_str = strerror_r(err, buf, sizeof(buf));
-		LOG(NOTICE) << "Thread "<< selfid << " (task " << tid << ") set name \"" << name << "\" failed: (" << err << ") " << err_str;
-	}
+	gStreamLock.lock();
+	Timeval entryTime;
+	cout << entryTime << " " << pthread_self() << ": ";
 }
 
-void thread_enable_cancel(bool cancel)
+
+void unlockCout()
 {
-	cancel ? pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) :
-		 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+	cout << dec << endl << flush;
+	gStreamLock.unlock();
 }
 
+
+void lockCerr()
+{
+	gStreamLock.lock();
+	Timeval entryTime;
+	cerr << entryTime << " " << pthread_self() << ": ";
+}
+
+void unlockCerr()
+{
+	cerr << dec << endl << flush;
+	gStreamLock.unlock();
+}
+
+
+
+
+
+
+
+Mutex::Mutex()
+{
+	bool res;
+	res = pthread_mutexattr_init(&mAttribs);
+	assert(!res);
+	res = pthread_mutexattr_settype(&mAttribs,PTHREAD_MUTEX_RECURSIVE);
+	assert(!res);
+	res = pthread_mutex_init(&mMutex,&mAttribs);
+	assert(!res);
+}
+
+
+Mutex::~Mutex()
+{
+	pthread_mutex_destroy(&mMutex);
+	bool res = pthread_mutexattr_destroy(&mAttribs);
+	assert(!res);
+}
+
+
+
+
+/** Block for the signal up to the cancellation timeout. */
+void Signal::wait(Mutex& wMutex, unsigned timeout) const
+{
+	Timeval then(timeout);
+	struct timespec waitTime = then.timespec();
+	pthread_cond_timedwait(&mSignal,&wMutex.mMutex,&waitTime);
+}
+
+
 void Thread::start(void *(*task)(void*), void *arg)
 {
 	assert(mThread==((pthread_t)0));
@@ -71,10 +110,8 @@ void Thread::start(void *(*task)(void*), void *arg)
 	// (pat) Moved initialization to constructor to avoid crash in destructor.
 	//res = pthread_attr_init(&mAttrib);
 	//assert(!res);
-	if (mStackSize != 0) {
-		res = pthread_attr_setstacksize(&mAttrib, mStackSize);
-		assert(!res);
-	}
+	res = pthread_attr_setstacksize(&mAttrib, mStackSize);
+	assert(!res);
 	res = pthread_create(&mThread, &mAttrib, task, arg);
 	assert(!res);
 }

CommonLibs/Threads.h

@@ -1,8 +1,6 @@
 /*
 * Copyright 2008, 2011 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -28,96 +26,138 @@
 #ifndef THREADS_H
 #define THREADS_H
 
-#include <chrono>
-#include <mutex>
-#include <condition_variable>
 #include <pthread.h>
 #include <iostream>
-#include <cassert>
+#include <assert.h>
 #include <unistd.h>
 
-#include "config.h"
-#include "Timeval.h"
-
 class Mutex;
 
+
+/**@name Multithreaded access for standard streams. */
+//@{
+
+/**@name Functions for gStreamLock. */
+//@{
+extern Mutex gStreamLock;	///< global lock for cout and cerr
+void lockCerr();		///< call prior to writing cerr
+void unlockCerr();		///< call after writing cerr
+void lockCout();		///< call prior to writing cout
+void unlockCout();		///< call after writing cout
+//@}
+
+/**@name Macros for standard messages. */
+//@{
+#define COUT(text) { lockCout(); std::cout << text; unlockCout(); }
+#define CERR(text) { lockCerr(); std::cerr << __FILE__ << ":" << __LINE__ << ": " << text; unlockCerr(); }
+#ifdef NDEBUG
+#define DCOUT(text) {}
+#define OBJDCOUT(text) {}
+#else
+#define DCOUT(text) { COUT(__FILE__ << ":" << __LINE__ << " " << text); }
+#define OBJDCOUT(text) { DCOUT(this << " " << text); } 
+#endif
+//@}
+//@}
+
+
+
 /**@defgroup C++ wrappers for pthread mechanisms. */
 //@{
 
-/** A class for recursive mutexes. */
+/** A class for recursive mutexes based on pthread_mutex. */
 class Mutex {
-	std::recursive_mutex m;
 
-    public:
+	private:
 
-	void lock() {
-		m.lock();
-	}
+	pthread_mutex_t mMutex;
+	pthread_mutexattr_t mAttribs;
 
-	bool trylock() {
-		return m.try_lock();
-	}
+	public:
 
-	void unlock() {
-		m.unlock();
-	}
+	Mutex();
+
+	~Mutex();
+
+	void lock() { pthread_mutex_lock(&mMutex); }
+
+	bool trylock() { return pthread_mutex_trylock(&mMutex)==0; }
+
+	void unlock() { pthread_mutex_unlock(&mMutex); }
 
 	friend class Signal;
+
 };
 
+
 class ScopedLock {
-	Mutex &mMutex;
 
-    public:
-	ScopedLock(Mutex &wMutex) : mMutex(wMutex) {
-		mMutex.lock();
-	}
-	~ScopedLock() {
-		mMutex.unlock();
-	}
+	private:
+	Mutex& mMutex;
+
+	public:
+	ScopedLock(Mutex& wMutex) :mMutex(wMutex) { mMutex.lock(); }
+	~ScopedLock() { mMutex.unlock(); }
+
 };
 
-/** A C++ interthread signal. */
+
+
+
+/** A C++ interthread signal based on pthread condition variables. */
 class Signal {
-	/* any, because for some reason our mutex is recursive... */
-	std::condition_variable_any mSignal;
 
-    public:
+	private:
 
-	void wait(Mutex &wMutex, unsigned timeout) {
-		mSignal.wait_for(wMutex.m, std::chrono::milliseconds(timeout));
-	}
+	mutable pthread_cond_t mSignal;
 
-	void wait(Mutex &wMutex) {
-		mSignal.wait(wMutex.m);
-	}
+	public:
 
-	void signal() {
-		mSignal.notify_one();
-	}
+	Signal() { int s = pthread_cond_init(&mSignal,NULL); assert(!s); }
+
+	~Signal() { pthread_cond_destroy(&mSignal); }
+
+	/**
+		Block for the signal up to the cancellation timeout.
+		Under Linux, spurious returns are possible.
+	*/
+	void wait(Mutex& wMutex, unsigned timeout) const;
+
+	/**
+		Block for the signal.
+		Under Linux, spurious returns are possible.
+	*/
+	void wait(Mutex& wMutex) const
+		{ pthread_cond_wait(&mSignal,&wMutex.mMutex); }
+
+	void signal() { pthread_cond_signal(&mSignal); }
+
+	void broadcast() { pthread_cond_broadcast(&mSignal); }
 
-	void broadcast() {
-		mSignal.notify_all();
-	}
 };
 
-void set_selfthread_name(const char *name);
-void thread_enable_cancel(bool cancel);
+
+
+#define START_THREAD(thread,function,argument) \
+	thread.start((void *(*)(void*))function, (void*)argument);
 
 /** A C++ wrapper for pthread threads.  */
 class Thread {
-    private:
+
+	private:
+
 	pthread_t mThread;
 	pthread_attr_t mAttrib;
 	// FIXME -- Can this be reduced now?
 	size_t mStackSize;
 	
-    public:
+
+	public:
+
 	/** Create a thread in a non-running state. */
-	Thread(size_t wStackSize = 0) : mThread((pthread_t)0)
-	{
-		pthread_attr_init(&mAttrib); // (pat) moved this here.
-		mStackSize = wStackSize;
+	Thread(size_t wStackSize = (65536*4)):mThread((pthread_t)0) {
+		pthread_attr_init(&mAttrib);	// (pat) moved this here.
+		mStackSize=wStackSize;
 	}
 
 	/**
@@ -125,54 +165,26 @@ class Thread {
 		It should be stopped and joined.
 	*/
 	// (pat) If the Thread is destroyed without being started, then mAttrib is undefined.  Oops.
-	~Thread()
-	{
-		pthread_attr_destroy(&mAttrib);
-	}
+	~Thread() { pthread_attr_destroy(&mAttrib); }
+
 
 	/** Start the thread on a task. */
-	void start(void *(*task)(void *), void *arg);
+	void start(void *(*task)(void*), void *arg);
 
 	/** Join a thread that will stop on its own. */
-	void join()
-	{
+	void join() {
 		if (mThread) {
 			int s = pthread_join(mThread, NULL);
 			assert(!s);
 		}
 	}
 
-	/** Send cancellation to thread */
-	void cancel()
-	{
-		pthread_cancel(mThread);
-	}
+	/** Send cancelation to thread */
+	void cancel() { pthread_cancel(mThread); }
 };
 
-#ifdef HAVE_ATOMIC_OPS
-#define osmo_trx_sync_fetch_and_and(ptr, value) __sync_fetch_and_and((ptr), (value))
-#define osmo_trx_sync_or_and_fetch(ptr, value) __sync_or_and_fetch((ptr), (value))
-#else
-extern pthread_mutex_t atomic_ops_mutex;
-static inline int osmo_trx_sync_fetch_and_and(int *ptr, int value)
-{
-	pthread_mutex_lock(&atomic_ops_mutex);
-	int tmp = *ptr;
-	*ptr &= value;
-	pthread_mutex_unlock(&atomic_ops_mutex);
-	return tmp;
-}
 
-static inline int osmo_trx_sync_or_and_fetch(int *ptr, int value)
-{
-	int tmp;
-	pthread_mutex_lock(&atomic_ops_mutex);
-	*ptr |= value;
-	tmp = *ptr;
-	pthread_mutex_unlock(&atomic_ops_mutex);
-	return tmp;
-}
-#endif
+
 
 #endif
 // vim: ts=4 sw=4

CommonLibs/Timeval.cpp

@@ -1,7 +1,6 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
 *
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
@@ -28,49 +27,43 @@
 
 #include "Timeval.h"
 
-extern "C" {
-#include <osmocom/core/timer.h>
-}
-
 using namespace std;
 
-void Timeval::now()
-{
-	osmo_clock_gettime(CLOCK_REALTIME, &mTimespec);
-}
-
 void Timeval::future(unsigned offset)
 {
 	now();
 	unsigned sec = offset/1000;
 	unsigned msec = offset%1000;
-	mTimespec.tv_nsec += msec*1000*1000;
-	mTimespec.tv_sec += sec;
-	if (mTimespec.tv_nsec > 1000*1000*1000) {
-		mTimespec.tv_nsec -= 1000*1000*1000;
-		mTimespec.tv_sec += 1;
+	mTimeval.tv_usec += msec*1000;
+	mTimeval.tv_sec += sec;
+	if (mTimeval.tv_usec>1000000) {
+		mTimeval.tv_usec -= 1000000;
+		mTimeval.tv_sec += 1;
 	}
 }
 
 
 struct timespec Timeval::timespec() const
 {
-	return mTimespec;
+	struct timespec retVal;
+	retVal.tv_sec = mTimeval.tv_sec;
+	retVal.tv_nsec = 1000 * (long)mTimeval.tv_usec;
+	return retVal;
 }
 
 
 bool Timeval::passed() const
 {
 	Timeval nowTime;
-	if (nowTime.mTimespec.tv_sec < mTimespec.tv_sec) return false;
-	if (nowTime.mTimespec.tv_sec > mTimespec.tv_sec) return true;
-	if (nowTime.mTimespec.tv_nsec >= mTimespec.tv_nsec) return true;
+	if (nowTime.mTimeval.tv_sec < mTimeval.tv_sec) return false;
+	if (nowTime.mTimeval.tv_sec > mTimeval.tv_sec) return true;
+	if (nowTime.mTimeval.tv_usec > mTimeval.tv_usec) return true;
 	return false;
 }
 
 double Timeval::seconds() const
 {
-	return ((double)mTimespec.tv_sec) + 1e-9*((double)mTimespec.tv_nsec);
+	return ((double)mTimeval.tv_sec) + 1e-6*((double)mTimeval.tv_usec);
 }
 
 
@@ -79,8 +72,8 @@ long Timeval::delta(const Timeval& other) const
 {
 	// 2^31 milliseconds is just over 4 years.
 	int32_t deltaS = other.sec() - sec();
-	int32_t deltaNs = other.nsec() - nsec();
-	return 1000*deltaS + deltaNs/1000000;
+	int32_t deltaUs = other.usec() - usec();
+	return 1000*deltaS + deltaUs/1000;
 }
 	
 
@@ -88,16 +81,15 @@ long Timeval::delta(const Timeval& other) const
 
 ostream& operator<<(ostream& os, const Timeval& tv)
 {
-	ios_base::fmtflags flags_backup = os.setf( ios::fixed, ios::floatfield );
+	os.setf( ios::fixed, ios::floatfield );
 	os << tv.seconds();
-	os.flags( flags_backup );
 	return os;
 }
 
 
 ostream& operator<<(ostream& os, const struct timespec& ts)
 {
-	os << ts.tv_sec << "," << ts.tv_nsec/1000;
+	os << ts.tv_sec << "," << ts.tv_nsec;
 	return os;
 }
 

CommonLibs/Timeval.h

@@ -1,8 +1,6 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -44,12 +42,12 @@ class Timeval {
 
 	private:
 
-	struct timespec mTimespec;
+	struct timeval mTimeval;
 
 	public:
 
-	/** Set the value to current time. */
-	void now();
+	/** Set the value to gettimeofday. */
+	void now() { gettimeofday(&mTimeval,NULL); }
 
 	/** Set the value to gettimeofday plus an offset. */
 	void future(unsigned ms);
@@ -57,18 +55,16 @@ class Timeval {
 	//@{
 	Timeval(unsigned sec, unsigned usec)
 	{
-		mTimespec.tv_sec = sec;
-		mTimespec.tv_nsec = usec*1000;
+		mTimeval.tv_sec = sec;
+		mTimeval.tv_usec = usec;
 	}
 
 	Timeval(const struct timeval& wTimeval)
-	{
-		mTimespec.tv_sec = wTimeval.tv_sec;
-		mTimespec.tv_nsec = wTimeval.tv_sec*1000;
-	}
+		:mTimeval(wTimeval)
+	{}
 
 	/**
-		Create a Timespec offset into the future.
+		Create a Timeval offset into the future.
 		@param offset milliseconds
 	*/
 	Timeval(unsigned offset=0) { future(offset); }
@@ -80,11 +76,10 @@ class Timeval {
 	/** Return total seconds. */
 	double seconds() const;
 
-	uint32_t sec() const { return mTimespec.tv_sec; }
-	uint32_t usec() const { return mTimespec.tv_nsec / 1000; }
-	uint32_t nsec() const { return mTimespec.tv_nsec; }
+	uint32_t sec() const { return mTimeval.tv_sec; }
+	uint32_t usec() const { return mTimeval.tv_usec; }
 
-	/** Return difference from other (other-self), in ms. */
+	/** Return differnce from other (other-self), in ms. */
 	long delta(const Timeval& other) const;
 
 	/** Elapsed time in ms. */
@@ -93,11 +88,11 @@ class Timeval {
 	/** Remaining time in ms. */
 	long remaining() const { return -elapsed(); }
 
-	/** Return true if the time has passed, as per clock_gettime(CLOCK_REALTIME). */
+	/** Return true if the time has passed, as per gettimeofday. */
 	bool passed() const;
 
 	/** Add a given number of minutes to the time. */
-	void addMinutes(unsigned minutes) { mTimespec.tv_sec += minutes*60; }
+	void addMinutes(unsigned minutes) { mTimeval.tv_sec += minutes*60; }
 
 };
 

CommonLibs/Utils.cpp

@@ -1,34 +0,0 @@
-/*
- * Copyright 2018 sysmocom - s.f.m.c. GmbH
- *
- * SPDX-License-Identifier: LGPL-2.1+
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- */
-
-#include <vector>
-#include <string>
-#include <sstream>
-
-std::vector<std::string> comma_delimited_to_vector(const char* opt)
-{
-	std::string str = std::string(opt);
-	std::vector<std::string> result;
-	std::stringstream ss(str);
-
-	while( ss.good() )
-	{
-	    std::string substr;
-	    getline(ss, substr, ',');
-	    result.push_back(std::move(substr));
-	}
-	return result;
-}

CommonLibs/Utils.h

@@ -1,22 +0,0 @@
-/*
- * Copyright 2018 sysmocom - s.f.m.c. GmbH
- *
- * SPDX-License-Identifier: LGPL-2.1+
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- */
-
-#pragma once
-
-#include <vector>
-#include <string>
-
-std::vector<std::string> comma_delimited_to_vector(const char* opt);

CommonLibs/Vector.h

@@ -2,8 +2,6 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -34,19 +32,11 @@
 #include <string.h>
 #include <iostream>
 #include <assert.h>
-#include <stdlib.h>
-
-#ifndef __OPTIMIZE__
-#define assert_no_opt(x) assert(x)
-#else
-#define assert_no_opt(x)
-#endif
-// We can't use Logger.h in this file...
+// We cant use Logger.h in this file...
 extern int gVectorDebug;
 #define BVDEBUG(msg) if (gVectorDebug) {std::cout << msg;}
 
-typedef void (*vector_free_func)(void* wData);
-typedef void *(*vector_alloc_func)(size_t newSize);
+
 
 /**
 	A simplified Vector template with aliases.
@@ -70,8 +60,6 @@ template <class T> class Vector {
 	T* mData;		///< allocated data block, if any
 	T* mStart;		///< start of useful data
 	T* mEnd;		///< end of useful data + 1
-	vector_alloc_func mAllocFunc; ///< function used to alloc new mData during resize.
-	vector_free_func mFreeFunc; ///< function used to free mData.
 
 	public:
 
@@ -86,8 +74,8 @@ template <class T> class Vector {
 	/** Return the size of the Vector. */
 	size_t size() const
 	{
-		assert_no_opt(mStart>=mData);
-		assert_no_opt(mEnd>=mStart);
+		assert(mStart>=mData);
+		assert(mEnd>=mStart);
 		return mEnd - mStart;
 	}
 
@@ -97,19 +85,9 @@ template <class T> class Vector {
 	/** Change the size of the Vector, discarding content. */
 	void resize(size_t newSize)
 	{
-		if (mData!=NULL) {
-			if (mFreeFunc)
-				mFreeFunc(mData);
-			else
-				delete[] mData;
-		}
+		if (mData!=NULL) delete[] mData;
 		if (newSize==0) mData=NULL;
-		else {
-			if (mAllocFunc)
-				mData = (T*) mAllocFunc(newSize);
-			else
-				mData = new T[newSize];
-		}
+		else mData = new T[newSize];
 		mStart = mData;
 		mEnd = mStart + newSize;
 	}
@@ -117,7 +95,7 @@ template <class T> class Vector {
 	/** Reduce addressable size of the Vector, keeping content. */
 	void shrink(size_t newSize)
 	{
-		assert_no_opt(newSize <= mEnd - mStart);
+		assert(newSize <= mEnd - mStart);
 		mEnd = mStart + newSize;
 	}
 
@@ -129,7 +107,7 @@ template <class T> class Vector {
 	void clone(const Vector<T>& other)
 	{
 		resize(other.size());
-		other.copyTo(*this);
+		memcpy(mData,other.mStart,other.bytes());
 	}
 
 
@@ -138,31 +116,29 @@ template <class T> class Vector {
 	//@{
 
 	/** Build an empty Vector of a given size. */
-	Vector(size_t wSize=0, vector_alloc_func wAllocFunc=NULL, vector_free_func wFreeFunc=NULL)
-		:mData(NULL), mAllocFunc(wAllocFunc), mFreeFunc(wFreeFunc)
-	{ resize(wSize); }
+	Vector(size_t wSize=0):mData(NULL) { resize(wSize); }
 
 	/** Build a Vector by moving another. */
 	Vector(Vector<T>&& other)
-		:mData(other.mData),mStart(other.mStart),mEnd(other.mEnd), mAllocFunc(other.mAllocFunc),  mFreeFunc(other.mFreeFunc)
+		:mData(other.mData),mStart(other.mStart),mEnd(other.mEnd)
 	{ other.mData=NULL; }
 
 	/** Build a Vector by copying another. */
-	Vector(const Vector<T>& other):mData(NULL), mAllocFunc(other.mAllocFunc), mFreeFunc(other.mFreeFunc) { clone(other); }
+	Vector(const Vector<T>& other):mData(NULL) { clone(other); }
 
 	/** Build a Vector with explicit values. */
-	Vector(T* wData, T* wStart, T* wEnd, vector_alloc_func wAllocFunc=NULL, vector_free_func wFreeFunc=NULL)
-		:mData(wData),mStart(wStart),mEnd(wEnd), mAllocFunc(wAllocFunc), mFreeFunc(wFreeFunc)
+	Vector(T* wData, T* wStart, T* wEnd)
+		:mData(wData),mStart(wStart),mEnd(wEnd)
 	{ }
 
 	/** Build a vector from an existing block, NOT to be deleted upon destruction. */
-	Vector(T* wStart, size_t span, vector_alloc_func wAllocFunc=NULL, vector_free_func wFreeFunc=NULL)
-		:mData(NULL),mStart(wStart),mEnd(wStart+span),mAllocFunc(wAllocFunc), mFreeFunc(wFreeFunc)
+	Vector(T* wStart, size_t span)
+		:mData(NULL),mStart(wStart),mEnd(wStart+span)
 	{ }
 
 	/** Build a Vector by concatenation. */
-	Vector(const Vector<T>& other1, const Vector<T>& other2, vector_alloc_func wAllocFunc=NULL, vector_free_func wFreeFunc=NULL)
-		:mData(NULL), mAllocFunc(wAllocFunc), mFreeFunc(wFreeFunc)
+	Vector(const Vector<T>& other1, const Vector<T>& other2)
+		:mData(NULL)
 	{
 		resize(other1.size()+other2.size());
 		memcpy(mStart, other1.mStart, other1.bytes());
@@ -186,8 +162,6 @@ template <class T> class Vector {
 		mData=other.mData;
 		mStart=other.mStart;
 		mEnd=other.mEnd;
-		mAllocFunc=other.mAllocFunc;
-		mFreeFunc=other.mFreeFunc;
 		other.mData=NULL;
 	}
 
@@ -204,7 +178,7 @@ template <class T> class Vector {
 	{
 		T* wStart = mStart + start;
 		T* wEnd = wStart + span;
-		assert_no_opt(wEnd<=mEnd);
+		assert(wEnd<=mEnd);
 		return Vector<T>(NULL,wStart,wEnd);
 	}
 
@@ -213,7 +187,7 @@ template <class T> class Vector {
 	{
 		T* wStart = mStart + start;
 		T* wEnd = wStart + span;
-		assert_no_opt(wEnd<=mEnd);
+		assert(wEnd<=mEnd);
 		return Vector<T>(NULL,wStart,wEnd);
 	}
 
@@ -230,15 +204,10 @@ template <class T> class Vector {
 	*/
 	void copyToSegment(Vector<T>& other, size_t start, size_t span) const
 	{
-		unsigned int i;
-		T* dst = other.mStart + start;
-		T* src = mStart;
-		assert_no_opt(dst+span<=other.mEnd);
-		assert_no_opt(mStart+span<=mEnd);
-		for (i = 0; i < span; i++, src++, dst++)
-			*dst = *src;
-		/*TODO if not non-trivially copiable type class, optimize:
-		memcpy(dst,mStart,span*sizeof(T)); */
+		T* base = other.mStart + start;
+		assert(base+span<=other.mEnd);
+		assert(mStart+span<=mEnd);
+		memcpy(base,mStart,span*sizeof(T));
 	}
 
 	/** Copy all of this Vector to a segment of another Vector. */
@@ -255,8 +224,8 @@ template <class T> class Vector {
 	void segmentCopyTo(Vector<T>& other, size_t start, size_t span) const
 	{
 		const T* base = mStart + start;
-		assert_no_opt(base+span<=mEnd);
-		assert_no_opt(other.mStart+span<=other.mEnd);
+		assert(base+span<=mEnd);
+		assert(other.mStart+span<=other.mEnd);
 		memcpy(other.mStart,base,span*sizeof(T));
 	}
 
@@ -270,8 +239,8 @@ template <class T> class Vector {
 	{
 		const T* baseFrom = mStart + from;
 		T* baseTo = mStart + to;
-		assert_no_opt(baseFrom+span<=mEnd);
-		assert_no_opt(baseTo+span<=mEnd);
+		assert(baseFrom+span<=mEnd);
+		assert(baseTo+span<=mEnd);
 		memmove(baseTo,baseFrom,span*sizeof(T));
 	}
 
@@ -285,7 +254,7 @@ template <class T> class Vector {
 	{
 		T* dp=mStart+start;
 		T* end=dp+length;
-		assert_no_opt(end<=mEnd);
+		assert(end<=mEnd);
 		while (dp<end) *dp++=val;
 	}
 
@@ -297,13 +266,13 @@ template <class T> class Vector {
 
 	T& operator[](size_t index)
 	{
-		assert_no_opt(mStart+index<mEnd);
+		assert(mStart+index<mEnd);
 		return mStart[index];
 	}
 
 	const T& operator[](size_t index) const
 	{
-		assert_no_opt(mStart+index<mEnd);
+		assert(mStart+index<mEnd);
 		return mStart[index];
 	}
 

CommonLibs/config_defs.h

@@ -1,71 +0,0 @@
-#pragma once
-
-/*
- * This file contains structures used by both VTY (C, dir CommonLibs) and
- * osmo-trx (CXX, dir Transceiver52)
- */
-
-#include <stdbool.h>
-
-enum FillerType {
-  FILLER_DUMMY,
-  FILLER_ZERO,
-  FILLER_NORM_RAND,
-  FILLER_EDGE_RAND,
-  FILLER_ACCESS_RAND,
-};
-
-enum ReferenceType {
-  REF_INTERNAL,
-  REF_EXTERNAL,
-  REF_GPS,
-};
-
-/* Maximum number of physical RF channels */
-#define TRX_CHAN_MAX 8
-
-struct trx_ctx;
-
-struct trx_chan {
-	struct trx_ctx *trx; /* backpointer */
-	unsigned int idx; /* channel index */
-	char *rx_path;
-	char *tx_path;
-};
-
-struct trx_cfg {
-	char *bind_addr;
-	char *remote_addr;
-	char *dev_args;
-	unsigned int base_port;
-	unsigned int tx_sps;
-	unsigned int rx_sps;
-	unsigned int rtsc;
-	unsigned int rach_delay;
-	enum ReferenceType clock_ref;
-	enum FillerType filler;
-	bool multi_arfcn;
-	double offset;
-	double freq_offset_khz;
-	double rssi_offset;
-	int ul_fn_offset;
-	bool force_rssi_offset; /* Force value set in VTY? */
-	bool swap_channels;
-	bool ext_rach;
-	bool egprs;
-	unsigned int sched_rr;
-	unsigned int stack_size;
-	unsigned int num_chans;
-	struct trx_chan chans[TRX_CHAN_MAX];
-	struct {
-		bool ul_freq_override;
-		bool dl_freq_override;
-		bool ul_gain_override;
-		bool dl_gain_override;
-		double ul_freq;
-		double dl_freq;
-		double ul_gain;
-		double dl_gain;
-	} overrides;
-	bool use_va;
-};

CommonLibs/debug.c

@@ -1,83 +0,0 @@
-/*
- * Copyright (C) 2018-2019 sysmocom - s.f.m.c. GmbH
- * All Rights Reserved
- *
- * SPDX-License-Identifier: AGPL-3.0+
- *
- * Author: Pau Espin Pedrol <pespin@sysmocom.de>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- * See the COPYING file in the main directory for details.
- */
-
-#include <osmocom/core/logging.h>
-#include <osmocom/core/utils.h>
-#include "debug.h"
-
-/* default categories */
-static const struct log_info_cat default_categories[] = {
-	[DMAIN] = {
-		.name = "DMAIN",
-		.description = "Main generic category",
-		.color = NULL,
-		.enabled = 1, .loglevel = LOGL_NOTICE,
-	},
-	[DTRXCLK] = {
-			.name = "DTRXCLK",
-			.description = "TRX Master Clock",
-			.color = NULL,
-			.enabled = 1, .loglevel = LOGL_NOTICE,
-	},
-	[DTRXCTRL] = {
-			.name = "DTRXCTRL",
-			.description = "TRX CTRL interface",
-			.color = "\033[1;33m",
-			.enabled = 1, .loglevel = LOGL_NOTICE,
-	},
-	[DTRXDDL] = {
-			.name = "DTRXDDL",
-			.description = "TRX Data interface Downlink",
-			.color = NULL,
-			.enabled = 1, .loglevel = LOGL_NOTICE,
-	},
-	[DTRXDUL] = {
-			.name = "DTRXDUL",
-			.description = "TRX CTRL interface Uplink",
-			.color = NULL,
-			.enabled = 1, .loglevel = LOGL_NOTICE,
-	},
-	[DDEV] = {
-		.name = "DDEV",
-		.description = "Device/Driver specific code",
-		.color = NULL,
-		.enabled = 1, .loglevel = LOGL_NOTICE,
-	},
-	[DDEVDRV] = {
-		.name = "DDEVDRV",
-		.description = "Logging from external device driver library implementing lower level specifics",
-		.color = NULL,
-		.enabled = 1, .loglevel = LOGL_NOTICE,
-	},
-	[DCTR] = {
-		.name = "DCTR",
-		.description = "Rate counter related logging",
-		.color = NULL,
-		.enabled = 1, .loglevel = LOGL_NOTICE,
-	},
-};
-
-const struct log_info log_info = {
-	.cat = default_categories,
-	.num_cat = ARRAY_SIZE(default_categories),
-};

CommonLibs/debug.h

@@ -1,23 +0,0 @@
-#pragma once
-
-#include <stdbool.h>
-
-#include <osmocom/core/logging.h>
-
-extern const struct log_info log_info;
-
-/* Debug Areas of the code */
-enum {
-	DMAIN,
-	DTRXCLK,
-	DTRXCTRL,
-	DTRXDDL,
-	DTRXDUL,
-	DDEV,
-	DDEVDRV,
-	DCTR,
-};
-
-#define CLOGCHAN(chan, category, level, fmt, args...) do { \
-	LOGP(category, level, "[chan=%zu] " fmt, chan, ##args);  \
-} while(0)

CommonLibs/osmo_signal.h

@@ -1,71 +0,0 @@
-/* Generic signalling/notification infrastructure */
-/* (C) 2018 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
- *
- * Author: Pau Espin Pedrol <pespin@sysmocom.de>
- *
- * All Rights Reserved
- *
- * SPDX-License-Identifier: AGPL-3.0+
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#pragma once
-
-#include <osmocom/core/signal.h>
-
-/* Signalling subsystems */
-enum signal_subsystems {
-	SS_MAIN,
-	SS_DEVICE,
-};
-
-/* SS_MAIN signals */
-enum SS_MAIN {
-	S_MAIN_STOP_REQUIRED, /* TRX fatal error, it should be stopped */
-};
-
-/* SS_DEVICE signals */
-enum SS_DEVICE {
-	/* Device internal counters changed. Counters are provided as cb data
-	   (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> */
-struct device_counters {
-	size_t chan;
-	unsigned int rx_overruns;
-	unsigned int tx_underruns;
-	unsigned int rx_dropped_events;
-	unsigned int rx_dropped_samples;
-	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

@@ -1,409 +0,0 @@
-/*
- * Copyright (C) 2019 sysmocom - s.f.m.c. GmbH
- * All Rights Reserved
- *
- * SPDX-License-Identifier: AGPL-3.0+
- *
- * Author: Pau Espin Pedrol <pespin@sysmocom.de>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- * See the COPYING file in the main directory for details.
- */
-
-/*
- * rate_ctr API uses several osmocom select loop features, and as a result,
- * calls to it must be done through the main thread (the one running the osmocom
- * loop in osmo-trx).
- * Since read/write from/to SDR is done in separate threads (even read and write
- * each use a different thread), we must use some sort of message passing system
- * between main thread feeding rate_ctr structures and the Rx/Tx threads
- * generating the events.
- * The idea is that upon read/write issues, lower layers (SDR APIs) provide us with
- * underrun/overrun/droppedPackets information, and in that case we pass that up
- * the stack through signal <SS_DEVICE,S_DEVICE_COUNTER_CHANGE> with signal_cb
- * being a pointer to a "struct device_counters" structure, which contains
- * device (implementation agnostic) statful counters for different kind of
- * statistics.
- * That signal is processed here in device_sig_cb, where a copy of the "struct
- * device_counters" structure is held and the main thread is instructed through
- * a timerfd to update rate_ctr APIs against this copy. All this is done inside
- * a mutex to avoid different race conditions (between Rx andTx threads, and
- * between Rx/Tx and main thread). For the same reason, callers of signal
- * <SS_DEVICE,S_DEVICE_COUNTER_CHANGE> (device_sig_cb), that is Rx/Tx threads,
- * must do so with PTHREAD_CANCEL_DISABLE, in order to avoid possible deadlocks
- * in case the main thread decides to cancel other threads due to a shutdown
- * operation (fi SIGKILL received)
- */
-
-#include <string.h>
-#include <stdint.h>
-#include <inttypes.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-
-extern "C" {
-#include <osmocom/core/talloc.h>
-#include <osmocom/core/utils.h>
-#include <osmocom/core/rate_ctr.h>
-#include <osmocom/core/select.h>
-#include <osmocom/core/stats.h>
-#include <osmocom/core/timer.h>
-
-#include "osmo_signal.h"
-#include "trx_vty.h"
-#include "trx_rate_ctr.h"
-}
-#include "Threads.h"
-#include "Logger.h"
-
-/* 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* dev_ctrs_pending;
-static struct trx_counters* trx_ctrs_pending;
-static size_t chan_len;
-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 unsigned int threshold_timer_sched_secs;
-static bool threshold_initied;
-
-const struct value_string rate_ctr_intv[] = {
-	{ RATE_CTR_INTV_SEC,	"per-second" },
-	{ RATE_CTR_INTV_MIN,	"per-minute" },
-	{ RATE_CTR_INTV_HOUR,	"per-hour" },
-	{ RATE_CTR_INTV_DAY, 	"per-day" },
-	{ 0, NULL }
-};
-
-const struct value_string trx_chan_ctr_names[] = {
-	{ 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_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 = {
-	.group_name_prefix		= "trx:chan",
-	.group_description		= "osmo-trx statistics",
-	.class_id			= OSMO_STATS_CLASS_GLOBAL,
-	.num_ctr			= ARRAY_SIZE(trx_chan_ctr_desc),
-	.ctr_desc			= trx_chan_ctr_desc,
-};
-
-static int dev_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 Device counters";
-	dev_rate_ctr_mutex.lock();
-	for (chan = 0; chan < chan_len; chan++) {
-		if (dev_ctrs_pending[chan].chan == PENDING_CHAN_NONE)
-			continue;
-		LOGCHAN(chan, DCTR, DEBUG) << "rate_ctr update";
-		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_RX_OVERRUNS);
-		rate_ctr_add(ctr, dev_ctrs_pending[chan].rx_overruns - ctr->current);
-		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_TX_UNDERRUNS);
-		rate_ctr_add(ctr, dev_ctrs_pending[chan].tx_underruns - ctr->current);
-		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_RX_DROP_EV);
-		rate_ctr_add(ctr, dev_ctrs_pending[chan].rx_dropped_events - ctr->current);
-		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_RX_DROP_SMPL);
-		rate_ctr_add(ctr, dev_ctrs_pending[chan].rx_dropped_samples - ctr->current);
-		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_TX_DROP_EV);
-		rate_ctr_add(ctr, dev_ctrs_pending[chan].tx_dropped_events - ctr->current);
-		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_TX_DROP_SMPL);
-		rate_ctr_add(ctr, dev_ctrs_pending[chan].tx_dropped_samples - ctr->current);
-
-		/* Mark as done */
-		dev_ctrs_pending[chan].chan = PENDING_CHAN_NONE;
-	}
-	if (osmo_timerfd_disable(&dev_rate_ctr_timerfd) < 0)
-		LOGC(DCTR, ERROR) << "Failed to disable timerfd";
-	dev_rate_ctr_mutex.unlock();
-	return 0;
-}
-
-static int trx_rate_ctr_timerfd_cb(struct osmo_fd *ofd, unsigned int what) {
-	size_t chan;
-	struct rate_ctr *ctr;
-	LOGC(DCTR, INFO) << "Main thread is updating Transceiver counters";
-	trx_rate_ctr_mutex.lock();
-	for (chan = 0; chan < chan_len; chan++) {
-		if (trx_ctrs_pending[chan].chan == PENDING_CHAN_NONE)
-			continue;
-		LOGCHAN(chan, DCTR, DEBUG) << "rate_ctr update";
-		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TX_STALE_BURSTS);
-		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_stale_bursts - ctr->current);
-		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TX_UNAVAILABLE_BURSTS);
-		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_unavailable_bursts - ctr->current);
-		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TRXD_FN_REPEATED);
-		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_trxd_fn_repeated - ctr->current);
-		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TRXD_FN_OUTOFORDER);
-		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_trxd_fn_outoforder - ctr->current);
-		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TRXD_FN_SKIPPED);
-		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_trxd_fn_skipped - ctr->current);
-		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_RX_EMPTY_BURST);
-		rate_ctr_add(ctr, trx_ctrs_pending[chan].rx_empty_burst - ctr->current);
-		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_RX_CLIPPING);
-		rate_ctr_add(ctr, trx_ctrs_pending[chan].rx_clipping - ctr->current);
-		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_RX_NO_BURST_DETECTED);
-		rate_ctr_add(ctr, trx_ctrs_pending[chan].rx_no_burst_detected - ctr->current);
-		/* Mark as done */
-		trx_ctrs_pending[chan].chan = PENDING_CHAN_NONE;
-	}
-	if (osmo_timerfd_disable(&trx_rate_ctr_timerfd) < 0)
-		LOGC(DCTR, ERROR) << "Failed to disable timerfd";
-	trx_rate_ctr_mutex.unlock();
-	return 0;
-}
-
-/* Callback function to be called every time we receive a signal from DEVICE */
-static int device_sig_cb(unsigned int subsys, unsigned int signal,
-			 void *handler_data, void *signal_data)
-{
-	struct device_counters *dev_ctr;
-	struct trx_counters *trx_ctr;
-	/* Delay sched around 20 ms, in case we receive several calls from several
-	 * channels batched */
-	struct timespec next_sched = {.tv_sec = 0, .tv_nsec = 20*1000*1000};
-	/* no automatic re-trigger */
-	struct timespec intv_sched = {.tv_sec = 0, .tv_nsec = 0};
-	char err_buf[256];
-
-	switch (signal) {
-	case S_DEVICE_COUNTER_CHANGE:
-		dev_ctr = (struct device_counters *)signal_data;
-		LOGCHAN(dev_ctr->chan, DCTR, INFO) << "Received counter change from radioDevice";
-		dev_rate_ctr_mutex.lock();
-		dev_ctrs_pending[dev_ctr->chan] = *dev_ctr;
-		if (osmo_timerfd_schedule(&dev_rate_ctr_timerfd, &next_sched, &intv_sched) < 0) {
-			LOGC(DCTR, ERROR) << "Failed to schedule timerfd: " << errno
-					  << " = "<< strerror_r(errno, err_buf, sizeof(err_buf));
-		}
-		dev_rate_ctr_mutex.unlock();
-		break;
-	case S_TRX_COUNTER_CHANGE:
-		trx_ctr = (struct trx_counters *)signal_data;
-		LOGCHAN(trx_ctr->chan, DCTR, INFO) << "Received counter change from Transceiver";
-		trx_rate_ctr_mutex.lock();
-		trx_ctrs_pending[trx_ctr->chan] = *trx_ctr;
-		if (osmo_timerfd_schedule(&trx_rate_ctr_timerfd, &next_sched, &intv_sched) < 0) {
-			LOGC(DCTR, ERROR) << "Failed to schedule timerfd: " << errno
-					  << " = "<< strerror_r(errno, err_buf, sizeof(err_buf));
-		}
-		trx_rate_ctr_mutex.unlock();
-		break;
-	default:
-		break;
-	}
-	return 0;
-}
-
-/************************************
- * ctr_threshold  APIs
- ************************************/
-static const char* ctr_threshold_2_vty_str(struct ctr_threshold *ctr)
-{
-	static char buf[256];
-	int rc = 0;
-	rc += snprintf(buf, sizeof(buf), "ctr-error-threshold %s", get_value_string(trx_chan_ctr_names, ctr->ctr_id));
-	rc += snprintf(buf + rc, sizeof(buf) - rc, " %d %s", ctr->val, get_value_string(rate_ctr_intv, ctr->intv));
-	return buf;
-}
-
-static void threshold_timer_cb(void *data)
-{
-	struct ctr_threshold *ctr_thr;
-	struct rate_ctr *rate_ctr;
-	size_t chan;
-	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_ctr_group_get_ctr(rate_ctrs[chan], ctr_thr->ctr_id);
-			LOGCHAN(chan, DCTR, INFO) << "checking threshold: " << ctr_threshold_2_vty_str(ctr_thr)
-						   << " ("<< rate_ctr->intv[ctr_thr->intv].rate << " vs " << ctr_thr->val << ")";
-			if (rate_ctr->intv[ctr_thr->intv].rate >= ctr_thr->val) {
-				LOGCHAN(chan, 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;
-			}
-		}
-	}
-	osmo_timer_schedule(&threshold_timer, threshold_timer_sched_secs, 0);
-}
-
-static size_t ctr_threshold_2_seconds(struct ctr_threshold *ctr)
-{
-	size_t mult = 0;
-	switch (ctr->intv) {
-	case RATE_CTR_INTV_SEC:
-		mult = 1;
-		break;
-	case RATE_CTR_INTV_MIN:
-		mult = 60;
-		break;
-	case RATE_CTR_INTV_HOUR:
-		mult = 60*60;
-		break;
-	case RATE_CTR_INTV_DAY:
-		mult = 60*60*24;
-		break;
-	default:
-		OSMO_ASSERT(false);
-	}
-	return mult;
-}
-
-static void threshold_timer_update_intv() {
-	struct ctr_threshold *ctr, *min_ctr;
-	size_t secs, min_secs;
-
-	/* Avoid scheduling timer until itself and other structures are prepared
-	   by trx_rate_ctr_init */
-	if (!threshold_initied)
-		return;
-
-	if (llist_empty(&threshold_list)) {
-		osmo_timer_del(&threshold_timer);
-		return;
-	}
-
-	min_ctr = llist_first_entry(&threshold_list, struct ctr_threshold, list);
-	min_secs = ctr_threshold_2_seconds(min_ctr);
-
-	llist_for_each_entry(ctr, &threshold_list, list) {
-		secs = ctr_threshold_2_seconds(ctr);
-		if (min_secs > secs)
-			min_secs = secs;
-	}
-
-
-	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);
-}
-
-/* Init rate_ctr subsystem. Expected to be called during process start by main thread before VTY is ready */
-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;
-	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++) {
-		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, DCTR, ERROR) << "Failed to allocate rate ctr";
-			exit(1);
-		}
-	}
-	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);
-
-	/* Now set up threshold checks */
-	threshold_initied = true;
-	osmo_timer_setup(&threshold_timer, threshold_timer_cb, NULL);
-	threshold_timer_update_intv();
-}
-
-void trx_rate_ctr_threshold_add(struct ctr_threshold *ctr)
-{
-	struct ctr_threshold *new_ctr;
-
-	new_ctr = talloc_zero(trx_rate_ctr_ctx, struct ctr_threshold);
-	*new_ctr = *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();
-}
-
-int trx_rate_ctr_threshold_del(struct ctr_threshold *del_ctr)
-{
-	struct ctr_threshold *ctr;
-
-	llist_for_each_entry(ctr, &threshold_list, list) {
-		if (ctr->intv != del_ctr->intv ||
-		    ctr->ctr_id != del_ctr->ctr_id ||
-		    ctr->val != del_ctr->val)
-			continue;
-
-		LOGC(DCTR, NOTICE) << "Deleting threshold check: " << ctr_threshold_2_vty_str(del_ctr);
-		llist_del(&ctr->list);
-		talloc_free(ctr);
-		threshold_timer_update_intv();
-		return 0;
-	}
-	return -1;
-}
-
-void trx_rate_ctr_threshold_write_config(struct vty *vty, char *indent_prefix)
-{
-	struct ctr_threshold *ctr;
-
-	llist_for_each_entry(ctr, &threshold_list, list) {
-		vty_out(vty, "%s%s%s", indent_prefix, ctr_threshold_2_vty_str(ctr), VTY_NEWLINE);
-	}
-}

CommonLibs/trx_rate_ctr.h

@@ -1,38 +0,0 @@
-#pragma once
-
-#include <osmocom/core/rate_ctr.h>
-#include <osmocom/vty/command.h>
-
-enum TrxCtr {
-	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 {
-	/*! Linked list of all counter groups in the system */
-	struct llist_head list;
-	enum rate_ctr_intv intv;
-	enum TrxCtr ctr_id;
-	uint32_t val;
-};
-
-extern const struct value_string rate_ctr_intv[];
-extern const struct value_string trx_chan_ctr_names[];
-
-struct trx_ctx;
-void trx_rate_ctr_init(void *ctx, struct trx_ctx* trx_ctx);
-void trx_rate_ctr_threshold_add(struct ctr_threshold *ctr);
-int trx_rate_ctr_threshold_del(struct ctr_threshold *del_ctr);
-void trx_rate_ctr_threshold_write_config(struct vty *vty, char *indent_prefix);

CommonLibs/trx_vty.c

@@ -1,901 +0,0 @@
-/*
- * Copyright (C) 2018-2019 sysmocom - s.f.m.c. GmbH
- * All Rights Reserved
- *
- * SPDX-License-Identifier: AGPL-3.0+
- *
- * Author: Pau Espin Pedrol <pespin@sysmocom.de>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- * See the COPYING file in the main directory for details.
- */
-
-#include <string.h>
-#include <stdint.h>
-#include <inttypes.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-
-#include <osmocom/core/talloc.h>
-#include <osmocom/core/utils.h>
-#include <osmocom/core/rate_ctr.h>
-
-#include <osmocom/vty/command.h>
-#include <osmocom/vty/logging.h>
-#include <osmocom/vty/vty.h>
-#include <osmocom/vty/misc.h>
-
-#include "trx_rate_ctr.h"
-#include "trx_vty.h"
-#include "../config.h"
-
-static struct trx_ctx* g_trx_ctx;
-
-const struct value_string clock_ref_names[] = {
-	{ REF_INTERNAL,	"internal" },
-	{ REF_EXTERNAL,	"external" },
-	{ REF_GPS,	"gpsdo" },
-	{ 0,		NULL }
-};
-
-const struct value_string filler_names[] = {
-	{ FILLER_DUMMY,		"Dummy bursts (C0 only)" },
-	{ FILLER_ZERO,		"Empty bursts" },
-	{ FILLER_NORM_RAND,	"GMSK Normal Bursts with random payload" },
-	{ FILLER_EDGE_RAND,	"8-PSK Normal Bursts with random payload" },
-	{ FILLER_ACCESS_RAND,	"Access Bursts with random payload" },
-	{ 0,			NULL }
-};
-
-static const struct value_string filler_types[] = {
-	{ FILLER_DUMMY,		"dummy" },
-	{ FILLER_ZERO,		"zero" },
-	{ FILLER_NORM_RAND,	"random-nb-gmsk" },
-	{ FILLER_EDGE_RAND,	"random-nb-8psk" },
-	{ FILLER_ACCESS_RAND,	"random-ab" },
-	{ 0,			NULL }
-};
-
-static const struct value_string filler_docs[] = {
-	{ FILLER_DUMMY,		"Send a Dummy Burst on C0 (TRX0) and empty burst on other channels" },
-	{ FILLER_ZERO,		"Send an empty burst (default)" },
-	{ FILLER_NORM_RAND,	"Send a GMSK modulated Normal Burst with random bits (spectrum mask testing)" },
-	{ FILLER_EDGE_RAND,	"Send an 8-PSK modulated Normal Burst with random bits (spectrum mask testing)" },
-	{ FILLER_ACCESS_RAND,	"Send an Access Burst with random bits (Rx/Tx alignment testing)" },
-	{ 0,			NULL }
-};
-
-
-struct trx_ctx *trx_from_vty(struct vty *v)
-{
-        /* It can't hurt to force callers to continue to pass the vty instance
-         * to this function, in case we'd like to retrieve the global
-         * trx instance from the vty at some point in the future. But
-         * until then, just return the global pointer, which should have been
-         * initialized by trx_vty_init().
-         */
-        OSMO_ASSERT(g_trx_ctx);
-        return g_trx_ctx;
-}
-
-enum trx_vty_node {
-	TRX_NODE = _LAST_OSMOVTY_NODE + 1,
-	CHAN_NODE,
-};
-
-static struct cmd_node trx_node = {
-	TRX_NODE,
-	"%s(config-trx)# ",
-	1,
-};
-
-static struct cmd_node chan_node = {
-	CHAN_NODE,
-	"%s(config-trx-chan)# ",
-	1,
-};
-
-DEFUN(cfg_trx, cfg_trx_cmd,
-	"trx",
-	"Configure the TRX\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	if (!trx)
-		return CMD_WARNING;
-
-	vty->node = TRX_NODE;
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_bind_ip, cfg_bind_ip_cmd,
-	"bind-ip " VTY_IPV4_CMD,
-	"Set the IP address for the local bind\n"
-	"IPv4 Address\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	osmo_talloc_replace_string(trx, &trx->cfg.bind_addr, argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_remote_ip, cfg_remote_ip_cmd,
-	"remote-ip " VTY_IPV4_CMD,
-	"Set the IP address for the remote BTS\n"
-	"IPv4 Address\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	osmo_talloc_replace_string(trx, &trx->cfg.remote_addr, argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_base_port, cfg_base_port_cmd,
-	"base-port <1-65535>",
-	"Set the TRX Base Port\n"
-	"TRX Base Port\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.base_port = atoi(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_dev_args, cfg_dev_args_cmd,
-	"dev-args DESC",
-	"Set the device-specific arguments to pass to the device\n"
-	"Device-specific arguments\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	osmo_talloc_replace_string(trx, &trx->cfg.dev_args, argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_tx_sps, cfg_tx_sps_cmd,
-	"tx-sps (1|4)",
-	"Set the Tx Samples-per-Symbol\n"
-	"Tx Samples-per-Symbol\n"
-	"1 Sample-per-Symbol\n"
-	"4 Samples-per-Symbol\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.tx_sps = atoi(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_rx_sps, cfg_rx_sps_cmd,
-	"rx-sps (1|4)",
-	"Set the Rx Samples-per-Symbol\n"
-	"Rx Samples-per-Symbol\n"
-	"1 Sample-per-Symbol\n"
-	"4 Samples-per-Symbol\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.rx_sps = atoi(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_clock_ref, cfg_clock_ref_cmd,
-	"clock-ref (internal|external|gpsdo)",
-	"Set the Reference Clock\n"
-	"Enable internal reference (default)\n"
-	"Enable external 10 MHz reference\n"
-	"Enable GPSDO reference\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.clock_ref = get_string_value(clock_ref_names, argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_multi_arfcn, cfg_multi_arfcn_cmd,
-	"multi-arfcn (disable|enable)",
-	"Multi-ARFCN transceiver mode (default=disable)\n"
-	"Enable multi-ARFCN mode\n" "Disable multi-ARFCN mode\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	if (strcmp("disable", argv[0]) == 0) {
-		trx->cfg.multi_arfcn = false;
-		return CMD_SUCCESS;
-	}
-
-	if (trx->cfg.num_chans > TRX_MCHAN_MAX) {
-		vty_out(vty, "Up to %i channels are supported for multi-TRX mode%s",
-			TRX_MCHAN_MAX, VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-
-	trx->cfg.multi_arfcn = true;
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_offset, cfg_offset_cmd,
-	"offset FLOAT",
-	"Set the baseband frequency offset (default=0, auto)\n"
-	"Baseband Frequency Offset\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.offset = atof(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN_ATTR(cfg_freq_offset, cfg_freq_offset_cmd,
-	   "freq-offset FLOAT",
-	   "Apply an artificial offset to Rx/Tx carrier frequency\n"
-	   "Frequency offset in kHz (e.g. -145300)\n",
-	   CMD_ATTR_HIDDEN)
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.freq_offset_khz = atof(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_rssi_offset, cfg_rssi_offset_cmd,
-	"rssi-offset FLOAT [relative]",
-	"Set the RSSI to dBm offset in dB (default=0)\n"
-	"RSSI to dBm offset in dB\n"
-	"Add to the default rssi-offset value instead of completely replacing it\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.rssi_offset = atof(argv[0]);
-	trx->cfg.force_rssi_offset = (argc == 1);
-
-	return CMD_SUCCESS;
-}
-
-
-DEFUN_ATTR(cfg_ul_fn_offset, cfg_ul_fn_offset_cmd,
-	"ul-fn-offset <-10-10>",
-	"Adjusts the uplink frame FN by the specified amount\n"
-	"Frame Number offset\n",
-	CMD_ATTR_HIDDEN)
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.ul_fn_offset = atoi(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN_ATTR(cfg_ul_freq_override, cfg_ul_freq_override_cmd,
-	   "ul-freq-override FLOAT",
-	   "Overrides Rx carrier frequency\n"
-	   "Frequency in Hz (e.g. 145300000)\n",
-	   CMD_ATTR_HIDDEN)
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.overrides.ul_freq_override = true;
-	trx->cfg.overrides.ul_freq = atof(argv[0]);
-
-	return CMD_SUCCESS;
-}
-DEFUN_ATTR(cfg_dl_freq_override, cfg_dl_freq_override_cmd,
-	   "dl-freq-override FLOAT",
-	   "Overrides Tx carrier frequency\n"
-	   "Frequency in Hz (e.g. 145300000)\n",
-	   CMD_ATTR_HIDDEN)
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.overrides.dl_freq_override = true;
-	trx->cfg.overrides.dl_freq = atof(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN_ATTR(cfg_ul_gain_override, cfg_ul_gain_override_cmd,
-	   "ul-gain-override FLOAT",
-	   "Overrides Rx gain\n"
-	   "gain in dB\n",
-	   CMD_ATTR_HIDDEN)
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.overrides.ul_gain_override = true;
-	trx->cfg.overrides.ul_gain = atof(argv[0]);
-
-	return CMD_SUCCESS;
-}
-DEFUN_ATTR(cfg_dl_gain_override, cfg_dl_gain_override_cmd,
-	   "dl-gain-override FLOAT",
-	   "Overrides Tx gain\n"
-	   "gain in dB\n",
-	   CMD_ATTR_HIDDEN)
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.overrides.dl_gain_override = true;
-	trx->cfg.overrides.dl_gain = atof(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN_ATTR(cfg_use_viterbi, cfg_use_viterbi_cmd,
-	"viterbi-eq (disable|enable)",
-	"Use viterbi equalizer for gmsk (default=disable)\n"
-	"Disable VA\n"
-	"Enable VA\n",
-	CMD_ATTR_HIDDEN)
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	if (strcmp("disable", argv[0]) == 0)
-		trx->cfg.use_va = false;
-	else if (strcmp("enable", argv[0]) == 0)
-		trx->cfg.use_va = true;
-	else
-		return CMD_WARNING;
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_swap_channels, cfg_swap_channels_cmd,
-	"swap-channels (disable|enable)",
-	"Swap primary and secondary channels of the PHY (if any)\n"
-	"Do not swap primary and secondary channels (default)\n"
-	"Swap primary and secondary channels\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	if (strcmp("disable", argv[0]) == 0) {
-		trx->cfg.swap_channels = false;
-	} else if (strcmp("enable", argv[0]) == 0) {
-		trx->cfg.swap_channels = true;
-	} else {
-		return CMD_WARNING;
-	}
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_egprs, cfg_egprs_cmd,
-	"egprs (disable|enable)",
-	"EGPRS (8-PSK demodulation) support (default=disable)\n"
-	"Disable EGPRS (8-PSK demodulation) support\n"
-	"Enable EGPRS (8-PSK demodulation) support\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	if (strcmp("disable", argv[0]) == 0) {
-		trx->cfg.egprs = false;
-	} else if (strcmp("enable", argv[0]) == 0) {
-		trx->cfg.egprs = true;
-	} else {
-		return CMD_WARNING;
-	}
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_ext_rach, cfg_ext_rach_cmd,
-	"ext-rach (disable|enable)",
-	"11-bit Access Burst correlation support (default=disable)\n"
-	"Disable 11-bit Access Burst (TS1 & TS2) correlation\n"
-	"Enable 11-bit Access Burst (TS1 & TS2) correlation\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	if (strcmp("disable", argv[0]) == 0)
-		trx->cfg.ext_rach = false;
-
-	if (strcmp("enable", argv[0]) == 0)
-		trx->cfg.ext_rach = true;
-
-	return CMD_SUCCESS;
-}
-
-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")
-{
-	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;
-}
-
-DEFUN(cfg_stack_size, cfg_stack_size_cmd,
-	"stack-size <0-2147483647>",
-	"Set the stack size per thread in BYTE, 0 = OS default\n"
-	"Stack size per thread in BYTE\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.stack_size = atoi(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-#define CFG_FILLER_DOC_STR \
-	"Filler burst settings\n"
-
-DEFUN(cfg_filler, cfg_filler_type_cmd,
-      "AUTO-GENERATED", "AUTO-GENERATED")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-	// trx->cfg.filler is unsigned, so we need an interim int var to detect errors
-	int type = get_string_value(filler_types, argv[0]);
-
-	if (type < 0) {
-		trx->cfg.filler = FILLER_ZERO;
-		return CMD_WARNING;
-	}
-	trx->cfg.filler = type;
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_test_rtsc, cfg_filler_tsc_cmd,
-	"filler tsc <0-7>",
-	CFG_FILLER_DOC_STR
-	"Set the TSC for GMSK/8-PSK Normal Burst random fillers. Used only with 'random-nb-gmsk' and"
-	" 'random-nb-8psk' filler types. (default=0)\n"
-	"TSC\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.rtsc = atoi(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_test_rach_delay, cfg_filler_rach_delay_cmd,
-	"filler access-burst-delay <0-68>",
-	CFG_FILLER_DOC_STR
-	"Set the delay for Access Burst random fillers. Used only with 'random-ab' filler type. (default=0)\n"
-	"RACH delay in symbols\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.rach_delay = atoi(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-static int vty_ctr_name_2_id(const char* str) {
-	size_t i;
-	for (i = 0; trx_chan_ctr_names[i].str; i++) {
-		if (strstr(trx_chan_ctr_names[i].str, str)) {
-			return i;
-		}
-	}
-	return -1;
-}
-
-static int vty_intv_name_2_id(const char* str) {
-	size_t i;
-	for (i = 0; rate_ctr_intv[i].str; i++) {
-		if (strcmp(rate_ctr_intv[i].str, str) == 0) {
-			return i;
-		}
-	}
-	return -1;
-}
-
-#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) \
-	THRESHOLD_STR_VAL(tx_underruns) \
-	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_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 \
-	INTV_STR_VAL(per-second) \
-	INTV_STR_VAL(per-minute) \
-	INTV_STR_VAL(per-hour) \
-	INTV_STR_VAL(per-day)
-
-DEFUN_ATTR(cfg_ctr_error_threshold, cfg_ctr_error_threshold_cmd,
-	   "ctr-error-threshold " THRESHOLD_ARGS " <0-65535> " INTV_ARGS,
-	   "Threshold rate for error counter\n"
-	   THRESHOLD_STRS
-	   "Value to set for threshold\n"
-	   INTV_STRS,
-	   CMD_ATTR_IMMEDIATE)
-{
-	int rc;
-	struct ctr_threshold ctr;
-
-	rc = vty_ctr_name_2_id(argv[0]);
-	if (rc < 0) {
-		vty_out(vty, "No valid ctr_name found for ctr-error-threshold %s%s",
-			argv[0], VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-	ctr.ctr_id = (enum TrxCtr)rc;
-	ctr.val = atoi(argv[1]);
-	rc = vty_intv_name_2_id(argv[2]);
-	if (rc < 0) {
-		vty_out(vty, "No valid time frame found for ctr-error-threshold %s %d %s%s",
-			argv[0], ctr.val, argv[2], VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-	ctr.intv = (enum rate_ctr_intv) rc;
-	trx_rate_ctr_threshold_add(&ctr);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN_ATTR(cfg_no_ctr_error_threshold, cfg_no_ctr_error_threshold_cmd,
-	   "no ctr-error-threshold " THRESHOLD_ARGS " <0-65535> " INTV_ARGS,
-	   NO_STR "Threshold rate for error counter\n"
-	   THRESHOLD_STRS
-	   "Value to set for threshold\n"
-	   INTV_STRS,
-	   CMD_ATTR_IMMEDIATE)
-{
-	int rc;
-	struct ctr_threshold ctr;
-
-	rc = vty_ctr_name_2_id(argv[0]);
-	if (rc < 0) {
-		vty_out(vty, "No valid ctr_name found for ctr-error-threshold %s%s",
-			argv[0], VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-	ctr.ctr_id = (enum TrxCtr)rc;
-	ctr.val = atoi(argv[1]);
-	rc = vty_intv_name_2_id(argv[2]);
-	if (rc < 0) {
-		vty_out(vty, "No valid time frame found for ctr-error-threshold %s %d %s%s",
-			argv[0], ctr.val, argv[2], VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-	ctr.intv = (enum rate_ctr_intv) rc;
-	if (trx_rate_ctr_threshold_del(&ctr) < 0) {
-		vty_out(vty, "no ctr-error-threshold: Entry to delete not found%s", VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_chan, cfg_chan_cmd,
-	"chan <0-100>",
-	"Select a channel to configure\n"
-	"Channel index\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-	int idx = atoi(argv[0]);
-
-	if (idx >= TRX_CHAN_MAX) {
-		vty_out(vty, "Chan list full.%s", VTY_NEWLINE);
-		return CMD_WARNING;
-	} else if (trx->cfg.multi_arfcn && trx->cfg.num_chans >= TRX_MCHAN_MAX) {
-		vty_out(vty, "Up to %i channels are supported for multi-TRX mode%s",
-			TRX_MCHAN_MAX, VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-
-	if (trx->cfg.num_chans < idx) { /* Unexisting or creating non-consecutive */
-		vty_out(vty, "Non-existent or non-consecutive chan %d.%s",
-				idx, VTY_NEWLINE);
-		return CMD_WARNING;
-	} else if (trx->cfg.num_chans == idx)  { /* creating it */
-		trx->cfg.num_chans++;
-		trx->cfg.chans[idx].trx = trx;
-		trx->cfg.chans[idx].idx = idx;
-	}
-
-	vty->node = CHAN_NODE;
-	vty->index = &trx->cfg.chans[idx];
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_chan_rx_path, cfg_chan_rx_path_cmd,
-	"rx-path NAME",
-	"Set the Rx Path\n"
-	"Rx Path name\n")
-{
-	struct trx_chan *chan = vty->index;
-
-	if (chan->trx->cfg.multi_arfcn && chan->idx > 0) {
-		vty_out(vty, "%% Setting 'rx-path' for chan %u in multi-ARFCN mode "
-			     "does not make sense, because only chan 0 is used%s",
-			chan->idx, VTY_NEWLINE);
-	}
-
-	osmo_talloc_replace_string(chan->trx, &chan->rx_path, argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_chan_tx_path, cfg_chan_tx_path_cmd,
-	"tx-path NAME",
-	"Set the Tx Path\n"
-	"Tx Path name\n")
-{
-	struct trx_chan *chan = vty->index;
-
-	if (chan->trx->cfg.multi_arfcn && chan->idx > 0) {
-		vty_out(vty, "%% Setting 'tx-path' for chan %u in multi-ARFCN mode "
-			     "does not make sense, because only chan 0 is used%s",
-			chan->idx, VTY_NEWLINE);
-	}
-
-	osmo_talloc_replace_string(chan->trx, &chan->tx_path, argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-static int dummy_config_write(struct vty *v)
-{
-	return CMD_SUCCESS;
-}
-
-static int config_write_trx(struct vty *vty)
-{
-	struct trx_chan *chan;
-	int i;
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	vty_out(vty, "trx%s", VTY_NEWLINE);
-	if (trx->cfg.bind_addr)
-		vty_out(vty, " bind-ip %s%s", trx->cfg.bind_addr, VTY_NEWLINE);
-	if (trx->cfg.remote_addr)
-		vty_out(vty, " remote-ip %s%s", trx->cfg.remote_addr, VTY_NEWLINE);
-	if (trx->cfg.base_port != DEFAULT_TRX_PORT)
-		vty_out(vty, " base-port %u%s", trx->cfg.base_port, VTY_NEWLINE);
-	if (strlen(trx->cfg.dev_args))
-		vty_out(vty, " dev-args %s%s", trx->cfg.dev_args, VTY_NEWLINE);
-	if (trx->cfg.tx_sps != DEFAULT_TX_SPS)
-		vty_out(vty, " tx-sps %u%s", trx->cfg.tx_sps, VTY_NEWLINE);
-	if (trx->cfg.rx_sps != DEFAULT_RX_SPS)
-		vty_out(vty, " rx-sps %u%s", trx->cfg.rx_sps, VTY_NEWLINE);
-	if (trx->cfg.clock_ref != REF_INTERNAL)
-		vty_out(vty, " clock-ref %s%s", get_value_string(clock_ref_names, trx->cfg.clock_ref), VTY_NEWLINE);
-	vty_out(vty, " multi-arfcn %s%s", trx->cfg.multi_arfcn ? "enable" : "disable", VTY_NEWLINE);
-	if (trx->cfg.offset != 0)
-		vty_out(vty, " offset %f%s", trx->cfg.offset, VTY_NEWLINE);
-	if (trx->cfg.freq_offset_khz != 0)
-		vty_out(vty, " freq-offset %f%s", trx->cfg.freq_offset_khz, VTY_NEWLINE);
-	if (!(trx->cfg.rssi_offset == 0 && !trx->cfg.force_rssi_offset))
-		vty_out(vty, " rssi-offset %f%s%s", trx->cfg.rssi_offset,
-			trx->cfg.force_rssi_offset ? " relative": "", VTY_NEWLINE);
-	vty_out(vty, " swap-channels %s%s", trx->cfg.swap_channels ? "enable" : "disable", VTY_NEWLINE);
-	vty_out(vty, " egprs %s%s", trx->cfg.egprs ? "enable" : "disable", VTY_NEWLINE);
-	vty_out(vty, " ext-rach %s%s", trx->cfg.ext_rach ? "enable" : "disable", VTY_NEWLINE);
-	if (trx->cfg.sched_rr != 0)
-		vty_out(vty, " rt-prio %u%s", trx->cfg.sched_rr, VTY_NEWLINE);
-	if (trx->cfg.filler != FILLER_ZERO)
-		vty_out(vty, " filler type %s%s", get_value_string(filler_types, trx->cfg.filler), VTY_NEWLINE);
-	if (trx->cfg.rtsc > 0)
-		vty_out(vty, " filler tsc %u%s", trx->cfg.rtsc, VTY_NEWLINE);
-	if (trx->cfg.rach_delay > 0)
-		vty_out(vty, " filler access-burst-delay %u%s", trx->cfg.rach_delay, VTY_NEWLINE);
-	if (trx->cfg.stack_size != 0)
-		vty_out(vty, " stack-size %u%s", trx->cfg.stack_size, VTY_NEWLINE);
-	if (trx->cfg.ul_fn_offset != 0)
-		vty_out(vty, " ul-fn-offset %d%s", trx->cfg.ul_fn_offset, VTY_NEWLINE);
-	if (trx->cfg.overrides.dl_freq_override)
-		vty_out(vty, " dl-freq-override %f%s", trx->cfg.overrides.dl_freq, VTY_NEWLINE);
-	if (trx->cfg.overrides.ul_freq_override)
-		vty_out(vty, " ul-freq-override %f%s", trx->cfg.overrides.ul_freq, VTY_NEWLINE);
-	if (trx->cfg.overrides.dl_gain_override)
-		vty_out(vty, " dl-gain-override %f%s", trx->cfg.overrides.dl_gain, VTY_NEWLINE);
-	if (trx->cfg.overrides.ul_gain_override)
-		vty_out(vty, " ul-gain-override %f%s", trx->cfg.overrides.ul_gain, VTY_NEWLINE);
-	if (trx->cfg.use_va)
-		vty_out(vty, " viterbi-eq %s%s", trx->cfg.use_va ? "enable" : "disable", VTY_NEWLINE);
-	trx_rate_ctr_threshold_write_config(vty, " ");
-
-	for (i = 0; i < trx->cfg.num_chans; i++) {
-		chan = &trx->cfg.chans[i];
-		vty_out(vty, " chan %u%s", chan->idx, VTY_NEWLINE);
-		if (chan->rx_path)
-			vty_out(vty, "  rx-path %s%s", chan->rx_path, VTY_NEWLINE);
-		if (chan->tx_path)
-			vty_out(vty, "  tx-path %s%s", chan->tx_path, VTY_NEWLINE);
-	}
-
-	return CMD_SUCCESS;
-}
-
-static void trx_dump_vty(struct vty *vty, struct trx_ctx *trx)
-{
-	struct trx_chan *chan;
-	int i;
-	vty_out(vty, "TRX Config:%s", VTY_NEWLINE);
-	vty_out(vty, " Local IP: %s%s", trx->cfg.bind_addr, VTY_NEWLINE);
-	vty_out(vty, " Remote IP: %s%s", trx->cfg.remote_addr, VTY_NEWLINE);
-	vty_out(vty, " TRX Base Port: %u%s", trx->cfg.base_port, VTY_NEWLINE);
-	vty_out(vty, " Device args: %s%s", trx->cfg.dev_args, VTY_NEWLINE);
-	vty_out(vty, " Tx Samples-per-Symbol: %u%s", trx->cfg.tx_sps, VTY_NEWLINE);
-	vty_out(vty, " Rx Samples-per-Symbol: %u%s", trx->cfg.rx_sps, VTY_NEWLINE);
-	vty_out(vty, " Filler Burst Type: %s%s", get_value_string(filler_names, trx->cfg.filler), VTY_NEWLINE);
-	vty_out(vty, " Filler Burst TSC: %u%s", trx->cfg.rtsc, VTY_NEWLINE);
-	vty_out(vty, " Filler Burst RACH Delay: %u%s", trx->cfg.rach_delay, VTY_NEWLINE);
-	vty_out(vty, " Clock Reference: %s%s", get_value_string(clock_ref_names, trx->cfg.clock_ref), VTY_NEWLINE);
-	vty_out(vty, " Multi-Carrier: %s%s", trx->cfg.multi_arfcn ? "Enabled" : "Disabled", VTY_NEWLINE);
-	vty_out(vty, " Tuning offset: %f%s", trx->cfg.offset, VTY_NEWLINE);
-	vty_out(vty, " RSSI to dBm offset: %f%s", trx->cfg.rssi_offset, VTY_NEWLINE);
-	vty_out(vty, " Swap channels: %s%s", trx->cfg.swap_channels ? "Enabled" : "Disabled", VTY_NEWLINE);
-	vty_out(vty, " EDGE support: %s%s", trx->cfg.egprs ? "Enabled" : "Disabled", VTY_NEWLINE);
-	vty_out(vty, " Extended RACH support: %s%s", trx->cfg.ext_rach ? "Enabled" : "Disabled", VTY_NEWLINE);
-	vty_out(vty, " Real Time Priority: %u (%s)%s", trx->cfg.sched_rr,
-		trx->cfg.sched_rr ? "Enabled" : "Disabled", VTY_NEWLINE);
-	vty_out(vty, " Stack size per Thread in BYTE (0 = OS default): %u%s", trx->cfg.stack_size, VTY_NEWLINE);
-	vty_out(vty, " Channels: %u%s", trx->cfg.num_chans, VTY_NEWLINE);
-	for (i = 0; i < trx->cfg.num_chans; i++) {
-		chan = &trx->cfg.chans[i];
-		vty_out(vty, "  Channel %u:%s", chan->idx, VTY_NEWLINE);
-		if (chan->rx_path)
-			vty_out(vty, "   Rx Path: %s%s", chan->rx_path, VTY_NEWLINE);
-		if (chan->tx_path)
-			vty_out(vty, "   Tx Path: %s%s", chan->tx_path, VTY_NEWLINE);
-	}
-}
-
-DEFUN(show_trx, show_trx_cmd,
-	"show trx",
-	SHOW_STR "Display information on the TRX\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx_dump_vty(vty, trx);
-
-	return CMD_SUCCESS;
-}
-
-static int trx_vty_is_config_node(struct vty *vty, int node)
-{
-	switch (node) {
-	case TRX_NODE:
-	case CHAN_NODE:
-		return 1;
-	default:
-		return 0;
-	}
-}
-
-static int trx_vty_go_parent(struct vty *vty)
-{
-	switch (vty->node) {
-	case TRX_NODE:
-		vty->node = CONFIG_NODE;
-		vty->index = NULL;
-		vty->index_sub = NULL;
-		break;
-	case CHAN_NODE:
-		vty->node = TRX_NODE;
-		vty->index = NULL;
-		vty->index_sub = NULL;
-		break;
-	default:
-		vty->node = CONFIG_NODE;
-		vty->index = NULL;
-		vty->index_sub = NULL;
-	}
-
-	return vty->node;
-}
-
-static const char trx_copyright[] =
-	"Copyright (C) 2007-2014 Free Software Foundation, Inc.\r\n"
-	"Copyright (C) 2013 Thomas Tsou <tom@tsou.cc>\r\n"
-	"Copyright (C) 2013-2019 Fairwaves, Inc.\r\n"
-	"Copyright (C) 2015 Ettus Research LLC\r\n"
-	"Copyright (C) 2017-2018 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>\r\n"
-	"License AGPLv3+: GNU AGPL version 3 or later <http://gnu.org/licenses/agpl-3.0.html>\r\n"
-	"This is free software: you are free to change and redistribute it.\r\n"
-	"There is NO WARRANTY, to the extent permitted by law.\r\n";
-
-struct vty_app_info g_vty_info = {
-	.name		= "OsmoTRX",
-	.version	= PACKAGE_VERSION,
-	.copyright	= trx_copyright,
-	.go_parent_cb	= trx_vty_go_parent,
-	.is_config_node	= trx_vty_is_config_node,
-};
-
-struct trx_ctx *vty_trx_ctx_alloc(void *talloc_ctx)
-{
-	struct trx_ctx * trx = talloc_zero(talloc_ctx, struct trx_ctx);
-
-	trx->cfg.bind_addr =  talloc_strdup(trx, DEFAULT_TRX_IP);
-	trx->cfg.remote_addr = talloc_strdup(trx, DEFAULT_TRX_IP);
-	trx->cfg.base_port = DEFAULT_TRX_PORT;
-	trx->cfg.tx_sps = DEFAULT_TX_SPS;
-	trx->cfg.rx_sps = DEFAULT_RX_SPS;
-	trx->cfg.filler = FILLER_ZERO;
-	trx->cfg.rssi_offset = 0.0f;
-	trx->cfg.dev_args = talloc_strdup(trx, "");
-
-	return trx;
-}
-
-int trx_vty_init(struct trx_ctx* trx)
-{
-	cfg_filler_type_cmd.string = vty_cmd_string_from_valstr(trx, filler_types,
-		"filler type (", "|", ")", 0);
-	cfg_filler_type_cmd.doc = vty_cmd_string_from_valstr(trx, filler_docs,
-		CFG_FILLER_DOC_STR "What to do when there is nothing to send "
-		"(filler type, default=zero)\n", "\n", "", 0);
-
-	g_trx_ctx = trx;
-	install_element_ve(&show_trx_cmd);
-
-	install_element(CONFIG_NODE, &cfg_trx_cmd);
-
-	install_node(&trx_node, config_write_trx);
-	install_element(TRX_NODE, &cfg_bind_ip_cmd);
-	install_element(TRX_NODE, &cfg_remote_ip_cmd);
-	install_element(TRX_NODE, &cfg_base_port_cmd);
-	install_element(TRX_NODE, &cfg_dev_args_cmd);
-	install_element(TRX_NODE, &cfg_tx_sps_cmd);
-	install_element(TRX_NODE, &cfg_rx_sps_cmd);
-	install_element(TRX_NODE, &cfg_clock_ref_cmd);
-	install_element(TRX_NODE, &cfg_multi_arfcn_cmd);
-	install_element(TRX_NODE, &cfg_offset_cmd);
-	install_element(TRX_NODE, &cfg_freq_offset_cmd);
-	install_element(TRX_NODE, &cfg_rssi_offset_cmd);
-	install_element(TRX_NODE, &cfg_swap_channels_cmd);
-	install_element(TRX_NODE, &cfg_egprs_cmd);
-	install_element(TRX_NODE, &cfg_ext_rach_cmd);
-	install_element(TRX_NODE, &cfg_rt_prio_cmd);
-	install_element(TRX_NODE, &cfg_filler_type_cmd);
-	install_element(TRX_NODE, &cfg_filler_tsc_cmd);
-	install_element(TRX_NODE, &cfg_filler_rach_delay_cmd);
-	install_element(TRX_NODE, &cfg_ctr_error_threshold_cmd);
-	install_element(TRX_NODE, &cfg_no_ctr_error_threshold_cmd);
-	install_element(TRX_NODE, &cfg_stack_size_cmd);
-
-	install_element(TRX_NODE, &cfg_chan_cmd);
-	install_element(TRX_NODE, &cfg_ul_fn_offset_cmd);
-	install_element(TRX_NODE, &cfg_ul_freq_override_cmd);
-	install_element(TRX_NODE, &cfg_dl_freq_override_cmd);
-	install_element(TRX_NODE, &cfg_ul_gain_override_cmd);
-	install_element(TRX_NODE, &cfg_dl_gain_override_cmd);
-	install_element(TRX_NODE, &cfg_use_viterbi_cmd);
-	install_node(&chan_node, dummy_config_write);
-	install_element(CHAN_NODE, &cfg_chan_rx_path_cmd);
-	install_element(CHAN_NODE, &cfg_chan_tx_path_cmd);
-
-	logging_vty_add_deprecated_subsys(g_trx_ctx, "lms");
-
-	return 0;
-}

CommonLibs/trx_vty.h

@@ -1,41 +0,0 @@
-#pragma once
-
-#include <osmocom/vty/command.h>
-
-#include "config_defs.h"
-
-extern struct vty_app_info g_vty_info;
-extern const struct value_string clock_ref_names[];
-extern const struct value_string filler_names[];
-
-/* Maximum number of carriers in multi-ARFCN mode */
-#define TRX_MCHAN_MAX 3
-
-/* Samples-per-symbol for downlink path
- *     4 - Uses precision modulator (more computation, less distortion)
- *     1 - Uses minimized modulator (less computation, more distortion)
- *
- *     Other values are invalid. Receive path (uplink) is always
- *     downsampled to 1 sps. Default to 4 sps for all cases.
- */
-#define DEFAULT_TX_SPS		4
-
-/*
- * Samples-per-symbol for uplink (receiver) path
- *     Do not modify this value. EDGE configures 4 sps automatically on
- *     B200/B210 devices only. Use of 4 sps on the receive path for other
- *     configurations is not supported.
- */
-#define DEFAULT_RX_SPS		1
-
-/* Default configuration parameters */
-#define DEFAULT_TRX_PORT	5700
-#define DEFAULT_TRX_IP		"127.0.0.1"
-#define DEFAULT_CHANS		1
-
-struct trx_ctx {
-	struct trx_cfg cfg;
-};
-
-int trx_vty_init(struct trx_ctx* trx);
-struct trx_ctx *vty_trx_ctx_alloc(void *talloc_ctx);

GSM/GSMCommon.cpp

@@ -2,8 +2,6 @@
 * Copyright 2008 Free Software Foundation, Inc.
 * Copyright 2011 Range Networks, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -55,14 +53,8 @@ const BitVector GSM::gEdgeTrainingSequence[] = {
 };
 
 const BitVector GSM::gDummyBurst("0001111101101110110000010100100111000001001000100000001111100011100010111000101110001010111010010100011001100111001111010011111000100101111101010000");
-const BitVector GSM::gDummyBurstTSC("01110001011100010111000101");
 
-/* 3GPP TS 05.02, section 5.2.7 "Access burst (AB)", synch. sequence bits */
-const BitVector GSM::gRACHSynchSequenceTS0("01001011011111111001100110101010001111000");  /* GSM, GMSK (default) */
-const BitVector GSM::gRACHSynchSequenceTS1("01010100111110001000011000101111001001101");  /* EGPRS, 8-PSK */
-const BitVector GSM::gRACHSynchSequenceTS2("11101111001001110101011000001101101110111");  /* EGPRS, GMSK */
-
-const BitVector GSM::gSCHSynchSequence("1011100101100010000001000000111100101101010001010111011000011011");
+const BitVector GSM::gRACHSynchSequence("01001011011111111001100110101010001111000");
 
 //                               |-head-||---------midamble----------------------||--------------data----------------||t|
 const BitVector GSM::gRACHBurst("0011101001001011011111111001100110101010001111000110111101111110000111001001010110011000");

GSM/GSMCommon.h

@@ -2,8 +2,6 @@
 /*
 * Copyright 2008-2011 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -52,16 +50,9 @@ extern const BitVector gEdgeTrainingSequence[];
 
 /** C0T0 filler burst, GSM 05.02, 5.2.6 */
 extern const BitVector gDummyBurst;
-extern const BitVector gDummyBurstTSC;
 
 /** Random access burst synch. sequence */
-extern const BitVector gRACHSynchSequenceTS0;
-extern const BitVector gRACHSynchSequenceTS1;
-extern const BitVector gRACHSynchSequenceTS2;
-
-/** Synchronization burst sync sequence */
-extern const BitVector gSCHSynchSequence;
-
+extern const BitVector gRACHSynchSequence;
 /** Random access burst synch. sequence, GSM 05.02 5.2.7 */
 extern const BitVector gRACHBurst;
 

INSTALLATION

@@ -0,0 +1,19 @@
+Installation Requirements
+
+
+
+osmo-trx compiles to a simple Unix binary and does not require special
+installation.
+
+One some systems (Ubuntu), you will need to define LIBS = -lpthread prior to
+running configure.
+
+To run osmo-trx, the following should be installed:
+	libuhd (https://gnuradio.org).
+	This is part of the GNURadio installation.
+
+For information on specific executables, see tests/README.tests and
+apps/README.apps.
+
+See https://osmocom.org/projects/osmotrx/wiki/OsmoTRX for more
+information.

Makefile.am

@@ -26,40 +26,19 @@ AM_CXXFLAGS = -Wall -pthread
 #AM_CXXFLAGS = -Wall -O2 -NDEBUG -pthread
 #AM_CFLAGS = -Wall -O2 -NDEBUG -pthread
 
-SUBDIRS =
-
-if ENABLE_MS_TRX
-SUBDIRS += $(LIBTRXCON_DIR)
-endif
-
 # Order must be preserved
-SUBDIRS += \
+SUBDIRS = \
 	CommonLibs \
 	GSM \
 	Transceiver52M \
-	contrib \
-	tests \
-	utils \
-	doc \
-	$(NULL)
-
-BUILT_SOURCES = $(top_srcdir)/.version
-$(top_srcdir)/.version:
-	echo $(VERSION) > $@-t && mv $@-t $@
-dist-hook:
-	echo $(VERSION) > $(distdir)/.tarball-version
+	tests
 
 EXTRA_DIST = \
-	.version \
+	autogen.sh \
+	INSTALLATION \
 	LEGAL \
 	COPYING \
-	README.md \
-	debian \
-	git-version-gen \
-	$(NULL)
-
-AM_DISTCHECK_CONFIGURE_FLAGS = \
-	--with-systemdsystemunitdir=$$dc_install_base/$(systemdsystemunitdir)
+	README
 
 .PHONY: release
 

Makefile.common

@@ -18,6 +18,9 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+top_srcdir = $(abs_top_srcdir)
+top_builddir = $(abs_top_builddir)
+
 COMMON_INCLUDEDIR = $(top_srcdir)/CommonLibs
 GSM_INCLUDEDIR = $(top_srcdir)/GSM
 
@@ -30,9 +33,9 @@ COMMON_LA = $(top_builddir)/CommonLibs/libcommon.la
 GSM_LA = $(top_builddir)/GSM/libGSM.la
 
 if ARCH_ARM
-ARCH_LA = $(top_builddir)/Transceiver52M/arch/arm/libarch.la
+ARCH_LA = $(top_builddir)/Transceiver52M/arm/libarch.la
 else
-ARCH_LA = $(top_builddir)/Transceiver52M/arch/x86/libarch.la
+ARCH_LA = $(top_builddir)/Transceiver52M/x86/libarch.la
 endif
 
 MOSTLYCLEANFILES = *~

README

@@ -0,0 +1,116 @@
+This is the interface to the transcevier.
+
+Each TRX Manager UDP socket interface represents a single ARFCN.
+Each of these per-ARFCN interfaces is a pair of UDP sockets, one for control and one for data.
+Give a base port B (5700), the master clock interface is at port P=B.
+The TRX-side control interface for C(N) is on  port P=B+2N+1 and the data interface is on an odd numbered port P=B+2N+2.
+The corresponding core-side interface for every socket is at P+100.
+For any given build, the number of ARFCN interfaces can be fixed.
+
+
+
+Indications on the Master Clock Interface
+
+The master clock interface is output only (from the radio).
+Messages are "indications".
+
+CLOCK gives the current value of the transceiver clock to be used by the core.
+This message is sent whenever a trasmission packet arrives that is too late or too early.  The clock value is NOT the current transceiver time.  It is a time setting the the core should use to give better packet arrival times.
+IND CLOCK <totalFrames>
+
+
+
+Commands on the Per-ARFCN Control Interface
+
+The per-ARFCN control interface uses a command-reponse protocol.
+Commands are NULL-terminated ASCII strings, one per UDP socket.
+Each command has a corresponding response.
+Every command is of the form:
+
+CMD <cmdtype> [params]
+
+The <cmdtype> is the actual command.
+Parameters are optional depending on the commands type.
+Every response is of the form:
+
+RSP <cmdtype> <status> [result]
+
+The <status> is 0 for success and a non-zero error code for failure.
+Successful responses may include results, depending on the command type.
+
+
+Power Control
+
+POWEROFF shuts off transmitter power and stops the demodulator.
+CMD POWEROFF
+RSP POWEROFF <status>
+
+POWERON starts the transmitter and starts the demodulator.  Initial power level is very low.
+This command fails if the transmitter and receiver are not yet tuned.
+This command fails if the transmit or receive frequency creates a conflict with another ARFCN that is already runnng.
+If the transceiver is already on, it response with success to this command.
+CMD POWERON
+RSP POWERON <status>
+
+SETPOWER sets output power in dB wrt full scale.
+This command fails if the transmitter and receiver are not running.
+CMD SETPOWER <dB>
+RSP SETPOWER <status> <dB>
+
+ADJPOWER adjusts power by the given dB step.  Response returns resulting power level wrt full scale.
+This command fails if the transmitter and receiver are not running.
+CMD ADJPOWER <dBStep>
+RSP ADJPOWER <status> <dBLevel>
+
+
+Tuning Control
+
+RXTUNE tunes the receiver to a given frequency in kHz.
+This command fails if the receiver is already running.
+(To re-tune you stop the radio, re-tune, and restart.)
+This command fails if the transmit or receive frequency creates a conflict with another ARFCN that is already runnng.
+CMD RXTUNE <kHz>
+RSP RXTUNE <status> <kHz>
+
+TXTUNE tunes the transmitter to a given frequency in kHz.
+This command fails if the transmitter is already running.
+(To re-tune you stop the radio, re-tune, and restart.)
+This command fails if the transmit or receive frequency creates a conflict with another ARFCN that is already runnng.
+CMD TXTUNE <kHz>
+RSP TXTUNE <status> <kHz>
+
+
+Timeslot Control
+
+SETSLOT sets the format of the uplink timeslots in the ARFCN.
+The <timeslot> indicates the timeslot of interest.
+The <chantype> indicates the type of channel that occupies the timeslot.
+A chantype of zero indicates the timeslot is off.
+CMD SETSLOT <timeslot> <chantype>
+RSP SETSLOT <status> <timeslot> <chantype>
+
+
+Messages on the per-ARFCN Data Interface
+
+Messages on the data interface carry one radio burst per UDP message.
+
+
+Received Data Burst
+
+1 byte timeslot index
+4 bytes GSM frame number, big endian
+1 byte RSSI in -dBm
+2 bytes correlator timing offset in 1/256 symbol steps, 2's-comp, big endian
+148 bytes soft symbol estimates, 0 -> definite "0", 255 -> definite "1"
+
+
+Transmit Data Burst
+
+1 byte timeslot index
+4 bytes GSM frame number, big endian
+1 byte transmit level wrt ARFCN max, -dB (attenuation)
+148 bytes output symbol values, 0 & 1
+
+
+
+

README.md

@@ -1,78 +0,0 @@
-About OsmoTRX
-=============
-
-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*
-
-OsmoTRX is originally based on the transceiver code from the
-[OpenBTS](https://osmocom.org/projects/osmobts/wiki/OpenBTS) project, but setup
-to operate independently with the purpose of using with non-OpenBTS software and
-projects, specifically within the Osmocom stack.  Used together with
-[OsmoBTS](https://osmocom.org/projects/osmobts/wiki) you can get a pretty
-standard GSM/GPRS/EGPRS BTS with Abis interface as per the relevant 3GPP specifications.
-
-Homepage
---------
-
-The official homepage of the project is
-<https://osmocom.org/projects/osmotrx/wiki/OsmoTRX>
-
-GIT Repository
---------------
-
-You can clone from the official osmo-trx.git repository using
-
-        git clone https://gitea.osmocom.org/cellular-infrastructure/osmo-trx
-
-There is a web interface at <https://gitea.osmocom.org/cellular-infrastructure/osmo-trx>
-
-Documentation
--------------
-
-Doxygen-generated API documentation is generated during the build process, but
-also available online for each of the sub-libraries at User Manual for OsmoTRX
-can be generated during the build process, and is also available online at
-<https://ftp.osmocom.org/docs/latest/osmotrx-usermanual.pdf>.
-
-Forum
------
-
-We welcome any osmo-trx related discussions in the
-[Cellular Network Infrastructure -> 2 RAN (GERAN)](https://discourse.osmocom.org/c/cni/geran)
-section of the osmocom discourse (web based Forum).
-
-Mailing List
-------------
-
-Discussions related to OsmoTRX are happening on the openbsc@lists.osmocom.org
-mailing list, please see <https://lists.osmocom.org/mailman/listinfo/openbsc>
-for subscription options and the list archive.
-
-Please observe the [Osmocom Mailing List
-Rules](https://osmocom.org/projects/cellular-infrastructure/wiki/Mailing_List_Rules)
-when posting.
-
-Issue Tracker
--------------
-
-We use the [issue tracker of the osmo-trx project on osmocom.org](https://osmocom.org/projects/osmotrx/issues) for
-tracking the state of bug reports and feature requests.  Feel free to submit any issues you may find, or help
-us out by resolving existing issues.
-
-Contributing
-------------
-
-Our coding standards are described at
-<https://osmocom.org/projects/cellular-infrastructure/wiki/Coding_standards>
-
-We use a Gerrit based patch submission/review process for managing contributions.
-Please see <https://osmocom.org/projects/cellular-infrastructure/wiki/Gerrit>
-for more details
-
-The current patch queue for OsmoTRX can be seen at
-<https://gerrit.osmocom.org/q/project:osmo-trx+status:open>

TODO-RELEASE

@@ -1,9 +0,0 @@
-# When cleaning up this file: bump API version in corresponding Makefile.am and rename corresponding debian/lib*.install
-# according to https://osmocom.org/projects/cellular-infrastructure/wiki/Make_a_new_release
-# In short: https://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html#Updating-version-info
-# LIBVERSION=c:r:a
-# If the library source code has changed at all since the last update, then increment revision: c:r + 1:a.
-# If any interfaces have been added, removed, or changed since the last update: c + 1:0:a.
-# If any interfaces have been added since the last public release: c:r:a + 1.
-# If any interfaces have been removed or changed since the last public release: c:r:0.
-#library	what			description / commit summary line

Transceiver52M/Channelizer.cpp

@@ -4,8 +4,6 @@
  * Copyright (C) 2012-2014 Tom Tsou <tom@tsou.cc>
  * Copyright (C) 2015 Ettus Research LLC
  *
- * SPDX-License-Identifier: AGPL-3.0+
- *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
@@ -30,8 +28,8 @@
 #include "Channelizer.h"
 
 extern "C" {
-#include "fft.h"
-#include "convolve.h"
+#include "common/fft.h"
+#include "common/convolve.h"
 }
 
 static void deinterleave(const float *in, size_t ilen,
@@ -90,7 +88,7 @@ bool Channelizer::rotate(const float *in, size_t len)
 		convolve_real(hInputs[i], blockLen,
 			      subFilters[i], hLen,
 			      hOutputs[i], blockLen,
-			      0, blockLen);
+			      0, blockLen, 1, 0);
 	}
 
 	cxvec_fft(fftHandle);
@@ -98,7 +96,7 @@ bool Channelizer::rotate(const float *in, size_t len)
 	return true;
 }
 
-/* Setup channelizer parameters */
+/* Setup channelizer paramaters */
 Channelizer::Channelizer(size_t m, size_t blockLen, size_t hLen)
 	: ChannelizerBase(m, blockLen, hLen)
 {

Transceiver52M/ChannelizerBase.cpp

@@ -4,8 +4,6 @@
  * Copyright (C) 2012-2014 Tom Tsou <tom@tsou.cc>
  * Copyright (C) 2015 Ettus Research LLC 
  *
- * SPDX-License-Identifier: AGPL-3.0+
- *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
@@ -31,7 +29,7 @@
 #include "ChannelizerBase.h"
 
 extern "C" {
-#include "fft.h"
+#include "common/fft.h"
 }
 
 static float sinc(float x)
@@ -225,11 +223,10 @@ bool ChannelizerBase::checkLen(size_t innerLen, size_t outerLen)
 }
 
 /* 
- * Setup channelizer parameters
+ * Setup channelizer paramaters
  */
 ChannelizerBase::ChannelizerBase(size_t m, size_t blockLen, size_t hLen)
-	: subFilters(NULL), hInputs(NULL), hOutputs(NULL), hist(NULL),
-	  fftInput(NULL), fftOutput(NULL), fftHandle(NULL)
+	: fftInput(NULL), fftOutput(NULL), fftHandle(NULL)
 {
 	this->m = m;
 	this->hLen = hLen;
@@ -242,9 +239,8 @@ ChannelizerBase::~ChannelizerBase()
 
 	for (size_t i = 0; i < m; i++) {
 		free(subFilters[i]);
-		delete[] hist[i];
+		delete hist[i];
 	}
-	free(subFilters);
 
 	fft_free(fftInput);
 	fft_free(fftOutput);

Transceiver52M/ChannelizerBase.h

@@ -32,7 +32,7 @@ protected:
 	/* Buffer length validity checking */
 	bool checkLen(size_t innerLen, size_t outerLen);
 public:
-	/* Initialize channelizer/synthesis filter internals */
+	/* Initilize channelizer/synthesis filter internals */
 	bool init();
 };
 

Transceiver52M/Complex.h

@@ -5,7 +5,7 @@ unlike the built-in complex<> templates, these inline most operations for speed
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* This software is distributed under multiple licenses; see the COPYING file in the main directory for licensing information for this specific distribution.
+* This software is distributed under multiple licenses; see the COPYING file in the main directory for licensing information for this specific distribuion.
 *
 * This use of this software may be subject to additional restrictions.
 * See the LEGAL file in the main directory for details.
@@ -29,7 +29,7 @@ unlike the built-in complex<> templates, these inline most operations for speed
 template<class Real> class Complex {
 
 public:
-  typedef Real value_type;
+
   Real r, i;
 
   /**@name constructors */

Transceiver52M/Makefile.am

@@ -21,13 +21,28 @@
 
 include $(top_srcdir)/Makefile.common
 
-SUBDIRS = arch device
+AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/common
+AM_CXXFLAGS = -lpthread
 
-AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/arch/common -I${srcdir}/device/common
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
-AM_CFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
+SUBDIRS = arm x86
 
-noinst_LTLIBRARIES = libtransceiver_common.la
+if USRP1
+AM_CPPFLAGS += $(USRP_CFLAGS)
+else
+AM_CPPFLAGS += $(UHD_CFLAGS)
+endif
+
+rev2dir = $(datadir)/usrp/rev2
+rev4dir = $(datadir)/usrp/rev4
+
+dist_rev2_DATA = std_inband.rbf
+dist_rev4_DATA = std_inband.rbf
+
+EXTRA_DIST = \
+	README \
+	README.Talgorithm
+
+noinst_LTLIBRARIES = libtransceiver.la
 
 COMMON_SOURCES = \
 	radioInterface.cpp \
@@ -40,151 +55,49 @@ COMMON_SOURCES = \
 	ChannelizerBase.cpp \
 	Channelizer.cpp \
 	Synthesis.cpp \
-	proto_trxd.c \
-	grgsm_vitac/grgsm_vitac.cpp \
-	grgsm_vitac/viterbi_detector.cc
+	common/fft.c
 
-libtransceiver_common_la_SOURCES = \
+libtransceiver_la_SOURCES = \
 	$(COMMON_SOURCES) \
 	Resampler.cpp \
 	radioInterfaceResamp.cpp \
 	radioInterfaceMulti.cpp
 
+bin_PROGRAMS = osmo-trx
+
 noinst_HEADERS = \
 	Complex.h \
 	radioInterface.h \
 	radioVector.h \
 	radioClock.h \
+	radioDevice.h \
 	radioBuffer.h \
 	sigProcLib.h \
 	signalVector.h \
 	Transceiver.h \
+	USRPDevice.h \
 	Resampler.h \
 	ChannelizerBase.h \
 	Channelizer.h \
 	Synthesis.h \
-	proto_trxd.h
+	common/convolve.h \
+	common/convert.h \
+	common/scale.h \
+	common/mult.h \
+	common/fft.h
 
-COMMON_LDADD = \
-	libtransceiver_common.la \
+osmo_trx_SOURCES = osmo-trx.cpp
+osmo_trx_LDADD = \
+	libtransceiver.la \
 	$(ARCH_LA) \
 	$(GSM_LA) \
 	$(COMMON_LA) \
-	$(FFTWF_LIBS) \
-	$(LIBOSMOCORE_LIBS) \
-	$(LIBOSMOCTRL_LIBS) \
-	$(LIBOSMOVTY_LIBS)
-
-if ENABLE_MS_TRX
-AM_CPPFLAGS += -I$(top_srcdir)/osmocom-bb/src/host/trxcon/include/
-AM_CPPFLAGS += -I${srcdir}
-
-TRXCON_LDADD = \
-	$(top_builddir)/osmocom-bb/src/host/trxcon/src/.libs/libtrxcon.a \
-	$(top_builddir)/osmocom-bb/src/host/trxcon/src/.libs/libl1sched.a \
-	$(top_builddir)/osmocom-bb/src/host/trxcon/src/.libs/libl1gprs.a \
-	$(LIBOSMOCODING_LIBS)
-
-MS_LOWER_SRC = \
-	ms/sch.c \
-	ms/ms.cpp \
-	ms/threadsched.cpp \
-	ms/ms_rx_lower.cpp \
-	grgsm_vitac/grgsm_vitac.cpp \
-	grgsm_vitac/viterbi_detector.cc
-
-MS_UPPER_SRC = \
-	ms/ms_upper.cpp \
-	ms/l1ctl_server.c \
-	ms/logging.c \
-	ms/l1ctl_server_cb.cpp \
-	ms/ms_trxcon_if.cpp
-
-noinst_HEADERS += \
-   	ms/ms.h \
-	ms/threadsched.h \
-	ms/bladerf_specific.h \
-	ms/uhd_specific.h \
-	ms/ms_upper.h \
-	ms/ms_trxcon_if.h \
-	ms/itrq.h \
-	ms/sch.h \
-	ms/threadpool.h \
-	grgsm_vitac/viterbi_detector.h \
-	grgsm_vitac/constants.h \
-	grgsm_vitac/grgsm_vitac.h
+	$(FFTWF_LIBS)
 
-endif
-
-bin_PROGRAMS =
-
-if DEVICE_UHD
-bin_PROGRAMS += osmo-trx-uhd
-osmo_trx_uhd_SOURCES = osmo-trx.cpp
-osmo_trx_uhd_LDADD = \
-	$(builddir)/device/uhd/libdevice.la \
-	$(COMMON_LDADD) \
-	$(UHD_LIBS)
-osmo_trx_uhd_CPPFLAGS  = $(AM_CPPFLAGS) $(UHD_CFLAGS)
-
-#if ENABLE_MS_TRX
-#bin_PROGRAMS += osmo-trx-ms-uhd
-#osmo_trx_ms_uhd_SOURCES = $(MS_LOWER_SRC) $(MS_UPPER_SRC)
-#osmo_trx_ms_uhd_LDADD = \
-#	$(builddir)/device/uhd/libdevice.la \
-#	$(COMMON_LDADD) \
-#	$(UHD_LIBS) \
-#	$(TRXCON_LDADD)
-#osmo_trx_ms_uhd_CPPFLAGS  = $(AM_CPPFLAGS) $(UHD_CFLAGS) -DBUILDUHD
-#endif
-endif
-
-if DEVICE_USRP1
-bin_PROGRAMS += osmo-trx-usrp1
-osmo_trx_usrp1_SOURCES = osmo-trx.cpp
-osmo_trx_usrp1_LDADD = \
-	$(builddir)/device/usrp1/libdevice.la \
-	$(COMMON_LDADD) \
-	$(USRP_LIBS)
-osmo_trx_usrp1_CPPFLAGS  = $(AM_CPPFLAGS) $(USRP_CFLAGS)
-endif
-
-if DEVICE_LMS
-bin_PROGRAMS += osmo-trx-lms
-osmo_trx_lms_SOURCES = osmo-trx.cpp
-osmo_trx_lms_LDADD = \
-	$(builddir)/device/lms/libdevice.la \
-	$(COMMON_LDADD) \
-	$(LMS_LIBS)
-osmo_trx_lms_CPPFLAGS  = $(AM_CPPFLAGS) $(LMS_CFLAGS)
-endif
-
-if DEVICE_BLADE
-bin_PROGRAMS += osmo-trx-blade
-osmo_trx_blade_SOURCES = osmo-trx.cpp
-osmo_trx_blade_LDADD = \
-	$(builddir)/device/bladerf/libdevice.la \
-	$(COMMON_LDADD) \
-	$(BLADE_LIBS)
-osmo_trx_blade_CPPFLAGS  = $(AM_CPPFLAGS) $(LMS_CFLAGS)
-
-if ENABLE_MS_TRX
-bin_PROGRAMS += osmo-trx-ms-blade
-osmo_trx_ms_blade_SOURCES = $(MS_LOWER_SRC) $(MS_UPPER_SRC)
-osmo_trx_ms_blade_LDADD = \
-	$(builddir)/device/bladerf/libdevice.la \
-	$(COMMON_LDADD) \
-	$(BLADE_LIBS) \
-	$(TRXCON_LDADD)
-osmo_trx_ms_blade_CPPFLAGS  = $(AM_CPPFLAGS) $(BLADE_CFLAGS) -DBUILDBLADE
-endif
-endif
-
-if DEVICE_IPC
-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)
+if USRP1
+libtransceiver_la_SOURCES += USRPDevice.cpp
+osmo_trx_LDADD += $(USRP_LIBS)
+else
+libtransceiver_la_SOURCES += UHDDevice.cpp
+osmo_trx_LDADD += $(UHD_LIBS)
 endif

Transceiver52M/README

@@ -0,0 +1,35 @@
+The Transceiver
+
+The transceiver consists of three modules:
+   --- transceiver
+   --- radioInterface
+   --- USRPDevice
+
+The USRPDevice module is basically a driver that reads/writes
+packets to a USRP with two RFX900 daughterboards, board 
+A is the Tx chain and board B is the Rx chain.  
+
+The radioInterface module is basically an interface b/w the
+transceiver and the USRP.   It operates the basestation clock
+based upon the sample count of received USRP samples.  Packets 
+from the USRP are queued and segmented into GSM bursts that are
+passed up to the transceiver; bursts from the transceiver are
+passed down to the USRP. 
+
+The transceiver basically operates "layer 0" of the GSM stack,
+performing the modulation, detection, and demodulation of GSM 
+bursts.  It communicates with the GSM stack via three UDP sockets,
+one socket for data, one for control messages, and one socket to
+pass clocking information.  The transceiver contains a priority
+queue to sort to-be-transmitted bursts, and a filler table to fill
+in timeslots that do not have bursts in the priority queue.  The
+transceiver tries to stay ahead of the basestation clock, adapting 
+its latency when underruns are reported by the radioInterface/USRP.
+Received bursts (from the radioInterface) pass through a simple 
+energy detector, a RACH or midamble correlator, and a DFE-based demodulator.
+
+NOTE: There's a SWLOOPBACK #define statement, where the USRP is replaced
+with a memory buffer.  In this mode, data written to the USRP is actually stored 
+in a buffer, and read commands to the USRP simply pull data from this buffer.
+This was very useful in early testing, and still may be useful in testing basic
+Transceiver and radioInterface functionality. 

Transceiver52M/Resampler.cpp

@@ -2,8 +2,6 @@
  * Rational Sample Rate Conversion
  * Copyright (C) 2012, 2013  Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -13,6 +11,10 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <stdlib.h>
@@ -32,7 +34,7 @@ extern "C" {
 #define M_PI			3.14159265358979323846264338327f
 #endif
 
-#define MAX_OUTPUT_LEN		4096*4
+#define MAX_OUTPUT_LEN		4096
 
 using namespace std;
 
@@ -95,7 +97,6 @@ void Resampler::initFilters(float bw)
 		reverse(&part[0], &part[filt_len]);
 }
 
-#ifndef __OPTIMIZE__
 static bool check_vec_len(int in_len, int out_len, int p, int q)
 {
 	if (in_len % q) {
@@ -126,15 +127,14 @@ static bool check_vec_len(int in_len, int out_len, int p, int q)
 
 	return true;
 }
-#endif
 
 int Resampler::rotate(const float *in, size_t in_len, float *out, size_t out_len)
 {
 	int n, path;
-#ifndef __OPTIMIZE__
+
 	if (!check_vec_len(in_len, out_len, p, q))
 		return -1;
-#endif
+
 	/* Generate output from precomputed input/output paths */
 	for (size_t i = 0; i < out_len; i++) {
 		n = in_index[i]; 
@@ -143,7 +143,7 @@ int Resampler::rotate(const float *in, size_t in_len, float *out, size_t out_len
 		convolve_real(in, in_len,
 			      reinterpret_cast<float *>(partitions[path]),
 			      filt_len, &out[2 * i], out_len - i,
-			      n, 1);
+			      n, 1, 1, 0);
 	}
 
 	return out_len;

Transceiver52M/Resampler.h

@@ -2,8 +2,6 @@
  * Rational Sample Rate Conversion
  * Copyright (C) 2012, 2013  Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -13,6 +11,10 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #ifndef _RESAMPLER_H_
@@ -31,12 +33,12 @@ public:
 	Resampler(size_t p, size_t q, size_t filt_len = 16);
 	~Resampler();
 
-	/* Initialize resampler filterbank.
+	/* Initilize resampler filterbank.
 	 *   @param bw bandwidth factor on filter generation (pre-window)
 	 *   @return false on error, zero otherwise
 	 *
 	 * Automatic setting is to compute the filter to prevent aliasing with
-	 * a Blackman-Harris window. Adjustment is made through a bandwidth
+	 * a Blackman-Harris window. Adjustment is made through a bandwith
 	 * factor to shift the cutoff and/or the constituent filter lengths.
 	 * Calculation of specific rolloff factors or 3-dB cutoff points is
 	 * left as an excersize for the reader.

Transceiver52M/Synthesis.cpp

@@ -4,8 +4,6 @@
  * Copyright (C) 2012-2014 Tom Tsou <tom@tsou.cc>
  * Copyright (C) 2015 Ettus Research LLC
  *
- * SPDX-License-Identifier: AGPL-3.0+
- *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
@@ -31,8 +29,8 @@
 #include "Synthesis.h"
 
 extern "C" {
-#include "fft.h"
-#include "convolve.h"
+#include "common/fft.h"
+#include "common/convolve.h"
 }
 
 static void interleave(float **in, size_t ilen,
@@ -104,7 +102,7 @@ bool Synthesis::rotate(float *out, size_t len)
 		convolve_real(hInputs[i], blockLen,
 			      subFilters[i], hLen,
 			      hOutputs[i], blockLen,
-			      0, blockLen);
+			      0, blockLen, 1, 0);
 	}
 
 	/* Interleave into output vector */

Transceiver52M/Transceiver.h

@@ -1,8 +1,6 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: GPL-3.0+
-*
 * This software is distributed under the terms of the GNU Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -27,24 +25,27 @@
 #include "radioInterface.h"
 #include "Interthread.h"
 #include "GSMCommon.h"
+#include "Sockets.h"
 
 #include <sys/types.h>
 #include <sys/socket.h>
 
-extern "C" {
-#include <osmocom/core/signal.h>
-#include <osmocom/core/select.h>
-#include "config_defs.h"
-}
-
 class Transceiver;
 
-extern Transceiver *transceiver;
-
 /** Channel descriptor for transceiver object and channel number pair */
-struct TrxChanThParams {
-	Transceiver *trx;
-	size_t num;
+struct TransceiverChannel {
+  TransceiverChannel(Transceiver *trx, int num)
+  {
+    this->trx = trx;
+    this->num = num;
+  }
+
+  ~TransceiverChannel()
+  {
+  }
+
+  Transceiver *trx;
+  size_t num;
 };
 
 /** Internal transceiver state variables */
@@ -53,7 +54,7 @@ struct TransceiverState {
   ~TransceiverState();
 
   /* Initialize a multiframe slot in the filler table */
-  bool init(FillerType filler, size_t sps, float scale, size_t rtsc, unsigned rach_delay);
+  bool init(int filler, size_t sps, float scale, size_t rtsc, unsigned rach_delay);
 
   int chanType[8];
 
@@ -63,7 +64,6 @@ struct TransceiverState {
   /* The filler table */
   signalVector *fillerTable[102][8];
   int fillerModulus[8];
-  FillerType mFiller;
   bool mRetrans;
 
   /* Most recent channel estimate of all timeslots */
@@ -80,39 +80,36 @@ struct TransceiverState {
 
   /* Received noise energy levels */
   float mNoiseLev;
-  avgVector mNoises;
+  noiseVector mNoises;
 
   /* Shadowed downlink attenuation */
   int mPower;
-
-  /* RF emission and reception disabled, as per NM Administrative State Locked */
-  bool mMuted;
-
-  /* counters */
-  struct trx_counters ctrs;
-
-  /* Used to keep track of lost and out of order frames */
-  bool first_dl_fn_rcv[8];
-  GSM::Time last_dl_time_rcv[8];
 };
 
 /** The Transceiver class, responsible for physical layer of basestation */
 class Transceiver {
 public:
   /** Transceiver constructor
-      @param cfg VTY populated config
+      @param wBasePort base port number of UDP sockets
+      @param TRXAddress IP address of the TRX, as a string
+      @param GSMcoreAddress IP address of the GSM core, as a string
+      @param wSPS number of samples per GSM symbol
       @param wTransmitLatency initial setting of transmit latency
       @param radioInterface associated radioInterface object
   */
-  Transceiver(const struct trx_cfg *cfg,
+  Transceiver(int wBasePort,
+              const char *TRXAddress,
+              const char *GSMcoreAddress,
+              size_t tx_sps, size_t rx_sps, size_t chans,
               GSM::Time wTransmitLatency,
-              RadioInterface *wRadioInterface);
+              RadioInterface *wRadioInterface,
+              double wRssiOffset);
 
   /** Destructor */
   ~Transceiver();
 
   /** Start the control loop */
-  bool init(void);
+  bool init(int filler, size_t rtsc, unsigned rach_delay, bool edge);
 
   /** attach the radioInterface receive FIFO */
   bool receiveFIFO(VectorFIFO *wFIFO, size_t chan)
@@ -125,7 +122,7 @@ public:
   }
 
   /** accessor for number of channels */
-  size_t numChans() const { return cfg->num_chans; };
+  size_t numChans() const { return mChans; };
 
   /** Codes for channel combinations */
   typedef enum {
@@ -147,32 +144,22 @@ public:
     LOOPBACK            ///< similar go VII, used in loopback testing
   } ChannelCombination;
 
+  enum FillerType {
+    FILLER_DUMMY,
+    FILLER_ZERO,
+    FILLER_NORM_RAND,
+    FILLER_EDGE_RAND,
+    FILLER_ACCESS_RAND,
+  };
+
 private:
-  size_t mChans;
-struct ctrl_msg {
-  char data[101];
-  ctrl_msg() {};
-};
+  int mBasePort;
+  std::string mLocalAddr;
+  std::string mRemoteAddr;
 
-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) {
-          osmo_fd_unregister(&conn_bfd);
-          close(conn_bfd.fd);
-          conn_bfd.fd = -1;
-      }
-  }
-};
-
-  const struct trx_cfg *cfg;	///< VTY populated config
-  std::vector<int> mDataSockets;  ///< socket for writing to/reading from GSM core
-  std::vector<ctrl_sock_state> mCtrlSockets;  ///< socket for writing/reading control commands from GSM core
-  int mClockSocket;               ///< socket for writing clock updates to GSM core
+  std::vector<UDPSocket *> mDataSockets;  ///< socket for writing to/reading from GSM core
+  std::vector<UDPSocket *> mCtrlSockets;  ///< socket for writing/reading control commands from GSM core
+  UDPSocket mClockSocket;                 ///< socket for writing clock updates to GSM core
 
   std::vector<VectorQueue> mTxPriorityQueues;   ///< priority queue of transmit bursts received from GSM core
   std::vector<VectorFIFO *>  mReceiveFIFO;      ///< radioInterface FIFO of receive bursts
@@ -180,6 +167,7 @@ struct ctrl_sock_state {
   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
@@ -191,6 +179,8 @@ struct ctrl_sock_state {
   double txFullScale;                     ///< full scale input to radio
   double rxFullScale;                     ///< full scale output to radio
 
+  double rssiOffset;                      ///< RSSI to dBm conversion offset
+
   /** modulate and add a burst to the transmit queue */
   void addRadioVector(size_t chan, BitVector &bits,
                       int RSSI, GSM::Time &wTime);
@@ -202,7 +192,9 @@ struct ctrl_sock_state {
   void pushRadioVector(GSM::Time &nowTime);
 
   /** Pull and demodulate a burst from the receive FIFO */
-  int pullRadioVector(size_t chan, struct trx_ul_burst_ind *ind);
+  SoftVector *pullRadioVector(GSM::Time &wTime, double &RSSI, bool &isRssiValid,
+                              double &timingOffset, double &noise,
+                              size_t chan = 0);
 
   /** Set modulus for specific timeslot */
   void setModulus(size_t timeslot, size_t chan);
@@ -211,15 +203,13 @@ struct ctrl_sock_state {
   CorrType expectedCorrType(GSM::Time currTime, size_t chan);
 
   /** 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);
+  void writeClockInterface(void);
 
+  int mSPSTx;                          ///< number of samples per Tx symbol
+  int mSPSRx;                          ///< number of samples per Rx symbol
+  size_t mChans;
 
+  bool mEdge;
   bool mOn;	                           ///< flag to indicate that transceiver is powered on
   bool mForceClockInterface;           ///< flag to indicate whether IND CLOCK shall be sent unconditionally after transceiver is started
   bool mHandover[8][8];                ///< expect handover to the timeslot/subslot
@@ -230,48 +220,62 @@ struct ctrl_sock_state {
   unsigned mMaxExpectedDelayNB;        ///< maximum expected time-of-arrival offset in GSM symbols for Normal Bursts
   unsigned mWriteBurstToDiskMask;      ///< debug: bitmask to indicate which timeslots to dump to disk
 
-  std::vector<unsigned> mVersionTRXD;  ///< Format version to use for TRXD protocol communication, per channel
   std::vector<TransceiverState> mStates;
 
   /** Start and stop I/O threads through the control socket API */
   bool start();
   void stop();
 
-  /** Protect destructor accessible stop call */
+  /** Protect destructor accessable stop call */
   Mutex mLock;
 
 protected:
   /** drive lower receive I/O and burst generation */
-  bool driveReceiveRadio();
+  void driveReceiveRadio();
 
   /** drive demodulation of GSM bursts */
-  bool driveReceiveFIFO(size_t chan);
+  void driveReceiveFIFO(size_t chan);
 
   /** drive transmission of GSM bursts */
   void driveTxFIFO();
 
+  /** drive handling of control messages from GSM core */
+  void driveControl(size_t chan);
+
   /**
     drive modulation and sorting of GSM bursts from GSM core
     @return true if a burst was transferred successfully
   */
   bool driveTxPriorityQueue(size_t chan);
 
-  friend void *RxUpperLoopAdapter(TrxChanThParams *params);
-  friend void *TxUpperLoopAdapter(TrxChanThParams *params);
-  friend void *RxLowerLoopAdapter(Transceiver *transceiver);
-  friend void *TxLowerLoopAdapter(Transceiver *transceiver);
+  friend void *RxUpperLoopAdapter(TransceiverChannel *);
+
+  friend void *TxUpperLoopAdapter(TransceiverChannel *);
+
+  friend void *RxLowerLoopAdapter(Transceiver *);
+
+  friend void *TxLowerLoopAdapter(Transceiver *);
+
+  friend void *ControlServiceLoopAdapter(TransceiverChannel *);
+
 
-  double rssiOffset(size_t chan);
   void reset();
 
-  void logRxBurst(size_t chan, const struct trx_ul_burst_ind *bi);
+  /** set priority on current thread */
+  void setPriority(float prio = 0.5) { mRadioInterface->setPriority(prio); }
+
+  void logRxBurst(size_t chan, SoftVector *burst, GSM::Time time, double dbm,
+                  double rssi, double noise, double toa);
 };
 
-void *RxUpperLoopAdapter(TrxChanThParams *params);
+void *RxUpperLoopAdapter(TransceiverChannel *);
 
 /** Main drive threads */
-void *RxLowerLoopAdapter(Transceiver *transceiver);
-void *TxLowerLoopAdapter(Transceiver *transceiver);
+void *RxLowerLoopAdapter(Transceiver *);
+void *TxLowerLoopAdapter(Transceiver *);
+
+/** control message handler thread loop */
+void *ControlServiceLoopAdapter(TransceiverChannel *);
 
 /** transmit queueing thread loop */
-void *TxUpperLoopAdapter(TrxChanThParams *params);
+void *TxUpperLoopAdapter(TransceiverChannel *);

Transceiver52M/USRPDevice.cpp

@@ -1,8 +1,6 @@
 /*
 * Copyright 2008, 2009 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -60,14 +58,14 @@ const dboardConfigType dboardConfig = TXA_RXB;
 
 const double USRPDevice::masterClockRate = 52.0e6;
 
-USRPDevice::USRPDevice(InterfaceType iface, const struct trx_cfg *cfg) : RadioDevice(iface, cfg)
+USRPDevice::USRPDevice(size_t sps)
 {
-  LOGC(DDEV, INFO) << "creating USRP device...";
+  LOG(INFO) << "creating USRP device...";
 
-  decimRate = (unsigned int) round(masterClockRate/((GSMRATE) * (double) tx_sps));
+  this->sps = sps;
+  decimRate = (unsigned int) round(masterClockRate/((GSMRATE) * (double) sps));
   actualSampleRate = masterClockRate/decimRate;
   rxGain = 0;
-  txGain = 0;
 
   /*
    * Undetermined delay b/w ping response timestamp and true
@@ -75,9 +73,9 @@ USRPDevice::USRPDevice(InterfaceType iface, const struct trx_cfg *cfg) : RadioDe
    * split sample rate Tx/Rx - 4/1 sps we need to need to
    * compensate for advance rather than delay.
    */
-  if (tx_sps == 1)
+  if (sps == 1)
     pingOffset = 272;
-  else if (tx_sps == 4)
+  else if (sps == 4)
     pingOffset = 269 - 7500;
   else
     pingOffset = 0;
@@ -90,36 +88,38 @@ USRPDevice::USRPDevice(InterfaceType iface, const struct trx_cfg *cfg) : RadioDe
 #endif
 }
 
-int USRPDevice::open()
+int USRPDevice::open(const std::string &, int, bool)
 {
   writeLock.unlock();
 
-  LOGC(DDEV, INFO) << "opening USRP device..";
+  LOG(INFO) << "opening USRP device..";
 #ifndef SWLOOPBACK
   string rbf = "std_inband.rbf";
   //string rbf = "inband_1rxhb_1tx.rbf";
   m_uRx.reset();
+  if (!skipRx) {
   try {
     m_uRx = usrp_standard_rx_sptr(usrp_standard_rx::make(
-                                        0, decimRate * tx_sps, 1, -1,
+                                        0, decimRate * sps, 1, -1,
                                         usrp_standard_rx::FPGA_MODE_NORMAL,
                                         1024, 16 * 8, rbf));
     m_uRx->set_fpga_master_clock_freq(masterClockRate);
   }
 
   catch(...) {
-    LOGC(DDEV, ALERT) << "make failed on Rx";
+    LOG(ALERT) << "make failed on Rx";
     m_uRx.reset();
     return -1;
   }
 
   if (m_uRx->fpga_master_clock_freq() != masterClockRate)
   {
-    LOGC(DDEV, ALERT) << "WRONG FPGA clock freq = " << m_uRx->fpga_master_clock_freq()
+    LOG(ALERT) << "WRONG FPGA clock freq = " << m_uRx->fpga_master_clock_freq()
                << ", desired clock freq = " << masterClockRate;
     m_uRx.reset();
     return -1;
   }
+  }
 
   try {
     m_uTx = usrp_standard_tx_sptr(usrp_standard_tx::make(
@@ -129,20 +129,20 @@ int USRPDevice::open()
   }
 
   catch(...) {
-    LOGC(DDEV, ALERT) << "make failed on Tx";
+    LOG(ALERT) << "make failed on Tx";
     m_uTx.reset();
     return -1;
   }
 
   if (m_uTx->fpga_master_clock_freq() != masterClockRate)
   {
-    LOGC(DDEV, ALERT) << "WRONG FPGA clock freq = " << m_uTx->fpga_master_clock_freq()
+    LOG(ALERT) << "WRONG FPGA clock freq = " << m_uTx->fpga_master_clock_freq()
                << ", desired clock freq = " << masterClockRate;
     m_uTx.reset();
     return -1;
   }
 
-  m_uRx->stop();
+  if (!skipRx) m_uRx->stop();
   m_uTx->stop();
 
 #endif
@@ -172,6 +172,8 @@ int USRPDevice::open()
   m_dbTx = m_uTx->selected_subdev(txSubdevSpec);
   m_dbRx = m_uRx->selected_subdev(rxSubdevSpec);
 
+  samplesRead = 0;
+  samplesWritten = 0;
   started = false;
 
   return NORMAL;
@@ -181,12 +183,12 @@ int USRPDevice::open()
 
 bool USRPDevice::start()
 {
-  LOGC(DDEV, INFO) << "starting USRP...";
+  LOG(INFO) << "starting USRP...";
 #ifndef SWLOOPBACK
-  if (!m_uRx) return false;
+  if (!m_uRx && !skipRx) return false;
   if (!m_uTx) return false;
 
-  m_uRx->stop();
+  if (!skipRx) m_uRx->stop();
   m_uTx->stop();
 
   writeLock.lock();
@@ -201,8 +203,8 @@ bool USRPDevice::start()
   writeLock.unlock();
 
   // Set gains to midpoint
-  setTxGain((m_dbTx->gain_min() + m_dbTx->gain_max()) / 2);
-  setRxGain((m_dbTx->gain_min() + m_dbTx->gain_max()) / 2);
+  setTxGain((minTxGain() + maxTxGain()) / 2);
+  setRxGain((minRxGain() + maxRxGain()) / 2);
 
   data = new short[currDataSize];
   dataStart = 0;
@@ -216,7 +218,10 @@ bool USRPDevice::start()
   isAligned = false;
 
 
+  if (!skipRx)
   started = (m_uRx->start() && m_uTx->start());
+  else
+  started = m_uTx->start();
   return started;
 #else
   gettimeofday(&lastReadTime,NULL);
@@ -239,6 +244,16 @@ 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();
@@ -252,32 +267,31 @@ double USRPDevice::minRxGain()
 double USRPDevice::setTxGain(double dB, size_t chan)
 {
   if (chan) {
-    LOGC(DDEV, ALERT) << "Invalid channel " << chan;
+    LOG(ALERT) << "Invalid channel " << chan;
     return 0.0;
   }
 
   writeLock.lock();
-  if (dB > m_dbTx->gain_max())
-    dB = m_dbTx->gain_max();
-  if (dB < m_dbTx->gain_min())
-    dB = m_dbTx->gain_min();
+  if (dB > maxTxGain())
+    dB = maxTxGain();
+  if (dB < minTxGain())
+    dB = minTxGain();
 
-  LOGC(DDEV, NOTICE) << "Setting TX gain to " << dB << " dB.";
+  LOG(NOTICE) << "Setting TX gain to " << dB << " dB.";
 
   if (!m_dbTx->set_gain(dB))
-    LOGC(DDEV, ERR) << "Error setting TX gain";
-  else
-    txGain = dB;
+    LOG(ERR) << "Error setting TX gain";
+
   writeLock.unlock();
 
-  return txGain;
+  return dB;
 }
 
 
 double USRPDevice::setRxGain(double dB, size_t chan)
 {
   if (chan) {
-    LOGC(DDEV, ALERT) << "Invalid channel " << chan;
+    LOG(ALERT) << "Invalid channel " << chan;
     return 0.0;
   }
 
@@ -289,86 +303,60 @@ double USRPDevice::setRxGain(double dB, size_t chan)
   if (dB < minRxGain())
     dB = minRxGain();
 
-  LOGC(DDEV, NOTICE) << "Setting RX gain to " << dB << " dB.";
+  LOG(NOTICE) << "Setting RX gain to " << dB << " dB.";
 
   if (!m_dbRx->set_gain(dB))
-    LOGC(DDEV, ERR) << "Error setting RX gain";
-  else
-    rxGain = dB;
+    LOG(ERR) << "Error setting RX gain";
+
   writeLock.unlock();
 
-  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;
+  return dB;
 }
 
 bool USRPDevice::setRxAntenna(const std::string &ant, size_t chan)
 {
 	if (chan >= rx_paths.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		LOG(ALERT) << "Requested non-existent channel " << chan;
 		return false;
 	}
-	LOGC(DDEV, ALERT) << "Not implemented";
+	LOG(ALERT) << "Not implemented";
 	return true;
 }
 
 std::string USRPDevice::getRxAntenna(size_t chan)
 {
 	if (chan >= rx_paths.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		LOG(ALERT) << "Requested non-existent channel " << chan;
 		return "";
 	}
-	LOGC(DDEV, ALERT) << "Not implemented";
+	LOG(ALERT) << "Not implemented";
 	return "";
 }
 
 bool USRPDevice::setTxAntenna(const std::string &ant, size_t chan)
 {
 	if (chan >= tx_paths.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		LOG(ALERT) << "Requested non-existent channel " << chan;
 		return false;
 	}
-	LOGC(DDEV, ALERT) << "Not implemented";
+	LOG(ALERT) << "Not implemented";
 	return true;
 }
 
 std::string USRPDevice::getTxAntenna(size_t chan)
 {
 	if (chan >= tx_paths.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		LOG(ALERT) << "Requested non-existent channel " << chan;
 		return "";
 	}
-	LOGC(DDEV, ALERT) << "Not implemented";
+	LOG(ALERT) << "Not implemented";
 	return "";
 }
 
-bool USRPDevice::requiresRadioAlign()
-{
-	return true;
-}
-
-GSM::Time USRPDevice::minLatency() {
-	return GSM::Time(1,1);
-}
 
 // NOTE: Assumes sequential reads
 int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
-                            TIMESTAMP timestamp, bool *underrun)
+                            TIMESTAMP timestamp, bool *underrun, unsigned *RSSI)
 {
 #ifndef SWLOOPBACK
   if (!m_uRx)
@@ -383,7 +371,7 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
     return len;
   }
 
-  *underrun = false;
+  if (underrun) *underrun = false;
 
   uint32_t readBuf[2000];
 
@@ -399,18 +387,18 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
 
     // read USRP packets, parse and save A/D data as needed
     readLen = m_uRx->read((void *)readBuf,readLen,overrun);
-    for (int pktNum = 0; pktNum < (readLen/512); pktNum++) {
+    for(int pktNum = 0; pktNum < (readLen/512); pktNum++) {
       // tmpBuf points to start of a USB packet
       uint32_t* tmpBuf = (uint32_t *) (readBuf+pktNum*512/4);
       TIMESTAMP pktTimestamp = usrp_to_host_u32(tmpBuf[1]);
       uint32_t word0 = usrp_to_host_u32(tmpBuf[0]);
       uint32_t chan = (word0 >> 16) & 0x1f;
       unsigned payloadSz = word0 & 0x1ff;
-      LOGC(DDEV, DEBUG) << "first two bytes: " << hex << word0 << " " << dec << pktTimestamp;
+      LOG(DEBUG) << "first two bytes: " << hex << word0 << " " << dec << pktTimestamp;
 
       bool incrementHi32 = ((lastPktTimestamp & 0x0ffffffffll) > pktTimestamp);
       if (incrementHi32 && (timeStart!=0)) {
-           LOGC(DDEV, DEBUG) << "high 32 increment!!!";
+           LOG(DEBUG) << "high 32 increment!!!";
            hi32Timestamp++;
       }
       pktTimestamp = (((TIMESTAMP) hi32Timestamp) << 32) | pktTimestamp;
@@ -422,24 +410,22 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
 	if ((word2 >> 16) == ((0x01 << 8) | 0x02)) {
           timestamp -= timestampOffset;
 	  timestampOffset = pktTimestamp - pingTimestamp + pingOffset;
-	  LOGC(DDEV, DEBUG) << "updating timestamp offset to: " << timestampOffset;
+	  LOG(DEBUG) << "updating timestamp offset to: " << timestampOffset;
           timestamp += timestampOffset;
 	  isAligned = true;
 	}
 	continue;
       }
       if (chan != 0) {
-	LOGC(DDEV, DEBUG) << "chan: " << chan << ", timestamp: " << pktTimestamp << ", sz:" << payloadSz;
+	LOG(DEBUG) << "chan: " << chan << ", timestamp: " << pktTimestamp << ", sz:" << payloadSz;
 	continue;
       }
       if ((word0 >> 28) & 0x04) {
-	*underrun = true;
-	LOGC(DDEV, DEBUG) << "UNDERRUN in TRX->USRP interface";
+	if (underrun) *underrun = true;
+	LOG(DEBUG) << "UNDERRUN in TRX->USRP interface";
       }
-#if 0
-      /* FIXME: Do something with this ? */
-      unsigned RSSI = (word0 >> 21) & 0x3f;
-#endif
+      if (RSSI) *RSSI = (word0 >> 21) & 0x3f;
+
       if (!isAligned) continue;
 
       unsigned cursorStart = pktTimestamp - timeStart + dataStart;
@@ -457,7 +443,7 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
       if (pktTimestamp + payloadSz/2/sizeof(short) > timeEnd)
 	timeEnd = pktTimestamp+payloadSz/2/sizeof(short);
 
-      LOGC(DDEV, DEBUG) << "timeStart: " << timeStart << ", timeEnd: " << timeEnd << ", pktTimestamp: " << pktTimestamp;
+      LOG(DEBUG) << "timeStart: " << timeStart << ", timeEnd: " << timeEnd << ", pktTimestamp: " << pktTimestamp;
 
     }
   }
@@ -465,14 +451,14 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
   // copy desired data to buf
   unsigned bufStart = dataStart+(timestamp-timeStart);
   if (bufStart + len < currDataSize/2) {
-    LOGC(DDEV, DEBUG) << "bufStart: " << bufStart;
+    LOG(DEBUG) << "bufStart: " << bufStart;
     memcpy(buf,data+bufStart*2,len*2*sizeof(short));
     memset(data+bufStart*2,0,len*2*sizeof(short));
   }
   else {
-    LOGC(DDEV, DEBUG) << "len: " << len << ", currDataSize/2: " << currDataSize/2 << ", bufStart: " << bufStart;
+    LOG(DEBUG) << "len: " << len << ", currDataSize/2: " << currDataSize/2 << ", bufStart: " << bufStart;
     unsigned firstLength = (currDataSize/2-bufStart);
-    LOGC(DDEV, DEBUG) << "firstLength: " << firstLength;
+    LOG(DEBUG) << "firstLength: " << firstLength;
     memcpy(buf,data+bufStart*2,firstLength*2*sizeof(short));
     memset(data+bufStart*2,0,firstLength*2*sizeof(short));
     memcpy(buf+firstLength*2,data,(len-firstLength)*2*sizeof(short));
@@ -513,13 +499,15 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
     gettimeofday(&lastReadTime,NULL);
     firstRead = true;
   }
+  samplesRead += numSamples;
 
   return numSamples;
 #endif
 }
 
-int USRPDevice::writeSamplesControl(std::vector<short *> &bufs, int len,
-                             bool *underrun, unsigned long long timestamp, bool isControl)
+int USRPDevice::writeSamples(std::vector<short *> &bufs, int len,
+                             bool *underrun, unsigned long long timestamp,
+                             bool isControl)
 {
   writeLock.lock();
 
@@ -561,33 +549,30 @@ int USRPDevice::writeSamplesControl(std::vector<short *> &bufs, int len,
   }
   m_uTx->write((const void*) outPkt,sizeof(uint32_t)*128*numPkts,NULL);
 
+  samplesWritten += len/2/sizeof(short);
   writeLock.unlock();
 
   return len/2/sizeof(short);
 #else
   int retVal = len;
   memcpy(loopbackBuffer+loopbackBufferSize,buf,sizeof(short)*2*len);
+  samplesWritten += retVal;
   loopbackBufferSize += retVal*2;
 
   return retVal;
 #endif
 }
 
-int USRPDevice::writeSamples(std::vector<short *> &bufs, int len,
-                             bool *underrun, unsigned long long timestamp)
-{
-  return writeSamplesControl(bufs, len, underrun, timestamp, false);
-}
-
 bool USRPDevice::updateAlignment(TIMESTAMP timestamp)
 {
 #ifndef SWLOOPBACK
   short data[] = {0x00,0x02,0x00,0x00};
-  /* FIXME: big endian */
+  uint32_t *wordPtr = (uint32_t *) data;
+  *wordPtr = host_to_usrp_u32(*wordPtr);
   bool tmpUnderrun;
 
   std::vector<short *> buf(1, data);
-  if (writeSamplesControl(buf, 1, &tmpUnderrun, timestamp & 0x0ffffffffll, true)) {
+  if (writeSamples(buf, 1, &tmpUnderrun, timestamp & 0x0ffffffffll, true)) {
     pingTimestamp = timestamp;
     return true;
   }
@@ -603,19 +588,19 @@ bool USRPDevice::setTxFreq(double wFreq, size_t chan)
   usrp_tune_result result;
 
   if (chan) {
-    LOGC(DDEV, ALERT) << "Invalid channel " << chan;
+    LOG(ALERT) << "Invalid channel " << chan;
     return false;
   }
 
   if (m_uTx->tune(txSubdevSpec.side, m_dbTx, wFreq, &result)) {
-    LOGC(DDEV, INFO) << "set TX: " << wFreq << std::endl
+    LOG(INFO) << "set TX: " << wFreq << std::endl
               << "    baseband freq: " << result.baseband_freq << std::endl
               << "    DDC freq:      " << result.dxc_freq << std::endl
               << "    residual freq: " << result.residual_freq;
     return true;
   }
   else {
-    LOGC(DDEV, ALERT) << "set TX: " << wFreq << " failed" << std::endl
+    LOG(ALERT) << "set TX: " << wFreq << "failed" << std::endl
                << "    baseband freq: " << result.baseband_freq << std::endl
                << "    DDC freq:      " << result.dxc_freq << std::endl
                << "    residual freq: " << result.residual_freq;
@@ -628,19 +613,19 @@ bool USRPDevice::setRxFreq(double wFreq, size_t chan)
   usrp_tune_result result;
 
   if (chan) {
-    LOGC(DDEV, ALERT) << "Invalid channel " << chan;
+    LOG(ALERT) << "Invalid channel " << chan;
     return false;
   }
 
   if (m_uRx->tune(0, m_dbRx, wFreq, &result)) {
-    LOGC(DDEV, INFO) << "set RX: " << wFreq << std::endl
+    LOG(INFO) << "set RX: " << wFreq << std::endl
               << "    baseband freq: " << result.baseband_freq << std::endl
               << "    DDC freq:      " << result.dxc_freq << std::endl
               << "    residual freq: " << result.residual_freq;
     return true;
   }
   else {
-    LOGC(DDEV, ALERT) << "set RX: " << wFreq << " failed" << std::endl
+    LOG(ALERT) << "set RX: " << wFreq << "failed" << std::endl
                << "    baseband freq: " << result.baseband_freq << std::endl
                << "    DDC freq:      " << result.dxc_freq << std::endl
                << "    residual freq: " << result.residual_freq;
@@ -654,19 +639,10 @@ bool USRPDevice::setTxFreq(double wFreq) { return true;};
 bool USRPDevice::setRxFreq(double wFreq) { return true;};
 #endif
 
-RadioDevice *RadioDevice::make(InterfaceType type, const struct trx_cfg *cfg)
+RadioDevice *RadioDevice::make(size_t tx_sps, size_t rx_sps,
+			       InterfaceType iface, size_t chans, double offset,
+			       const std::vector<std::string>& tx_paths,
+			       const std::vector<std::string>& rx_paths)
 {
-  if (cfg->tx_sps != cfg->rx_sps) {
-    LOGC(DDEV, ERROR) << "USRP1 requires tx_sps == rx_sps";
-    return NULL;
-  }
-  if (cfg->num_chans != 1) {
-    LOGC(DDEV, ERROR) << "USRP1 supports only 1 channel";
-    return NULL;
-  }
-  if (cfg->offset != 0.0) {
-    LOGC(DDEV, ERROR) << "USRP1 doesn't support lo_offset";
-    return NULL;
-  }
-  return new USRPDevice(type, cfg);
+	return new USRPDevice(tx_sps);
 }

Transceiver52M/USRPDevice.h

@@ -1,10 +1,7 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* 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 software is distributed under multiple licenses; see the COPYING file in the main directory for licensing information for this specific distribuion.
 *
 * This use of this software may be subject to additional restrictions.
 * See the LEGAL file in the main directory for details.
@@ -51,10 +48,15 @@ private:
   usrp_subdev_spec rxSubdevSpec;
   usrp_subdev_spec txSubdevSpec;
 
+  int sps;
   double actualSampleRate;	///< the actual USRP sampling rate
   unsigned int decimRate;	///< the USRP decimation rate
 
+  unsigned long long samplesRead;	///< number of samples read from USRP
+  unsigned long long samplesWritten;	///< number of samples sent to USRP
+
   bool started;			///< flag indicates USRP has started
+  bool skipRx;			///< set if USRP is transmit-only.
 
   static const unsigned int currDataSize_log2 = 21;
   static const unsigned long currDataSize = (1 << currDataSize_log2);
@@ -80,16 +82,6 @@ private:
   unsigned long lastPktTimestamp;
 
   double rxGain;
-  double txGain;
-
-  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];
@@ -104,21 +96,21 @@ private:
  public:
 
   /** Object constructor */
-     USRPDevice(InterfaceType iface, const struct trx_cfg *cfg);
+  USRPDevice(size_t sps);
 
-     /** Instantiate the USRP */
-     int open();
+  /** Instantiate the USRP */
+  int open(const std::string &, int, bool);
 
-     /** Start the USRP */
-     bool start();
+  /** Start the USRP */
+  bool start();
 
-     /** Stop the USRP */
-     bool stop();
+  /** Stop the USRP */
+  bool stop();
 
-     enum TxWindowType getWindowType()
-     {
-	     return TX_WINDOW_USRP1;
-     }
+  /** Set priority not supported */
+  void setPriority(float prio = 0.5) { }
+
+  enum TxWindowType getWindowType() { return TX_WINDOW_USRP1; }
 
   /**
 	Read samples from the USRP.
@@ -127,20 +119,23 @@ private:
 	@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 USRP does not have data to transmit, e.g. data not being sent fast enough
+	@param RSSI The received signal strength of the read result
 	@return The number of samples actually read
   */
   int readSamples(std::vector<short *> &buf, int len, bool *overrun,
-                  TIMESTAMP timestamp = 0xffffffff, bool *underrun = NULL);
+                  TIMESTAMP timestamp = 0xffffffff, bool *underrun = NULL,
+                  unsigned *RSSI = NULL);
   /**
         Write samples to the USRP.
         @param buf Contains the data to be written.
         @param len number of samples to write.
         @param underrun Set if USRP 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.
+        @param isControl Set if data is a control packet, e.g. a ping command
         @return The number of samples actually written
   */
   int writeSamples(std::vector<short *> &bufs, int len, bool *underrun,
-                   TIMESTAMP timestamp = 0xffffffff);
+                   TIMESTAMP timestamp = 0xffffffff, bool isControl = false);
 
   /** Update the alignment between the read and write timestamps */
   bool updateAlignment(TIMESTAMP timestamp);
@@ -175,12 +170,14 @@ private:
   /** return minimum Rx Gain **/
   double minRxGain(void);
 
-  double rssiOffset(size_t chan) { return 0.0f;  } /* FIXME: not implemented */
+  /** 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);
+  /** return maximum Tx Gain **/
+  double maxTxGain(void);
 
-  int getNominalTxPower(size_t chan = 0);
+  /** return minimum Rx Gain **/
+  double minTxGain(void);
 
   /** sets the RX path to use, returns true if successful and false otherwise */
   bool setRxAntenna(const std::string &ant, size_t chan = 0);
@@ -194,16 +191,14 @@ private:
   /* return the used RX path */
   std::string getTxAntenna(size_t chan = 0);
 
-  /** return whether user drives synchronization of Tx/Rx of USRP */
-  bool requiresRadioAlign();
-
-  /** return whether user drives synchronization of Tx/Rx of USRP */
-  virtual GSM::Time minLatency();
-
   /** Return internal status values */
   inline double getTxFreq(size_t chan = 0) { return 0; }
   inline double getRxFreq(size_t chan = 0) { return 0; }
   inline double getSampleRate() { return actualSampleRate; }
+  inline double numberRead() { return samplesRead; }
+  inline double numberWritten() { return samplesWritten; }
+
+  std::vector<std::string> tx_paths, rx_paths;
 };
 
 #endif // _USRP_DEVICE_H_

Transceiver52M/arch/Makefile.am

@@ -1,8 +0,0 @@
-include $(top_srcdir)/Makefile.common
-
-SUBDIRS = common
-if ARCH_ARM
-SUBDIRS += arm
-else
-SUBDIRS += x86
-endif

Transceiver52M/arch/common/Makefile.am

@@ -1,15 +0,0 @@
-AM_CFLAGS = -Wall -std=gnu99
-
-noinst_LTLIBRARIES = libarch_common.la
-
-noinst_HEADERS = \
-        convolve.h \
-        convert.h \
-        scale.h \
-        mult.h \
-        fft.h
-
-libarch_common_la_SOURCES = \
-        convolve_base.c \
-        convert_base.c \
-        fft.c

Transceiver52M/arm/Makefile.am

@@ -1,17 +1,17 @@
+if ARCH_ARM
 if ARCH_ARM_A15
 ARCH_FLAGS = -mfpu=neon-vfpv4
 else
 ARCH_FLAGS = -mfpu=neon
 endif
 
-AM_CFLAGS = -Wall $(ARCH_FLAGS) -std=gnu99 -I${srcdir}/../common
+AM_CFLAGS = -Wall $(ARCH_FLAGS) -std=gnu99 -I../common
 AM_CCASFLAGS = $(ARCH_FLAGS)
 
 noinst_LTLIBRARIES = libarch.la
 
-libarch_la_LIBADD = $(top_builddir)/Transceiver52M/arch/common/libarch_common.la
-
 libarch_la_SOURCES = \
+	../common/convolve_base.c \
 	convert.c \
 	convert_neon.S \
 	convolve.c \
@@ -20,3 +20,4 @@ libarch_la_SOURCES = \
 	scale_neon.S \
 	mult.c \
 	mult_neon.S
+endif

Transceiver52M/arm/convert.c

@@ -2,8 +2,6 @@
  * NEON type conversions
  * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -13,6 +11,10 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>

Transceiver52M/arm/convert_neon.S

@@ -2,8 +2,6 @@
  * NEON type conversions
  * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -13,6 +11,10 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 	.syntax unified

Transceiver52M/arm/convolve.c

@@ -2,8 +2,6 @@
  * NEON Convolution
  * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -13,6 +11,10 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>
@@ -27,15 +29,17 @@
 int _base_convolve_real(float *x, int x_len,
 			float *h, int h_len,
 			float *y, int y_len,
-			int start, int len);
+			int start, int len,
+			int step, int offset);
 
 int _base_convolve_complex(float *x, int x_len,
 			   float *h, int h_len,
 			   float *y, int y_len,
-			   int start, int len);
+			   int start, int len,
+			   int step, int offset);
 
 int bounds_check(int x_len, int h_len, int y_len,
-		 int start, int len);
+		 int start, int len, int step);
 
 #ifdef HAVE_NEON
 /* Calls into NEON assembler */
@@ -54,7 +58,7 @@ static void neon_conv_cmplx_4n(float *x, float *h, float *y, int h_len, int len)
 }
 #endif
 
-/* API: Initialize convolve module */
+/* API: Initalize convolve module */
 void convolve_init(void)
 {
 	/* Stub */
@@ -65,32 +69,35 @@ void convolve_init(void)
 int convolve_real(float *x, int x_len,
 		  float *h, int h_len,
 		  float *y, int y_len,
-		  int start, int len)
+		  int start, int len,
+		  int step, int offset)
 {
 	void (*conv_func)(float *, float *, float *, int) = NULL;
 
-	if (bounds_check(x_len, h_len, y_len, start, len) < 0)
+	if (bounds_check(x_len, h_len, y_len, start, len, step) < 0)
 		return -1;
 
 	memset(y, 0, len * 2 * sizeof(float));
 
 #ifdef HAVE_NEON
-	switch (h_len) {
-	case 4:
-		conv_func = neon_conv_real4;
-		break;
-	case 8:
-		conv_func = neon_conv_real8;
-		break;
-	case 12:
-		conv_func = neon_conv_real12;
-		break;
-	case 16:
-		conv_func = neon_conv_real16;
-		break;
-	case 20:
-		conv_func = neon_conv_real20;
-		break;
+	if (step <= 4) {
+		switch (h_len) {
+		case 4:
+			conv_func = neon_conv_real4;
+			break;
+		case 8:
+			conv_func = neon_conv_real8;
+			break;
+		case 12:
+			conv_func = neon_conv_real12;
+			break;
+		case 16:
+			conv_func = neon_conv_real16;
+			break;
+		case 20:
+			conv_func = neon_conv_real20;
+			break;
+		}
 	}
 #endif
 	if (conv_func) {
@@ -100,7 +107,7 @@ int convolve_real(float *x, int x_len,
 		_base_convolve_real(x, x_len,
 				    h, h_len,
 				    y, y_len,
-				    start, len);
+				    start, len, step, offset);
 	}
 
 	return len;
@@ -111,17 +118,18 @@ int convolve_real(float *x, int x_len,
 int convolve_complex(float *x, int x_len,
 		     float *h, int h_len,
 		     float *y, int y_len,
-		     int start, int len)
+		     int start, int len,
+		     int step, int offset)
 {
 	void (*conv_func)(float *, float *, float *, int, int) = NULL;
 
-	if (bounds_check(x_len, h_len, y_len, start, len) < 0)
+	if (bounds_check(x_len, h_len, y_len, start, len, step) < 0)
 		return -1;
 
 	memset(y, 0, len * 2 * sizeof(float));
 
 #ifdef HAVE_NEON
-	if (!(h_len % 4))
+	if (step <= 4 && !(h_len % 4))
 		conv_func = neon_conv_cmplx_4n;
 #endif
 	if (conv_func) {
@@ -131,7 +139,7 @@ int convolve_complex(float *x, int x_len,
 		_base_convolve_complex(x, x_len,
 				       h, h_len,
 				       y, y_len,
-				       start, len);
+				       start, len, step, offset);
 	}
 
 	return len;

Transceiver52M/arm/convolve_neon.S

@@ -2,8 +2,6 @@
  * NEON Convolution
  * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -13,6 +11,10 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #ifdef HAVE_CONFIG_H
@@ -90,8 +92,8 @@ neon_conv_real12:
 	vld2.32     {q8-q9}, [r4], r6
 	vld2.32   {q10-q11}, [r5], r6
 #ifdef HAVE_NEON_FMA
-	vmul.f32         q1,   q6, q0
-	vmul.f32         q3,   q7, q0
+	vfma.f32         q1,   q6, q0
+	vfma.f32         q3,   q7, q0
 	vfma.f32         q1,   q8, q2
 	vfma.f32         q3,   q9, q2
 	vfma.f32         q1,  q10, q4

Transceiver52M/arm/mult.c

@@ -2,8 +2,6 @@
  * NEON scaling
  * Copyright (C) 2012,2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -13,6 +11,10 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>

Transceiver52M/arm/mult_neon.S

@@ -2,8 +2,6 @@
  * NEON complex multiplication 
  * Copyright (C) 2012,2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -13,6 +11,10 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 	.syntax unified

Transceiver52M/arm/scale.c

@@ -2,8 +2,6 @@
  * NEON scaling
  * Copyright (C) 2012,2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -13,6 +11,10 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>

Transceiver52M/arm/scale_neon.S

@@ -2,8 +2,6 @@
  * ARM NEON Scaling
  * Copyright (C) 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -13,6 +11,10 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 	.syntax unified

Transceiver52M/common/convert_base.c

@@ -2,8 +2,6 @@
  * Conversion
  * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -13,6 +11,10 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include "convert.h"
@@ -29,3 +31,4 @@ void base_convert_short_float(float *out, const short *in, int len)
 	for (int i = 0; i < len; i++)
 		out[i] = in[i];
 }
+

Transceiver52M/common/convolve.h

@@ -1,27 +1,31 @@
 #ifndef _CONVOLVE_H_
 #define _CONVOLVE_H_
 
-void *convolve_h_alloc(size_t num);
+void *convolve_h_alloc(int num);
 
 int convolve_real(const float *x, int x_len,
 		  const float *h, int h_len,
 		  float *y, int y_len,
-		  int start, int len);
+		  int start, int len,
+		  int step, int offset);
 
 int convolve_complex(const float *x, int x_len,
 		     const float *h, int h_len,
 		     float *y, int y_len,
-		     int start, int len);
+		     int start, int len,
+		     int step, int offset);
 
 int base_convolve_real(const float *x, int x_len,
 		       const float *h, int h_len,
 		       float *y, int y_len,
-		       int start, int len);
+		       int start, int len,
+		       int step, int offset);
 
 int base_convolve_complex(const float *x, int x_len,
 			  const float *h, int h_len,
 			  float *y, int y_len,
-			  int start, int len);
+			  int start, int len,
+			  int step, int offset);
 
 void convolve_init(void);
 

Transceiver52M/common/convolve_base.c

@@ -2,8 +2,6 @@
  * Convolution
  * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -13,6 +11,10 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include <malloc.h>
@@ -39,17 +41,17 @@ static void mac_cmplx(const float *x, const float *h, float *y)
 
 /* Base vector complex-complex multiply and accumulate */
 static void mac_real_vec_n(const float *x, const float *h, float *y,
-			   int len)
+			   int len, int step, int offset)
 {
-	for (int i=0; i<len; i++)
+	for (int i = offset; i < len; i += step)
 		mac_real(&x[2 * i], &h[2 * i], y);
 }
 
 /* Base vector complex-complex multiply and accumulate */
 static void mac_cmplx_vec_n(const float *x, const float *h, float *y,
-			    int len)
+			    int len, int step, int offset)
 {
-	for (int i=0; i<len; i++)
+	for (int i = offset; i < len; i += step)
 		mac_cmplx(&x[2 * i], &h[2 * i], y);
 }
 
@@ -57,12 +59,14 @@ static void mac_cmplx_vec_n(const float *x, const float *h, float *y,
 int _base_convolve_real(const float *x, int x_len,
 			const float *h, int h_len,
 			float *y, int y_len,
-			int start, int len)
+			int start, int len,
+			int step, int offset)
 {
 	for (int i = 0; i < len; i++) {
 		mac_real_vec_n(&x[2 * (i - (h_len - 1) + start)],
 			       h,
-			       &y[2 * i], h_len);
+			       &y[2 * i], h_len,
+			       step, offset);
 	}
 
 	return len;
@@ -72,13 +76,14 @@ int _base_convolve_real(const float *x, int x_len,
 int _base_convolve_complex(const float *x, int x_len,
 			   const float *h, int h_len,
 			   float *y, int y_len,
-			   int start, int len)
+			   int start, int len,
+			   int step, int offset)
 {
 	for (int i = 0; i < len; i++) {
 		mac_cmplx_vec_n(&x[2 * (i - (h_len - 1) + start)],
 				h,
 				&y[2 * i],
-				h_len);
+				h_len, step, offset);
 	}
 
 	return len;
@@ -86,10 +91,10 @@ int _base_convolve_complex(const float *x, int x_len,
 
 /* Buffer validity checks */
 int bounds_check(int x_len, int h_len, int y_len,
-		 int start, int len)
+		 int start, int len, int step)
 {
 	if ((x_len < 1) || (h_len < 1) ||
-	    (y_len < 1) || (len < 1)) {
+	    (y_len < 1) || (len < 1) || (step < 1)) {
 		fprintf(stderr, "Convolve: Invalid input\n");
 		return -1;
 	}
@@ -108,9 +113,10 @@ int bounds_check(int x_len, int h_len, int y_len,
 int base_convolve_real(const float *x, int x_len,
 		       const float *h, int h_len,
 		       float *y, int y_len,
-		       int start, int len)
+		       int start, int len,
+		       int step, int offset)
 {
-	if (bounds_check(x_len, h_len, y_len, start, len) < 0)
+	if (bounds_check(x_len, h_len, y_len, start, len, step) < 0)
 		return -1;
 
 	memset(y, 0, len * 2 * sizeof(float));
@@ -118,16 +124,17 @@ int base_convolve_real(const float *x, int x_len,
 	return _base_convolve_real(x, x_len,
 				   h, h_len,
 				   y, y_len,
-				   start, len);
+				   start, len, step, offset);
 }
 
 /* API: Non-aligned (no SSE) complex-complex */
 int base_convolve_complex(const float *x, int x_len,
 			  const float *h, int h_len,
 			  float *y, int y_len,
-			  int start, int len)
+			  int start, int len,
+			  int step, int offset)
 {
-	if (bounds_check(x_len, h_len, y_len, start, len) < 0)
+	if (bounds_check(x_len, h_len, y_len, start, len, step) < 0)
 		return -1;
 
 	memset(y, 0, len * 2 * sizeof(float));
@@ -135,11 +142,11 @@ int base_convolve_complex(const float *x, int x_len,
 	return _base_convolve_complex(x, x_len,
 				      h, h_len,
 				      y, y_len,
-				      start, len);
+				      start, len, step, offset);
 }
 
 /* Aligned filter tap allocation */
-void *convolve_h_alloc(size_t len)
+void *convolve_h_alloc(int len)
 {
 #ifdef HAVE_SSE3
 	return memalign(16, len * 2 * sizeof(float));

Transceiver52M/common/fft.c

@@ -3,8 +3,6 @@
  *
  * Copyright (C) 2012 Tom Tsou <tom@tsou.cc>
  * 
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
@@ -103,7 +101,7 @@ void free_fft(struct fft_hdl *hdl)
 }
 
 /*! \brief Run multiple DFT operations with the initialized plan
- *  \param[in] hdl handle to an initialized fft struct
+ *  \param[in] hdl handle to an intitialized fft struct
  *
  * Input and output buffers are configured with init_fft().
  */

Transceiver52M/device/Makefile.am

@@ -1,23 +0,0 @@
-include $(top_srcdir)/Makefile.common
-
-SUBDIRS = common
-
-if DEVICE_IPC
-SUBDIRS += ipc
-endif
-
-if DEVICE_USRP1
-SUBDIRS += usrp1
-endif
-
-if DEVICE_UHD
-SUBDIRS += uhd
-endif
-
-if DEVICE_LMS
-SUBDIRS += lms
-endif
-
-if DEVICE_BLADE
-SUBDIRS += bladerf
-endif

Transceiver52M/device/bladerf/Makefile.am

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

Transceiver52M/device/bladerf/bladerf.cpp

@@ -1,611 +0,0 @@
-/*
- * Copyright 2022 sysmocom - s.f.m.c. GmbH
- *
- * Author: Eric Wild <ewild@sysmocom.de>
- *
- * SPDX-License-Identifier: AGPL-3.0+
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- * See the COPYING file in the main directory for details.
- */
-
-#include <map>
-#include <libbladeRF.h>
-#include "radioDevice.h"
-#include "bladerf.h"
-#include "Threads.h"
-#include "Logger.h"
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-extern "C" {
-#include <osmocom/core/utils.h>
-#include <osmocom/gsm/gsm_utils.h>
-#include <osmocom/vty/cpu_sched_vty.h>
-}
-
-#define SAMPLE_BUF_SZ (1 << 20)
-
-#define B2XX_TIMING_4_4SPS 6.18462e-5
-
-#define CHKRET()                                                                                                       \
-	{                                                                                                              \
-		if (status != 0)                                                                                       \
-			LOGC(DDEV, ERROR) << bladerf_strerror(status);                                                 \
-	}
-
-static const dev_map_t dev_param_map{
-	{ std::make_tuple(blade_dev_type::BLADE2, 4, 4), { 1, 26e6, GSMRATE, B2XX_TIMING_4_4SPS, "B200 4 SPS" } },
-};
-
-static const power_map_t dev_band_nom_power_param_map{
-	{ std::make_tuple(blade_dev_type::BLADE2, GSM_BAND_850), { 89.75, 13.3, -7.5 } },
-	{ std::make_tuple(blade_dev_type::BLADE2, GSM_BAND_900), { 89.75, 13.3, -7.5 } },
-	{ std::make_tuple(blade_dev_type::BLADE2, GSM_BAND_1800), { 89.75, 7.5, -11.0 } },
-	{ std::make_tuple(blade_dev_type::BLADE2, GSM_BAND_1900), { 89.75, 7.7, -11.0 } },
-};
-
-/* So far measurements done for B210 show really close to linear relationship
- * between gain and real output power, so we simply adjust the measured offset
- */
-static double TxGain2TxPower(const dev_band_desc &desc, double tx_gain_db)
-{
-	return desc.nom_out_tx_power - (desc.nom_uhd_tx_gain - tx_gain_db);
-}
-static double TxPower2TxGain(const dev_band_desc &desc, double tx_power_dbm)
-{
-	return desc.nom_uhd_tx_gain - (desc.nom_out_tx_power - tx_power_dbm);
-}
-
-blade_device::blade_device(InterfaceType iface, const struct trx_cfg *cfg)
-	: RadioDevice(iface, cfg), band_manager(dev_band_nom_power_param_map, dev_param_map), dev(nullptr),
-	  rx_gain_min(0.0), rx_gain_max(0.0), tx_spp(0), rx_spp(0), started(false), aligned(false), drop_cnt(0),
-	  prev_ts(0), ts_initial(0), ts_offset(0), async_event_thrd(NULL)
-{
-}
-
-blade_device::~blade_device()
-{
-	if (dev) {
-		bladerf_enable_module(dev, BLADERF_CHANNEL_RX(0), false);
-		bladerf_enable_module(dev, BLADERF_CHANNEL_TX(0), false);
-	}
-
-	stop();
-
-	for (size_t i = 0; i < rx_buffers.size(); i++)
-		delete rx_buffers[i];
-}
-
-void blade_device::init_gains()
-{
-	double tx_gain_min, tx_gain_max;
-	int status;
-
-	const struct bladerf_range *r;
-	bladerf_get_gain_range(dev, BLADERF_RX, &r);
-
-	rx_gain_min = r->min;
-	rx_gain_max = r->max;
-	LOGC(DDEV, INFO) << "Supported Rx gain range [" << rx_gain_min << "; " << rx_gain_max << "]";
-
-	for (size_t i = 0; i < rx_gains.size(); i++) {
-		double gain = (rx_gain_min + rx_gain_max) / 2;
-		status = bladerf_set_gain_mode(dev, BLADERF_CHANNEL_RX(i), BLADERF_GAIN_MGC);
-		CHKRET()
-		bladerf_gain_mode m;
-		bladerf_get_gain_mode(dev, BLADERF_CHANNEL_RX(i), &m);
-		LOGC(DDEV, INFO) << (m == BLADERF_GAIN_MANUAL ? "gain manual" : "gain AUTO");
-
-		status = bladerf_set_gain(dev, BLADERF_CHANNEL_RX(i), 0);
-		CHKRET()
-		int actual_gain;
-		status = bladerf_get_gain(dev, BLADERF_CHANNEL_RX(i), &actual_gain);
-		CHKRET()
-		LOGC(DDEV, INFO) << "Default setting Rx gain for channel " << i << " to " << gain << " scale "
-				 << r->scale << " actual " << actual_gain;
-		rx_gains[i] = actual_gain;
-
-		status = bladerf_set_gain(dev, BLADERF_CHANNEL_RX(i), 0);
-		CHKRET()
-		status = bladerf_get_gain(dev, BLADERF_CHANNEL_RX(i), &actual_gain);
-		CHKRET()
-		LOGC(DDEV, INFO) << "Default setting Rx gain for channel " << i << " to " << gain << " scale "
-				 << r->scale << " actual " << actual_gain;
-		rx_gains[i] = actual_gain;
-	}
-
-	status = bladerf_get_gain_range(dev, BLADERF_TX, &r);
-	CHKRET()
-	tx_gain_min = r->min;
-	tx_gain_max = r->max;
-	LOGC(DDEV, INFO) << "Supported Tx gain range [" << tx_gain_min << "; " << tx_gain_max << "]";
-
-	for (size_t i = 0; i < tx_gains.size(); i++) {
-		double gain = (tx_gain_min + tx_gain_max) / 2;
-		status = bladerf_set_gain(dev, BLADERF_CHANNEL_TX(i), 30);
-		CHKRET()
-		int actual_gain;
-		status = bladerf_get_gain(dev, BLADERF_CHANNEL_TX(i), &actual_gain);
-		CHKRET()
-		LOGC(DDEV, INFO) << "Default setting Tx gain for channel " << i << " to " << gain << " scale "
-				 << r->scale << " actual " << actual_gain;
-		tx_gains[i] = actual_gain;
-	}
-
-	return;
-}
-
-void blade_device::set_rates()
-{
-	struct bladerf_rational_rate rate = { 0, static_cast<uint64_t>((1625e3 * 4)), 6 }, actual;
-	auto status = bladerf_set_rational_sample_rate(dev, BLADERF_CHANNEL_RX(0), &rate, &actual);
-	CHKRET()
-	status = bladerf_set_rational_sample_rate(dev, BLADERF_CHANNEL_TX(0), &rate, &actual);
-	CHKRET()
-
-	tx_rate = rx_rate = (double)rate.num / (double)rate.den;
-
-	LOGC(DDEV, INFO) << "Rates set to" << tx_rate << " / " << rx_rate;
-
-	bladerf_set_bandwidth(dev, BLADERF_CHANNEL_RX(0), (bladerf_bandwidth)2e6, (bladerf_bandwidth *)NULL);
-	bladerf_set_bandwidth(dev, BLADERF_CHANNEL_TX(0), (bladerf_bandwidth)2e6, (bladerf_bandwidth *)NULL);
-
-	ts_offset = 60; // FIXME: actual blade offset, should equal b2xx
-}
-
-double blade_device::setRxGain(double db, size_t chan)
-{
-	if (chan >= rx_gains.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
-		return 0.0f;
-	}
-
-	bladerf_set_gain(dev, BLADERF_CHANNEL_RX(chan), 30); //db);
-	int actual_gain;
-	bladerf_get_gain(dev, BLADERF_CHANNEL_RX(chan), &actual_gain);
-
-	rx_gains[chan] = actual_gain;
-
-	LOGC(DDEV, INFO) << "Set RX gain to " << rx_gains[chan] << "dB (asked for " << db << "dB)";
-
-	return rx_gains[chan];
-}
-
-double blade_device::getRxGain(size_t chan)
-{
-	if (chan >= rx_gains.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
-		return 0.0f;
-	}
-
-	return rx_gains[chan];
-}
-
-double blade_device::rssiOffset(size_t chan)
-{
-	double rssiOffset;
-	dev_band_desc desc;
-
-	if (chan >= rx_gains.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
-		return 0.0f;
-	}
-
-	get_dev_band_desc(desc);
-	rssiOffset = rx_gains[chan] + desc.rxgain2rssioffset_rel;
-	return rssiOffset;
-}
-
-double blade_device::setPowerAttenuation(int atten, size_t chan)
-{
-	double tx_power, db;
-	dev_band_desc desc;
-
-	if (chan >= tx_gains.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel" << chan;
-		return 0.0f;
-	}
-
-	get_dev_band_desc(desc);
-	tx_power = desc.nom_out_tx_power - atten;
-	db = TxPower2TxGain(desc, tx_power);
-
-	bladerf_set_gain(dev, BLADERF_CHANNEL_TX(chan), 30);
-	int actual_gain;
-	bladerf_get_gain(dev, BLADERF_CHANNEL_RX(chan), &actual_gain);
-
-	tx_gains[chan] = actual_gain;
-
-	LOGC(DDEV, INFO)
-		<< "Set TX gain to " << tx_gains[chan] << "dB, ~" << TxGain2TxPower(desc, tx_gains[chan]) << " dBm "
-		<< "(asked for " << db << " dB, ~" << tx_power << " dBm)";
-
-	return desc.nom_out_tx_power - TxGain2TxPower(desc, tx_gains[chan]);
-}
-double blade_device::getPowerAttenuation(size_t chan)
-{
-	dev_band_desc desc;
-	if (chan >= tx_gains.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
-		return 0.0f;
-	}
-
-	get_dev_band_desc(desc);
-	return desc.nom_out_tx_power - TxGain2TxPower(desc, tx_gains[chan]);
-}
-
-int blade_device::getNominalTxPower(size_t chan)
-{
-	dev_band_desc desc;
-	get_dev_band_desc(desc);
-
-	return desc.nom_out_tx_power;
-}
-
-int blade_device::open()
-{
-	bladerf_log_set_verbosity(BLADERF_LOG_LEVEL_VERBOSE);
-	bladerf_set_usb_reset_on_open(true);
-	auto success = bladerf_open(&dev, cfg->dev_args);
-	if (success != 0) {
-		struct bladerf_devinfo *info;
-		auto num_devs = bladerf_get_device_list(&info);
-		LOGC(DDEV, ALERT) << "No bladerf devices found with identifier '" << cfg->dev_args << "'";
-		if (num_devs) {
-			for (int i = 0; i < num_devs; i++)
-				LOGC(DDEV, ALERT) << "Found device:" << info[i].product << " serial " << info[i].serial;
-		}
-
-		return -1;
-	}
-	if (strcmp("bladerf2", bladerf_get_board_name(dev))) {
-		LOGC(DDEV, ALERT) << "Only BladeRF2 supported! found:" << bladerf_get_board_name(dev);
-		return -1;
-	}
-
-	dev_type = blade_dev_type::BLADE2;
-	tx_window = TX_WINDOW_FIXED;
-	update_band_dev(dev_key(dev_type, tx_sps, rx_sps));
-
-	struct bladerf_devinfo info;
-	bladerf_get_devinfo(dev, &info);
-	LOGC(DDEV, INFO) << "Using discovered bladerf device " << info.serial;
-
-	tx_freqs.resize(chans);
-	rx_freqs.resize(chans);
-	tx_gains.resize(chans);
-	rx_gains.resize(chans);
-	rx_buffers.resize(chans);
-
-	switch (cfg->clock_ref) {
-	case REF_INTERNAL:
-	case REF_EXTERNAL:
-		break;
-	default:
-		LOGC(DDEV, ALERT) << "Invalid reference type";
-		return -1;
-	}
-
-	if (cfg->clock_ref == REF_EXTERNAL) {
-		bool is_locked;
-		int status = bladerf_set_pll_enable(dev, true);
-		CHKRET()
-		status = bladerf_set_pll_refclk(dev, 10000000);
-		CHKRET()
-		for (int i = 0; i < 20; i++) {
-			usleep(50 * 1000);
-			status = bladerf_get_pll_lock_state(dev, &is_locked);
-			CHKRET()
-			if (is_locked)
-				break;
-		}
-		if (!is_locked) {
-			LOGC(DDEV, ALERT) << "unable to lock refclk!";
-			return -1;
-		}
-	}
-
-	LOGC(DDEV, INFO)
-		<< "Selected clock source is " << ((cfg->clock_ref == REF_INTERNAL) ? "internal" : "external 10Mhz");
-
-	set_rates();
-
-	/*
-	1ts = 3/5200s
-	1024*2 = small gap(~180us) every 9.23ms = every 16 ts? -> every 2 frames
-	1024*1 = large gap(~627us) every 9.23ms = every 16 ts? -> every 2 frames
-
-	rif convertbuffer = 625*4 = 2500 -> 4 ts
-	rif rxtxbuf = 4 * segment(625*4) = 10000 -> 16 ts
-	*/
-	const unsigned int num_buffers = 256;
-	const unsigned int buffer_size = 1024 * 4; /* Must be a multiple of 1024 */
-	const unsigned int num_transfers = 32;
-	const unsigned int timeout_ms = 3500;
-
-	bladerf_sync_config(dev, BLADERF_RX_X1, BLADERF_FORMAT_SC16_Q11_META, num_buffers, buffer_size, num_transfers,
-			    timeout_ms);
-
-	bladerf_sync_config(dev, BLADERF_TX_X1, BLADERF_FORMAT_SC16_Q11_META, num_buffers, buffer_size, num_transfers,
-			    timeout_ms);
-
-	/* Number of samples per over-the-wire packet */
-	tx_spp = rx_spp = buffer_size;
-
-	size_t buf_len = SAMPLE_BUF_SZ / sizeof(uint32_t);
-	for (size_t i = 0; i < rx_buffers.size(); i++)
-		rx_buffers[i] = new smpl_buf(buf_len);
-
-	pkt_bufs = std::vector<std::vector<short> >(chans, std::vector<short>(2 * rx_spp));
-	for (size_t i = 0; i < pkt_bufs.size(); i++)
-		pkt_ptrs.push_back(&pkt_bufs[i].front());
-
-	init_gains();
-
-	return NORMAL;
-}
-
-bool blade_device::restart()
-{
-	/* Allow 100 ms delay to align multi-channel streams */
-	double delay = 0.2;
-	int status;
-
-	status = bladerf_enable_module(dev, BLADERF_CHANNEL_RX(0), true);
-	CHKRET()
-	status = bladerf_enable_module(dev, BLADERF_CHANNEL_TX(0), true);
-	CHKRET()
-
-	bladerf_timestamp now;
-	status = bladerf_get_timestamp(dev, BLADERF_RX, &now);
-	ts_initial = now + rx_rate * delay;
-	LOGC(DDEV, INFO) << "Initial timestamp " << ts_initial << std::endl;
-
-	return true;
-}
-
-bool blade_device::start()
-{
-	LOGC(DDEV, INFO) << "Starting USRP...";
-
-	if (started) {
-		LOGC(DDEV, ERROR) << "Device already started";
-		return false;
-	}
-
-	if (!restart())
-		return false;
-
-	started = true;
-	return true;
-}
-
-bool blade_device::stop()
-{
-	if (!started)
-		return false;
-
-	/* reset internal buffer timestamps */
-	for (size_t i = 0; i < rx_buffers.size(); i++)
-		rx_buffers[i]->reset();
-
-	band_reset();
-
-	started = false;
-	return true;
-}
-
-int blade_device::readSamples(std::vector<short *> &bufs, int len, bool *overrun, TIMESTAMP timestamp, bool *underrun)
-{
-	ssize_t rc;
-	uint64_t ts;
-
-	if (bufs.size() != chans) {
-		LOGC(DDEV, ALERT) << "Invalid channel combination " << bufs.size();
-		return -1;
-	}
-
-	*overrun = false;
-	*underrun = false;
-
-	// Shift read time with respect to transmit clock
-	timestamp += ts_offset;
-
-	ts = timestamp;
-	LOGC(DDEV, DEBUG) << "Requested timestamp = " << ts;
-
-	// Check that timestamp is valid
-	rc = rx_buffers[0]->avail_smpls(timestamp);
-	if (rc < 0) {
-		LOGC(DDEV, ERROR) << rx_buffers[0]->str_code(rc);
-		LOGC(DDEV, ERROR) << rx_buffers[0]->str_status(timestamp);
-		return 0;
-	}
-
-	struct bladerf_metadata meta = {};
-	meta.timestamp = ts;
-
-	while (rx_buffers[0]->avail_smpls(timestamp) < len) {
-		thread_enable_cancel(false);
-		int status = bladerf_sync_rx(dev, pkt_ptrs[0], len, &meta, 200U);
-		thread_enable_cancel(true);
-
-		if (status != 0)
-			LOGC(DDEV, ERROR) << "RX broken: " << bladerf_strerror(status);
-		if (meta.flags & BLADERF_META_STATUS_OVERRUN)
-			LOGC(DDEV, ERROR) << "RX borken, OVERRUN: " << bladerf_strerror(status);
-
-		size_t num_smpls = meta.actual_count;
-		;
-		ts = meta.timestamp;
-
-		for (size_t i = 0; i < rx_buffers.size(); i++) {
-			rc = rx_buffers[i]->write((short *)&pkt_bufs[i].front(), num_smpls, ts);
-
-			// Continue on local overrun, exit on other errors
-			if ((rc < 0)) {
-				LOGC(DDEV, ERROR) << rx_buffers[i]->str_code(rc);
-				LOGC(DDEV, ERROR) << rx_buffers[i]->str_status(timestamp);
-				if (rc != smpl_buf::ERROR_OVERFLOW)
-					return 0;
-			}
-		}
-		meta = {};
-		meta.timestamp = ts + num_smpls;
-	}
-
-	for (size_t i = 0; i < rx_buffers.size(); i++) {
-		rc = rx_buffers[i]->read(bufs[i], len, timestamp);
-		if ((rc < 0) || (rc != len)) {
-			LOGC(DDEV, ERROR) << rx_buffers[i]->str_code(rc);
-			LOGC(DDEV, ERROR) << rx_buffers[i]->str_status(timestamp);
-			return 0;
-		}
-	}
-
-	return len;
-}
-
-int blade_device::writeSamples(std::vector<short *> &bufs, int len, bool *underrun, unsigned long long timestamp)
-{
-	*underrun = false;
-	static bool first_tx = true;
-	struct bladerf_metadata meta = {};
-	if (first_tx) {
-		meta.timestamp = timestamp;
-		meta.flags = BLADERF_META_FLAG_TX_BURST_START;
-		first_tx = false;
-	}
-
-	thread_enable_cancel(false);
-	int status = bladerf_sync_tx(dev, (const void *)bufs[0], len, &meta, 200U);
-	thread_enable_cancel(true);
-
-	if (status != 0)
-		LOGC(DDEV, ERROR) << "TX broken: " << bladerf_strerror(status);
-
-	return len;
-}
-
-bool blade_device::updateAlignment(TIMESTAMP timestamp)
-{
-	return true;
-}
-
-bool blade_device::set_freq(double freq, size_t chan, bool tx)
-{
-	if (tx) {
-		bladerf_set_frequency(dev, BLADERF_CHANNEL_TX(chan), freq);
-		bladerf_frequency f;
-		bladerf_get_frequency(dev, BLADERF_CHANNEL_TX(chan), &f);
-		tx_freqs[chan] = f;
-	} else {
-		bladerf_set_frequency(dev, BLADERF_CHANNEL_RX(chan), freq);
-		bladerf_frequency f;
-		bladerf_get_frequency(dev, BLADERF_CHANNEL_RX(chan), &f);
-		rx_freqs[chan] = f;
-	}
-	LOGCHAN(chan, DDEV, INFO) << "set_freq(" << freq << ", " << (tx ? "TX" : "RX") << "): " << std::endl;
-
-	return true;
-}
-
-bool blade_device::setTxFreq(double wFreq, size_t chan)
-{
-	if (chan >= tx_freqs.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
-		return false;
-	}
-	ScopedLock lock(tune_lock);
-
-	if (!update_band_from_freq(wFreq, chan, true))
-		return false;
-
-	if (!set_freq(wFreq, chan, true))
-		return false;
-
-	return true;
-}
-
-bool blade_device::setRxFreq(double wFreq, size_t chan)
-{
-	if (chan >= rx_freqs.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
-		return false;
-	}
-	ScopedLock lock(tune_lock);
-
-	if (!update_band_from_freq(wFreq, chan, false))
-		return false;
-
-	return set_freq(wFreq, chan, false);
-}
-
-double blade_device::getTxFreq(size_t chan)
-{
-	if (chan >= tx_freqs.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
-		return 0.0;
-	}
-
-	return tx_freqs[chan];
-}
-
-double blade_device::getRxFreq(size_t chan)
-{
-	if (chan >= rx_freqs.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
-		return 0.0;
-	}
-
-	return rx_freqs[chan];
-}
-
-bool blade_device::requiresRadioAlign()
-{
-	return false;
-}
-
-GSM::Time blade_device::minLatency()
-{
-	return GSM::Time(6, 7);
-}
-
-TIMESTAMP blade_device::initialWriteTimestamp()
-{
-	return ts_initial;
-}
-
-TIMESTAMP blade_device::initialReadTimestamp()
-{
-	return ts_initial;
-}
-
-double blade_device::fullScaleInputValue()
-{
-	return (double)2047;
-}
-
-double blade_device::fullScaleOutputValue()
-{
-	return (double)2047;
-}
-
-RadioDevice *RadioDevice::make(InterfaceType type, const struct trx_cfg *cfg)
-{
-	return new blade_device(type, cfg);
-}

Transceiver52M/device/bladerf/bladerf.h

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

Transceiver52M/device/common/Makefile.am

@@ -1,12 +0,0 @@
-include $(top_srcdir)/Makefile.common
-
-AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES)
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS)
-
-
-noinst_HEADERS = radioDevice.h smpl_buf.h bandmanager.h
-
-noinst_LTLIBRARIES = libdevice_common.la
-
-libdevice_common_la_SOURCES = \
-	smpl_buf.cpp

Transceiver52M/device/common/bandmanager.h

@@ -1,137 +0,0 @@
-#pragma once
-/*
- * (C) 2022 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
- * All Rights Reserved
- *
- * Author: Eric Wild <ewild@sysmocom.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include <string>
-#include <tuple>
-
-#include "Logger.h"
-
-extern "C" {
-#include <osmocom/gsm/gsm_utils.h>
-}
-
-template <typename powermapt, typename devmapt>
-class band_manager {
-	using powerkeyt = typename powermapt::key_type;
-	using powermappedt = typename powermapt::mapped_type;
-	using devkeyt = typename devmapt::key_type;
-	devkeyt m_dev_type;
-	const powermapt &m_power_map;
-	const devmapt &m_dev_map;
-	powerkeyt m_fallback;
-	enum gsm_band m_band;
-	powermappedt m_band_desc;
-	bool band_ass_curr_sess{}; /* true if  "band" was set after last POWEROFF */
-
-	// looks up either first tuple element (->enum) or straight enum
-	template <typename T, typename std::enable_if<std::is_enum<T>::value>::type *dummy = nullptr>
-	auto key_helper(T &t) -> T
-	{
-		return t;
-	}
-
-	template <typename T>
-	auto key_helper(T t) -> typename std::tuple_element<0, T>::type
-	{
-		return std::get<0>(t);
-	}
-
-	void assign_band_desc(enum gsm_band req_band)
-	{
-		auto key = key_helper(m_dev_type);
-		auto fallback_key = key_helper(m_fallback);
-		auto it = m_power_map.find({ key, req_band });
-		if (it == m_power_map.end()) {
-			auto desc = m_dev_map.at(m_dev_type);
-			LOGC(DDEV, ERROR) << "No Tx Power measurements exist for device " << desc.desc_str
-					  << " on band " << gsm_band_name(req_band) << ", using fallback..";
-			it = m_power_map.find({ fallback_key, req_band });
-		}
-		OSMO_ASSERT(it != m_power_map.end());
-		m_band_desc = it->second;
-	}
-
-	bool set_band(enum gsm_band req_band)
-	{
-		if (band_ass_curr_sess && req_band != m_band) {
-			LOGC(DDEV, ALERT) << "Requesting band " << gsm_band_name(req_band)
-					  << " different from previous band " << gsm_band_name(m_band);
-			return false;
-		}
-
-		if (req_band != m_band) {
-			m_band = req_band;
-			assign_band_desc(m_band);
-		}
-		band_ass_curr_sess = true;
-		return true;
-	}
-
-    public:
-	band_manager(const devkeyt &dev_type, const powermapt &power_map, const devmapt &dev_map, powerkeyt fallback)
-		: m_dev_type(dev_type), m_power_map(power_map), m_dev_map(dev_map), m_fallback(fallback),
-		  m_band((enum gsm_band)0)
-	{
-	}
-	band_manager(const powermapt &power_map, const devmapt &dev_map)
-		: m_dev_type(dev_map.begin()->first), m_power_map(power_map), m_dev_map(dev_map),
-		  m_fallback(m_power_map.begin()->first), m_band((enum gsm_band)0)
-	{
-	}
-	void band_reset()
-	{
-		band_ass_curr_sess = false;
-	}
-
-	void update_band_dev(devkeyt dev_type) {
-		m_dev_type = dev_type;
-	}
-
-	void get_dev_band_desc(powermappedt &desc)
-	{
-		if (m_band == 0) {
-			LOGC(DDEV, ERROR)
-				<< "Power parameters requested before Tx Frequency was set! Providing band 900 by default...";
-			assign_band_desc(GSM_BAND_900);
-		}
-		desc = m_band_desc;
-	}
-
-	bool update_band_from_freq(double wFreq, int chan, bool is_tx)
-	{
-		enum gsm_band req_band;
-		auto dirstr = is_tx ? "Tx" : "Rx";
-		auto req_arfcn = gsm_freq102arfcn(wFreq / 1000 / 100, !is_tx);
-		if (req_arfcn == 0xffff) {
-			LOGCHAN(chan, DDEV, ALERT)
-				<< "Unknown ARFCN for " << dirstr << " Frequency " << wFreq / 1000 << " kHz";
-			return false;
-		}
-		if (gsm_arfcn2band_rc(req_arfcn, &req_band) < 0) {
-			LOGCHAN(chan, DDEV, ALERT) << "Unknown GSM band for " << dirstr << " Frequency " << wFreq
-						   << " Hz (ARFCN " << req_arfcn << " )";
-			return false;
-		}
-
-		return set_band(req_band);
-	}
-};

Transceiver52M/device/common/smpl_buf.cpp

@@ -1,181 +0,0 @@
-/*
- * Sample Buffer - Allows reading and writing of timed samples
- *
- * Copyright 2010,2011 Free Software Foundation, Inc.
- * Copyright (C) 2015 Ettus Research LLC
- * Copyright 2019 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
- *
- * Author: Tom Tsou <tom.tsou@ettus.com>
- *
- * SPDX-License-Identifier: AGPL-3.0+
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- * See the COPYING file in the main directory for details.
- */
-
-#include "smpl_buf.h"
-#include <inttypes.h>
-
-smpl_buf::smpl_buf(size_t len)
-	: buf_len(len)
-{
-	reset();
-	data = new uint32_t[len];
-}
-
-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)
-		return ERROR_TIMESTAMP;
-	else if (timestamp >= time_end)
-		return 0;
-	else
-		return time_end - timestamp;
-}
-
-ssize_t smpl_buf::read(void *buf, size_t len, TIMESTAMP timestamp)
-{
-	int type_sz = 2 * sizeof(short);
-
-	// Check for valid read
-	if (timestamp < time_start)
-		return ERROR_TIMESTAMP;
-	if (timestamp >= time_end)
-		return 0;
-	if (len >= buf_len)
-		return ERROR_READ;
-
-	// How many samples should be copied
-	size_t num_smpls = time_end - timestamp;
-	if (num_smpls > len)
-		num_smpls = len;
-
-	// Starting index
-	size_t read_start = (data_start + (timestamp - time_start)) % buf_len;
-
-	// Read it
-	if (read_start + num_smpls < buf_len) {
-		size_t numBytes = len * type_sz;
-		memcpy(buf, data + read_start, numBytes);
-	} else {
-		size_t first_cp = (buf_len - read_start) * type_sz;
-		size_t second_cp = len * type_sz - first_cp;
-
-		memcpy(buf, data + read_start, first_cp);
-		memcpy((char*) buf + first_cp, data, second_cp);
-	}
-
-	data_start = (read_start + len) % buf_len;
-	time_start = timestamp + len;
-
-	if (time_start > time_end)
-		return ERROR_READ;
-	else
-		return num_smpls;
-}
-
-ssize_t smpl_buf::write(void *buf, size_t len, TIMESTAMP timestamp)
-{
-	int type_sz = 2 * sizeof(short);
-
-	// Check for valid write
-	if ((len == 0) || (len >= buf_len))
-		return ERROR_WRITE;
-	if ((timestamp + len) <= time_end)
-		return ERROR_TIMESTAMP;
-
-	if (timestamp < time_end) {
-		LOGC(DDEV, ERR) << "Overwriting old buffer data: timestamp="
-				<< timestamp << " time_end=" << time_end;
-		// Do not return error here, because it's a rounding error and is not fatal
-	}
-	if (timestamp > time_end && time_end != 0) {
-		LOGC(DDEV, ERR) << "Skipping buffer data: timestamp="
-				<< timestamp << " time_end=" << time_end;
-		// Do not return error here, because it's a rounding error and is not fatal
-	}
-
-	// Starting index
-	size_t write_start = (data_start + (timestamp - time_start)) % buf_len;
-
-	// Write it
-	if ((write_start + len) < buf_len) {
-		size_t numBytes = len * type_sz;
-		memcpy(data + write_start, buf, numBytes);
-	} else {
-		size_t first_cp = (buf_len - write_start) * type_sz;
-		size_t second_cp = len * type_sz - first_cp;
-
-		memcpy(data + write_start, buf, first_cp);
-		memcpy(data, (char*) buf + first_cp, second_cp);
-	}
-
-	data_end = (write_start + len) % buf_len;
-	time_end = timestamp + len;
-
-	if (!data_start)
-		data_start = write_start;
-
-	if (((write_start + len) > buf_len) && (data_end > data_start))
-		return ERROR_OVERFLOW;
-	else if (time_end <= time_start)
-		return ERROR_WRITE;
-	else
-		return len;
-}
-
-std::string smpl_buf::str_status(TIMESTAMP timestamp) const
-{
-	std::ostringstream ost("Sample buffer: ");
-
-	ost << "timestamp = " << timestamp;
-	ost << ", length = " << buf_len;
-	ost << ", time_start = " << time_start;
-	ost << ", time_end = " << time_end;
-	ost << ", data_start = " << data_start;
-	ost << ", data_end = " << data_end;
-
-	return ost.str();
-}
-
-std::string smpl_buf::str_code(int code)
-{
-	switch (code) {
-	case ERROR_TIMESTAMP:
-		return "Sample buffer: Requested timestamp is not valid";
-	case ERROR_READ:
-		return "Sample buffer: Read error";
-	case ERROR_WRITE:
-		return "Sample buffer: Write error";
-	case ERROR_OVERFLOW:
-		return "Sample buffer: Overrun";
-	default:
-		std::stringstream ss;
-		ss << "Sample buffer: Unknown error " << code;
-		return ss.str();
-	}
-}

Transceiver52M/device/common/smpl_buf.h

@@ -1,93 +0,0 @@
-/*
- * Sample Buffer - Allows reading and writing of timed samples
- *
- * Copyright 2010,2011 Free Software Foundation, Inc.
- * Copyright (C) 2015 Ettus Research LLC
- * Copyright 2019 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
- *
- * Author: Tom Tsou <tom.tsou@ettus.com>
- *
- * SPDX-License-Identifier: AGPL-3.0+
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- * See the COPYING file in the main directory for details.
- */
-
-#pragma once
-
-#include <unistd.h>
-
-#include "radioDevice.h"
-
-/*
-    Sample Buffer - Allows reading and writing of timed samples using osmo-trx
-                    timestamps. Time conversions are handled
-                    internally or accessible through the static convert calls.
-*/
-class smpl_buf {
-public:
-	/** Sample buffer constructor
-	    @param len number of 32-bit samples the buffer should hold
-	    @param timestamp
-	*/
-	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
-	*/
-	ssize_t avail_smpls(TIMESTAMP timestamp) const;
-
-	/** Read and write
-	    @param buf pointer to buffer
-	    @param len number of samples desired to read or write
-	    @param timestamp time of first stample
-	    @return number of actual samples read or written or error
-	*/
-	ssize_t read(void *buf, size_t len, TIMESTAMP timestamp);
-	ssize_t write(void *buf, size_t len, TIMESTAMP timestamp);
-
-	/** Buffer status string
-	    @return a formatted string describing internal buffer state
-	*/
-	std::string str_status(TIMESTAMP timestamp) const;
-
-	/** Formatted error string
-	    @param code an error code
-	    @return a formatted error string
-	*/
-	static std::string str_code(int code);
-
-	enum err_code {
-		ERROR_TIMESTAMP = -1,
-		ERROR_READ = -2,
-		ERROR_WRITE = -3,
-		ERROR_OVERFLOW = -4
-	};
-
-private:
-	uint32_t *data;
-	size_t buf_len;
-
-	TIMESTAMP time_start;
-	TIMESTAMP time_end;
-
-	size_t data_start;
-	size_t data_end;
-};

Transceiver52M/device/ipc/IPCDevice.h

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

Transceiver52M/device/ipc/Makefile.am

@@ -1,34 +0,0 @@
-include $(top_srcdir)/Makefile.common
-
-AM_CPPFLAGS = $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/../common
-AM_CFLAGS = -Wall $(LIBOSMOCORE_CFLAGS) $(UHD_CFLAGS)
-AM_CXXFLAGS = -Wall $(LIBOSMOCORE_CFLAGS) $(UHD_CFLAGS)
-
-noinst_HEADERS = IPCDevice.h shm.h ipc_shm.h ipc_chan.h ipc_sock.h
-
-if DEVICE_UHD
-noinst_HEADERS += ../uhd/UHDDevice.h uhdwrap.h ipc-driver-test.h
-endif
-
-noinst_LTLIBRARIES = libdevice.la
-
-libdevice_la_SOURCES = IPCDevice.cpp shm.c ipc_shm.c ipc_chan.c ipc_sock.c
-libdevice_la_CPPFLAGS = $(AM_CPPFLAGS) -DIPCMAGIC
-libdevice_la_LIBADD = \
-	$(top_builddir)/Transceiver52M/device/common/libdevice_common.la \
-	-lpthread \
-	-lrt \
-	$(NULL)
-
-if DEVICE_UHD
-
-bin_PROGRAMS = ipc-driver-test
-#ipc_driver_test_SHORTNAME = drvt
-ipc_driver_test_SOURCES = ipc-driver-test.c uhdwrap.cpp ../uhd/UHDDevice.cpp
-ipc_driver_test_LDADD = \
-	libdevice.la \
-	$(COMMON_LA) \
-	$(LIBOSMOCORE_LIBS) \
-	$(UHD_LIBS) \
-	$(NULL)
-endif

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

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

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

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

Transceiver52M/device/ipc/ipc_chan.c

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

Transceiver52M/device/ipc/ipc_chan.h

@@ -1,25 +0,0 @@
-/*
-* 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

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

Transceiver52M/device/ipc/ipc_shm.h

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

Transceiver52M/device/ipc/ipc_sock.c

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

Transceiver52M/device/ipc/ipc_sock.h

@@ -1,26 +0,0 @@
-/*
-* 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

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

Transceiver52M/device/ipc/shm.h

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

Transceiver52M/device/ipc/uhdwrap.cpp

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

Transceiver52M/device/ipc/uhdwrap.h

@@ -1,83 +0,0 @@
-/*
-* 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() 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