osmo-trx-dec: Offline demodulation tool.

Change-Id: Ic5b59c7fe1a0c02d962b36de2fd5d7fc9a02f266

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

.gitignore

@@ -2,27 +2,22 @@
 *.o
 *.lo
 *.la
-Transceiver52M/osmo-trx-uhd
-Transceiver52M/osmo-trx-usrp1
-Transceiver52M/osmo-trx-lms
-Transceiver52M/osmo-trx-ipc
-
-.clang-format
+Transceiver52M/osmo-trx
+Transceiver52M/osmo-trx-gen
+Transceiver52M/osmo-trx-dec
 
 # tests
-tests/CommonLibs/BitVectorTest
-tests/CommonLibs/F16Test
-tests/CommonLibs/InterthreadTest
-tests/CommonLibs/LogTest
-tests/CommonLibs/RegexpTest
-tests/CommonLibs/SocketsTest
-tests/CommonLibs/TimevalTest
-tests/CommonLibs/URLEncodeTest
-tests/CommonLibs/VectorTest
-tests/CommonLibs/PRBSTest
-tests/Transceiver52M/convolve_test
-tests/Transceiver52M/LMSDeviceTest
-Transceiver52M/device/ipc/ipc-driver-test
+CommonLibs/BitVectorTest
+CommonLibs/ConfigurationTest
+CommonLibs/F16Test
+CommonLibs/InterthreadTest
+CommonLibs/LogTest
+CommonLibs/RegexpTest
+CommonLibs/SocketsTest
+CommonLibs/TimevalTest
+CommonLibs/URLEncodeTest
+CommonLibs/VectorTest
+CommonLibs/PRBSTest
 
 # automake/autoconf
 *.in
@@ -48,29 +43,6 @@ ltmain.sh
 missing
 stamp-h1
 INSTALL
-tests/package.m4
-tests/testsuite
-tests/atconfig
-tests/testsuite.dir
-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

AUTHORS

@@ -0,0 +1,192 @@
+#
+# 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/BitVectorTest.cpp
+    CommonLibs/Configuration.cpp
+    CommonLibs/Configuration.h
+    CommonLibs/ConfigurationTest.cpp
+    CommonLibs/Interthread.h
+    CommonLibs/InterthreadTest.cpp
+    CommonLibs/LinkedLists.cpp
+    CommonLibs/LinkedLists.h
+    CommonLibs/Regexp.h
+    CommonLibs/RegexpTest.cpp
+    CommonLibs/Sockets.cpp
+    CommonLibs/Sockets.h
+    CommonLibs/SocketsTest.cpp
+    CommonLibs/Threads.cpp
+    CommonLibs/Threads.h
+    CommonLibs/Timeval.cpp
+    CommonLibs/Timeval.h
+    CommonLibs/TimevalTest.cpp
+    CommonLibs/Vector.h
+    CommonLibs/VectorTest.cpp
+    Control/CallControl.cpp
+    Control/ControlCommon.cpp
+    Control/ControlCommon.h
+    Control/FACCHDispatch.cpp
+    Control/MobilityManagement.cpp
+    Control/PagerTest.cpp
+    Control/RadioResource.cpp
+    Control/SDCCHDispatch.cpp
+    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
+    SIP/SIPEngine.h
+    SIP/SIPInterface.h
+    SMS/SMSMessages.cpp
+    SMS/SMSMessages.h
+    SMS/SMSTransfer.cpp
+    SMS/SMSTransfer.h
+    TRXManager/TRXManager.cpp
+    Transceiver/Complex.h
+    apps/OpenBTS900.cpp
+    apps/OpenBTS850.cpp
+    apps/OpenBTS25c3.cpp
+    tests/AGCHTest.cpp
+    tests/BeaconTest.cpp
+    tests/CallTest.cpp
+    tests/CallTest2.cpp
+    tests/LAPDmTest.cpp
+    tests/LoopbackTest.cpp
+    tests/RegistrationTest.cpp
+    tests/TRXSimulator.cpp
+
+Harvind S. Samra, hssamra@kestrelsp.com:
+    Control/PagerTest.cpp
+    Control/RadioResource.cpp
+    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:
+    Control/CallControl.cpp
+    Control/ControlCommon.cpp
+    Control/ControlCommon.h
+    Control/FACCHDispatch.cpp
+    Control/MobilityManagement.cpp
+    Control/PagerTest.cpp
+    Control/RadioResource.cpp
+    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
+    SIP/SIPEngine.cpp
+    SIP/SIPInterface.cpp
+    SIP/SIPInterface.h
+    SIP/SIPMessage.cpp
+    SIP/SIPMessage.h
+    SIP/SIPUtility.cpp
+    SIP/SIPUtility.h
+    SMS/CMMessage.cpp
+    SMS/CMMessage.h
+    SMS/CMProcessor.cpp
+    SMS/CMProcessor.h
+    SMS/CMTest.cpp
+    SMS/RLMessage.cpp
+    SMS/RLMessage.h
+    SMS/RLProcessor.cpp
+    SMS/RLProcessor.h
+    SMS/SMSMessages.cpp
+    SMS/SMSMessages.h
+    SMS/SMSProcessors.cpp
+    SMS/SMSProcessors.h
+    SMS/SMSTransfer.cpp
+    SMS/SMSTransfer.h
+    SMS/TLMessage.cpp
+    SMS/TLMessage.h
+    SMS/TLProcessor.cpp
+    SMS/TLProcessor.h
+    TRXManager/TRXManager.h
+
+Alon Levy, alonlevy1@gmail.com
+    RRLPMessages.cpp
+    RRLPMessages.h
+    RRLPTest.cpp
+

COPYING

@@ -666,23 +666,23 @@ 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.
 
 =========================================================================
 
 
-ADDITIONAL TERMS TO THE AGPLv3 LICENSE FOR OsmoTRX
+ADDITIONAL TERMS TO THE AGPLv3 LICENSE FOR OPENBTS
 
 
 Permissive Terms Supplementing the License
 
 1. Remote Interaction Through IP Networks.
 
-OsmoTRX is an implementation of the GSM network cellular air interface,
+OpenBTS includes an implementation of the GSM network cellular air interface,
 as well as other interfaces to IP networks.  The interaction of cellular
