Wed Aug 18 22:34:18 2010

Asterisk developer's documentation


chan_usbradio.c File Reference

Channel driver for CM108 USB Cards with Radio Interface. More...

#include "asterisk.h"
#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include <string.h>
#include <unistd.h>
#include <sys/io.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <sys/time.h>
#include <stdlib.h>
#include <errno.h>
#include <usb.h>
#include <alsa/asoundlib.h>
#include "./xpmr/xpmr.h"
#include <soundcard.h>
#include "asterisk/lock.h"
#include "asterisk/frame.h"
#include "asterisk/logger.h"
#include "asterisk/callerid.h"
#include "asterisk/channel.h"
#include "asterisk/module.h"
#include "asterisk/options.h"
#include "asterisk/pbx.h"
#include "asterisk/config.h"
#include "asterisk/cli.h"
#include "asterisk/utils.h"
#include "asterisk/causes.h"
#include "asterisk/endian.h"
#include "asterisk/stringfields.h"
#include "asterisk/abstract_jb.h"
#include "asterisk/musiconhold.h"
#include "asterisk/dsp.h"
#include "./xpmr/xpmr.c"

Go to the source code of this file.

Data Structures

struct  chan_usbradio_pvt
struct  sound

Defines

#define BOOST_MAX   40
#define BOOST_SCALE   (1<<9)
#define C108_HID_INTERFACE   3
#define C108_PRODUCT_ID   0x000c
#define C108_VENDOR_ID   0x0d8c
#define CHAN_USBRADIO   1
#define config1   "usbradio_tune_%s.conf"
#define DEBUG_CAP_RX_OUT   0
#define DEBUG_CAP_TX_OUT   0
#define DEBUG_CAPTURES   1
#define DEBUG_FILETEST   0
#define DEBUG_USBRADIO   0
#define DELIMCHR   ','
#define DEV_DSP   "/dev/dsp"
#define EEPROM_CS_ADDR   62
#define EEPROM_END_ADDR   63
#define EEPROM_MAGIC   34329
#define EEPROM_MAGIC_ADDR   6
#define EEPROM_PHYSICAL_LEN   64
#define EEPROM_RXCTCSSADJ   13
#define EEPROM_RXMIXERSET   8
#define EEPROM_RXSQUELCHADJ   16
#define EEPROM_RXVOICEADJ   11
#define EEPROM_START_ADDR   6
#define EEPROM_TEST_ADDR   EEPROM_END_ADDR
#define EEPROM_TXCTCSSADJ   15
#define EEPROM_TXMIXASET   9
#define EEPROM_TXMIXBSET   10
#define FRAGS   ( ( (6 * 5) << 16 ) | 0xc )
#define FRAME_SIZE   160
#define HID_REPORT_GET   0x01
#define HID_REPORT_SET   0x09
#define HID_RT_INPUT   0x01
#define HID_RT_OUTPUT   0x02
#define M_BOOL(tag, dst)   M_F(tag, (dst) = ast_true(__val) )
#define M_END(x)   x;
#define M_F(tag, f)   if (!strcasecmp((__s), tag)) { f; } else
#define M_START(var, val)   char *__s = var; char *__val = val;
#define M_STR(tag, dst)   M_F(tag, ast_copy_string(dst, __val, sizeof(dst)))
#define M_UINT(tag, dst)   M_F(tag, (dst) = strtoul(__val, NULL, 0) )
#define MIXER_PARAM_MIC_BOOST   "Auto Gain Control"
#define MIXER_PARAM_MIC_CAPTURE_SW   "Mic Capture Switch"
#define MIXER_PARAM_MIC_CAPTURE_VOL   "Mic Capture Volume"
#define MIXER_PARAM_MIC_PLAYBACK_SW   "Mic Playback Switch"
#define MIXER_PARAM_MIC_PLAYBACK_VOL   "Mic Playback Volume"
#define MIXER_PARAM_SPKR_PLAYBACK_SW   "Speaker Playback Switch"
#define MIXER_PARAM_SPKR_PLAYBACK_VOL   "Speaker Playback Volume"
#define NEW_ASTERISK
#define O_CLOSE   0x444
#define pd(x)   {printf(#x" = %d\n",x);}
#define pf(x)   {printf(#x" = %f\n",x);}
#define pp(x)   {printf(#x" = %p\n",x);}
#define ps(x)   {printf(#x" = %s\n",x);}
#define QUEUE_SIZE   2
#define QUOTECHR   34
#define READERR_THRESHOLD   50
#define RX_CAP_OUT_FILE   "/tmp/rx_cap_out.pcm"
#define RX_CAP_RAW_FILE   "/tmp/rx_cap_in.pcm"
#define RX_CAP_TRACE_FILE   "/tmp/rx_trace.pcm"
#define TEXT_SIZE   256
#define traceusb1(a)
#define traceusb2(a)
#define TX_CAP_OUT_FILE   "/tmp/tx_cap_out.pcm"
#define TX_CAP_RAW_FILE   "/tmp/tx_cap_in.pcm"
#define TX_CAP_TRACE_FILE   "/tmp/tx_trace.pcm"
#define WARN_frag   4
#define WARN_speed   2
#define WARN_used_blocks   1

Enumerations

enum  { RX_AUDIO_NONE, RX_AUDIO_SPEAKER, RX_AUDIO_FLAT }
enum  {
  CD_IGNORE, CD_XPMR_NOISE, CD_XPMR_VOX, CD_HID,
  CD_HID_INVERT
}
enum  { SD_IGNORE, SD_HID, SD_HID_INVERT, SD_XPMR }
enum  { RX_KEY_CARRIER, RX_KEY_CARRIER_CODE }
enum  {
  TX_OUT_OFF, TX_OUT_VOICE, TX_OUT_LSD, TX_OUT_COMPOSITE,
  TX_OUT_AUX
}
enum  { TOC_NONE, TOC_PHASE, TOC_NOTONE }

Functions

static void __reg_module (void)
static void __unreg_module (void)
static int amixer_max (int devnum, char *param)
static int console_key (int fd, int argc, char *argv[])
static int console_unkey (int fd, int argc, char *argv[])
static struct chan_usbradio_pvtfind_desc (char *dev)
static struct chan_usbradio_pvtfind_desc_usb (char *devstr)
static unsigned short get_eeprom (struct usb_dev_handle *handle, unsigned short *buf)
static char * handle_console_key (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char * handle_console_unkey (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char * handle_radio_active (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char * handle_radio_debug (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char * handle_radio_debug_off (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char * handle_radio_tune (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char * handle_set_xdebug (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static struct usb_device * hid_device_init (char *desired_device)
static int hid_device_mklist (void)
static void hid_get_inputs (struct usb_dev_handle *handle, unsigned char *inputs)
static void hid_set_outputs (struct usb_dev_handle *handle, unsigned char *outputs)
static int hidhdwconfig (struct chan_usbradio_pvt *o)
static void * hidthread (void *arg)
static void kickptt (struct chan_usbradio_pvt *o)
static int load_module (void)
static void mixer_write (struct chan_usbradio_pvt *o)
static int mult_calc (int value)
static void mult_set (struct chan_usbradio_pvt *o)
static void pmrdump (struct chan_usbradio_pvt *o)
static void put_eeprom (struct usb_dev_handle *handle, unsigned short *buf)
static int radio_active (int fd, int argc, char *argv[])
static int radio_set_debug (int fd, int argc, char *argv[])
static int radio_set_debug_off (int fd, int argc, char *argv[])
static int radio_set_xpmr_debug (int fd, int argc, char *argv[])
static int radio_tune (int fd, int argc, char *argv[])
static unsigned short read_eeprom (struct usb_dev_handle *handle, int addr)
static char * res2cli (int r)
static void ring (struct chan_usbradio_pvt *o, int x)
static int set_txctcss_level (struct chan_usbradio_pvt *o)
static int setamixer (int devnum, char *param, int v1, int v2)
static int setformat (struct chan_usbradio_pvt *o, int mode)
static int soundcard_writeframe (struct chan_usbradio_pvt *o, short *data)
static struct chan_usbradio_pvtstore_config (struct ast_config *cfg, char *ctg)
static void store_rxcdtype (struct chan_usbradio_pvt *o, char *s)
static void store_rxctcssadj (struct chan_usbradio_pvt *o, char *s)
static void store_rxdemod (struct chan_usbradio_pvt *o, char *s)
static void store_rxgain (struct chan_usbradio_pvt *o, char *s)
static void store_rxsdtype (struct chan_usbradio_pvt *o, char *s)
static void store_rxvoiceadj (struct chan_usbradio_pvt *o, char *s)
static void store_txmixa (struct chan_usbradio_pvt *o, char *s)
static void store_txmixb (struct chan_usbradio_pvt *o, char *s)
static void store_txtoctype (struct chan_usbradio_pvt *o, char *s)
static void tune_rxctcss (int fd, struct chan_usbradio_pvt *o)
static void tune_rxinput (int fd, struct chan_usbradio_pvt *o)
static void tune_rxvoice (int fd, struct chan_usbradio_pvt *o)
static void tune_txoutput (struct chan_usbradio_pvt *o, int value, int fd)
static void tune_write (struct chan_usbradio_pvt *o)
static int unload_module (void)
static int usb_get_usbdev (char *devstr)
static int usb_list_check (char *devstr)
static int usbradio_answer (struct ast_channel *c)
static int usbradio_call (struct ast_channel *c, char *dest, int timeout)
static int usbradio_digit_begin (struct ast_channel *c, char digit)
static int usbradio_digit_end (struct ast_channel *c, char digit, unsigned int duration)
static int usbradio_fixup (struct ast_channel *oldchan, struct ast_channel *newchan)
static int usbradio_hangup (struct ast_channel *c)
static int usbradio_indicate (struct ast_channel *chan, int cond, const void *data, size_t datalen)
static struct ast_channelusbradio_new (struct chan_usbradio_pvt *o, char *ext, char *ctx, int state)
static struct ast_frameusbradio_read (struct ast_channel *chan)
static struct ast_channelusbradio_request (const char *type, int format, void *data, int *cause)
static int usbradio_text (struct ast_channel *c, const char *text)
static int usbradio_write (struct ast_channel *chan, struct ast_frame *f)
static int used_blocks (struct chan_usbradio_pvt *o)
static void write_eeprom (struct usb_dev_handle *handle, int addr, unsigned short data)
static int xpmr_config (struct chan_usbradio_pvt *o)

Variables

static struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "usb Console Channel Driver" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "a9c98e5d177805051735cb5b0b16b0a0" , .load = load_module, .unload = unload_module, }
static char active_usage []
static struct ast_module_infoast_module_info = &__mod_info
static struct ast_cli_entry cli_usbradio []
static const char * config = "usbradio.conf"
static struct ast_jb_conf default_jbconf
static FILE * frxcapraw = NULL
static FILE * frxcaptrace = NULL
static FILE * frxoutraw = NULL
static FILE * ftxcapraw = NULL
static FILE * ftxcaptrace = NULL
static FILE * ftxoutraw = NULL
static struct ast_jb_conf global_jbconf
static char key_usage []
static char radio_tune_usage []
static char tdesc [] = "USB (CM108) Radio Channel Driver"
static char unkey_usage []
static char * usb_device_list = NULL
static int usb_device_list_size = 0
static char * usbradio_active
static int usbradio_debug
static struct chan_usbradio_pvt usbradio_default
static struct ast_channel_tech usbradio_tech


Detailed Description

Channel driver for CM108 USB Cards with Radio Interface.

Author:
Jim Dixon <jim@lambdatel.com>

Steve Henke <w9sh@arrl.net>

See also

Definition in file chan_usbradio.c.


Define Documentation

#define BOOST_MAX   40

Definition at line 457 of file chan_usbradio.c.

#define BOOST_SCALE   (1<<9)

Definition at line 456 of file chan_usbradio.c.

#define C108_HID_INTERFACE   3

Definition at line 167 of file chan_usbradio.c.

Referenced by hid_get_inputs(), hid_set_outputs(), and hidthread().

#define C108_PRODUCT_ID   0x000c

Definition at line 166 of file chan_usbradio.c.

Referenced by hid_device_init(), and hid_device_mklist().

#define C108_VENDOR_ID   0x0d8c

Definition at line 165 of file chan_usbradio.c.

Referenced by hid_device_init(), and hid_device_mklist().

#define CHAN_USBRADIO   1

Definition at line 83 of file chan_usbradio.c.

#define config1   "usbradio_tune_%s.conf"

Definition at line 357 of file chan_usbradio.c.

Referenced by store_config().

#define DEBUG_CAP_RX_OUT   0

Definition at line 86 of file chan_usbradio.c.

#define DEBUG_CAP_TX_OUT   0

Definition at line 87 of file chan_usbradio.c.

#define DEBUG_CAPTURES   1

Definition at line 85 of file chan_usbradio.c.

#define DEBUG_FILETEST   0

Definition at line 88 of file chan_usbradio.c.

#define DEBUG_USBRADIO   0

Definition at line 84 of file chan_usbradio.c.

#define DELIMCHR   ','

Definition at line 106 of file chan_usbradio.c.

Referenced by finddelim().

#define DEV_DSP   "/dev/dsp"

Definition at line 353 of file chan_usbradio.c.

#define EEPROM_CS_ADDR   62

Definition at line 181 of file chan_usbradio.c.

Referenced by put_eeprom().

#define EEPROM_END_ADDR   63

Definition at line 176 of file chan_usbradio.c.

Referenced by get_eeprom().

#define EEPROM_MAGIC   34329

Definition at line 180 of file chan_usbradio.c.

Referenced by hidthread(), and put_eeprom().

#define EEPROM_MAGIC_ADDR   6

Definition at line 179 of file chan_usbradio.c.

Referenced by hidthread(), and put_eeprom().

#define EEPROM_PHYSICAL_LEN   64

Definition at line 177 of file chan_usbradio.c.

#define EEPROM_RXCTCSSADJ   13

Definition at line 186 of file chan_usbradio.c.

Referenced by hidthread(), and tune_write().

#define EEPROM_RXMIXERSET   8

Definition at line 182 of file chan_usbradio.c.

Referenced by hidthread(), and tune_write().

#define EEPROM_RXSQUELCHADJ   16

Definition at line 188 of file chan_usbradio.c.

Referenced by hidthread(), and tune_write().

#define EEPROM_RXVOICEADJ   11

Definition at line 185 of file chan_usbradio.c.

Referenced by hidthread(), and tune_write().

#define EEPROM_START_ADDR   6

Definition at line 175 of file chan_usbradio.c.

Referenced by get_eeprom(), and put_eeprom().

#define EEPROM_TEST_ADDR   EEPROM_END_ADDR

Definition at line 178 of file chan_usbradio.c.

#define EEPROM_TXCTCSSADJ   15

Definition at line 187 of file chan_usbradio.c.

Referenced by hidthread(), and tune_write().

#define EEPROM_TXMIXASET   9

Definition at line 183 of file chan_usbradio.c.

Referenced by hidthread(), and tune_write().

#define EEPROM_TXMIXBSET   10

Definition at line 184 of file chan_usbradio.c.

Referenced by hidthread(), and tune_write().

#define FRAGS   ( ( (6 * 5) << 16 ) | 0xc )

Definition at line 336 of file chan_usbradio.c.

#define FRAME_SIZE   160

Definition at line 330 of file chan_usbradio.c.

#define HID_REPORT_GET   0x01

Definition at line 169 of file chan_usbradio.c.

Referenced by hid_get_inputs().

#define HID_REPORT_SET   0x09

Definition at line 170 of file chan_usbradio.c.

Referenced by hid_set_outputs().

#define HID_RT_INPUT   0x01

Definition at line 172 of file chan_usbradio.c.

Referenced by hid_get_inputs().

#define HID_RT_OUTPUT   0x02

Definition at line 173 of file chan_usbradio.c.

Referenced by hid_set_outputs().

#define M_BOOL ( tag,
dst   )     M_F(tag, (dst) = ast_true(__val) )

Definition at line 296 of file chan_usbradio.c.

Referenced by store_config().

#define M_END (  )     x;

Definition at line 294 of file chan_usbradio.c.

Referenced by store_config().

#define M_F ( tag,
f   )     if (!strcasecmp((__s), tag)) { f; } else

Definition at line 295 of file chan_usbradio.c.

Referenced by store_config().

#define M_START ( var,
val   )     char *__s = var; char *__val = val;

Definition at line 292 of file chan_usbradio.c.

Referenced by store_config().

#define M_STR ( tag,
dst   )     M_F(tag, ast_copy_string(dst, __val, sizeof(dst)))

Definition at line 298 of file chan_usbradio.c.

Referenced by store_config().

#define M_UINT ( tag,
dst   )     M_F(tag, (dst) = strtoul(__val, NULL, 0) )

Definition at line 297 of file chan_usbradio.c.

Referenced by store_config().

#define MIXER_PARAM_MIC_BOOST   "Auto Gain Control"

Definition at line 102 of file chan_usbradio.c.

Referenced by mixer_write(), and tune_rxinput().

#define MIXER_PARAM_MIC_CAPTURE_SW   "Mic Capture Switch"

Definition at line 100 of file chan_usbradio.c.

Referenced by mixer_write().

#define MIXER_PARAM_MIC_CAPTURE_VOL   "Mic Capture Volume"

Definition at line 101 of file chan_usbradio.c.

Referenced by mixer_write(), store_config(), and tune_rxinput().

#define MIXER_PARAM_MIC_PLAYBACK_SW   "Mic Playback Switch"

Definition at line 98 of file chan_usbradio.c.

Referenced by mixer_write().

#define MIXER_PARAM_MIC_PLAYBACK_VOL   "Mic Playback Volume"

Definition at line 99 of file chan_usbradio.c.

Referenced by mixer_write().

#define MIXER_PARAM_SPKR_PLAYBACK_SW   "Speaker Playback Switch"

Definition at line 103 of file chan_usbradio.c.

Referenced by mixer_write().

#define MIXER_PARAM_SPKR_PLAYBACK_VOL   "Speaker Playback Volume"

Definition at line 104 of file chan_usbradio.c.

Referenced by mixer_write(), and store_config().

#define NEW_ASTERISK

Definition at line 1 of file chan_usbradio.c.

#define O_CLOSE   0x444

Definition at line 348 of file chan_usbradio.c.

#define pd (  )     {printf(#x" = %d\n",x);}

Definition at line 3157 of file chan_usbradio.c.

Referenced by pcm_write(), playtones_alloc(), and pmrdump().

#define pf (  )     {printf(#x" = %f\n",x);}

Definition at line 3160 of file chan_usbradio.c.

Referenced by pmrdump().

#define pp (  )     {printf(#x" = %p\n",x);}

Definition at line 3158 of file chan_usbradio.c.

Referenced by dahdi_setoption(), get_unaligned_uint16(), get_unaligned_uint32(), put_unaligned_uint16(), put_unaligned_uint32(), sms_readfile(), st_get_mode(), st_get_refresher(), and st_get_se().

#define ps (  )     {printf(#x" = %s\n",x);}

Definition at line 3159 of file chan_usbradio.c.

Referenced by ast_register_indication(), ast_unregister_indication(), ind_load_module(), playtones_alloc(), playtones_generator(), playtones_release(), and pmrdump().

#define QUEUE_SIZE   2

Definition at line 331 of file chan_usbradio.c.

#define QUOTECHR   34

Definition at line 107 of file chan_usbradio.c.

Referenced by finddelim().

#define READERR_THRESHOLD   50

Definition at line 109 of file chan_usbradio.c.

Referenced by usbradio_read().

#define RX_CAP_OUT_FILE   "/tmp/rx_cap_out.pcm"

Definition at line 92 of file chan_usbradio.c.

Referenced by usbradio_read().

#define RX_CAP_RAW_FILE   "/tmp/rx_cap_in.pcm"

Definition at line 90 of file chan_usbradio.c.

Referenced by radio_tune().

#define RX_CAP_TRACE_FILE   "/tmp/rx_trace.pcm"

Definition at line 91 of file chan_usbradio.c.

Referenced by radio_tune().

#define TEXT_SIZE   256

Definition at line 343 of file chan_usbradio.c.

#define traceusb1 (  ) 

Definition at line 120 of file chan_usbradio.c.

Referenced by hidthread(), and store_config().

#define traceusb2 (  ) 

Definition at line 126 of file chan_usbradio.c.

Referenced by usbradio_read(), and usbradio_write().

#define TX_CAP_OUT_FILE   "/tmp/tx_cap_out.pcm"

Definition at line 96 of file chan_usbradio.c.

Referenced by usbradio_read().

#define TX_CAP_RAW_FILE   "/tmp/tx_cap_in.pcm"

Definition at line 94 of file chan_usbradio.c.

Referenced by radio_tune().

#define TX_CAP_TRACE_FILE   "/tmp/tx_trace.pcm"

Definition at line 95 of file chan_usbradio.c.

Referenced by radio_tune().

#define WARN_frag   4

Definition at line 446 of file chan_usbradio.c.

#define WARN_speed   2

Definition at line 445 of file chan_usbradio.c.

#define WARN_used_blocks   1

Definition at line 444 of file chan_usbradio.c.


Enumeration Type Documentation

anonymous enum

Enumerator:
RX_AUDIO_NONE 
RX_AUDIO_SPEAKER 
RX_AUDIO_FLAT 

Definition at line 370 of file chan_usbradio.c.

anonymous enum

Enumerator:
CD_IGNORE 
CD_XPMR_NOISE 
CD_XPMR_VOX 
CD_HID 
CD_HID_INVERT 

Definition at line 371 of file chan_usbradio.c.

anonymous enum

Enumerator:
SD_IGNORE 
SD_HID 
SD_HID_INVERT 
SD_XPMR 

Definition at line 372 of file chan_usbradio.c.

00372 {SD_IGNORE,SD_HID,SD_HID_INVERT,SD_XPMR};                 // no,external,externalinvert,software

anonymous enum

Enumerator:
RX_KEY_CARRIER 
RX_KEY_CARRIER_CODE 

Definition at line 373 of file chan_usbradio.c.

anonymous enum

Enumerator:
TX_OUT_OFF 
TX_OUT_VOICE 
TX_OUT_LSD 
TX_OUT_COMPOSITE 
TX_OUT_AUX 

Definition at line 374 of file chan_usbradio.c.

anonymous enum

Enumerator:
TOC_NONE 
TOC_PHASE 
TOC_NOTONE 

Definition at line 375 of file chan_usbradio.c.


Function Documentation

static void __reg_module ( void   )  [static]

Definition at line 4029 of file chan_usbradio.c.

static void __unreg_module ( void   )  [static]

Definition at line 4029 of file chan_usbradio.c.

static int amixer_max ( int  devnum,
char *  param 
) [static]

Definition at line 707 of file chan_usbradio.c.

References id, str, and type.

Referenced by store_config().

00708 {
00709 int   rv,type;
00710 char  str[100];
00711 snd_hctl_t *hctl;
00712 snd_ctl_elem_id_t *id;
00713 snd_hctl_elem_t *elem;
00714 snd_ctl_elem_info_t *info;
00715 
00716    sprintf(str,"hw:%d",devnum);
00717    if (snd_hctl_open(&hctl, str, 0)) return(-1);
00718    snd_hctl_load(hctl);
00719    snd_ctl_elem_id_alloca(&id);
00720    snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
00721    snd_ctl_elem_id_set_name(id, param);  
00722    elem = snd_hctl_find_elem(hctl, id);
00723    if (!elem)
00724    {
00725       snd_hctl_close(hctl);
00726       return(-1);
00727    }
00728    snd_ctl_elem_info_alloca(&info);
00729    snd_hctl_elem_info(elem,info);
00730    type = snd_ctl_elem_info_get_type(info);
00731    rv = 0;
00732    switch(type)
00733    {
00734        case SND_CTL_ELEM_TYPE_INTEGER:
00735       rv = snd_ctl_elem_info_get_max(info);
00736       break;
00737        case SND_CTL_ELEM_TYPE_BOOLEAN:
00738       rv = 1;
00739       break;
00740    }
00741    snd_hctl_close(hctl);
00742    return(rv);
00743 }

static int console_key ( int  fd,
int  argc,
char *  argv[] 
) [static]

Definition at line 2265 of file chan_usbradio.c.

References find_desc(), RESULT_SHOWUSAGE, RESULT_SUCCESS, chan_usbradio_pvt::txtestkey, and usbradio_active.

Referenced by handle_console_key().

02266 {
02267    struct chan_usbradio_pvt *o = find_desc(usbradio_active);
02268 
02269    if (argc != 2)
02270       return RESULT_SHOWUSAGE; 
02271    o->txtestkey = 1;
02272    return RESULT_SUCCESS;
02273 }

static int console_unkey ( int  fd,
int  argc,
char *  argv[] 
) [static]

Definition at line 2276 of file chan_usbradio.c.

References find_desc(), RESULT_SHOWUSAGE, RESULT_SUCCESS, chan_usbradio_pvt::txtestkey, and usbradio_active.

Referenced by handle_console_unkey().

02277 {
02278    struct chan_usbradio_pvt *o = find_desc(usbradio_active);
02279 
02280    if (argc != 2)
02281       return RESULT_SHOWUSAGE;
02282    o->txtestkey = 0;
02283    return RESULT_SUCCESS;
02284 }

static struct chan_usbradio_pvt* find_desc ( char *  dev  )  [static]

Definition at line 1260 of file chan_usbradio.c.

References ast_log(), LOG_WARNING, chan_usbradio_pvt::name, chan_usbradio_pvt::next, and usbradio_default.

01261 {
01262    struct chan_usbradio_pvt *o = NULL;
01263 
01264    if (!dev)
01265       ast_log(LOG_WARNING, "null dev\n");
01266 
01267    for (o = usbradio_default.next; o && o->name && dev && strcmp(o->name, dev) != 0; o = o->next);
01268    if (!o)
01269    {
01270       ast_log(LOG_WARNING, "could not find <%s>\n", dev ? dev : "--no-device--");
01271       pthread_exit(0);
01272    }
01273 
01274    return o;
01275 }

static struct chan_usbradio_pvt* find_desc_usb ( char *  devstr  )  [static]

Definition at line 1277 of file chan_usbradio.c.

References ast_log(), chan_usbradio_pvt::devstr, LOG_WARNING, chan_usbradio_pvt::next, and usbradio_default.

Referenced by store_config().

01278 {
01279    struct chan_usbradio_pvt *o = NULL;
01280 
01281    if (!devstr)
01282       ast_log(LOG_WARNING, "null dev\n");
01283 
01284    for (o = usbradio_default.next; o && devstr && strcmp(o->devstr, devstr) != 0; o = o->next);
01285 
01286    return o;
01287 }

static unsigned short get_eeprom ( struct usb_dev_handle *  handle,
unsigned short *  buf 
) [static]

Definition at line 848 of file chan_usbradio.c.

References EEPROM_END_ADDR, EEPROM_START_ADDR, and read_eeprom().

Referenced by hidthread().

00850 {
00851 int   i;
00852 unsigned short cs;
00853 
00854    cs = 0xffff;
00855    for(i = EEPROM_START_ADDR; i < EEPROM_END_ADDR; i++)
00856    {
00857       cs += buf[i] = read_eeprom(handle,i);
00858    }
00859    return(cs);
00860 }

static char* handle_console_key ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
) [static]

