Changeset 32681


Ignore:
Timestamp:
2012-07-12T15:27:46+02:00 (6 years ago)
Author:
mirko
Message:

[packages/asterisk-1.8.x] upgrade lantiq channel driver to version 553ea59a4cc2d4b963d25ca6c82c0d71311331ac

Location:
packages/net/asterisk-1.8.x
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • packages/net/asterisk-1.8.x/Makefile

    r32354 r32681  
    1414PKG_SOURCE:=asterisk-$(PKG_VERSION).tar.gz 
    1515PKG_SOURCE_URL:=http://downloads.asterisk.org/pub/telephony/asterisk/releases/ 
    16 PKG_MD5SUM:=415738d347b9037cbe5f8bfbe66843de 
     16PKG_MD5SUM:=553ea59a4cc2d4b963d25ca6c82c0d71311331ac 
    1717 
    1818PKG_BUILD_DIR=$(BUILD_DIR)/asterisk-$(PKG_VERSION) 
     
    227227  DEPENDS:= asterisk18 @TARGET_lantiq +TARGET_lantiq:kmod-ltq-vmmc +TARGET_lantiq:kmod-ltq-tapi 
    228228  URL:=http://git.nanl.de/?p=asterisk_channel_lantiq.git 
     229  MAINTAINER:=Mirko Vogt <mirko@openwrt.org> 
    229230endef 
    230231 
  • packages/net/asterisk-1.8.x/src-lantiq/channels/chan_lantiq.c

    r32097 r32681  
    6868#include <asterisk/sched.h> 
    6969 
    70 #include "chan_phone.h" 
    71  
    7270/* Lantiq TAPI includes */ 
    7371#include <drv_tapi/drv_tapi_io.h> 
     
    7775 
    7876#define TAPI_AUDIO_PORT_NUM_MAX                 2 
    79 #define TAPI_TONE_LOCALE_NONE                   0       // for TAPI user defined use 32 
    80 #define TAPI_TONE_LOCALE_BUSY_CODE              27      // for TAPI user defined use 33 
    81 #define TAPI_TONE_LOCALE_CONGESTION_CODE        27      // for TAPI user defined use 34 
    82 #define TAPI_TONE_LOCALE_DIAL_CODE              25      // for TAPI user defined use 35 
    83 #define TAPI_TONE_LOCALE_RING_CODE              36 
     77#define TAPI_TONE_LOCALE_NONE                   0  
     78#define TAPI_TONE_LOCALE_RINGING_CODE           26 
     79#define TAPI_TONE_LOCALE_BUSY_CODE              27 
     80#define TAPI_TONE_LOCALE_CONGESTION_CODE        27 
     81#define TAPI_TONE_LOCALE_DIAL_CODE              25 
    8482#define TAPI_TONE_LOCALE_WAITING_CODE           37 
     83 
     84#define LANTIQ_CONTEXT_PREFIX "lantiq" 
    8585 
    8686static const char config[] = "lantiq.conf"; 
     
    8989static char bbd_filename[PATH_MAX] = "/lib/firmware/ifx_bbd_fxs.bin"; 
    9090static char base_path[PATH_MAX] = "/dev/vmmc"; 
     91static int per_channel_context = 0; 
    9192 
    9293/* 
     
    104105}; 
    105106 
    106 static struct tapi_pvt { 
     107static struct lantiq_pvt { 
    107108        struct ast_channel *owner;         /* Channel we belong to, possibly NULL  */ 
    108109        int port_id;                       /* Port number of this object, 0..n     */ 
    109110        int channel_state; 
    110         char *context;                     /* this port's dialplan context         */ 
     111        char context[AST_MAX_CONTEXT];     /* this port's dialplan context         */ 
    111112        char ext[AST_MAX_EXTENSION+1];     /* the extension this port is connecting*/ 
    112113        int dial_timer;                    /* timer handle for autodial timeout    */ 
     
    117118} *iflist = NULL; 
    118119 
    119 static struct tapi_ctx { 
     120static struct lantiq_ctx { 
    120121                int dev_fd; 
    121122                int channels; 
     
    125126static int ast_digit_begin(struct ast_channel *ast, char digit); 
    126127static int ast_digit_end(struct ast_channel *ast, char digit, unsigned int duration); 
    127 static int ast_phone_call(struct ast_channel *ast, char *dest, int timeout); 
    128 static int ast_phone_hangup(struct ast_channel *ast); 
    129 static int ast_phone_answer(struct ast_channel *ast); 
    130 static struct ast_frame *ast_phone_read(struct ast_channel *ast); 
    131 static int ast_phone_write(struct ast_channel *ast, struct ast_frame *frame); 
    132 static struct ast_frame *ast_phone_exception(struct ast_channel *ast); 
    133 static int ast_phone_indicate(struct ast_channel *chan, int condition, const void *data, size_t datalen); 
    134 static int ast_phone_fixup(struct ast_channel *old, struct ast_channel *new); 
    135 static struct ast_channel *ast_phone_requester(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause); 
    136  
    137 static const struct ast_channel_tech tapi_tech = { 
     128static int ast_lantiq_call(struct ast_channel *ast, char *dest, int timeout); 
     129static int ast_lantiq_hangup(struct ast_channel *ast); 
     130static int ast_lantiq_answer(struct ast_channel *ast); 
     131static struct ast_frame *ast_lantiq_read(struct ast_channel *ast); 
     132static int ast_lantiq_write(struct ast_channel *ast, struct ast_frame *frame); 
     133static struct ast_frame *ast_lantiq_exception(struct ast_channel *ast); 
     134static int ast_lantiq_indicate(struct ast_channel *chan, int condition, const void *data, size_t datalen); 
     135static int ast_lantiq_fixup(struct ast_channel *old, struct ast_channel *new); 
     136static struct ast_channel *ast_lantiq_requester(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause); 
     137 
     138static const struct ast_channel_tech lantiq_tech = { 
    138139        .type = "TAPI", 
    139140        .description = "Lantiq TAPI Telephony API Driver", 
     
    141142        .send_digit_begin = ast_digit_begin, 
    142143        .send_digit_end = ast_digit_end, 
    143         .call = ast_phone_call, 
    144         .hangup = ast_phone_hangup, 
    145         .answer = ast_phone_answer, 
    146         .read = ast_phone_read, 
    147         .write = ast_phone_write, 
    148         .exception = ast_phone_exception, 
    149         .indicate = ast_phone_indicate, 
    150         .fixup = ast_phone_fixup, 
    151         .requester = ast_phone_requester 
     144        .call = ast_lantiq_call, 
     145        .hangup = ast_lantiq_hangup, 
     146        .answer = ast_lantiq_answer, 
     147        .read = ast_lantiq_read, 
     148        .write = ast_lantiq_write, 
     149        .exception = ast_lantiq_exception, 
     150        .indicate = ast_lantiq_indicate, 
     151        .fixup = ast_lantiq_fixup, 
     152        .requester = ast_lantiq_requester 
    152153}; 
    153154 
    154 /* Protect the interface list (of tapi_pvt's) */ 
     155/* Protect the interface list (of lantiq_pvt's) */ 
    155156AST_MUTEX_DEFINE_STATIC(iflock); 
    156157 
     
    193194} rtp_header_t; 
    194195 
    195 static int tapi_dev_open(const char *dev_path, const int32_t ch_num) 
    196 { 
    197         char dev_name[FILENAME_MAX + 1]; 
     196static int lantiq_dev_open(const char *dev_path, const int32_t ch_num) 
     197{ 
     198        char dev_name[PATH_MAX]; 
    198199        memset(dev_name, 0, sizeof(dev_name)); 
    199         snprintf(dev_name, FILENAME_MAX, "%s%u%u", dev_path, 1, ch_num); 
     200        snprintf(dev_name, PATH_MAX, "%s%u%u", dev_path, 1, ch_num); 
    200201        return open((const char*)dev_name, O_RDWR, 0644); 
    201202} 
    202203 
    203 static void tapi_ring(int c, int r) 
     204static void lantiq_ring(int c, int r) 
    204205{ 
    205206        uint8_t status; 
     
    217218} 
    218219 
    219 static int tapi_play_tone(int c, int t) 
    220 { 
     220static int lantiq_play_tone(int c, int t) 
     221{ 
     222        /* stop currently playing tone before starting new one */ 
     223        if (t != TAPI_TONE_LOCALE_NONE) { 
     224                ioctl(dev_ctx.ch_fd[c], IFX_TAPI_TONE_LOCAL_PLAY, TAPI_TONE_LOCALE_NONE); 
     225        } 
     226 
    221227        if (ioctl(dev_ctx.ch_fd[c], IFX_TAPI_TONE_LOCAL_PLAY, t)) { 
    222228                ast_log(LOG_ERROR, "IFX_TAPI_TONE_LOCAL_PLAY ioctl failed\n"); 
     
    227233} 
    228234 
    229 static enum channel_state tapi_get_hookstatus(int port) 
     235static enum channel_state lantiq_get_hookstatus(int port) 
    230236{ 
    231237        uint8_t status; 
     
    244250 
    245251static int 
    246 tapi_dev_binary_buffer_create(const char *path, uint8_t **ppBuf, uint32_t *pBufSz) 
     252lantiq_dev_binary_buffer_create(const char *path, uint8_t **ppBuf, uint32_t *pBufSz) 
    247253{ 
    248254        FILE *fd; 
     
    286292} 
    287293 
    288 static void 
    289 tapi_dev_binary_buffer_delete(uint8_t *pBuf) 
    290 { 
    291         if (pBuf != NULL) 
    292                 free(pBuf); 
    293 } 
    294  
    295 static int32_t 
    296 tapi_dev_firmware_download(int32_t fd, const char *path) 
     294static int32_t lantiq_dev_firmware_download(int32_t fd, const char *path) 
    297295{ 
    298296        uint8_t *firmware = NULL; 
     
    300298        VMMC_IO_INIT vmmc_io_init; 
    301299 
    302         if (tapi_dev_binary_buffer_create(path, &firmware, &size)) { 
    303                 ast_log(LOG_ERROR, "binary buffer create failed!\n"); 
     300        ast_log(LOG_DEBUG, "loading firmware: \"%s\".", path); 
     301 
     302        if (lantiq_dev_binary_buffer_create(path, &firmware, &size)) 
    304303                return -1; 
    305         } 
    306304 
    307305        memset(&vmmc_io_init, 0, sizeof(VMMC_IO_INIT)); 
     
    310308 
    311309        if (ioctl(fd, FIO_FW_DOWNLOAD, &vmmc_io_init)) { 
    312                 ast_log(LOG_ERROR, "FIO_FW_DOWNLOAD ioctl failed!\n"); 
     310                ast_log(LOG_ERROR, "FIO_FW_DOWNLOAD ioctl failed\n"); 
    313311                return -1; 
    314312        } 
    315313 
    316         tapi_dev_binary_buffer_delete(firmware); 
     314        if (firmware != NULL) 
     315                free(firmware); 
    317316 
    318317        return 0; 
     
    361360} 
    362361 
    363 static int ast_phone_indicate(struct ast_channel *chan, int condition, const void *data, size_t datalen) 
    364 { 
    365         ast_verb(3, "TAPI: phone indication \"%s\".\n", control_string(condition)); 
    366         return 0; 
    367 } 
    368  
    369 static int ast_phone_fixup(struct ast_channel *old, struct ast_channel *new) 
    370 { 
    371         ast_debug(1, "TAPI: ast_phone_fixup()\n"); 
     362static int ast_lantiq_indicate(struct ast_channel *chan, int condition, const void *data, size_t datalen) 
     363{ 
     364        ast_verb(3, "phone indication \"%s\"\n", control_string(condition)); 
     365 
     366        struct lantiq_pvt *pvt = chan->tech_pvt; 
     367 
     368        switch (condition) { 
     369                case -1: 
     370                        { 
     371                                lantiq_play_tone(pvt->port_id, TAPI_TONE_LOCALE_NONE); 
     372                                return 0; 
     373                        } 
     374                case AST_CONTROL_CONGESTION: 
     375                case AST_CONTROL_BUSY: 
     376                        { 
     377                                lantiq_play_tone(pvt->port_id, TAPI_TONE_LOCALE_BUSY_CODE); 
     378                                return 0; 
     379                        } 
     380                case AST_CONTROL_RINGING: 
     381                        { 
     382                                lantiq_play_tone(pvt->port_id, TAPI_TONE_LOCALE_RINGING_CODE); 
     383                                return 0; 
     384                        } 
     385                default: 
     386                        { 
     387                                /* -1 lets asterisk generate the tone */ 
     388                                return -1; 
     389                        } 
     390        } 
     391} 
     392 
     393static int ast_lantiq_fixup(struct ast_channel *old, struct ast_channel *new) 
     394{ 
     395        ast_log(LOG_DEBUG, "entering... no code here...\n"); 
    372396        return 0; 
    373397} 
     
    376400{ 
    377401        /* TODO: Modify this callback to let Asterisk support controlling the length of DTMF */ 
    378         ast_debug(1, "TAPI: ast_digit_begin()\n"); 
     402        ast_log(LOG_DEBUG, "entering... no code here...\n"); 
    379403        return 0; 
    380404} 
     
    382406static int ast_digit_end(struct ast_channel *ast, char digit, unsigned int duration) 
    383407{ 
    384         ast_debug(1, "TAPI: ast_digit_end()\n"); 
    385         return 0; 
    386 } 
    387  
    388 static int ast_phone_call(struct ast_channel *ast, char *dest, int timeout) 
    389 { 
    390         ast_debug(1, "TAPI: ast_phone_call()\n"); 
    391  
     408        ast_log(LOG_DEBUG, "entering... no code here...\n"); 
     409        return 0; 
     410} 
     411 
     412static int ast_lantiq_call(struct ast_channel *ast, char *dest, int timeout) 
     413{ 
     414        /* lock to prevent simultaneous access with do_monitor thread processing */ 
    392415        ast_mutex_lock(&iflock); 
    393          
    394         struct tapi_pvt *pvt = ast->tech_pvt; 
    395          
    396         ast_debug(1, "TAPI: ast_phone_call() state: %s\n", state_string(pvt->channel_state)); 
     416 
     417        struct lantiq_pvt *pvt = ast->tech_pvt; 
     418        ast_log(LOG_DEBUG, "state: %s\n", state_string(pvt->channel_state)); 
    397419 
    398420        if (pvt->channel_state == ONHOOK) { 
    399                 ast_debug(1, "TAPI: ast_phone_call(): port %i ringing.\n", pvt->port_id); 
    400                 tapi_ring(pvt->port_id, 1); 
     421                ast_log(LOG_DEBUG, "port %i is ringing\n", pvt->port_id); 
     422                lantiq_ring(pvt->port_id, 1); 
    401423                pvt->channel_state = RINGING; 
    402424 
     
    404426                ast_queue_control(ast, AST_CONTROL_RINGING); 
    405427        } else { 
    406                 ast_debug(1, "TAPI: ast_phone_call(): port %i busy.\n", pvt->port_id); 
     428                ast_log(LOG_DEBUG, "port %i is busy\n", pvt->port_id); 
    407429                ast_setstate(ast, AST_STATE_BUSY); 
    408430                ast_queue_control(ast, AST_CONTROL_BUSY); 
     
    414436} 
    415437 
    416 static int ast_phone_hangup(struct ast_channel *ast) 
    417 { 
    418         ast_debug(1, "TAPI: ast_phone_hangup()\n"); 
    419  
    420         struct tapi_pvt *pvt = ast->tech_pvt; 
    421  
     438static int ast_lantiq_hangup(struct ast_channel *ast) 
     439{ 
    422440        /* lock to prevent simultaneous access with do_monitor thread processing */ 
    423441        ast_mutex_lock(&iflock); 
     442 
     443        struct lantiq_pvt *pvt = ast->tech_pvt; 
     444        ast_log(LOG_DEBUG, "state: %s\n", state_string(pvt->channel_state)); 
    424445         
    425446        if (ast->_state == AST_STATE_RINGING) { 
    426                 ast_debug(1, "TAPI: ast_phone_hangup(): ast->_state == AST_STATE_RINGING\n"); 
     447                // FIXME 
     448                ast_debug(1, "TAPI: ast_lantiq_hangup(): ast->_state == AST_STATE_RINGING\n"); 
    427449        } 
    428450 
     
    430452                case RINGING: 
    431453                case ONHOOK:  
    432                         { 
    433                                 tapi_ring(pvt->port_id, 0); 
    434                                 pvt->channel_state = ONHOOK; 
    435                                 break; 
    436                         } 
     454                        lantiq_ring(pvt->port_id, 0); 
     455                        pvt->channel_state = ONHOOK; 
     456                        break; 
    437457                default: 
    438                         { 
    439                                 ast_debug(1, "TAPI: ast_phone_hangup(): we were hung up, play busy tone.\n"); 
    440                                 pvt->channel_state = CALL_ENDED; 
    441                                 tapi_play_tone(pvt->port_id, TAPI_TONE_LOCALE_BUSY_CODE); 
    442                         } 
     458                        ast_log(LOG_DEBUG, "we were hung up, play busy tone\n"); 
     459                        pvt->channel_state = CALL_ENDED; 
     460                        lantiq_play_tone(pvt->port_id, TAPI_TONE_LOCALE_BUSY_CODE); 
    443461        } 
    444462 
     
    453471} 
    454472 
    455 static int ast_phone_answer(struct ast_channel *ast) 
    456 { 
    457         ast_debug(1, "TAPI: ast_phone_answer()\n"); 
    458         return 0; 
    459 } 
    460  
    461 static struct ast_frame * ast_phone_read(struct ast_channel *ast) 
    462 { 
    463         ast_debug(1, "TAPI: ast_phone_read()\n"); 
     473static int ast_lantiq_answer(struct ast_channel *ast) 
     474{ 
     475        ast_log(LOG_DEBUG, "entering... no code here...\n"); 
     476        return 0; 
     477} 
     478 
     479static struct ast_frame * ast_lantiq_read(struct ast_channel *ast) 
     480{ 
     481        ast_log(LOG_DEBUG, "entering... no code here...\n"); 
    464482        return NULL; 
    465483} 
    466484 
    467 static int ast_phone_write(struct ast_channel *ast, struct ast_frame *frame) 
    468 { 
    469         ast_debug(1, "TAPI: ast_phone_write()\n"); 
    470  
     485static int ast_lantiq_write(struct ast_channel *ast, struct ast_frame *frame) 
     486{ 
    471487        char buf[2048]; 
    472         struct tapi_pvt *pvt = ast->tech_pvt; 
     488        struct lantiq_pvt *pvt = ast->tech_pvt; 
    473489        int ret = -1; 
    474490        rtp_header_t *rtp_header = (rtp_header_t *) buf; 
    475491 
    476492        if(frame->frametype != AST_FRAME_VOICE) { 
    477                 ast_debug(1, "TAPI: ast_phone_write(): unhandled frame type.\n"); 
     493                ast_log(LOG_DEBUG, "unhandled frame type\n"); 
    478494                return 0; 
    479495        } 
    480  
    481         memset(buf, '\0', sizeof(rtp_header_t)); 
     496         
     497        if (frame->datalen == 0) { 
     498                ast_log(LOG_DEBUG, "we've been prodded\n"); 
     499                return 0; 
     500        } 
     501 
     502        memset(buf, 0, sizeof(rtp_header_t)); 
    482503        rtp_header->version      = 2; 
    483504        rtp_header->padding      = 0; 
     
    496517        ret = write(dev_ctx.ch_fd[pvt->port_id], buf, frame->datalen+RTP_HEADER_LEN); 
    497518        if (ret <= 0) { 
    498                 ast_debug(1, "TAPI: ast_phone_write(): error writing.\n"); 
     519                ast_debug(1, "TAPI: ast_lantiq_write(): error writing.\n"); 
    499520                return -1; 
    500521        } 
    501522 
    502523#ifdef TODO_DEVEL_INFO 
    503         ast_debug(1, "ast_phone_write(): size: %i version: %i padding: %i extension: %i csrc_count: %i\n" 
     524        ast_debug(1, "ast_lantiq_write(): size: %i version: %i padding: %i extension: %i csrc_count: %i\n" 
    504525                 "marker: %i payload_type: %s seqno: %i timestamp: %i ssrc: %i\n",  
    505526                         (int)ret, 
     
    518539} 
    519540 
    520 static struct ast_frame * ast_phone_exception(struct ast_channel *ast) 
    521 { 
    522         ast_debug(1, "TAPI: ast_phone_exception()\n"); 
     541static struct ast_frame * ast_lantiq_exception(struct ast_channel *ast) 
     542{ 
     543        ast_log(LOG_DEBUG, "entering... no code here...\n"); 
    523544        return NULL; 
    524545} 
    525546 
    526 static int tapi_standby(int c) 
     547static int lantiq_standby(int c) 
    527548{ 
    528549        if (ioctl(dev_ctx.ch_fd[c], IFX_TAPI_LINE_FEED_SET, IFX_TAPI_LINE_FEED_STANDBY)) { 
     
    541562        } 
    542563 
    543         return tapi_play_tone(c, TAPI_TONE_LOCALE_NONE); 
    544 } 
    545  
    546 static int tapi_end_dialing(int c) 
    547 { 
    548         ast_debug(1, "%s\n", __FUNCTION__); 
    549         struct tapi_pvt *pvt = &iflist[c]; 
     564        return lantiq_play_tone(c, TAPI_TONE_LOCALE_NONE); 
     565} 
     566 
     567static int lantiq_end_dialing(int c) 
     568{ 
     569        ast_log(LOG_DEBUG, "TODO - DEBUG MSG"); 
     570        struct lantiq_pvt *pvt = &iflist[c]; 
    550571 
    551572        if (pvt->dial_timer) { 
     
    561582} 
    562583 
    563 static int tapi_end_call(int c) 
    564 { 
    565         ast_debug(1, "%s\n", __FUNCTION__); 
    566  
    567         struct tapi_pvt *pvt = &iflist[c]; 
     584static int lantiq_end_call(int c) 
     585{ 
     586        ast_log(LOG_DEBUG, "TODO - DEBUG MSG"); 
     587 
     588        struct lantiq_pvt *pvt = &iflist[c]; 
    568589         
    569590        if(pvt->owner) { 
     
    574595} 
    575596 
    576 static struct ast_channel * tapi_channel(int state, int c, char *ext, char *ctx) 
    577 { 
    578         ast_debug(1, "tapi_channel()\n"); 
     597static struct ast_channel * lantiq_channel(int state, int c, char *ext, char *ctx) 
     598{ 
     599        ast_log(LOG_DEBUG, "TODO - DEBUG MSG"); 
    579600 
    580601        struct ast_channel *chan = NULL; 
    581602 
    582         struct tapi_pvt *pvt = &iflist[c]; 
     603        struct lantiq_pvt *pvt = &iflist[c]; 
    583604 
    584605        chan = ast_channel_alloc(1, state, NULL, NULL, "", ext, ctx, 0, c, "TAPI/%s", "1"); 
    585606 
    586         chan->tech = &tapi_tech; 
     607        chan->tech = &lantiq_tech; 
    587608        chan->nativeformats = AST_FORMAT_ULAW; 
    588609        chan->readformat  = AST_FORMAT_ULAW; 
     
    595616} 
    596617 
    597 static struct ast_channel * ast_phone_requester(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause) 
    598 { 
     618static struct ast_channel * ast_lantiq_requester(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause) 
     619{ 
     620        ast_mutex_lock(&iflock); 
     621 
    599622        char buf[BUFSIZ]; 
    600          
    601623        struct ast_channel *chan = NULL; 
    602624        int port_id = -1; 
     
    604626        ast_debug(1, "Asked to create a TAPI channel with formats: %s\n", ast_getformatname_multiple(buf, sizeof(buf), format)); 
    605627 
    606         if (ast_mutex_lock(&iflock)) { 
    607                 ast_log(LOG_WARNING, "Unable to lock the monitor\n"); 
    608                 return NULL; 
    609         } 
    610628 
    611629        /* check for correct data argument */ 
     
    630648        port_id -= 1; 
    631649 
    632         chan = tapi_channel(AST_STATE_DOWN, port_id, NULL, NULL); 
     650        chan = lantiq_channel(AST_STATE_DOWN, port_id, NULL, NULL); 
    633651 
    634652        ast_mutex_unlock(&iflock); 
     
    636654} 
    637655 
    638 static int tapi_dev_data_handler(int c) { 
     656static int lantiq_dev_data_handler(int c) 
     657{ 
    639658        char buf[BUFSIZ]; 
    640659        struct ast_frame frame = {0}; 
    641660 
    642661        int res = read(dev_ctx.ch_fd[c], buf, sizeof(buf)); 
    643         if (res <= 0) ast_debug(1, "%s: Read error: %i.\n", __FUNCTION__, res); 
     662        if (res <= 0) ast_log(LOG_ERROR, "we got read error %i\n", res); 
    644663         
    645664        rtp_header_t *rtp = (rtp_header_t*) buf; 
     
    653672 
    654673        ast_mutex_lock(&iflock); 
    655         struct tapi_pvt *pvt = (struct tapi_pvt *) &iflist[c]; 
     674        struct lantiq_pvt *pvt = (struct lantiq_pvt *) &iflist[c]; 
    656675        if (pvt->owner && (pvt->owner->_state == AST_STATE_UP)) { 
    657676                if(!ast_channel_trylock(pvt->owner)) { 
     
    663682        ast_mutex_unlock(&iflock); 
    664683 
    665 /*      ast_debug(1, "tapi_dev_data_handler(): size: %i version: %i padding: %i extension: %i csrc_count: %i \n" 
     684/*      ast_debug(1, "lantiq_dev_data_handler(): size: %i version: %i padding: %i extension: %i csrc_count: %i \n" 
    666685                                 "marker: %i payload_type: %s seqno: %i timestamp: %i ssrc: %i\n",  
    667686                                 (int)res, 
     
    680699 
    681700static int accept_call(int c) 
    682 { 
    683         ast_debug(1, "%s: line %i\n", __FUNCTION__, __LINE__); 
    684  
    685         struct tapi_pvt *pvt = &iflist[c]; 
     701{  
     702        ast_log(LOG_DEBUG, "TODO - DEBUG MSG"); 
     703 
     704        struct lantiq_pvt *pvt = &iflist[c]; 
    686705 
    687706        if (pvt->owner) { 
     
    690709                switch (chan->_state) { 
    691710                        case AST_STATE_RINGING: 
    692                                 { 
    693                                         ast_queue_control(pvt->owner, AST_CONTROL_ANSWER); 
    694                                         pvt->channel_state = INCALL; 
    695                                         break; 
    696                                 } 
     711                                ast_queue_control(pvt->owner, AST_CONTROL_ANSWER); 
     712                                pvt->channel_state = INCALL; 
     713                                break; 
    697714                        default: 
    698                                 { 
    699                                         ast_debug(1, "%s: line %i: unhandled state %s.\n", __FUNCTION__, __LINE__, ast_state2str(chan->_state)); 
    700                                 } 
    701                 } 
    702         } 
    703  
    704         return 0; 
    705 } 
    706  
    707 static int tapi_dev_event_hook(int c, int state) 
    708 { 
    709         ast_log(LOG_ERROR, "TAPI: channel %i %s hook.\n", c, state ? "on" : "off"); 
    710  
    711         if (ast_mutex_lock(&iflock)) { 
    712                 ast_log(LOG_WARNING, "Unable to lock the monitor\n"); 
    713                 return -1; 
    714         } 
     715                                ast_log(LOG_WARNING, "entered unhandled state %s\n", ast_state2str(chan->_state)); 
     716                } 
     717        } 
     718 
     719        return 0; 
     720} 
     721 
     722static int lantiq_dev_event_hook(int c, int state) 
     723{ 
     724        ast_mutex_lock(&iflock); 
     725 
     726        ast_log(LOG_DEBUG, "on port %i detected event %s hook\n", c, state ? "on" : "off"); 
    715727 
    716728        int ret = -1; 
     
    718730                switch (iflist[c].channel_state) { 
    719731                        case OFFHOOK:  
    720                                 ret = tapi_standby(c); 
     732                                ret = lantiq_standby(c); 
    721733                                break; 
    722734                        case DIALING:  
    723                                 ret = tapi_end_dialing(c); 
     735                                ret = lantiq_end_dialing(c); 
    724736                                break; 
    725737                        case INCALL:  
    726                                 ret = tapi_end_call(c); 
     738                                ret = lantiq_end_call(c); 
    727739                                break; 
    728740                        case CALL_ENDED: 
    729                                 ret = tapi_standby(c); // TODO: are we sure for this ? 
     741                                ret = lantiq_standby(c); // TODO: are we sure for this ? 
    730742                                break; 
    731743                        default: 
     
    755767                        default: 
    756768                                iflist[c].channel_state = OFFHOOK; 
    757                                 tapi_play_tone(c, TAPI_TONE_LOCALE_DIAL_CODE); 
     769                                lantiq_play_tone(c, TAPI_TONE_LOCALE_DIAL_CODE); 
    758770                                ret = 0; 
    759771                                break; 
     
    768780} 
    769781 
    770 static void tapi_reset_dtmfbuf(struct tapi_pvt *pvt) 
     782static void lantiq_reset_dtmfbuf(struct lantiq_pvt *pvt) 
    771783{ 
    772784        pvt->dtmfbuf[0] = '\0'; 
     
    775787} 
    776788 
    777 static void tapi_dial(struct tapi_pvt *pvt) 
    778 { 
    779         ast_debug(1, "TAPI: tapi_dial()\n"); 
    780  
     789static void lantiq_dial(struct lantiq_pvt *pvt) 
     790{ 
    781791        struct ast_channel *chan = NULL; 
    782792 
    783         ast_debug(1, "TAPI: tapi_dial(): user want's to dial %s.\n", pvt->dtmfbuf); 
     793        ast_log(LOG_DEBUG, "user want's to dial %s.\n", pvt->dtmfbuf); 
    784794 
    785795        if (ast_exists_extension(NULL, pvt->context, pvt->dtmfbuf, 1, NULL)) { 
    786                 ast_debug(1, "TAPI: tapi_dial(): Asterisk knows extension %s, dialing.\n", pvt->dtmfbuf); 
     796                ast_debug(1, "found extension %s, dialing\n", pvt->dtmfbuf); 
    787797 
    788798                strcpy(pvt->ext, pvt->dtmfbuf); 
    789799 
    790                 ast_verbose( VERBOSE_PREFIX_3 " extension exists, starting PBX %s\n", pvt->ext); 
    791  
    792                 chan = tapi_channel(1, AST_STATE_UP, pvt->ext+1, pvt->context); 
     800                ast_verbose(VERBOSE_PREFIX_3 " extension exists, starting PBX %s\n", pvt->ext); 
     801 
     802                chan = lantiq_channel(AST_STATE_UP, 1, pvt->ext+1, pvt->context); 
    793803                chan->tech_pvt = pvt; 
    794804                pvt->owner = chan; 
     
    799809 
    800810                if (ast_pbx_start(chan)) { 
    801                         ast_log(LOG_WARNING, "  Unable to start PBX on %s\n", chan->name); 
     811                        ast_log(LOG_WARNING, " unable to start PBX on %s\n", chan->name); 
    802812                        ast_hangup(chan); 
    803813                } 
    804         } 
    805         else { 
    806                 ast_debug(1, "TAPI: tapi_dial(): no extension found.\n"); 
    807  
    808                 tapi_play_tone(pvt->port_id, TAPI_TONE_LOCALE_BUSY_CODE); 
     814        } else { 
     815                ast_log(LOG_DEBUG, "no extension found\n"); 
     816                lantiq_play_tone(pvt->port_id, TAPI_TONE_LOCALE_BUSY_CODE); 
    809817                pvt->channel_state = CALL_ENDED; 
    810818        } 
    811819         
    812         tapi_reset_dtmfbuf(pvt); 
    813 } 
    814  
    815 static int tapi_event_dial_timeout(const void* data) 
    816 { 
    817         ast_debug(1, "TAPI: tapi_event_dial_timeout()\n"); 
    818  
    819         struct tapi_pvt *pvt = (struct tapi_pvt *) data; 
     820        lantiq_reset_dtmfbuf(pvt); 
     821} 
     822 
     823static int lantiq_event_dial_timeout(const void* data) 
     824{ 
     825        ast_debug(1, "TAPI: lantiq_event_dial_timeout()\n"); 
     826 
     827        struct lantiq_pvt *pvt = (struct lantiq_pvt *) data; 
    820828        pvt->dial_timer = 0; 
    821829 
    822830        if (! pvt->channel_state == ONHOOK) { 
    823                 tapi_dial(pvt); 
     831                lantiq_dial(pvt); 
    824832        } else { 
    825                 ast_debug(1, "TAPI: tapi_event_dial_timeout(): dial timeout in state ONHOOK.\n"); 
    826         } 
    827  
    828         return 0; 
    829 } 
    830  
    831  
    832 static void tapi_dev_event_digit(int c, char digit) 
    833 { 
    834         ast_debug(1, "TAPI: tapi_event_digit() port=%i digit=%c\n", port, digit); 
    835         if (ast_mutex_lock(&iflock)) { 
    836                 ast_log(LOG_WARNING, "Unable to lock the monitor\n"); 
    837                 return; 
    838         } 
    839  
    840         struct tapi_pvt *pvt = &iflist[c]; 
     833                ast_debug(1, "TAPI: lantiq_event_dial_timeout(): dial timeout in state ONHOOK.\n"); 
     834        } 
     835 
     836        return 0; 
     837} 
     838 
     839static int lantiq_send_digit(int c, char digit)  
     840{ 
     841        struct lantiq_pvt *pvt = &iflist[c]; 
     842 
     843        struct ast_frame f = { .frametype = AST_FRAME_DTMF, .subclass.integer = digit }; 
     844 
     845        if (pvt->owner) { 
     846                ast_log(LOG_DEBUG, "Port %i transmitting digit \"%c\"\n", c, digit); 
     847                return ast_queue_frame(pvt->owner, &f); 
     848        } else { 
     849                ast_debug(1, "Warning: lantiq_send_digit() without owner!\n"); 
     850                return -1; 
     851        } 
     852} 
     853 
     854static void lantiq_dev_event_digit(int c, char digit) 
     855{ 
     856        ast_mutex_lock(&iflock); 
     857 
     858        ast_log(LOG_DEBUG, "on port %i detected digit \"%c\"\n", c, digit); 
     859 
     860        struct lantiq_pvt *pvt = &iflist[c]; 
    841861 
    842862        switch (pvt->channel_state) { 
     863                case INCALL: 
     864                        { 
     865                                lantiq_send_digit(c, digit); 
     866                                break; 
     867                        } 
    843868                case OFFHOOK:   
    844869                        pvt->channel_state = DIALING; 
    845870 
    846                         tapi_play_tone(c, TAPI_TONE_LOCALE_NONE); 
     871                        lantiq_play_tone(c, TAPI_TONE_LOCALE_NONE); 
    847872 
    848873                        /* fall through */ 
     
    854879                                } 
    855880 
    856                                 tapi_dial(pvt); 
     881                                lantiq_dial(pvt); 
    857882                        } else { 
    858883                                pvt->dtmfbuf[pvt->dtmfbuf_len] = digit; 
     
    862887                                /* setup autodial timer */ 
    863888                                if (!pvt->dial_timer) { 
    864                                         ast_debug(1, "TAPI: tapi_dev_event_digit() setting new timer.\n"); 
    865                                         pvt->dial_timer = ast_sched_thread_add(sched_thread, 2000, tapi_event_dial_timeout, (const void*) pvt); 
     889                                        ast_log(LOG_DEBUG, "setting new timer\n"); 
     890                                        pvt->dial_timer = ast_sched_thread_add(sched_thread, 2000, lantiq_event_dial_timeout, (const void*) pvt); 
    866891                                } else { 
    867                                         ast_debug(1, "TAPI: tapi_dev_event_digit() replacing timer.\n"); 
     892                                        ast_log(LOG_DEBUG, "replacing timer\n"); 
    868893                                        struct sched_context *sched = ast_sched_thread_get_context(sched_thread); 
    869                                         AST_SCHED_REPLACE(pvt->dial_timer, sched, 2000, tapi_event_dial_timeout, (const void*) pvt); 
     894                                        AST_SCHED_REPLACE(pvt->dial_timer, sched, 2000, lantiq_event_dial_timeout, (const void*) pvt); 
    870895                                } 
    871896                        } 
    872897                        break; 
    873898                default: 
    874                         ast_debug(1, "TAPI: tapi_dev_event_digit() unhandled state.\n"); 
     899                        ast_log(LOG_ERROR, "don't know what to do in unhandled state\n"); 
    875900                        break; 
    876901        } 
     
    880905} 
    881906 
    882 static void tapi_dev_event_handler(void) 
     907static void lantiq_dev_event_handler(void) 
    883908{ 
    884909        IFX_TAPI_EVENT_t event; 
     
    886911 
    887912        for (i = 0; i < dev_ctx.channels ; i++) { 
    888                 if (ast_mutex_lock(&iflock)) { 
    889                         ast_log(LOG_WARNING, "Unable to lock the monitor\n"); 
    890                         break; 
    891                 } 
     913                ast_mutex_lock(&iflock); 
    892914 
    893915                memset (&event, 0, sizeof(event)); 
    894916                event.ch = i; 
    895                 if (ioctl(dev_ctx.dev_fd, IFX_TAPI_EVENT_GET, &event)) 
     917                if (ioctl(dev_ctx.dev_fd, IFX_TAPI_EVENT_GET, &event)) { 
     918                        ast_mutex_unlock(&iflock); 
    896919                        continue; 
    897                 if (event.id == IFX_TAPI_EVENT_NONE) 
     920                } 
     921                if (event.id == IFX_TAPI_EVENT_NONE) { 
     922                        ast_mutex_unlock(&iflock); 
    898923                        continue; 
     924                } 
     925 
    899926                ast_mutex_unlock(&iflock); 
    900927 
    901928                switch(event.id) { 
    902929                        case IFX_TAPI_EVENT_FXS_ONHOOK: 
    903                                 tapi_dev_event_hook(i, 1); 
     930                                lantiq_dev_event_hook(i, 1); 
    904931                                break; 
    905932                        case IFX_TAPI_EVENT_FXS_OFFHOOK: 
    906                                 tapi_dev_event_hook(i, 0); 
     933                                lantiq_dev_event_hook(i, 0); 
    907934                                break; 
    908935                        case IFX_TAPI_EVENT_DTMF_DIGIT: 
    909                                 ast_log(LOG_ERROR, "ON CHANNEL %d DETECTED DTMF DIGIT: %c\n", i, (char)event.data.dtmf.ascii); 
    910                                 tapi_dev_event_digit(i, (char)event.data.dtmf.ascii); 
     936                                lantiq_dev_event_digit(i, (char)event.data.dtmf.ascii); 
    911937                                break; 
    912938                        case IFX_TAPI_EVENT_PULSE_DIGIT: 
    913939                                if (event.data.pulse.digit == 0xB) { 
    914                                         ast_log(LOG_ERROR, "ON CHANNEL %d DETECTED PULSE DIGIT: %c\n", i, '0'); 
    915                                         tapi_dev_event_digit(i, '0'); 
     940                                        lantiq_dev_event_digit(i, '0'); 
    916941                                } else { 
    917                                         ast_log(LOG_ERROR, "ON CHANNEL %d DETECTED PULSE DIGIT: %c\n", i, '0' + (char)event.data.pulse.digit); 
    918                                         tapi_dev_event_digit(i, '0' + (char)event.data.pulse.digit); 
     942                                        lantiq_dev_event_digit(i, '0' + (char)event.data.pulse.digit); 
    919943                                } 
    920944                                break; 
     
    924948                                break; 
    925949                        default: 
    926                                 ast_log(LOG_ERROR, "Unable TAPI event %08X\n", event.id); 
     950                                ast_log(LOG_ERROR, "unknown TAPI event %08X\n", event.id); 
    927951                                break; 
    928952                } 
     
    930954} 
    931955 
    932 static void * 
    933 tapi_events_monitor(void *data) 
     956static void * lantiq_events_monitor(void *data) 
    934957{ 
    935958        ast_verbose("TAPI thread started\n"); 
     
    945968 
    946969        while (monitor) { 
    947                 if (ast_mutex_lock(&monlock)) { 
    948                         ast_log(LOG_WARNING, "Unable to lock the monitor\n"); 
    949                         break; 
    950                 } 
     970                ast_mutex_lock(&monlock); 
    951971 
    952972                if (poll(fds, dev_ctx.channels + 1, 2000) <= 0) { 
     
    956976 
    957977                if (fds[0].revents & POLLIN) { 
    958                         tapi_dev_event_handler(); 
     978                        lantiq_dev_event_handler(); 
    959979                } 
    960980 
    961981                ast_mutex_unlock(&monlock); 
    962982 
    963                 if ((fds[1].revents & POLLIN) && (tapi_dev_data_handler(0))) { 
    964                         ast_verbose("TAPI: data handler failed\n"); 
     983                if ((fds[1].revents & POLLIN) && (lantiq_dev_data_handler(0))) { 
     984                        ast_log(LOG_ERROR, "data handler 0 failed\n"); 
    965985                        break; 
    966986                } 
    967987 
    968                 if ((fds[2].revents & POLLIN) && (tapi_dev_data_handler(1))) { 
    969                         ast_verbose("TAPI: data handler failed\n"); 
     988                if ((fds[2].revents & POLLIN) && (lantiq_dev_data_handler(1))) { 
     989                        ast_log(LOG_ERROR, "data handler 1 failed\n"); 
    970990                        break; 
    971991                } 
     
    9801000        if (monitor_thread == AST_PTHREADT_STOP) 
    9811001                return 0; 
    982         if (ast_mutex_lock(&monlock)) { 
    983                 ast_log(LOG_WARNING, "Unable to lock monitor\n"); 
    984                 return -1; 
    985         } 
     1002 
     1003        ast_mutex_lock(&monlock); 
     1004 
    9861005        if (monitor_thread == pthread_self()) { 
    9871006                ast_mutex_unlock(&monlock); 
     
    9891008                return -1; 
    9901009        } 
     1010 
    9911011        if (monitor_thread != AST_PTHREADT_NULL) { 
    9921012                if (ast_mutex_lock(&iflock)) { 
     
    10011021                ast_mutex_unlock(&iflock); 
    10021022        } 
     1023 
    10031024        monitor = 1; 
    10041025        /* Start a new monitor */ 
    1005         if (ast_pthread_create_background(&monitor_thread, NULL, tapi_events_monitor, NULL) < 0) { 
     1026        if (ast_pthread_create_background(&monitor_thread, NULL, lantiq_events_monitor, NULL) < 0) { 
    10061027                ast_mutex_unlock(&monlock); 
    10071028                ast_log(LOG_ERROR, "Unable to start monitor thread.\n"); 
    10081029                return -1; 
    10091030        } 
     1031 
    10101032        ast_mutex_unlock(&monlock); 
    1011         return 0; 
     1033 
     1034        return 0; 
     1035} 
     1036 
     1037static void lantiq_cleanup(void) 
     1038{ 
     1039        int c; 
     1040 
     1041        for (c = 0; c < dev_ctx.channels ; c++) {  
     1042                if (ioctl(dev_ctx.ch_fd[c], IFX_TAPI_LINE_FEED_SET, IFX_TAPI_LINE_FEED_STANDBY)) { 
     1043                        ast_log(LOG_WARNING, "IFX_TAPI_LINE_FEED_SET ioctl failed\n"); 
     1044                } 
     1045 
     1046                if (ioctl(dev_ctx.ch_fd[c], IFX_TAPI_ENC_STOP, 0)) { 
     1047                        ast_log(LOG_WARNING, "IFX_TAPI_ENC_STOP ioctl failed\n"); 
     1048                } 
     1049 
     1050                if (ioctl(dev_ctx.ch_fd[c], IFX_TAPI_DEC_STOP, 0)) { 
     1051                        ast_log(LOG_WARNING, "IFX_TAPI_DEC_STOP ioctl failed\n"); 
     1052                } 
     1053        } 
     1054 
     1055        if (ioctl(dev_ctx.dev_fd, IFX_TAPI_DEV_STOP, 0)) { 
     1056                ast_log(LOG_WARNING, "IFX_TAPI_DEV_STOP ioctl failed\n"); 
     1057        } 
     1058 
     1059        close(dev_ctx.dev_fd); 
    10121060} 
    10131061 
     
    10161064        int c; 
    10171065 
    1018         ast_channel_unregister(&tapi_tech); 
     1066        ast_channel_unregister(&lantiq_tech); 
    10191067 
    10201068        if (!ast_mutex_lock(&iflock)) { 
    1021 //              for (c = 0; c < dev_ctx.channels ; c++) 
    1022 //                      ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD); 
     1069                for (c = 0; c < dev_ctx.channels ; c++) { 
     1070                        if (iflist[c].owner) 
     1071                                ast_softhangup(iflist[c].owner, AST_SOFTHANGUP_APPUNLOAD); 
     1072                } 
    10231073                ast_mutex_unlock(&iflock); 
    10241074        } else { 
     
    10411091        } 
    10421092 
    1043         if (!ast_mutex_lock(&iflock)) { 
    1044                 if (ioctl(dev_ctx.dev_fd, IFX_TAPI_DEV_STOP, 0)) { 
    1045                         ast_log(LOG_WARNING, "IFX_TAPI_DEV_STOP ioctl failed\n"); 
    1046                 } 
    1047  
    1048                 close(dev_ctx.dev_fd); 
    1049                 for (c = 0; c < dev_ctx.channels ; c++) close(dev_ctx.ch_fd[c]); 
    1050  
    1051                 ast_mutex_unlock(&iflock); 
    1052         } else { 
    1053                 ast_log(LOG_WARNING, "Unable to lock the monitor\n"); 
    1054                 return -1; 
    1055         } 
    1056  
    1057         return 0; 
    1058 } 
    1059  
    1060 static struct tapi_pvt *tapi_init_pvt(struct tapi_pvt *pvt) 
     1093        return 0; 
     1094} 
     1095 
     1096static struct lantiq_pvt *lantiq_init_pvt(struct lantiq_pvt *pvt) 
    10611097{ 
    10621098        if (pvt) { 
     
    10641100                pvt->port_id = -1; 
    10651101                pvt->channel_state = UNKNOWN; 
    1066                 pvt->context = strdup("default"); 
     1102                pvt->context[0] = '\0'; 
    10671103                pvt->ext[0] = '\0'; 
    10681104                pvt->dial_timer = 0; 
     
    10701106                pvt->dtmfbuf_len = 0; 
    10711107        } else { 
    1072                 ast_log(LOG_ERROR, "%s line %i: cannot clear structure.\n", __FUNCTION__, __LINE__); 
     1108                ast_log(LOG_ERROR, "unable to clear pvt structure\n"); 
    10731109        } 
    10741110 
     
    10761112} 
    10771113 
    1078 static int tapi_create_pvts(void) 
     1114static int lantiq_create_pvts(void) 
    10791115{ 
    10801116        int i; 
    10811117 
    1082         iflist = ast_calloc(1, sizeof(struct tapi_pvt)*dev_ctx.channels); 
     1118        iflist = ast_calloc(1, sizeof(struct lantiq_pvt) * dev_ctx.channels); 
    10831119 
    10841120        if (iflist) {  
    10851121                for (i=0 ; i<dev_ctx.channels ; i++) { 
    1086                         tapi_init_pvt(&iflist[i]); 
     1122                        lantiq_init_pvt(&iflist[i]); 
    10871123                        iflist[i].port_id = i; 
     1124                        if (per_channel_context) { 
     1125                                snprintf(iflist[i].context, AST_MAX_CONTEXT, "%s%i", LANTIQ_CONTEXT_PREFIX, i+1); 
     1126                                ast_debug(1, "Context for channel %i: %s\n", i, iflist[i].context); 
     1127                        } else { 
     1128                                snprintf(iflist[i].context, AST_MAX_CONTEXT, "default"); 
     1129                        } 
    10881130                } 
    10891131                return 0; 
    10901132        } else { 
    1091                 ast_log(LOG_ERROR, "%s line %i: cannot allocate memory.\n", __FUNCTION__, __LINE__); 
     1133                ast_log(LOG_ERROR, "unable to allocate memory\n"); 
    10921134                return -1; 
    10931135        } 
    10941136} 
    10951137 
    1096 static int tapi_setup_rtp(int c) 
     1138static int lantiq_setup_rtp(int c) 
    10971139{ 
    10981140        /* Configure RTP payload type tables */ 
     
    11821224                } else if (!strcasecmp(v->name, "basepath")) { 
    11831225                        ast_copy_string(base_path, v->value, sizeof(base_path)); 
     1226                } else if (!strcasecmp(v->name, "per_channel_context")) { 
     1227                        if (!strcasecmp(v->value, "on")) { 
     1228                                per_channel_context = 1; 
     1229                        } else if (!strcasecmp(v->value, "off")) { 
     1230                                per_channel_context = 0; 
     1231                        } else { 
     1232                                ast_log(LOG_ERROR, "Unknown per_channel_context value '%s'. Try 'on' or 'off'.\n", v->value); 
     1233                                ast_config_destroy(cfg); 
     1234                                return AST_MODULE_LOAD_DECLINE; 
     1235                        } 
    11841236                } 
    11851237        } 
     
    13121364        } 
    13131365 
    1314         tapi_create_pvts(); 
     1366        lantiq_create_pvts(); 
    13151367 
    13161368        ast_mutex_unlock(&iflock); 
    13171369 
    1318         if (ast_channel_register(&tapi_tech)) { 
     1370        if (ast_channel_register(&lantiq_tech)) { 
    13191371                ast_log(LOG_ERROR, "Unable to register channel class 'Phone'\n"); 
    13201372                ast_config_destroy(cfg); 
     
    13381390 
    13391391        /* open device */ 
    1340         dev_ctx.dev_fd = tapi_dev_open(base_path, 0); 
     1392        dev_ctx.dev_fd = lantiq_dev_open(base_path, 0); 
    13411393 
    13421394        if (dev_ctx.dev_fd < 0) { 
    1343                 ast_log(LOG_ERROR, "tapi device open function failed\n"); 
     1395                ast_log(LOG_ERROR, "lantiq tapi device open function failed\n"); 
    13441396                return AST_MODULE_LOAD_FAILURE; 
    13451397        } 
    13461398 
    13471399        for (c = 0; c < dev_ctx.channels ; c++) { 
    1348                 dev_ctx.ch_fd[c] = tapi_dev_open(base_path, c + 1); 
     1400                dev_ctx.ch_fd[c] = lantiq_dev_open(base_path, c + 1); 
    13491401 
    13501402                if (dev_ctx.ch_fd[c] < 0) { 
    1351                         ast_log(LOG_ERROR, "tapi channel %d open function failed\n", c); 
     1403                        ast_log(LOG_ERROR, "lantiq tapi channel %d open function failed\n", c); 
    13521404                        return AST_MODULE_LOAD_FAILURE; 
    13531405                } 
    13541406        } 
    13551407 
    1356         if (tapi_dev_firmware_download(dev_ctx.dev_fd, firmware_filename)) { 
     1408        if (lantiq_dev_firmware_download(dev_ctx.dev_fd, firmware_filename)) { 
    13571409                ast_log(LOG_ERROR, "voice firmware download failed\n"); 
    13581410                return AST_MODULE_LOAD_FAILURE; 
     
    14871539 
    14881540                /* Setup TAPI <-> Asterisk codec type mapping */ 
    1489                 if (tapi_setup_rtp(c)) { 
     1541                if (lantiq_setup_rtp(c)) { 
    14901542                        return AST_MODULE_LOAD_FAILURE; 
    14911543                } 
    14921544 
    14931545                /* Set initial hook status */ 
    1494                 iflist[c].channel_state = tapi_get_hookstatus(c); 
     1546                iflist[c].channel_state = lantiq_get_hookstatus(c); 
    14951547                 
    14961548                if (iflist[c].channel_state == UNKNOWN) { 
     
    14991551        } 
    15001552 
     1553        /* make sure our device will be closed properly */ 
     1554        ast_register_atexit(lantiq_cleanup); 
     1555 
    15011556        restart_monitor(); 
    15021557        return AST_MODULE_LOAD_SUCCESS; 
Note: See TracChangeset for help on using the changeset viewer.