-handsets with the OsmoTRX software is considered "remote network interaction"
+handsets with the OpenBTS software is considered "remote network interaction"
 for the purposes of the Affero General Public License and cellular users are
 subject to the source code access requirements of Section 13 of AGPLv3 ("Remote
 Network Interaction; Use with the GNU General Public License").
@@ -694,6 +694,17 @@ interfaces other than the GSM air interface from the requirements of Section 13
 is an additional permission granted to you.  
 
 
+Non-Permissive Terms Supplementing The License
+
+1. Trademarks.
+
+"OpenBTS" is a trademark of Range Networks, Inc., registered with
+the US Patent and Trademark Office.  Your use of OpenBTS software under a GPL
+license does not include the right to use the OpenBTS trademark in commerce.
+This additional non-permissive term is consistent with Section 7 of the AGPLv3
+license.
+
+
 END OF ADDITIONAL TERMS
 
 
@@ -701,8 +712,13 @@ END OF ADDITIONAL TERMS
 How to comply with Section 13 of the AGPLv3 license.
 
 The recommended method for compliance with Section 13 of the AGPLv3 license is
-to deliver a text message to each handset that attaches to the cellular
-network which uses OsmoTRX.  At a minimum, that text message should include the string
-"OsmoTRX AGPLv3" and a URL that can be used to access the OsmoBTS source code.  This
+to deliver a text message to each handset that attaches to the OpenBTS cellular
+network.  At a minimum, that text message should include the string "OpenBTS
+AGPLv3" and a URL that can be used to access the OpenBTS source code.  This
 message need not be delivered to handsets that are denied registration with the
 network, since those handsets have been denied service.
+
+In OpenBTS 2.6, such text messages can be delivered with the "Welcome Message"
+feature.  See the OpenBTS.config.example file for more information on the use of
+this feature for AGPLv3 compliance.
+

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/BitVectorTest.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,7 +29,7 @@
 #include "BitVector.h"
 #include <iostream>
 #include <cstdlib>
-
+ 
 using namespace std;
 
 

CommonLibs/Configuration.h

@@ -0,0 +1,422 @@
+/*
+* Copyright 2009, 2010 Free Software Foundation, Inc.
+* Copyright 2010 Kestrel Signal Processing, Inc.
+* Copyright 2011, 2012 Range Networks, 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 CONFIGURATION_H
+#define CONFIGURATION_H
+
+
+#include "sqlite3util.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <regex.h>
+
+#include <map>
+#include <vector>
+#include <string>
+#include <sstream>
+#include <iostream>
+
+#include <Threads.h>
+#include <stdint.h>
+
+
+/** A class for configuration file errors. */
+class ConfigurationTableError {};
+extern char gCmdName[];	// Gotta be global, gotta be char*, gotta love it.
+
+/** An exception thrown when a given config key isn't found. */
+class ConfigurationTableKeyNotFound : public ConfigurationTableError {
+
+	private:
+
+	std::string mKey;
+
+	public:
+
+	ConfigurationTableKeyNotFound(const std::string& wKey)
+		:mKey(wKey)
+	{ }
+
+	const std::string& key() const { return mKey; }
+
+};
+
+
+class ConfigurationRecord {
+
+	private:
+
+	std::string mValue;
+	long mNumber;
+	bool mDefined;
+
+	public:
+
+	ConfigurationRecord(bool wDefined=true):
+		mDefined(wDefined)
+	{ }
+
+	ConfigurationRecord(const std::string& wValue):
+		mValue(wValue),
+		mNumber(strtol(wValue.c_str(),NULL,0)),
+		mDefined(true)
+	{ }
+
+	ConfigurationRecord(const char* wValue):
+		mValue(std::string(wValue)),
+		mNumber(strtol(wValue,NULL,0)),
+		mDefined(true)
+	{ }
+
+
+	const std::string& value() const { return mValue; }
+	long number() const { return mNumber; }
+	bool defined() const { return mDefined; }
+
+	float floatNumber() const;
+
+};
+
+
+/** A string class that uses a hash function for comparison. */
+class HashString : public std::string {
+
+
+	protected:
+
+	uint64_t mHash;
+
+	void computeHash();
+
+
+	public:
+
+	HashString(const char* src)
+		:std::string(src)
+	{
+		computeHash();
+	}
+
+	HashString(const std::string& src)
+		:std::string(src)
+	{
+		computeHash();
+	}
+
+	HashString()
+	{
+		mHash=0;
+	}
+
+	HashString& operator=(std::string& src)
+	{
+		std::string::operator=(src);
+		computeHash();
+		return *this;
+	}
+
+	HashString& operator=(const char* src)
+	{
+		std::string::operator=(src);
+		computeHash();
+		return *this;
+	}
+
+	bool operator==(const HashString& other)
+	{
+		return mHash==other.mHash;
+	}
+
+	bool operator<(const HashString& other)
+	{
+		return mHash<other.mHash;
+	}
+
+	bool operator>(const HashString& other)
+	{
+		return mHash<other.mHash;
+	}
+
+	uint64_t hash() const { return mHash; }
+
+};
+
+
+typedef std::map<std::string, ConfigurationRecord> ConfigurationRecordMap;
+typedef std::map<HashString, ConfigurationRecord> ConfigurationMap;
+class ConfigurationKey;
+typedef std::map<std::string, ConfigurationKey> ConfigurationKeyMap;
+
+/**
+	A class for maintaining a configuration key-value table,
+	based on sqlite3 and a local map-based cache.
+	Thread-safe, too.
+*/
+class ConfigurationTable {
+
+	private:
+
+	sqlite3* mDB;				///< database connection
+	ConfigurationMap mCache;	///< cache of recently access configuration values
+	mutable Mutex mLock;		///< control for multithreaded access to the cache
+	std::vector<std::string> (*mCrossCheck)(const std::string&);	///< cross check callback pointer
+
+	public:
+
+	ConfigurationKeyMap mSchema;///< definition of configuration default values and validation logic
+
+	ConfigurationTable(const char* filename = ":memory:", const char *wCmdName = 0, ConfigurationKeyMap wSchema = ConfigurationKeyMap());
+
+	/** Generate an up-to-date example sql file for new installs. */
+	std::string getDefaultSQL(const std::string& program, const std::string& version);
+
+	/** Generate an up-to-date TeX snippet. */
+	std::string getTeX(const std::string& program, const std::string& version);
+
+	/** Return true if the key is used in the table.  */
+	bool defines(const std::string& key);
+
+	/** Return true if the application's schema knows about this key. */
+	bool keyDefinedInSchema(const std::string& name);
+
+	/** Return true if the provided value validates correctly against the defined schema. */
+	bool isValidValue(const std::string& name, const std::string& val);
+
+	/** Return true if the provided value validates correctly against the defined schema. */
+	bool isValidValue(const std::string& name, const int val) { std::stringstream ss; ss << val; return isValidValue(name, ss.str()); }
+
+	/** Return a map of all similar keys in the defined schema. */
+	ConfigurationKeyMap getSimilarKeys(const std::string& snippet);
+
+	/** Return true if this key is identified as static. */
+	bool isStatic(const std::string& key);
+
+	/**
+		Get a string parameter from the table.
+		Throw ConfigurationTableKeyNotFound if not found.
+	*/
+	std::string getStr(const std::string& key);
+
+
+	/**
+		Get a boolean from the table.
+		Return false if NULL or 0, true otherwise.
+	*/
+	bool getBool(const std::string& key);
+
+	/**
+		Get a numeric parameter from the table.
+		Throw ConfigurationTableKeyNotFound if not found.
+	*/
+	long getNum(const std::string& key);
+
+	/**
+		Get a vector of strings from the table.
+	*/
+	std::vector<std::string> getVectorOfStrings(const std::string& key);
+
+	/**
+		Get a float from the table.
+		Throw ConfigurationTableKeyNotFound if not found.
+	*/
+	float getFloat(const std::string& key);
+
+	/**
+		Get a numeric vector from the table.
+	*/
+	std::vector<unsigned> getVector(const std::string& key);
+
+	/** Get length of a vector */
+	unsigned getVectorLength(const std::string &key) 
+		{ return getVector(key).size(); }
+
+	/** Set or change a value in the table.  */
+	bool set(const std::string& key, const std::string& value);
+
+	/** Set or change a value in the table.  */
+	bool set(const std::string& key, long value);
+
+	/** Create an entry in the table, no value though. */
+	bool set(const std::string& key);
+
+	/**
+		Remove an entry from the table.
+		Will not alter required values.
+		@param key The key of the item to be removed.
+		@return true if anything was actually removed.
+	*/
+	bool remove(const std::string& key);
+
+	/** Search the table, dumping to a stream. */
+	void find(const std::string& pattern, std::ostream&) const;
+
+	/** Return all key/value pairs stored in the ConfigurationTable */
+	ConfigurationRecordMap getAllPairs() const;
+
+	/** Define the callback to purge the cache whenever the database changes. */
+	void setUpdateHook(void(*)(void *,int ,char const *,char const *,sqlite3_int64));
+
+	/** Define the callback for cross checking. */
+	void setCrossCheckHook(std::vector<std::string> (*wCrossCheck)(const std::string&));
+
+	/** Execute the application specific value cross checking logic. */
+	std::vector<std::string> crossCheck(const std::string& key);
+
+	/** purege cache if it exceeds a certain age */
+	void checkCacheAge();
+
+	/** Delete all records from the cache. */
+	void purge();
+
+
+	private:
+
+	/**
+		Attempt to lookup a record, cache if needed.
+		Throw ConfigurationTableKeyNotFound if not found.
+		Caller should hold mLock because the returned reference points into the cache.
+	*/
+	const ConfigurationRecord& lookup(const std::string& key);
+
+};
+
+
+typedef std::map<HashString, std::string> HashStringMap;
+
+class SimpleKeyValue {
+
+	protected:
+
+	HashStringMap mMap;
+
+	public:
+
+	/** Take a C string "A=B" and set map["A"]="B". */
+	void addItem(const char*);
+
+	/** Take a C string "A=B C=D E=F ..." and add all of the pairs to the map. */
+	void addItems(const char*s);
+
+	/** Return a reference to the string at map["key"]. */
+	const char* get(const char*) const;
+};
+
+
+class ConfigurationKey {
+
+	public:
+
+	enum VisibilityLevel
+	{
+		CUSTOMER,
+		CUSTOMERSITE,
+		CUSTOMERTUNE,
+		CUSTOMERWARN,
+		DEVELOPER,
+		FACTORY
+	};
+
+	enum Type
+	{
+		BOOLEAN,
+		CHOICE_OPT,
+		CHOICE,
+		CIDR_OPT,
+		CIDR,
+		FILEPATH_OPT,
+		FILEPATH,
+		IPADDRESS_OPT,
+		IPADDRESS,
+		IPANDPORT,
+		MIPADDRESS_OPT,
+		MIPADDRESS,
+		PORT_OPT,
+		PORT,
+		REGEX_OPT,
+		REGEX,
+		STRING_OPT,
+		STRING,
+		VALRANGE
+	};
+
+	private:
+
+	std::string mName;
+	std::string mDefaultValue;
+	std::string mUnits;
+	VisibilityLevel mVisibility;
+	Type mType;
+	std::string mValidValues;
+	bool mIsStatic;
+	std::string mDescription;
+
+
+	public:
+
+	ConfigurationKey(const std::string& wName, const std::string& wDefaultValue, const std::string& wUnits, const VisibilityLevel wVisibility, const Type wType, const std::string& wValidValues, bool wIsStatic, const std::string& wDescription):
+		mName(wName),
+		mDefaultValue(wDefaultValue),
+		mUnits(wUnits),
+		mVisibility(wVisibility),
+		mType(wType),
+		mValidValues(wValidValues),
+		mIsStatic(wIsStatic),
+		mDescription(wDescription)
+	{ }
+
+	ConfigurationKey()
+	{ }
+
+	const std::string& getName() const { return mName; }
+	const std::string& getDefaultValue() const { return mDefaultValue; }
+	void updateDefaultValue(const std::string& newValue) { mDefaultValue = newValue; }
+	void updateDefaultValue(const int newValue) { std::stringstream ss; ss << newValue; updateDefaultValue(ss.str()); }
+	const std::string& getUnits() const { return mUnits; }
+	const VisibilityLevel& getVisibility() const { return mVisibility; }
+	const Type& getType() const { return mType; }
+	const std::string& getValidValues() const { return mValidValues; }
+	bool isStatic() const { return mIsStatic; }
+	const std::string& getDescription() const { return mDescription; }
+
+	static bool isValidIP(const std::string& ip);
+	static void getMinMaxStepping(const ConfigurationKey &key, std::string &min, std::string &max, std::string &stepping);
+	template<class T> static bool isInValRange(const ConfigurationKey &key, const std::string& val, const bool isInteger);
+	static const std::string visibilityLevelToString(const VisibilityLevel& visibility);
+	static const std::string typeToString(const ConfigurationKey::Type& type);
+	static void printKey(const ConfigurationKey &key, const std::string& currentValue, std::ostream& os);
+	static void printDescription(const ConfigurationKey &key, std::ostream& os);
+	static const std::string getARFCNsString();
+};
+
+
+#endif
+
+
+// vim: ts=4 sw=4

CommonLibs/ConfigurationTest.cpp

@@ -0,0 +1,149 @@
+/*
+* Copyright 2009, 2010 Free Software Foundation, Inc.
+* Copyright 2010 Kestrel Signal Processing, 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 "Configuration.h"
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+ConfigurationKeyMap getConfigurationKeys();
+ConfigurationTable gConfig("exampleconfig.db","test", getConfigurationKeys());
+
+void purgeConfig(void*,int,char const*, char const*, sqlite3_int64)
+{
+	//cout << "update hook" << endl;
+	gConfig.purge();
+}
+
+
+int main(int argc, char *argv[])
+{
+
+	gConfig.setUpdateHook(purgeConfig);
+
+	const char *keys[5] = {"key1", "key2", "key3", "key4", "key5"};
+
+	for (int i=0; i<5; i++) {
+		gConfig.set(keys[i],i);
+	}
+
+	for (int i=0; i<5; i++) {
+		cout << "table[" << keys[i] << "]=" << gConfig.getStr(keys[i]) <<  endl;
+		cout << "table[" << keys[i] << "]=" << gConfig.getNum(keys[i]) <<  endl;
+	}
+
+	for (int i=0; i<5; i++) {
+		cout << "defined table[" << keys[i] << "]=" << gConfig.defines(keys[i]) <<  endl;
+	}
+
+	gConfig.set("key5","100 200 300  400 ");
+	std::vector<unsigned> vect = gConfig.getVector("key5");
+	cout << "vect length " << vect.size() << ": ";
+	for (unsigned i=0; i<vect.size(); i++) cout << " " << vect[i];
+	cout << endl;
+	std::vector<string> svect = gConfig.getVectorOfStrings("key5");
+	cout << "vect length " << svect.size() << ": ";
+	for (unsigned i=0; i<svect.size(); i++) cout << " " << svect[i] << ":";
+	cout << endl;
+
+	cout << "bool " << gConfig.getBool("booltest") << endl;
+	gConfig.set("booltest",1);
+	cout << "bool " << gConfig.getBool("booltest") << endl;
+	gConfig.set("booltest",0);
+	cout << "bool " << gConfig.getBool("booltest") << endl;
+
+	gConfig.getStr("newstring");
+	gConfig.getNum("numnumber");
+
+
+	SimpleKeyValue pairs;
+	pairs.addItems(" a=1 b=34 dd=143 ");
+	cout<< pairs.get("a") << endl;
+	cout<< pairs.get("b") << endl;
+	cout<< pairs.get("dd") << endl;
+
+	gConfig.set("fkey","123.456");
+	float fval = gConfig.getFloat("fkey");
+	cout << "fkey " << fval << endl;
+
+	cout << "search fkey:" << endl;
+	gConfig.find("fkey",cout);
+	cout << "search fkey:" << endl;
+	gConfig.find("fkey",cout);
+	gConfig.remove("fkey");
+	cout << "search fkey:" << endl;
+	gConfig.find("fkey",cout);
+
+	try {
+		gConfig.getNum("supposedtoabort");
+	} catch (ConfigurationTableKeyNotFound) {
+		cout << "ConfigurationTableKeyNotFound exception successfully caught." << endl;
+	}
+}
+
+ConfigurationKeyMap getConfigurationKeys()
+{
+	ConfigurationKeyMap map;
+	ConfigurationKey *tmp;
+
+	tmp = new ConfigurationKey("booltest","0",
+		"",
+		ConfigurationKey::DEVELOPER,
+		ConfigurationKey::BOOLEAN,
+		"",
+		false,
+		""
+	);
+	map[tmp->getName()] = *tmp;
+	free(tmp);
+
+	tmp = new ConfigurationKey("numnumber","42",
+		"",
+		ConfigurationKey::DEVELOPER,
+		ConfigurationKey::VALRANGE,
+		"0-100",
+		false,
+		""
+	);
+	map[tmp->getName()] = *tmp;
+	free(tmp);
+
+	tmp = new ConfigurationKey("newstring","new string value",
+		"",
+		ConfigurationKey::DEVELOPER,
+		ConfigurationKey::STRING,
+		"",
+		false,
+		""
+	);
+	map[tmp->getName()] = *tmp;
+	free(tmp);
+
+	return map;
+}

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*).
@@ -55,7 +53,7 @@ template <class T, class Fifo=PointerFIFO> class InterthreadQueue {
 
 	protected:
 
-	Fifo mQ;
+	Fifo mQ;	
 	mutable Mutex mLock;
 	mutable Signal mWriteSignal;
 
@@ -162,7 +160,7 @@ template <class T, class Fifo=PointerFIFO> class InterthreadQueue2 {
 
 	protected:
 
-	Fifo mQ;
+	Fifo mQ;	
 	mutable Mutex mLock;
 	mutable Signal mWriteSignal;
 
@@ -258,7 +256,7 @@ template <class T, class Fifo=PointerFIFO> class InterthreadQueue2 {
 		// This recurs (and the InterthreadQueue fills up with data)
 		// until the read thread's accumulated temporary priority causes it to
 		// get a second pre-emptive activation over the writing thread,
-		// resulting in bursts of activity by the read thread.
+		// resulting in bursts of activity by the read thread. 
 		{ ScopedLock lock(mLock);
 		  mQ.put(val);
 		}
@@ -283,7 +281,7 @@ template <class T> class InterthreadQueueWithWait {
 
 	protected:
 
-	PointerFIFO mQ;
+	PointerFIFO mQ;	
 	mutable Mutex mLock;
 	mutable Signal mWriteSignal;
 	mutable Signal mReadSignal;

CommonLibs/InterthreadTest.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.
@@ -36,20 +35,14 @@ using namespace std;
 InterthreadQueue<int> gQ;
 InterthreadMap<int,int> gMap;
 
-int q_last_read_val = -1;
-int q_last_write_val;
-int m_last_read_val;
-int m_last_write_val;
-
 void* qWriter(void*)
 {
 	int *p;
 	for (int i=0; i<20; i++) {
 		p = new int;
 		*p = i;
-		CERR("queue write " << *p);
+		COUT("queue write " << *p);
 		gQ.write(p);
-		q_last_write_val = i;
 		if (random()%2) sleep(1);
 	}
 	p = new int;
@@ -63,14 +56,8 @@ void* qReader(void*)
 	bool done = false;
 	while (!done) {
 		int *p = gQ.read();
-		CERR("queue read " << *p);
-		if (*p<0) {
-			assert(q_last_read_val == 19 && *p == -1);
-			done = true;
-		} else {
-			assert(q_last_read_val == *p - 1);
-			q_last_read_val = *p;
-		}
+		COUT("queue read " << *p);
+		if (*p<0) done=true;
 		delete p;
 	}
 	return NULL;
@@ -83,9 +70,8 @@ void* mapWriter(void*)
 	for (int i=0; i<20; i++) {
 		p = new int;
 		*p = i;
-		CERR("map write " << *p);
+		COUT("map write " << *p);
 		gMap.write(i,p);
-		m_last_write_val = i;
 		if (random()%2) sleep(1);
 	}
 	return NULL;
@@ -95,9 +81,7 @@ void* mapReader(void*)
 {
 	for (int i=0; i<20; i++) {
 		int *p = gMap.read(i);
-		CERR("map read " << *p);
-		assert(*p == i);
-		m_last_read_val = *p;
+		COUT("map read " << *p);
 		// InterthreadMap will delete the pointers
 		// delete p;
 	}
@@ -125,13 +109,6 @@ int main(int argc, char *argv[])
 	qWriterThread.join();
 	mapReaderThread.join();
 	mapWriterThread.join();
-
-	assert(q_last_write_val == 19);
-	assert(q_last_read_val == 19);
-	assert(m_last_write_val == 19);
-	assert(m_last_read_val == 19);
-
-	printf("Done\n");
 }
 
 

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/LogTest.cpp

@@ -0,0 +1,69 @@
+/*
+* Copyright 2009 Free Software Foundation, Inc.
+* Copyright 2010 Kestrel Signal Processing, 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 <iostream>
+#include <iterator>
+
+#include "Logger.h"
+#include "Configuration.h"
+
+ConfigurationTable gConfig;
+//ConfigurationTable gConfig("example.config");
+
+void printAlarms()
+{
+    std::ostream_iterator<std::string> output( std::cout, "\n" );
+    std::list<std::string> alarms = gGetLoggerAlarms();
+    std::cout << "# alarms = " << alarms.size() << std::endl;
+    std::copy( alarms.begin(), alarms.end(), output );
+}
+
+int main(int argc, char *argv[])
+{
+	gLogInit("LogTest","NOTICE",LOG_LOCAL7);
+
+	LOG(EMERG) << " testing the logger.";
+	LOG(ALERT) << " testing the logger.";
+	LOG(CRIT) << " testing the logger.";
+	LOG(ERR) << " testing the logger.";
+	LOG(WARNING) << " testing the logger.";
+	LOG(NOTICE) << " testing the logger.";
+	LOG(INFO) << " testing the logger.";
+	LOG(DEBUG) << " testing the logger.";
+    std::cout << "\n\n\n";
+    std::cout << "testing Alarms\n";
+    std::cout << "you should see three lines:" << std::endl;
+    printAlarms();
+    std::cout << "----------- generating 20 alarms ----------" << std::endl;
+    for (int i = 0 ; i < 20 ; ++i) {
+        LOG(ALERT) << i;
+    }
+    std::cout << "you should see ten lines with the numbers 10..19:" << std::endl;
+    printAlarms();
+}
+
+
+

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.
@@ -31,33 +32,300 @@
 #include <stdarg.h>
 #include <sys/time.h>	// For gettimeofday
 
+#include "Configuration.h"
 #include "Logger.h"
 #include "Threads.h"	// pat added
 
+
 using namespace std;
 
+// Switches to enable/disable logging targets
+// MUST BE DEFINED BEFORE gConfig FOR gLogEarly() TO WORK CORRECTLY
+bool gLogToConsole = true;
+bool gLogToSyslog = false;
+FILE *gLogToFile = NULL;
+Mutex gLogToLock;
+
+
+// Reference to a global config table, used all over the system.
+extern ConfigurationTable gConfig;
+
+
+/**@ The global alarms table. */
+//@{
+Mutex           alarmsLock;
+list<string>    alarmsList;
+void            addAlarm(const string&);
+//@}
+
+
+
+// (pat) If Log messages are printed before the classes in this module are inited
+// (which happens when static classes have constructors that do work)
+// the OpenBTS just crashes.
+// Prevent that by setting sLoggerInited to true when this module is inited.
+static bool sLoggerInited = 0;
+static struct CheckLoggerInitStatus {
+	CheckLoggerInitStatus() { sLoggerInited = 1; }
+} sCheckloggerInitStatus;
+
+
+
+/** 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;
+}
+
+/** Given a string, return the corresponding level name. */
+int lookupLevel(const string& key)
+{
+	string val = gConfig.getStr(key);
+	int level = levelStringToInt(val);
+
+	if (level == -1) {
+		string defaultLevel = gConfig.mSchema["Log.Level"].getDefaultValue();
+		level = levelStringToInt(defaultLevel);
+		_LOG(CRIT) << "undefined logging level (" << key << " = \"" << val << "\") defaulting to \"" << defaultLevel << ".\" Valid levels are: EMERG, ALERT, CRIT, ERR, WARNING, NOTICE, INFO or DEBUG";
+		gConfig.set(key, defaultLevel);
+	}
+
+	return level;
+}
+
+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();
 }
 
