res/res_timing_dahdi.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2008, Digium, Inc.
   5  *
   6  * Russell Bryant <russell@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*!
  20  * \file
  21  * \author Russell Bryant <russell@digium.com>
  22  *
  23  * \brief DAHDI timing interface
  24  */
  25
  26 /*** MODULEINFO
  27         <depend>dahdi</depend>
  28  ***/
  29
  30 #include "asterisk.h"
  31
  32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
  33
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <fcntl.h>
  37 #include <math.h>
  38
  39 #include <dahdi/user.h>
  40
  41 #include "asterisk/module.h"
  42 #include "asterisk/timing.h"
  43 #include "asterisk/utils.h"
  44
  45 static void *timing_funcs_handle;
  46
  47 static int dahdi_timer_open(void);
  48 static void dahdi_timer_close(int handle);
  49 static int dahdi_timer_set_rate(int handle, unsigned int rate);
  50 static void dahdi_timer_ack(int handle, unsigned int quantity);
  51 static int dahdi_timer_enable_continuous(int handle);
  52 static int dahdi_timer_disable_continuous(int handle);
  53 static enum ast_timing_event dahdi_timer_get_event(int handle);
  54
  55 static struct ast_timing_functions dahdi_timing_functions = {
  56         .timer_open = dahdi_timer_open,
  57         .timer_close = dahdi_timer_close,
  58         .timer_set_rate = dahdi_timer_set_rate,
  59         .timer_ack = dahdi_timer_ack,
  60         .timer_enable_continuous = dahdi_timer_enable_continuous,
  61         .timer_disable_continuous = dahdi_timer_disable_continuous,
  62         .timer_get_event = dahdi_timer_get_event,
  63 };
  64
  65 static int dahdi_timer_open(void)
  66 {
  67         return open("/dev/dahdi/timer", O_RDWR);
  68 }
  69
  70 static void dahdi_timer_close(int handle)
  71 {
  72         close(handle);
  73 }
  74
  75 static int dahdi_timer_set_rate(int handle, unsigned int rate)
  76 {
  77         int samples;
  78
  79         /* DAHDI timers are configured using a number of samples,
  80          * based on an 8 kHz sample rate. */
  81         samples = (unsigned int) roundf((8000.0 / ((float) rate)));
  82
  83         if (ioctl(handle, DAHDI_TIMERCONFIG, &samples)) {
  84                 ast_log(LOG_ERROR, "Failed to configure DAHDI timing fd for %u sample timer ticks\n",
  85                         samples);
  86                 return -1;
  87         }
  88
  89         return 0;
  90 }
  91
  92 static void dahdi_timer_ack(int handle, unsigned int quantity)
  93 {
  94         ioctl(handle, DAHDI_TIMERACK, &quantity);
  95 }
  96
  97 static int dahdi_timer_enable_continuous(int handle)
  98 {
  99         int flags = 1;
 100
 101         return ioctl(handle, DAHDI_TIMERPING, &flags) ? -1 : 0;
 102 }
 103
 104 static int dahdi_timer_disable_continuous(int handle)
 105 {
 106         int flags = -1;
 107
 108         return ioctl(handle, DAHDI_TIMERPONG, &flags) ? -1 : 0;
 109 }
 110
 111 static enum ast_timing_event dahdi_timer_get_event(int handle)
 112 {
 113         int res;
 114         int event;
 115
 116         res = ioctl(handle, DAHDI_GETEVENT, &event);
 117
 118         if (res) {
 119                 event = DAHDI_EVENT_TIMER_EXPIRED;
 120         }
 121
 122         switch (event) {
 123         case DAHDI_EVENT_TIMER_PING:
 124                 return AST_TIMING_EVENT_CONTINUOUS;
 125         case DAHDI_EVENT_TIMER_EXPIRED:
 126         default:
 127                 return AST_TIMING_EVENT_EXPIRED;
 128         }
 129 }
 130
 131 static int dahdi_test_timer(void)
 132 {
 133         int fd;
 134         int x = 160;
 135
 136         fd = open("/dev/dahdi/timer", O_RDWR);
 137
 138         if (fd < 0) {
 139                 return -1;
 140         }
 141
 142         if (ioctl(fd, DAHDI_TIMERCONFIG, &x)) {
 143                 ast_log(LOG_ERROR, "You have DAHDI built and drivers loaded, but the DAHDI timer test failed to set DAHDI_TIMERCONFIG to %d.\n", x);
 144                 close(fd);
 145                 return -1;
 146         }
 147
 148         if ((x = ast_wait_for_input(fd, 300)) < 0) {
 149                 ast_log(LOG_ERROR, "You have DAHDI built and drivers loaded, but the DAHDI timer could not be polled during the DAHDI timer test.\n");
 150                 close(fd);
 151                 return -1;
 152         }
 153
 154         if (!x) {
 155                 const char dahdi_timer_error[] = {
 156                         "Asterisk has detected a problem with your DAHDI configuration and will shutdown for your protection.  You have options:"
 157                         "\n\t1. You only have to compile DAHDI support into Asterisk if you need it.  One option is to recompile without DAHDI support."
 158                         "\n\t2. You only have to load DAHDI drivers if you want to take advantage of DAHDI services.  One option is to unload DAHDI modules if you don't need them."
 159                         "\n\t3. If you need DAHDI services, you must correctly configure DAHDI."
 160                 };
 161                 ast_log(LOG_ERROR, "%s\n", dahdi_timer_error);
 162                 usleep(100);
 163                 close(fd);
 164                 return -1;
 165         }
 166
 167         close(fd);
 168
 169         return 0;
 170 }
 171
 172 static int load_module(void)
 173 {
 174         if (dahdi_test_timer()) {
 175                 return AST_MODULE_LOAD_DECLINE;
 176         }
 177
 178         return (timing_funcs_handle = ast_install_timing_functions(&dahdi_timing_functions)) ?
 179                 AST_MODULE_LOAD_SUCCESS : AST_MODULE_LOAD_DECLINE;
 180 }
 181
 182 static int unload_module(void)
 183 {
 184         /* ast_uninstall_timing_functions(timing_funcs_handle); */
 185
 186         /* This module can not currently be unloaded.  No use count handling is being done. */
 187
 188         return -1;
 189 }
 190
 191 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "DAHDI Timing Interface");