Definition at line 3816 of file chan_usbradio.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, ast_cli_entry::command, console_key(), ast_cli_args::fd, res2cli(), and ast_cli_entry::usage.

03818 {
03819         switch (cmd) {
03820         case CLI_INIT:
03821                 e->command = "radio key";
03822                 e->usage = key_usage;
03823                 return NULL;
03824         case CLI_GENERATE:
03825                 return NULL;
03826    }
03827    return res2cli(console_key(a->fd,a->argc,a->argv));
03828 }

static char* handle_console_unkey ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
) [static]

Definition at line 3830 of file chan_usbradio.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, ast_cli_entry::command, console_unkey(), ast_cli_args::fd, res2cli(), and ast_cli_entry::usage.

03832 {
03833         switch (cmd) {
03834         case CLI_INIT:
03835                 e->command = "radio unkey";
03836                 e->usage = unkey_usage;
03837                 return NULL;
03838         case CLI_GENERATE:
03839                 return NULL;
03840    }
03841    return res2cli(console_unkey(a->fd,a->argc,a->argv));
03842 }

static char* handle_radio_active ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
) [static]

Definition at line 3886 of file chan_usbradio.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, ast_cli_entry::command, ast_cli_args::fd, radio_active(), res2cli(), and ast_cli_entry::usage.

03888 {
03889         switch (cmd) {
03890         case CLI_INIT:
03891                 e->command = "radio active";
03892                 e->usage = active_usage;
03893                 return NULL;
03894         case CLI_GENERATE:
03895                 return NULL;
03896    }
03897    return res2cli(radio_active(a->fd,a->argc,a->argv));
03898 }

static char* handle_radio_debug ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
) [static]

Definition at line 3858 of file chan_usbradio.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, ast_cli_entry::command, ast_cli_args::fd, radio_set_debug(), res2cli(), and ast_cli_entry::usage.

03860 {
03861         switch (cmd) {
03862         case CLI_INIT:
03863                 e->command = "radio debug";
03864                 e->usage = radio_tune_usage;
03865                 return NULL;
03866         case CLI_GENERATE:
03867                 return NULL;
03868    }
03869    return res2cli(radio_set_debug(a->fd,a->argc,a->argv));
03870 }

static char* handle_radio_debug_off ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
) [static]

Definition at line 3872 of file chan_usbradio.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, ast_cli_entry::command, ast_cli_args::fd, radio_set_debug_off(), res2cli(), and ast_cli_entry::usage.

03874 {
03875         switch (cmd) {
03876         case CLI_INIT:
03877                 e->command = "radio debug off";
03878                 e->usage = radio_tune_usage;
03879                 return NULL;
03880         case CLI_GENERATE:
03881                 return NULL;
03882    }
03883    return res2cli(radio_set_debug_off(a->fd,a->argc,a->argv));
03884 }

static char* handle_radio_tune ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
) [static]

Definition at line 3844 of file chan_usbradio.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, ast_cli_entry::command, ast_cli_args::fd, radio_tune(), res2cli(), and ast_cli_entry::usage.

03846 {
03847         switch (cmd) {
03848         case CLI_INIT:
03849                 e->command = "radio tune";
03850                 e->usage = radio_tune_usage;
03851                 return NULL;
03852         case CLI_GENERATE:
03853                 return NULL;
03854    }
03855    return res2cli(radio_tune(a->fd,a->argc,a->argv));
03856 }

static char* handle_set_xdebug ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
) [static]

Definition at line 3900 of file chan_usbradio.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, ast_cli_entry::command, ast_cli_args::fd, radio_set_xpmr_debug(), res2cli(), and ast_cli_entry::usage.

03902 {
03903         switch (cmd) {
03904         case CLI_INIT:
03905                 e->command = "radio set xdebug";
03906                 e->usage = active_usage;
03907                 return NULL;
03908         case CLI_GENERATE:
03909                 return NULL;
03910    }
03911    return res2cli(radio_set_xpmr_debug(a->fd,a->argc,a->argv));
03912 }

static struct usb_device* hid_device_init ( char *  desired_device  )  [static]

Definition at line 878 of file chan_usbradio.c.

References C108_PRODUCT_ID, C108_VENDOR_ID, and str.

Referenced by hidthread().

00879 {
00880     struct usb_bus *usb_bus;
00881     struct usb_device *dev;
00882     char devstr[200],str[200],desdev[200],*cp;
00883     int i;
00884     FILE *fp;
00885 
00886     usb_init();
00887     usb_find_busses();
00888     usb_find_devices();
00889     for (usb_bus = usb_busses;
00890          usb_bus;
00891          usb_bus = usb_bus->next) {
00892         for (dev = usb_bus->devices;
00893              dev;
00894              dev = dev->next) {
00895             if ((dev->descriptor.idVendor
00896                   == C108_VENDOR_ID) &&
00897                 (dev->descriptor.idProduct
00898                   == C108_PRODUCT_ID))
00899       {
00900                         sprintf(devstr,"%s/%s", usb_bus->dirname,dev->filename);
00901          for(i = 0; i < 32; i++)
00902          {
00903             sprintf(str,"/proc/asound/card%d/usbbus",i);
00904             fp = fopen(str,"r");
00905             if (!fp) continue;
00906             if ((!fgets(desdev,sizeof(desdev) - 1,fp)) || (!desdev[0]))
00907             {
00908                fclose(fp);
00909                continue;
00910             }
00911             fclose(fp);
00912             if (desdev[strlen(desdev) - 1] == '\n')
00913                   desdev[strlen(desdev) -1 ] = 0;
00914             if (strcasecmp(desdev,devstr)) continue;
00915             if (i) sprintf(str,"/sys/class/sound/dsp%d/device",i);
00916             else strcpy(str,"/sys/class/sound/dsp/device");
00917             memset(desdev,0,sizeof(desdev));
00918             if (readlink(str,desdev,sizeof(desdev) - 1) == -1)
00919             {
00920                sprintf(str,"/sys/class/sound/controlC%d/device",i);
00921                memset(desdev,0,sizeof(desdev));
00922                if (readlink(str,desdev,sizeof(desdev) - 1) == -1) continue;
00923             }
00924             cp = strrchr(desdev,'/');
00925             if (cp) *cp = 0; else continue;
00926             cp = strrchr(desdev,'/');
00927             if (!cp) continue;
00928             cp++;
00929             break;
00930          }
00931          if (i >= 32) continue;
00932                         if (!strcmp(cp,desired_device)) return dev;
00933       }
00934 
00935         }
00936     }
00937     return NULL;
00938 }

static int hid_device_mklist ( void   )  [static]

Definition at line 940 of file chan_usbradio.c.

References ast_malloc, ast_realloc, C108_PRODUCT_ID, C108_VENDOR_ID, and str.

Referenced by load_module().

00941 {
00942     struct usb_bus *usb_bus;
00943     struct usb_device *dev;
00944     char devstr[200],str[200],desdev[200],*cp;
00945     int i;
00946     FILE *fp;
00947 
00948     usb_device_list = ast_malloc(2);
00949     if (!usb_device_list) return -1;
00950     memset(usb_device_list,0,2);
00951 
00952     usb_init();
00953     usb_find_busses();
00954     usb_find_devices();
00955     for (usb_bus = usb_busses;
00956          usb_bus;
00957          usb_bus = usb_bus->next) {
00958         for (dev = usb_bus->devices;
00959              dev;
00960              dev = dev->next) {
00961             if ((dev->descriptor.idVendor
00962                   == C108_VENDOR_ID) &&
00963                 (dev->descriptor.idProduct
00964                   == C108_PRODUCT_ID))
00965       {
00966                         sprintf(devstr,"%s/%s", usb_bus->dirname,dev->filename);
00967          for(i = 0;i < 32; i++)
00968          {
00969             sprintf(str,"/proc/asound/card%d/usbbus",i);
00970             fp = fopen(str,"r");
00971             if (!fp) continue;
00972             if ((!fgets(desdev,sizeof(desdev) - 1,fp)) || (!desdev[0]))
00973             {
00974                fclose(fp);
00975                continue;
00976             }
00977             fclose(fp);
00978             if (desdev[strlen(desdev) - 1] == '\n')
00979                   desdev[strlen(desdev) -1 ] = 0;
00980             if (strcasecmp(desdev,devstr)) continue;
00981             if (i) sprintf(str,"/sys/class/sound/dsp%d/device",i);
00982             else strcpy(str,"/sys/class/sound/dsp/device");
00983             memset(desdev,0,sizeof(desdev));
00984             if (readlink(str,desdev,sizeof(desdev) - 1) == -1)
00985             {
00986                sprintf(str,"/sys/class/sound/controlC%d/device",i);
00987                memset(desdev,0,sizeof(desdev));
00988                if (readlink(str,desdev,sizeof(desdev) - 1) == -1) continue;
00989             }
00990             cp = strrchr(desdev,'/');
00991             if (cp) *cp = 0; else continue;
00992             cp = strrchr(desdev,'/');
00993             if (!cp) continue;
00994             cp++;
00995             break;
00996          }
00997          if (i >= 32) return -1;
00998          usb_device_list = ast_realloc(usb_device_list,
00999             usb_device_list_size + 2 +
01000                strlen(cp));
01001          if (!usb_device_list) return -1;
01002          usb_device_list_size += strlen(cp) + 2;
01003          i = 0;
01004          while(usb_device_list[i])
01005          {
01006             i += strlen(usb_device_list + i) + 1;
01007          }
01008          strcat(usb_device_list + i,cp);
01009          usb_device_list[strlen(cp) + i + 1] = 0;
01010       }
01011 
01012         }
01013     }
01014     return 0;
01015 }

static void hid_get_inputs ( struct usb_dev_handle *  handle,
unsigned char *  inputs 
) [static]

Definition at line 809 of file chan_usbradio.c.

References C108_HID_INTERFACE, HID_REPORT_GET, and HID_RT_INPUT.

Referenced by hidthread(), and read_eeprom().

00811 {
00812    usleep(1500);
00813    usb_control_msg(handle,
00814          USB_ENDPOINT_IN + USB_TYPE_CLASS + USB_RECIP_INTERFACE,
00815          HID_REPORT_GET,
00816          0 + (HID_RT_INPUT << 8),
00817          C108_HID_INTERFACE,
00818          (char*)inputs, 4, 5000);
00819 }

static void hid_set_outputs ( struct usb_dev_handle *  handle,
unsigned char *  outputs 
) [static]

Definition at line 797 of file chan_usbradio.c.

References C108_HID_INTERFACE, HID_REPORT_SET, and HID_RT_OUTPUT.

Referenced by hidthread(), read_eeprom(), and write_eeprom().

00799 {
00800    usleep(1500);
00801    usb_control_msg(handle,
00802          USB_ENDPOINT_OUT + USB_TYPE_CLASS + USB_RECIP_INTERFACE,
00803          HID_REPORT_SET,
00804          0 + (HID_RT_OUTPUT << 8),
00805          C108_HID_INTERFACE,
00806          (char*)outputs, 4, 5000);
00807 }

static int hidhdwconfig ( struct chan_usbradio_pvt o  )  [static]

Definition at line 1061 of file chan_usbradio.c.

References chan_usbradio_pvt::hdwtype, chan_usbradio_pvt::hid_gpio_ctl, chan_usbradio_pvt::hid_gpio_ctl_loc, chan_usbradio_pvt::hid_gpio_loc, chan_usbradio_pvt::hid_io_cor, chan_usbradio_pvt::hid_io_cor_loc, chan_usbradio_pvt::hid_io_ctcss, chan_usbradio_pvt::hid_io_ctcss_loc, and chan_usbradio_pvt::hid_io_ptt.

Referenced by store_config().

01062 {
01063    if(o->hdwtype==1)   //sphusb
01064    {
01065       o->hid_gpio_ctl      =  0x08; /* set GPIO4 to output mode */
01066       o->hid_gpio_ctl_loc  =  2;    /* For CTL of GPIO */
01067       o->hid_io_cor     =  4; /* GPIO3 is COR */
01068       o->hid_io_cor_loc =  1; /* GPIO3 is COR */
01069       o->hid_io_ctcss      =  2;    /* GPIO 2 is External CTCSS */
01070       o->hid_io_ctcss_loc =  1;  /* is GPIO 2 */
01071       o->hid_io_ptt     =  8;    /* GPIO 4 is PTT */
01072       o->hid_gpio_loc   =  1;    /* For ALL GPIO */
01073    }
01074    else if(o->hdwtype==0)  //dudeusb
01075    {
01076       o->hid_gpio_ctl      =  0x0c; /* set GPIO 3 & 4 to output mode */
01077       o->hid_gpio_ctl_loc  =  2;    /* For CTL of GPIO */
01078       o->hid_io_cor     =  2; /* VOLD DN is COR */
01079       o->hid_io_cor_loc =  0; /* VOL DN COR */
01080       o->hid_io_ctcss      =  2;    /* GPIO 2 is External CTCSS */
01081       o->hid_io_ctcss_loc =  1;  /* is GPIO 2 */
01082       o->hid_io_ptt     =  4;    /* GPIO 3 is PTT */
01083       o->hid_gpio_loc   =  1;    /* For ALL GPIO */
01084    }
01085    else if(o->hdwtype==3)  // custom version
01086    {
01087       o->hid_gpio_ctl      =  0x0c; /* set GPIO 3 & 4 to output mode */
01088       o->hid_gpio_ctl_loc  =  2;    /* For CTL of GPIO */
01089       o->hid_io_cor     =  2; /* VOLD DN is COR */
01090       o->hid_io_cor_loc =  0; /* VOL DN COR */
01091       o->hid_io_ctcss      =  2;    /* GPIO 2 is External CTCSS */
01092       o->hid_io_ctcss_loc =  1;  /* is GPIO 2 */
01093       o->hid_io_ptt     =  4;    /* GPIO 3 is PTT */
01094       o->hid_gpio_loc   =  1;    /* For ALL GPIO */
01095    }
01096 
01097    return 0;
01098 }

static void* hidthread ( void *  arg  )  [static]

Definition at line 1113 of file chan_usbradio.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_select(), buf, C108_HID_INTERFACE, chan_usbradio_pvt::debuglevel, chan_usbradio_pvt::devstr, chan_usbradio_pvt::eeprom, EEPROM_MAGIC, EEPROM_MAGIC_ADDR, EEPROM_RXCTCSSADJ, EEPROM_RXMIXERSET, EEPROM_RXSQUELCHADJ, EEPROM_RXVOICEADJ, EEPROM_TXCTCSSADJ, EEPROM_TXMIXASET, EEPROM_TXMIXBSET, chan_usbradio_pvt::eepromctl, chan_usbradio_pvt::eepromlock, errno, get_eeprom(), hid_device_init(), hid_get_inputs(), chan_usbradio_pvt::hid_gpio_ctl, chan_usbradio_pvt::hid_gpio_ctl_loc, chan_usbradio_pvt::hid_gpio_loc, chan_usbradio_pvt::hid_io_cor, chan_usbradio_pvt::hid_io_cor_loc, chan_usbradio_pvt::hid_io_ptt, hid_set_outputs(), chan_usbradio_pvt::invertptt, chan_usbradio_pvt::lasthidtime, chan_usbradio_pvt::lasttx, LOG_ERROR, LOG_NOTICE, LOG_WARNING, chan_usbradio_pvt::name, chan_usbradio_pvt::pmrChan, chan_usbradio_pvt::pttkick, put_eeprom(), chan_usbradio_pvt::rxctcssadj, chan_usbradio_pvt::rxhidsq, chan_usbradio_pvt::rxmixerset, chan_usbradio_pvt::rxsquelchadj, chan_usbradio_pvt::rxvoiceadj, chan_usbradio_pvt::stophid, traceusb1, chan_usbradio_pvt::txctcssadj, chan_usbradio_pvt::txmixaset, chan_usbradio_pvt::txmixbset, and chan_usbradio_pvt::wanteeprom.

Referenced by usbradio_call().