+int getLoggingLevel(const char* filename)
+{
+	// Default level?
+	if (!filename) return lookupLevel("Log.Level");
+
+	// This can afford to be inefficient since it is not called that often.
+	const string keyName = string("Log.Level.") + string(filename);
+	if (gConfig.defines(keyName)) return lookupLevel(keyName);
+	return lookupLevel("Log.Level");
+}
+
+
+
+int gGetLoggingLevel(const char* filename)
+{
+	// This is called a lot and needs to be efficient.
+
+	static Mutex sLogCacheLock;
+	static map<uint64_t,int>  sLogCache;
+	static unsigned sCacheCount;
+	static const unsigned sCacheRefreshCount = 1000;
+
+	if (filename==NULL) return gGetLoggingLevel("");
+
+	HashString hs(filename);
+	uint64_t key = hs.hash();
+
+	sLogCacheLock.lock();
+	// Time for a cache flush?
+	if (sCacheCount>sCacheRefreshCount) {
+		sLogCache.clear();
+		sCacheCount=0;
+	}
+	// Is it cached already?
+	map<uint64_t,int>::const_iterator where = sLogCache.find(key);
+	sCacheCount++;
+	if (where!=sLogCache.end()) {
+		int retVal = where->second;
+		sLogCacheLock.unlock();
+		return retVal;
+	}
+	// Look it up in the config table and cache it.
+	// FIXME: Figure out why unlock and lock below fix the config table deadlock.
+	// (pat) Probably because getLoggingLevel may call LOG recursively via lookupLevel().
+	sLogCacheLock.unlock();
+	int level = getLoggingLevel(filename);
+	sLogCacheLock.lock();
+	sLogCache.insert(pair<uint64_t,int>(key,level));
+	sLogCacheLock.unlock();
+	return level;
+}
+
+
+
+
+
+// copies the alarm list and returns it. list supposed to be small.
+list<string> gGetLoggerAlarms()
+{
+    alarmsLock.lock();
+    list<string> ret;
+    // excuse the "complexity", but to use std::copy with a list you need
+    // an insert_iterator - copy technically overwrites, doesn't insert.
+    insert_iterator< list<string> > ii(ret, ret.begin());
+    copy(alarmsList.begin(), alarmsList.end(), ii);
+    alarmsLock.unlock();
+    return ret;
+}
+
+/** Add an alarm to the alarm list. */
+void addAlarm(const string& s)
+{
+    alarmsLock.lock();
+    alarmsList.push_back(s);
+	unsigned maxAlarms = gConfig.getNum("Log.Alarms.Max");
+    while (alarmsList.size() > maxAlarms) alarmsList.pop_front();
+    alarmsLock.unlock();
+}
+
+
 Log::~Log()
 {
-	int old_state;
-	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);
+	if (mDummyInit) return;
+	// Anything at or above LOG_CRIT is an "alarm".
+	// Save alarms in the local list and echo them to stderr.
+	if (mPriority <= LOG_ERR) {
+		if (sLoggerInited) addAlarm(mStream.str().c_str());
+		cerr << mStream.str() << endl;
+	}
+	// Current logging level was already checked by the macro. So just log.
+	// Log to syslog
+	if (gLogToSyslog) {
+		syslog(mPriority, "%s", mStream.str().c_str());
+	}
+	// Log to file and console
+	if (gLogToConsole||gLogToFile) {
+		int mlen = mStream.str().size();
+		int neednl = (mlen==0 || mStream.str()[mlen-1] != '\n');
+		ScopedLock lock(gLogToLock);
+		if (gLogToConsole) {
+			// 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";
+		}
+		if (gLogToFile) {
+			fputs(mStream.str().c_str(),gLogToFile);
+			if (neednl) {fputc('\n',gLogToFile);}
+			fflush(gLogToFile);
+		}
+	}
 }
 
+
+Log::Log(const char* name, const char* level, int facility)
+{
+	mDummyInit = true;
+	gLogInit(name, level, facility);
+}
+
+
 ostringstream& Log::get()
 {
+	assert(mPriority<numLevels);
+	mStream << levelNames[mPriority] <<  ' ';
 	return mStream;
 }
 
+
+
+void gLogInit(const char* name, const char* level, int facility)
+{
+	// Set the level if one has been specified.
+	if (level) {
+		gConfig.set("Log.Level",level);
+	}
+
+	// Both the transceiver and OpenBTS use this same facility, but only OpenBTS/OpenNodeB may use this log file:
+	string str = gConfig.getStr("Log.File");
+	if (gLogToFile==NULL && str.length() && 0==strncmp(gCmdName,"Open",4)) {
+		const char *fn = str.c_str();
+		if (fn && *fn && strlen(fn)>3) {	// strlen because a garbage char is getting in sometimes.
+			gLogToFile = fopen(fn,"w"); // New log file each time we start.
+			if (gLogToFile) {
+				time_t now;
+				time(&now);
+				fprintf(gLogToFile,"Starting at %s",ctime(&now));
+				fflush(gLogToFile);
+				std::cout << "Logging to file: " << fn << "\n";
+			}
+		}
+	}
+
+	// Open the log connection.
+	openlog(name,0,facility);
+}
+
+
+void gLogEarly(int level, const char *fmt, ...)
+{
+	va_list args;
+
+	va_start(args, fmt);
+
+	if (gLogToSyslog) {
+		va_list args_copy;
+		va_copy(args_copy, args);
+		vsyslog(level | LOG_USER, fmt, args_copy);
+		va_end(args_copy);
+	}
+
+	if (gLogToConsole) {
+		va_list args_copy;
+		va_copy(args_copy, args);
+		vprintf(fmt, args_copy);
+		printf("\n");
+		va_end(args_copy);
+	}
+
+	if (gLogToFile) {
+		va_list args_copy;
+		va_copy(args_copy, args);
+		vfprintf(gLogToFile, fmt, args_copy);
+		fprintf(gLogToFile, "\n");
+		va_end(args_copy);
+	}
+
+	va_end(args);
+}
+
 // 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,47 +23,71 @@
 
 */
 
+// (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
 
+#include <syslog.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <sstream>
+#include <list>
+#include <map>
 #include <string>
 
-extern "C" {
-#include <osmocom/core/logging.h>
-#include "debug.h"
-}
+#define _LOG(level) \
+	Log(LOG_##level).get() << pthread_self() \
+	<< timestr() << " " __FILE__  ":"  << __LINE__ << ":" << __FUNCTION__ << ": "
 
-/* Translation for old log statements */
-#ifndef LOGL_ALERT
-#define LOGL_ALERT LOGL_FATAL
-#endif
-#ifndef LOGL_ERR
-#define LOGL_ERR LOGL_ERROR
-#endif
-#ifndef LOGL_WARNING
-#define LOGL_WARNING LOGL_NOTICE
+#define IS_LOG_LEVEL(wLevel) (gGetLoggingLevel(__FILE__)>=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
 
-#define LOG(level) \
-	Log(DMAIN, LOGL_##level, __BASE_FILE__, __LINE__).get()
+// pat: And for your edification here are the 'levels' as defined in syslog.h:
+// LOG_EMERG   0  system is unusable
+// LOG_ALERT   1  action must be taken immediately
+// LOG_CRIT    2  critical conditions
+// LOG_ERR     3  error conditions
+// LOG_WARNING 4  warning conditions
+// LOG_NOTICE  5  normal, but significant, condition
+// LOG_INFO    6  informational message
+// LOG_DEBUG   7  debug-level message
 
-#define LOGC(category, level) \
-	Log(category, LOGL_##level, __BASE_FILE__, __LINE__).get()
+// (pat) added - print out a var and its name.
+// Use like this: int descriptive_name; LOG(INFO)<<LOGVAR(descriptive_name);
+#define LOGVAR2(name,val) " " << name << "=" << (val)
+#define LOGVAR(var) (" " #var "=") << var
+#define LOGHEX(var) (" " #var "=0x") << hex << ((unsigned)var) << dec
+#define LOGHEX2(name,val) " " << name << "=0x" << hex << ((unsigned)(val)) << dec
+// These are kind of cheesy, but you can use for bitvector
+#define LOGBV2(name,val) " " << name << "=(" << val<<" size:"<<val.size()<<")"
+#define LOGBV(bv) LOGBV2(#bv,bv)
+#define LOGVARRANGE(name,cur,lo,hi) " "<<name <<"=("<<(cur) << " range:"<<(lo) << " to "<<(hi) <<")"
 
-#define LOGLV(category, level) \
-	Log(category, level, __BASE_FILE__, __LINE__).get()
 
-#define LOGSRC(category, level, file, line) \
-	Log(category, level, file, line).get()
+#define OBJLOG(wLevel) \
+	LOG(wLevel) << "obj: " << this << ' '
 
-#define LOGCHAN(chan, category, level) \
-	Log(category, LOGL_##level, __BASE_FILE__, __LINE__).get() <<  "[chan=" << chan << "] "
+#define LOG_ASSERT(x) { if (!(x)) LOG(EMERG) << "assertion " #x " failed"; } assert(x);
+
+
+#include "Threads.h"		// must be after defines above, if these files are to be allowed to use LOG()
 
 /**
 	A C++ stream-based thread-safe logger.
+	Derived from Dr. Dobb's Sept. 2007 issue.
+	Updated to use syslog.
 	This object is NOT the global logger;
 	every log record is an object of this class.
 */
@@ -75,28 +97,45 @@ 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.
+	bool mDummyInit;
 
 	public:
 
-	Log(int wCategory, int wPriority, const char* filename, int line)
-		: mCategory(wCategory), mPriority(wPriority),
-		  filename(filename), line(line)
+	Log(int wPriority)
+		:mPriority(wPriority), mDummyInit(false)
 	{ }
 
+	Log(const char* name, const char* level=NULL, int facility=LOG_USER);
+
 	// Most of the work is in the destructor.
 	/** The destructor actually generates the log entry. */
 	~Log();
 
 	std::ostringstream& get();
 };
+extern bool gLogToConsole;	// Output log messages to stdout
+extern bool gLogToSyslog;	// Output log messages to syslog
 
+
+
+std::list<std::string> gGetLoggerAlarms();		///< Get a copy of the recent alarm list.
+
+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* name, const char* level=NULL, int facility=LOG_USER);
+/** Get the logging level associated with a given file. */
+int gGetLoggingLevel(const char *filename=NULL);
+/** Allow early logging when still in constructors */
+void gLogEarly(int level, const char *fmt, ...) __attribute__((format(printf, 2, 3)));
+//@}
+
+
 #endif
 
 // vim: ts=4 sw=4

CommonLibs/Makefile.am

@@ -22,35 +22,77 @@
 include $(top_srcdir)/Makefile.common
 
 AM_CPPFLAGS = $(STD_DEFINES_AND_INCLUDES)
-AM_CXXFLAGS = -Wall -O3 -g -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
-AM_CFLAGS = $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
+AM_CXXFLAGS = -Wall -O3 -g -ldl -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)
+	Configuration.cpp \
+	sqlite3util.cpp
+
+noinst_PROGRAMS = \
+	BitVectorTest \
+	PRBSTest \
+	InterthreadTest \
+	SocketsTest \
+	TimevalTest \
+	VectorTest \
+	ConfigurationTest \
+	LogTest
+
+#	ReportingTest 
 
 noinst_HEADERS = \
 	BitVector.h \
 	PRBS.h \
 	Interthread.h \
 	LinkedLists.h \
+	Sockets.h \
 	Threads.h \
 	Timeval.h \
 	Vector.h \
+	Configuration.h \
 	Logger.h \
-	Utils.h \
-	trx_rate_ctr.h \
-	trx_vty.h \
-	debug.h \
-	osmo_signal.h \
-	config_defs.h
+	sqlite3util.h
+
+BitVectorTest_SOURCES = BitVectorTest.cpp
+BitVectorTest_LDADD = libcommon.la $(SQLITE3_LIBS)
+
+PRBSTest_SOURCES = PRBSTest.cpp
+
+InterthreadTest_SOURCES = InterthreadTest.cpp
+InterthreadTest_LDADD = libcommon.la
+InterthreadTest_LDFLAGS = -lpthread
+
+SocketsTest_SOURCES = SocketsTest.cpp
+SocketsTest_LDADD = libcommon.la
+SocketsTest_LDFLAGS = -lpthread
+
+TimevalTest_SOURCES = TimevalTest.cpp
+TimevalTest_LDADD = libcommon.la
+
+VectorTest_SOURCES = VectorTest.cpp
+VectorTest_LDADD = libcommon.la $(SQLITE3_LIBS)
+
+ConfigurationTest_SOURCES = ConfigurationTest.cpp
+ConfigurationTest_LDADD = libcommon.la 	$(SQLITE3_LIBS)
+
+# ReportingTest_SOURCES = ReportingTest.cpp
+# ReportingTest_LDADD = libcommon.la $(SQLITE_LA)
+
+LogTest_SOURCES = LogTest.cpp
+LogTest_LDADD = libcommon.la $(SQLITE3_LIBS)
+
+MOSTLYCLEANFILES += testSource testDestination
+
+

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/PRBSTest.cpp

@@ -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
  */
 
 #include "PRBS.h"

CommonLibs/Sockets.cpp

@@ -0,0 +1,333 @@
+/*
+* 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(unsigned short wSrcPort)
+	:DatagramSocket()
+{
+	open(wSrcPort);
+}
+
+
+UDPSocket::UDPSocket(unsigned short wSrcPort,
+          	 const char * wDestIP, unsigned short wDestPort )
+	:DatagramSocket()
+{
+	open(wSrcPort);
+	destination(wDestPort, wDestIP);
+}
+
+
+
+void UDPSocket::destination( unsigned short wDestPort, const char * wDestIP )
+{
+	resolveAddress((sockaddr_in*)mDestination, wDestIP, wDestPort );
+}
+
+
+void UDPSocket::open(unsigned short localPort)
+{
+	// 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 = htonl(INADDR_LOOPBACK);
+	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);
+}
+
+
+
+
+
+UDDSocket::UDDSocket(const char* localPath, const char* remotePath)
+	:DatagramSocket()
+{
+	if (localPath!=NULL) open(localPath);
+	if (remotePath!=NULL) destination(remotePath);
+}
+
+
+
+void UDDSocket::open(const char* localPath)
+{
+	// create
+	mSocketFD = socket(AF_UNIX,SOCK_DGRAM,0);
+	if (mSocketFD<0) {
+		perror("socket() failed");
+		throw SocketError();
+	}
+
+	// bind
+	struct sockaddr_un address;
+	size_t length = sizeof(address);
+	bzero(&address,length);
+	address.sun_family = AF_UNIX;
+	strcpy(address.sun_path,localPath);
+	unlink(localPath);
+	if (bind(mSocketFD,(struct sockaddr*)&address,length)<0) {
+		perror("bind() failed");
+		throw SocketError();
+	}
+}
+
+
+
+void UDDSocket::destination(const char* remotePath)
+{
+	struct sockaddr_un* unAddr = (struct sockaddr_un*)mDestination;
+	strcpy(unAddr->sun_path,remotePath);
+}
+
+
+
+
+// vim:ts=4:sw=4

CommonLibs/Sockets.h

@@ -0,0 +1,193 @@
+/*
+* 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( unsigned short localPort=0);
+
+	/** Given a full specification, open the socket and set the dest address. */
+	UDPSocket( 	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);
+
+	/** 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); }
+
+};
+
+
+/** Unix Domain Datagram Socket */
+class UDDSocket : public DatagramSocket {
+
+public:
+
+	UDDSocket(const char* localPath=NULL, const char* remotePath=NULL);
+
+	void destination(const char* remotePath);
+
+	void open(const char* localPath);
+
+	/** Give the return address of the most recently received packet. */
+	const struct sockaddr_un* source() const { return (const struct sockaddr_un*)mSource; }
+
+	size_t addressSize() const { return sizeof(struct sockaddr_un); }
+
+};
+
+
+#endif
+
+
+
+// vim:ts=4:sw=4

CommonLibs/SocketsTest.cpp

@@ -0,0 +1,103 @@
+/*
+* Copyright 2008 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 "Sockets.h"
+#include "Threads.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+
+static const int gNumToSend = 10;
+
+
+void *testReaderIP(void *)
+{
+	UDPSocket readSocket(5934, "localhost", 5061);
+	readSocket.nonblocking();
+	int rc = 0;
+	while (rc<gNumToSend) {
+		char buf[MAX_UDP_LENGTH];
+		int count = readSocket.read(buf, MAX_UDP_LENGTH);
+		if (count>0) {
+			COUT("read: " << buf);
+			rc++;
+		} else {
+			sleep(2);
+		}
+	}
+	return NULL;
+}
+
+
+
+void *testReaderUnix(void *)
+{
+	UDDSocket readSocket("testDestination");
+	readSocket.nonblocking();
+	int rc = 0;
+	while (rc<gNumToSend) {
+		char buf[MAX_UDP_LENGTH];
+		int count = readSocket.read(buf, MAX_UDP_LENGTH);
+		if (count>0) {
+			COUT("read: " << buf);
+			rc++;
+		} else {
+			sleep(2);
+		}
+	}
+	return NULL;
+}
+
+
+int main(int argc, char * argv[] )
+{
+
+  Thread readerThreadIP;
+  readerThreadIP.start(testReaderIP,NULL);
+  Thread readerThreadUnix;
+  readerThreadUnix.start(testReaderUnix,NULL);
+
+  UDPSocket socket1(5061, "127.0.0.1",5934);
+  UDDSocket socket1U("testSource","testDestination");
+  
+  COUT("socket1: " << socket1.port());
+
+  // give the readers time to open
+  sleep(1);
+
+  for (int i=0; i<gNumToSend; i++) {
+    socket1.write("Hello IP land");	
+	socket1U.write("Hello Unix domain");
+	sleep(1);
+  }
+
+  readerThreadIP.join();
+  readerThreadUnix.join();
+}
+
+// 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,22 +24,16 @@
 */
 
 
-#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
+
 
 
 Mutex gStreamLock;		///< Global lock to control access to cout and cerr.
@@ -49,7 +42,7 @@ void lockCout()
 {
 	gStreamLock.lock();
 	Timeval entryTime;
-	cout << entryTime << " " << osmo_gettid() << ": ";
+	cout << entryTime << " " << pthread_self() << ": ";
 }
 
 
@@ -64,7 +57,7 @@ void lockCerr()
 {
 	gStreamLock.lock();
 	Timeval entryTime;
-	cerr << entryTime << " " << osmo_gettid() << ": ";
+	cerr << entryTime << " " << pthread_self() << ": ";
 }
 
 void unlockCerr()
@@ -109,25 +102,6 @@ void Signal::wait(Mutex& wMutex, unsigned timeout) const
 	pthread_cond_timedwait(&mSignal,&wMutex.mMutex,&waitTime);
 }
 
-void set_selfthread_name(const char *name)
-{
-	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;
-	}
-}
-
-void thread_enable_cancel(bool cancel)
-{
-	cancel ? pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) :
-		 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
-}
 
 void Thread::start(void *(*task)(void*), void *arg)
 {
@@ -136,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,8 +26,6 @@
 #ifndef THREADS_H
 #define THREADS_H
 
-#include "config.h"
-
 #include <pthread.h>
 #include <iostream>
 #include <assert.h>
@@ -59,7 +55,7 @@ void unlockCout();		///< call after writing cout
 #define OBJDCOUT(text) {}
 #else
 #define DCOUT(text) { COUT(__FILE__ << ":" << __LINE__ << " " << text); }
-#define OBJDCOUT(text) { DCOUT(this << " " << text); }
+#define OBJDCOUT(text) { DCOUT(this << " " << text); } 
 #endif
 //@}
 //@}
@@ -145,9 +141,6 @@ class Signal {
 #define START_THREAD(thread,function,argument) \
 	thread.start((void *(*)(void*))function, (void*)argument);
 
-void set_selfthread_name(const char *name);
-void thread_enable_cancel(bool cancel);
-
 /** A C++ wrapper for pthread threads.  */
 class Thread {
 
@@ -157,12 +150,12 @@ class Thread {
 	pthread_attr_t mAttrib;
 	// FIXME -- Can this be reduced now?
 	size_t mStackSize;
-
+	
 
 	public:
 
 	/** Create a thread in a non-running state. */
-	Thread(size_t wStackSize = 0):mThread((pthread_t)0) {
+	Thread(size_t wStackSize = (65536*4)):mThread((pthread_t)0) {
 		pthread_attr_init(&mAttrib);	// (pat) moved this here.
 		mStackSize=wStackSize;
 	}
@@ -186,34 +179,12 @@ class Thread {
 		}
 	}
 
-	/** Send cancellation to thread */
+	/** 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,25 +72,24 @@ 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;
 }
-
+	
 
 
 
 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/TimevalTest.cpp

@@ -0,0 +1,45 @@
+/*
+* Copyright 2008 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 "Timeval.h"
+#include <iostream>
+
+using namespace std;
+
+int main(int argc, char *argv[])
+{
+
+	Timeval then(10000);
+	cout << then.elapsed() << endl;
+
+	while (!then.passed()) {
+		cout << "now: " << Timeval() << " then: " << then << " remaining: " << then.remaining() << endl;
+		usleep(500000);
+	}
+	cout << "now: " << Timeval() << " then: " << then << " remaining: " << then.remaining() << endl;
+}

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(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)
+	/** Build a Vector by shifting the data block. */
+	Vector(Vector<T>& other)
+		: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];
 	}
 
@@ -313,7 +282,7 @@ template <class T> class Vector {
 	T* end() { return mEnd; }
 	bool isOwner() { return !!mData; }	// Do we own any memory ourselves?
 	//@}
-
+	
 
 };
 

CommonLibs/VectorTest.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.
@@ -29,6 +28,10 @@
 #include "Vector.h"
 #include <iostream>
 
+// We must have a gConfig now to include Vector.
+#include "Configuration.h"
+ConfigurationTable gConfig;
+
 using namespace std;
 
 typedef Vector<int> TestVector;

CommonLibs/config_defs.h

@@ -1,60 +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];
-};

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/sqlite3util.cpp