01114 {
01115    unsigned char buf[4],bufsave[4],keyed;
01116    char lastrx, txtmp;
01117    int res;
01118    struct usb_device *usb_dev;
01119    struct usb_dev_handle *usb_handle;
01120    struct chan_usbradio_pvt *o = (struct chan_usbradio_pvt *) arg;
01121    struct timeval to;
01122    fd_set rfds;
01123 
01124    usb_dev = hid_device_init(o->devstr);
01125    if (usb_dev == NULL) {
01126       ast_log(LOG_ERROR,"USB HID device not found\n");
01127       pthread_exit(NULL);
01128    }
01129    usb_handle = usb_open(usb_dev);
01130    if (usb_handle == NULL) {
01131            ast_log(LOG_ERROR,"Not able to open USB device\n");
01132       pthread_exit(NULL);
01133    }
01134    if (usb_claim_interface(usb_handle,C108_HID_INTERFACE) < 0)
01135    {
01136        if (usb_detach_kernel_driver_np(usb_handle,C108_HID_INTERFACE) < 0) {
01137               ast_log(LOG_ERROR,"Not able to detach the USB device\n");
01138          pthread_exit(NULL);
01139       }
01140       if (usb_claim_interface(usb_handle,C108_HID_INTERFACE) < 0) {
01141               ast_log(LOG_ERROR,"Not able to claim the USB device\n");
01142          pthread_exit(NULL);
01143       }
01144    }
01145    memset(buf,0,sizeof(buf));
01146    buf[2] = o->hid_gpio_ctl;
01147    buf[1] = 0;
01148    hid_set_outputs(usb_handle,buf);
01149    memcpy(bufsave,buf,sizeof(buf));
01150    if (pipe(o->pttkick) == -1)
01151    {
01152        ast_log(LOG_ERROR,"Not able to create pipe\n");
01153       pthread_exit(NULL);
01154    }
01155    traceusb1(("hidthread: Starting normally on %s!!\n",o->name));
01156    lastrx = 0;
01157    // popen 
01158    while(!o->stophid)
01159    {
01160       to.tv_sec = 0;
01161       to.tv_usec = 50000;   // maw sph
01162 
01163       FD_ZERO(&rfds);
01164       FD_SET(o->pttkick[0],&rfds);
01165       /* ast_select emulates linux behaviour in terms of timeout handling */
01166       res = ast_select(o->pttkick[0] + 1, &rfds, NULL, NULL, &to);
01167       if (res < 0) {
01168          ast_log(LOG_WARNING, "select failed: %s\n", strerror(errno));
01169          usleep(10000);
01170          continue;
01171       }
01172       if (FD_ISSET(o->pttkick[0],&rfds))
01173       {
01174          char c;
01175 
01176          if (read(o->pttkick[0],&c,1) < 0) {
01177             ast_log(LOG_ERROR, "read() failed: %s\n", strerror(errno));
01178          }
01179       }
01180       if(o->wanteeprom)
01181       {
01182          ast_mutex_lock(&o->eepromlock);
01183          if (o->eepromctl == 1)  /* to read */
01184          {
01185             /* if CS okay */
01186             if (!get_eeprom(usb_handle,o->eeprom))
01187             {
01188                if (o->eeprom[EEPROM_MAGIC_ADDR] != EEPROM_MAGIC)
01189                {
01190                   ast_log(LOG_NOTICE,"UNSUCCESSFUL: EEPROM MAGIC NUMBER BAD on channel %s\n",o->name);
01191                }
01192                else
01193                {
01194                   o->rxmixerset = o->eeprom[EEPROM_RXMIXERSET];
01195                   o->txmixaset =    o->eeprom[EEPROM_TXMIXASET];
01196                   o->txmixbset = o->eeprom[EEPROM_TXMIXBSET];
01197                   memcpy(&o->rxvoiceadj,&o->eeprom[EEPROM_RXVOICEADJ],sizeof(float));
01198                   memcpy(&o->rxctcssadj,&o->eeprom[EEPROM_RXCTCSSADJ],sizeof(float));
01199                   o->txctcssadj = o->eeprom[EEPROM_TXCTCSSADJ];
01200                   o->rxsquelchadj = o->eeprom[EEPROM_RXSQUELCHADJ];
01201                   ast_log(LOG_NOTICE,"EEPROM Loaded on channel %s\n",o->name);
01202                }
01203             }
01204             else
01205             {
01206                ast_log(LOG_NOTICE,"USB Adapter has no EEPROM installed or Checksum BAD on channel %s\n",o->name);
01207             }
01208             hid_set_outputs(usb_handle,bufsave);
01209          } 
01210          if (o->eepromctl == 2) /* to write */
01211          {
01212             put_eeprom(usb_handle,o->eeprom);
01213             hid_set_outputs(usb_handle,bufsave);
01214             ast_log(LOG_NOTICE,"USB Parameters written to EEPROM on %s\n",o->name);
01215          }
01216          o->eepromctl = 0;
01217          ast_mutex_unlock(&o->eepromlock);
01218       }
01219       buf[o->hid_gpio_ctl_loc] = o->hid_gpio_ctl;
01220       hid_get_inputs(usb_handle,buf);
01221       keyed = !(buf[o->hid_io_cor_loc] & o->hid_io_cor);
01222       if (keyed != o->rxhidsq)
01223       {
01224          if(o->debuglevel)printf("chan_usbradio() hidthread: update rxhidsq = %d\n",keyed);
01225          o->rxhidsq=keyed;
01226       }
01227 
01228       /* if change in tx state as controlled by xpmr */
01229       txtmp=o->pmrChan->txPttOut;
01230             
01231       if (o->lasttx != txtmp)
01232       {
01233          o->pmrChan->txPttHid=o->lasttx = txtmp;
01234          if(o->debuglevel)printf("hidthread: tx set to %d\n",txtmp);
01235          buf[o->hid_gpio_loc] = 0;
01236          if (!o->invertptt)
01237          {
01238             if (txtmp) buf[o->hid_gpio_loc] = o->hid_io_ptt;
01239          }
01240          else
01241          {
01242             if (!txtmp) buf[o->hid_gpio_loc] = o->hid_io_ptt;
01243          }
01244          buf[o->hid_gpio_ctl_loc] = o->hid_gpio_ctl;
01245          memcpy(bufsave,buf,sizeof(buf));
01246          hid_set_outputs(usb_handle,buf);
01247       }
01248       time(&o->lasthidtime);
01249    }
01250    buf[o->hid_gpio_loc] = 0;
01251    if (o->invertptt) buf[o->hid_gpio_loc] = o->hid_io_ptt;
01252    buf[o->hid_gpio_ctl_loc] = o->hid_gpio_ctl;
01253    hid_set_outputs(usb_handle,buf);
01254    pthread_exit(0);
01255 }

static void kickptt ( struct chan_usbradio_pvt o  )  [static]

Definition at line 1101 of file chan_usbradio.c.

References ast_log(), errno, LOG_ERROR, and chan_usbradio_pvt::pttkick.

Referenced by usbradio_read().

01102 {
01103    char c = 0;
01104    //printf("kickptt  %i  %i  %i\n",o->txkeyed,o->txchankey,o->txtestkey);
01105    if (!o) return;
01106    if (!o->pttkick) return;
01107    if (write(o->pttkick[1],&c,1) < 0) {
01108       ast_log(LOG_ERROR, "write() failed: %s\n", strerror(errno));
01109    }
01110 }

static int load_module ( void   )  [static]

Definition at line 3934 of file chan_usbradio.c.