@@ -0,0 +1,154 @@
+/*
+* Copyright 2010 Kestrel Signal Processing, Inc.
+* All rights reserved.
+*/
+
+
+#include <sqlite3.h>
+#include "sqlite3util.h"
+
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+
+
+// Wrappers to sqlite operations.
+// These will eventually get moved to commonlibs.
+
+int sqlite3_prepare_statement(sqlite3* DB, sqlite3_stmt **stmt, const char* query)
+{
+        int src = SQLITE_BUSY;
+        while (src==SQLITE_BUSY) {
+                src = sqlite3_prepare_v2(DB,query,strlen(query),stmt,NULL);
+                if (src==SQLITE_BUSY) {
+                        usleep(100000);
+                }
+        }
+        if (src) {
+                fprintf(stderr,"sqlite3_prepare_v2 failed for \"%s\": %s\n",query,sqlite3_errmsg(DB));
+                sqlite3_finalize(*stmt);
+        }
+        return src;
+}
+
+int sqlite3_run_query(sqlite3* DB, sqlite3_stmt *stmt)
+{
+	int src = SQLITE_BUSY;
+	while (src==SQLITE_BUSY) {
+		src = sqlite3_step(stmt);
+		if (src==SQLITE_BUSY) {
+			usleep(100000);
+		}
+	}
+	if ((src!=SQLITE_DONE) && (src!=SQLITE_ROW)) {
+		fprintf(stderr,"sqlite3_run_query failed: %s: %s\n", sqlite3_sql(stmt), sqlite3_errmsg(DB));
+	}
+	return src;
+}
+
+
+bool sqlite3_exists(sqlite3* DB, const char *tableName,
+		const char* keyName, const char* keyData)
+{
+	size_t stringSize = 100 + strlen(tableName) + strlen(keyName) + strlen(keyData);
+	char query[stringSize];
+	sprintf(query,"SELECT * FROM %s WHERE %s == \"%s\"",tableName,keyName,keyData);
+	// Prepare the statement.
+	sqlite3_stmt *stmt;
+	if (sqlite3_prepare_statement(DB,&stmt,query)) return false;
+	// Read the result.
+	int src = sqlite3_run_query(DB,stmt);
+	sqlite3_finalize(stmt);
+	// Anything there?
+	return (src == SQLITE_ROW);
+}
+
+
+
+bool sqlite3_single_lookup(sqlite3* DB, const char *tableName,
+		const char* keyName, const char* keyData,
+		const char* valueName, unsigned &valueData)
+{
+	size_t stringSize = 100 + strlen(valueName) + strlen(tableName) + strlen(keyName) + strlen(keyData);
+	char query[stringSize];
+	sprintf(query,"SELECT %s FROM %s WHERE %s == \"%s\"",valueName,tableName,keyName,keyData);
+	// Prepare the statement.
+	sqlite3_stmt *stmt;
+	if (sqlite3_prepare_statement(DB,&stmt,query)) return false;
+	// Read the result.
+	int src = sqlite3_run_query(DB,stmt);
+	bool retVal = false;
+	if (src == SQLITE_ROW) {
+		valueData = (unsigned)sqlite3_column_int64(stmt,0);
+		retVal = true;
+	}
+	sqlite3_finalize(stmt);
+	return retVal;
+}
+
+
+// This function returns an allocated string that must be free'd by the caller.
+bool sqlite3_single_lookup(sqlite3* DB, const char* tableName,
+		const char* keyName, const char* keyData,
+		const char* valueName, char* &valueData)
+{
+	valueData=NULL;
+	size_t stringSize = 100 + strlen(valueName) + strlen(tableName) + strlen(keyName) + strlen(keyData);
+	char query[stringSize];
+	sprintf(query,"SELECT %s FROM %s WHERE %s == \"%s\"",valueName,tableName,keyName,keyData);
+	// Prepare the statement.
+	sqlite3_stmt *stmt;
+	if (sqlite3_prepare_statement(DB,&stmt,query)) return false;
+	// Read the result.
+	int src = sqlite3_run_query(DB,stmt);
+	bool retVal = false;
+	if (src == SQLITE_ROW) {
+		const char* ptr = (const char*)sqlite3_column_text(stmt,0);
+		if (ptr) valueData = strdup(ptr);
+		retVal = true;
+	}
+	sqlite3_finalize(stmt);
+	return retVal;
+}
+
+
+// This function returns an allocated string that must be free'd by tha caller.
+bool sqlite3_single_lookup(sqlite3* DB, const char* tableName,
+		const char* keyName, unsigned keyData,
+		const char* valueName, char* &valueData)
+{
+	valueData=NULL;
+	size_t stringSize = 100 + strlen(valueName) + strlen(tableName) + strlen(keyName) + 20;
+	char query[stringSize];
+	sprintf(query,"SELECT %s FROM %s WHERE %s == %u",valueName,tableName,keyName,keyData);
+	// Prepare the statement.
+	sqlite3_stmt *stmt;
+	if (sqlite3_prepare_statement(DB,&stmt,query)) return false;
+	// Read the result.
+	int src = sqlite3_run_query(DB,stmt);
+	bool retVal = false;
+	if (src == SQLITE_ROW) {
+		const char* ptr = (const char*)sqlite3_column_text(stmt,0);
+		if (ptr) valueData = strdup(ptr);
+		retVal = true;
+	}
+	sqlite3_finalize(stmt);
+	return retVal;
+}
+
+
+
+
+bool sqlite3_command(sqlite3* DB, const char* query)
+{
+	// Prepare the statement.
+	sqlite3_stmt *stmt;
+	if (sqlite3_prepare_statement(DB,&stmt,query)) return false;
+	// Run the query.
+	int src = sqlite3_run_query(DB,stmt);
+	sqlite3_finalize(stmt);
+	return src==SQLITE_DONE;
+}
+
+
+

CommonLibs/sqlite3util.h

@@ -0,0 +1,29 @@
+#ifndef SQLITE3UTIL_H
+#define SQLITE3UTIL_H
+
+#include <sqlite3.h>
+
+int sqlite3_prepare_statement(sqlite3* DB, sqlite3_stmt **stmt, const char* query);
+
+int sqlite3_run_query(sqlite3* DB, sqlite3_stmt *stmt);
+
+bool sqlite3_single_lookup(sqlite3* DB, const char *tableName,
+		const char* keyName, const char* keyData,
+		const char* valueName, unsigned &valueData);
+
+bool sqlite3_single_lookup(sqlite3* DB, const char* tableName,
+		const char* keyName, const char* keyData,
+		const char* valueName, char* &valueData);
+
+// This function returns an allocated string that must be free'd by the caller.
+bool sqlite3_single_lookup(sqlite3* DB, const char* tableName,
+		const char* keyName, unsigned keyData,
+		const char* valueName, char* &valueData);
+
+bool sqlite3_exists(sqlite3* DB, const char* tableName,
+		const char* keyName, const char* keyData);
+
+/** Run a query, ignoring the result; return true on success. */
+bool sqlite3_command(sqlite3* DB, const char* query);
+
+#endif

CommonLibs/trx_rate_ctr.cpp

@@ -1,410 +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)) {
-		if (osmo_timer_pending(&threshold_timer))
-			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,814 +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(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;
-
-	struct trx_ctx *trx = trx_from_vty(vty);
-	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;
-
-	struct trx_ctx *trx = trx_from_vty(vty);
-	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 (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);
-	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;
-
-	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_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.
 *
@@ -56,10 +54,7 @@ const BitVector GSM::gEdgeTrainingSequence[] = {
 
 const BitVector GSM::gDummyBurst("0001111101101110110000010100100111000001001000100000001111100011100010111000101110001010111010010100011001100111001111010011111000100101111101010000");
 
-/* 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::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.
 *
@@ -54,9 +52,7 @@ extern const BitVector gEdgeTrainingSequence[];
 extern const BitVector gDummyBurst;
 
 /** Random access burst synch. sequence */
-extern const BitVector gRACHSynchSequenceTS0;
-extern const BitVector gRACHSynchSequenceTS1;
-extern const BitVector gRACHSynchSequenceTS2;
+extern const BitVector gRACHSynchSequence;
 /** Random access burst synch. sequence, GSM 05.02 5.2.7 */
 extern const BitVector gRACHBurst;
 
@@ -168,7 +164,7 @@ class Time {
         unsigned newTN = (mTN + other.mTN) % 8;
 		uint64_t newFN = (mFN+other.mFN + (mTN + other.mTN)/8) % gHyperframe;
         return Time(newFN,newTN);
-    }
+    } 
 
 	int operator-(const Time& other) const
 	{

INSTALLATION

@@ -0,0 +1,33 @@
+Installation Requirements
+
+
+
+OpenBTS 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 OpenBTS, the following should be installed:
+
+	Asterisk (http://www.asterisk.org), running SIP on port 5060.
+
+	libosip2 (http://www.gnu.org/software/osip/)
+
+	libortp (http://freshmeat.net/projects/ortp/)
+
+	libusrp (http://gnuradio.org).
+	This is part of the GNURadio installation.
+	It is the only part used by OpenBTS.
+
+
+OpenBTS logs to syslogd as facility LOG_LOCAL7.  Please set your /etc/syslog.conf
+accordingly.
+
+
+For information on specific executables, see tests/README.tests and
+apps/README.apps.
+
+See http://gnuradio.org/redmine/wiki/gnuradio/OpenBTS/BuildingAndRunning for more
+information.
+

LEGAL

@@ -1,8 +1,5 @@
 OpenBTS
 
-The OsmoTRX project is direved from OpenBTS transceiver code. See http://openbts.org/ for details.
-
-The related copyrights:
 Most parts copyright 2008-2011 Free Software Foundation.
 Some parts copyright 2010 Kestrel Signal Processing, Inc.
 Some parts copyright 2011 Range Networks, Inc.
@@ -15,9 +12,17 @@ patented technologies.  The user of this software is required to take whatever
 actions are necessary to avoid patent infringement.
 
 
+Trademark
+
+"OpenBTS" is a registered trademark of Range Networks, Inc. (Range), a
+California corporation.  Range reserves the right to control the use of this 
+trademark.  Do not use this trademark in commerce without permission and do not
+rebrand OpenBTS under a different trademark.
+
+
 Telecom and Radio Spectrum Laws
 
-The primary function of OsmoTRX is the provision of telecommunications service
+The primary function of OpenBTS is the provision of telecommunications service
 over a radio link.  This activity is heavily regulated nearly everywhere in
 the world.  Users of this software are expected to comply with local and national
 regulations in the jurisdictions where this sortware is used with radio equipment.
@@ -34,7 +39,7 @@ The legal restrictions listed here are not necessarily exhaustive.
 
 Note to US Government Users
 
-The OsmoTRX software applications and associated documentation are "Commercial
+The OpenBTS software applications and associated documentation are "Commercial
 Item(s)," as that term is defined at 48 C.F.R. Section 2.101, consisting of
 "Commercial Computer Software" and "Commercial Computer Software Documentation,"
 as such terms are used in 48 C.F.R. 12.212 or 48 C.F.R. 227.7202, as
@@ -49,12 +54,13 @@ and AGPLv3.
 Note to US Government Contractors
 
 GPL is not compatible with "government purpose rights" (GPR).  If you receive
-OsmoTRX software under a GPL and deliver it under GPR, you will be in violation
+OpenBTS software under a GPL and deliver it under GPR, you will be in violation
 of GPL and possibly subject to enforcement actions by the original authors and
 copyright holders, including the Free Software Foundation, Inc.
 
 
 Software Licensing and Distribution
 
-The OsmoTRX is distributed publicly under AGPLv3. See the COPYING file
+A subset of OpenBTS is distributed publicly under AGPLv3.  Range reserves the right to
+distribute most of this source code other licenses as well.  See the COPYING file
 for more information on the license for this distribution.

Makefile.am

@@ -21,36 +21,24 @@
 include $(top_srcdir)/Makefile.common
 
 ACLOCAL_AMFLAGS = -I config
-AM_CPPFLAGS = $(STD_DEFINES_AND_INCLUDES) $(USB_INCLUDES) $(WITH_INCLUDES)
-AM_CXXFLAGS = -Wall -pthread
-#AM_CXXFLAGS = -Wall -O2 -NDEBUG -pthread
-#AM_CFLAGS = -Wall -O2 -NDEBUG -pthread
+AM_CPPFLAGS = $(STD_DEFINES_AND_INCLUDES) $(USB_INCLUDES) $(WITH_INCLUDES) $(SQLITE3_CFLAGS)
+AM_CXXFLAGS = -Wall -pthread -ldl
+#AM_CXXFLAGS = -Wall -O2 -NDEBUG -pthread -ldl
+#AM_CFLAGS = -Wall -O2 -NDEBUG -pthread -ldl
 
 # Order must be preserved
 SUBDIRS = \
 	CommonLibs \
 	GSM \
-	Transceiver52M \
-	contrib \
-	tests \
-	utils \
-	doc \
-	$(NULL)
+	Transceiver52M
 
 EXTRA_DIST = \
+	autogen.sh \
+	INSTALLATION \
 	LEGAL \
 	COPYING \
-	README.md \
-	contrib/osmo-trx.spec.in \
-	debian \
-	$(NULL)
+	README
 
-AM_DISTCHECK_CONFIGURE_FLAGS = \
-	--with-systemdsystemunitdir=$$dc_install_base/$(systemdsystemunitdir)
-
-.PHONY: release
-
-@RELMAKE@
 
 dox: FORCE
 	doxygen doxconfig

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
 
@@ -29,10 +32,4 @@ STD_DEFINES_AND_INCLUDES = \
 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
-else
-ARCH_LA = $(top_builddir)/Transceiver52M/arch/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,64 +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 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 git://git.osmocom.org/osmo-trx.git
-
-There is a cgit interface at <https://git.osmocom.org/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>.
-
-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.
-
-Contributing
-------------
-
-Our coding standards are described at
-<https://osmocom.org/projects/cellular-infrastructure/wiki/Coding_standards>
-
-We us 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>

Transceiver52M/Channelizer.cpp

@@ -1,11 +1,9 @@
 /*
  * Polyphase channelizer
- *
+ * 
  * 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
@@ -27,11 +25,12 @@
 #include <string.h>
 #include <cstdio>
 
+#include "Logger.h"
 #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,
@@ -65,7 +64,7 @@ float *Channelizer::outputBuffer(size_t chan) const
 	return hInputs[chan];
 }
 
-/*
+/* 
  * Implementation based on material found in:
  *
  * "harris, fred, Multirate Signal Processing, Upper Saddle River, NJ,
@@ -80,8 +79,8 @@ bool Channelizer::rotate(const float *in, size_t len)
 
 	deinterleave(in, len, hInputs, blockLen, m);
 
-	/*
-	 * Convolve through filterbank while applying and saving sample history
+	/* 
+	 * Convolve through filterbank while applying and saving sample history 
 	 */
 	for (size_t i = 0; i < m; i++) {
 		memcpy(&hInputs[i][2 * -hLen], hist[i], hSize);
@@ -90,7 +89,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 +97,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

@@ -1,10 +1,8 @@
 /*
  * Polyphase channelizer
- *
+ * 
  * Copyright (C) 2012-2014 Tom Tsou <tom@tsou.cc>
- * Copyright (C) 2015 Ettus Research LLC
- *
- * SPDX-License-Identifier: AGPL-3.0+
+ * Copyright (C) 2015 Ettus Research LLC 
  *
  * 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
@@ -31,7 +29,7 @@
 #include "ChannelizerBase.h"
 
 extern "C" {
-#include "fft.h"
+#include "common/fft.h"
 }
 
 static float sinc(float x)
@@ -57,10 +55,10 @@ static void reverse(float *buf, size_t len)
 	}
 }
 
-/*
+/* 
  * Create polyphase filterbank
  *
- * Implementation based material found in,
+ * Implementation based material found in, 
  *
  * "harris, fred, Multirate Signal Processing, Upper Saddle River, NJ,
  *     Prentice Hall, 2006."
@@ -72,7 +70,7 @@ bool ChannelizerBase::initFilters()
 	float sum = 0.0f, scale = 0.0f;
 	float midpt = (float) (protoLen - 1.0) / 2.0;
 
-	/*
+	/* 
 	 * Allocate 'M' partition filters and the temporary prototype
 	 * filter. Coefficients are real only and must be 16-byte memory
 	 * aligned for SSE usage.
@@ -92,7 +90,7 @@ bool ChannelizerBase::initFilters()
 				memalign(16, hLen * 2 * sizeof(float));
 	}
 
-	/*
+	/* 
 	 * Generate the prototype filter with a Blackman-harris window.
 	 * Scale coefficients with DC filter gain set to unity divided
 	 * by the number of channels.
@@ -112,7 +110,7 @@ bool ChannelizerBase::initFilters()
 	}
 	scale = (float) m / sum;
 
-	/*
+	/* 
 	 * Populate partition filters and reverse the coefficients per
 	 * convolution requirements.
 	 */
@@ -176,7 +174,7 @@ bool ChannelizerBase::mapBuffers()
 	return true;
 }
 
-/*
+/* 
  * Setup filterbank internals
  */
 bool ChannelizerBase::init()
@@ -224,12 +222,11 @@ bool ChannelizerBase::checkLen(size_t innerLen, size_t outerLen)
 	return true;
 }
 
-/*
- * 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.

Transceiver52M/Makefile.am

@@ -21,13 +21,34 @@
 
 include $(top_srcdir)/Makefile.common
 
-SUBDIRS = arch device
+AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/common
+AM_CXXFLAGS = -ldl -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 ARCH_ARM
+ARCH_LA = arm/libarch.la
+else
+ARCH_LA = x86/libarch.la
+endif
+
+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,77 +61,65 @@ COMMON_SOURCES = \
 	ChannelizerBase.cpp \
 	Channelizer.cpp \
 	Synthesis.cpp \
-	proto_trxd.c
+	common/fft.c
 
-libtransceiver_common_la_SOURCES = \
+libtransceiver_la_SOURCES = \
 	$(COMMON_SOURCES) \
 	Resampler.cpp \
 	radioInterfaceResamp.cpp \
 	radioInterfaceMulti.cpp
 
+bin_PROGRAMS = \
+	osmo-trx \
+	osmo-trx-gen \
+	osmo-trx-dec
+
 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)
+	$(COMMON_LA) $(SQLITE3_LIBS)
 
-bin_PROGRAMS =
+osmo_trx_gen_SOURCES = osmo-trx-gen.cpp
+osmo_trx_gen_LDADD = \
+	libtransceiver.la \
+	$(ARCH_LA) \
+	$(GSM_LA) \
+	$(COMMON_LA) $(SQLITE_LA)
 
-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)
+osmo_trx_dec_SOURCES = osmo-trx-dec.cpp
+osmo_trx_dec_LDADD = \
+	libtransceiver.la \
+	$(ARCH_LA) \
+	$(GSM_LA) \
+	$(COMMON_LA) $(SQLITE_LA)
+
+if USRP1 
+libtransceiver_la_SOURCES += USRPDevice.cpp
+osmo_trx_LDADD += $(USRP_LIBS)
+else
+libtransceiver_la_SOURCES += UHDDevice.cpp
+osmo_trx_LDADD += $(UHD_LIBS) $(FFTWF_LIBS)
 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_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)
-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>
@@ -20,7 +22,6 @@
 #include <string.h>
 #include <malloc.h>
 #include <iostream>
-#include <algorithm>
 
 #include "Resampler.h"
 
@@ -34,8 +35,6 @@ extern "C" {
 
 #define MAX_OUTPUT_LEN		4096
 
-using namespace std;
-
 static float sinc(float x)
 {
 	if (x == 0.0)
@@ -44,24 +43,37 @@ static float sinc(float x)
 	return sin(M_PI * x) / (M_PI * x);
 }
 
-void Resampler::initFilters(float bw)
+bool Resampler::initFilters(float bw)
 {
-	float cutoff;
+	size_t proto_len = p * filt_len;
+	float *proto, val, cutoff;
 	float sum = 0.0f, scale = 0.0f;
+	float midpt = (float) (proto_len - 1.0) / 2.0;
 
-	/*
+	/* 
 	 * Allocate partition filters and the temporary prototype filter
 	 * according to numerator of the rational rate. Coefficients are
 	 * real only and must be 16-byte memory aligned for SSE usage.
 	 */
-	auto proto = vector<float>(p * filt_len);
-	for (auto &part : partitions)
-		part = (complex<float> *) memalign(16, filt_len * sizeof(complex<float>));
+	proto = new float[proto_len];
+	if (!proto)
+		return false;
 
-	/*
+	partitions = (float **) malloc(sizeof(float *) * p);
+	if (!partitions) {
+		delete[] proto;
+		return false;
+	}
+
+	for (size_t i = 0; i < p; i++) {
+		partitions[i] = (float *)
+				memalign(16, filt_len * 2 * sizeof(float));
+	}
+
+	/* 
 	 * Generate the prototype filter with a Blackman-harris window.
 	 * Scale coefficients with DC filter gain set to unity divided
-	 * by the number of filter partitions.
+	 * by the number of filter partitions. 
 	 */
 	float a0 = 0.35875;
 	float a1 = 0.48829;
@@ -73,29 +85,49 @@ void Resampler::initFilters(float bw)
 	else
 		cutoff = (float) q;
 
-	float midpt = (proto.size() - 1) / 2.0;
-	for (size_t i = 0; i < proto.size(); i++) {
+	for (size_t i = 0; i < proto_len; i++) {
 		proto[i] = sinc(((float) i - midpt) / cutoff * bw);
 		proto[i] *= a0 -
-			    a1 * cos(2 * M_PI * i / (proto.size() - 1)) +
-			    a2 * cos(4 * M_PI * i / (proto.size() - 1)) -
-			    a3 * cos(6 * M_PI * i / (proto.size() - 1));
+			    a1 * cos(2 * M_PI * i / (proto_len - 1)) +
+			    a2 * cos(4 * M_PI * i / (proto_len - 1)) -
+			    a3 * cos(6 * M_PI * i / (proto_len - 1));
 		sum += proto[i];
 	}
 	scale = p / sum;
 
 	/* Populate filter partitions from the prototype filter */
 	for (size_t i = 0; i < filt_len; i++) {
-		for (size_t n = 0; n < p; n++)
-			partitions[n][i] = complex<float>(proto[i * p + n] * scale);
+		for (size_t n = 0; n < p; n++) {
+			partitions[n][2 * i + 0] = proto[i * p + n] * scale;
+			partitions[n][2 * i + 1] = 0.0f;
+		}
 	}
 
-	/* Store filter taps in reverse */
-	for (auto &part : partitions)
-		reverse(&part[0], &part[filt_len]);
+	/* For convolution, we store the filter taps in reverse */ 
+	for (size_t n = 0; n < p; n++) {
+		for (size_t i = 0; i < filt_len / 2; i++) {
+			val = partitions[n][2 * i];
+			partitions[n][2 * i] = partitions[n][2 * (filt_len - 1 - i)];
+			partitions[n][2 * (filt_len - 1 - i)] = val;
+		}
+	}
+
+	delete[] proto;
+
+	return true;
+}
+
+void Resampler::releaseFilters()
+{
+	if (partitions) {
+		for (size_t i = 0; i < p; i++)
+			free(partitions[i]);
+	}
+
+	free(partitions);
+	partitions = NULL;
 }
 
-#ifndef __OPTIMIZE__
 static bool check_vec_len(int in_len, int out_len, int p, int q)
 {
 	if (in_len % q) {
@@ -126,24 +158,31 @@ static bool check_vec_len(int in_len, int out_len, int p, int q)
 
 	return true;
 }
-#endif
+
+void Resampler::computePath()
+{
+	for (int i = 0; i < MAX_OUTPUT_LEN; i++) {
+		in_index[i] = (q * i) / p;
+		out_path[i] = (q * i) % p;
+	}
+}
 
 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];
-		path = out_path[i];
+		n = in_index[i]; 
+		path = out_path[i]; 
 
 		convolve_real(in, in_len,
-			      reinterpret_cast<float *>(partitions[path]),
-			      filt_len, &out[2 * i], out_len - i,
-			      n, 1);
+			      partitions[path], filt_len,
+			      &out[2 * i], out_len - i,
+			      n, 1, 1, 0);
 	}
 
 	return out_len;
@@ -151,18 +190,14 @@ int Resampler::rotate(const float *in, size_t in_len, float *out, size_t out_len
 
 bool Resampler::init(float bw)
 {
-	if (p == 0 || q == 0 || filt_len == 0) return false;
-
 	/* Filterbank filter internals */
-	initFilters(bw);
+	if (!initFilters(bw))
+		return false;
 
 	/* Precompute filterbank paths */
-	int i = 0;
-	for (auto &index : in_index)
-		index = (q * i++) / p;
-	i = 0;
-	for (auto &path : out_path)
-		path = (q * i++) % p;
+	in_index = new size_t[MAX_OUTPUT_LEN];
+	out_path = new size_t[MAX_OUTPUT_LEN];
+	computePath();
 
 	return true;
 }
@@ -173,7 +208,7 @@ size_t Resampler::len()
 }
 
 Resampler::Resampler(size_t p, size_t q, size_t filt_len)
-	: in_index(MAX_OUTPUT_LEN), out_path(MAX_OUTPUT_LEN), partitions(p)
+	: in_index(NULL), out_path(NULL), partitions(NULL)
 {
 	this->p = p;
 	this->q = q;
@@ -182,6 +217,8 @@ Resampler::Resampler(size_t p, size_t q, size_t filt_len)
 
 Resampler::~Resampler()
 {
-	for (auto &part : partitions)
-		free(part);
+	releaseFilters();
+
+	delete in_index;
+	delete out_path;
 }

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,30 +11,31 @@
  * 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_
 #define _RESAMPLER_H_
 
-#include <vector>
-#include <complex>
-
 class Resampler {
 public:
 	/* Constructor for rational sample rate conversion
 	 *   @param p numerator of resampling ratio
 	 *   @param q denominator of resampling ratio
-	 *   @param filt_len length of each polyphase subfilter
+	 *   @param filt_len length of each polyphase subfilter 
 	 */
 	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.
@@ -56,7 +55,7 @@ public:
 	int rotate(const float *in, size_t in_len, float *out, size_t out_len);
 
 	/* Get filter length
-	 *   @return number of taps in each filter partition
+	 *   @return number of taps in each filter partition 
 	 */
 	size_t len();
 
@@ -64,11 +63,14 @@ private:
 	size_t p;
 	size_t q;
 	size_t filt_len;
-	std::vector<size_t> in_index;
-	std::vector<size_t> out_path;
-	std::vector<std::complex<float> *> partitions;
+	size_t *in_index;
+	size_t *out_path;
 
-	void initFilters(float bw);
+	float **partitions;
+
+	bool initFilters(float bw);
+	void releaseFilters();
+	void computePath();
 };
 
 #endif /* _RESAMPLER_H_ */

Transceiver52M/Synthesis.cpp

@@ -1,11 +1,9 @@
 /*
  * Polyphase synthesis filter
- *
+ * 
  * 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
@@ -26,13 +24,13 @@
 #include <assert.h>
 #include <string.h>
 #include <cstdio>
-#include <iostream>
 
+#include "Logger.h"
 #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,
@@ -76,7 +74,7 @@ bool Synthesis::resetBuffer(size_t chan)
 	return true;
 }
 
-/*
+/* 
  * Implementation based on material found in:
  *
  * "harris, fred, Multirate Signal Processing, Upper Saddle River, NJ,
@@ -94,8 +92,8 @@ bool Synthesis::rotate(float *out, size_t len)
 
 	cxvec_fft(fftHandle);
 
-	/*
-	 * Convolve through filterbank while applying and saving sample history
+	/* 
+	 * Convolve through filterbank while applying and saving sample history 
 	 */
 	for (size_t i = 0; i < m; i++) {
 		memcpy(&hInputs[i][2 * -hLen], hist[i], hSize);
@@ -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 */
@@ -85,34 +85,32 @@ struct TransceiverState {
   /* 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];
+  /* Pseudorandom bit sequence */
+  PRBS9 mPrbs;
 };
 
 /** The Transceiver class, responsible for physical layer of basestation */
 class Transceiver {
 public:
-  /** Transceiver constructor
-      @param cfg VTY populated config
+  /** Transceiver constructor 
+      @param wBasePort base port number of UDP sockets
+      @param TRXAddress IP address of the TRX manager, as a string
+      @param wSPS number of samples per GSM symbol
       @param wTransmitLatency initial setting of transmit latency
       @param radioInterface associated radioInterface object
   */
-  Transceiver(const struct trx_cfg *cfg,
+  Transceiver(int wBasePort,
+              const char *TRXAddress,
+              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 +123,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,31 +145,21 @@ 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:
-struct ctrl_msg {
-  char data[101];
-  ctrl_msg() {};
-};
+  int mBasePort;
+  std::string mAddr;
 
-struct ctrl_sock_state {
-  osmo_fd conn_bfd;
-  std::deque<ctrl_msg> txmsgqueue;
-  ctrl_sock_state() {
-      conn_bfd.fd =  -1;
-  }
-  ~ctrl_sock_state() {
-      if(conn_bfd.fd >= 0) {
-          close(conn_bfd.fd);
-          conn_bfd.fd = -1;
-          osmo_fd_unregister(&conn_bfd);
-      }
-  }
-};
-
-  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
@@ -179,17 +167,20 @@ 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
   GSM::Time mLatencyUpdateTime;           ///< last time latency was updated
-  GSM::Time mTransmitDeadlineClock;       ///< deadline for pushing bursts into transmit FIFO
+  GSM::Time mTransmitDeadlineClock;       ///< deadline for pushing bursts into transmit FIFO 
   GSM::Time mLastClockUpdateTime;         ///< last time clock update was sent up to core
 
   RadioInterface *mRadioInterface;	  ///< associated radioInterface object
   double txFullScale;                     ///< full scale input to radio
   double rxFullScale;                     ///< full scale output to radio
 
+  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);
@@ -201,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);
@@ -210,17 +203,14 @@ 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
   double mTxFreq;                      ///< the transmit frequency
   double mRxFreq;                      ///< the receive frequency
@@ -229,48 +219,63 @@ 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.
 *
@@ -29,16 +27,17 @@
 	Compilation Flags
 
 	SWLOOPBACK	compile for software loopback testing
-*/
+*/ 
 
 
 #include <stdint.h>
 #include <string.h>
 #include <stdlib.h>
-#include "Logger.h"
 #include "Threads.h"
 #include "USRPDevice.h"
 
+#include <Logger.h>
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -60,18 +59,14 @@ const dboardConfigType dboardConfig = TXA_RXB;
 
 const double USRPDevice::masterClockRate = 52.0e6;
 
-USRPDevice::USRPDevice(size_t tx_sps, size_t rx_sps, InterfaceType iface,
-		       size_t chan_num, double lo_offset,
-		       const std::vector<std::string>& tx_paths,
-		       const std::vector<std::string>& rx_paths):
-		RadioDevice(tx_sps, rx_sps, iface, chan_num, lo_offset, tx_paths, rx_paths)
+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
@@ -79,14 +74,14 @@ USRPDevice::USRPDevice(size_t tx_sps, size_t rx_sps, InterfaceType iface,
    * 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;
 
-#ifdef SWLOOPBACK
+#ifdef SWLOOPBACK 
   samplePeriod = 1.0e6/actualSampleRate;
   loopbackBufferSize = 0;
   gettimeofday(&lastReadTime,NULL);
@@ -98,32 +93,34 @@ int USRPDevice::open(const std::string &, int, bool)
 {
   writeLock.unlock();
 
-  LOGC(DDEV, INFO) << "opening USRP device..";
-#ifndef SWLOOPBACK
+  LOG(INFO) << "opening USRP device..";
+#ifndef SWLOOPBACK 
   string rbf = "std_inband.rbf";
-  //string rbf = "inband_1rxhb_1tx.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(
@@ -133,22 +130,22 @@ int USRPDevice::open(const std::string &, int, bool)
   }
 
   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
 
   switch (dboardConfig) {
@@ -176,21 +173,23 @@ int USRPDevice::open(const std::string &, int, bool)
   m_dbTx = m_uTx->selected_subdev(txSubdevSpec);
   m_dbRx = m_uRx->selected_subdev(rxSubdevSpec);
 
+  samplesRead = 0;
+  samplesWritten = 0;
   started = false;
-
+  
   return NORMAL;
 }
 
 
 
-bool USRPDevice::start()
+bool USRPDevice::start() 
 {
-  LOGC(DDEV, INFO) << "starting USRP...";
-#ifndef SWLOOPBACK
-  if (!m_uRx) return false;
+  LOG(INFO) << "starting USRP...";
+#ifndef SWLOOPBACK 
+  if (!m_uRx && !skipRx) return false;
   if (!m_uTx) return false;
-
-  m_uRx->stop();
+  
+  if (!skipRx) m_uRx->stop();
   m_uTx->stop();
 
   writeLock.lock();
@@ -205,8 +204,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;
@@ -219,8 +218,11 @@ bool USRPDevice::start()
   hi32Timestamp = 0;
   isAligned = false;
 
-
+ 
+  if (!skipRx) 
   started = (m_uRx->start() && m_uTx->start());
+  else
+  started = m_uTx->start();
   return started;
 #else
   gettimeofday(&lastReadTime,NULL);
@@ -228,14 +230,14 @@ bool USRPDevice::start()
 #endif
 }
 
-bool USRPDevice::stop()
+bool USRPDevice::stop() 
 {
-#ifndef SWLOOPBACK
+#ifndef SWLOOPBACK 
   if (!m_uRx) return false;
   if (!m_uTx) return false;
-
+  
   delete[] currData;
-
+  
   started = !(m_uRx->stop() && m_uTx->stop());
   return !started;
 #else
@@ -243,10 +245,20 @@ 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();
-}
+} 
 
 double USRPDevice::minRxGain()
 {
@@ -256,32 +268,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;
   }
 
@@ -293,104 +304,38 @@ 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;
+  return dB;
 }
 
-double USRPDevice::setPowerAttenuation(int atten, size_t chan) {
-      double rfGain;
-      rfGain = setTxGain(m_dbTx->gain_max() - atten, chan);
-      return m_dbTx->gain_max() - rfGain;
-}
-double USRPDevice::getPowerAttenuation(size_t chan) {
-      return m_dbTx->gain_max() - getTxGain(chan);
-}
-
-int USRPDevice::getNominalTxPower(size_t chan)
-{
-	/* TODO: return value based on some experimentally generated table depending on
-	 * band/arfcn, which is known here thanks to TXTUNE
-	 */
-	return 23;
-}
-
-bool USRPDevice::setRxAntenna(const std::string &ant, size_t chan)
-{
-	if (chan >= rx_paths.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
-		return false;
-	}
-	LOGC(DDEV, 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;
-		return "";
-	}
-	LOGC(DDEV, 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;
-		return false;
-	}
-	LOGC(DDEV, 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;
-		return "";
-	}
-	LOGC(DDEV, 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
+#ifndef SWLOOPBACK 
   if (!m_uRx)
     return 0;
 
   short *buf = bufs[0];
 
   timestamp += timestampOffset;
-
+  
   if (timestamp + len < timeStart) {
     memset(buf,0,len*2*sizeof(short));
     return len;
   }
 
-  *underrun = false;
-
+  if (underrun) *underrun = false;
+ 
   uint32_t readBuf[2000];
-
+ 
   while (1) {
     //guestimate USB read size
     int readLen=0;
@@ -400,21 +345,21 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
       readLen = 512 * ((int) ceil((float) numSamplesNeeded/126.0));
       if (readLen > 8000) readLen= (8000/512)*512;
     }
-
+    
     // 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;
@@ -426,26 +371,24 @@ 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;
       while (cursorStart*2 > currDataSize) {
 	cursorStart -= currDataSize/2;
@@ -458,25 +401,25 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
       else {
 	memcpy(data+cursorStart*2,tmpBuf+2,payloadSz);
       }
-      if (pktTimestamp + payloadSz/2/sizeof(short) > timeEnd)
+      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;
 
+    }	
+  }     
+ 
   // copy desired data to buf
   unsigned bufStart = dataStart+(timestamp-timeStart);
-  if (bufStart + len < currDataSize/2) {
-    LOGC(DDEV, DEBUG) << "bufStart: " << bufStart;
+  if (bufStart + len < currDataSize/2) { 
+    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));
@@ -486,21 +429,21 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
   timeStart = timestamp + len;
 
   return len;
-
+  
 #else
   if (loopbackBufferSize < 2) return 0;
   int numSamples = 0;
   struct timeval currTime;
   gettimeofday(&currTime,NULL);
-  double timeElapsed = (currTime.tv_sec - lastReadTime.tv_sec)*1.0e6 +
+  double timeElapsed = (currTime.tv_sec - lastReadTime.tv_sec)*1.0e6 + 
     (currTime.tv_usec - lastReadTime.tv_usec);
   if (timeElapsed < samplePeriod) {return 0;}
   int numSamplesToRead = (int) floor(timeElapsed/samplePeriod);
   if (numSamplesToRead < len) return 0;
-
+  
   if (numSamplesToRead > len) numSamplesToRead = len;
   if (numSamplesToRead > loopbackBufferSize/2) {
-    firstRead =false;
+    firstRead =false; 
     numSamplesToRead = loopbackBufferSize/2;
   }
   memcpy(buf,loopbackBuffer,sizeof(short)*2*numSamplesToRead);
@@ -517,17 +460,19 @@ 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();
 
-#ifndef SWLOOPBACK
+#ifndef SWLOOPBACK 
   if (!m_uTx)
     return 0;
 
@@ -565,34 +510,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)
+bool USRPDevice::updateAlignment(TIMESTAMP timestamp) 
 {
-  return writeSamplesControl(bufs, len, underrun, timestamp, false);
-}
-
-bool USRPDevice::updateAlignment(TIMESTAMP timestamp)
-{
-#ifndef SWLOOPBACK
+#ifndef SWLOOPBACK 
   short data[] = {0x00,0x02,0x00,0x00};
   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;
   }
@@ -602,25 +543,25 @@ bool USRPDevice::updateAlignment(TIMESTAMP timestamp)
 #endif
 }
 
-#ifndef SWLOOPBACK
+#ifndef SWLOOPBACK 
 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;
@@ -633,19 +574,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;
@@ -660,21 +601,7 @@ bool USRPDevice::setRxFreq(double wFreq) { return true;};
 #endif
 
 RadioDevice *RadioDevice::make(size_t tx_sps, size_t rx_sps,
-			       InterfaceType iface, size_t chans, double lo_offset,
-			       const std::vector<std::string>& tx_paths,
-			       const std::vector<std::string>& rx_paths)
+			       size_t chans, double)
 {
-	if (tx_sps != rx_sps) {
-		LOGC(DDEV, ERROR) << "USRP1 requires tx_sps == rx_sps";
-		return NULL;
-	}
-	if (chans != 1) {
-		LOGC(DDEV, ERROR) << "USRP1 supports only 1 channel";
-		return NULL;
-	}
-	if (lo_offset != 0.0) {
-		LOGC(DDEV, ERROR) << "USRP1 doesn't support lo_offset";
-		return NULL;
-	}
-	return new USRPDevice(tx_sps, rx_sps, iface, chans, lo_offset, tx_paths, rx_paths);
+	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,21 +82,11 @@ 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
+#ifdef SWLOOPBACK 
   short loopbackBuffer[1000000];
   int loopbackBufferSize;
-  double samplePeriod;
+  double samplePeriod; 
 
   struct timeval startTime;
   struct timeval lastReadTime;
@@ -104,9 +96,7 @@ private:
  public:
 
   /** Object constructor */
-  USRPDevice(size_t tx_sps, size_t rx_sps, InterfaceType iface, size_t chan_num, double lo_offset,
-		const std::vector<std::string>& tx_paths,
-		const std::vector<std::string>& rx_paths);
+  USRPDevice(size_t sps);
 
   /** Instantiate the USRP */
   int open(const std::string &, int, bool);
@@ -117,6 +107,9 @@ private:
   /** Stop the USRP */
   bool stop();
 
+  /** Set priority not supported */
+  void setPriority(float prio = 0.5) { }
+
   enum TxWindowType getWindowType() { return TX_WINDOW_USRP1; }
 
   /**
@@ -126,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);
@@ -174,35 +170,23 @@ 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);
-
-  /** sets the RX path to use, returns true if successful and false otherwise */
-  bool setRxAntenna(const std::string &ant, size_t chan = 0);
-
-  /* return the used RX path */
-  std::string getRxAntenna(size_t chan = 0);
-
-  /** sets the RX path to use, returns true if successful and false otherwise */
-  bool setTxAntenna(const std::string &ant, size_t chan = 0);
-
-  /* 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 minimum Rx Gain **/
+  double minTxGain(void);
 
   /** 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; }
+
 };
 
 #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>
@@ -26,9 +28,6 @@
 void neon_convert_ps_si16_4n(short *, const float *, const float *, int);
 void neon_convert_si16_ps_4n(float *, const short *, int);
 
-void convert_init(void) {
-}
-
 /* 4*N 16-bit signed integer conversion with remainder */
 static void neon_convert_si16_ps(float *out,
 				 const short *in,
@@ -55,6 +54,7 @@ static void neon_convert_ps_si16(short *out,
 	for (int i = 0; i < len % 4; i++)
 		out[start + i] = (short) (in[start + i] * (*scale));
 }
+#endif
 
 void convert_float_short(short *out, const float *in, float scale, int len)
 {

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

@@ -1,9 +1,7 @@
 /*
- * NEON complex multiplication
+ * 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

@@ -1,20 +1,18 @@
 /*
- * Fast Fourier transform
+ * Fast Fourier transform 
  *
  * 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
  * (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.
@@ -34,9 +32,9 @@ struct fft_hdl {
 	fftwf_plan fft_plan;
 };
 
-/*! \brief Initialize FFT backend
+/*! \brief Initialize FFT backend 
  *  \param[in] reverse FFT direction
- *  \param[in] m FFT length
+ *  \param[in] m FFT length 
  *  \param[in] istride input stride count
  *  \param[in] ostride output stride count
  *  \param[in] in input buffer (FFTW aligned)
@@ -94,7 +92,7 @@ void fft_free(void *ptr)
 	free(ptr);
 }
 
-/*! \brief Free FFT backend resources
+/*! \brief Free FFT backend resources 
  */
 void free_fft(struct fft_hdl *hdl)
 {
@@ -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,19 +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

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
-
-noinst_LTLIBRARIES = libdevice_common.la
-
-libdevice_common_la_SOURCES = \
-	smpl_buf.cpp

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,242 +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(size_t tx_sps, size_t rx_sps, InterfaceType iface, size_t chan_num, double lo_offset,
-		  const std::vector<std::string> &tx_paths, const std::vector<std::string> &rx_paths);
-	virtual ~IPCDevice() override;
-
-	/** Instantiate the IPC */
-	virtual int open(const std::string &args, int ref, bool swap_channels) override;
-
-	/** Start the IPC */
-	virtual bool start() override;
-
-	/** Stop the IPC */
-	virtual bool stop() override;
-
-	/* FIXME: any != USRP1 will do for now... */
-	enum TxWindowType getWindowType() override
-	{
-		return TX_WINDOW_LMS1;
-	}
-
-	/**
-	Read samples from the IPC.
-	@param buf preallocated buf to contain read result
-	@param len number of samples desired
-	@param overrun Set if read buffer has been overrun, e.g. data not being read fast enough
-	@param timestamp The timestamp of the first samples to be read
-	@param underrun Set if IPC does not have data to transmit, e.g. data not being sent fast enough
-	@return The number of samples actually read
-	*/
-	virtual int readSamples(std::vector<short *> &buf, int len, bool *overrun, TIMESTAMP timestamp = 0xffffffff,
-				bool *underrun = NULL) override;
-	/**
-	Write samples to the IPC.
-	@param buf Contains the data to be written.
-	@param len number of samples to write.
-	@param underrun Set if IPC does not have data to transmit, e.g. data not being sent fast enough
-	@param timestamp The timestamp of the first sample of the data buffer.
-	@return The number of samples actually written
-	*/
-	virtual int writeSamples(std::vector<short *> &bufs, int len, bool *underrun,
-				 TIMESTAMP timestamp = 0xffffffff) override;
-
-	/** Update the alignment between the read and write timestamps */
-	virtual bool updateAlignment(TIMESTAMP timestamp) override;
-
-	/** Set the transmitter frequency */
-	virtual bool setTxFreq(double wFreq, size_t chan = 0) override;
-
-	/** Set the receiver frequency */
-	virtual bool setRxFreq(double wFreq, size_t chan = 0) override;
-
-	/** Returns the starting write Timestamp*/
-	virtual TIMESTAMP initialWriteTimestamp(void) override;
-
-	/** Returns the starting read Timestamp*/
-	virtual TIMESTAMP initialReadTimestamp(void) override;
-
-	/** returns the full-scale transmit amplitude **/
-	virtual double fullScaleInputValue() override
-	{
-		return (double)SHRT_MAX * current_info_cnf.iq_scaling_val_rx;
-	}
-
-	/** returns the full-scale receive amplitude **/
-	virtual double fullScaleOutputValue() override
-	{
-		return (double)SHRT_MAX * current_info_cnf.iq_scaling_val_tx;
-	}
-
-	/** sets the receive chan gain, returns the gain setting **/
-	virtual double setRxGain(double dB, size_t chan = 0) override;
-
-	/** get the current receive gain */
-	virtual double getRxGain(size_t chan = 0) override
-	{
-		return rx_gains[chan];
-	}
-
-	/** return maximum Rx Gain **/
-	virtual double maxRxGain(void) override;
-
-	/** return minimum Rx Gain **/
-	virtual double minRxGain(void) override;
-
-	/* FIXME: return rx_gains[chan] ? receive factor from IPC Driver? */
-	double rssiOffset(size_t chan) { return 0.0f; };
-
-	double setPowerAttenuation(int atten, size_t chan) override;
-	double getPowerAttenuation(size_t chan = 0) override;
-
-	virtual int getNominalTxPower(size_t chan = 0) override;
-
-	/** sets the RX path to use, returns true if successful and false otherwise */
-	virtual bool setRxAntenna(const std::string &ant, size_t chan = 0) override;
-
-	/* return the used RX path */
-	virtual std::string getRxAntenna(size_t chan = 0) override;
-
-	/** sets the RX path to use, returns true if successful and false otherwise */
-	virtual bool setTxAntenna(const std::string &ant, size_t chan = 0) override;
-
-	/* return the used RX path */
-	virtual std::string getTxAntenna(size_t chan = 0) override;
-
-	/** return whether user drives synchronization of Tx/Rx of USRP */
-	virtual bool requiresRadioAlign() override;
-
-	/** return whether user drives synchronization of Tx/Rx of USRP */
-	virtual GSM::Time minLatency() override;
-
-	/** 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,43 +0,0 @@
-include $(top_srcdir)/Makefile.common
-
-AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/../common
-AM_CFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS)
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS)
-AM_LDFLAGS = -lpthread -lrt
-
-noinst_HEADERS = IPCDevice.h shm.h ipc_shm.h ipc_chan.h ipc_sock.h
-
-if DEVICE_UHD
-noinst_HEADERS += ../uhd/UHDDevice.h uhdwrap.h ipc-driver-test.h
-endif
-
-noinst_LTLIBRARIES = libdevice.la
-
-libdevice_la_SOURCES = IPCDevice.cpp shm.c ipc_shm.c ipc_chan.c ipc_sock.c
-libdevice_la_LIBADD = $(top_builddir)/Transceiver52M/device/common/libdevice_common.la
-libdevice_la_CXXFLAGS = $(AM_CXXFLAGS) -DIPCMAGIC
-
-#work around distclean issue on older autotools vers:
-#a direct build of ../uhd/UHDDevice.cpp tries to clean
-#../uhd/.dep/UHDDevice.Plo twice and fails
-uhddev_ipc.cpp:
-	echo "#include \"../uhd/UHDDevice.cpp\"" >$@
-CLEANFILES= uhddev_ipc.cpp
-BUILT_SOURCES = uhddev_ipc.cpp
-
-if DEVICE_UHD
-
-bin_PROGRAMS = ipc-driver-test
-#ipc_driver_test_SHORTNAME = drvt
-ipc_driver_test_SOURCES = ipc-driver-test.c uhdwrap.cpp ipc_shm.c ipc_chan.c ipc_sock.c uhddev_ipc.cpp
-ipc_driver_test_LDADD = \
-        shm.lo \
-	$(top_builddir)/Transceiver52M/device/common/libdevice_common.la \
-	$(COMMON_LA)
-	$(LIBOSMOCORE_LIBS) \
-	$(NULL)
-ipc_driver_test_CXXFLAGS = $(AM_CXXFLAGS) $(UHD_CFLAGS)
-ipc_driver_test_CPPFLAGS  = $(AM_CPPFLAGS) $(UHD_CFLAGS)
-ipc_driver_test_CFLAGS  = $(AM_CFLAGS) $(UHD_CFLAGS)
-ipc_driver_test_LDFLAGS  = $(AM_LDFLAGS) $(UHD_LIBS)
-endif

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

@@ -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;
-
-	close(bfd->fd);
-	bfd->fd = -1;
-	osmo_fd_unregister(bfd);
-
-	/* re-enable the generation of ACCEPT for new connections */
-	osmo_fd_read_enable(&state->listen_bfd);
-
-	/* flush the queue */
-	while (!llist_empty(&state->upqueue)) {
-		struct msgb *msg = msgb_dequeue(&state->upqueue);
-		msgb_free(msg);
-	}
-}
-
-int ipc_sock_read(struct osmo_fd *bfd)
-{
-	struct ipc_sock_state *state = (struct ipc_sock_state *)bfd->data;
-	struct ipc_sk_if *ipc_prim;
-	struct msgb *msg;
-	int rc;
-
-	msg = msgb_alloc(sizeof(*ipc_prim) + 1000, "ipc_sock_rx");
-	if (!msg)
-		return -ENOMEM;
-
-	ipc_prim = (struct ipc_sk_if *)msg->tail;
-
-	rc = recv(bfd->fd, msg->tail, msgb_tailroom(msg), 0);
-	if (rc == 0)
-		goto close;
-
-	if (rc < 0) {
-		if (errno == EAGAIN) {
-			msgb_free(msg);
-			return 0;
-		}
-		goto close;
-	}
-
-	if (rc < (int)sizeof(*ipc_prim)) {
-		LOGP(DDEV, LOGL_ERROR,
-		     "Received %d bytes on Unix Socket, but primitive size "
-		     "is %zu, discarding\n",
-		     rc, sizeof(*ipc_prim));
-		msgb_free(msg);
-		return 0;
-	}
-
-	rc = ipc_rx(ipc_prim->msg_type, ipc_prim);
-
-	/* as we always synchronously process the message in IPC_rx() and
-	 * its callbacks, we can free the message here. */
-	msgb_free(msg);
-
-	return rc;
-
-close:
-	msgb_free(msg);
-	ipc_sock_close(state);
-	return -1;
-}
-
-static int ipc_sock_write(struct osmo_fd *bfd)
-{
-	struct ipc_sock_state *state = (struct ipc_sock_state *)bfd->data;
-	int rc;
-
-	while (!llist_empty(&state->upqueue)) {
-		struct msgb *msg, *msg2;
-		struct ipc_sk_if *ipc_prim;
-
-		/* peek at the beginning of the queue */
-		msg = llist_entry(state->upqueue.next, struct msgb, list);
-		ipc_prim = (struct ipc_sk_if *)msg->data;
-
-		osmo_fd_write_disable(bfd);
-
-		/* bug hunter 8-): maybe someone forgot msgb_put(...) ? */
-		if (!msgb_length(msg)) {
-			LOGP(DDEV, LOGL_ERROR,
-			     "message type (%d) with ZERO "
-			     "bytes!\n",
-			     ipc_prim->msg_type);
-			goto dontsend;
-		}
-
-		/* try to send it over the socket */
-		rc = write(bfd->fd, msgb_data(msg), msgb_length(msg));
-		if (rc == 0)
-			goto close;
-		if (rc < 0) {
-			if (errno == EAGAIN) {
-				osmo_fd_write_enable(bfd);
-				break;
-			}
-			goto close;
-		}
-
-	dontsend:
-		/* _after_ we send it, we can deueue */
-		msg2 = msgb_dequeue(&state->upqueue);
-		assert(msg == msg2);
-		msgb_free(msg);
-	}
-	return 0;
-
-close:
-	ipc_sock_close(state);
-	return -1;
-}
-
-static int ipc_sock_cb(struct osmo_fd *bfd, unsigned int flags)
-{
-	int rc = 0;
-
-	if (flags & OSMO_FD_READ)
-		rc = ipc_sock_read(bfd);
-	if (rc < 0)
-		return rc;
-
-	if (flags & OSMO_FD_WRITE)
-		rc = ipc_sock_write(bfd);
-
-	return rc;
-}
-
-/* accept connection coming from IPC */
-int ipc_sock_accept(struct osmo_fd *bfd, unsigned int flags)
-{
-	struct ipc_sock_state *state = (struct ipc_sock_state *)bfd->data;
-	struct osmo_fd *conn_bfd = &state->conn_bfd;
-	struct sockaddr_un un_addr;
-	socklen_t len;
-	int rc;
-
-	len = sizeof(un_addr);
-	rc = accept(bfd->fd, (struct sockaddr *)&un_addr, &len);
-	if (rc < 0) {
-		LOGP(DDEV, LOGL_ERROR, "Failed to accept a new connection\n");
-		return -1;
-	}
-
-	if (conn_bfd->fd >= 0) {
-		LOGP(DDEV, LOGL_NOTICE,
-		     "ip clent connects but we already have "
-		     "another active connection ?!?\n");
-		/* We already have one IPC connected, this is all we support */
-		osmo_fd_read_disable(&state->listen_bfd);
-		close(rc);
-		return 0;
-	}
-
-	osmo_fd_setup(conn_bfd, rc, OSMO_FD_READ, ipc_sock_cb, state, 0);
-
-	if (osmo_fd_register(conn_bfd) != 0) {
-		LOGP(DDEV, LOGL_ERROR,
-		     "Failed to register new connection "
-		     "fd\n");
-		close(conn_bfd->fd);
-		conn_bfd->fd = -1;
-		return -1;
-	}
-
-	LOGP(DDEV, LOGL_NOTICE, "Unix socket connected to external osmo-trx\n");
-
-	return 0;
-}