References ast_category_browse(), ast_channel_register(), ast_cli_register_multiple(), ast_config_destroy(), ast_config_load, ast_log(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SUCCESS, cli_usbradio, config, default_jbconf, find_desc(), global_jbconf, hid_device_mklist(), LOG_ERROR, LOG_NOTICE, store_config(), usb_list_check(), usbradio_active, and usbradio_tech.

03935 {
03936    struct ast_config *cfg = NULL;
03937    char *ctg = NULL;
03938 #ifdef   NEW_ASTERISK
03939    struct ast_flags zeroflag = {0};
03940 #endif
03941 
03942    if (hid_device_mklist()) {
03943       ast_log(LOG_NOTICE, "Unable to make hid list\n");
03944       return AST_MODULE_LOAD_DECLINE;
03945    }
03946 
03947    usb_list_check("");
03948 
03949    usbradio_active = NULL;
03950 
03951    /* Copy the default jb config over global_jbconf */
03952    memcpy(&global_jbconf, &default_jbconf, sizeof(struct ast_jb_conf));
03953 
03954    /* load config file */
03955 #ifdef   NEW_ASTERISK
03956    if (!(cfg = ast_config_load(config,zeroflag))) {
03957 #else
03958    if (!(cfg = ast_config_load(config))) {
03959 #endif
03960       ast_log(LOG_NOTICE, "Unable to load config %s\n", config);
03961       return AST_MODULE_LOAD_DECLINE;
03962    }
03963 
03964    do {
03965       store_config(cfg, ctg);
03966    } while ( (ctg = ast_category_browse(cfg, ctg)) != NULL);
03967 
03968    ast_config_destroy(cfg);
03969 
03970    if (find_desc(usbradio_active) == NULL) {
03971       ast_log(LOG_NOTICE, "radio active device %s not found\n", usbradio_active);
03972       /* XXX we could default to 'dsp' perhaps ? */
03973       /* XXX should cleanup allocated memory etc. */
03974       return AST_MODULE_LOAD_FAILURE;
03975    }
03976 
03977    if (ast_channel_register(&usbradio_tech)) {
03978       ast_log(LOG_ERROR, "Unable to register channel type 'usb'\n");
03979       return AST_MODULE_LOAD_FAILURE;
03980    }
03981 
03982    ast_cli_register_multiple(cli_usbradio, sizeof(cli_usbradio) / sizeof(struct ast_cli_entry));
03983 
03984    return AST_MODULE_LOAD_SUCCESS;
03985 }

static void mixer_write ( struct chan_usbradio_pvt o  )  [static]

Definition at line 3116 of file chan_usbradio.c.

References chan_usbradio_pvt::devicenum, chan_usbradio_pvt::micmax, MIXER_PARAM_MIC_BOOST, MIXER_PARAM_MIC_CAPTURE_SW, MIXER_PARAM_MIC_CAPTURE_VOL, MIXER_PARAM_MIC_PLAYBACK_SW, MIXER_PARAM_MIC_PLAYBACK_VOL, MIXER_PARAM_SPKR_PLAYBACK_SW, MIXER_PARAM_SPKR_PLAYBACK_VOL, chan_usbradio_pvt::rxboostset, chan_usbradio_pvt::rxmixerset, setamixer(), chan_usbradio_pvt::spkrmax, chan_usbradio_pvt::txmixaset, and chan_usbradio_pvt::txmixbset.

Referenced by radio_tune(), set_txctcss_level(), and store_config().

static int mult_calc ( int  value  )  [static]

Definition at line 3147 of file chan_usbradio.c.

Referenced by mult_set().

03148 {
03149    const int multx=M_Q8;
03150    int pot,mult;
03151 
03152    pot=((int)(value/4)*4)+2;
03153    mult = multx-( ( multx * (3-(value%4)) ) / (pot+2) );
03154    return(mult);
03155 }

static void mult_set ( struct chan_usbradio_pvt o  )  [static]

Definition at line 3132 of file chan_usbradio.c.

References mult_calc(), chan_usbradio_pvt::pmrChan, chan_usbradio_pvt::txmixaset, and chan_usbradio_pvt::txmixbset.

Referenced by radio_tune(), set_txctcss_level(), and store_config().

03133 {
03134 
03135    if(o->pmrChan->spsTxOutA) {
03136       o->pmrChan->spsTxOutA->outputGain = 
03137          mult_calc((o->txmixaset * 152) / 1000);
03138    }
03139    if(o->pmrChan->spsTxOutB){
03140       o->pmrChan->spsTxOutB->outputGain = 
03141          mult_calc((o->txmixbset * 152) / 1000);
03142    }
03143 }

static void pmrdump ( struct chan_usbradio_pvt o  )  [static]

Definition at line 3236 of file chan_usbradio.c.

References chan_usbradio_pvt::b, chan_usbradio_pvt::devicenum, chan_usbradio_pvt::devstr, chan_usbradio_pvt::micmax, chan_usbradio_pvt::numrxctcssfreqs, pd, pf, chan_usbradio_pvt::pmrChan, ps, chan_usbradio_pvt::rxboostset, chan_usbradio_pvt::rxcdtype, chan_usbradio_pvt::rxctcss, chan_usbradio_pvt::rxctcssadj, chan_usbradio_pvt::rxdemod, chan_usbradio_pvt::rxmixerset, chan_usbradio_pvt::rxpolarity, chan_usbradio_pvt::rxsdtype, chan_usbradio_pvt::rxsquelchadj, chan_usbradio_pvt::rxvoiceadj, chan_usbradio_pvt::spkrmax, chan_usbradio_pvt::txctcss, chan_usbradio_pvt::txctcssdefault, chan_usbradio_pvt::txctcssfreq, chan_usbradio_pvt::txmixa, chan_usbradio_pvt::txmixaset, chan_usbradio_pvt::txmixb, chan_usbradio_pvt::txmixbset, chan_usbradio_pvt::txpolarity, chan_usbradio_pvt::txprelim, and chan_usbradio_pvt::txtoctype.

Referenced by radio_tune().

03237 {
03238    t_pmr_chan *p;
03239    int i;
03240 
03241    p=o->pmrChan;
03242 
03243    printf("\nodump()\n");
03244 
03245    pd(o->devicenum);
03246    ps(o->devstr);
03247 
03248    pd(o->micmax);
03249    pd(o->spkrmax);
03250 
03251    pd(o->rxdemod);
03252    pd(o->rxcdtype);
03253    pd(o->rxsdtype);
03254    pd(o->txtoctype);
03255 
03256    pd(o->rxmixerset);
03257    pd(o->rxboostset);
03258 
03259    pf(o->rxvoiceadj);
03260    pf(o->rxctcssadj);
03261    pd(o->rxsquelchadj);
03262 
03263    ps(o->txctcssdefault);
03264    ps(o->txctcssfreq);
03265 
03266    pd(o->numrxctcssfreqs);
03267    if(o->numrxctcssfreqs>0)
03268    {
03269       for(i=0;i<o->numrxctcssfreqs;i++)
03270       {
03271          printf(" %i =  %s  %s\n",i,o->rxctcss[i],o->txctcss[i]); 
03272       }
03273    }
03274 
03275    pd(o->b.rxpolarity);
03276    pd(o->b.txpolarity);
03277 
03278    pd(o->txprelim);
03279    pd(o->txmixa);
03280    pd(o->txmixb);
03281    
03282    pd(o->txmixaset);
03283    pd(o->txmixbset);
03284    
03285    printf("\npmrdump()\n");
03286  
03287    pd(p->devicenum);
03288 
03289    printf("prxSquelchAdjust=%i\n",*(o->pmrChan->prxSquelchAdjust));
03290 
03291    pd(p->rxCarrierPoint);
03292    pd(p->rxCarrierHyst);
03293 
03294    pd(*p->prxVoiceAdjust);
03295    pd(*p->prxCtcssAdjust);
03296 
03297    pd(p->rxfreq);
03298    pd(p->txfreq);
03299 
03300    pd(p->rxCtcss->relax);
03301    //pf(p->rxCtcssFreq);   
03302    pd(p->numrxcodes);
03303    if(o->pmrChan->numrxcodes>0)
03304    {
03305       for(i=0;i<o->pmrChan->numrxcodes;i++)
03306       {
03307          printf(" %i = %s\n",i,o->pmrChan->pRxCode[i]); 
03308       }
03309    }
03310 
03311    pd(p->txTocType);
03312    ps(p->pTxCodeDefault);
03313    pd(p->txcodedefaultsmode);
03314    pd(p->numtxcodes);
03315    if(o->pmrChan->numtxcodes>0)
03316    {
03317       for(i=0;i<o->pmrChan->numtxcodes;i++)
03318       {                                       
03319          printf(" %i = %s\n",i,o->pmrChan->pTxCode[i]); 
03320       }
03321    }
03322 
03323    pd(p->b.rxpolarity);
03324    pd(p->b.txpolarity);
03325    pd(p->b.dcsrxpolarity);
03326    pd(p->b.dcstxpolarity);
03327    pd(p->b.lsdrxpolarity);
03328    pd(p->b.lsdtxpolarity);
03329 
03330    pd(p->txMixA);
03331    pd(p->txMixB);
03332     
03333    pd(p->rxDeEmpEnable);
03334    pd(p->rxCenterSlicerEnable);
03335    pd(p->rxCtcssDecodeEnable);
03336    pd(p->rxDcsDecodeEnable);
03337    pd(p->b.ctcssRxEnable);
03338    pd(p->b.dcsRxEnable);
03339    pd(p->b.lmrRxEnable);
03340    pd(p->b.dstRxEnable);
03341    pd(p->smode);
03342 
03343    pd(p->txHpfEnable);
03344    pd(p->txLimiterEnable);
03345    pd(p->txPreEmpEnable);
03346    pd(p->txLpfEnable);
03347 
03348    if(p->spsTxOutA)pd(p->spsTxOutA->outputGain);
03349    if(p->spsTxOutB)pd(p->spsTxOutB->outputGain);
03350    pd(p->txPttIn);
03351    pd(p->txPttOut);
03352 
03353    pd(p->tracetype);
03354 
03355    return;
03356 }

static void put_eeprom ( struct usb_dev_handle *  handle,
unsigned short *  buf 
) [static]

Definition at line 862 of file chan_usbradio.c.

References EEPROM_CS_ADDR, EEPROM_MAGIC, EEPROM_MAGIC_ADDR, EEPROM_START_ADDR, and write_eeprom().

Referenced by hidthread().

00863 {
00864 int   i;
00865 unsigned short cs;
00866 
00867    cs = 0xffff;
00868    buf[EEPROM_MAGIC_ADDR] = EEPROM_MAGIC;
00869    for(i = EEPROM_START_ADDR; i < EEPROM_CS_ADDR; i++)
00870    {
00871       write_eeprom(handle,i,buf[i]);
00872       cs += buf[i];
00873    }
00874    buf[EEPROM_CS_ADDR] = (65535 - cs) + 1;
00875    write_eeprom(handle,i,buf[EEPROM_CS_ADDR]);
00876 }

static int radio_active ( int  fd,
int  argc,
char *  argv[] 
) [static]

Definition at line 2576 of file chan_usbradio.c.

References ast_cli(), find_desc(), chan_usbradio_pvt::name, chan_usbradio_pvt::next, chan_usbradio_pvt::pmrChan, RESULT_SHOWUSAGE, RESULT_SUCCESS, usbradio_active, and usbradio_default.

Referenced by handle_radio_active().

02577 {
02578         if (argc == 2)
02579                 ast_cli(fd, "active (command) USB Radio device is [%s]\n", usbradio_active);
02580         else if (argc != 3)
02581                 return RESULT_SHOWUSAGE;
02582         else {
02583                 struct chan_usbradio_pvt *o;
02584                 if (strcmp(argv[2], "show") == 0) {
02585                         for (o = usbradio_default.next; o; o = o->next)
02586                                 ast_cli(fd, "device [%s] exists\n", o->name);
02587                         return RESULT_SUCCESS;
02588                 }
02589                 o = find_desc(argv[2]);
02590                 if (o == NULL)
02591                         ast_cli(fd, "No device [%s] exists\n", argv[2]);
02592                 else
02593             {
02594                struct chan_usbradio_pvt *ao;
02595                for (ao = usbradio_default.next; ao && ao->name ; ao = ao->next)ao->pmrChan->b.radioactive=0;
02596                     usbradio_active = o->name;
02597                 o->pmrChan->b.radioactive=1;
02598             }
02599         }
02600         return RESULT_SUCCESS;
02601 }

static int radio_set_debug ( int  fd,
int  argc,
char *  argv[] 
) [static]

Definition at line 2558 of file chan_usbradio.c.

References ast_cli(), chan_usbradio_pvt::debuglevel, find_desc(), RESULT_SUCCESS, and usbradio_active.

Referenced by handle_radio_debug().

02559 {
02560    struct chan_usbradio_pvt *o = find_desc(usbradio_active);
02561 
02562    o->debuglevel=1;
02563    ast_cli(fd,"usbradio debug on.\n");
02564    return RESULT_SUCCESS;
02565 }

static int radio_set_debug_off ( int  fd,
int  argc,
char *  argv[] 
) [static]

Definition at line 2567 of file chan_usbradio.c.

References ast_cli(), chan_usbradio_pvt::debuglevel, find_desc(), RESULT_SUCCESS, and usbradio_active.

Referenced by handle_radio_debug_off().

02568 {
02569    struct chan_usbradio_pvt *o = find_desc(usbradio_active);
02570 
02571    o->debuglevel=0;
02572    ast_cli(fd,"usbradio debug off.\n");
02573    return RESULT_SUCCESS;
02574 }

static int radio_set_xpmr_debug ( int  fd,
int  argc,
char *  argv[] 
) [static]

Definition at line 2605 of file chan_usbradio.c.

References ast_cli(), find_desc(), chan_usbradio_pvt::pmrChan, RESULT_SUCCESS, and usbradio_active.

Referenced by handle_set_xdebug().

02606 {
02607    struct chan_usbradio_pvt *o = find_desc(usbradio_active);
02608 
02609    if (argc == 4)
02610    {
02611       int i;
02612       i = atoi(argv[3]);
02613       if ((i >= 0) && (i <= 100))
02614       { 
02615          o->pmrChan->tracelevel=i;
02616       }
02617     }
02618    // add ability to set it for a number of frames after which it reverts
02619    ast_cli(fd,"usbradio xdebug on tracelevel %i\n",o->pmrChan->tracelevel);
02620 
02621    return RESULT_SUCCESS;
02622 }

static int radio_tune ( int  fd,
int  argc,
char *  argv[] 
) [static]

Definition at line 2286 of file chan_usbradio.c.

References ast_cli(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), chan_usbradio_pvt::b, chan_usbradio_pvt::devstr, chan_usbradio_pvt::eepromctl, chan_usbradio_pvt::eepromlock, find_desc(), frxcapraw, frxcaptrace, frxoutraw, ftxcapraw, ftxcaptrace, ftxoutraw, LOG_ERROR, LOG_WARNING, mixer_write(), mult_set(), chan_usbradio_pvt::name, chan_usbradio_pvt::pmrChan, pmrdump(), RESULT_SHOWUSAGE, RESULT_SUCCESS, RX_CAP_RAW_FILE, RX_CAP_TRACE_FILE, chan_usbradio_pvt::rxcap2, chan_usbradio_pvt::rxcapraw, chan_usbradio_pvt::rxsquelchadj, set_txctcss_level(), tune_rxctcss(), tune_rxinput(), tune_rxvoice(), tune_txoutput(), tune_write(), TX_CAP_RAW_FILE, TX_CAP_TRACE_FILE, TX_OUT_AUX, TX_OUT_COMPOSITE, TX_OUT_LSD, TX_OUT_VOICE, chan_usbradio_pvt::txcap2, chan_usbradio_pvt::txcapraw, chan_usbradio_pvt::txctcssadj, chan_usbradio_pvt::txmixa, chan_usbradio_pvt::txmixaset, chan_usbradio_pvt::txmixb, chan_usbradio_pvt::txmixbset, chan_usbradio_pvt::txtestkey, and usbradio_active.

Referenced by handle_radio_tune().

02287 {
02288    struct chan_usbradio_pvt *o = find_desc(usbradio_active);
02289    int i=0;
02290 
02291    if ((argc < 2) || (argc > 4))
02292       return RESULT_SHOWUSAGE; 
02293 
02294    if (argc == 2) /* just show stuff */
02295    {
02296       ast_cli(fd,"Active radio interface is [%s]\n",usbradio_active);
02297       ast_cli(fd,"Output A is currently set to ");
02298       if(o->txmixa==TX_OUT_COMPOSITE)ast_cli(fd,"composite.\n");
02299       else if (o->txmixa==TX_OUT_VOICE)ast_cli(fd,"voice.\n");
02300       else if (o->txmixa==TX_OUT_LSD)ast_cli(fd,"tone.\n");
02301       else if (o->txmixa==TX_OUT_AUX)ast_cli(fd,"auxvoice.\n");
02302       else ast_cli(fd,"off.\n");
02303 
02304       ast_cli(fd,"Output B is currently set to ");
02305       if(o->txmixb==TX_OUT_COMPOSITE)ast_cli(fd,"composite.\n");
02306       else if (o->txmixb==TX_OUT_VOICE)ast_cli(fd,"voice.\n");
02307       else if (o->txmixb==TX_OUT_LSD)ast_cli(fd,"tone.\n");
02308       else if (o->txmixb==TX_OUT_AUX)ast_cli(fd,"auxvoice.\n");
02309       else ast_cli(fd,"off.\n");
02310 
02311       ast_cli(fd,"Tx Voice Level currently set to %d\n",o->txmixaset);
02312       ast_cli(fd,"Tx Tone Level currently set to %d\n",o->txctcssadj);
02313       ast_cli(fd,"Rx Squelch currently set to %d\n",o->rxsquelchadj);
02314       ast_cli(fd,"Device String is %s\n",o->devstr);
02315       return RESULT_SHOWUSAGE;
02316    }
02317 
02318    o->pmrChan->b.tuning=1;
02319 
02320    if (!strcasecmp(argv[2],"rxnoise")) tune_rxinput(fd,o);
02321    else if (!strcasecmp(argv[2],"rxvoice")) tune_rxvoice(fd,o);
02322    else if (!strcasecmp(argv[2],"rxtone")) tune_rxctcss(fd,o);
02323    else if (!strcasecmp(argv[2],"rxsquelch"))
02324    {
02325       if (argc == 3)
02326       {
02327           ast_cli(fd,"Current Signal Strength is %d\n",((32767-o->pmrChan->rxRssi)*1000/32767));
02328           ast_cli(fd,"Current Squelch setting is %d\n",o->rxsquelchadj);
02329          //ast_cli(fd,"Current Raw RSSI        is %d\n",o->pmrChan->rxRssi);
02330           //ast_cli(fd,"Current (real) Squelch setting is %d\n",*(o->pmrChan->prxSquelchAdjust));
02331       } else {
02332          i = atoi(argv[3]);
02333          if ((i < 0) || (i > 999)) return RESULT_SHOWUSAGE;
02334          ast_cli(fd,"Changed Squelch setting to %d\n",i);
02335          o->rxsquelchadj = i;
02336          *(o->pmrChan->prxSquelchAdjust)= ((999 - i) * 32767) / 1000;
02337       }
02338    }
02339    else if (!strcasecmp(argv[2],"txvoice")) {
02340       i = 0;
02341 
02342       if( (o->txmixa!=TX_OUT_VOICE) && (o->txmixb!=TX_OUT_VOICE) &&
02343          (o->txmixa!=TX_OUT_COMPOSITE) && (o->txmixb!=TX_OUT_COMPOSITE)
02344         )
02345       {
02346          ast_log(LOG_ERROR,"No txvoice output configured.\n");
02347       }
02348       else if (argc == 3)
02349       {
02350          if((o->txmixa==TX_OUT_VOICE)||(o->txmixa==TX_OUT_COMPOSITE))
02351             ast_cli(fd,"Current txvoice setting on Channel A is %d\n",o->txmixaset);
02352          else
02353             ast_cli(fd,"Current txvoice setting on Channel B is %d\n",o->txmixbset);
02354       }
02355       else
02356       {
02357          i = atoi(argv[3]);
02358          if ((i < 0) || (i > 999)) return RESULT_SHOWUSAGE;
02359 
02360          if((o->txmixa==TX_OUT_VOICE)||(o->txmixa==TX_OUT_COMPOSITE))
02361          {
02362             o->txmixaset=i;
02363             ast_cli(fd,"Changed txvoice setting on Channel A to %d\n",o->txmixaset);
02364          }
02365          else
02366          {
02367             o->txmixbset=i;   
02368             ast_cli(fd,"Changed txvoice setting on Channel B to %d\n",o->txmixbset);
02369          }
02370          mixer_write(o);
02371          mult_set(o);
02372          ast_cli(fd,"Changed Tx Voice Output setting to %d\n",i);
02373       }
02374       o->pmrChan->b.txCtcssInhibit=1;
02375       tune_txoutput(o,i,fd);
02376       o->pmrChan->b.txCtcssInhibit=0;
02377    }
02378    else if (!strcasecmp(argv[2],"txall")) {
02379       i = 0;
02380 
02381       if( (o->txmixa!=TX_OUT_VOICE) && (o->txmixb!=TX_OUT_VOICE) &&
02382          (o->txmixa!=TX_OUT_COMPOSITE) && (o->txmixb!=TX_OUT_COMPOSITE)
02383         )
02384       {
02385          ast_log(LOG_ERROR,"No txvoice output configured.\n");
02386       }
02387       else if (argc == 3)
02388       {
02389          if((o->txmixa==TX_OUT_VOICE)||(o->txmixa==TX_OUT_COMPOSITE))
02390             ast_cli(fd,"Current txvoice setting on Channel A is %d\n",o->txmixaset);
02391          else
02392             ast_cli(fd,"Current txvoice setting on Channel B is %d\n",o->txmixbset);
02393       }
02394       else
02395       {
02396          i = atoi(argv[3]);
02397          if ((i < 0) || (i > 999)) return RESULT_SHOWUSAGE;
02398 
02399          if((o->txmixa==TX_OUT_VOICE)||(o->txmixa==TX_OUT_COMPOSITE))
02400          {
02401             o->txmixaset=i;
02402             ast_cli(fd,"Changed txvoice setting on Channel A to %d\n",o->txmixaset);
02403          }
02404          else
02405          {
02406             o->txmixbset=i;   
02407             ast_cli(fd,"Changed txvoice setting on Channel B to %d\n",o->txmixbset);
02408          }
02409          mixer_write(o);
02410          mult_set(o);
02411          ast_cli(fd,"Changed Tx Voice Output setting to %d\n",i);
02412       }
02413       tune_txoutput(o,i,fd);
02414    }
02415    else if (!strcasecmp(argv[2],"auxvoice")) {
02416       i = 0;
02417       if( (o->txmixa!=TX_OUT_AUX) && (o->txmixb!=TX_OUT_AUX))
02418       {
02419          ast_log(LOG_WARNING,"No auxvoice output configured.\n");
02420       }
02421       else if (argc == 3)
02422       {
02423          if(o->txmixa==TX_OUT_AUX)
02424             ast_cli(fd,"Current auxvoice setting on Channel A is %d\n",o->txmixaset);
02425          else
02426             ast_cli(fd,"Current auxvoice setting on Channel B is %d\n",o->txmixbset);
02427       }
02428       else
02429       {
02430          i = atoi(argv[3]);
02431          if ((i < 0) || (i > 999)) return RESULT_SHOWUSAGE;
02432          if(o->txmixa==TX_OUT_AUX)
02433          {
02434             o->txmixbset=i;
02435             ast_cli(fd,"Changed auxvoice setting on Channel A to %d\n",o->txmixaset);
02436          }
02437          else
02438          {
02439             o->txmixbset=i;
02440             ast_cli(fd,"Changed auxvoice setting on Channel B to %d\n",o->txmixbset);
02441          }
02442          mixer_write(o);
02443          mult_set(o);
02444       }
02445       //tune_auxoutput(o,i);
02446    }
02447    else if (!strcasecmp(argv[2],"txtone"))
02448    {
02449       if (argc == 3)
02450          ast_cli(fd,"Current Tx CTCSS modulation setting = %d\n",o->txctcssadj);
02451       else
02452       {
02453          i = atoi(argv[3]);
02454          if ((i < 0) || (i > 999)) return RESULT_SHOWUSAGE;
02455          o->txctcssadj = i;
02456          set_txctcss_level(o);
02457          ast_cli(fd,"Changed Tx CTCSS modulation setting to %i\n",i);
02458       }
02459       o->txtestkey=1;
02460       usleep(5000000);
02461       o->txtestkey=0;
02462    }
02463    else if (!strcasecmp(argv[2],"dump")) pmrdump(o);
02464    else if (!strcasecmp(argv[2],"nocap"))    
02465    {
02466       ast_cli(fd,"File capture (trace) was rx=%d tx=%d and now off.\n",o->b.rxcap2,o->b.txcap2);
02467       ast_cli(fd,"File capture (raw)   was rx=%d tx=%d and now off.\n",o->b.rxcapraw,o->b.txcapraw);
02468       o->b.rxcapraw=o->b.txcapraw=o->b.rxcap2=o->b.txcap2=o->pmrChan->b.rxCapture=o->pmrChan->b.txCapture=0;
02469       if (frxcapraw) { fclose(frxcapraw); frxcapraw = NULL; }
02470       if (frxcaptrace) { fclose(frxcaptrace); frxcaptrace = NULL; }
02471       if (frxoutraw) { fclose(frxoutraw); frxoutraw = NULL; }
02472       if (ftxcapraw) { fclose(ftxcapraw); ftxcapraw = NULL; }
02473       if (ftxcaptrace) { fclose(ftxcaptrace); ftxcaptrace = NULL; }
02474       if (ftxoutraw) { fclose(ftxoutraw); ftxoutraw = NULL; }
02475    }
02476    else if (!strcasecmp(argv[2],"rxtracecap")) 
02477    {
02478       if (!frxcaptrace) frxcaptrace= fopen(RX_CAP_TRACE_FILE,"w");
02479       ast_cli(fd,"Trace rx on.\n");
02480       o->b.rxcap2=o->pmrChan->b.rxCapture=1;
02481    }
02482    else if (!strcasecmp(argv[2],"txtracecap")) 
02483    {
02484       if (!ftxcaptrace) ftxcaptrace= fopen(TX_CAP_TRACE_FILE,"w");
02485       ast_cli(fd,"Trace tx on.\n");
02486       o->b.txcap2=o->pmrChan->b.txCapture=1;
02487    }
02488    else if (!strcasecmp(argv[2],"rxcap")) 
02489    {
02490       if (!frxcapraw) frxcapraw = fopen(RX_CAP_RAW_FILE,"w");
02491       ast_cli(fd,"cap rx raw on.\n");
02492       o->b.rxcapraw=1;
02493    }
02494    else if (!strcasecmp(argv[2],"txcap")) 
02495    {
02496       if (!ftxcapraw) ftxcapraw = fopen(TX_CAP_RAW_FILE,"w");
02497       ast_cli(fd,"cap tx raw on.\n");
02498       o->b.txcapraw=1;
02499    }
02500    else if (!strcasecmp(argv[2],"save"))
02501    {
02502       tune_write(o);
02503       ast_cli(fd,"Saved radio tuning settings to usbradio_tune_%s.conf\n",o->name);
02504    }
02505    else if (!strcasecmp(argv[2],"load"))
02506    {
02507       ast_mutex_lock(&o->eepromlock);
02508       while(o->eepromctl)
02509       {
02510          ast_mutex_unlock(&o->eepromlock);
02511          usleep(10000);
02512          ast_mutex_lock(&o->eepromlock);
02513       }
02514       o->eepromctl = 1;  /* request a load */
02515       ast_mutex_unlock(&o->eepromlock);
02516 
02517       ast_cli(fd,"Requesting loading of tuning settings from EEPROM for channel %s\n",o->name);
02518    }
02519    else
02520    {
02521       o->pmrChan->b.tuning=0;
02522       return RESULT_SHOWUSAGE;
02523    }
02524    o->pmrChan->b.tuning=0;
02525    return RESULT_SUCCESS;
02526 }

static unsigned short read_eeprom ( struct usb_dev_handle *  handle,
int  addr 
) [static]

Definition at line 821 of file chan_usbradio.c.

References buf, hid_get_inputs(), and hid_set_outputs().

Referenced by get_eeprom().

00822 {
00823    unsigned char buf[4];
00824 
00825    buf[0] = 0x80;
00826    buf[1] = 0;
00827    buf[2] = 0;
00828    buf[3] = 0x80 | (addr & 0x3f);
00829    hid_set_outputs(handle,buf);
00830    memset(buf,0,sizeof(buf));
00831    hid_get_inputs(handle,buf);
00832    return(buf[1] + (buf[2] << 8));
00833 }

static char* res2cli ( int  r  )  [static]

Definition at line 3802 of file chan_usbradio.c.

References CLI_FAILURE, CLI_SHOWUSAGE, CLI_SUCCESS, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

Referenced by handle_cli_cmd(), handle_cli_debug(), handle_cli_dump(), handle_cli_fun(), handle_cli_fun1(), handle_cli_local_nodes(), handle_cli_lstats(), handle_cli_nodes(), handle_cli_reload(), handle_cli_restart(), handle_cli_stats(), handle_console_key(), handle_console_unkey(), handle_radio_active(), handle_radio_debug(), handle_radio_debug_off(), handle_radio_tune(), and handle_set_xdebug().

03804 {
03805    switch (r)
03806    {
03807        case RESULT_SUCCESS:
03808       return(CLI_SUCCESS);
03809        case RESULT_SHOWUSAGE:
03810       return(CLI_SHOWUSAGE);
03811        default:
03812       return(CLI_FAILURE);
03813    }
03814 }

static void ring ( struct chan_usbradio_pvt o,
int  x 
) [static]

Definition at line 1687 of file chan_usbradio.c.

Referenced by ind_load_module(), usbradio_hangup(), and usbradio_indicate().

01688 {
01689 #ifndef  NEW_ASTERISK
01690    write(o->sndcmd[1], &x, sizeof(x));
01691 #endif
01692 }

static int set_txctcss_level ( struct chan_usbradio_pvt o  )  [static]

Definition at line 2533 of file chan_usbradio.c.

References mixer_write(), mult_set(), chan_usbradio_pvt::pmrChan, TX_OUT_LSD, chan_usbradio_pvt::txctcssadj, chan_usbradio_pvt::txmixa, chan_usbradio_pvt::txmixaset, chan_usbradio_pvt::txmixb, and chan_usbradio_pvt::txmixbset.

Referenced by radio_tune(), and store_config().

02534 {                      
02535    if (o->txmixa == TX_OUT_LSD)
02536    {
02537 //    o->txmixaset=(151*o->txctcssadj) / 1000;
02538       o->txmixaset=o->txctcssadj;
02539       mixer_write(o);
02540       mult_set(o);
02541    }
02542    else if (o->txmixb == TX_OUT_LSD)
02543    {
02544 //    o->txmixbset=(151*o->txctcssadj) / 1000;
02545       o->txmixbset=o->txctcssadj;
02546       mixer_write(o);
02547       mult_set(o);
02548    }
02549    else
02550    {
02551       *o->pmrChan->ptxCtcssAdjust=(o->txctcssadj * M_Q8) / 1000;
02552    }
02553    return 0;
02554 }

static int setamixer ( int  devnum,
char *  param,
int  v1,
int  v2 
) [static]

Definition at line 751 of file chan_usbradio.c.

References id, str, and type.

Referenced by mixer_write(), and tune_rxinput().

00752 {
00753 int   type;
00754 char  str[100];
00755 snd_hctl_t *hctl;
00756 snd_ctl_elem_id_t *id;
00757 snd_ctl_elem_value_t *control;
00758 snd_hctl_elem_t *elem;
00759 snd_ctl_elem_info_t *info;
00760 
00761    sprintf(str,"hw:%d",devnum);
00762    if (snd_hctl_open(&hctl, str, 0)) return(-1);
00763    snd_hctl_load(hctl);
00764    snd_ctl_elem_id_alloca(&id);
00765    snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
00766    snd_ctl_elem_id_set_name(id, param);  
00767    elem = snd_hctl_find_elem(hctl, id);
00768    if (!elem)
00769    {
00770       snd_hctl_close(hctl);
00771       return(-1);
00772    }
00773    snd_ctl_elem_info_alloca(&info);
00774    snd_hctl_elem_info(elem,info);
00775    type = snd_ctl_elem_info_get_type(info);
00776    snd_ctl_elem_value_alloca(&control);
00777    snd_ctl_elem_value_set_id(control, id);    
00778    switch(type)
00779    {
00780        case SND_CTL_ELEM_TYPE_INTEGER:
00781       snd_ctl_elem_value_set_integer(control, 0, v1);
00782       if (v2 > 0) snd_ctl_elem_value_set_integer(control, 1, v2);
00783       break;
00784        case SND_CTL_ELEM_TYPE_BOOLEAN:
00785       snd_ctl_elem_value_set_integer(control, 0, (v1 != 0));
00786       break;
00787    }
00788    if (snd_hctl_elem_write(elem, control))
00789    {
00790       snd_hctl_close(hctl);
00791       return(-1);
00792    }
00793    snd_hctl_close(hctl);
00794    return(0);
00795 }

static int setformat ( struct chan_usbradio_pvt o,
int  mode 
) [static]

Definition at line 1518 of file chan_usbradio.c.

References ast_log(), ast_tvnow(), ast_verbose, chan_usbradio_pvt::devicenum, chan_usbradio_pvt::duplex, errno, ast_channel::fds, chan_usbradio_pvt::frags, chan_usbradio_pvt::lastopen, LOG_WARNING, chan_usbradio_pvt::M_FULL, chan_usbradio_pvt::M_READ, chan_usbradio_pvt::M_UNSET, chan_usbradio_pvt::M_WRITE, O_CLOSE, option_verbose, chan_usbradio_pvt::owner, chan_usbradio_pvt::sounddev, VERBOSE_PREFIX_2, WARN_frag, WARN_speed, and chan_usbradio_pvt::warned.

01519 {
01520    int fmt, desired, res, fd;
01521    char device[100];
01522 
01523    if (o->sounddev >= 0) {
01524       ioctl(o->sounddev, SNDCTL_DSP_RESET, 0);
01525       close(o->sounddev);
01526       o->duplex = M_UNSET;
01527       o->sounddev = -1;
01528    }
01529    if (mode == O_CLOSE)    /* we are done */
01530       return 0;
01531    o->lastopen = ast_tvnow();
01532    strcpy(device,"/dev/dsp");
01533    if (o->devicenum)
01534       sprintf(device,"/dev/dsp%d",o->devicenum);
01535    fd = o->sounddev = open(device, mode | O_NONBLOCK);
01536    if (fd < 0) {
01537       ast_log(LOG_WARNING, "Unable to re-open DSP device %d: %s\n", o->devicenum, strerror(errno));
01538       return -1;
01539    }
01540    if (o->owner)
01541       o->owner->fds[0] = fd;
01542 
01543 #if __BYTE_ORDER == __LITTLE_ENDIAN
01544    fmt = AFMT_S16_LE;
01545 #else
01546    fmt = AFMT_S16_BE;
01547 #endif
01548    res = ioctl(fd, SNDCTL_DSP_SETFMT, &fmt);
01549    if (res < 0) {
01550       ast_log(LOG_WARNING, "Unable to set format to 16-bit signed\n");
01551       return -1;
01552    }
01553    switch (mode) {
01554       case O_RDWR:
01555          res = ioctl(fd, SNDCTL_DSP_SETDUPLEX, 0);
01556          /* Check to see if duplex set (FreeBSD Bug) */
01557          res = ioctl(fd, SNDCTL_DSP_GETCAPS, &fmt);
01558          if (res == 0 && (fmt & DSP_CAP_DUPLEX)) {
01559             if (option_verbose > 1)
01560                ast_verbose(VERBOSE_PREFIX_2 "Console is full duplex\n");
01561             o->duplex = M_FULL;
01562          };
01563          break;
01564       case O_WRONLY:
01565          o->duplex = M_WRITE;
01566          break;
01567       case O_RDONLY:
01568          o->duplex = M_READ;
01569          break;
01570    }
01571 
01572    fmt = 1;
01573    res = ioctl(fd, SNDCTL_DSP_STEREO, &fmt);
01574    if (res < 0) {
01575       ast_log(LOG_WARNING, "Failed to set audio device to mono\n");
01576       return -1;
01577    }
01578    fmt = desired = 48000;                    /* 8000 Hz desired */
01579    res = ioctl(fd, SNDCTL_DSP_SPEED, &fmt);
01580 
01581    if (res < 0) {
01582       ast_log(LOG_WARNING, "Failed to set audio device to mono\n");
01583       return -1;
01584    }
01585    if (fmt != desired) {
01586       if (!(o->warned & WARN_speed)) {
01587          ast_log(LOG_WARNING,
01588              "Requested %d Hz, got %d Hz -- sound may be choppy\n",
01589              desired, fmt);
01590          o->warned |= WARN_speed;
01591       }
01592    }
01593    /*
01594     * on Freebsd, SETFRAGMENT does not work very well on some cards.
01595     * Default to use 256 bytes, let the user override
01596     */
01597    if (o->frags) {
01598       fmt = o->frags;
01599       res = ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &fmt);
01600       if (res < 0) {
01601          if (!(o->warned & WARN_frag)) {
01602             ast_log(LOG_WARNING,
01603                "Unable to set fragment size -- sound may be choppy\n");
01604             o->warned |= WARN_frag;
01605          }
01606       }
01607    }
01608    /* on some cards, we need SNDCTL_DSP_SETTRIGGER to start outputting */
01609    res = PCM_ENABLE_INPUT | PCM_ENABLE_OUTPUT;
01610    res = ioctl(fd, SNDCTL_DSP_SETTRIGGER, &res);
01611    /* it may fail if we are in half duplex, never mind */
01612    return 0;
01613 }

static int soundcard_writeframe ( struct chan_usbradio_pvt o,
short *  data 
) [static]

Definition at line 1350 of file chan_usbradio.c.

References ast_log(), FRAME_SIZE, LOG_WARNING, chan_usbradio_pvt::pmrChan, chan_usbradio_pvt::queuesize, setformat(), chan_usbradio_pvt::sounddev, usbradio_debug, used_blocks(), and chan_usbradio_pvt::w_errors.

01351 {
01352    int res;
01353 
01354    if (o->sounddev < 0)
01355       setformat(o, O_RDWR);
01356    if (o->sounddev < 0)
01357       return 0;            /* not fatal */
01358    //  maw maw sph !!! may or may not be a good thing
01359    //  drop the frame if not transmitting, this keeps from gradually
01360    //  filling the buffer when asterisk clock > usb sound clock
01361    if(!o->pmrChan->txPttIn && !o->pmrChan->txPttOut)
01362    {
01363       //return 0;
01364    }
01365    /*
01366     * Nothing complex to manage the audio device queue.
01367     * If the buffer is full just drop the extra, otherwise write.
01368     * XXX in some cases it might be useful to write anyways after
01369     * a number of failures, to restart the output chain.
01370     */
01371    res = used_blocks(o);
01372    if (res > o->queuesize) {  /* no room to write a block */
01373        // ast_log(LOG_WARNING, "sound device write buffer overflow\n");
01374       if (o->w_errors++ == 0 && (usbradio_debug & 0x4))
01375          ast_log(LOG_WARNING, "write: used %d blocks (%d)\n", res, o->w_errors);
01376       return 0;
01377    }
01378    o->w_errors = 0;
01379 
01380    return write(o->sounddev, ((void *) data), FRAME_SIZE * 2 * 12);
01381 }

static struct chan_usbradio_pvt* store_config ( struct ast_config cfg,
char *  ctg 
) [static]

Definition at line 3407 of file chan_usbradio.c.

References amixer_max(), chan_usbradio_pvt::area, ast_calloc, ast_config_destroy(), ast_config_load, ast_dsp_new(), ast_dsp_set_digitmode(), ast_dsp_set_features(), ast_jb_read_conf(), ast_log(), ast_mutex_init(), ast_mutex_lock(), ast_mutex_unlock(), ast_pthread_create_background, ast_strdup, ast_tvnow(), ast_variable_browse(), chan_usbradio_pvt::autoanswer, chan_usbradio_pvt::autohangup, chan_usbradio_pvt::b, config1, chan_usbradio_pvt::ctx, chan_usbradio_pvt::dcsrxpolarity, chan_usbradio_pvt::dcstxpolarity, chan_usbradio_pvt::debuglevel, chan_usbradio_pvt::devicenum, chan_usbradio_pvt::devstr, chan_usbradio_pvt::dsp, DSP_DIGITMODE_DTMF, DSP_DIGITMODE_MUTECONF, DSP_DIGITMODE_RELAXDTMF, DSP_FEATURE_DIGIT_DETECT, chan_usbradio_pvt::eepromctl, chan_usbradio_pvt::eepromlock, chan_usbradio_pvt::ext, find_desc_usb(), chan_usbradio_pvt::frags, free, global_jbconf, chan_usbradio_pvt::hdwtype, hidhdwconfig(), chan_usbradio_pvt::idleinterval, chan_usbradio_pvt::invertptt, chan_usbradio_pvt::language, chan_usbradio_pvt::lastopen, LOG_ERROR, LOG_NOTICE, LOG_WARNING, chan_usbradio_pvt::loopback, chan_usbradio_pvt::lsdrxpolarity, chan_usbradio_pvt::lsdtxpolarity, M_BOOL, M_END, M_F, M_START, M_STR, M_UINT, chan_usbradio_pvt::micmax, MIXER_PARAM_MIC_CAPTURE_VOL, MIXER_PARAM_SPKR_PLAYBACK_VOL, mixer_write(), chan_usbradio_pvt::mohinterpret, mult_set(), ast_variable::name, chan_usbradio_pvt::name, chan_usbradio_pvt::next, ast_variable::next, chan_usbradio_pvt::overridecontext, chan_usbradio_pvt::pmrChan, chan_usbradio_pvt::queuesize, chan_usbradio_pvt::radioactive, chan_usbradio_pvt::radioduplex, chan_usbradio_pvt::rptnum, chan_usbradio_pvt::rxboostset, chan_usbradio_pvt::rxcdtype, chan_usbradio_pvt::rxcpusaver, chan_usbradio_pvt::rxctcssadj, chan_usbradio_pvt::rxctcssfreqs, chan_usbradio_pvt::rxctcssrelax, chan_usbradio_pvt::rxdemod, chan_usbradio_pvt::rxfreq, chan_usbradio_pvt::rxmixerset, chan_usbradio_pvt::rxpolarity, chan_usbradio_pvt::rxsquelchadj, chan_usbradio_pvt::rxsqvoxadj, chan_usbradio_pvt::rxvoiceadj, s, set_txctcss_level(), chan_usbradio_pvt::spkrmax, store_callerid(), store_rxcdtype(), store_rxctcssadj(), store_rxdemod(), store_rxgain(), store_rxsdtype(), store_rxvoiceadj(), store_txmixa(), store_txmixb(), store_txtoctype(), chan_usbradio_pvt::tracelevel, chan_usbradio_pvt::tracetype, traceusb1, chan_usbradio_pvt::turnoffs, TX_OUT_COMPOSITE, TX_OUT_LSD, TX_OUT_VOICE, chan_usbradio_pvt::txcpusaver, chan_usbradio_pvt::txctcssadj, chan_usbradio_pvt::txctcssdefault, chan_usbradio_pvt::txctcssfreq, chan_usbradio_pvt::txctcssfreqs, chan_usbradio_pvt::txfreq, chan_usbradio_pvt::txmixa, chan_usbradio_pvt::txmixaset, chan_usbradio_pvt::txmixb, chan_usbradio_pvt::txmixbset, chan_usbradio_pvt::txpolarity, chan_usbradio_pvt::txprelim, chan_usbradio_pvt::txsettletime, chan_usbradio_pvt::txtoctype, chan_usbradio_pvt::ukey, usb_device_list, usb_get_usbdev(), usb_list_check(), usbradio_active, usbradio_debug, usbradio_default, ast_variable::value, chan_usbradio_pvt::wanteeprom, and xpmr_config().

03408 {
03409    struct ast_variable *v;
03410    struct chan_usbradio_pvt *o;
03411    struct ast_config *cfg1;
03412    int i;
03413    char fname[200];
03414 #ifdef   NEW_ASTERISK
03415    struct ast_flags zeroflag = {0};
03416 #endif
03417    if (ctg == NULL) {
03418       traceusb1((" store_config() ctg == NULL\n"));
03419       o = &usbradio_default;
03420       ctg = "general";
03421    } else {
03422       /* "general" is also the default thing */
03423       if (strcmp(ctg, "general") == 0) {
03424          o = &usbradio_default;
03425       } else {
03426           // ast_log(LOG_NOTICE,"ast_calloc for chan_usbradio_pvt of %s\n",ctg);
03427          if (!(o = ast_calloc(1, sizeof(*o))))
03428             return NULL;
03429          *o = usbradio_default;
03430          o->name = ast_strdup(ctg);
03431          if (!usbradio_active) 
03432             usbradio_active = o->name;
03433       }
03434    }
03435    ast_mutex_init(&o->eepromlock);
03436    strcpy(o->mohinterpret, "default");
03437    /* fill other fields from configuration */
03438    for (v = ast_variable_browse(cfg, ctg); v; v = v->next) {
03439       M_START((char *)v->name, (char *)v->value);
03440 
03441       /* handle jb conf */
03442       if (!ast_jb_read_conf(&global_jbconf, v->name, v->value))
03443          continue;
03444 
03445 #if   0
03446          M_BOOL("autoanswer", o->autoanswer)
03447          M_BOOL("autohangup", o->autohangup)
03448          M_BOOL("overridecontext", o->overridecontext)
03449          M_STR("context", o->ctx)
03450          M_STR("language", o->language)
03451          M_STR("mohinterpret", o->mohinterpret)
03452          M_STR("extension", o->ext)
03453          M_F("callerid", store_callerid(o, v->value))
03454 #endif
03455          M_UINT("frags", o->frags)
03456          M_UINT("queuesize",o->queuesize)
03457 #if 0
03458          M_UINT("devicenum",o->devicenum)
03459 #endif
03460          M_UINT("debug", usbradio_debug)
03461          M_BOOL("rxcpusaver",o->rxcpusaver)
03462          M_BOOL("txcpusaver",o->txcpusaver)
03463          M_BOOL("invertptt",o->invertptt)
03464          M_F("rxdemod",store_rxdemod(o,(char *)v->value))
03465          M_BOOL("txprelim",o->txprelim);
03466          M_F("txmixa",store_txmixa(o,(char *)v->value))
03467          M_F("txmixb",store_txmixb(o,(char *)v->value))
03468          M_F("carrierfrom",store_rxcdtype(o,(char *)v->value))
03469          M_F("rxsdtype",store_rxsdtype(o,(char *)v->value))
03470           M_UINT("rxsqvox",o->rxsqvoxadj)
03471          M_STR("txctcssdefault",o->txctcssdefault)
03472          M_STR("rxctcssfreqs",o->rxctcssfreqs)
03473          M_STR("txctcssfreqs",o->txctcssfreqs)
03474          M_UINT("rxfreq",o->rxfreq)
03475          M_UINT("txfreq",o->txfreq)
03476          M_F("rxgain",store_rxgain(o,(char *)v->value))
03477          M_BOOL("rxboost",o->rxboostset)
03478          M_UINT("rxctcssrelax",o->rxctcssrelax)
03479          M_F("txtoctype",store_txtoctype(o,(char *)v->value))
03480          M_UINT("hdwtype",o->hdwtype)
03481          M_UINT("eeprom",o->wanteeprom)
03482          M_UINT("duplex",o->radioduplex)
03483          M_UINT("txsettletime",o->txsettletime)
03484          M_BOOL("rxpolarity",o->b.rxpolarity)
03485          M_BOOL("txpolarity",o->b.txpolarity)
03486          M_BOOL("dcsrxpolarity",o->b.dcsrxpolarity)
03487          M_BOOL("dcstxpolarity",o->b.dcstxpolarity)
03488          M_BOOL("lsdrxpolarity",o->b.lsdrxpolarity)
03489          M_BOOL("lsdtxpolarity",o->b.lsdtxpolarity)
03490          M_BOOL("loopback",o->b.loopback)
03491          M_BOOL("radioactive",o->b.radioactive)
03492          M_UINT("rptnum",o->rptnum)
03493          M_UINT("idleinterval",o->idleinterval)
03494          M_UINT("turnoffs",o->turnoffs)
03495          M_UINT("tracetype",o->tracetype)
03496          M_UINT("tracelevel",o->tracelevel)
03497          M_UINT("area",o->area)
03498          M_STR("ukey",o->ukey)
03499          M_END(;
03500          );
03501    }
03502 
03503    o->debuglevel=0;
03504 
03505    if (o == &usbradio_default)      /* we are done with the default */
03506       return NULL;
03507 
03508    snprintf(fname,sizeof(fname) - 1,config1,o->name);
03509 #ifdef   NEW_ASTERISK
03510    cfg1 = ast_config_load(fname,zeroflag);
03511 #else
03512    cfg1 = ast_config_load(fname);
03513 #endif
03514    o->rxmixerset = 500;
03515    o->txmixaset = 500;
03516    o->txmixbset = 500;
03517    o->rxvoiceadj = 0.5;
03518    o->rxctcssadj = 0.5;
03519    o->txctcssadj = 200;
03520    o->rxsquelchadj = 500;
03521    o->devstr[0] = 0;
03522    if (cfg1) {
03523       for (v = ast_variable_browse(cfg1, o->name); v; v = v->next) {
03524    
03525          M_START((char *)v->name, (char *)v->value);
03526          M_UINT("rxmixerset", o->rxmixerset)
03527          M_UINT("txmixaset", o->txmixaset)
03528          M_UINT("txmixbset", o->txmixbset)
03529          M_F("rxvoiceadj",store_rxvoiceadj(o,(char *)v->value))
03530          M_F("rxctcssadj",store_rxctcssadj(o,(char *)v->value))
03531          M_UINT("txctcssadj",o->txctcssadj);
03532          M_UINT("rxsquelchadj", o->rxsquelchadj)
03533          M_STR("devstr", o->devstr)
03534          M_END(;
03535          );
03536       }
03537       ast_config_destroy(cfg1);
03538    } else ast_log(LOG_WARNING,"File %s not found, using default parameters.\n",fname);
03539 
03540    if(o->wanteeprom)
03541    {
03542       ast_mutex_lock(&o->eepromlock);
03543       while(o->eepromctl)
03544       {
03545          ast_mutex_unlock(&o->eepromlock);
03546          usleep(10000);
03547          ast_mutex_lock(&o->eepromlock);
03548       }
03549       o->eepromctl = 1;  /* request a load */
03550       ast_mutex_unlock(&o->eepromlock);
03551    }
03552    /* if our specified one exists in the list */
03553    if ((!usb_list_check(o->devstr)) || find_desc_usb(o->devstr))
03554    {
03555       char *s;
03556 
03557       for(s = usb_device_list; *s; s += strlen(s) + 1)
03558       {
03559          if (!find_desc_usb(s)) break;
03560       }
03561       if (!*s)
03562       {
03563          ast_log(LOG_WARNING,"Unable to assign USB device for channel %s\n",o->name);
03564          goto error;
03565       }
03566       ast_log(LOG_NOTICE,"Assigned USB device %s to usbradio channel %s\n",s,o->name);
03567       strcpy(o->devstr,s);
03568    }
03569 
03570    i = usb_get_usbdev(o->devstr);
03571    if (i < 0)
03572    {
03573            ast_log(LOG_ERROR,"Not able to find alsa USB device\n");
03574       goto error;
03575    }
03576    o->devicenum = i;
03577 
03578    o->micmax = amixer_max(o->devicenum,MIXER_PARAM_MIC_CAPTURE_VOL);
03579    o->spkrmax = amixer_max(o->devicenum,MIXER_PARAM_SPKR_PLAYBACK_VOL);
03580    o->lastopen = ast_tvnow(); /* don't leave it 0 or tvdiff may wrap */
03581    o->dsp = ast_dsp_new();
03582    if (o->dsp)
03583    {
03584 #ifdef   NEW_ASTERISK
03585      ast_dsp_set_features(o->dsp,DSP_FEATURE_DIGIT_DETECT);
03586      ast_dsp_set_digitmode(o->dsp,DSP_DIGITMODE_DTMF | DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_RELAXDTMF);
03587 #else
03588      ast_dsp_set_features(o->dsp,DSP_FEATURE_DTMF_DETECT);
03589      ast_dsp_digitmode(o->dsp,DSP_DIGITMODE_DTMF | DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_RELAXDTMF);
03590 #endif
03591    }
03592 
03593    if(o->pmrChan==NULL)
03594    {
03595       t_pmr_chan tChan;
03596 
03597       // ast_log(LOG_NOTICE,"createPmrChannel() %s\n",o->name);
03598       memset(&tChan,0,sizeof(t_pmr_chan));
03599 
03600       tChan.pTxCodeDefault = o->txctcssdefault;
03601       tChan.pRxCodeSrc     = o->rxctcssfreqs;
03602       tChan.pTxCodeSrc     = o->txctcssfreqs;
03603 
03604       tChan.rxDemod=o->rxdemod;
03605       tChan.rxCdType=o->rxcdtype;
03606       tChan.rxSqVoxAdj=o->rxsqvoxadj;
03607 
03608       if (o->txprelim) 
03609          tChan.txMod = 2;
03610 
03611       tChan.txMixA = o->txmixa;
03612       tChan.txMixB = o->txmixb;
03613 
03614       tChan.rxCpuSaver=o->rxcpusaver;
03615       tChan.txCpuSaver=o->txcpusaver;
03616 
03617       tChan.b.rxpolarity=o->b.rxpolarity;
03618       tChan.b.txpolarity=o->b.txpolarity;
03619 
03620       tChan.b.dcsrxpolarity=o->b.dcsrxpolarity;
03621       tChan.b.dcstxpolarity=o->b.dcstxpolarity;
03622 
03623       tChan.b.lsdrxpolarity=o->b.lsdrxpolarity;
03624       tChan.b.lsdtxpolarity=o->b.lsdtxpolarity;
03625 
03626       tChan.tracetype=o->tracetype;
03627       tChan.tracelevel=o->tracelevel;
03628       tChan.rptnum=o->rptnum;
03629       tChan.idleinterval=o->idleinterval;
03630       tChan.turnoffs=o->turnoffs;
03631       tChan.area=o->area;
03632       tChan.ukey=o->ukey;
03633       tChan.name=o->name;
03634 
03635       o->pmrChan=createPmrChannel(&tChan,FRAME_SIZE);
03636                             
03637       o->pmrChan->radioDuplex=o->radioduplex;
03638       o->pmrChan->b.loopback=0; 
03639       o->pmrChan->txsettletime=o->txsettletime;
03640       o->pmrChan->rxCpuSaver=o->rxcpusaver;
03641       o->pmrChan->txCpuSaver=o->txcpusaver;
03642 
03643       *(o->pmrChan->prxSquelchAdjust) = 
03644          ((999 - o->rxsquelchadj) * 32767) / 1000;
03645 
03646       *(o->pmrChan->prxVoiceAdjust)=o->rxvoiceadj*M_Q8;
03647       *(o->pmrChan->prxCtcssAdjust)=o->rxctcssadj*M_Q8;
03648       o->pmrChan->rxCtcss->relax=o->rxctcssrelax;
03649       o->pmrChan->txTocType = o->txtoctype;
03650 
03651         if (    (o->txmixa == TX_OUT_LSD) ||
03652                 (o->txmixa == TX_OUT_COMPOSITE) ||
03653                 (o->txmixb == TX_OUT_LSD) ||
03654                 (o->txmixb == TX_OUT_COMPOSITE))
03655         {
03656                 set_txctcss_level(o);
03657         }
03658 
03659       if( (o->txmixa!=TX_OUT_VOICE) && (o->txmixb!=TX_OUT_VOICE) &&
03660          (o->txmixa!=TX_OUT_COMPOSITE) && (o->txmixb!=TX_OUT_COMPOSITE)
03661         )
03662       {
03663          ast_log(LOG_ERROR,"No txvoice output configured.\n");
03664       }
03665    
03666       if( o->txctcssfreq[0] && 
03667           o->txmixa!=TX_OUT_LSD && o->txmixa!=TX_OUT_COMPOSITE  &&
03668          o->txmixb!=TX_OUT_LSD && o->txmixb!=TX_OUT_COMPOSITE
03669         )
03670       {
03671          ast_log(LOG_ERROR,"No txtone output configured.\n");
03672       }
03673       
03674       if(o->b.radioactive)
03675       {
03676           // 20080328 sphenke asdf maw !!!
03677           // this diagnostic option was working but now appears broken
03678          // it's not required for operation so I'll fix it later.
03679          //struct chan_usbradio_pvt *ao;
03680          //for (ao = usbradio_default.next; ao && ao->name ; ao = ao->next)ao->pmrChan->b.radioactive=0;
03681          usbradio_active = o->name;
03682          // o->pmrChan->b.radioactive=1;
03683          //o->b.radioactive=0;
03684          //o->pmrChan->b.radioactive=0;
03685          ast_log(LOG_NOTICE,"radio active set to [%s]\n",o->name);
03686       }
03687    }
03688 
03689    xpmr_config(o);
03690 
03691    TRACEO(1,("store_config() 120\n"));
03692    mixer_write(o);
03693    TRACEO(1,("store_config() 130\n"));
03694    mult_set(o);    
03695    TRACEO(1,("store_config() 140\n"));
03696    hidhdwconfig(o);
03697 
03698    TRACEO(1,("store_config() 200\n"));
03699 
03700 #ifndef  NEW_ASTERISK
03701    if (pipe(o->sndcmd) != 0) {
03702       ast_log(LOG_ERROR, "Unable to create pipe\n");
03703       goto error;
03704    }
03705 
03706    ast_pthread_create_background(&o->sthread, NULL, sound_thread, o);
03707 #endif
03708 
03709    /* link into list of devices */
03710    if (o != &usbradio_default) {
03711       o->next = usbradio_default.next;
03712       usbradio_default.next = o;
03713    }
03714    TRACEO(1,("store_config() complete\n"));
03715    return o;
03716   
03717   error:
03718    if (o != &usbradio_default)
03719       free(o);
03720    return NULL;
03721 }

static void store_rxcdtype ( struct chan_usbradio_pvt o,
char *  s 
) [static]

Definition at line 2766 of file chan_usbradio.c.

References ast_log(), CD_HID, CD_HID_INVERT, CD_IGNORE, CD_XPMR_NOISE, CD_XPMR_VOX, LOG_WARNING, and chan_usbradio_pvt::rxcdtype.

Referenced by store_config().

02767 {
02768    if (!strcasecmp(s,"no")){
02769       o->rxcdtype = CD_IGNORE;
02770    }
02771    else if (!strcasecmp(s,"usb")){
02772       o->rxcdtype = CD_HID;
02773    }
02774    else if (!strcasecmp(s,"dsp")){
02775       o->rxcdtype = CD_XPMR_NOISE;
02776    }  
02777    else if (!strcasecmp(s,"vox")){
02778       o->rxcdtype = CD_XPMR_VOX;
02779    }  
02780    else if (!strcasecmp(s,"usbinvert")){
02781       o->rxcdtype = CD_HID_INVERT;
02782    }  
02783    else {
02784       ast_log(LOG_WARNING,"Unrecognized rxcdtype parameter: %s\n",s);
02785    }
02786 
02787    //ast_log(LOG_WARNING, "set rxcdtype = %s\n", s);
02788 }

static void store_rxctcssadj ( struct chan_usbradio_pvt o,
char *  s 
) [static]

Definition at line 2831 of file chan_usbradio.c.

References ast_debug, f, and chan_usbradio_pvt::rxctcssadj.

Referenced by store_config().

02832 {
02833    float f;
02834    if (sscanf(s, "%30f", &f) == 1)
02835       o->rxctcssadj = f;
02836    ast_debug(4, "set rxctcssadj = %f\n", f);
02837 }

static void store_rxdemod ( struct chan_usbradio_pvt o,
char *  s 
) [static]

Definition at line 2698 of file chan_usbradio.c.

References ast_log(), LOG_WARNING, RX_AUDIO_FLAT, RX_AUDIO_NONE, RX_AUDIO_SPEAKER, and chan_usbradio_pvt::rxdemod.

Referenced by store_config().

02699 {
02700    if (!strcasecmp(s,"no")){
02701       o->rxdemod = RX_AUDIO_NONE;
02702    }
02703    else if (!strcasecmp(s,"speaker")){
02704       o->rxdemod = RX_AUDIO_SPEAKER;
02705    }
02706    else if (!strcasecmp(s,"flat")){
02707          o->rxdemod = RX_AUDIO_FLAT;
02708    }  
02709    else {
02710       ast_log(LOG_WARNING,"Unrecognized rxdemod parameter: %s\n",s);
02711    }
02712 
02713    //ast_log(LOG_WARNING, "set rxdemod = %s\n", s);
02714 }

static void store_rxgain ( struct chan_usbradio_pvt o,
char *  s 
) [static]

Definition at line 2813 of file chan_usbradio.c.

References ast_debug, f, and chan_usbradio_pvt::rxgain.

Referenced by store_config().

02814 {
02815    float f;
02816    if (sscanf(s, "%30f", &f) == 1)
02817       o->rxgain = f;
02818    ast_debug(4, "set rxgain = %f\n", f);
02819 }

static void store_rxsdtype ( struct chan_usbradio_pvt o,
char *  s 
) [static]

Definition at line 2791 of file chan_usbradio.c.

References ast_log(), LOG_WARNING, chan_usbradio_pvt::rxsdtype, SD_HID, SD_HID_INVERT, SD_IGNORE, and SD_XPMR.

Referenced by store_config().

02792 {
02793    if (!strcasecmp(s,"no") || !strcasecmp(s,"SD_IGNORE")){
02794       o->rxsdtype = SD_IGNORE;
02795    }
02796    else if (!strcasecmp(s,"usb") || !strcasecmp(s,"SD_HID")){
02797       o->rxsdtype = SD_HID;
02798    }
02799    else if (!strcasecmp(s,"usbinvert") || !strcasecmp(s,"SD_HID_INVERT")){
02800       o->rxsdtype = SD_HID_INVERT;
02801    }  
02802    else if (!strcasecmp(s,"software") || !strcasecmp(s,"SD_XPMR")){
02803       o->rxsdtype = SD_XPMR;
02804    }  
02805    else {
02806       ast_log(LOG_WARNING,"Unrecognized rxsdtype parameter: %s\n",s);
02807    }
02808 
02809    //ast_log(LOG_WARNING, "set rxsdtype = %s\n", s);
02810 }

static void store_rxvoiceadj ( struct chan_usbradio_pvt o,
char *  s 
) [static]

Definition at line 2822 of file chan_usbradio.c.

References ast_debug, f, and chan_usbradio_pvt::rxvoiceadj.

Referenced by store_config().

02823 {
02824    float f;
02825    if (sscanf(s, "%30f", &f) == 1)
02826       o->rxvoiceadj = f;
02827    ast_debug(4, "set rxvoiceadj = %f\n", f);
02828 }

static void store_txmixa ( struct chan_usbradio_pvt o,
char *  s 
) [static]

Definition at line 2717 of file chan_usbradio.c.

References ast_log(), LOG_WARNING, TX_OUT_AUX, TX_OUT_COMPOSITE, TX_OUT_LSD, TX_OUT_OFF, TX_OUT_VOICE, and chan_usbradio_pvt::txmixa.

Referenced by store_config().

02718 {
02719    if (!strcasecmp(s,"no")){
02720       o->txmixa = TX_OUT_OFF;
02721    }
02722    else if (!strcasecmp(s,"voice")){
02723       o->txmixa = TX_OUT_VOICE;
02724    }
02725    else if (!strcasecmp(s,"tone")){
02726          o->txmixa = TX_OUT_LSD;
02727    }  
02728    else if (!strcasecmp(s,"composite")){
02729       o->txmixa = TX_OUT_COMPOSITE;
02730    }  
02731    else if (!strcasecmp(s,"auxvoice")){
02732       o->txmixa = TX_OUT_AUX;
02733    }  
02734    else {
02735       ast_log(LOG_WARNING,"Unrecognized txmixa parameter: %s\n",s);
02736    }
02737 
02738    //ast_log(LOG_WARNING, "set txmixa = %s\n", s);
02739 }

static void store_txmixb ( struct chan_usbradio_pvt o,
char *  s 
) [static]

Definition at line 2741 of file chan_usbradio.c.

References ast_log(), LOG_WARNING, TX_OUT_AUX, TX_OUT_COMPOSITE, TX_OUT_LSD, TX_OUT_OFF, TX_OUT_VOICE, and chan_usbradio_pvt::txmixb.

Referenced by store_config().

02742 {
02743    if (!strcasecmp(s,"no")){
02744       o->txmixb = TX_OUT_OFF;
02745    }
02746    else if (!strcasecmp(s,"voice")){
02747       o->txmixb = TX_OUT_VOICE;
02748    }
02749    else if (!strcasecmp(s,"tone")){
02750          o->txmixb = TX_OUT_LSD;
02751    }  
02752    else if (!strcasecmp(s,"composite")){
02753       o->txmixb = TX_OUT_COMPOSITE;
02754    }  
02755    else if (!strcasecmp(s,"auxvoice")){
02756       o->txmixb = TX_OUT_AUX;
02757    }  
02758    else {
02759       ast_log(LOG_WARNING,"Unrecognized txmixb parameter: %s\n",s);
02760    }
02761 
02762    //ast_log(LOG_WARNING, "set txmixb = %s\n", s);
02763 }

static void store_txtoctype ( struct chan_usbradio_pvt o,
char *  s 
) [static]

Definition at line 2840 of file chan_usbradio.c.

References ast_log(), LOG_WARNING, TOC_NONE, TOC_NOTONE, TOC_PHASE, and chan_usbradio_pvt::txtoctype.

Referenced by store_config().

02841 {
02842    if (!strcasecmp(s,"no") || !strcasecmp(s,"TOC_NONE")){
02843       o->txtoctype = TOC_NONE;
02844    }
02845    else if (!strcasecmp(s,"phase") || !strcasecmp(s,"TOC_PHASE")){
02846       o->txtoctype = TOC_PHASE;
02847    }
02848    else if (!strcasecmp(s,"notone") || !strcasecmp(s,"TOC_NOTONE")){
02849       o->txtoctype = TOC_NOTONE;
02850    }  
02851    else {
02852       ast_log(LOG_WARNING,"Unrecognized txtoctype parameter: %s\n",s);
02853    }
02854 }

static void tune_rxctcss ( int  fd,
struct chan_usbradio_pvt o 
) [static]

Definition at line 3017 of file chan_usbradio.c.

References ast_cli(), chan_usbradio_pvt::pmrChan, and chan_usbradio_pvt::rxctcssadj.

Referenced by radio_tune().

03018 {
03019    const int target=2400;      // was 4096 pre 20080205
03020    const int tolerance=100;
03021    const float settingmin=0.1;
03022    const float settingmax=8;
03023    const float settingstart=1;
03024    const int maxtries=12;
03025 
03026    float setting;
03027    int tries=0, meas;
03028 
03029    ast_cli(fd,"INFO: RX CTCSS ADJUST START.\n");   
03030    ast_cli(fd,"target=%i tolerance=%i \n",target,tolerance);
03031 
03032    o->pmrChan->b.tuning=1;
03033    o->pmrChan->spsMeasure->source=o->pmrChan->prxCtcssMeasure;
03034    o->pmrChan->spsMeasure->discfactor=400;
03035    o->pmrChan->spsMeasure->enabled=1;
03036 
03037    setting=settingstart;
03038 
03039    while(tries<maxtries)
03040    {
03041       *(o->pmrChan->prxCtcssAdjust)=setting*M_Q8;
03042       usleep(10000);
03043       o->pmrChan->spsMeasure->amax = o->pmrChan->spsMeasure->amin = 0;
03044       usleep(500000);
03045       meas = o->pmrChan->spsMeasure->apeak;
03046       ast_cli(fd,"tries=%i, setting=%f, meas=%i\n",tries,setting,meas);
03047 
03048       if( meas<(target-tolerance) || meas>(target+tolerance) || tries<3){
03049          setting=setting*target/meas;
03050       }
03051       else if(tries>4 && meas>(target-tolerance) && meas<(target+tolerance) )
03052       {
03053          break;
03054       }
03055       if(setting<settingmin)setting=settingmin;
03056       else if(setting>settingmax)setting=settingmax;
03057 
03058       tries++;
03059    }
03060    o->pmrChan->spsMeasure->enabled=0;
03061    ast_cli(fd,"DONE tries=%i, setting=%f, meas=%f\n",tries,setting,(float)meas);
03062    if( meas<(target-tolerance) || meas>(target+tolerance) ){
03063       ast_cli(fd,"ERROR: RX CTCSS GAIN ADJUST FAILED.\n");
03064    }else{
03065       ast_cli(fd,"INFO: RX CTCSS GAIN ADJUST SUCCESS.\n");
03066       o->rxctcssadj=setting;
03067    }
03068    o->pmrChan->b.tuning=0;
03069 }

static void tune_rxinput ( int  fd,
struct chan_usbradio_pvt o 
) [static]

Definition at line 2871 of file chan_usbradio.c.

References ast_cli(), CD_XPMR_NOISE, chan_usbradio_pvt::devicenum, chan_usbradio_pvt::micmax, MIXER_PARAM_MIC_BOOST, MIXER_PARAM_MIC_CAPTURE_VOL, chan_usbradio_pvt::pmrChan, RX_AUDIO_SPEAKER, chan_usbradio_pvt::rxboostset, chan_usbradio_pvt::rxcdtype, chan_usbradio_pvt::rxdemod, chan_usbradio_pvt::rxmixerset, and setamixer().

Referenced by radio_tune().

02872 {
02873    const int target=23000;
02874    const int tolerance=2000;
02875    const int settingmin=1;
02876    const int settingstart=2;
02877    const int maxtries=12;
02878 
02879    float settingmax;
02880    
02881    int setting=0, tries=0, tmpdiscfactor, meas;
02882    int tunetype=0;
02883 
02884    settingmax = o->micmax;
02885 
02886    if(o->pmrChan->rxDemod)tunetype=1;
02887    o->pmrChan->b.tuning=1;
02888 
02889    setting = settingstart;
02890 
02891     ast_cli(fd,"tune rxnoise maxtries=%i, target=%i, tolerance=%i\n",maxtries,target,tolerance);
02892 
02893    while(tries<maxtries)
02894    {
02895       setamixer(o->devicenum,MIXER_PARAM_MIC_CAPTURE_VOL,setting,0);
02896       setamixer(o->devicenum,MIXER_PARAM_MIC_BOOST,o->rxboostset,0);
02897        
02898       usleep(100000);
02899       if(o->rxcdtype!=CD_XPMR_NOISE || o->rxdemod==RX_AUDIO_SPEAKER) 
02900       {
02901          // printf("Measure Direct Input\n");
02902          o->pmrChan->spsMeasure->source = o->pmrChan->spsRx->source;
02903          o->pmrChan->spsMeasure->discfactor=2000;
02904          o->pmrChan->spsMeasure->enabled=1;
02905          o->pmrChan->spsMeasure->amax = o->pmrChan->spsMeasure->amin = 0;
02906          usleep(400000);   
02907          meas=o->pmrChan->spsMeasure->apeak;
02908          o->pmrChan->spsMeasure->enabled=0;  
02909       }
02910       else
02911       {
02912          // printf("Measure HF Noise\n");
02913          tmpdiscfactor=o->pmrChan->spsRx->discfactor;
02914          o->pmrChan->spsRx->discfactor=(i16)2000;
02915          o->pmrChan->spsRx->discounteru=o->pmrChan->spsRx->discounterl=0;
02916          o->pmrChan->spsRx->amax=o->pmrChan->spsRx->amin=0;
02917          usleep(200000);
02918          meas=o->pmrChan->rxRssi;
02919          o->pmrChan->spsRx->discfactor=tmpdiscfactor;
02920          o->pmrChan->spsRx->discounteru=o->pmrChan->spsRx->discounterl=0;
02921          o->pmrChan->spsRx->amax=o->pmrChan->spsRx->amin=0;
02922       }
02923         if(!meas)meas++;
02924       ast_cli(fd,"tries=%i, setting=%i, meas=%i\n",tries,setting,meas);
02925 
02926       if( meas<(target-tolerance) || meas>(target+tolerance) || tries<3){
02927          setting=setting*target/meas;
02928       }
02929       else if(tries>4 && meas>(target-tolerance) && meas<(target+tolerance) )
02930       {
02931          break;
02932       }
02933 
02934       if(setting<settingmin)setting=settingmin;
02935       else if(setting>settingmax)setting=settingmax;
02936 
02937       tries++;
02938    }
02939    ast_cli(fd,"DONE tries=%i, setting=%i, meas=%i\n",tries,
02940       (setting * 1000) / o->micmax,meas);
02941    if( meas<(target-tolerance) || meas>(target+tolerance) ){
02942       ast_cli(fd,"ERROR: RX INPUT ADJUST FAILED.\n");
02943    }else{
02944       ast_cli(fd,"INFO: RX INPUT ADJUST SUCCESS.\n"); 
02945       o->rxmixerset=(setting * 1000) / o->micmax;
02946    }
02947    o->pmrChan->b.tuning=0;
02948 }

static void tune_rxvoice ( int  fd,
struct chan_usbradio_pvt o 
) [static]

Definition at line 2951 of file chan_usbradio.c.

References ast_cli(), chan_usbradio_pvt::pmrChan, and chan_usbradio_pvt::rxvoiceadj.

Referenced by radio_tune().

02952 {
02953    const int target=7200;           // peak
02954    const int tolerance=360;            // peak to peak
02955    const float settingmin=0.1;
02956    const float settingmax=4;
02957    const float settingstart=1;
02958    const int maxtries=12;
02959 
02960    float setting;
02961 
02962    int tries=0, meas;
02963 
02964    ast_cli(fd,"INFO: RX VOICE ADJUST START.\n");   
02965    ast_cli(fd,"target=%i tolerance=%i \n",target,tolerance);
02966 
02967    o->pmrChan->b.tuning=1;
02968    if(!o->pmrChan->spsMeasure)
02969       ast_cli(fd,"ERROR: NO MEASURE BLOCK.\n");
02970 
02971    if(!o->pmrChan->spsMeasure->source || !o->pmrChan->prxVoiceAdjust )
02972       ast_cli(fd,"ERROR: NO SOURCE OR MEASURE SETTING.\n");
02973 
02974    o->pmrChan->spsMeasure->source=o->pmrChan->spsRxOut->sink;
02975    o->pmrChan->spsMeasure->enabled=1;
02976    o->pmrChan->spsMeasure->discfactor=1000;
02977    
02978    setting=settingstart;
02979 
02980    // ast_cli(fd,"ERROR: NO MEASURE BLOCK.\n");
02981 
02982    while(tries<maxtries)
02983    {
02984       *(o->pmrChan->prxVoiceAdjust)=setting*M_Q8;
02985       usleep(10000);
02986       o->pmrChan->spsMeasure->amax = o->pmrChan->spsMeasure->amin = 0;
02987       usleep(1000000);
02988       meas = o->pmrChan->spsMeasure->apeak;
02989       ast_cli(fd,"tries=%i, setting=%f, meas=%i\n",tries,setting,meas);
02990 
02991       if( meas<(target-tolerance) || meas>(target+tolerance) || tries<3){
02992          setting=setting*target/meas;
02993       }
02994       else if(tries>4 && meas>(target-tolerance) && meas<(target+tolerance) )
02995       {
02996          break;
02997       }
02998       if(setting<settingmin)setting=settingmin;
02999       else if(setting>settingmax)setting=settingmax;
03000 
03001       tries++;
03002    }
03003 
03004    o->pmrChan->spsMeasure->enabled=0;
03005 
03006    ast_cli(fd,"DONE tries=%i, setting=%f, meas=%f\n",tries,setting,(float)meas);
03007    if( meas<(target-tolerance) || meas>(target+tolerance) ){
03008       ast_cli(fd,"ERROR: RX VOICE GAIN ADJUST FAILED.\n");
03009    }else{
03010       ast_cli(fd,"INFO: RX VOICE GAIN ADJUST SUCCESS.\n");
03011       o->rxvoiceadj=setting;
03012    }
03013    o->pmrChan->b.tuning=0;
03014 }

static void tune_txoutput ( struct chan_usbradio_pvt o,
int  value,
int  fd 
) [static]

Definition at line 2857 of file chan_usbradio.c.

References ast_cli(), chan_usbradio_pvt::name, chan_usbradio_pvt::pmrChan, and chan_usbradio_pvt::txtestkey.

Referenced by radio_tune().

02858 {
02859    o->txtestkey=1;
02860    o->pmrChan->txPttIn=1;
02861    TxTestTone(o->pmrChan, 1);   // generate 1KHz tone at 7200 peak
02862    if (fd > 0) ast_cli(fd,"Tone output starting on channel %s...\n",o->name);
02863    usleep(5000000);
02864    TxTestTone(o->pmrChan, 0);
02865    if (fd > 0) ast_cli(fd,"Tone output ending on channel %s...\n",o->name);
02866    o->pmrChan->txPttIn=0;
02867    o->txtestkey=0;
02868 }

static void tune_write ( struct chan_usbradio_pvt o  )  [static]

Definition at line 3073 of file chan_usbradio.c.

References ast_mutex_lock(), ast_mutex_unlock(), chan_usbradio_pvt::devicenum, chan_usbradio_pvt::devstr, chan_usbradio_pvt::eeprom, EEPROM_RXCTCSSADJ, EEPROM_RXMIXERSET, EEPROM_RXSQUELCHADJ, EEPROM_RXVOICEADJ, EEPROM_TXCTCSSADJ, EEPROM_TXMIXASET, EEPROM_TXMIXBSET, chan_usbradio_pvt::eepromctl, chan_usbradio_pvt::eepromlock, chan_usbradio_pvt::name, chan_usbradio_pvt::rxctcssadj, chan_usbradio_pvt::rxmixerset, chan_usbradio_pvt::rxsquelchadj, chan_usbradio_pvt::rxvoiceadj, chan_usbradio_pvt::txctcssadj, chan_usbradio_pvt::txmixaset, chan_usbradio_pvt::txmixbset, and chan_usbradio_pvt::wanteeprom.

Referenced by radio_tune().

03074 {
03075    FILE *fp;
03076    char fname[200];
03077 
03078    snprintf(fname,sizeof(fname) - 1,"/etc/asterisk/usbradio_tune_%s.conf",o->name);
03079    fp = fopen(fname,"w");
03080 
03081    fprintf(fp,"[%s]\n",o->name);
03082 
03083    fprintf(fp,"; name=%s\n",o->name);
03084    fprintf(fp,"; devicenum=%i\n",o->devicenum);
03085    fprintf(fp,"devstr=%s\n",o->devstr);
03086    fprintf(fp,"rxmixerset=%i\n",o->rxmixerset);
03087    fprintf(fp,"txmixaset=%i\n",o->txmixaset);
03088    fprintf(fp,"txmixbset=%i\n",o->txmixbset);
03089    fprintf(fp,"rxvoiceadj=%f\n",o->rxvoiceadj);
03090    fprintf(fp,"rxctcssadj=%f\n",o->rxctcssadj);
03091    fprintf(fp,"txctcssadj=%i\n",o->txctcssadj);
03092    fprintf(fp,"rxsquelchadj=%i\n",o->rxsquelchadj);
03093    fclose(fp);
03094 
03095    if(o->wanteeprom)
03096    {
03097       ast_mutex_lock(&o->eepromlock);
03098       while(o->eepromctl)
03099       {
03100          ast_mutex_unlock(&o->eepromlock);
03101          usleep(10000);
03102          ast_mutex_lock(&o->eepromlock);
03103       }
03104       o->eeprom[EEPROM_RXMIXERSET] = o->rxmixerset;
03105       o->eeprom[EEPROM_TXMIXASET] = o->txmixaset;
03106       o->eeprom[EEPROM_TXMIXBSET] = o->txmixbset;
03107       memcpy(&o->eeprom[EEPROM_RXVOICEADJ],&o->rxvoiceadj,sizeof(float));
03108       memcpy(&o->eeprom[EEPROM_RXCTCSSADJ],&o->rxctcssadj,sizeof(float));
03109       o->eeprom[EEPROM_TXCTCSSADJ] = o->txctcssadj;
03110       o->eeprom[EEPROM_RXSQUELCHADJ] = o->rxsquelchadj;
03111       o->eepromctl = 2;  /* request a write */
03112       ast_mutex_unlock(&o->eepromlock);
03113    }
03114 }

static int unload_module ( void   )  [static]

Definition at line 3988 of file chan_usbradio.c.

References ast_channel_unregister(), ast_cli_unregister_multiple(), ast_dsp_free(), ast_log(), ast_softhangup(), AST_SOFTHANGUP_APPUNLOAD, cli_usbradio, chan_usbradio_pvt::dsp, frxcapraw, frxcaptrace, frxoutraw, ftxcapraw, ftxcaptrace, ftxoutraw, LOG_WARNING, chan_usbradio_pvt::next, chan_usbradio_pvt::owner, chan_usbradio_pvt::pmrChan, chan_usbradio_pvt::sounddev, usbradio_default, and usbradio_tech.

03989 {
03990    struct chan_usbradio_pvt *o;
03991 
03992    ast_log(LOG_WARNING, "unload_module() called\n");
03993 
03994    ast_channel_unregister(&usbradio_tech);
03995    ast_cli_unregister_multiple(cli_usbradio, sizeof(cli_usbradio) / sizeof(struct ast_cli_entry));
03996 
03997    for (o = usbradio_default.next; o; o = o->next) {
03998 
03999       ast_log(LOG_WARNING, "destroyPmrChannel() called\n");
04000       if(o->pmrChan)destroyPmrChannel(o->pmrChan);
04001       
04002       #if DEBUG_CAPTURES == 1
04003       if (frxcapraw) { fclose(frxcapraw); frxcapraw = NULL; }
04004       if (frxcaptrace) { fclose(frxcaptrace); frxcaptrace = NULL; }
04005       if (frxoutraw) { fclose(frxoutraw); frxoutraw = NULL; }
04006       if (ftxcapraw) { fclose(ftxcapraw); ftxcapraw = NULL; }
04007       if (ftxcaptrace) { fclose(ftxcaptrace); ftxcaptrace = NULL; }
04008       if (ftxoutraw) { fclose(ftxoutraw); ftxoutraw = NULL; }
04009       #endif
04010 
04011       close(o->sounddev);
04012 #ifndef  NEW_ASTERISK
04013       if (o->sndcmd[0] > 0) {
04014          close(o->sndcmd[0]);
04015          close(o->sndcmd[1]);
04016       }
04017 #endif
04018       if (o->dsp) ast_dsp_free(o->dsp);
04019       if (o->owner)
04020          ast_softhangup(o->owner, AST_SOFTHANGUP_APPUNLOAD);
04021       if (o->owner)        /* XXX how ??? */
04022          return -1;
04023       /* XXX what about the thread ? */
04024       /* XXX what about the memory allocated ? */
04025    }
04026    return 0;
04027 }

static int usb_get_usbdev ( char *  devstr  )  [static]

Definition at line 1018 of file chan_usbradio.c.

References str.

Referenced by store_config().

01019 {
01020 int   i;
01021 char  str[200],desdev[200],*cp;
01022 
01023    for(i = 0;i < 32; i++)
01024    {
01025       if (i) sprintf(str,"/sys/class/sound/dsp%d/device",i);
01026       else strcpy(str,"/sys/class/sound/dsp/device");
01027       memset(desdev,0,sizeof(desdev));
01028       if (readlink(str,desdev,sizeof(desdev) - 1) == -1)
01029       {
01030          sprintf(str,"/sys/class/sound/controlC%d/device",i);
01031          memset(desdev,0,sizeof(desdev));
01032          if (readlink(str,desdev,sizeof(desdev) - 1) == -1) continue;
01033       }
01034       cp = strrchr(desdev,'/');
01035       if (cp) *cp = 0; else continue;
01036       cp = strrchr(desdev,'/');
01037       if (!cp) continue;
01038       cp++;
01039       if (!strcasecmp(cp,devstr)) break;
01040    }
01041    if (i >= 32) return -1;
01042    return i;
01043 
01044 }

static int usb_list_check ( char *  devstr  )  [static]

Definition at line 1046 of file chan_usbradio.c.

References s, and usb_device_list.

Referenced by load_module(), and store_config().

01047 {
01048 
01049 char *s = usb_device_list;
01050 
01051    if (!s) return(0);
01052    while(*s)
01053    {
01054       if (!strcasecmp(s,devstr)) return(1);
01055       s += strlen(s) + 1;
01056    }
01057    return(0);
01058 }

static int usbradio_answer ( struct ast_channel c  )  [static]

Definition at line 1711 of file chan_usbradio.c.

References ast_setstate(), AST_STATE_UP, and ast_channel::tech_pvt.

01712 {
01713 #ifndef  NEW_ASTERISK
01714    struct chan_usbradio_pvt *o = c->tech_pvt;
01715 #endif
01716 
01717    ast_setstate(c, AST_STATE_UP);
01718 #ifndef  NEW_ASTERISK
01719    o->cursound = -1;
01720    o->nosound = 0;
01721 #endif
01722    return 0;
01723 }

static int usbradio_call ( struct ast_channel c,
char *  dest,
int  timeout 
) [static]

Definition at line 1697 of file chan_usbradio.c.

References ast_pthread_create_background, ast_setstate(), AST_STATE_UP, hidthread(), chan_usbradio_pvt::hidthread, chan_usbradio_pvt::lasthidtime, chan_usbradio_pvt::stophid, and ast_channel::tech_pvt.

01698 {
01699    struct chan_usbradio_pvt *o = c->tech_pvt;
01700 
01701    o->stophid = 0;
01702    time(&o->lasthidtime);
01703    ast_pthread_create_background(&o->hidthread, NULL, hidthread, o);
01704    ast_setstate(c, AST_STATE_UP);
01705    return 0;
01706 }

static int usbradio_digit_begin ( struct ast_channel c,
char  digit 
) [static]

Definition at line 1618 of file chan_usbradio.c.

01619 {
01620    return 0;
01621 }

static int usbradio_digit_end ( struct ast_channel c,
char  digit,
unsigned int  duration 
) [static]

Definition at line 1623 of file chan_usbradio.c.

References ast_verbose.

01624 {
01625    /* no better use for received digits than print them */
01626    ast_verbose(" << Console Received digit %c of duration %u ms >> \n", 
01627       digit, duration);
01628    return 0;
01629 }

static int usbradio_fixup ( struct ast_channel oldchan,
struct ast_channel newchan 
) [static]

Definition at line 2116 of file chan_usbradio.c.

References ast_log(), LOG_WARNING, chan_usbradio_pvt::owner, and ast_channel::tech_pvt.

02117 {
02118    struct chan_usbradio_pvt *o = newchan->tech_pvt;
02119    ast_log(LOG_WARNING,"usbradio_fixup()\n");
02120    o->owner = newchan;
02121    return 0;
02122 }

static int usbradio_hangup ( struct ast_channel c  )  [static]

Definition at line 1725 of file chan_usbradio.c.

References AST_CONTROL_CONGESTION, ast_module_unref(), chan_usbradio_pvt::autoanswer, chan_usbradio_pvt::autohangup, chan_usbradio_pvt::hidthread, chan_usbradio_pvt::hookstate, O_CLOSE, chan_usbradio_pvt::owner, ring(), setformat(), chan_usbradio_pvt::stophid, and ast_channel::tech_pvt.

01726 {
01727    struct chan_usbradio_pvt *o = c->tech_pvt;
01728 
01729    //ast_log(LOG_NOTICE, "usbradio_hangup()\n");
01730 #ifndef  NEW_ASTERISK
01731    o->cursound = -1;
01732    o->nosound = 0;
01733 #endif
01734    c->tech_pvt = NULL;
01735    o->owner = NULL;
01736    ast_module_unref(ast_module_info->self);
01737    if (o->hookstate) {
01738       if (o->autoanswer || o->autohangup) {
01739          /* Assume auto-hangup too */
01740          o->hookstate = 0;
01741          setformat(o, O_CLOSE);
01742       } else {
01743          /* Make congestion noise */
01744          ring(o, AST_CONTROL_CONGESTION);
01745       }
01746    }
01747    o->stophid = 1;
01748    pthread_join(o->hidthread,NULL);
01749    return 0;
01750 }

static int usbradio_indicate ( struct ast_channel chan,
int  cond,
const void *  data,
size_t  datalen 
) [static]

Definition at line 2124 of file chan_usbradio.c.

References AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_HOLD, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_RADIO_KEY, AST_CONTROL_RADIO_UNKEY, AST_CONTROL_RINGING, AST_CONTROL_UNHOLD, AST_CONTROL_VIDUPDATE, ast_log(), ast_moh_start(), ast_moh_stop(), ast_verbose, chan_usbradio_pvt::debuglevel, LOG_WARNING, chan_usbradio_pvt::mohinterpret, ast_channel::name, ring(), ast_channel::tech_pvt, and chan_usbradio_pvt::txkeyed.

02125 {
02126    struct chan_usbradio_pvt *o = c->tech_pvt;
02127    int res = -1;
02128 
02129    switch (cond) {
02130       case AST_CONTROL_BUSY:
02131       case AST_CONTROL_CONGESTION:
02132       case AST_CONTROL_RINGING:
02133          res = cond;
02134          break;
02135 
02136       case -1:
02137 #ifndef  NEW_ASTERISK
02138          o->cursound = -1;
02139          o->nosound = 0;      /* when cursound is -1 nosound must be 0 */
02140 #endif
02141          return 0;
02142 
02143       case AST_CONTROL_VIDUPDATE:
02144          res = -1;
02145          break;
02146       case AST_CONTROL_HOLD:
02147          ast_verbose(" << Console Has Been Placed on Hold >> \n");
02148          ast_moh_start(c, data, o->mohinterpret);
02149          break;
02150       case AST_CONTROL_UNHOLD:
02151          ast_verbose(" << Console Has Been Retrieved from Hold >> \n");
02152          ast_moh_stop(c);
02153          break;
02154       case AST_CONTROL_PROCEEDING:
02155          ast_verbose(" << Call Proceeding... >> \n");
02156          ast_moh_stop(c);
02157          break;
02158       case AST_CONTROL_PROGRESS:
02159          ast_verbose(" << Call Progress... >> \n");
02160          ast_moh_stop(c);
02161          break;
02162       case AST_CONTROL_RADIO_KEY:
02163          o->txkeyed = 1;
02164          if(o->debuglevel)ast_verbose(" << AST_CONTROL_RADIO_KEY Radio Transmit On. >> \n");
02165          break;
02166       case AST_CONTROL_RADIO_UNKEY:
02167          o->txkeyed = 0;
02168          if(o->debuglevel)ast_verbose(" << AST_CONTROL_RADIO_UNKEY Radio Transmit Off. >> \n");
02169          break;
02170       default:
02171          ast_log(LOG_WARNING, "Don't know how to display condition %d on %s\n", cond, c->name);
02172          return -1;
02173    }
02174 
02175    if (res > -1)
02176       ring(o, res);
02177 
02178    return 0;
02179 }

static struct ast_channel* usbradio_new ( struct chan_usbradio_pvt o,
char *  ext,
char *  ctx,
int  state 
) [static]

Definition at line 2184 of file chan_usbradio.c.

References ast_channel_alloc, AST_FORMAT_SLINEAR, ast_hangup(), ast_jb_configure(), ast_log(), ast_module_ref(), ast_pbx_start(), AST_STATE_DOWN, ast_strdup, ast_string_field_set, ast_strlen_zero(), ast_channel::cid, ast_callerid::cid_ani, ast_callerid::cid_dnid, ast_callerid::cid_name, chan_usbradio_pvt::cid_name, ast_callerid::cid_num, chan_usbradio_pvt::cid_num, ast_channel::fds, global_jbconf, language, chan_usbradio_pvt::language, LOG_WARNING, chan_usbradio_pvt::name, ast_channel::nativeformats, chan_usbradio_pvt::owner, ast_channel::readformat, setformat(), chan_usbradio_pvt::sounddev, ast_channel::tech, ast_channel::tech_pvt, usbradio_tech, and ast_channel::writeformat.

Referenced by usbradio_request().

02185 {
02186    struct ast_channel *c;
02187 
02188    c = ast_channel_alloc(1, state, o->cid_num, o->cid_name, "", ext, ctx, 0, "Radio/%s", o->name);
02189    if (c == NULL)
02190       return NULL;
02191    c->tech = &usbradio_tech;
02192    if (o->sounddev < 0)
02193       setformat(o, O_RDWR);
02194    c->fds[0] = o->sounddev;   /* -1 if device closed, override later */
02195    c->nativeformats = AST_FORMAT_SLINEAR;
02196    c->readformat = AST_FORMAT_SLINEAR;
02197    c->writeformat = AST_FORMAT_SLINEAR;
02198    c->tech_pvt = o;
02199 
02200    if (!ast_strlen_zero(o->language))
02201       ast_string_field_set(c, language, o->language);
02202    /* Don't use ast_set_callerid() here because it will
02203     * generate a needless NewCallerID event */
02204    c->cid.cid_num = ast_strdup(o->cid_num);
02205    c->cid.cid_ani = ast_strdup(o->cid_num);
02206    c->cid.cid_name = ast_strdup(o->cid_name);
02207    if (!ast_strlen_zero(ext))
02208       c->cid.cid_dnid = ast_strdup(ext);
02209 
02210    o->owner = c;
02211    ast_module_ref(ast_module_info->self);
02212    ast_jb_configure(c, &global_jbconf);
02213    if (state != AST_STATE_DOWN) {
02214       if (ast_pbx_start(c)) {
02215          ast_log(LOG_WARNING, "Unable to start PBX on %s\n", c->name);
02216          ast_hangup(c);
02217          o->owner = c = NULL;
02218          /* XXX what about the channel itself ? */
02219          /* XXX what about usecnt ? */
02220       }
02221    }
02222 
02223    return c;
02224 }

static struct ast_frame * usbradio_read ( struct ast_channel chan  )  [static]

Definition at line 1797 of file chan_usbradio.c.

References ast_channel::_state, AST_CONTROL_RADIO_KEY, AST_CONTROL_RADIO_UNKEY, ast_dsp_process(), AST_FORMAT_SLINEAR, AST_FRAME_CONTROL, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, AST_FRAME_NULL, AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_log(), ast_queue_frame(), AST_STATE_UP, chan_usbradio_pvt::b, chan_usbradio_pvt::boost, BOOST_SCALE, CD_HID, CD_HID_INVERT, CD_XPMR_NOISE, CD_XPMR_VOX, ast_frame::data, ast_frame::datalen, chan_usbradio_pvt::debuglevel, chan_usbradio_pvt::dsp, errno, f, ast_frame::frametype, frxcapraw, frxcaptrace, frxoutraw, ftxcaptrace, ftxoutraw, fwrite, kickptt(), chan_usbradio_pvt::lasthidtime, chan_usbradio_pvt::lastrx, LOG_ERROR, LOG_NOTICE, LOG_WARNING, chan_usbradio_pvt::mute, ast_channel::name, chan_usbradio_pvt::name, chan_usbradio_pvt::owner, chan_usbradio_pvt::pmrChan, ast_frame::ptr, chan_usbradio_pvt::radioduplex, chan_usbradio_pvt::read_f, READERR_THRESHOLD, chan_usbradio_pvt::readerrs, chan_usbradio_pvt::readpos, RX_CAP_OUT_FILE, chan_usbradio_pvt::rxcap2, chan_usbradio_pvt::rxcapraw, chan_usbradio_pvt::rxcarrierdetect, chan_usbradio_pvt::rxcdtype, chan_usbradio_pvt::rxctcssdecode, chan_usbradio_pvt::rxctcssfreq, chan_usbradio_pvt::rxdcsdecode, chan_usbradio_pvt::rxhidsq, chan_usbradio_pvt::rxkeyed, chan_usbradio_pvt::rxlsddecode, soundcard_writeframe(), chan_usbradio_pvt::sounddev, ast_frame::subclass, ast_channel::tech_pvt, traceusb2, TX_CAP_OUT_FILE, chan_usbradio_pvt::txcap2, chan_usbradio_pvt::txkeyed, chan_usbradio_pvt::txtestkey, ast_channel_tech::type, chan_usbradio_pvt::usbradio_read_buf, chan_usbradio_pvt::usbradio_read_buf_8k, usbradio_tech, chan_usbradio_pvt::usbradio_write_buf, chan_usbradio_pvt::usbradio_write_buf_1, and chan_usbradio_pvt::usbradio_write_dst.

01798 {
01799    int res, src, datalen, oldpttout;
01800    int cd,sd;
01801    struct chan_usbradio_pvt *o = c->tech_pvt;
01802    struct ast_frame *f = &o->read_f,*f1;
01803    struct ast_frame wf = { AST_FRAME_CONTROL };
01804    time_t now;
01805 
01806    traceusb2(("usbradio_read()\n"));
01807 
01808    if (o->lasthidtime)
01809    {
01810       time(&now);
01811       if ((now - o->lasthidtime) > 3)
01812       {
01813          ast_log(LOG_ERROR,"HID process has died or something!!\n");
01814          return NULL;
01815       }
01816    }
01817    /* XXX can be simplified returning &ast_null_frame */
01818    /* prepare a NULL frame in case we don't have enough data to return */
01819    memset(f, '\0', sizeof(struct ast_frame));
01820    f->frametype = AST_FRAME_NULL;
01821    f->src = usbradio_tech.type;
01822 
01823    res = read(o->sounddev, o->usbradio_read_buf + o->readpos, 
01824       sizeof(o->usbradio_read_buf) - o->readpos);
01825    if (res < 0)            /* audio data not ready, return a NULL frame */
01826    {
01827       if (errno != EAGAIN) return NULL;
01828       if (o->readerrs++ > READERR_THRESHOLD)
01829       {
01830          ast_log(LOG_ERROR,"Stuck USB read channel [%s], un-sticking it!\n",o->name);
01831          o->readerrs = 0;
01832          return NULL;
01833       }
01834       if (o->readerrs == 1) 
01835          ast_log(LOG_WARNING,"Possibly stuck USB read channel. [%s]\n",o->name);
01836       return f;
01837    }
01838    if (o->readerrs) ast_log(LOG_WARNING,"Nope, USB read channel [%s] wasn't stuck after all.\n",o->name);
01839    o->readerrs = 0;
01840    o->readpos += res;
01841    if (o->readpos < sizeof(o->usbradio_read_buf))  /* not enough samples */
01842       return f;
01843 
01844    if (o->mute)
01845       return f;
01846 
01847    #if DEBUG_CAPTURES == 1
01848    if ((o->b.rxcapraw && frxcapraw) && (fwrite((o->usbradio_read_buf + AST_FRIENDLY_OFFSET),1,FRAME_SIZE * 2 * 2 * 6,frxcapraw) != FRAME_SIZE * 2 * 2 * 6)) {
01849       ast_log(LOG_ERROR, "fwrite() failed: %s\n", strerror(errno));
01850    }
01851    #endif
01852 
01853    #if 1
01854    if(o->txkeyed||o->txtestkey)
01855    {
01856       if(!o->pmrChan->txPttIn)
01857       {
01858          o->pmrChan->txPttIn=1;
01859          if(o->debuglevel) ast_log(LOG_NOTICE,"txPttIn = %i, chan %s\n",o->pmrChan->txPttIn,o->owner->name);
01860       }
01861    }
01862    else if(o->pmrChan->txPttIn)
01863    {
01864       o->pmrChan->txPttIn=0;
01865       if(o->debuglevel) ast_log(LOG_NOTICE,"txPttIn = %i, chan %s\n",o->pmrChan->txPttIn,o->owner->name);
01866    }
01867    oldpttout = o->pmrChan->txPttOut;
01868 
01869    PmrRx(         o->pmrChan, 
01870          (i16 *)(o->usbradio_read_buf + AST_FRIENDLY_OFFSET),
01871          (i16 *)(o->usbradio_read_buf_8k + AST_FRIENDLY_OFFSET),
01872          (i16 *)(o->usbradio_write_buf_1));
01873 
01874    if (oldpttout != o->pmrChan->txPttOut)
01875    {
01876       if(o->debuglevel) ast_log(LOG_NOTICE,"txPttOut = %i, chan %s\n",o->pmrChan->txPttOut,o->owner->name);
01877       kickptt(o);
01878    }
01879 
01880    #if 0 // to write 48KS/s stereo tx data to a file
01881    if (!ftxoutraw) ftxoutraw = fopen(TX_CAP_OUT_FILE,"w");
01882    if (ftxoutraw) fwrite(o->usbradio_write_buf_1,1,FRAME_SIZE * 2 * 6,ftxoutraw);
01883    #endif
01884 
01885    #if DEBUG_CAPTURES == 1 && XPMR_DEBUG0 == 1
01886     if ((o->b.txcap2 && ftxcaptrace) && (fwrite((o->pmrChan->ptxDebug),1,FRAME_SIZE * 2 * 16,ftxcaptrace) != FRAME_SIZE * 2 * 16)) {
01887       ast_log(LOG_ERROR, "fwrite() failed: %s\n", strerror(errno));
01888    }
01889    #endif
01890    
01891    // 160 samples * 2 bytes/sample * 2 chan * 6x oversampling to 48KS/s
01892    datalen = FRAME_SIZE * 24;  
01893    src = 0;             /* read position into f->data */
01894    while (src < datalen) 
01895    {
01896       /* Compute spare room in the buffer */
01897       int l = sizeof(o->usbradio_write_buf) - o->usbradio_write_dst;
01898 
01899       if (datalen - src >= l) 
01900       {  
01901          /* enough to fill a frame */
01902          memcpy(o->usbradio_write_buf + o->usbradio_write_dst, o->usbradio_write_buf_1 + src, l);
01903          soundcard_writeframe(o, (short *) o->usbradio_write_buf);
01904          src += l;
01905          o->usbradio_write_dst = 0;
01906       } 
01907       else 
01908       {           
01909          /* copy residue */
01910          l = datalen - src;
01911          memcpy(o->usbradio_write_buf + o->usbradio_write_dst, o->usbradio_write_buf_1 + src, l);
01912          src += l;         /* but really, we are done */
01913          o->usbradio_write_dst += l;
01914       }
01915    }
01916    #else
01917    static FILE *hInput;
01918    i16 iBuff[FRAME_SIZE*2*6];
01919 
01920    o->pmrChan->b.rxCapture=1;
01921 
01922    if(!hInput)
01923    {
01924       hInput  = fopen("/usr/src/xpmr/testdata/rx_in.pcm","r");
01925       if(!hInput)
01926       {
01927          printf(" Input Data File Not Found.\n");
01928          return 0;
01929       }
01930    }
01931 
01932    if(0==fread((void *)iBuff,2,FRAME_SIZE*2*6,hInput))exit;
01933 
01934    PmrRx(  o->pmrChan, 
01935          (i16 *)iBuff,
01936          (i16 *)(o->usbradio_read_buf_8k + AST_FRIENDLY_OFFSET));
01937 
01938    #endif
01939 
01940    #if 0
01941    if (!frxoutraw) frxoutraw = fopen(RX_CAP_OUT_FILE,"w");
01942     if (frxoutraw) fwrite((o->usbradio_read_buf_8k + AST_FRIENDLY_OFFSET),1,FRAME_SIZE * 2,frxoutraw);
01943    #endif
01944 
01945    #if DEBUG_CAPTURES == 1 && XPMR_DEBUG0 == 1
01946     if ((frxcaptrace && o->b.rxcap2 && o->pmrChan->b.radioactive) && (fwrite((o->pmrChan->prxDebug),1,FRAME_SIZE * 2 * 16,frxcaptrace) != FRAME_SIZE * 2 * 16 )) {
01947       ast_log(LOG_ERROR, "fwrite() failed: %s\n", strerror(errno));
01948    }
01949    #endif
01950 
01951    cd = 0;
01952    if(o->rxcdtype==CD_HID && (o->pmrChan->rxExtCarrierDetect!=o->rxhidsq))
01953       o->pmrChan->rxExtCarrierDetect=o->rxhidsq;
01954    
01955    if(o->rxcdtype==CD_HID_INVERT && (o->pmrChan->rxExtCarrierDetect==o->rxhidsq))
01956       o->pmrChan->rxExtCarrierDetect=!o->rxhidsq;
01957       
01958    if( (o->rxcdtype==CD_HID        && o->rxhidsq)                  ||
01959       (o->rxcdtype==CD_HID_INVERT && !o->rxhidsq)                 ||
01960       (o->rxcdtype==CD_XPMR_NOISE && o->pmrChan->rxCarrierDetect) ||
01961       (o->rxcdtype==CD_XPMR_VOX   && o->pmrChan->rxCarrierDetect)
01962      )
01963    {
01964       if (!o->pmrChan->txPttOut || o->radioduplex)cd=1;  
01965    }
01966    else
01967    {
01968       cd=0;
01969    }
01970 
01971    if(cd!=o->rxcarrierdetect)
01972    {
01973       o->rxcarrierdetect=cd;
01974       if(o->debuglevel) ast_log(LOG_NOTICE,"rxcarrierdetect = %i, chan %s\n",cd,o->owner->name);
01975       // printf("rxcarrierdetect = %i, chan %s\n",res,o->owner->name);
01976    }
01977 
01978    if(o->pmrChan->b.ctcssRxEnable && o->pmrChan->rxCtcss->decode!=o->rxctcssdecode)
01979    {
01980       if(o->debuglevel)ast_log(LOG_NOTICE,"rxctcssdecode = %i, chan %s\n",o->pmrChan->rxCtcss->decode,o->owner->name);
01981       // printf("rxctcssdecode = %i, chan %s\n",o->pmrChan->rxCtcss->decode,o->owner->name);
01982       o->rxctcssdecode=o->pmrChan->rxCtcss->decode;
01983       strcpy(o->rxctcssfreq, o->pmrChan->rxctcssfreq);
01984    }
01985 
01986    #ifndef HAVE_XPMRX
01987    if(  !o->pmrChan->b.ctcssRxEnable ||
01988       ( o->pmrChan->b.ctcssRxEnable && 
01989          o->pmrChan->rxCtcss->decode>CTCSS_NULL && 
01990          o->pmrChan->smode==SMODE_CTCSS )  
01991    )
01992    {
01993       sd=1; 
01994    }
01995    else
01996    {
01997       sd=0;
01998    }
01999    #else
02000    if( (!o->pmrChan->b.ctcssRxEnable && !o->pmrChan->b.dcsRxEnable && !o->pmrChan->b.lmrRxEnable) ||
02001       ( o->pmrChan->b.ctcssRxEnable && 
02002          o->pmrChan->rxCtcss->decode>CTCSS_NULL && 
02003          o->pmrChan->smode==SMODE_CTCSS ) ||
02004       ( o->pmrChan->b.dcsRxEnable && 
02005          o->pmrChan->decDcs->decode > 0 &&
02006          o->pmrChan->smode==SMODE_DCS )
02007    )
02008    {
02009       sd=1; 
02010    }
02011    else
02012    {
02013       sd=0;
02014    }
02015 
02016    if(o->pmrChan->decDcs->decode!=o->rxdcsdecode)
02017    {                                      
02018       if(o->debuglevel)ast_log(LOG_NOTICE,"rxdcsdecode = %s, chan %s\n",o->pmrChan->rxctcssfreq,o->owner->name);
02019       // printf("rxctcssdecode = %i, chan %s\n",o->pmrChan->rxCtcss->decode,o->owner->name);
02020       o->rxdcsdecode=o->pmrChan->decDcs->decode;
02021       strcpy(o->rxctcssfreq, o->pmrChan->rxctcssfreq);
02022    }                                                                      
02023 
02024    if(o->pmrChan->rptnum && (o->pmrChan->pLsdCtl->cs[o->pmrChan->rptnum].b.rxkeyed != o->rxlsddecode))
02025    {                       
02026       if(o->debuglevel)ast_log(LOG_NOTICE,"rxLSDecode = %s, chan %s\n",o->pmrChan->rxctcssfreq,o->owner->name);
02027       o->rxlsddecode=o->pmrChan->pLsdCtl->cs[o->pmrChan->rptnum].b.rxkeyed;
02028       strcpy(o->rxctcssfreq, o->pmrChan->rxctcssfreq);
02029    }
02030 
02031    if( (o->pmrChan->rptnum>0 && o->pmrChan->smode==SMODE_LSD && o->pmrChan->pLsdCtl->cs[o->pmrChan->rptnum].b.rxkeyed)||
02032        (o->pmrChan->smode==SMODE_DCS && o->pmrChan->decDcs->decode>0) )
02033    {
02034       sd=1;
02035    }
02036    #endif
02037 
02038    if ( cd && sd )
02039    {
02040       //if(!o->rxkeyed)o->pmrChan->dd.b.doitnow=1;
02041       if(!o->rxkeyed && o->debuglevel)ast_log(LOG_NOTICE,"o->rxkeyed = 1, chan %s\n", o->owner->name);
02042       o->rxkeyed = 1;
02043    }
02044    else 
02045    {
02046       //if(o->rxkeyed)o->pmrChan->dd.b.doitnow=1;
02047       if(o->rxkeyed && o->debuglevel)ast_log(LOG_NOTICE,"o->rxkeyed = 0, chan %s\n",o->owner->name);
02048       o->rxkeyed = 0;
02049    }
02050 
02051    // provide rx signal detect conditions
02052    if (o->lastrx && (!o->rxkeyed))
02053    {
02054       o->lastrx = 0;
02055       //printf("AST_CONTROL_RADIO_UNKEY\n");
02056       wf.subclass = AST_CONTROL_RADIO_UNKEY;
02057       ast_queue_frame(o->owner, &wf);
02058    }
02059    else if ((!o->lastrx) && (o->rxkeyed))
02060    {
02061       o->lastrx = 1;
02062       //printf("AST_CONTROL_RADIO_KEY\n");
02063       wf.subclass = AST_CONTROL_RADIO_KEY;
02064       if(o->rxctcssdecode)    
02065         {
02066            wf.data.ptr = o->rxctcssfreq;
02067            wf.datalen = strlen(o->rxctcssfreq) + 1;
02068          TRACEO(1,("AST_CONTROL_RADIO_KEY text=%s\n",o->rxctcssfreq));
02069         }
02070       ast_queue_frame(o->owner, &wf);
02071    }
02072 
02073    o->readpos = AST_FRIENDLY_OFFSET;   /* reset read pointer for next frame */
02074    if (c->_state != AST_STATE_UP)   /* drop data if frame is not up */
02075       return f;
02076    /* ok we can build and deliver the frame to the caller */
02077    f->frametype = AST_FRAME_VOICE;
02078    f->subclass = AST_FORMAT_SLINEAR;
02079    f->samples = FRAME_SIZE;
02080    f->datalen = FRAME_SIZE * 2;
02081    f->data.ptr = o->usbradio_read_buf_8k + AST_FRIENDLY_OFFSET;
02082    if (o->boost != BOOST_SCALE) {   /* scale and clip values */
02083       int i, x;
02084       int16_t *p = (int16_t *) f->data.ptr;
02085       for (i = 0; i < f->samples; i++) {
02086          x = (p[i] * o->boost) / BOOST_SCALE;
02087          if (x > 32767)
02088             x = 32767;
02089          else if (x < -32768)
02090             x = -32768;
02091          p[i] = x;
02092       }
02093    }
02094 
02095    f->offset = AST_FRIENDLY_OFFSET;
02096    if (o->dsp)
02097    {
02098        f1 = ast_dsp_process(c,o->dsp,f);
02099        if ((f1->frametype == AST_FRAME_DTMF_END) ||
02100          (f1->frametype == AST_FRAME_DTMF_BEGIN))
02101        {
02102       if ((f1->subclass == 'm') || (f1->subclass == 'u'))
02103       {
02104          f1->frametype = AST_FRAME_NULL;
02105          f1->subclass = 0;
02106          return(f1);
02107       }
02108       if (f1->frametype == AST_FRAME_DTMF_END)
02109          ast_log(LOG_NOTICE,"Got DTMF char %c\n",f1->subclass);
02110       return(f1);
02111        }
02112    }
02113    return f;
02114 }

static struct ast_channel * usbradio_request ( const char *  type,
int  format,
void *  data,
int *  cause 
) [static]

Definition at line 2227 of file chan_usbradio.c.

References AST_CAUSE_BUSY, AST_FORMAT_SLINEAR, ast_log(), AST_STATE_DOWN, chan_usbradio_pvt::b, find_desc(), LOG_NOTICE, LOG_WARNING, chan_usbradio_pvt::owner, chan_usbradio_pvt::remoted, usbradio_new(), and xpmr_config().

02228 {
02229    struct ast_channel *c;
02230    struct chan_usbradio_pvt *o = find_desc(data);
02231 
02232    TRACEO(1,("usbradio_request()\n"));
02233 
02234    if (0)
02235    {
02236       ast_log(LOG_WARNING, "usbradio_request type <%s> data 0x%p <%s>\n", type, data, (char *) data);
02237    }
02238    if (o == NULL) {
02239       ast_log(LOG_NOTICE, "Device %s not found\n", (char *) data);
02240       /* XXX we could default to 'dsp' perhaps ? */
02241       return NULL;
02242    }
02243    if ((format & AST_FORMAT_SLINEAR) == 0) {
02244       ast_log(LOG_NOTICE, "Format 0x%x unsupported\n", format);
02245       return NULL;
02246    }
02247    if (o->owner) {
02248       ast_log(LOG_NOTICE, "Already have a call (chan %p) on the usb channel\n", o->owner);
02249       *cause = AST_CAUSE_BUSY;
02250       return NULL;
02251    }
02252    c = usbradio_new(o, NULL, NULL, AST_STATE_DOWN);
02253    if (c == NULL) {
02254       ast_log(LOG_WARNING, "Unable to create new usb channel\n");
02255       return NULL;
02256    }
02257       
02258    o->b.remoted=0;
02259    xpmr_config(o);
02260 
02261    return c;
02262 }

static int usbradio_text ( struct ast_channel c,
const char *  text 
) [static]

Definition at line 1634 of file chan_usbradio.c.

References ast_log(), ast_verbose, chan_usbradio_pvt::b, chan, chan_usbradio_pvt::debuglevel, find_desc(), LOG_ERROR, LOG_NOTICE, chan_usbradio_pvt::pmrChan, chan_usbradio_pvt::remoted, round, chan_usbradio_pvt::set_rxctcssfreqs, chan_usbradio_pvt::set_rxfreq, chan_usbradio_pvt::set_txctcssfreqs, chan_usbradio_pvt::set_txfreq, usbradio_active, and xpmr_config().

01635 {
01636    struct chan_usbradio_pvt *o = find_desc(usbradio_active);
01637    double tx,rx;
01638    char cnt,rxs[16],txs[16],txpl[16],rxpl[16];
01639    char pwr,*cmd;
01640 
01641    cmd = alloca(strlen(text) + 10);
01642 
01643    /* print received messages */
01644    if(o->debuglevel)ast_verbose(" << Console Received usbradio text %s >> \n", text);
01645 
01646    cnt=sscanf(text,"%s %s %s %s %s %c",cmd,rxs,txs,rxpl,txpl,&pwr);
01647 
01648    if (strcmp(cmd,"SETCHAN")==0)
01649     { 
01650       u8 chan;
01651       chan=strtod(rxs,NULL);
01652       ppbinout(chan);
01653         if(o->debuglevel)ast_log(LOG_NOTICE,"parse usbradio SETCHAN cmd: %s chan: %i\n",text,chan);
01654         return 0;
01655     }
01656    
01657     if (cnt < 6)
01658     {
01659        ast_log(LOG_ERROR,"Cannot parse usbradio text: %s\n",text);
01660        return 0;
01661     }
01662    else
01663    {
01664       if(o->debuglevel)ast_verbose(" << %s %s %s %s %s %c >> \n", cmd,rxs,txs,rxpl,txpl,pwr);   
01665    }
01666     
01667     if (strcmp(cmd,"SETFREQ")==0)
01668     {
01669         if(o->debuglevel)ast_log(LOG_NOTICE,"parse usbradio SETFREQ cmd: %s\n",text);
01670       tx=strtod(txs,NULL);
01671       rx=strtod(rxs,NULL);
01672       o->set_txfreq = round(tx * (double)1000000);
01673       o->set_rxfreq = round(rx * (double)1000000);
01674       o->pmrChan->txpower = (pwr == 'H');
01675       strcpy(o->set_rxctcssfreqs,rxpl);
01676       strcpy(o->set_txctcssfreqs,txpl);
01677    
01678       o->b.remoted=1;
01679       xpmr_config(o);
01680         return 0;
01681     }
01682    ast_log(LOG_ERROR,"Cannot parse usbradio cmd: %s\n",text);
01683    return 0;
01684 }

static int usbradio_write ( struct ast_channel chan,
struct ast_frame f 
) [static]

Definition at line 1754 of file chan_usbradio.c.

References ast_log(), chan_usbradio_pvt::b, errno, f, ftxcapraw, fwrite, LOG_ERROR, ast_channel::tech_pvt, traceusb2, chan_usbradio_pvt::txcapraw, and chan_usbradio_pvt::txkeyed.

01755 {
01756    struct chan_usbradio_pvt *o = c->tech_pvt;
01757 
01758    traceusb2(("usbradio_write() o->nosound= %i\n",o->nosound));
01759 
01760 #ifndef  NEW_ASTERISK
01761    /* Immediately return if no sound is enabled */
01762    if (o->nosound)
01763       return 0;
01764    /* Stop any currently playing sound */
01765    o->cursound = -1;
01766 #endif
01767    /*
01768     * we could receive a block which is not a multiple of our
01769     * FRAME_SIZE, so buffer it locally and write to the device
01770     * in FRAME_SIZE chunks.
01771     * Keep the residue stored for future use.
01772     */
01773 
01774    #if DEBUG_CAPTURES == 1 // to write input data to a file   datalen=320
01775    if (ftxcapraw && o->b.txcapraw)
01776    {
01777       i16 i, tbuff[f->datalen];
01778       for(i=0;i<f->datalen;i+=2)
01779       {
01780          tbuff[i]= ((i16*)(f->data.ptr))[i/2];
01781          tbuff[i+1]= o->txkeyed*M_Q13;
01782       }
01783       if (fwrite(tbuff,2,f->datalen,ftxcapraw) != f->datalen) {
01784          ast_log(LOG_ERROR, "write() failed: %s\n", strerror(errno));
01785       }
01786       //fwrite(f->data,1,f->datalen,ftxcapraw);
01787    }
01788    #endif
01789 
01790    // maw just take the data from the network and save it for PmrRx processing
01791 
01792    PmrTx(o->pmrChan,(i16*)f->data.ptr);
01793    
01794    return 0;
01795 }

static int used_blocks ( struct chan_usbradio_pvt o  )  [static]

Definition at line 1328 of file chan_usbradio.c.

References ast_log(), LOG_WARNING, chan_usbradio_pvt::sounddev, chan_usbradio_pvt::total_blocks, WARN_used_blocks, and chan_usbradio_pvt::warned.

01329 {
01330    struct audio_buf_info info;
01331 
01332    if (ioctl(o->sounddev, SNDCTL_DSP_GETOSPACE, &info)) {
01333       if (!(o->warned & WARN_used_blocks)) {
01334          ast_log(LOG_WARNING, "Error reading output space\n");
01335          o->warned |= WARN_used_blocks;
01336       }
01337       return 1;
01338    }
01339 
01340    if (o->total_blocks == 0) {
01341       if (0)               /* debugging */
01342          ast_log(LOG_WARNING, "fragtotal %d size %d avail %d\n", info.fragstotal, info.fragsize, info.fragments);
01343       o->total_blocks = info.fragments;
01344    }
01345 
01346    return o->total_blocks - info.fragments;
01347 }

static void write_eeprom ( struct usb_dev_handle *  handle,
int  addr,
unsigned short  data 
) [static]

Definition at line 835 of file chan_usbradio.c.

References buf, and hid_set_outputs().

Referenced by put_eeprom().

00837 {
00838 
00839    unsigned char buf[4];
00840 
00841    buf[0] = 0x80;
00842    buf[1] = data & 0xff;
00843    buf[2] = data >> 8;
00844    buf[3] = 0xc0 | (addr & 0x3f);
00845    hid_set_outputs(handle,buf);
00846 }

static int xpmr_config ( struct chan_usbradio_pvt o  )  [static]

Definition at line 3361 of file chan_usbradio.c.

References ast_log(), chan_usbradio_pvt::b, LOG_ERROR, chan_usbradio_pvt::pmrChan, chan_usbradio_pvt::remoted, chan_usbradio_pvt::rxctcssfreqs, chan_usbradio_pvt::rxctcssrelax, chan_usbradio_pvt::rxfreq, chan_usbradio_pvt::set_rxctcssfreqs, chan_usbradio_pvt::set_rxfreq, chan_usbradio_pvt::set_txctcssdefault, chan_usbradio_pvt::set_txctcssfreqs, chan_usbradio_pvt::set_txfreq, chan_usbradio_pvt::txctcssdefault, chan_usbradio_pvt::txctcssfreqs, and chan_usbradio_pvt::txfreq.

Referenced by store_config(), usbradio_request(), and usbradio_text().

03362 {
03363    //ast_log(LOG_NOTICE,"xpmr_config()\n");
03364 
03365    TRACEO(1,("xpmr_config()\n"));
03366 
03367    if(o->pmrChan==NULL)
03368    {
03369       ast_log(LOG_ERROR,"pmr channel structure NULL\n");
03370       return 1;
03371    }
03372 
03373    o->pmrChan->rxCtcss->relax = o->rxctcssrelax;
03374    o->pmrChan->txpower=0;
03375 
03376    if(o->b.remoted)
03377    {
03378       o->pmrChan->pTxCodeDefault = o->set_txctcssdefault;
03379       o->pmrChan->pRxCodeSrc=o->set_rxctcssfreqs;
03380       o->pmrChan->pTxCodeSrc=o->set_txctcssfreqs;
03381 
03382       o->pmrChan->rxfreq=o->set_rxfreq;
03383       o->pmrChan->txfreq=o->set_txfreq;
03384       /* printf(" remoted %s %s --> %s \n",o->pmrChan->txctcssdefault,
03385          o->pmrChan->txctcssfreq,o->pmrChan->rxctcssfreq); */
03386    }
03387    else
03388    {
03389       // set xpmr pointers to source strings
03390 
03391       o->pmrChan->pTxCodeDefault = o->txctcssdefault;
03392       o->pmrChan->pRxCodeSrc     = o->rxctcssfreqs;
03393       o->pmrChan->pTxCodeSrc     = o->txctcssfreqs;
03394    
03395       o->pmrChan->rxfreq = o->rxfreq;
03396       o->pmrChan->txfreq = o->txfreq;
03397    }
03398    
03399    code_string_parse(o->pmrChan);
03400    if(o->pmrChan->rxfreq) o->pmrChan->b.reprog=1;
03401 
03402    return 0;
03403 }


Variable Documentation

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "usb Console Channel Driver" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "a9c98e5d177805051735cb5b0b16b0a0" , .load = load_module, .unload = unload_module, } [static]

Definition at line 4029 of file chan_usbradio.c.

char active_usage[] [static]

Initial value:

        "Usage: radio active [device-name]\n"
        "       If used without a parameter, displays which device is the current\n"
        "one being commanded.  If a device is specified, the commanded radio device is changed\n"
        "to the device specified.\n"

Definition at line 2633 of file chan_usbradio.c.

struct ast_module_info* ast_module_info = &__mod_info [static]

Definition at line 4029 of file chan_usbradio.c.

struct ast_cli_entry cli_usbradio[] [static]

Definition at line 3915 of file chan_usbradio.c.

Referenced by load_module(), and unload_module().

const char* config = "usbradio.conf" [static]

Definition at line 356 of file chan_usbradio.c.

struct ast_jb_conf default_jbconf [static]

Global jitterbuffer configuration - by default, jb is disabled

Definition at line 191 of file chan_usbradio.c.

FILE* frxcapraw = NULL [static]

Definition at line 359 of file chan_usbradio.c.

Referenced by radio_tune(), unload_module(), and usbradio_read().

FILE * frxcaptrace = NULL [static]

Definition at line 359 of file chan_usbradio.c.

Referenced by radio_tune(), unload_module(), and usbradio_read().

FILE * frxoutraw = NULL [static]

Definition at line 359 of file chan_usbradio.c.

Referenced by radio_tune(), unload_module(), and usbradio_read().

FILE* ftxcapraw = NULL [static]

Definition at line 360 of file chan_usbradio.c.

Referenced by radio_tune(), unload_module(), and usbradio_write().

FILE * ftxcaptrace = NULL [static]

Definition at line 360 of file chan_usbradio.c.

Referenced by radio_tune(), unload_module(), and usbradio_read().

FILE * ftxoutraw = NULL [static]

Definition at line 360 of file chan_usbradio.c.

Referenced by radio_tune(), unload_module(), and usbradio_read().

struct ast_jb_conf global_jbconf [static]

Definition at line 199 of file chan_usbradio.c.

char key_usage[] [static]

Initial value:

   "Usage: radio key\n"
   "       Simulates COR active.\n"

Definition at line 2625 of file chan_usbradio.c.

char radio_tune_usage[] [static]

Definition at line 2641 of file chan_usbradio.c.

char tdesc[] = "USB (CM108) Radio Channel Driver" [static]

Definition at line 682 of file chan_usbradio.c.

char unkey_usage[] [static]

Initial value:

   "Usage: radio unkey\n"
   "       Simulates COR un-active.\n"

Definition at line 2629 of file chan_usbradio.c.

char* usb_device_list = NULL [static]

Definition at line 362 of file chan_usbradio.c.

Referenced by store_config(), and usb_list_check().

int usb_device_list_size = 0 [static]

Definition at line 363 of file chan_usbradio.c.

char* usbradio_active [static]

Definition at line 660 of file chan_usbradio.c.

Referenced by console_key(), console_unkey(), load_module(), radio_active(), radio_set_debug(), radio_set_debug_off(), radio_set_xpmr_debug(), radio_tune(), store_config(), and usbradio_text().

int usbradio_debug [static]

Definition at line 365 of file chan_usbradio.c.

Referenced by soundcard_writeframe(), and store_config().

struct chan_usbradio_pvt usbradio_default [static]

Definition at line 625 of file chan_usbradio.c.

Referenced by find_desc(), find_desc_usb(), radio_active(), store_config(), and unload_module().

struct ast_channel_tech usbradio_tech [static]

Definition at line 684 of file chan_usbradio.c.

Referenced by load_module(), unload_module(), usbradio_new(), and usbradio_read().


Generated on Wed Aug 18 22:34:19 2010 for Asterisk - the Open Source PBX by  doxygen 1.4.7