Root/target/linux/amazon/files/drivers/char/amazon_mei.c

1/* ============================================================================
2 * Copyright (C) 2004 -Infineon Technologies AG.
3 *
4 * All rights reserved.
5 * ============================================================================
6 *
7 *============================================================================
8 * Licensed under GNU GPL v2
9 * ============================================================================
10 */
11
12 
13/* ===========================================================================
14 *
15 * File Name: amazon_mei.c
16 * Author : Ou Ke
17 *
18 * ===========================================================================
19 *
20 * Project: Amazon
21 *
22 * ===========================================================================
23 * Contents:This file implements the MEI driver for Amazon ADSL/ADSL2+
24 * controller.
25 *
26 * ===========================================================================
27 * References:
28 *
29 */
30
31
32/* ===========================================================================
33 * Revision History:
34 * 12/1/2005 : Ritesh Banerjee
35 * - Create a kernel thread kmibpoll to poll for periodic RFC 2662
36 * and RFC 3440 counters. Removes the need for user space
37 * adsl_mibpoll_daemon and saves atleast 30KB of RAM.
38 *
39 * $Log$
40 * ===========================================================================
41 */
42
43/*
44 * ===========================================================================
45 * INCLUDE FILES
46 * ===========================================================================
47 */
48//000002:fchang 2005/6/2 joelin 04/27/2005 for pcm clock
49//000003:fchang 2005/6/2 Henry added for Amazon-E support
50//165001:henryhsu 2005/9/6 Modify for adsl firmware version 1.2.1.2.0.1 DATA_LED can't flash.
51// 509221:tc.chen 2005/09/22 Reset DFE added when MEI_TO_ARC_CS_DONE not cleared by ARC
52// 603221:tc.chen 2006/03/21 added APIs to support the WEB related parameters for ADSL Statistics
53
54#ifndef EXPORT_SYMTAB
55#define EXPORT_SYMTAB
56#endif
57#define AMAZON_MEI_MIB_RFC3440
58
59#include <linux/config.h>
60#include <linux/kernel.h>
61#include <linux/module.h>
62#include <linux/version.h>
63#include <linux/types.h>
64#include <linux/fs.h>
65#include <linux/mm.h>
66#include <linux/errno.h>
67#include <linux/interrupt.h>
68#include <linux/netdevice.h>
69#include <linux/etherdevice.h>
70#include <asm/irq.h>
71#include <asm/segment.h>
72#include <asm/semaphore.h>
73#include <linux/init.h>
74#include <linux/ioport.h>
75#include <asm/uaccess.h>
76#include <linux/proc_fs.h>
77#include <asm/io.h>
78#include <linux/vmalloc.h>
79#include <linux/delay.h>
80#include <linux/poll.h>
81#include <linux/list.h>
82#include <linux/time.h>
83
84#include <asm/amazon/amazon.h>
85#include <asm/irq.h>
86#include <asm/amazon/irq.h>
87#include <asm/amazon/amazon_mei.h>
88#include <asm/amazon/amazon_mei_app.h>
89#include <asm/amazon/amazon_mei_ioctl.h>
90#include <asm/amazon/amazon_mei_app_ioctl.h>
91
92#define SET_BIT(reg, mask) reg |= (mask)
93#define CLEAR_BIT(reg, mask) reg &= (~mask)
94#define CLEAR_BITS(reg, mask) CLEAR_BIT(reg, mask)
95#define SET_BITS(reg, mask) SET_BIT(reg, mask)
96#define SET_BITFIELD(reg, mask, off, val) {reg &= (~mask); reg |= (val << off);}
97
98extern void mask_and_ack_amazon_irq(unsigned int irq_nr);
99
100#ifdef AMAZON_CHECK_LINK
101//amazon_tpe.c
102extern int (*adsl_link_notify)(int);
103#endif //AMAZON_CHECK_LINK
104
105// for ARC memory access
106#define WHILE_DELAY 20000
107#define AMAZON_DMA_DEBUG_MUTEX
108
109
110//TODO
111#undef DFE_LOOPBACK
112#define ARC_READY_ACK
113
114static amazon_mei_mib * current_intvl;
115static struct list_head interval_list;
116static amazon_mei_mib * mei_mib;
117
118static int reboot_firsttime=1;//000002:fchang
119
120    //PCM
121#define PCM_CHANNEL_NUM 2 //1 rx, 1 tx
122static pcm_data_struct pcm_data[PCM_CHANNEL_NUM]__attribute__ ((aligned(4))); //0=tx0, 1=rx0, 2=tx1, 3=rx1
123static u32 pcm_start_addr;
124//#define PCM_HRT_TIME_HZ 4000 //?us
125#define PCM_ACCESS_DEBUG
126static int irqtimes=0;
127#undef DATA_LED_ON_MODE
128#define ADSL_LED_SUPPORT //joelin for adsl led
129#ifdef ADSL_LED_SUPPORT
130static int firmware_support_led=0; //joelin version check for adsl led
131static int stop_led_module=0; //wakeup and clean led module
132static int led_support_check=0; //1.1.2.7.1.1
133#endif //ADSL_LED_SUPPORT
134#define IFX_DYING_GASP
135#ifdef IFX_DYING_GASP
136static wait_queue_head_t wait_queue_dying_gasp; //dying gasp
137//struct tq_struct dying_gasp_task; //dying gasp
138static wait_queue_head_t wait_queue_uas_poll; //joelin 04/16/2005
139static u16 unavailable_seconds=0; //joelin 04/16/2005
140static meidebug lop_debugwr; //dying gasp
141#endif //IFX_DYING_GASP
142static int dbg_int=0;
143//#define DEBUG_ACCESS_DELAY for(dbg_int=0;dbg_int<100;dbg_int++){;}
144#define DEBUG_ACCESS_DELAY
145static u8 sampledata[512];
146static int firsttime[PCM_CHANNEL_NUM]={0,1};
147static int num_cmp[PCM_CHANNEL_NUM]={0,0};
148static int pcm_start_loc[PCM_CHANNEL_NUM]={0,0};
149
150    // for clearEoC
151//#define MEI_CLREOC_BUFF_SIZE 512 //double the receive fifo size, bytes
152//static u8 clreoc[MEI_CLREOC_BUFF_SIZE]__attribute__ ((aligned(4))); //buffer to hold clearEoC data in bytes
153#undef AMAZON_CLEAR_EOC
154#ifdef AMAZON_CLEAR_EOC
155extern void ifx_push_eoc(struct sk_buff * pkt);
156#endif
157static int meiResetArc(void);
158#define IFX_POP_EOC_DONE 0
159#define IFX_POP_EOC_FAIL -1
160static struct list_head clreoc_list;
161static amazon_clreoc_pkt * clreoc_pkt;
162#define CLREOC_BUFF_SIZE 12 //number of clreoc commands being buffered
163//static int clreoc_wr=0;
164//static int clreoc_rd=0; //used to control clreoc circular buffer
165static wait_queue_head_t wait_queue_clreoc;
166#ifdef ADSL_LED_SUPPORT
167static wait_queue_head_t wait_queue_led; //adsl led
168static wait_queue_head_t wait_queue_led_polling;// adsl led
169struct tq_struct led_task; // adsl led
170static DECLARE_TASK_QUEUE(tq_ifx_led); // task
171int adsl_led_flash_task(void *ptr); // adsl led
172#endif //ADSL_LED_SUPPORT
173static void * clreoc_command_pkt=NULL;
174static int clreoc_max_tx_len=0;
175
176// 603221:tc.chen start
177#define ME_HDLC_IDLE 0
178#define ME_HDLC_INVALID_MSG 1
179#define ME_HDLC_MSG_QUEUED 2
180#define ME_HDLC_MSG_SENT 3
181#define ME_HDLC_RESP_RCVD 4
182#define ME_HDLC_RESP_TIMEOUT 5
183#define ME_HDLC_RX_BUF_OVERFLOW 6
184#define ME_HDLC_UNRESOLVED 1
185#define ME_HDLC_RESOLVED 2
186// 603221:tc.chen end
187
188#ifdef LOCK_RETRY
189static int reboot_lock=0;
190#endif
191
192static mib_previous_read mib_pread={0,0,0,0,0,0,0,0,0,0,0,0};
193static mib_flags_pretime mib_pflagtime;// initialized when module loaded
194
195    static u32 ATUC_PERF_LOFS=0;
196    static u32 ATUC_PERF_LOSS=0;
197    static u32 ATUC_PERF_ESS=0;
198    static u32 ATUC_PERF_INITS=0;
199    static u32 ATUR_PERF_LOFS=0;
200    static u32 ATUR_PERF_LOSS=0;
201    static u32 ATUR_PERF_LPR=0;
202    static u32 ATUR_PERF_ESS=0;
203    static u32 ATUR_CHAN_RECV_BLK=0;
204    static u32 ATUR_CHAN_TX_BLK=0;
205    static u32 ATUR_CHAN_CORR_BLK=0;
206    static u32 ATUR_CHAN_UNCORR_BLK=0;
207    //RFC-3440
208    static u32 ATUC_PERF_STAT_FASTR=0;
209    static u32 ATUC_PERF_STAT_FAILED_FASTR=0;
210    static u32 ATUC_PERF_STAT_SESL=0;
211    static u32 ATUC_PERF_STAT_UASL=0;
212    static u32 ATUR_PERF_STAT_SESL=0;
213    static u32 ATUR_PERF_STAT_UASL=0;
214
215    static adslChanPrevTxRate PrevTxRate={0,0};
216    static adslPhysCurrStatus CurrStatus={0,0};
217    static ChanType chantype={0,0};
218    static adslLineAlarmConfProfileEntry AlarmConfProfile={"No Name\0",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
219// 603221:tc.chen start
220    static adslFarEndPerfStats FarendStatsData;
221    struct timeval FarendData_acquire_time={0};
222    static u32 adsl_mode,adsl_mode_extend; // adsl mode : adsl/ 2/ 2+
223    static adslInitStats AdslInitStatsData;
224//603221:tc.chen end
225static u32 loop_diagnostics_mode=0;
226static wait_queue_head_t wait_queue_loop_diagnostic;
227#ifdef AMAZON_MEI_MIB_RFC3440
228    static adslLineAlarmConfProfileExtEntry AlarmConfProfileExt={"No Name\0",0,0,0,0,0,0};
229#endif
230
231static int showtime=0;
232static int loop_diagnostics_completed=0;
233//////////////////////////////////////////////////////////////////////////////////
234static int phy_mei_net_init(struct net_device * dev);
235static int interleave_mei_net_init(struct net_device * dev);
236static int fast_mei_net_init(struct net_device * dev);
237static struct net_device_stats * phy_mei_net_get_stats(struct net_device * dev);
238static struct net_device_stats * interleave_mei_net_get_stats(struct net_device * dev);
239static struct net_device_stats * fast_mei_net_get_stats(struct net_device * dev);
240
241typedef struct mei_priv{
242        struct net_device_stats stats;
243}mei_priv;
244
245static struct net_device phy_mei_net = { init: phy_mei_net_init, name: "MEI_PHY"};
246static struct net_device interleave_mei_net = { init: interleave_mei_net_init, name: "MEI_INTL"};
247static struct net_device fast_mei_net = { init: fast_mei_net_init, name: "MEI_FAST"};
248///////////////////////////////////////////////////////////////////////////////////
249
250static int major=AMAZON_MEI_MAJOR;
251
252static struct semaphore mei_sema;
253
254// Mei to ARC CMV count, reply count, ARC Indicator count
255static int indicator_count=0;
256static int cmv_count=0;
257static int reply_count=0;
258static u16 Recent_indicator[MSG_LENGTH];
259
260// Used in interrupt handler as flags
261static int arcmsgav=0;
262static int cmv_reply=0;
263static int cmv_waiting=0;
264
265#define PROC_ITEMS 8
266
267long mei_debug_mode = 0; //509221:tc.chen for adsl firmware debug
268
269// to wait for arc cmv reply, sleep on wait_queue_arcmsgav;
270static wait_queue_head_t wait_queue_arcmsgav;
271static wait_queue_head_t wait_queue_codeswap;
272static wait_queue_head_t wait_queue_mibdaemon;
273static wait_queue_head_t wait_queue_reboot;
274static u32 * image_buffer=NULL; // holding adsl firmware image
275static u16 RxMessage[MSG_LENGTH]__attribute__ ((aligned(4)));
276static u16 TxMessage[MSG_LENGTH]__attribute__ ((aligned(4)));
277static u32 * mei_arc_swap_buff=NULL; // holding swap pages
278static ARC_IMG_HDR * img_hdr;
279static int reboot_flag;
280
281#ifdef DFE_LOOPBACK
282#include "arc_pm.h"
283#endif
284
285
286///////////////// net device ///////////////////////////////////////////////////
287static int phy_mei_net_init(struct net_device * dev)
288{
289        //ether_setup(dev);
290        dev->get_stats = phy_mei_net_get_stats;
291        dev->ip_ptr = NULL;
292    dev->type = 94;
293    
294// dev->mtu=12345;
295    dev->flags=IFF_UP;
296    
297        dev->priv = kmalloc(sizeof(struct mei_priv), GFP_KERNEL);
298        if(dev->priv == NULL)
299                return -ENOMEM;
300        memset(dev->priv, 0, sizeof(struct mei_priv));
301        return 0;
302}
303
304static int interleave_mei_net_init(struct net_device * dev)
305{
306        //ether_setup(dev);
307        dev->get_stats = interleave_mei_net_get_stats;
308        dev->ip_ptr = NULL;
309    dev->type = 124;
310    dev->flags=IFF_UP;
311        dev->priv = kmalloc(sizeof(struct mei_priv), GFP_KERNEL);
312        if(dev->priv == NULL)
313                return -ENOMEM;
314        memset(dev->priv, 0, sizeof(struct mei_priv));
315        return 0;
316}
317
318static int fast_mei_net_init(struct net_device * dev)
319{
320        //ether_setup(dev);
321        dev->get_stats = fast_mei_net_get_stats;
322        dev->ip_ptr = NULL;
323    dev->type = 125;
324    dev->flags=IFF_UP;
325        dev->priv = kmalloc(sizeof(struct mei_priv), GFP_KERNEL);
326        if(dev->priv == NULL)
327                return -ENOMEM;
328        memset(dev->priv, 0, sizeof(struct mei_priv));
329        return 0;
330}
331
332static struct net_device_stats * phy_mei_net_get_stats(struct net_device * dev)
333{
334        struct mei_priv * priv;
335        priv = (struct mei_priv *)dev->priv;
336    // update statistics
337    (priv->stats).rx_packets = ATUR_CHAN_RECV_BLK;
338    (priv->stats).tx_packets = ATUR_CHAN_TX_BLK;
339    (priv->stats).rx_errors = ATUR_CHAN_CORR_BLK + ATUR_CHAN_UNCORR_BLK;
340    (priv->stats).rx_dropped = ATUR_CHAN_UNCORR_BLK;
341    
342        return &(priv->stats);
343}
344
345static struct net_device_stats * interleave_mei_net_get_stats(struct net_device * dev)
346{
347        struct mei_priv * priv;
348        priv = (struct mei_priv *)dev->priv;
349    // update statistics
350    (priv->stats).rx_packets = ATUR_CHAN_RECV_BLK;
351    (priv->stats).tx_packets = ATUR_CHAN_TX_BLK;
352    (priv->stats).rx_errors = ATUR_CHAN_CORR_BLK + ATUR_CHAN_UNCORR_BLK;
353    (priv->stats).rx_dropped = ATUR_CHAN_UNCORR_BLK;
354    
355        return &(priv->stats);
356}
357
358static struct net_device_stats * fast_mei_net_get_stats(struct net_device * dev)
359{
360        struct mei_priv * priv;
361        priv = (struct mei_priv *)dev->priv;
362    // update statistics
363    (priv->stats).rx_packets = ATUR_CHAN_RECV_BLK;
364    (priv->stats).tx_packets = ATUR_CHAN_TX_BLK;
365    (priv->stats).rx_errors = ATUR_CHAN_CORR_BLK + ATUR_CHAN_UNCORR_BLK;
366    (priv->stats).rx_dropped = ATUR_CHAN_UNCORR_BLK;
367    
368        return &(priv->stats);
369}
370///////////////// mei access Rd/Wr methods ///////////////////////////////////////////////////
371void meiLongwordWrite(u32 ul_address, u32 ul_data)
372{
373    *((volatile u32 *)ul_address) = ul_data;
374    asm("SYNC");
375    return;
376} // end of "meiLongwordWrite(..."
377
378void meiLongwordRead(u32 ul_address, u32 *pul_data)
379{
380    *pul_data = *((volatile u32 *)ul_address);
381    asm("SYNC");
382    return;
383} // end of "meiLongwordRead(..."
384
385MEI_ERROR meiDMAWrite(u32 destaddr, u32 *databuff, u32 databuffsize)
386{
387    u32 *p = databuff;
388    u32 temp;
389    u32 flags;
390
391    if( destaddr & 3)
392        return MEI_FAILURE;
393
394#ifdef AMAZON_DMA_DEBUG_MUTEX
395    save_flags(flags);
396    cli();
397#endif
398        
399
400    // Set the write transfer address
401    meiLongwordWrite(MEI_XFR_ADDR, destaddr);
402
403    // Write the data pushed across DMA
404    while (databuffsize--)
405    {
406        temp = *p;
407        if(databuff==(u32 *)TxMessage) // swap half word
408            temp = ((temp & 0xffff)<<16) + ((temp & 0xffff0000)>>16);
409        meiLongwordWrite(MEI_DATA_XFR, temp);
410        p++;
411    } // end of "while(..."
412
413#ifdef AMAZON_DMA_DEBUG_MUTEX
414    restore_flags(flags);
415#endif
416    
417    return MEI_SUCCESS;
418
419} // end of "meiDMAWrite(..."
420
421MEI_ERROR meiDMAWrite_16(u32 destaddr, u32 *databuff, u32 databuffsize)
422{
423    u32 *p = databuff;
424    u32 temp;
425    u32 flags;
426
427    if( destaddr & 3)
428        return MEI_FAILURE;
429        
430#ifdef AMAZON_DMA_DEBUG_MUTEX
431    save_flags(flags);
432    cli();
433#endif
434        
435
436    // Set the write transfer address
437    meiLongwordWrite(MEI_XFR_ADDR, destaddr);
438
439    // Write the data pushed across DMA
440    while (databuffsize--)
441    {
442        temp = *p;
443        temp = ((temp & 0xffff)<<16) + ((temp & 0xffff0000)>>16);//swap half word
444        meiLongwordWrite(MEI_DATA_XFR, temp);
445        p++;
446    } // end of "while(..."
447    
448#ifdef AMAZON_DMA_DEBUG_MUTEX
449    restore_flags(flags);
450#endif
451
452    return MEI_SUCCESS;
453
454} // end of "meiDMAWrite_16(..."
455
456MEI_ERROR meiDMAWrite_8(u32 destaddr, u32 *databuff, u32 databuffsize)
457{
458    u32 *p = databuff;
459    u32 temp;
460    u32 flags;
461
462    if( destaddr & 3)
463        return MEI_FAILURE;
464        
465#ifdef AMAZON_DMA_DEBUG_MUTEX
466    save_flags(flags);
467    cli();
468#endif
469        
470
471    // Set the write transfer address
472    meiLongwordWrite(MEI_XFR_ADDR, destaddr);
473
474    // Write the data pushed across DMA
475    while (databuffsize--)
476    {
477        temp = *p;
478        temp = ((temp & 0xff)<<24) + ((temp & 0xff00)<<8)+ ((temp & 0xff0000)>>8)+ ((temp & 0xff000000)>>24);//swap byte
479        meiLongwordWrite(MEI_DATA_XFR, temp);
480        p++;
481    } // end of "while(..."
482    
483#ifdef AMAZON_DMA_DEBUG_MUTEX
484    restore_flags(flags);
485#endif
486
487    return MEI_SUCCESS;
488
489} // end of "meiDMAWrite_8(..."
490
491MEI_ERROR meiDMARead(u32 srcaddr, u32 *databuff, u32 databuffsize)
492{
493    u32 *p = databuff;
494    u32 temp;
495    u32 flags;
496    
497    if( srcaddr & 3)
498        return MEI_FAILURE;
499
500#ifdef AMAZON_DMA_DEBUG_MUTEX
501    save_flags(flags);
502    cli();
503#endif
504    
505
506    // Set the read transfer address
507    meiLongwordWrite(MEI_XFR_ADDR, srcaddr);
508
509    // Read the data popped across DMA
510    while (databuffsize--)
511    {
512        meiLongwordRead(MEI_DATA_XFR, &temp);
513        if(databuff==(u32 *)RxMessage) // swap half word
514            temp = ((temp & 0xffff)<<16) + ((temp & 0xffff0000)>>16);
515        *p=temp;
516        p++;
517    } // end of "while(..."
518
519#ifdef AMAZON_DMA_DEBUG_MUTEX
520    restore_flags(flags);
521#endif
522
523    return MEI_SUCCESS;
524
525} // end of "meiDMARead(..."
526
527MEI_ERROR meiDMARead_16(u32 srcaddr, u32 *databuff, u32 databuffsize)
528{
529    u32 *p = databuff;
530    u32 temp;
531    u32 flags;
532    
533    if( srcaddr & 3)
534        return MEI_FAILURE;
535        
536#ifdef AMAZON_DMA_DEBUG_MUTEX
537    save_flags(flags);
538    cli();
539#endif
540        
541
542    // Set the read transfer address
543    meiLongwordWrite(MEI_XFR_ADDR, srcaddr);
544
545    // Read the data popped across DMA
546    while (databuffsize--)
547    {
548        meiLongwordRead(MEI_DATA_XFR, &temp);
549        temp = ((temp & 0xffff)<<16) + ((temp & 0xffff0000)>>16);
550        *p=temp;
551        p++;
552    } // end of "while(..."
553    
554#ifdef AMAZON_DMA_DEBUG_MUTEX
555    restore_flags(flags);
556#endif
557
558    return MEI_SUCCESS;
559
560} // end of "meiDMARead_16(..."
561
562MEI_ERROR meiDMARead_8(u32 srcaddr, u32 *databuff, u32 databuffsize)
563{
564    u32 *p = databuff;
565    u32 temp;
566    u32 flags;
567    
568    if( srcaddr & 3)
569        return MEI_FAILURE;
570        
571#ifdef AMAZON_DMA_DEBUG_MUTEX
572    save_flags(flags);
573    cli();
574#endif
575        
576
577    // Set the read transfer address
578    meiLongwordWrite(MEI_XFR_ADDR, srcaddr);
579
580    // Read the data popped across DMA
581    while (databuffsize--)
582    {
583        meiLongwordRead(MEI_DATA_XFR, &temp);
584        temp = ((temp & 0xff)<<24) + ((temp & 0xff00)<<8)+ ((temp & 0xff0000)>>8)+ ((temp & 0xff000000)>>24);//swap byte
585        *p=temp;
586        p++;
587    } // end of "while(..."
588    
589#ifdef AMAZON_DMA_DEBUG_MUTEX
590    restore_flags(flags);
591#endif
592
593    return MEI_SUCCESS;
594
595} // end of "meiDMARead_8(..."
596
597void meiPollForDbgDone(void)
598{
599    u32 query = 0;
600    int i=0;
601    while (i<WHILE_DELAY)
602    {
603        meiLongwordRead(ARC_TO_MEI_INT, &query);
604        query &= (ARC_TO_MEI_DBG_DONE);
605        if(query)
606            break;
607        i++;
608        if(i==WHILE_DELAY){
609#ifdef AMAZON_MEI_DEBUG_ON
610            printk("\n\n PollforDbg fail");
611#endif
612        }
613            DEBUG_ACCESS_DELAY;
614    }
615       meiLongwordWrite(ARC_TO_MEI_INT, ARC_TO_MEI_DBG_DONE); // to clear this interrupt
616} // end of "meiPollForDbgDone(..."
617
618MEI_ERROR meiDebugWrite_8(u32 destaddr, u32 *databuff, u32 databuffsize)
619{
620    u32 i;
621    u32 temp = 0x0;
622    u32 address = 0x0;
623    u32 *buffer = 0x0;
624    u32 flags;
625    
626#ifdef AMAZON_DMA_DEBUG_MUTEX
627    save_flags(flags);
628    cli();
629#endif
630    
631
632    // Open the debug port before DMP memory write
633    meiLongwordRead(MEI_CONTROL, &temp);
634        DEBUG_ACCESS_DELAY;
635    temp |= (HOST_MSTR);
636    meiLongwordWrite(MEI_CONTROL, temp);
637        DEBUG_ACCESS_DELAY;
638    meiLongwordWrite(MEI_DEBUG_DEC, MEI_DEBUG_DEC_DMP1_MASK);
639        DEBUG_ACCESS_DELAY;
640
641    // For the requested length, write the address and write the data
642    address = destaddr;
643    buffer = databuff;
644    for (i=0; i < databuffsize; i++)
645    {
646        meiLongwordWrite(MEI_DEBUG_WAD, address);
647            DEBUG_ACCESS_DELAY;
648        temp=*buffer;
649        temp = ((temp & 0xff)<<24) + ((temp & 0xff00)<<8)+ ((temp & 0xff0000)>>8)+ ((temp & 0xff000000)>>24);//swap byte
650        meiLongwordWrite(MEI_DEBUG_DATA, temp);
651            DEBUG_ACCESS_DELAY;
652        meiPollForDbgDone();
653        address += 4;
654        buffer++;
655    } // end of "for(..."
656
657    // Close the debug port after DMP memory write
658    meiLongwordRead(MEI_CONTROL, &temp);
659        DEBUG_ACCESS_DELAY;
660    temp &= ~(HOST_MSTR);
661    meiLongwordWrite(MEI_CONTROL, temp);
662        DEBUG_ACCESS_DELAY;
663        
664#ifdef AMAZON_DMA_DEBUG_MUTEX
665    restore_flags(flags);
666#endif
667
668    // Return
669    return MEI_SUCCESS;
670
671} // end of "meiDebugWrite_8(..."
672
673MEI_ERROR meiDebugRead_8(u32 srcaddr, u32 *databuff, u32 databuffsize)
674{
675    u32 i;
676    u32 temp = 0x0;
677    u32 address = 0x0;
678    u32 *buffer = 0x0;
679    u32 flags;
680    
681#ifdef AMAZON_DMA_DEBUG_MUTEX
682    save_flags(flags);
683    cli();
684#endif
685    
686
687    // Open the debug port before DMP memory read
688    meiLongwordRead(MEI_CONTROL, &temp);
689        DEBUG_ACCESS_DELAY;
690    temp |= (HOST_MSTR);
691    meiLongwordWrite(MEI_CONTROL, temp);
692        DEBUG_ACCESS_DELAY;
693    meiLongwordWrite(MEI_DEBUG_DEC, MEI_DEBUG_DEC_DMP2_MASK);
694        DEBUG_ACCESS_DELAY;
695
696    // For the requested length, write the address and read the data
697    address = srcaddr;
698    buffer = databuff;
699    for (i=0; i<databuffsize; i++)
700    {
701        meiLongwordWrite(MEI_DEBUG_RAD, address);
702            DEBUG_ACCESS_DELAY;
703        meiPollForDbgDone();
704        meiLongwordRead(MEI_DEBUG_DATA, &temp);
705            DEBUG_ACCESS_DELAY;
706        temp = ((temp & 0xff)<<24) + ((temp & 0xff00)<<8)+ ((temp & 0xff0000)>>8)+ ((temp & 0xff000000)>>24);//swap byte
707        *buffer=temp;
708        address += 4;
709        buffer++;
710    } // end of "for(..."
711
712    // Close the debug port after DMP memory read
713    meiLongwordRead(MEI_CONTROL, &temp);
714        DEBUG_ACCESS_DELAY;
715    temp &= ~(HOST_MSTR);
716    meiLongwordWrite(MEI_CONTROL, temp);
717        DEBUG_ACCESS_DELAY;
718        
719#ifdef AMAZON_DMA_DEBUG_MUTEX
720    restore_flags(flags);
721#endif
722
723    // Return
724    return MEI_SUCCESS;
725
726} // end of "meiDebugRead_8(..."
727
728MEI_ERROR meiDebugWrite_16(u32 destaddr, u32 *databuff, u32 databuffsize)
729{
730    u32 i;
731    u32 temp = 0x0;
732    u32 address = 0x0;
733    u32 *buffer = 0x0;
734    u32 flags;
735    
736#ifdef AMAZON_DMA_DEBUG_MUTEX
737    save_flags(flags);
738    cli();
739#endif
740    
741
742    // Open the debug port before DMP memory write
743    meiLongwordRead(MEI_CONTROL, &temp);
744        DEBUG_ACCESS_DELAY;
745    temp |= (HOST_MSTR);
746    meiLongwordWrite(MEI_CONTROL, temp);
747        DEBUG_ACCESS_DELAY;
748    meiLongwordWrite(MEI_DEBUG_DEC, MEI_DEBUG_DEC_DMP1_MASK);
749        DEBUG_ACCESS_DELAY;
750
751    // For the requested length, write the address and write the data
752    address = destaddr;
753    buffer = databuff;
754    for (i=0; i < databuffsize; i++)
755    {
756        meiLongwordWrite(MEI_DEBUG_WAD, address);
757            DEBUG_ACCESS_DELAY;
758        temp=*buffer;
759        temp = ((temp & 0xffff)<<16) + ((temp & 0xffff0000)>>16);//swap half word
760        meiLongwordWrite(MEI_DEBUG_DATA, temp);
761            DEBUG_ACCESS_DELAY;
762        meiPollForDbgDone();
763        address += 4;
764        buffer++;
765    } // end of "for(..."
766
767    // Close the debug port after DMP memory write
768    meiLongwordRead(MEI_CONTROL, &temp);
769        DEBUG_ACCESS_DELAY;
770    temp &= ~(HOST_MSTR);
771    meiLongwordWrite(MEI_CONTROL, temp);
772        DEBUG_ACCESS_DELAY;
773        
774#ifdef AMAZON_DMA_DEBUG_MUTEX
775    restore_flags(flags);
776#endif
777
778    // Return
779    return MEI_SUCCESS;
780
781} // end of "meiDebugWrite_16(..."
782
783MEI_ERROR meiDebugRead_16(u32 srcaddr, u32 *databuff, u32 databuffsize)
784{
785    u32 i;
786    u32 temp = 0x0;
787    u32 address = 0x0;
788    u32 *buffer = 0x0;
789    u32 flags;
790    
791#ifdef AMAZON_DMA_DEBUG_MUTEX
792    save_flags(flags);
793    cli();
794#endif
795    
796
797    // Open the debug port before DMP memory read
798    meiLongwordRead(MEI_CONTROL, &temp);
799        DEBUG_ACCESS_DELAY;
800    temp |= (HOST_MSTR);
801    meiLongwordWrite(MEI_CONTROL, temp);
802        DEBUG_ACCESS_DELAY;
803    meiLongwordWrite(MEI_DEBUG_DEC, MEI_DEBUG_DEC_DMP2_MASK);
804        DEBUG_ACCESS_DELAY;
805
806    // For the requested length, write the address and read the data
807    address = srcaddr;
808    buffer = databuff;
809    for (i=0; i<databuffsize; i++)
810    {
811        meiLongwordWrite(MEI_DEBUG_RAD, address);
812            DEBUG_ACCESS_DELAY;
813        meiPollForDbgDone();
814        meiLongwordRead(MEI_DEBUG_DATA, &temp);
815            DEBUG_ACCESS_DELAY;
816        temp = ((temp & 0xffff)<<16) + ((temp & 0xffff0000)>>16);//swap half word
817        *buffer=temp;
818        address += 4;
819        buffer++;
820    } // end of "for(..."
821
822    // Close the debug port after DMP memory read
823    meiLongwordRead(MEI_CONTROL, &temp);
824        DEBUG_ACCESS_DELAY;
825    temp &= ~(HOST_MSTR);
826    meiLongwordWrite(MEI_CONTROL, temp);
827        DEBUG_ACCESS_DELAY;
828        
829#ifdef AMAZON_DMA_DEBUG_MUTEX
830    restore_flags(flags);
831#endif
832
833    // Return
834    return MEI_SUCCESS;
835
836} // end of "meiDebugRead_16(..."
837
838MEI_ERROR meiDebugWrite(u32 destaddr, u32 *databuff, u32 databuffsize)
839{
840    u32 i;
841    u32 temp = 0x0;
842    u32 address = 0x0;
843    u32 *buffer = 0x0;
844    u32 flags;
845    
846#ifdef AMAZON_DMA_DEBUG_MUTEX
847    save_flags(flags);
848    cli();
849#endif
850    
851
852    // Open the debug port before DMP memory write
853    meiLongwordRead(MEI_CONTROL, &temp);
854        DEBUG_ACCESS_DELAY;
855    temp |= (HOST_MSTR);
856    meiLongwordWrite(MEI_CONTROL, temp);
857        DEBUG_ACCESS_DELAY;
858    meiLongwordWrite(MEI_DEBUG_DEC, MEI_DEBUG_DEC_DMP1_MASK);
859        DEBUG_ACCESS_DELAY;
860
861    // For the requested length, write the address and write the data
862    address = destaddr;
863    buffer = databuff;
864    for (i=0; i < databuffsize; i++)
865    {
866        meiLongwordWrite(MEI_DEBUG_WAD, address);
867            DEBUG_ACCESS_DELAY;
868        temp=*buffer;
869        meiLongwordWrite(MEI_DEBUG_DATA, temp);
870            DEBUG_ACCESS_DELAY;
871        meiPollForDbgDone();
872        address += 4;
873        buffer++;
874    } // end of "for(..."
875
876    // Close the debug port after DMP memory write
877    meiLongwordRead(MEI_CONTROL, &temp);
878        DEBUG_ACCESS_DELAY;
879    temp &= ~(HOST_MSTR);
880    meiLongwordWrite(MEI_CONTROL, temp);
881        DEBUG_ACCESS_DELAY;
882
883#ifdef AMAZON_DMA_DEBUG_MUTEX
884    restore_flags(flags);
885#endif
886
887    // Return
888    return MEI_SUCCESS;
889
890} // end of "meiDebugWrite(..."
891
892MEI_ERROR meiDebugRead(u32 srcaddr, u32 *databuff, u32 databuffsize)
893{
894    u32 i;
895    u32 temp = 0x0;
896    u32 address = 0x0;
897    u32 *buffer = 0x0;
898    u32 flags;
899    
900#ifdef AMAZON_DMA_DEBUG_MUTEX
901    save_flags(flags);
902    cli();
903#endif
904    
905
906    // Open the debug port before DMP memory read
907    meiLongwordRead(MEI_CONTROL, &temp);
908        DEBUG_ACCESS_DELAY;
909    temp |= (HOST_MSTR);
910    meiLongwordWrite(MEI_CONTROL, temp);
911        DEBUG_ACCESS_DELAY;
912    meiLongwordWrite(MEI_DEBUG_DEC, MEI_DEBUG_DEC_DMP2_MASK);
913        DEBUG_ACCESS_DELAY;
914
915    // For the requested length, write the address and read the data
916    address = srcaddr;
917    buffer = databuff;
918    for (i=0; i<databuffsize; i++)
919    {
920        meiLongwordWrite(MEI_DEBUG_RAD, address);
921            DEBUG_ACCESS_DELAY;
922        meiPollForDbgDone();
923        meiLongwordRead(MEI_DEBUG_DATA, &temp);
924            DEBUG_ACCESS_DELAY;
925        *buffer=temp;
926        address += 4;
927        buffer++;
928    } // end of "for(..."
929
930    // Close the debug port after DMP memory read
931    meiLongwordRead(MEI_CONTROL, &temp);
932        DEBUG_ACCESS_DELAY;
933    temp &= ~(HOST_MSTR);
934    meiLongwordWrite(MEI_CONTROL, temp);
935        DEBUG_ACCESS_DELAY;
936        
937#ifdef AMAZON_DMA_DEBUG_MUTEX
938    restore_flags(flags);
939#endif
940
941    // Return
942    return MEI_SUCCESS;
943
944} // end of "meiDebugRead(..."
945EXPORT_SYMBOL(meiDebugRead);
946
947void meiMailboxInterruptsDisable(void)
948{
949    meiLongwordWrite(ARC_TO_MEI_INT_MASK, 0x0);
950} // end of "meiMailboxInterruptsDisable(..."
951
952void meiMailboxInterruptsEnable(void)
953{
954    meiLongwordWrite(ARC_TO_MEI_INT_MASK, MSGAV_EN);
955} // end of "meiMailboxInterruptsEnable(..."
956
957MEI_ERROR meiMailboxWrite(u16 *msgsrcbuffer, u16 msgsize)
958{
959    int i;
960    u32 arc_mailbox_status = 0x0;
961    u32 temp=0;
962    MEI_ERROR meiMailboxError = MEI_SUCCESS;
963
964    // Check arc if mailbox write can be initiated
965/* meiLongwordRead(MEI_TO_ARC_INT, &arc_mailbox_status);
966    if ((arc_mailbox_status & MEI_TO_ARC_MSGAV))
967    {
968        return MEI_MAILBOX_FULL;
969    }
970*/
971    // Write to mailbox
972    meiMailboxError = meiDMAWrite(MEI_TO_ARC_MAILBOX, (u32*)msgsrcbuffer, msgsize/2);
973    meiMailboxError = meiDMAWrite(MEI_TO_ARC_MAILBOXR, (u32 *)(&temp), 1);
974
975    // Notify arc that mailbox write completed
976    cmv_waiting=1;
977    meiLongwordWrite(MEI_TO_ARC_INT, MEI_TO_ARC_MSGAV);
978    
979    i=0;
980        while(i<WHILE_DELAY){ // wait for ARC to clear the bit
981        meiLongwordRead(MEI_TO_ARC_INT, &arc_mailbox_status);
982        if((arc_mailbox_status & MEI_TO_ARC_MSGAV) != MEI_TO_ARC_MSGAV)
983            break;
984        i++;
985        if(i==WHILE_DELAY){
986#ifdef AMAZON_MEI_DEBUG_ON
987            printk("\n\n MEI_TO_ARC_MSGAV not cleared by ARC");
988#endif
989            meiMailboxError = MEI_FAILURE;
990#if 0
991            for(i=0;i<msgsize;i++)
992                printk("\n %8x", (*(msgsrcbuffer+i)));
993#endif
994        }
995    }
996        
997    // Return
998    return meiMailboxError;
999
1000} // end of "meiMailboxWrite(..."
1001
1002MEI_ERROR meiMailboxRead(u16 *msgdestbuffer, u16 msgsize)
1003{
1004    //u32 arc_mailbox_status = 0x0;
1005    //u32 *mei_arc_msgbuff = 0x0;
1006    MEI_ERROR meiMailboxError = MEI_SUCCESS;
1007
1008            /*
1009            // Check arc if mailbox read can be initiated
1010    meiLongwordRead(ARC_TO_MEI_INT, &arc_mailbox_status);
1011    if ((arc_mailbox_status & ARC_TO_MEI_MSGAV) == 0)
1012    {
1013        return MEI_MAILBOX_EMPTY;
1014    } // end of "if(..."
1015            */
1016            
1017    // Read from mailbox
1018    meiMailboxError = meiDMARead(ARC_TO_MEI_MAILBOX, (u32*)msgdestbuffer, msgsize/2);
1019
1020    // Notify arc that mailbox read completed
1021    meiLongwordWrite(ARC_TO_MEI_INT, ARC_TO_MEI_MSGAV);
1022
1023    // Return
1024    return meiMailboxError;
1025
1026} // end of "meiMailboxRead(..."
1027
1028MEI_ERROR meiHaltArc(void)
1029{
1030    u32 arc_control_mode = 0x0;
1031    u32 arc_debug_addr = 0x5;
1032    u32 arc_debug_data = 0x0;
1033
1034    // Switch arc control from JTAG mode to MEI mode- write '1' to bit0
1035    meiLongwordRead(MEI_CONTROL, &arc_control_mode);
1036    arc_control_mode |= (HOST_MSTR);
1037    meiLongwordWrite(MEI_CONTROL, arc_control_mode);
1038
1039    // Write arc aux reg access mask (0x0) into debug addr decode reg
1040    meiLongwordWrite(MEI_DEBUG_DEC, MEI_DEBUG_DEC_AUX_MASK);
1041
1042    // Write arc debug reg addr (0x5) into debug read addr reg
1043    meiLongwordWrite(MEI_DEBUG_RAD, arc_debug_addr);
1044    meiPollForDbgDone();
1045
1046    // Read debug data reg and save content
1047    meiLongwordRead(MEI_DEBUG_DATA, &arc_debug_data);
1048
1049    // Write arc debug reg addr (0x5) into debug write addr reg
1050    meiLongwordWrite(MEI_DEBUG_WAD, arc_debug_addr);
1051
1052    // Write debug data reg with content ORd with 0x2 (halt bit set)
1053    arc_debug_data |= (BIT1);
1054    meiLongwordWrite(MEI_DEBUG_DATA, arc_debug_data);
1055           meiPollForDbgDone();
1056
1057    // Switch arc control from MEI mode to JTAG mode- write '0' to bit0
1058    meiLongwordRead(MEI_CONTROL, &arc_control_mode);
1059    arc_control_mode &= ~(HOST_MSTR);
1060    meiLongwordWrite(MEI_CONTROL, arc_control_mode);
1061
1062    // Return
1063    return MEI_SUCCESS;
1064
1065} // end of "meiHalt(..."
1066
1067MEI_ERROR meiDownloadBootCode(void)
1068{
1069    u32 arc_control_mode;
1070    u32 boot_loop;
1071    u32 page_size;
1072    u32 dest_addr;
1073
1074    u32 arc_debug_addr = 0x31F00;
1075    u32 arc_debug_data = 0x10;
1076    u32 temp;
1077// int i;
1078
1079    //MEI_ERROR meiDMAError = MEI_SUCCESS;
1080
1081    // Disable mask for arc codeswap interrupts
1082    meiMailboxInterruptsDisable();
1083
1084    // Switch arc control from JTAG mode to MEI mode- write '1' to bit0
1085    meiLongwordRead(MEI_CONTROL, &arc_control_mode);
1086    arc_control_mode |= (HOST_MSTR);
1087    meiLongwordWrite(MEI_CONTROL, arc_control_mode);
1088
1089    // Write (0x10) to CRI_CCR0(0x31F00) to enable ac_clk signal
1090    meiLongwordWrite(MEI_DEBUG_DEC, MEI_DEBUG_DEC_DMP1_MASK);
1091    meiLongwordWrite(MEI_DEBUG_RAD, arc_debug_addr);
1092    meiPollForDbgDone();
1093    meiLongwordRead(MEI_DEBUG_DATA, &temp);
1094    temp |=arc_debug_data;
1095    
1096    meiLongwordWrite(MEI_DEBUG_WAD, arc_debug_addr);
1097    meiLongwordWrite(MEI_DEBUG_DATA, temp);
1098        meiPollForDbgDone();
1099            //meiLongwordWrite(MEI_DEBUG_DEC, MEI_DEBUG_DEC_AUX_MASK);
1100
1101    // Switch arc control from MEI mode to JTAG mode- write '0' to bit0
1102    meiLongwordRead(MEI_CONTROL, &arc_control_mode);
1103    arc_control_mode &= ~(HOST_MSTR);
1104    meiLongwordWrite(MEI_CONTROL, arc_control_mode);
1105    
1106#ifdef AMAZON_MEI_DEBUG_ON //to test ac_clk setting correctness
1107    meiLongwordRead(MEI_CONTROL, &arc_control_mode);
1108    arc_control_mode |= (HOST_MSTR);
1109    meiLongwordWrite(MEI_CONTROL, arc_control_mode);
1110    
1111    meiLongwordWrite(MEI_DEBUG_DEC, MEI_DEBUG_DEC_DMP1_MASK);
1112    meiLongwordWrite(MEI_DEBUG_RAD, arc_debug_addr);
1113    meiPollForDbgDone();
1114    meiLongwordRead(MEI_DEBUG_DATA, &arc_debug_data);
1115
1116    meiLongwordRead(MEI_CONTROL, &arc_control_mode);
1117    arc_control_mode &= ~(HOST_MSTR);
1118    meiLongwordWrite(MEI_CONTROL, arc_control_mode);
1119    
1120// printk("\n\n ac_clk is %8x\n", arc_debug_data);
1121#endif
1122
1123    /*
1124    ** DMA the boot code page(s)
1125    */
1126#ifdef AMAZON_MEI_DEBUG_ON
1127// printk("\n\n start download pages");
1128#endif
1129    for( boot_loop = 0; boot_loop < img_hdr->count; boot_loop++)
1130    {
1131        if( img_hdr->page[boot_loop].p_size & BOOT_FLAG)
1132        {
1133            page_size = meiGetPage( boot_loop, GET_PROG, MAXSWAPSIZE, mei_arc_swap_buff, &dest_addr);
1134            if( page_size > 0)
1135            {
1136                meiDMAWrite(dest_addr, mei_arc_swap_buff, page_size);
1137            }
1138        }
1139        if( img_hdr->page[boot_loop].d_size & BOOT_FLAG)
1140        {
1141            page_size = meiGetPage( boot_loop, GET_DATA, MAXSWAPSIZE, mei_arc_swap_buff, &dest_addr);
1142            if( page_size > 0)
1143            {
1144                meiDMAWrite( dest_addr, mei_arc_swap_buff, page_size);
1145            }
1146        }
1147    }
1148#ifdef AMAZON_MEI_DEBUG_ON
1149// printk("\n\n pages downloaded");
1150#endif
1151    return MEI_SUCCESS;
1152
1153} // end of "meiDownloadBootCode(..."
1154
1155MEI_ERROR meiRunArc(void)
1156{
1157    u32 arc_control_mode = 0x0;
1158    u32 arc_debug_addr = 0x0;
1159    u32 arc_debug_data = 0x0;
1160
1161    // Switch arc control from JTAG mode to MEI mode- write '1' to bit0
1162    meiLongwordRead(MEI_CONTROL, &arc_control_mode);
1163    arc_control_mode |= (HOST_MSTR);
1164    meiLongwordWrite(MEI_CONTROL, arc_control_mode);
1165
1166    // Write arc aux reg access mask (0x0) into debug addr decode reg
1167    meiLongwordWrite(MEI_DEBUG_DEC, MEI_DEBUG_DEC_AUX_MASK);
1168
1169    // Write arc status aux reg addr (0x0) into debug read addr reg
1170    meiLongwordWrite(MEI_DEBUG_RAD, arc_debug_addr);
1171    meiPollForDbgDone();
1172
1173    // Read debug data reg and save content
1174    meiLongwordRead(MEI_DEBUG_DATA, &arc_debug_data);
1175
1176    // Write arc status aux reg addr (0x0) into debug write addr reg
1177    meiLongwordWrite(MEI_DEBUG_WAD, arc_debug_addr);
1178
1179    // Write debug data reg with content ANDd with 0xFDFFFFFF (halt bit cleared)
1180    arc_debug_data &= ~(BIT25);
1181    meiLongwordWrite(MEI_DEBUG_DATA, arc_debug_data);
1182        meiPollForDbgDone();
1183
1184    // Switch arc control from MEI mode to JTAG mode- write '0' to bit0
1185    meiLongwordRead(MEI_CONTROL, &arc_control_mode);
1186    arc_control_mode &= ~(HOST_MSTR);
1187    meiLongwordWrite(MEI_CONTROL, arc_control_mode);
1188
1189    // Enable mask for arc codeswap interrupts
1190    meiMailboxInterruptsEnable();
1191
1192    // Return
1193    return MEI_SUCCESS;
1194
1195} // end of "meiActivate(..."
1196
1197int meiGetPage( u32 Page, u32 data, u32 MaxSize, u32 *Buffer, u32 *Dest)
1198{
1199    u32 size;
1200    u32 i;
1201    u32 *p;
1202
1203    if( Page > img_hdr->count)
1204        return -2;
1205
1206    /*
1207    ** Get program or data size, depending on "data" flag
1208    */
1209    size = (data == GET_DATA) ? img_hdr->page[ Page].d_size : img_hdr->page[ Page].p_size;
1210
1211    size &= BOOT_FLAG_MASK; // Clear boot bit!
1212    if( size > MaxSize)
1213        return -1;
1214
1215    if( size == 0)
1216        return 0;
1217    /*
1218    ** Get program or data offset, depending on "data" flag
1219    */
1220    i = data ? img_hdr->page[ Page].d_offset : img_hdr->page[ Page].p_offset;
1221
1222    /*
1223    ** Copy data/program to buffer
1224    */
1225
1226    i /= 4; // Adjust offset for byte-to-UINT for array operation
1227
1228    p = (u32 *)img_hdr + i;
1229    for(i = 0; i < size; i++)
1230        Buffer[i] = *p++;
1231    /*
1232    ** Pass back data/program destination address
1233    */
1234    *Dest = data ? img_hdr->page[Page].d_dest : img_hdr->page[Page].p_dest;
1235
1236    return size;
1237}
1238
1239MEI_ERROR meiCMV(u16 * request, int reply) // write cmv to arc, if reply needed, wait for reply
1240{
1241        MEI_ERROR meierror;
1242        wait_queue_t wait;
1243        
1244        cmv_reply=reply;
1245        
1246        meierror = meiMailboxWrite(request, MSG_LENGTH);
1247    
1248        if(meierror != MEI_SUCCESS){
1249#ifdef AMAZON_MEI_DEBUG_ON
1250                printk("\n\n MailboxWrite Fail.");
1251#endif
1252                return meierror;
1253        }
1254        else{
1255                cmv_count++;
1256    }
1257
1258        if(cmv_reply == NO_REPLY)
1259                return MEI_SUCCESS;
1260
1261        init_waitqueue_entry(&wait, current);
1262        add_wait_queue(&wait_queue_arcmsgav, &wait);
1263        set_current_state(TASK_INTERRUPTIBLE);
1264// cmv_waiting=1;
1265    
1266        if(arcmsgav==1){
1267                set_current_state(TASK_RUNNING);
1268                remove_wait_queue(&wait_queue_arcmsgav, &wait);
1269        }
1270        else{
1271                schedule_timeout(CMV_TIMEOUT);
1272                remove_wait_queue(&wait_queue_arcmsgav, &wait);
1273        }
1274    if(arcmsgav==0){//CMV_timeout
1275        cmv_waiting=0;
1276        arcmsgav=0;
1277#ifdef AMAZON_MEI_DEBUG_ON
1278        printk("\nmeiCMV: MEI_MAILBOX_TIMEOUT\n");
1279#endif
1280        return MEI_MAILBOX_TIMEOUT;
1281    }
1282    else{
1283            arcmsgav=0;
1284                reply_count++;
1285            return MEI_SUCCESS;
1286    }
1287}
1288
1289//TODO, for loopback test
1290#ifdef DFE_LOOPBACK
1291#define mte_reg_base (0x4800*4+0x20000)
1292 
1293/* Iridia Registers Address Constants */
1294#define MTE_Reg(r) (int)(mte_reg_base + (r*4))
1295 
1296#define IT_AMODE MTE_Reg(0x0004)
1297
1298
1299#define OMBOX_BASE 0x15F80
1300#define IMBOX_BASE 0x15FC0
1301
1302#define TIMER_DELAY (1024)
1303#define BC0_BYTES (32)
1304#define BC1_BYTES (30)
1305#define NUM_MB (12)
1306#define TIMEOUT_VALUE 2000
1307
1308void BFMWait (u32 cycle) {
1309  u32 i;
1310  for (i = 0 ; i< cycle ; i++);
1311}
1312
1313void WriteRegLong(u32 addr, u32 data){
1314  //printk("[%8x] <= %8x \n\n", addr, data);
1315  *((volatile u32 *)(addr)) = data;
1316}
1317
1318u32 ReadRegLong (u32 addr) {
1319  u32 rd_val;
1320  
1321  rd_val = *((volatile u32 *)(addr));
1322  //printk("[%8x] => %8x \n\n", addr, rd_val);
1323  return rd_val;
1324
1325}
1326
1327/* This routine writes the mailbox with the data in an input array */
1328void WriteMbox(u32 *mboxarray,u32 size) {
1329  u32 i;
1330  
1331  WriteRegLong(MEI_XFR_ADDR,IMBOX_BASE);
1332  for (i=0;i<size;i++) {
1333    WriteRegLong(MEI_DATA_XFR,*(mboxarray+i));
1334  }
1335}
1336
1337/* This routine reads the output mailbox and places the results into an array */
1338void ReadMbox(u32 *mboxarray,u32 size) {
1339  u32 i;
1340  
1341  WriteRegLong(MEI_XFR_ADDR,OMBOX_BASE);
1342  for (i=0;i<size;i++) {
1343    mboxarray[i] = ReadRegLong(MEI_DATA_XFR);
1344  }
1345}
1346
1347void MEIWriteARCValue(u32 address, u32 value)
1348{
1349  u32 i,check = 0;
1350  /* Write address register */
1351  *((volatile u32 *)MEI_DEBUG_WAD) = address;
1352
1353  /* Write data register */
1354  *((volatile u32 *)MEI_DEBUG_DATA) = value;
1355
1356  /* wait until complete - timeout at 40*/
1357  for (i=0;i<40;i++) {
1358    check = *((volatile u32 *)ARC_TO_MEI_INT);
1359    if ((check & 0x20)) break;
1360    //printk("MEIWriteARCValue: check:%8x\n\n", check);
1361    }
1362
1363  /* clear the flag */
1364  *((volatile u32 *)ARC_TO_MEI_INT) = 0x20;
1365
1366}
1367
1368
1369void post_mei_init(void)
1370{
1371u32 mailbox[NUM_MB];
1372
1373  mailbox[0] = TIMER_DELAY;
1374 
1375  /* set bytes per bearer channel */
1376  mailbox[1] = BC0_BYTES;
1377  mailbox[2] = BC1_BYTES;
1378  WriteMbox(mailbox, 3);
1379
1380  WriteRegLong(AAI_ACCESS, 0x00000001);
1381
1382  /* enable ADSL block clock, ac_clk */
1383  WriteRegLong(MEI_CONTROL, 0x01);
1384  WriteRegLong(MEI_DEBUG_DEC, 0x00000001); // select ld/st space
1385  MEIWriteARCValue(0x31F00, 0x00000010); // write CRI_CCR0 to enable ac_clk
1386
1387  /* set the MTE to register start */
1388  MEIWriteARCValue(IT_AMODE, 0xF);
1389  BFMWait(10);
1390}
1391
1392
1393int wait_sync(void)
1394{
1395u32 mailbox[NUM_MB];
1396  /* wait for ATM sync to be achieved on both BC0 and BC1 */
1397  u32 timeout=0;
1398  ReadMbox(mailbox, 1);
1399  u32 readval = mailbox[0];
1400  while( ((readval & 0xFFFFFFFF) == 0) && (timeout < TIMEOUT_VALUE) ) {
1401    BFMWait(1);
1402    //printk("wait_sync\n\n");
1403    ReadMbox(mailbox, 1);
1404    readval = mailbox[0];
1405    timeout++;
1406  }
1407  if(timeout == TIMEOUT_VALUE)return 0;
1408  else return 1;
1409}
1410#endif //DFE_LOOPBACK
1411//end of TODO, for loopback test
1412
1413MEI_ERROR meiForceRebootAdslModem(void)
1414{
1415#if 0
1416//#ifdef ARC_READY_ACK
1417        if(down_interruptible(&mei_sema)) //disable CMV access until ARC ready
1418        {
1419                    return -ERESTARTSYS;
1420        }
1421#endif
1422    if(reboot_firsttime==1){//000002:fchang Start
1423        // reset ARC
1424        *((volatile u32 *)0xB0100910) = 0x80; //reset DFE
1425        asm("SYNC");
1426        *((volatile u32 *)0xB0100910) = 0x0;
1427        asm("SYNC");
1428        if((*((volatile u32 *)0xB0100910))!=0x0)
1429#ifdef AMAZON_MEI_DEBUG_ON
1430            printk("\n reset DFE fail");
1431#endif
1432        
1433        // reset ARC
1434        meiLongwordWrite(MEI_CONTROL, SOFT_RESET);
1435        asm("SYNC");
1436        meiLongwordWrite(MEI_CONTROL, 0);
1437        asm("SYNC");
1438
1439    } //000002:fchang End
1440#ifdef DFE_LOOPBACK
1441                img_hdr=(ARC_IMG_HDR *)lp_image;
1442#else
1443        img_hdr=(ARC_IMG_HDR *)image_buffer;
1444#endif
1445// printk("\n\n enter haltarc");
1446                meiHaltArc();
1447// printk("\n\n haltarc done");
1448//000002:fchang Start
1449    if(reboot_firsttime==0){
1450        printk("\n\n new reboot");
1451        meiResetArc();
1452        meiResetCore();
1453    }
1454    if(reboot_firsttime==1)
1455                meiDownloadBootCode();
1456    else
1457        mei_ioctl((struct inode *)NULL, (struct file *)NULL, AMAZON_MEI_DOWNLOAD, (unsigned long)NULL);
1458
1459//000002:fchang End
1460#ifdef AMAZON_MEI_DEBUG_ON
1461// printk("\n\n Download Done");
1462#endif
1463
1464#ifdef DFE_LOOPBACK
1465        post_mei_init();
1466#endif
1467
1468// sema_init(&mei_sema, 1);
1469        //up(&mei_sema);
1470
1471// enable_irq(AMAZON_MEI_INT);
1472                    
1473        meiRunArc();
1474//000002:fchang Start
1475    if(reboot_firsttime==0){
1476        meiEnalbeMailboxInt();
1477    }
1478//000002:fchang End
1479        
1480#ifdef AMAZON_MEI_DEBUG_ON
1481// printk("\n\n ARC Running");
1482#endif
1483        
1484#ifdef AMAZON_MEI_DEBUG_ON //to test ac_clk setting correctness
1485    {
1486    u32 arc_control_mode;
1487    u32 arc_debug_addr = 0x31F00;
1488    u32 arc_debug_data = 0x10;
1489    meiLongwordRead(MEI_CONTROL, &arc_control_mode);
1490    arc_control_mode |= (HOST_MSTR);
1491    meiLongwordWrite(MEI_CONTROL, arc_control_mode);
1492    
1493    meiLongwordWrite(MEI_DEBUG_DEC, MEI_DEBUG_DEC_DMP1_MASK);
1494    meiLongwordWrite(MEI_DEBUG_RAD, arc_debug_addr);
1495    meiPollForDbgDone();
1496    meiLongwordRead(MEI_DEBUG_DATA, &arc_debug_data);
1497
1498    meiLongwordRead(MEI_CONTROL, &arc_control_mode);
1499    arc_control_mode &= ~(HOST_MSTR);
1500    meiLongwordWrite(MEI_CONTROL, arc_control_mode);
1501    
1502// printk("\n\n ac_clk is %8x\n", arc_debug_data);
1503    }
1504#endif
1505            
1506        
1507#ifdef DFE_LOOPBACK
1508        if (wait_sync() == 0){
1509            printk("ARC fails to run: time out\n\n");
1510        }else{
1511// printk("ARC is ready\n\n");
1512        }
1513#endif
1514        if(reboot_firsttime==1) //000002:fchang
1515            reboot_firsttime=0; //000002:fchang
1516        
1517                return MEI_SUCCESS;
1518}
1519
1520//////////////////// procfs debug ////////////////////////////////////////////////////////
1521#define MEI_DIRNAME "mei"
1522static struct proc_dir_entry *meidir;
1523
1524static ssize_t proc_write(struct file *, const char *, size_t, loff_t *);
1525static ssize_t proc_read(struct file *, char *, size_t, loff_t *);
1526
1527static struct file_operations proc_operations = {
1528    read: proc_read,
1529    write: proc_write,
1530};
1531
1532typedef struct reg_entry {
1533    int * flag;
1534    char name[30]; // big enough to hold names
1535    char description[100]; // big enough to hold description
1536    unsigned short low_ino;
1537} reg_entry_t;
1538
1539static reg_entry_t regs[PROC_ITEMS]; // total items to be monitored by /proc/mei
1540
1541#define NUM_OF_REG_ENTRY (sizeof(regs)/sizeof(reg_entry_t))
1542
1543static int proc_read(struct file * file, char * buf, size_t nbytes, loff_t *ppos)
1544{
1545        int i_ino = (file->f_dentry->d_inode)->i_ino;
1546    char outputbuf[64];
1547    int count=0;
1548    int i;
1549    u32 version=0;
1550    reg_entry_t* current_reg=NULL;
1551    
1552    for (i=0;i<NUM_OF_REG_ENTRY;i++) {
1553        if (regs[i].low_ino==i_ino) {
1554            current_reg = &regs[i];
1555            break;
1556        }
1557    }
1558    if (current_reg==NULL)
1559        return -EINVAL;
1560    
1561    if (current_reg->flag == (int *) 8){
1562    ///proc/mei/version
1563    //format:
1564    //Firmware version: major.minor.sub_version.int_version.rel_state.spl_appl
1565    //Firmware Date Time Code: date/month min:hour
1566        if (*ppos>0) /* Assume reading completed in previous read*/
1567            return 0; // indicates end of file
1568        if(down_interruptible(&mei_sema))
1569                    return -ERESTARTSYS;
1570        
1571        //if (indicator_count != 1){
1572        if (indicator_count < 1){
1573            up(&mei_sema);
1574            return -EAGAIN;
1575        }
1576        //major:bits 0-7
1577        //minor:bits 8-15
1578        makeCMV(H2D_CMV_READ, INFO, 54, 0, 1, NULL);
1579        if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
1580#if 0
1581#ifdef AMAZON_MEI_DEBUG_ON
1582            printk("\n\n WINHOST CMV fail");
1583#endif
1584#endif
1585            up(&mei_sema);
1586            return -EIO;
1587        }
1588        version = RxMessage[4];
1589        count = sprintf(outputbuf, "%d.%d.",(version)&0xff,(version>>8)&0xff);
1590        
1591        //sub_version:bits 4-7
1592        //int_version:bits 0-3
1593        //spl_appl:bits 8-13
1594        //rel_state:bits 14-15
1595        makeCMV(H2D_CMV_READ, INFO, 54, 1, 1, NULL);
1596        if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
1597#if 0
1598#ifdef AMAZON_MEI_DEBUG_ON
1599            printk("\n\n WINHOST CMV fail");
1600#endif
1601#endif
1602            up(&mei_sema);
1603            return -EFAULT;
1604        }
1605        version =RxMessage[4];
1606        count += sprintf(outputbuf+count, "%d.%d.%d.%d",
1607                (version>>4)&0xf,
1608                version&0xf,
1609                (version>>14)&0x3,
1610                (version>>8)&0x3f);
1611#ifdef ADSL_LED_SUPPORT
1612// version check -start for adsl led
1613        if ((((version>>4)&0xf)==2)&&((version&0xf)>=3)&&((version&0xf)<7)) firmware_support_led=1;
1614        else if ((((version>>4)&0xf)==2)&&((version&0xf)>=7)) firmware_support_led=2;
1615        else if (((version>>4)&0xf)>2) firmware_support_led=2;
1616
1617//165001:henryhsu:20050906:Modify for adsl firmware version 1.2.1.2.0.1 DATA_LED can't flash.
1618    //else firmware_support_led=0;
1619    else firmware_support_led=2;
1620//165001
1621
1622
1623// version check -end
1624#endif
1625        //Date:bits 0-7
1626        //Month:bits 8-15
1627        makeCMV(H2D_CMV_READ, INFO, 55, 0, 1, NULL);
1628        if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
1629#if 0
1630#ifdef AMAZON_MEI_DEBUG_ON
1631            printk("\n\n WINHOST CMV fail");
1632#endif
1633#endif
1634            up(&mei_sema);
1635            return -EIO;
1636        }
1637        version = RxMessage[4];
1638        
1639        //Hour:bits 0-7
1640        //Minute:bits 8-15
1641        makeCMV(H2D_CMV_READ, INFO, 55, 1, 1, NULL);
1642        if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
1643#if 0
1644#ifdef AMAZON_MEI_DEBUG_ON
1645            printk("\n\n WINHOST CMV fail");
1646#endif
1647#endif
1648            up(&mei_sema);
1649            return -EFAULT;
1650        }
1651        version += (RxMessage[4]<<16);
1652        count += sprintf(outputbuf+count, " %d/%d %d:%d\n"
1653                ,version&0xff
1654                ,(version>>8)&0xff
1655                ,(version>>25)&0xff
1656                ,(version>>16)&0xff);
1657                
1658        up(&mei_sema);
1659        
1660        *ppos+=count;
1661    }else if(current_reg->flag != (int *)Recent_indicator){
1662            if (*ppos>0) /* Assume reading completed in previous read*/
1663            return 0; // indicates end of file
1664        count = sprintf(outputbuf, "0x%08X\n\n", *(current_reg->flag));
1665            *ppos+=count;
1666            if (count>nbytes) /* Assume output can be read at one time */
1667            return -EINVAL;
1668        }else{
1669            if((int)(*ppos)/((int)7)==16)
1670                    return 0; // indicate end of the message
1671            count = sprintf(outputbuf, "0x%04X\n\n", *(((u16 *)(current_reg->flag))+ (int)(*ppos)/((int)7)));
1672                *ppos+=count;
1673    }
1674    if (copy_to_user(buf, outputbuf, count))
1675        return -EFAULT;
1676    return count;
1677}
1678
1679static ssize_t proc_write(struct file * file, const char * buffer, size_t count, loff_t *ppos)
1680{
1681    int i_ino = (file->f_dentry->d_inode)->i_ino;
1682    reg_entry_t* current_reg=NULL;
1683    int i;
1684    unsigned long newRegValue;
1685    char *endp;
1686
1687    for (i=0;i<NUM_OF_REG_ENTRY;i++) {
1688        if (regs[i].low_ino==i_ino) {
1689            current_reg = &regs[i];
1690            break;
1691        }
1692    }
1693    if ((current_reg==NULL) || (current_reg->flag == (int *)Recent_indicator))
1694        return -EINVAL;
1695
1696    newRegValue = simple_strtoul(buffer,&endp,0);
1697    *(current_reg->flag)=(int)newRegValue;
1698    return (count+endp-buffer);
1699}
1700////////////////makeCMV(Opcode, Group, Address, Index, Size, Data), CMV in u16 TxMessage[MSG_LENGTH]///////////////////////////
1701void makeCMV(u8 opcode, u8 group, u16 address, u16 index, int size, u16 * data)
1702{
1703    memset(TxMessage, 0, MSG_LENGTH*2);
1704    TxMessage[0]= (opcode<<4) + (size&0xf);
1705    TxMessage[1]= (((index==0)?0:1)<<7) + (group&0x7f);
1706    TxMessage[2]= address;
1707    TxMessage[3]= index;
1708    if(opcode == H2D_CMV_WRITE)
1709        memcpy(TxMessage+4, data, size*2);
1710    return;
1711}
1712
1713////////////////makeCMV(Opcode, Group, Address, Index, Size, Data), CMV in u16 TxMessage[MSG_LENGTH]///////////////////////////
1714void makeCMV_local(u8 opcode, u8 group, u16 address, u16 index, int size, u16 * data,u16 *CMVMSG)
1715{
1716    memset(CMVMSG, 0, MSG_LENGTH*2);
1717    CMVMSG[0]= (opcode<<4) + (size&0xf);
1718    CMVMSG[1]= (((index==0)?0:1)<<7) + (group&0x7f);
1719    CMVMSG[2]= address;
1720    CMVMSG[3]= index;
1721    if(opcode == H2D_CMV_WRITE)
1722        memcpy(CMVMSG+4, data, size*2);
1723    return;
1724}
1725
1726//////////////// Driver Structure /////////////////////////////////////////////////////////////////////////////
1727static ssize_t mei_write(struct file *, const char *, size_t, loff_t *);
1728static int mei_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
1729
1730static struct file_operations mei_operations = {
1731        write: mei_write,
1732        ioctl: mei_ioctl,
1733};
1734
1735
1736static ssize_t mei_write(struct file * filp, const char * buf, size_t size, loff_t * loff)
1737{
1738// printk("\n\n mei_write entered");
1739// image_buffer = (u32 *)kmalloc(size, GFP_KERNEL);
1740    image_buffer = (u32 *)vmalloc(size);
1741// printk("\n\n image_buffer kmalloc done");
1742    if(image_buffer == NULL){
1743#ifdef AMAZON_MEI_DEBUG_ON
1744// printk("\n\n kmalloc for firmware image fail");
1745        printk("\n\n vmalloc for firmware image fail");
1746#endif
1747        return -1;
1748    }
1749    copy_from_user((char *)image_buffer, buf, size);
1750// printk("\n\n copy_from_user done");
1751        return size;
1752}
1753
1754    ////////// ISR GPTU Timer 6 for high resolution timer /////////////
1755void amazon_timer6_interrupt_MEI(int irq, void *dev_id, struct pt_regs *regs)
1756{
1757    int i,j;
1758    u32 temp;
1759    u16 temp16;
1760    u16 rdindex, wrindex;
1761    u16 num_rd=0; //num of byte can be read
1762    u16 bytes_to_wr=0;
1763    
1764// printk("\n\nenter timer\n\n");
1765    irqtimes++;
1766// printk("\n%d\n",irqtimes);
1767
1768
1769/*
1770#ifdef PCM_ACCESS_DEBUG
1771        meiDebugRead_8(0x30f20, &temp, 1);
1772#else
1773        meiDMARead_8(0x30f20, &temp, 1);
1774#endif
1775    if((temp&0x4000)!=0){
1776        printk("\nER_ERR");
1777#ifdef PCM_ACCESS_DEBUG
1778        meiDebugWrite_8(0x30f20, &temp, 1);
1779#else
1780        meiDMAWrite_8(0x30f20, &temp, 1);
1781#endif
1782#ifdef PCM_ACCESS_DEBUG
1783        meiDebugRead_8(0x30f20, &temp, 1);
1784#else
1785        meiDMARead_8(0x30f20, &temp, 1);
1786#endif
1787        if((temp&0x4000)!=0)
1788            printk("\nER_ERR not cleared");
1789    }
1790*/
1791    
1792    for(i=PCM_CHANNEL_NUM-1;i>=0;i--){// start from last channel, which is rx
1793#ifdef PCM_ACCESS_DEBUG
1794        meiDebugRead_16(pcm_start_addr+i*16+12, &temp, 1);
1795#else
1796        meiDMARead_16(pcm_start_addr+i*16+12, &temp, 1);
1797#endif
1798        wrindex = (u16)((temp & 0xffff0000)>>16);
1799// printk(" %d",wrindex);
1800#ifdef PCM_ACCESS_DEBUG
1801        meiDebugRead_16(pcm_start_addr+i*16+8, &temp, 1);
1802#else
1803        meiDMARead_16(pcm_start_addr+i*16+8, &temp, 1);
1804#endif
1805        rdindex = (u16)(temp & 0xffff);
1806// printk(" %d",rdindex);
1807        if(rdindex<=wrindex)
1808            num_rd=((wrindex-rdindex)/4)*4; //read multiply of 4 bytes
1809        else
1810            num_rd=((pcm_data[i].len-(rdindex-wrindex))/4)*4; //read multiply of 4 bytes
1811        
1812        if(i%2!=0){//rx channel
1813            pcm_data[i].point=0;
1814            for(j=0;j<num_rd/4;j++){
1815                if(pcm_data[i].finish!=1){
1816                    if((rdindex+j*4)>=pcm_data[i].len)
1817                        temp16=(rdindex+j*4) - pcm_data[i].len;
1818                    else
1819                        temp16=rdindex+j*4;
1820#ifdef PCM_ACCESS_DEBUG
1821                    meiDebugRead_8((((u32)(pcm_data[i].LSW))+(((u32)(pcm_data[i].MSW))<<16))+temp16, (u32*)(pcm_data[i].buff+pcm_data[i].point), 1);
1822#else
1823                    meiDMARead_8((((u32)(pcm_data[i].LSW))+(((u32)(pcm_data[i].MSW))<<16))+temp16, (u32*)(pcm_data[i].buff+pcm_data[i].point), 1);
1824#endif
1825                // printk(" %8x", *((u32*)(pcm_data[i].buff+pcm_data[i].point)));
1826                /* if(pcm_data[i].point==0){
1827                        if(pcm_data[i].buff[0]==0xA5){// start of loopback data
1828                            pcm_data[i].point+=4;
1829                            printk("\nstart receive data");
1830                        }
1831                    }
1832                    else*/
1833                        pcm_data[i].point+=4;
1834                /* if(pcm_data[i].point==PCM_BUFF_SIZE){ //finish rx
1835                        pcm_data[i].finish=1;
1836                        printk("\nchannel[%d] finished", i);
1837                    } */
1838                }
1839            }
1840            if(firsttime[i]==1){
1841                for(j=0;j<num_rd;j++){
1842                    if(pcm_data[i].buff[j]==0x1){
1843                        num_cmp[i]=num_rd-j;
1844                        firsttime[i]=0;
1845                        break;
1846                    }
1847                }
1848                if(memcmp(sampledata+1, pcm_data[i].buff+j, num_cmp[i])!=0)
1849                    printk("\n\ndata wrong,1st\n\n");
1850                else
1851                    pcm_start_loc[i] = num_cmp[i]+1;
1852            }
1853            else{
1854                if(memcmp(sampledata+pcm_start_loc[i], pcm_data[i].buff, num_rd)!=0)
1855                    printk("\n\ndata wrong\n\n");
1856                else{
1857                    pcm_start_loc[i]+=num_rd;
1858                    if(pcm_start_loc[i]>=256)
1859                        pcm_start_loc[i]=pcm_start_loc[i]-256;
1860                }
1861            }
1862            
1863            rdindex +=num_rd;
1864            if(rdindex>=pcm_data[i].len)
1865                rdindex=rdindex-pcm_data[i].len;
1866#ifdef PCM_ACCESS_DEBUG
1867            meiDebugRead_16(pcm_start_addr+i*16+8, &temp, 1);
1868#else
1869            meiDMARead_16(pcm_start_addr+i*16+8, &temp, 1);
1870#endif
1871            temp= (temp & 0xffff0000) + rdindex;
1872#ifdef PCM_ACCESS_DEBUG
1873            meiDebugWrite_16(pcm_start_addr+i*16+8, &temp, 1); // update rdindex
1874#else
1875            meiDMAWrite_16(pcm_start_addr+i*16+8, &temp, 1); // update rdindex
1876#endif
1877            
1878            bytes_to_wr = num_rd;
1879            
1880    // if(bytes_to_wr>0){
1881        // printk(" %d", num_rd);
1882        // printk(" %d", rdindex);
1883// printk("\n\nrdindex = %d", rdindex);
1884            //}
1885        }
1886        else{ //tx channel
1887    // if((bytes_to_wr + num_rd) < pcm_data[i].len){
1888                for(j=0;j<bytes_to_wr/4;j++){
1889                    if(pcm_data[i].finish!=1){
1890                        if((wrindex+j*4)>=pcm_data[i].len)
1891                            temp16=(wrindex+j*4) - pcm_data[i].len;
1892                        else
1893                            temp16=wrindex + j*4;
1894/*
1895#ifdef PCM_ACCESS_DEBUG
1896                        meiDebugWrite_8((((u32)(pcm_data[i].LSW))+(((u32)(pcm_data[i].MSW))<<16))+temp16,(u32*)(pcm_data[i+1].buff+j*4), 1);
1897#else
1898                        meiDMAWrite_8((((u32)(pcm_data[i].LSW))+(((u32)(pcm_data[i].MSW))<<16))+temp16,(u32*)(pcm_data[i+1].buff+j*4), 1);
1899#endif*/
1900                            
1901#ifdef PCM_ACCESS_DEBUG
1902                        meiDebugWrite_8((((u32)(pcm_data[i].LSW))+(((u32)(pcm_data[i].MSW))<<16))+temp16,(u32*)(pcm_data[i].buff+pcm_data[i].point), 1);
1903                // meiDebugWrite_8((((u32)(pcm_data[i].LSW))+(((u32)(pcm_data[i].MSW))<<16))+temp16,(u32*)(pcm_data[i].buff), 1);
1904#else
1905                        meiDMAWrite_8((((u32)(pcm_data[i].LSW))+(((u32)(pcm_data[i].MSW))<<16))+temp16,(u32*)(pcm_data[i].buff+pcm_data[i].point), 1);
1906#endif
1907                        pcm_data[i].point+=4;
1908                        if(pcm_data[i].point==PCM_BUFF_SIZE){
1909                    // pcm_data[i].finish=1;
1910                    // printk("\nchannel[%d] finished", i);
1911                            pcm_data[i].point=0;
1912                        }
1913                    }
1914                }
1915                wrindex+=bytes_to_wr;
1916                if(wrindex>=pcm_data[i].len)
1917                    wrindex=wrindex-pcm_data[i].len;
1918#ifdef PCM_ACCESS_DEBUG
1919                meiDebugRead_16(pcm_start_addr+i*16+12, &temp, 1);
1920#else
1921                meiDMARead_16(pcm_start_addr+i*16+12, &temp, 1);
1922#endif
1923                temp=(temp&0xffff) + (wrindex<<16);
1924#ifdef PCM_ACCESS_DEBUG
1925                meiDebugWrite_16(pcm_start_addr+i*16+12, &temp, 1); // update wrindex
1926#else
1927                meiDMAWrite_16(pcm_start_addr+i*16+12, &temp, 1); // update wrindex
1928#endif
1929            
1930                //if(bytes_to_wr>0){
1931            // printk(" %d", bytes_to_wr);
1932            // printk(" %d", wrindex);
1933// printk("\n\nwrindex = %d", wrindex);
1934                //}
1935        // }
1936        }
1937    }
1938    return;
1939}
1940//000002:fchang Start
1941static int meiResetArc(void)
1942{
1943    u32 auxreg0;
1944    u32 auxreg5;
1945    int flshcnt=0;
1946    int flshcnt1=0;
1947    int flshcnt2=0;
1948    
1949    meiLongwordWrite(MEI_CONTROL, 1);
1950    meiLongwordWrite(MEI_DEBUG_DEC, 3);
1951    meiLongwordWrite(MEI_DEBUG_WAD, 0x3c);
1952    meiLongwordWrite(MEI_DEBUG_DATA, 0x10);
1953    meiPollForDbgDone();
1954    meiLongwordWrite(MEI_DEBUG_DEC, 0x0);
1955    meiLongwordWrite(MEI_DEBUG_WAD, 0x2);
1956    meiLongwordWrite(MEI_DEBUG_DATA, 0x0);
1957    meiPollForDbgDone();
1958    meiLongwordWrite(MEI_DEBUG_WAD, 0x3);
1959    meiLongwordWrite(MEI_DEBUG_DATA, 0x0);
1960    meiPollForDbgDone();
1961    meiLongwordWrite(MEI_DEBUG_DEC, 0x0);
1962    meiLongwordWrite(MEI_DEBUG_RAD, 0x0);
1963    meiPollForDbgDone();
1964    meiLongwordRead(MEI_DEBUG_DATA, &auxreg0);
1965    auxreg0 = auxreg0 & 0x03ffffff;
1966    meiLongwordWrite(MEI_DEBUG_WAD, 0x0);
1967    meiLongwordWrite(MEI_DEBUG_DATA, auxreg0);
1968    meiPollForDbgDone();
1969    meiLongwordWrite(MEI_DEBUG_WAD, 0x10a);
1970    meiLongwordWrite(MEI_DEBUG_DATA, 0x0);
1971    meiPollForDbgDone();
1972    meiLongwordWrite(MEI_DEBUG_DEC, 0x2);
1973    meiLongwordWrite(MEI_DEBUG_WAD, 0xfffc);
1974    meiLongwordWrite(MEI_DEBUG_DATA, 0x1fffffff);
1975    meiPollForDbgDone();
1976    while(flshcnt<3){
1977        meiLongwordWrite(MEI_DEBUG_DEC, 0x0);
1978        meiLongwordWrite(MEI_DEBUG_RAD, 0x0);
1979        meiPollForDbgDone();
1980        meiLongwordRead(MEI_DEBUG_DATA, &auxreg0);
1981        auxreg0 = auxreg0 & 0xff000000;
1982        auxreg0 = auxreg0 | 0x3fff;
1983        meiLongwordWrite(MEI_DEBUG_WAD, 0x0);
1984        meiLongwordWrite(MEI_DEBUG_DATA, auxreg0);
1985        meiPollForDbgDone();
1986        
1987        meiLongwordWrite(MEI_DEBUG_DEC, 0x0);
1988        meiLongwordWrite(MEI_DEBUG_RAD, 0x5);
1989        meiPollForDbgDone();
1990        meiLongwordRead(MEI_DEBUG_DATA, &auxreg5);
1991        auxreg5 = auxreg5 | 0x801;
1992        meiLongwordWrite(MEI_DEBUG_WAD, 0x5);
1993        meiLongwordWrite(MEI_DEBUG_DATA, auxreg5);
1994        meiPollForDbgDone();
1995        meiLongwordWrite(MEI_DEBUG_RAD, 0x0);
1996        meiPollForDbgDone();
1997        meiLongwordRead(MEI_DEBUG_DATA, &auxreg0);
1998        auxreg0 = auxreg0 & 0x00ffffff;
1999        if(auxreg0 == 0x4000)
2000            flshcnt = flshcnt+1;
2001        else{
2002            if(flshcnt == 0)
2003                flshcnt1 = flshcnt1 +1;
2004            else
2005                flshcnt2 = flshcnt2 +1;
2006        }
2007    }
2008    
2009    return 1;
2010}
2011
2012static int meiResetCore(void)
2013{
2014    meiLongwordWrite(MEI_CONTROL, 0x1);
2015    meiLongwordWrite(MEI_DEBUG_DEC, 0x2);
2016    meiLongwordWrite(MEI_DEBUG_WAD, 0x31f10);
2017    meiLongwordWrite(MEI_DEBUG_DATA, 0xf);
2018    meiPollForDbgDone();
2019    meiLongwordWrite(MEI_DEBUG_WAD, 0x31f10);
2020    meiLongwordWrite(MEI_DEBUG_DATA, 0x0);
2021    meiPollForDbgDone();
2022    meiLongwordWrite(MEI_DEBUG_WAD, 0x31f00);
2023    meiLongwordWrite(MEI_DEBUG_DATA, 0x55);
2024    meiPollForDbgDone();
2025    return 1;
2026}
2027
2028static int meiEnalbeMailboxInt(void)
2029{
2030    u32 arc2meiintmsk;
2031    meiLongwordRead(ARC_TO_MEI_INT_MASK, &arc2meiintmsk);
2032    arc2meiintmsk = arc2meiintmsk | 0x1;
2033    meiLongwordWrite(ARC_TO_MEI_INT_MASK, arc2meiintmsk);
2034    meiLongwordWrite(MEI_CONTROL, 0x0);
2035    return 1;
2036}
2037
2038
2039
2040//000002:fchang End
2041
2042static int mei_ioctl(struct inode * ino, struct file * fil, unsigned int command, unsigned long lon)
2043{
2044        int i,k;
2045    u32 boot_loop;
2046    u32 page_size;
2047    u32 dest_addr;
2048    u32 j;
2049    u32 temp;
2050    u32 temp2;
2051    u16 trapsflag=0;
2052    amazon_clreoc_pkt * current_clreoc;
2053    struct timeval time_now;
2054    struct timeval time_fini;
2055    struct list_head * ptr;
2056    amazon_mei_mib * mib_ptr;
2057// u16 buff[MSG_LENGTH]__attribute__ ((aligned(4)));
2058    structpts pts;
2059        int meierr=MEI_SUCCESS;
2060    u16 data[12]; //used in makeCMV, to pass in payload when CMV set, ignored when CMV read.
2061    meireg regrdwr;
2062    meidebug debugrdwr;
2063    amazon_mei_mib * temp_intvl;
2064    struct sk_buff * eoc_skb;
2065// 603221:tc.chen start
2066    u16 hdlc_cmd[2];
2067    u16 hdlc_rx_buffer[32];
2068    int hdlc_rx_len=0;
2069// 603221:tc.chen end
2070    
2071    int from_kernel = 0;//joelin
2072    if (ino == (struct inode *)0) from_kernel = 1;//joelin
2073    
2074// printk("\n switch.command = %i\n", command);
2075        switch(command){
2076        case GET_ADSL_LINE_CODE:
2077            pts.adslLineTableEntry_pt = (adslLineTableEntry *)kmalloc(sizeof(adslLineTableEntry), GFP_KERNEL);
2078            copy_from_user((char *)pts.adslLineTableEntry_pt, (char *)lon, sizeof(adslLineTableEntry));
2079            if(IS_FLAG_SET((&(pts.adslLineTableEntry_pt->flags)), LINE_CODE_FLAG)){
2080                pts.adslLineTableEntry_pt->adslLineCode = 2;
2081            }
2082            copy_to_user((char *)lon, (char *)pts.adslLineTableEntry_pt, sizeof(adslLineTableEntry));
2083            kfree(pts.adslLineTableEntry_pt);
2084            break;
2085#ifdef AMAZON_MEI_MIB_RFC3440
2086        case GET_ADSL_ATUC_LINE_EXT:
2087            if(down_interruptible(&mei_sema))
2088                        return -ERESTARTSYS;
2089            pts.adslLineExtTableEntry_pt = (adslLineExtTableEntry *)kmalloc(sizeof(adslLineExtTableEntry), GFP_KERNEL);
2090            copy_from_user((char *)pts.adslLineExtTableEntry_pt, (char *)lon, sizeof(adslLineExtTableEntry));
2091            if(IS_FLAG_SET((&(pts.adslLineExtTableEntry_pt->flags)), ATUC_LINE_TRANS_CAP_FLAG)){
2092                ATUC_LINE_TRANS_CAP_FLAG_MAKECMV;
2093                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2094#ifdef AMAZON_MEI_DEBUG_ON
2095                    printk("\n\nCMV fail, Group 3 Address 67 Index 0");
2096#endif
2097                    CLR_FLAG((&(pts.adslLineExtTableEntry_pt->flags)), ATUC_LINE_TRANS_CAP_FLAG);
2098                }
2099                else{
2100                    memcpy((&(pts.adslLineExtTableEntry_pt->adslLineTransAtucCap)), RxMessage+4, ((RxMessage[0]&0xf)*2));
2101                }
2102            }
2103            if(IS_FLAG_SET((&(pts.adslLineExtTableEntry_pt->flags)), ATUC_LINE_TRANS_CONFIG_FLAG)){
2104                ATUC_LINE_TRANS_CONFIG_FLAG_MAKECMV;
2105                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2106#ifdef AMAZON_MEI_DEBUG_ON
2107                    printk("\n\nCMV fail, Group 3 Address 67 Index 0");
2108#endif
2109                    CLR_FLAG((&(pts.adslLineExtTableEntry_pt->flags)), ATUC_LINE_TRANS_CONFIG_FLAG);
2110                }
2111                else{
2112                    memcpy((&(pts.adslLineExtTableEntry_pt->adslLineTransAtucConfig)), RxMessage+4, ((RxMessage[0]&0xf)*2));
2113                }
2114            }
2115            if(IS_FLAG_SET((&(pts.adslLineExtTableEntry_pt->flags)), ATUC_LINE_TRANS_ACTUAL_FLAG)){
2116                ATUC_LINE_TRANS_ACTUAL_FLAG_MAKECMV;
2117                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2118#ifdef AMAZON_MEI_DEBUG_ON
2119                    printk("\n\nCMV fail, Group 2 Address 1 Index 0");
2120#endif
2121                    CLR_FLAG((&(pts.adslLineExtTableEntry_pt->flags)), ATUC_LINE_TRANS_ACTUAL_FLAG);
2122                }
2123                else{
2124                    memcpy((&(pts.adslLineExtTableEntry_pt->adslLineTransAtucActual)), RxMessage+4, ((RxMessage[0]&0xf)*2));
2125                }
2126            }
2127            if(IS_FLAG_SET((&(pts.adslLineExtTableEntry_pt->flags)), LINE_GLITE_POWER_STATE_FLAG)){ // not supported currently
2128/*
2129                LINE_GLITE_POWER_STATE_FLAG_MAKECMV;
2130                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2131#ifdef AMAZON_MEI_DEBUG_ON
2132                    printk("\n\nCMV fail, Group 2 Address 0 Index 0");
2133#endif
2134                    CLR_FLAG((&(pts.adslLineExtTableEntry_pt->flags)), LINE_GLITE_POWER_STATE_FLAG);
2135                }
2136                else{
2137                    memcpy((&(pts.adslLineExtTableEntry_pt->adslLineGlitePowerState)), RxMessage+4, ((RxMessage[0]&0xf)*2));
2138                }
2139*/
2140                CLR_FLAG((&(pts.adslLineExtTableEntry_pt->flags)), LINE_GLITE_POWER_STATE_FLAG);
2141            }
2142            copy_to_user((char *)lon, (char *)pts.adslLineExtTableEntry_pt, sizeof(adslLineExtTableEntry));
2143            kfree(pts.adslLineTableEntry_pt);
2144            up(&mei_sema);
2145            break;
2146#endif
2147
2148#ifdef AMAZON_MEI_MIB_RFC3440
2149        case SET_ADSL_ATUC_LINE_EXT:
2150            if(down_interruptible(&mei_sema))
2151                        return -ERESTARTSYS;
2152            pts.adslLineExtTableEntry_pt = (adslLineExtTableEntry *)kmalloc(sizeof(adslLineExtTableEntry), GFP_KERNEL);
2153            copy_from_user((char *)pts.adslLineExtTableEntry_pt, (char *)lon, sizeof(adslLineExtTableEntry));
2154            
2155            //only adslLineTransAtucConfig can be set.
2156            CLR_FLAG((&(pts.adslLineExtTableEntry_pt->flags)), ATUC_LINE_TRANS_CAP_FLAG);
2157            if(IS_FLAG_SET((&(pts.adslLineExtTableEntry_pt->flags)), ATUC_LINE_TRANS_CONFIG_FLAG)){
2158                memcpy(data,(&(pts.adslLineExtTableEntry_pt->adslLineTransAtucConfig)), 2);
2159                ATUC_LINE_TRANS_CONFIG_FLAG_MAKECMV_WR;
2160                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2161#ifdef AMAZON_MEI_DEBUG_ON
2162                    printk("\n\nCMV fail, Group 3 Address 67 Index 0");
2163#endif
2164                    CLR_FLAG((&(pts.adslLineExtTableEntry_pt->flags)), ATUC_LINE_TRANS_CONFIG_FLAG);
2165                }
2166            }
2167            CLR_FLAG((&(pts.adslLineExtTableEntry_pt->flags)), ATUC_LINE_TRANS_ACTUAL_FLAG);
2168            CLR_FLAG((&(pts.adslLineExtTableEntry_pt->flags)), LINE_GLITE_POWER_STATE_FLAG);
2169    
2170            copy_to_user((char *)lon, (char *)pts.adslLineExtTableEntry_pt, sizeof(adslLineExtTableEntry));
2171            kfree(pts.adslLineTableEntry_pt);
2172            up(&mei_sema);
2173            break;
2174#endif
2175
2176        case GET_ADSL_ATUC_PHY:
2177            if(down_interruptible(&mei_sema))
2178                        return -ERESTARTSYS;
2179            
2180            pts.adslAtucPhysEntry_pt = (adslAtucPhysEntry *)kmalloc(sizeof(adslAtucPhysEntry), GFP_KERNEL);
2181            copy_from_user((char *)pts.adslAtucPhysEntry_pt, (char *)lon, sizeof(adslAtucPhysEntry));
2182            if(IS_FLAG_SET((&(pts.adslAtucPhysEntry_pt->flags)), ATUC_PHY_SER_NUM_FLAG)){
2183                ATUC_PHY_SER_NUM_FLAG_MAKECMV1;
2184                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2185#ifdef AMAZON_MEI_DEBUG_ON
2186                    printk("\n\nCMV fail, Group 3 Address 57 Index 0");
2187#endif
2188                    CLR_FLAG((&(pts.adslAtucPhysEntry_pt->flags)), ATUC_PHY_SER_NUM_FLAG);
2189                }
2190                else{
2191                    memcpy(pts.adslAtucPhysEntry_pt->serial_no, RxMessage+4, ((RxMessage[0]&0xf)*2));
2192                }
2193                ATUC_PHY_SER_NUM_FLAG_MAKECMV2;
2194                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2195#ifdef AMAZON_MEI_DEBUG_ON
2196                    printk("\n\nCMV fail, Group 3 Address 57 Index 12");
2197#endif
2198                    CLR_FLAG((&(pts.adslAtucPhysEntry_pt->flags)), ATUC_PHY_SER_NUM_FLAG);
2199                }
2200                else{
2201                    memcpy((pts.adslAtucPhysEntry_pt->serial_no+24), RxMessage+4, ((RxMessage[0]&0xf)*2));
2202                }
2203            }
2204            if(IS_FLAG_SET((&(pts.adslAtucPhysEntry_pt->flags)), ATUC_PHY_VENDOR_ID_FLAG)){
2205                ATUC_PHY_VENDOR_ID_FLAG_MAKECMV;
2206                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2207#ifdef AMAZON_MEI_DEBUG_ON
2208                    printk("\n\nCMV fail, Group 3 Address 64 Index 0");
2209#endif
2210                    CLR_FLAG((&(pts.adslAtucPhysEntry_pt->flags)), ATUC_PHY_VENDOR_ID_FLAG);
2211                }
2212                else{
2213                    memcpy(pts.adslAtucPhysEntry_pt->vendor_id.vendor_id, RxMessage+4, ((RxMessage[0]&0xf)*2));
2214                }
2215            }
2216            if(IS_FLAG_SET((&(pts.adslAtucPhysEntry_pt->flags)), ATUC_PHY_VER_NUM_FLAG)){
2217                ATUC_PHY_VER_NUM_FLAG_MAKECMV;
2218                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2219#ifdef AMAZON_MEI_DEBUG_ON
2220                    printk("\n\nCMV fail, Group 3 Address 58 Index 0");
2221#endif
2222                    CLR_FLAG((&(pts.adslAtucPhysEntry_pt->flags)), ATUC_PHY_VER_NUM_FLAG);
2223                }
2224                else{
2225                    memcpy(pts.adslAtucPhysEntry_pt->version_no, RxMessage+4, ((RxMessage[0]&0xf)*2));
2226                }
2227            }
2228            if(IS_FLAG_SET((&(pts.adslAtucPhysEntry_pt->flags)), ATUC_CURR_STAT_FLAG)){
2229                pts.adslAtucPhysEntry_pt->status = CurrStatus.adslAtucCurrStatus;
2230            }
2231            if(IS_FLAG_SET((&(pts.adslAtucPhysEntry_pt->flags)), ATUC_CURR_OUT_PWR_FLAG)){
2232                ATUC_CURR_OUT_PWR_FLAG_MAKECMV;
2233                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2234#ifdef AMAZON_MEI_DEBUG_ON
2235                    printk("\n\nCMV fail, Group 3 Address 68 Index 5");
2236#endif
2237                    CLR_FLAG((&(pts.adslAtucPhysEntry_pt->flags)), ATUC_CURR_OUT_PWR_FLAG);
2238                }
2239                else{
2240                    memcpy((&(pts.adslAtucPhysEntry_pt->outputPwr)), RxMessage+4, ((RxMessage[0]&0xf)*2));
2241                }
2242            }
2243            if(IS_FLAG_SET((&(pts.adslAtucPhysEntry_pt->flags)), ATUC_CURR_ATTR_FLAG)){
2244                ATUC_CURR_ATTR_FLAG_MAKECMV;
2245                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2246#ifdef AMAZON_MEI_DEBUG_ON
2247                    printk("\n\nCMV fail, Group 3 Address 69 Index 0");
2248#endif
2249                    CLR_FLAG((&(pts.adslAtucPhysEntry_pt->flags)), ATUC_CURR_ATTR_FLAG);
2250                }
2251                else{
2252                    memcpy((&(pts.adslAtucPhysEntry_pt->attainableRate)), RxMessage+4, ((RxMessage[0]&0xf)*2));
2253                }
2254            }
2255            copy_to_user((char *)lon, (char *)pts.adslAtucPhysEntry_pt, sizeof(adslAtucPhysEntry));
2256            kfree(pts.adslAtucPhysEntry_pt);
2257            
2258            up(&mei_sema);
2259            break;
2260        case GET_ADSL_ATUR_PHY:
2261            if(down_interruptible(&mei_sema))
2262                        return -ERESTARTSYS;
2263            
2264            pts.adslAturPhysEntry_pt = (adslAturPhysEntry *)kmalloc(sizeof(adslAturPhysEntry), GFP_KERNEL);
2265            copy_from_user((char *)pts.adslAturPhysEntry_pt, (char *)lon, sizeof(adslAturPhysEntry));
2266            if(IS_FLAG_SET((&(pts.adslAturPhysEntry_pt->flags)), ATUR_PHY_SER_NUM_FLAG)){
2267                ATUR_PHY_SER_NUM_FLAG_MAKECMV1;
2268                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2269#ifdef AMAZON_MEI_DEBUG_ON
2270                    printk("\n\nCMV fail, Group 3 Address 62 Index 0");
2271#endif
2272                    CLR_FLAG((&(pts.adslAturPhysEntry_pt->flags)), ATUR_PHY_SER_NUM_FLAG);
2273                }
2274                else{
2275                    memcpy(pts.adslAturPhysEntry_pt->serial_no, RxMessage+4, ((RxMessage[0]&0xf)*2));
2276                }
2277                ATUR_PHY_SER_NUM_FLAG_MAKECMV2;
2278                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2279#ifdef AMAZON_MEI_DEBUG_ON
2280                    printk("\n\nCMV fail, Group 3 Address 62 Index 12");
2281#endif
2282                    CLR_FLAG((&(pts.adslAturPhysEntry_pt->flags)), ATUR_PHY_SER_NUM_FLAG);
2283                }
2284                else{
2285                    memcpy((pts.adslAturPhysEntry_pt->serial_no+24), RxMessage+4, ((RxMessage[0]&0xf)*2));
2286                }
2287            }
2288            if(IS_FLAG_SET((&(pts.adslAturPhysEntry_pt->flags)), ATUR_PHY_VENDOR_ID_FLAG)){
2289                ATUR_PHY_VENDOR_ID_FLAG_MAKECMV;
2290                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2291#ifdef AMAZON_MEI_DEBUG_ON
2292                    printk("\n\nCMV fail, Group 3 Address 65 Index 0");
2293#endif
2294                    CLR_FLAG((&(pts.adslAturPhysEntry_pt->flags)), ATUR_PHY_VENDOR_ID_FLAG);
2295                }
2296                else{
2297                    memcpy(pts.adslAturPhysEntry_pt->vendor_id.vendor_id, RxMessage+4, ((RxMessage[0]&0xf)*2));
2298                }
2299            }
2300            if(IS_FLAG_SET((&(pts.adslAturPhysEntry_pt->flags)), ATUR_PHY_VER_NUM_FLAG)){
2301                ATUR_PHY_VER_NUM_FLAG_MAKECMV;
2302                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2303#ifdef AMAZON_MEI_DEBUG_ON
2304                    printk("\n\nCMV fail, Group 3 Address 61 Index 0");
2305#endif
2306                    CLR_FLAG((&(pts.adslAturPhysEntry_pt->flags)), ATUR_PHY_VER_NUM_FLAG);
2307                }
2308                else{
2309                    memcpy(pts.adslAturPhysEntry_pt->version_no, RxMessage+4, ((RxMessage[0]&0xf)*2));
2310                }
2311            }
2312            if(IS_FLAG_SET((&(pts.adslAturPhysEntry_pt->flags)), ATUR_SNRMGN_FLAG)){
2313                ATUR_SNRMGN_FLAG_MAKECMV;
2314                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2315#ifdef AMAZON_MEI_DEBUG_ON
2316                    printk("\n\nCMV fail, Group 3 Address 68 Index 4");
2317#endif
2318                    CLR_FLAG((&(pts.adslAturPhysEntry_pt->flags)), ATUR_SNRMGN_FLAG);
2319                }
2320                else{
2321                    memcpy((&(pts.adslAturPhysEntry_pt->SnrMgn)), RxMessage+4, ((RxMessage[0]&0xf)*2));
2322                }
2323            }
2324            if(IS_FLAG_SET((&(pts.adslAturPhysEntry_pt->flags)), ATUR_ATTN_FLAG)){
2325                ATUR_ATTN_FLAG_MAKECMV;
2326                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2327#ifdef AMAZON_MEI_DEBUG_ON
2328                    printk("\n\nCMV fail, Group 3 Address 68 Index 2");
2329#endif
2330                    CLR_FLAG((&(pts.adslAturPhysEntry_pt->flags)), ATUR_ATTN_FLAG);
2331                }
2332                else{
2333                    memcpy((&(pts.adslAturPhysEntry_pt->Attn)), RxMessage+4, ((RxMessage[0]&0xf)*2));
2334                }
2335            }
2336            if(IS_FLAG_SET((&(pts.adslAturPhysEntry_pt->flags)), ATUR_CURR_STAT_FLAG)){
2337                pts.adslAturPhysEntry_pt->status = CurrStatus.adslAturCurrStatus;
2338            }
2339            if(IS_FLAG_SET((&(pts.adslAturPhysEntry_pt->flags)), ATUR_CURR_OUT_PWR_FLAG)){
2340                ATUR_CURR_OUT_PWR_FLAG_MAKECMV;
2341                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2342#ifdef AMAZON_MEI_DEBUG_ON
2343                    printk("\n\nCMV fail, Group 3 Address 69 Index 5");
2344#endif
2345                    CLR_FLAG((&(pts.adslAturPhysEntry_pt->flags)), ATUR_CURR_OUT_PWR_FLAG);
2346                }
2347                else{
2348                    memcpy((&(pts.adslAturPhysEntry_pt->outputPwr)), RxMessage+4, ((RxMessage[0]&0xf)*2));
2349                }
2350            }
2351            if(IS_FLAG_SET((&(pts.adslAturPhysEntry_pt->flags)), ATUR_CURR_ATTR_FLAG)){
2352                ATUR_CURR_ATTR_FLAG_MAKECMV;
2353                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2354#ifdef AMAZON_MEI_DEBUG_ON
2355                    printk("\n\nCMV fail, Group 3 Address 68 Index 0");
2356#endif
2357                    CLR_FLAG((&(pts.adslAturPhysEntry_pt->flags)), ATUR_CURR_ATTR_FLAG);
2358                }
2359                else{
2360                    memcpy((&(pts.adslAturPhysEntry_pt->attainableRate)), RxMessage+4, ((RxMessage[0]&0xf)*2));
2361                }
2362            }
2363            copy_to_user((char *)lon, (char *)pts.adslAturPhysEntry_pt, sizeof(adslAturPhysEntry));
2364            kfree(pts.adslAturPhysEntry_pt);
2365            
2366            up(&mei_sema);
2367            break;
2368        case GET_ADSL_ATUC_CHAN_INFO:
2369            if(down_interruptible(&mei_sema))
2370                        return -ERESTARTSYS;
2371            
2372            pts.adslAtucChanInfo_pt = (adslAtucChanInfo *)kmalloc(sizeof(adslAtucChanInfo), GFP_KERNEL);
2373            copy_from_user((char *)pts.adslAtucChanInfo_pt, (char *)lon, sizeof(adslAtucChanInfo));
2374            if(IS_FLAG_SET((&(pts.adslAtucChanInfo_pt->flags)), ATUC_CHAN_INTLV_DELAY_FLAG)){
2375                if((chantype.interleave!=1) || (chantype.fast==1)){
2376                    CLR_FLAG((&(pts.adslAtucChanInfo_pt->flags)), ATUC_CHAN_INTLV_DELAY_FLAG);
2377                }
2378                else{
2379                    ATUC_CHAN_INTLV_DELAY_FLAG_MAKECMV;
2380                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2381#ifdef AMAZON_MEI_DEBUG_ON
2382                        printk("\n\nCMV fail, Group 6 Address 3 Index 1");
2383#endif
2384                        CLR_FLAG((&(pts.adslAtucChanInfo_pt->flags)), ATUC_CHAN_INTLV_DELAY_FLAG);
2385                    }
2386                    else{
2387                        memcpy((&(pts.adslAtucChanInfo_pt->interleaveDelay)), RxMessage+4, ((RxMessage[0]&0xf)*2));
2388                    }
2389                }
2390            }
2391            if(IS_FLAG_SET((&(pts.adslAtucChanInfo_pt->flags)), ATUC_CHAN_CURR_TX_RATE_FLAG)){
2392                ATUC_CHAN_CURR_TX_RATE_FLAG_MAKECMV;
2393                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2394#ifdef AMAZON_MEI_DEBUG_ON
2395                    printk("\n\nCMV fail, Group 6 Address 1 Index 0");
2396#endif
2397                    CLR_FLAG((&(pts.adslAtucChanInfo_pt->flags)), ATUC_CHAN_CURR_TX_RATE_FLAG);
2398                }
2399                else{
2400                    pts.adslAtucChanInfo_pt->currTxRate = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
2401                }
2402            }
2403            if(IS_FLAG_SET((&(pts.adslAtucChanInfo_pt->flags)), ATUC_CHAN_PREV_TX_RATE_FLAG)){
2404                pts.adslAtucChanInfo_pt->prevTxRate = PrevTxRate.adslAtucChanPrevTxRate;
2405            }
2406            copy_to_user((char *)lon, (char *)pts.adslAtucChanInfo_pt, sizeof(adslAtucChanInfo));
2407            kfree(pts.adslAtucChanInfo_pt);
2408            
2409            up(&mei_sema);
2410            break;
2411        case GET_ADSL_ATUR_CHAN_INFO:
2412            if(down_interruptible(&mei_sema))
2413                        return -ERESTARTSYS;
2414            
2415            pts.adslAturChanInfo_pt = (adslAturChanInfo *)kmalloc(sizeof(adslAturChanInfo), GFP_KERNEL);
2416            copy_from_user((char *)pts.adslAturChanInfo_pt, (char *)lon, sizeof(adslAturChanInfo));
2417            if(IS_FLAG_SET((&(pts.adslAturChanInfo_pt->flags)), ATUR_CHAN_INTLV_DELAY_FLAG)){
2418                if((chantype.interleave!=1) || (chantype.fast==1)){
2419                    CLR_FLAG((&(pts.adslAturChanInfo_pt->flags)), ATUR_CHAN_INTLV_DELAY_FLAG);
2420                }
2421                else{
2422                    ATUR_CHAN_INTLV_DELAY_FLAG_MAKECMV;
2423                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2424#ifdef AMAZON_MEI_DEBUG_ON
2425                        printk("\n\nCMV fail, Group 6 Address 2 Index 1");
2426#endif
2427                        CLR_FLAG((&(pts.adslAturChanInfo_pt->flags)), ATUR_CHAN_INTLV_DELAY_FLAG);
2428                    }
2429                    else{
2430                        memcpy((&(pts.adslAturChanInfo_pt->interleaveDelay)), RxMessage+4, ((RxMessage[0]&0xf)*2));
2431                    }
2432                }
2433            }
2434            if(IS_FLAG_SET((&(pts.adslAturChanInfo_pt->flags)), ATUR_CHAN_CURR_TX_RATE_FLAG)){
2435                ATUR_CHAN_CURR_TX_RATE_FLAG_MAKECMV;
2436                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
2437#ifdef AMAZON_MEI_DEBUG_ON
2438                    printk("\n\nCMV fail, Group 6 Address 0 Index 0");
2439#endif
2440                    CLR_FLAG((&(pts.adslAturChanInfo_pt->flags)), ATUR_CHAN_CURR_TX_RATE_FLAG);
2441                }
2442                else{
2443                    pts.adslAturChanInfo_pt->currTxRate = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
2444                }
2445            }
2446            if(IS_FLAG_SET((&(pts.adslAturChanInfo_pt->flags)), ATUR_CHAN_PREV_TX_RATE_FLAG)){
2447                pts.adslAturChanInfo_pt->prevTxRate = PrevTxRate.adslAturChanPrevTxRate;
2448            }
2449            if(IS_FLAG_SET((&(pts.adslAturChanInfo_pt->flags)), ATUR_CHAN_CRC_BLK_LEN_FLAG)){
2450                // ? no CMV to update this
2451                CLR_FLAG((&(pts.adslAturChanInfo_pt->flags)), ATUR_CHAN_CRC_BLK_LEN_FLAG);
2452            }
2453            copy_to_user((char *)lon, (char *)pts.adslAturChanInfo_pt, sizeof(adslAturChanInfo));
2454            kfree(pts.adslAturChanInfo_pt);
2455            
2456            up(&mei_sema);
2457            break;
2458        case GET_ADSL_ATUC_PERF_DATA:
2459            pts.atucPerfDataEntry_pt = (atucPerfDataEntry *)kmalloc(sizeof(atucPerfDataEntry), GFP_KERNEL);
2460            copy_from_user((char *)pts.atucPerfDataEntry_pt, (char *)lon, sizeof(atucPerfDataEntry));
2461            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_LOFS_FLAG)){
2462                pts.atucPerfDataEntry_pt->adslAtucPerfLofs=ATUC_PERF_LOFS;
2463            }
2464            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_LOSS_FLAG)){
2465                pts.atucPerfDataEntry_pt->adslAtucPerfLoss=ATUC_PERF_LOSS;
2466            }
2467            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_ESS_FLAG)){
2468                pts.atucPerfDataEntry_pt->adslAtucPerfESs=ATUC_PERF_ESS;
2469            }
2470            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_INITS_FLAG)){
2471                pts.atucPerfDataEntry_pt->adslAtucPerfInits=ATUC_PERF_INITS;
2472            }
2473            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_VALID_INTVLS_FLAG)){
2474                i=0;
2475                for(ptr=(current_intvl->list).prev; ptr!=&interval_list; ptr=ptr->prev){
2476                    i++;
2477                    if(i==96)
2478                        break;
2479                }
2480                pts.atucPerfDataEntry_pt->adslAtucPerfValidIntervals=i;
2481            }
2482            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_INVALID_INTVLS_FLAG)){
2483                pts.atucPerfDataEntry_pt->adslAtucPerfInvalidIntervals=0;
2484            }
2485            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_CURR_15MIN_TIME_ELAPSED_FLAG)){
2486                do_gettimeofday(&time_now);
2487                pts.atucPerfDataEntry_pt->adslAtucPerfCurr15MinTimeElapsed=time_now.tv_sec - (current_intvl->start_time).tv_sec;
2488            }
2489            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_CURR_15MIN_LOFS_FLAG)){
2490                pts.atucPerfDataEntry_pt->adslAtucPerfCurr15MinLofs=current_intvl->AtucPerfLof;
2491            }
2492            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_CURR_15MIN_LOSS_FLAG)){
2493                pts.atucPerfDataEntry_pt->adslAtucPerfCurr15MinLoss=current_intvl->AtucPerfLos;
2494            }
2495            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_CURR_15MIN_ESS_FLAG)){
2496                pts.atucPerfDataEntry_pt->adslAtucPerfCurr15MinESs=current_intvl->AtucPerfEs;
2497            }
2498            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_CURR_15MIN_INIT_FLAG)){
2499                pts.atucPerfDataEntry_pt->adslAtucPerfCurr15MinInits=current_intvl->AtucPerfInit;
2500            }
2501            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_CURR_1DAY_TIME_ELAPSED_FLAG)){
2502                i=0;
2503                for(ptr=(current_intvl->list).prev; ptr!=&interval_list; ptr=ptr->prev){
2504                    i+=900;
2505                }
2506                do_gettimeofday(&time_now);
2507                i+=time_now.tv_sec - (current_intvl->start_time).tv_sec;
2508                if(i>=86400)
2509                    pts.atucPerfDataEntry_pt->adslAtucPerfCurr1DayTimeElapsed=i-86400;
2510                else
2511                    pts.atucPerfDataEntry_pt->adslAtucPerfCurr1DayTimeElapsed=i;
2512            }
2513            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_CURR_1DAY_LOFS_FLAG)){
2514                i=0;
2515                j=0;
2516                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2517                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2518                    j+=mib_ptr->AtucPerfLof;
2519                    i++;
2520                    if(i==96)
2521                        j=0;
2522                }
2523                j+=current_intvl->AtucPerfLof;
2524                pts.atucPerfDataEntry_pt->adslAtucPerfCurr1DayLofs=j;
2525            }
2526            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_CURR_1DAY_LOSS_FLAG)){
2527                i=0;
2528                j=0;
2529                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2530                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2531                    j+=mib_ptr->AtucPerfLos;
2532                    i++;
2533                    if(i==96)
2534                        j=0;
2535                }
2536                j+=current_intvl->AtucPerfLos;
2537                pts.atucPerfDataEntry_pt->adslAtucPerfCurr1DayLoss=j;
2538            }
2539            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_CURR_1DAY_ESS_FLAG)){
2540                i=0;
2541                j=0;
2542                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2543                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2544                    j+=mib_ptr->AtucPerfEs;
2545                    i++;
2546                    if(i==96)
2547                        j=0;
2548                }
2549                j+=current_intvl->AtucPerfEs;
2550                pts.atucPerfDataEntry_pt->adslAtucPerfCurr1DayESs=j;
2551            }
2552            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_CURR_1DAY_INIT_FLAG)){
2553                i=0;
2554                j=0;
2555                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2556                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2557                    j+=mib_ptr->AtucPerfInit;
2558                    i++;
2559                    if(i==96)
2560                        j=0;
2561                }
2562                j+=current_intvl->AtucPerfInit;
2563                pts.atucPerfDataEntry_pt->adslAtucPerfCurr1DayInits=j;
2564            }
2565            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_PREV_1DAY_MON_SEC_FLAG)){
2566                i=0;
2567                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2568                    i++;
2569                }
2570                if(i>=96)
2571                    pts.atucPerfDataEntry_pt->adslAtucPerfPrev1DayMoniSecs=86400;
2572                else
2573                    pts.atucPerfDataEntry_pt->adslAtucPerfPrev1DayMoniSecs=0;
2574            }
2575            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_PREV_1DAY_LOFS_FLAG)){
2576                i=0;
2577                j=0;
2578                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2579                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2580                    j+=mib_ptr->AtucPerfLof;
2581                    i++;
2582                    if(i==96)
2583                        break;
2584                }
2585                if(i==96)
2586                    pts.atucPerfDataEntry_pt->adslAtucPerfPrev1DayLofs=j;
2587                else
2588                    pts.atucPerfDataEntry_pt->adslAtucPerfPrev1DayLofs=0;
2589            }
2590            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_PREV_1DAY_LOSS_FLAG)){
2591                i=0;
2592                j=0;
2593                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2594                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2595                    j+=mib_ptr->AtucPerfLos;
2596                    i++;
2597                    if(i==96)
2598                        break;
2599                }
2600                if(i==96)
2601                    pts.atucPerfDataEntry_pt->adslAtucPerfPrev1DayLoss=j;
2602                else
2603                    pts.atucPerfDataEntry_pt->adslAtucPerfPrev1DayLoss=0;
2604            }
2605            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_PREV_1DAY_ESS_FLAG)){
2606                i=0;
2607                j=0;
2608                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2609                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2610                    j+=mib_ptr->AtucPerfEs;
2611                    i++;
2612                    if(i==96)
2613                        break;
2614                }
2615                if(i==96)
2616                    pts.atucPerfDataEntry_pt->adslAtucPerfPrev1DayESs=j;
2617                else
2618                    pts.atucPerfDataEntry_pt->adslAtucPerfPrev1DayESs=0;
2619            }
2620            if(IS_FLAG_SET((&(pts.atucPerfDataEntry_pt->flags)), ATUC_PERF_PREV_1DAY_INITS_FLAG)){
2621                i=0;
2622                j=0;
2623                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2624                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2625                    j+=mib_ptr->AtucPerfInit;
2626                    i++;
2627                    if(i==96)
2628                        break;
2629                }
2630                if(i==96)
2631                    pts.atucPerfDataEntry_pt->adslAtucPerfPrev1DayInits=j;
2632                else
2633                    pts.atucPerfDataEntry_pt->adslAtucPerfPrev1DayInits=0;
2634            }
2635            
2636            copy_to_user((char *)lon, (char *)pts.atucPerfDataEntry_pt, sizeof(atucPerfDataEntry));
2637            kfree(pts.atucPerfDataEntry_pt);
2638            break;
2639#ifdef AMAZON_MEI_MIB_RFC3440
2640        case GET_ADSL_ATUC_PERF_DATA_EXT: //??? CMV mapping not available
2641            pts.atucPerfDataExtEntry_pt = (atucPerfDataExtEntry *)kmalloc(sizeof(atucPerfDataExtEntry), GFP_KERNEL);
2642            copy_from_user((char *)pts.atucPerfDataExtEntry_pt, (char *)lon, sizeof(atucPerfDataExtEntry));
2643            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_STAT_FASTR_FLAG)){
2644                pts.atucPerfDataExtEntry_pt->adslAtucPerfStatFastR=ATUC_PERF_STAT_FASTR;
2645            }
2646            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_STAT_FAILED_FASTR_FLAG)){
2647                pts.atucPerfDataExtEntry_pt->adslAtucPerfStatFailedFastR=ATUC_PERF_STAT_FAILED_FASTR;
2648            }
2649            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_STAT_SESL_FLAG)){
2650                pts.atucPerfDataExtEntry_pt->adslAtucPerfStatSesL=ATUC_PERF_STAT_SESL;
2651            }
2652            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_STAT_UASL_FLAG)){
2653                pts.atucPerfDataExtEntry_pt->adslAtucPerfStatUasL=ATUC_PERF_STAT_UASL;
2654            }
2655            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_CURR_15MIN_FASTR_FLAG)){
2656                pts.atucPerfDataExtEntry_pt->adslAtucPerfCurr15MinFastR=current_intvl->AtucPerfStatFastR;
2657            }
2658            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_CURR_15MIN_FAILED_FASTR_FLAG)){
2659                pts.atucPerfDataExtEntry_pt->adslAtucPerfCurr15MinFailedFastR=current_intvl->AtucPerfStatFailedFastR;
2660            }
2661            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_CURR_15MIN_SESL_FLAG)){
2662                pts.atucPerfDataExtEntry_pt->adslAtucPerfCurr15MinSesL=current_intvl->AtucPerfStatSesL;
2663            }
2664            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_CURR_15MIN_UASL_FLAG)){
2665                pts.atucPerfDataExtEntry_pt->adslAtucPerfCurr15MinUasL=current_intvl->AtucPerfStatUasL;
2666            }
2667            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_CURR_1DAY_FASTR_FLAG)){
2668                i=0;
2669                j=0;
2670                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2671                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2672                    j+=mib_ptr->AtucPerfStatFastR;
2673                    i++;
2674                    if(i==96)
2675                        j=0;
2676                }
2677                j+=current_intvl->AtucPerfStatFastR;
2678                pts.atucPerfDataExtEntry_pt->adslAtucPerfCurr1DayFastR=j;
2679            }
2680            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_CURR_1DAY_FAILED_FASTR_FLAG)){
2681                i=0;
2682                j=0;
2683                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2684                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2685                    j+=mib_ptr->AtucPerfStatFailedFastR;
2686                    i++;
2687                    if(i==96)
2688                        j=0;
2689                }
2690                j+=current_intvl->AtucPerfStatFailedFastR;
2691                pts.atucPerfDataExtEntry_pt->adslAtucPerfCurr1DayFailedFastR=j;
2692            }
2693            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_CURR_1DAY_SESL_FLAG)){
2694                i=0;
2695                j=0;
2696                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2697                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2698                    j+=mib_ptr->AtucPerfStatSesL;
2699                    i++;
2700                    if(i==96)
2701                        j=0;
2702                }
2703                j+=current_intvl->AtucPerfStatSesL;
2704                pts.atucPerfDataExtEntry_pt->adslAtucPerfCurr1DaySesL=j;
2705            }
2706            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_CURR_1DAY_UASL_FLAG)){
2707                i=0;
2708                j=0;
2709                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2710                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2711                    j+=mib_ptr->AtucPerfStatUasL;
2712                    i++;
2713                    if(i==96)
2714                        j=0;
2715                }
2716                j+=current_intvl->AtucPerfStatUasL;
2717                pts.atucPerfDataExtEntry_pt->adslAtucPerfCurr1DayUasL=j;
2718            }
2719            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_PREV_1DAY_FASTR_FLAG)){
2720                i=0;
2721                j=0;
2722                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2723                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2724                    j+=mib_ptr->AtucPerfStatFastR;
2725                    i++;
2726                    if(i==96)
2727                        break;
2728                }
2729                if(i==96)
2730                    pts.atucPerfDataExtEntry_pt->adslAtucPerfPrev1DayFastR=j;
2731                else
2732                    pts.atucPerfDataExtEntry_pt->adslAtucPerfPrev1DayFastR=0;
2733            }
2734            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_PREV_1DAY_FAILED_FASTR_FLAG)){
2735                i=0;
2736                j=0;
2737                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2738                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2739                    j+=mib_ptr->AtucPerfStatFailedFastR;
2740                    i++;
2741                    if(i==96)
2742                        break;
2743                }
2744                if(i==96)
2745                    pts.atucPerfDataExtEntry_pt->adslAtucPerfPrev1DayFailedFastR=j;
2746                else
2747                    pts.atucPerfDataExtEntry_pt->adslAtucPerfPrev1DayFailedFastR=0;
2748            }
2749            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_PREV_1DAY_SESL_FLAG)){
2750                i=0;
2751                j=0;
2752                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2753                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2754                    j+=mib_ptr->AtucPerfStatSesL;
2755                    i++;
2756                    if(i==96)
2757                        break;
2758                }
2759                if(i==96)
2760                    pts.atucPerfDataExtEntry_pt->adslAtucPerfPrev1DaySesL=j;
2761                else
2762                    pts.atucPerfDataExtEntry_pt->adslAtucPerfPrev1DaySesL=0;
2763            }
2764            if(IS_FLAG_SET((&(pts.atucPerfDataExtEntry_pt->flags)), ATUC_PERF_PREV_1DAY_UASL_FLAG)){
2765                i=0;
2766                j=0;
2767                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2768                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2769                    j+=mib_ptr->AtucPerfStatUasL;
2770                    i++;
2771                    if(i==96)
2772                        break;
2773                }
2774                if(i==96)
2775                    pts.atucPerfDataExtEntry_pt->adslAtucPerfPrev1DayUasL=j;
2776                else
2777                    pts.atucPerfDataExtEntry_pt->adslAtucPerfPrev1DayUasL=0;
2778            }
2779            copy_to_user((char *)lon, (char *)pts.atucPerfDataExtEntry_pt, sizeof(atucPerfDataExtEntry));
2780            kfree(pts.atucPerfDataExtEntry_pt);
2781            break;
2782#endif
2783        case GET_ADSL_ATUR_PERF_DATA:
2784            pts.aturPerfDataEntry_pt = (aturPerfDataEntry *)kmalloc(sizeof(aturPerfDataEntry), GFP_KERNEL);
2785            copy_from_user((char *)pts.aturPerfDataEntry_pt, (char *)lon, sizeof(aturPerfDataEntry));
2786            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_LOFS_FLAG)){
2787                pts.aturPerfDataEntry_pt->adslAturPerfLofs=ATUR_PERF_LOFS;
2788            }
2789            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_LOSS_FLAG)){
2790                pts.aturPerfDataEntry_pt->adslAturPerfLoss=ATUR_PERF_LOSS;
2791            }
2792            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_LPR_FLAG)){
2793                pts.aturPerfDataEntry_pt->adslAturPerfLprs=ATUR_PERF_LPR;
2794            }
2795            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_ESS_FLAG)){
2796                pts.aturPerfDataEntry_pt->adslAturPerfESs=ATUR_PERF_ESS;
2797            }
2798            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_VALID_INTVLS_FLAG)){
2799                i=0;
2800                for(ptr=(current_intvl->list).prev; ptr!=&interval_list; ptr=ptr->prev){
2801                    i++;
2802                    if(i==96)
2803                        break;
2804                }
2805                pts.aturPerfDataEntry_pt->adslAturPerfValidIntervals=i;
2806            }
2807            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_INVALID_INTVLS_FLAG)){
2808                pts.aturPerfDataEntry_pt->adslAturPerfInvalidIntervals=0;
2809            }
2810            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_CURR_15MIN_TIME_ELAPSED_FLAG)){
2811                do_gettimeofday(&time_now);
2812                pts.aturPerfDataEntry_pt->adslAturPerfCurr15MinTimeElapsed=time_now.tv_sec - (current_intvl->start_time).tv_sec;
2813            }
2814            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_CURR_15MIN_LOFS_FLAG)){
2815                pts.aturPerfDataEntry_pt->adslAturPerfCurr15MinLofs=current_intvl->AturPerfLof;
2816            }
2817            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_CURR_15MIN_LOSS_FLAG)){
2818                pts.aturPerfDataEntry_pt->adslAturPerfCurr15MinLoss=current_intvl->AturPerfLos;
2819            }
2820            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_CURR_15MIN_LPR_FLAG)){
2821                pts.aturPerfDataEntry_pt->adslAturPerfCurr15MinLprs=current_intvl->AturPerfLpr;
2822            }
2823            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_CURR_15MIN_ESS_FLAG)){
2824                pts.aturPerfDataEntry_pt->adslAturPerfCurr15MinESs=current_intvl->AturPerfEs;
2825            }
2826            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_CURR_1DAY_TIME_ELAPSED_FLAG)){
2827                i=0;
2828                for(ptr=(current_intvl->list).prev; ptr!=&interval_list; ptr=ptr->prev){
2829                    i+=900;
2830                }
2831                do_gettimeofday(&time_now);
2832                i+=time_now.tv_sec - (current_intvl->start_time).tv_sec;
2833                if(i>=86400)
2834                    pts.aturPerfDataEntry_pt->adslAturPerfCurr1DayTimeElapsed=i-86400;
2835                else
2836                    pts.aturPerfDataEntry_pt->adslAturPerfCurr1DayTimeElapsed=i;
2837            }
2838            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_CURR_1DAY_LOFS_FLAG)){
2839                i=0;
2840                j=0;
2841                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2842                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2843                    j+=mib_ptr->AturPerfLof;
2844                    i++;
2845                    if(i==96)
2846                        j=0;
2847                }
2848                j+=current_intvl->AturPerfLof;
2849                pts.aturPerfDataEntry_pt->adslAturPerfCurr1DayLofs=j;
2850            }
2851            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_CURR_1DAY_LOSS_FLAG)){
2852                i=0;
2853                j=0;
2854                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2855                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2856                    j+=mib_ptr->AturPerfLos;
2857                    i++;
2858                    if(i==96)
2859                        j=0;
2860                }
2861                j+=current_intvl->AturPerfLos;
2862                pts.aturPerfDataEntry_pt->adslAturPerfCurr1DayLoss=j;
2863            }
2864            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_CURR_1DAY_LPR_FLAG)){
2865                i=0;
2866                j=0;
2867                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2868                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2869                    j+=mib_ptr->AturPerfLpr;
2870                    i++;
2871                    if(i==96)
2872                        j=0;
2873                }
2874                j+=current_intvl->AturPerfLpr;
2875                pts.aturPerfDataEntry_pt->adslAturPerfCurr1DayLprs=j;
2876            }
2877            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_CURR_1DAY_ESS_FLAG)){
2878                i=0;
2879                j=0;
2880                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2881                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2882                    j+=mib_ptr->AturPerfEs;
2883                    i++;
2884                    if(i==96)
2885                        j=0;
2886                }
2887                j+=current_intvl->AturPerfEs;
2888                pts.aturPerfDataEntry_pt->adslAturPerfCurr1DayESs=j;
2889            }
2890            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_PREV_1DAY_MON_SEC_FLAG)){
2891                i=0;
2892                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2893                    i++;
2894                }
2895                if(i>=96)
2896                    pts.aturPerfDataEntry_pt->adslAturPerfPrev1DayMoniSecs=86400;
2897                else
2898                    pts.aturPerfDataEntry_pt->adslAturPerfPrev1DayMoniSecs=0;
2899            }
2900            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_PREV_1DAY_LOFS_FLAG)){
2901                i=0;
2902                j=0;
2903                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2904                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2905                    j+=mib_ptr->AturPerfLof;
2906                    i++;
2907                    if(i==96)
2908                        break;
2909                }
2910                if(i==96)
2911                    pts.aturPerfDataEntry_pt->adslAturPerfPrev1DayLofs=j;
2912                else
2913                    pts.aturPerfDataEntry_pt->adslAturPerfPrev1DayLofs=0;
2914            }
2915            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_PREV_1DAY_LOSS_FLAG)){
2916                i=0;
2917                j=0;
2918                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2919                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2920                    j+=mib_ptr->AturPerfLos;
2921                    i++;
2922                    if(i==96)
2923                        break;
2924                }
2925                if(i==96)
2926                    pts.aturPerfDataEntry_pt->adslAturPerfPrev1DayLoss=j;
2927                else
2928                    pts.aturPerfDataEntry_pt->adslAturPerfPrev1DayLoss=0;
2929            }
2930            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_PREV_1DAY_LPR_FLAG)){
2931                i=0;
2932                j=0;
2933                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2934                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2935                    j+=mib_ptr->AturPerfLpr;
2936                    i++;
2937                    if(i==96)
2938                        break;
2939                }
2940                if(i==96)
2941                    pts.aturPerfDataEntry_pt->adslAturPerfPrev1DayLprs=j;
2942                else
2943                    pts.aturPerfDataEntry_pt->adslAturPerfPrev1DayLprs=0;
2944            }
2945            if(IS_FLAG_SET((&(pts.aturPerfDataEntry_pt->flags)), ATUR_PERF_PREV_1DAY_ESS_FLAG)){
2946                i=0;
2947                j=0;
2948                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2949                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2950                    j+=mib_ptr->AturPerfEs;
2951                    i++;
2952                    if(i==96)
2953                        break;
2954                }
2955                if(i==96)
2956                    pts.aturPerfDataEntry_pt->adslAturPerfPrev1DayESs=j;
2957                else
2958                    pts.aturPerfDataEntry_pt->adslAturPerfPrev1DayESs=0;
2959            }
2960            
2961            copy_to_user((char *)lon, (char *)pts.aturPerfDataEntry_pt, sizeof(aturPerfDataEntry));
2962            kfree(pts.aturPerfDataEntry_pt);
2963            break;
2964#ifdef AMAZON_MEI_MIB_RFC3440
2965        case GET_ADSL_ATUR_PERF_DATA_EXT:
2966            pts.aturPerfDataExtEntry_pt = (aturPerfDataExtEntry *)kmalloc(sizeof(aturPerfDataExtEntry), GFP_KERNEL);
2967            copy_from_user((char *)pts.aturPerfDataExtEntry_pt, (char *)lon, sizeof(aturPerfDataExtEntry));
2968            if(IS_FLAG_SET((&(pts.aturPerfDataExtEntry_pt->flags)), ATUR_PERF_STAT_SESL_FLAG)){
2969                pts.aturPerfDataExtEntry_pt->adslAturPerfStatSesL=ATUR_PERF_STAT_SESL;
2970            }
2971            if(IS_FLAG_SET((&(pts.aturPerfDataExtEntry_pt->flags)), ATUR_PERF_STAT_UASL_FLAG)){
2972                pts.aturPerfDataExtEntry_pt->adslAturPerfStatUasL=ATUR_PERF_STAT_UASL;
2973            }
2974            if(IS_FLAG_SET((&(pts.aturPerfDataExtEntry_pt->flags)), ATUR_PERF_CURR_15MIN_SESL_FLAG)){
2975                pts.aturPerfDataExtEntry_pt->adslAturPerfCurr15MinSesL=current_intvl->AturPerfStatSesL;
2976            }
2977            if(IS_FLAG_SET((&(pts.aturPerfDataExtEntry_pt->flags)), ATUR_PERF_CURR_15MIN_UASL_FLAG)){
2978                pts.aturPerfDataExtEntry_pt->adslAturPerfCurr15MinUasL=current_intvl->AturPerfStatUasL;
2979            }
2980            if(IS_FLAG_SET((&(pts.aturPerfDataExtEntry_pt->flags)), ATUR_PERF_CURR_1DAY_SESL_FLAG)){
2981                i=0;
2982                j=0;
2983                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2984                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2985                    j+=mib_ptr->AturPerfStatSesL;
2986                    i++;
2987                    if(i==96)
2988                        j=0;
2989                }
2990                j+=current_intvl->AturPerfStatSesL;
2991                pts.aturPerfDataExtEntry_pt->adslAturPerfCurr1DaySesL=j;
2992            }
2993            if(IS_FLAG_SET((&(pts.aturPerfDataExtEntry_pt->flags)), ATUR_PERF_CURR_1DAY_UASL_FLAG)){
2994                i=0;
2995                j=0;
2996                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
2997                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
2998                    j+=mib_ptr->AturPerfStatUasL;
2999                    i++;
3000                    if(i==96)
3001                        j=0;
3002                }
3003                j+=current_intvl->AturPerfStatUasL;
3004                pts.aturPerfDataExtEntry_pt->adslAturPerfCurr1DayUasL=j;
3005            }
3006            if(IS_FLAG_SET((&(pts.aturPerfDataExtEntry_pt->flags)), ATUR_PERF_PREV_1DAY_SESL_FLAG)){
3007                i=0;
3008                j=0;
3009                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
3010                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
3011                    j+=mib_ptr->AturPerfStatSesL;
3012                    i++;
3013                    if(i==96)
3014                        break;
3015                }
3016                if(i==96)
3017                    pts.aturPerfDataExtEntry_pt->adslAturPerfPrev1DaySesL=j;
3018                else
3019                    pts.aturPerfDataExtEntry_pt->adslAturPerfPrev1DaySesL=0;
3020            }
3021            if(IS_FLAG_SET((&(pts.aturPerfDataExtEntry_pt->flags)), ATUR_PERF_PREV_1DAY_UASL_FLAG)){
3022                i=0;
3023                j=0;
3024                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
3025                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
3026                    j+=mib_ptr->AturPerfStatUasL;
3027                    i++;
3028                    if(i==96)
3029                        break;
3030                }
3031                if(i==96)
3032                    pts.aturPerfDataExtEntry_pt->adslAturPerfPrev1DayUasL=j;
3033                else
3034                    pts.aturPerfDataExtEntry_pt->adslAturPerfPrev1DayUasL=0;
3035            }
3036            copy_to_user((char *)lon, (char *)pts.aturPerfDataExtEntry_pt, sizeof(aturPerfDataExtEntry));
3037            kfree(pts.aturPerfDataExtEntry_pt);
3038            break;
3039#endif
3040        case GET_ADSL_ATUC_INTVL_INFO:
3041            pts.adslAtucIntvlInfo_pt = (adslAtucIntvlInfo *)kmalloc(sizeof(adslAtucIntvlInfo), GFP_KERNEL);
3042            copy_from_user((char *)pts.adslAtucIntvlInfo_pt, (char *)lon, sizeof(adslAtucIntvlInfo));
3043            
3044            if(pts.adslAtucIntvlInfo_pt->IntervalNumber <1){
3045                pts.adslAtucIntvlInfo_pt->intervalLOF = ATUC_PERF_LOFS;
3046                pts.adslAtucIntvlInfo_pt->intervalLOS = ATUC_PERF_LOSS;
3047                pts.adslAtucIntvlInfo_pt->intervalES = ATUC_PERF_ESS;
3048                pts.adslAtucIntvlInfo_pt->intervalInits = ATUC_PERF_INITS;
3049                pts.adslAtucIntvlInfo_pt->intervalValidData = 1;
3050            }
3051            else{
3052                i=0;
3053                for(ptr=(current_intvl->list).prev; ptr!=&interval_list; ptr=ptr->prev){
3054                    i++;
3055                    if(i==pts.adslAtucIntvlInfo_pt->IntervalNumber){
3056                        temp_intvl = list_entry(ptr, amazon_mei_mib, list);
3057                        pts.adslAtucIntvlInfo_pt->intervalLOF = temp_intvl->AtucPerfLof;
3058                        pts.adslAtucIntvlInfo_pt->intervalLOS = temp_intvl->AtucPerfLos;
3059                        pts.adslAtucIntvlInfo_pt->intervalES = temp_intvl->AtucPerfEs;
3060                        pts.adslAtucIntvlInfo_pt->intervalInits = temp_intvl->AtucPerfInit;
3061                        pts.adslAtucIntvlInfo_pt->intervalValidData = 1;
3062                        break;
3063                    }
3064                }
3065                if(ptr==&interval_list){
3066                    pts.adslAtucIntvlInfo_pt->intervalValidData = 0;
3067                    pts.adslAtucIntvlInfo_pt->flags = 0;
3068                    pts.adslAtucIntvlInfo_pt->intervalLOF = 0;
3069                    pts.adslAtucIntvlInfo_pt->intervalLOS = 0;
3070                    pts.adslAtucIntvlInfo_pt->intervalES = 0;
3071                    pts.adslAtucIntvlInfo_pt->intervalInits = 0;
3072                }
3073            }
3074                                    
3075            copy_to_user((char *)lon, (char *)pts.adslAtucIntvlInfo_pt, sizeof(adslAtucIntvlInfo));
3076            kfree(pts.adslAtucIntvlInfo_pt);
3077            break;
3078#ifdef AMAZON_MEI_MIB_RFC3440
3079        case GET_ADSL_ATUC_INTVL_EXT_INFO:
3080            pts.adslAtucInvtlExtInfo_pt = (adslAtucInvtlExtInfo *)kmalloc(sizeof(adslAtucInvtlExtInfo), GFP_KERNEL);
3081            copy_from_user((char *)pts.adslAtucInvtlExtInfo_pt, (char *)lon, sizeof(adslAtucInvtlExtInfo));
3082            if(pts.adslAtucInvtlExtInfo_pt->IntervalNumber <1){
3083                pts.adslAtucInvtlExtInfo_pt->adslAtucIntervalFastR = ATUC_PERF_STAT_FASTR;
3084                pts.adslAtucInvtlExtInfo_pt->adslAtucIntervalFailedFastR = ATUC_PERF_STAT_FAILED_FASTR;
3085                pts.adslAtucInvtlExtInfo_pt->adslAtucIntervalSesL = ATUC_PERF_STAT_SESL;
3086                pts.adslAtucInvtlExtInfo_pt->adslAtucIntervalUasL = ATUC_PERF_STAT_UASL;
3087// pts.adslAtucInvtlExtInfo_pt->intervalValidData = 1;
3088            }
3089            else{
3090                i=0;
3091                for(ptr=(current_intvl->list).prev; ptr!=&interval_list; ptr=ptr->prev){
3092                    i++;
3093                    if(i==pts.adslAtucInvtlExtInfo_pt->IntervalNumber){
3094                        temp_intvl = list_entry(ptr, amazon_mei_mib, list);
3095                        pts.adslAtucInvtlExtInfo_pt->adslAtucIntervalFastR = temp_intvl->AtucPerfStatFastR;
3096                        pts.adslAtucInvtlExtInfo_pt->adslAtucIntervalFailedFastR = temp_intvl->AtucPerfStatFailedFastR;
3097                        pts.adslAtucInvtlExtInfo_pt->adslAtucIntervalSesL = temp_intvl->AtucPerfStatSesL;
3098                        pts.adslAtucInvtlExtInfo_pt->adslAtucIntervalUasL = temp_intvl->AtucPerfStatUasL;
3099// pts.adslAtucInvtlExtInfo_pt->intervalValidData = 1;
3100                        break;
3101                    }
3102                }
3103                if(ptr==&interval_list){
3104// pts.adslAtucInvtlExtInfo_pt->intervalValidData = 0;
3105                    pts.adslAtucInvtlExtInfo_pt->flags = 0;
3106                    pts.adslAtucInvtlExtInfo_pt->adslAtucIntervalFastR = 0;
3107                    pts.adslAtucInvtlExtInfo_pt->adslAtucIntervalFailedFastR = 0;
3108                    pts.adslAtucInvtlExtInfo_pt->adslAtucIntervalSesL = 0;
3109                    pts.adslAtucInvtlExtInfo_pt->adslAtucIntervalUasL = 0;
3110                }
3111            }
3112            copy_to_user((char *)lon, (char *)pts.adslAtucInvtlExtInfo_pt, sizeof(adslAtucInvtlExtInfo));
3113            kfree(pts.adslAtucInvtlExtInfo_pt);
3114            break;
3115#endif
3116        case GET_ADSL_ATUR_INTVL_INFO:
3117            pts.adslAturIntvlInfo_pt = (adslAturIntvlInfo *)kmalloc(sizeof(adslAturIntvlInfo), GFP_KERNEL);
3118            copy_from_user((char *)pts.adslAturIntvlInfo_pt, (char *)lon, sizeof(adslAturIntvlInfo));
3119            
3120            if(pts.adslAturIntvlInfo_pt->IntervalNumber <1){
3121                pts.adslAturIntvlInfo_pt->intervalLOF = ATUR_PERF_LOFS;
3122                pts.adslAturIntvlInfo_pt->intervalLOS = ATUR_PERF_LOSS;
3123                pts.adslAturIntvlInfo_pt->intervalES = ATUR_PERF_ESS;
3124                pts.adslAturIntvlInfo_pt->intervalLPR = ATUR_PERF_LPR;
3125                pts.adslAturIntvlInfo_pt->intervalValidData = 1;
3126            }
3127            else{
3128                i=0;
3129                for(ptr=(current_intvl->list).prev; ptr!=&interval_list; ptr=ptr->prev){
3130                    i++;
3131                    if(i==pts.adslAturIntvlInfo_pt->IntervalNumber){
3132                        temp_intvl = list_entry(ptr, amazon_mei_mib, list);
3133                        pts.adslAturIntvlInfo_pt->intervalLOF = temp_intvl->AturPerfLof;
3134                        pts.adslAturIntvlInfo_pt->intervalLOS = temp_intvl->AturPerfLos;
3135                        pts.adslAturIntvlInfo_pt->intervalES = temp_intvl->AturPerfEs;
3136                        pts.adslAturIntvlInfo_pt->intervalLPR = temp_intvl->AturPerfLpr;
3137                        pts.adslAturIntvlInfo_pt->intervalValidData = 1;
3138                        break;
3139                    }
3140                }
3141                if(ptr==&interval_list){
3142                    pts.adslAturIntvlInfo_pt->intervalValidData = 0;
3143                    pts.adslAturIntvlInfo_pt->flags = 0;
3144                    pts.adslAturIntvlInfo_pt->intervalLOF = 0;
3145                    pts.adslAturIntvlInfo_pt->intervalLOS = 0;
3146                    pts.adslAturIntvlInfo_pt->intervalES = 0;
3147                    pts.adslAturIntvlInfo_pt->intervalLPR = 0;
3148                }
3149            }
3150            
3151            copy_to_user((char *)lon, (char *)pts.adslAturIntvlInfo_pt, sizeof(adslAturIntvlInfo));
3152            kfree(pts.adslAturIntvlInfo_pt);
3153            break;
3154#ifdef AMAZON_MEI_MIB_RFC3440
3155        case GET_ADSL_ATUR_INTVL_EXT_INFO:
3156            pts.adslAturInvtlExtInfo_pt = (adslAturInvtlExtInfo *)kmalloc(sizeof(adslAturInvtlExtInfo), GFP_KERNEL);
3157            copy_from_user((char *)pts.adslAturInvtlExtInfo_pt, (char *)lon, sizeof(adslAturInvtlExtInfo));
3158            
3159            if(pts.adslAturInvtlExtInfo_pt->IntervalNumber <1){
3160                pts.adslAturInvtlExtInfo_pt->adslAturIntervalSesL = ATUR_PERF_STAT_SESL;
3161                pts.adslAturInvtlExtInfo_pt->adslAturIntervalUasL = ATUR_PERF_STAT_UASL;
3162// pts.adslAturInvtlExtInfo_pt->intervalValidData = 1;
3163            }
3164            else{
3165                i=0;
3166                for(ptr=(current_intvl->list).prev; ptr!=&interval_list; ptr=ptr->prev){
3167                    i++;
3168                    if(i==pts.adslAturInvtlExtInfo_pt->IntervalNumber){
3169                        temp_intvl = list_entry(ptr, amazon_mei_mib, list);
3170                        pts.adslAturInvtlExtInfo_pt->adslAturIntervalSesL = temp_intvl->AturPerfStatSesL;
3171                        pts.adslAturInvtlExtInfo_pt->adslAturIntervalUasL = temp_intvl->AturPerfStatUasL;
3172// pts.adslAturInvtlExtInfo_pt->intervalValidData = 1;
3173                        break;
3174                    }
3175                }
3176                if(ptr==&interval_list){
3177// pts.adslAturInvtlExtInfo_pt->intervalValidData = 0;
3178                    pts.adslAturInvtlExtInfo_pt->flags = 0;
3179                    pts.adslAturInvtlExtInfo_pt->adslAturIntervalSesL = 0;
3180                    pts.adslAturInvtlExtInfo_pt->adslAturIntervalUasL = 0;
3181                }
3182            }
3183            
3184            copy_to_user((char *)lon, (char *)pts.adslAturInvtlExtInfo_pt, sizeof(adslAturInvtlExtInfo));
3185            kfree(pts.adslAturInvtlExtInfo_pt);
3186            break;
3187#endif
3188        case GET_ADSL_ATUC_CHAN_PERF_DATA:
3189            pts.atucChannelPerfDataEntry_pt = (atucChannelPerfDataEntry *)kmalloc(sizeof(atucChannelPerfDataEntry), GFP_KERNEL);
3190            copy_from_user((char *)pts.atucChannelPerfDataEntry_pt, (char *)lon, sizeof(atucChannelPerfDataEntry));
3191    
3192            pts.atucChannelPerfDataEntry_pt->flags = 0;
3193            
3194            copy_to_user((char *)lon, (char *)pts.atucChannelPerfDataEntry_pt, sizeof(atucChannelPerfDataEntry));
3195            kfree(pts.atucChannelPerfDataEntry_pt);
3196            break;
3197        case GET_ADSL_ATUR_CHAN_PERF_DATA:
3198            pts.aturChannelPerfDataEntry_pt = (aturChannelPerfDataEntry *)kmalloc(sizeof(aturChannelPerfDataEntry), GFP_KERNEL);
3199            copy_from_user((char *)pts.aturChannelPerfDataEntry_pt, (char *)lon, sizeof(aturChannelPerfDataEntry));
3200            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_RECV_BLK_FLAG)){
3201                pts.aturChannelPerfDataEntry_pt->adslAturChanReceivedBlks=ATUR_CHAN_RECV_BLK;
3202            }
3203            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_TX_BLK_FLAG)){
3204                pts.aturChannelPerfDataEntry_pt->adslAturChanTransmittedBlks=ATUR_CHAN_TX_BLK;
3205            }
3206            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_CORR_BLK_FLAG)){
3207                pts.aturChannelPerfDataEntry_pt->adslAturChanCorrectedBlks=ATUR_CHAN_CORR_BLK;
3208            }
3209            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_UNCORR_BLK_FLAG)){
3210                pts.aturChannelPerfDataEntry_pt->adslAturChanUncorrectBlks=ATUR_CHAN_UNCORR_BLK;
3211            }
3212            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_VALID_INTVL_FLAG)){
3213                i=0;
3214                for(ptr=(current_intvl->list).prev; ptr!=&interval_list; ptr=ptr->prev){
3215                    i++;
3216                    if(i==96)
3217                        break;
3218                }
3219                pts.aturChannelPerfDataEntry_pt->adslAturChanPerfValidIntervals=i;
3220            }
3221            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_INVALID_INTVL_FLAG)){
3222                pts.aturChannelPerfDataEntry_pt->adslAturChanPerfInvalidIntervals=0;
3223            }
3224             if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_CURR_15MIN_TIME_ELAPSED_FLAG)){
3225                do_gettimeofday(&time_now);
3226                pts.aturChannelPerfDataEntry_pt->adslAturChanPerfCurr15MinTimeElapsed=time_now.tv_sec - (current_intvl->start_time).tv_sec;
3227            }
3228            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_CURR_15MIN_RECV_BLK_FLAG)){
3229                pts.aturChannelPerfDataEntry_pt->adslAturChanPerfCurr15MinReceivedBlks=current_intvl->AturChanPerfRxBlk;
3230            }
3231            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_CURR_15MIN_TX_BLK_FLAG)){
3232                pts.aturChannelPerfDataEntry_pt->adslAturChanPerfCurr15MinTransmittedBlks=current_intvl->AturChanPerfTxBlk;
3233            }
3234            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_CURR_15MIN_CORR_BLK_FLAG)){
3235                pts.aturChannelPerfDataEntry_pt->adslAturChanPerfCurr15MinCorrectedBlks=current_intvl->AturChanPerfCorrBlk;
3236            }
3237            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_CURR_15MIN_UNCORR_BLK_FLAG)){
3238                pts.aturChannelPerfDataEntry_pt->adslAturChanPerfCurr15MinUncorrectBlks=current_intvl->AturChanPerfUncorrBlk;
3239            }
3240            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_CURR_1DAY_TIME_ELAPSED_FLAG)){
3241                i=0;
3242                for(ptr=(current_intvl->list).prev; ptr!=&interval_list; ptr=ptr->prev){
3243                    i+=900;
3244                }
3245                do_gettimeofday(&time_now);
3246                i+=time_now.tv_sec - (current_intvl->start_time).tv_sec;
3247                if(i>=86400)
3248                    pts.aturChannelPerfDataEntry_pt->adslAturChanPerfCurr1DayTimeElapsed=i-86400;
3249                else
3250                    pts.aturChannelPerfDataEntry_pt->adslAturChanPerfCurr1DayTimeElapsed=i;
3251            }
3252            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_CURR_1DAY_RECV_BLK_FLAG)){
3253                i=0;
3254                j=0;
3255                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
3256                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
3257                    j+=mib_ptr->AturChanPerfRxBlk;
3258                    i++;
3259                    if(i==96)
3260                        j=0;
3261                }
3262                j+=current_intvl->AturChanPerfRxBlk;
3263                pts.aturChannelPerfDataEntry_pt->adslAturChanPerfCurr1DayReceivedBlks=j;
3264            }
3265            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_CURR_1DAY_TX_BLK_FLAG)){
3266                i=0;
3267                j=0;
3268                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
3269                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
3270                    j+=mib_ptr->AturChanPerfTxBlk;
3271                    i++;
3272                    if(i==96)
3273                        j=0;
3274                }
3275                j+=current_intvl->AturChanPerfTxBlk;
3276                pts.aturChannelPerfDataEntry_pt->adslAturChanPerfCurr1DayTransmittedBlks=j;
3277            }
3278            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_CURR_1DAY_CORR_BLK_FLAG)){
3279                i=0;
3280                j=0;
3281                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
3282                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
3283                    j+=mib_ptr->AturChanPerfCorrBlk;
3284                    i++;
3285                    if(i==96)
3286                        j=0;
3287                }
3288                j+=current_intvl->AturChanPerfCorrBlk;
3289                pts.aturChannelPerfDataEntry_pt->adslAturChanPerfCurr1DayCorrectedBlks=j;
3290            }
3291            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_CURR_1DAY_UNCORR_BLK_FLAG)){
3292                i=0;
3293                j=0;
3294                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
3295                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
3296                    j+=mib_ptr->AturChanPerfUncorrBlk;
3297                    i++;
3298                    if(i==96)
3299                        j=0;
3300                }
3301                j+=current_intvl->AturChanPerfUncorrBlk;
3302                pts.aturChannelPerfDataEntry_pt->adslAturChanPerfCurr1DayUncorrectBlks=j;
3303            }
3304            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_PREV_1DAY_MONI_SEC_FLAG)){
3305                i=0;
3306                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
3307                    i++;
3308                }
3309                if(i>=96)
3310                    pts.aturChannelPerfDataEntry_pt->adslAturChanPerfPrev1DayMoniSecs=86400;
3311                else
3312                    pts.aturChannelPerfDataEntry_pt->adslAturChanPerfPrev1DayMoniSecs=0;
3313            }
3314            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_PREV_1DAY_RECV_BLK_FLAG)){
3315                i=0;
3316                j=0;
3317                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
3318                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
3319                    j+=mib_ptr->AturChanPerfRxBlk;
3320                    i++;
3321                    if(i==96)
3322                        break;
3323                }
3324                if(i==96)
3325                    pts.aturChannelPerfDataEntry_pt->adslAturChanPerfPrev1DayReceivedBlks=j;
3326                else
3327                    pts.aturChannelPerfDataEntry_pt->adslAturChanPerfPrev1DayReceivedBlks=0;
3328            }
3329            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_PREV_1DAY_TRANS_BLK_FLAG)){
3330                i=0;
3331                j=0;
3332                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
3333                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
3334                    j+=mib_ptr->AturChanPerfTxBlk;
3335                    i++;
3336                    if(i==96)
3337                        break;
3338                }
3339                if(i==96)
3340                    pts.aturChannelPerfDataEntry_pt->adslAturChanPerfPrev1DayTransmittedBlks=j;
3341                else
3342                    pts.aturChannelPerfDataEntry_pt->adslAturChanPerfPrev1DayTransmittedBlks=0;
3343            }
3344            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_PREV_1DAY_CORR_BLK_FLAG)){
3345                i=0;
3346                j=0;
3347                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
3348                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
3349                    j+=mib_ptr->AturChanPerfCorrBlk;
3350                    i++;
3351                    if(i==96)
3352                        break;
3353                }
3354                if(i==96)
3355                    pts.aturChannelPerfDataEntry_pt->adslAturChanPerfPrev1DayCorrectedBlks=j;
3356                else
3357                    pts.aturChannelPerfDataEntry_pt->adslAturChanPerfPrev1DayCorrectedBlks=0;
3358            }
3359            if(IS_FLAG_SET((&(pts.aturChannelPerfDataEntry_pt->flags)), ATUR_CHAN_PERF_PREV_1DAY_UNCORR_BLK_FLAG)){
3360                i=0;
3361                j=0;
3362                for(ptr=interval_list.next; ptr!=&(current_intvl->list); ptr=ptr->next){
3363                    mib_ptr = list_entry(ptr, amazon_mei_mib, list);
3364                    j+=mib_ptr->AturChanPerfUncorrBlk;
3365                    i++;
3366                    if(i==96)
3367                        break;
3368                }
3369                if(i==96)
3370                    pts.aturChannelPerfDataEntry_pt->adslAturChanPerfPrev1DayUncorrectBlks=j;
3371                else
3372                    pts.aturChannelPerfDataEntry_pt->adslAturChanPerfPrev1DayUncorrectBlks=0;
3373            }
3374            
3375            copy_to_user((char *)lon, (char *)pts.aturChannelPerfDataEntry_pt, sizeof(aturChannelPerfDataEntry));
3376            kfree(pts.aturChannelPerfDataEntry_pt);
3377            break;
3378        case GET_ADSL_ATUC_CHAN_INTVL_INFO:
3379            pts.adslAtucChanIntvlInfo_pt = (adslAtucChanIntvlInfo *)kmalloc(sizeof(adslAtucChanIntvlInfo), GFP_KERNEL);
3380            copy_from_user((char *)pts.adslAtucChanIntvlInfo_pt, (char *)lon, sizeof(adslAtucChanIntvlInfo));
3381                
3382                pts.adslAtucChanIntvlInfo_pt->flags = 0;
3383                
3384            copy_to_user((char *)lon, (char *)pts.adslAtucChanIntvlInfo_pt, sizeof(adslAtucChanIntvlInfo));
3385            kfree(pts.adslAtucChanIntvlInfo_pt);
3386            break;
3387        case GET_ADSL_ATUR_CHAN_INTVL_INFO:
3388            pts.adslAturChanIntvlInfo_pt = (adslAturChanIntvlInfo *)kmalloc(sizeof(adslAturChanIntvlInfo), GFP_KERNEL);
3389            copy_from_user((char *)pts.adslAturChanIntvlInfo_pt, (char *)lon, sizeof(adslAturChanIntvlInfo));
3390            
3391            if(pts.adslAturChanIntvlInfo_pt->IntervalNumber <1){
3392                pts.adslAturChanIntvlInfo_pt->chanIntervalRecvdBlks = ATUR_CHAN_RECV_BLK;
3393                pts.adslAturChanIntvlInfo_pt->chanIntervalXmitBlks = ATUR_CHAN_TX_BLK;
3394                pts.adslAturChanIntvlInfo_pt->chanIntervalCorrectedBlks = ATUR_CHAN_CORR_BLK;
3395                pts.adslAturChanIntvlInfo_pt->chanIntervalUncorrectBlks = ATUR_CHAN_UNCORR_BLK;
3396                pts.adslAturChanIntvlInfo_pt->intervalValidData = 1;
3397            }
3398            else{
3399                i=0;
3400                for(ptr=(current_intvl->list).prev; ptr!=&interval_list; ptr=ptr->prev){
3401                    i++;
3402                    if(i==pts.adslAturChanIntvlInfo_pt->IntervalNumber){
3403                        temp_intvl = list_entry(ptr, amazon_mei_mib, list);
3404                        pts.adslAturChanIntvlInfo_pt->chanIntervalRecvdBlks = temp_intvl->AturChanPerfRxBlk;
3405                        pts.adslAturChanIntvlInfo_pt->chanIntervalXmitBlks = temp_intvl->AturChanPerfTxBlk;
3406                        pts.adslAturChanIntvlInfo_pt->chanIntervalCorrectedBlks = temp_intvl->AturChanPerfCorrBlk;
3407                        pts.adslAturChanIntvlInfo_pt->chanIntervalUncorrectBlks = temp_intvl->AturChanPerfUncorrBlk;
3408                        pts.adslAturChanIntvlInfo_pt->intervalValidData = 1;
3409                        break;
3410                    }
3411                }
3412                if(ptr==&interval_list){
3413                    pts.adslAturChanIntvlInfo_pt->intervalValidData = 0;
3414                    pts.adslAturChanIntvlInfo_pt->flags = 0;
3415                }
3416            }
3417            
3418            copy_to_user((char *)lon, (char *)pts.adslAturChanIntvlInfo_pt, sizeof(adslAturChanIntvlInfo));
3419            kfree(pts.adslAturChanIntvlInfo_pt);
3420            break;
3421        case GET_ADSL_ALRM_CONF_PROF:
3422            pts.adslLineAlarmConfProfileEntry_pt = (adslLineAlarmConfProfileEntry *)kmalloc(sizeof(adslLineAlarmConfProfileEntry), GFP_KERNEL);
3423            copy_from_user((char *)pts.adslLineAlarmConfProfileEntry_pt, (char *)lon, sizeof(adslLineAlarmConfProfileEntry));
3424            
3425            strncpy(pts.adslLineAlarmConfProfileEntry_pt->adslLineAlarmConfProfileName, AlarmConfProfile.adslLineAlarmConfProfileName, 32);
3426            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_THRESH_15MIN_LOFS_FLAG)){
3427                pts.adslLineAlarmConfProfileEntry_pt->adslAtucThresh15MinLofs=AlarmConfProfile.adslAtucThresh15MinLofs;
3428            }
3429            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_THRESH_15MIN_LOSS_FLAG)){
3430                pts.adslLineAlarmConfProfileEntry_pt->adslAtucThresh15MinLoss=AlarmConfProfile.adslAtucThresh15MinLoss;
3431            }
3432            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_THRESH_15MIN_ESS_FLAG)){
3433                pts.adslLineAlarmConfProfileEntry_pt->adslAtucThresh15MinESs=AlarmConfProfile.adslAtucThresh15MinESs;
3434            }
3435            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_THRESH_FAST_RATEUP_FLAG)){
3436                pts.adslLineAlarmConfProfileEntry_pt->adslAtucThreshFastRateUp=AlarmConfProfile.adslAtucThreshFastRateUp;
3437            }
3438            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_THRESH_INTERLEAVE_RATEUP_FLAG)){
3439                pts.adslLineAlarmConfProfileEntry_pt->adslAtucThreshInterleaveRateUp=AlarmConfProfile.adslAtucThreshInterleaveRateUp;
3440            }
3441            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_THRESH_FAST_RATEDOWN_FLAG)){
3442                pts.adslLineAlarmConfProfileEntry_pt->adslAtucThreshFastRateDown=AlarmConfProfile.adslAtucThreshFastRateDown;
3443            }
3444            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_THRESH_INTERLEAVE_RATEDOWN_FLAG)){
3445                pts.adslLineAlarmConfProfileEntry_pt->adslAtucThreshInterleaveRateDown=AlarmConfProfile.adslAtucThreshInterleaveRateDown;
3446            }
3447            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_INIT_FAILURE_TRAP_ENABLE_FLAG)){
3448                pts.adslLineAlarmConfProfileEntry_pt->adslAtucInitFailureTrapEnable=AlarmConfProfile.adslAtucInitFailureTrapEnable;
3449            }
3450            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_15MIN_LOFS_FLAG)){
3451                pts.adslLineAlarmConfProfileEntry_pt->adslAturThresh15MinLofs=AlarmConfProfile.adslAturThresh15MinLofs;
3452            }
3453            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_15MIN_LOSS_FLAG)){
3454                pts.adslLineAlarmConfProfileEntry_pt->adslAturThresh15MinLoss=AlarmConfProfile.adslAturThresh15MinLoss;
3455            }
3456            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_15MIN_LPRS_FLAG)){
3457                pts.adslLineAlarmConfProfileEntry_pt->adslAturThresh15MinLprs=AlarmConfProfile.adslAturThresh15MinLprs;
3458            }
3459            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_15MIN_ESS_FLAG)){
3460                pts.adslLineAlarmConfProfileEntry_pt->adslAturThresh15MinESs=AlarmConfProfile.adslAturThresh15MinESs;
3461            }
3462            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_FAST_RATEUP_FLAG)){
3463                pts.adslLineAlarmConfProfileEntry_pt->adslAturThreshFastRateUp=AlarmConfProfile.adslAturThreshFastRateUp;
3464            }
3465            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_INTERLEAVE_RATEUP_FLAG)){
3466                pts.adslLineAlarmConfProfileEntry_pt->adslAturThreshInterleaveRateUp=AlarmConfProfile.adslAturThreshInterleaveRateUp;
3467            }
3468            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_FAST_RATEDOWN_FLAG)){
3469                pts.adslLineAlarmConfProfileEntry_pt->adslAturThreshFastRateDown=AlarmConfProfile.adslAturThreshFastRateDown;
3470            }
3471            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_INTERLEAVE_RATEDOWN_FLAG)){
3472                pts.adslLineAlarmConfProfileEntry_pt->adslAturThreshInterleaveRateDown=AlarmConfProfile.adslAturThreshInterleaveRateDown;
3473            }
3474            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), LINE_ALARM_CONF_PROFILE_ROWSTATUS_FLAG)){
3475                pts.adslLineAlarmConfProfileEntry_pt->adslLineAlarmConfProfileRowStatus=AlarmConfProfile.adslLineAlarmConfProfileRowStatus;
3476            }
3477            copy_to_user((char *)lon, (char *)pts.adslLineAlarmConfProfileEntry_pt, sizeof(adslLineAlarmConfProfileEntry));
3478            kfree(pts.adslLineAlarmConfProfileEntry_pt);
3479            break;
3480#ifdef AMAZON_MEI_MIB_RFC3440
3481        case GET_ADSL_ALRM_CONF_PROF_EXT:
3482            pts.adslLineAlarmConfProfileExtEntry_pt = (adslLineAlarmConfProfileExtEntry *)kmalloc(sizeof(adslLineAlarmConfProfileExtEntry), GFP_KERNEL);
3483            copy_from_user((char *)pts.adslLineAlarmConfProfileExtEntry_pt, (char *)lon, sizeof(adslLineAlarmConfProfileExtEntry));
3484            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileExtEntry_pt->flags)), ATUC_THRESH_15MIN_FAILED_FASTR_FLAG)){
3485                pts.adslLineAlarmConfProfileExtEntry_pt->adslAtucThreshold15MinFailedFastR=AlarmConfProfileExt.adslAtucThreshold15MinFailedFastR;
3486            }
3487            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileExtEntry_pt->flags)), ATUC_THRESH_15MIN_SESL_FLAG)){
3488                pts.adslLineAlarmConfProfileExtEntry_pt->adslAtucThreshold15MinSesL=AlarmConfProfileExt.adslAtucThreshold15MinSesL;
3489            }
3490            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileExtEntry_pt->flags)), ATUC_THRESH_15MIN_UASL_FLAG)){
3491                pts.adslLineAlarmConfProfileExtEntry_pt->adslAtucThreshold15MinUasL=AlarmConfProfileExt.adslAtucThreshold15MinUasL;
3492            }
3493            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileExtEntry_pt->flags)), ATUR_THRESH_15MIN_SESL_FLAG)){
3494                pts.adslLineAlarmConfProfileExtEntry_pt->adslAturThreshold15MinSesL=AlarmConfProfileExt.adslAturThreshold15MinSesL;
3495            }
3496            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileExtEntry_pt->flags)), ATUR_THRESH_15MIN_UASL_FLAG)){
3497                pts.adslLineAlarmConfProfileExtEntry_pt->adslAturThreshold15MinUasL=AlarmConfProfileExt.adslAturThreshold15MinUasL;
3498            }
3499            copy_to_user((char *)lon, (char *)pts.adslLineAlarmConfProfileExtEntry_pt, sizeof(adslLineAlarmConfProfileExtEntry));
3500            kfree(pts.adslLineAlarmConfProfileExtEntry_pt);
3501            break;
3502#endif
3503        case SET_ADSL_ALRM_CONF_PROF:
3504            pts.adslLineAlarmConfProfileEntry_pt = (adslLineAlarmConfProfileEntry *)kmalloc(sizeof(adslLineAlarmConfProfileEntry), GFP_KERNEL);
3505            copy_from_user((char *)pts.adslLineAlarmConfProfileEntry_pt, (char *)lon, sizeof(adslLineAlarmConfProfileEntry));
3506
3507            strncpy(AlarmConfProfile.adslLineAlarmConfProfileName, pts.adslLineAlarmConfProfileEntry_pt->adslLineAlarmConfProfileName, 32);
3508            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_THRESH_15MIN_LOFS_FLAG)){
3509                AlarmConfProfile.adslAtucThresh15MinLofs=pts.adslLineAlarmConfProfileEntry_pt->adslAtucThresh15MinLofs;
3510            }
3511            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_THRESH_15MIN_LOSS_FLAG)){
3512                AlarmConfProfile.adslAtucThresh15MinLoss=pts.adslLineAlarmConfProfileEntry_pt->adslAtucThresh15MinLoss;
3513            }
3514            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_THRESH_15MIN_ESS_FLAG)){
3515                AlarmConfProfile.adslAtucThresh15MinESs=pts.adslLineAlarmConfProfileEntry_pt->adslAtucThresh15MinESs;
3516            }
3517            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_THRESH_FAST_RATEUP_FLAG)){
3518                AlarmConfProfile.adslAtucThreshFastRateUp=pts.adslLineAlarmConfProfileEntry_pt->adslAtucThreshFastRateUp;
3519            }
3520            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_THRESH_INTERLEAVE_RATEUP_FLAG)){
3521                AlarmConfProfile.adslAtucThreshInterleaveRateUp=pts.adslLineAlarmConfProfileEntry_pt->adslAtucThreshInterleaveRateUp;
3522            }
3523            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_THRESH_FAST_RATEDOWN_FLAG)){
3524                AlarmConfProfile.adslAtucThreshFastRateDown=pts.adslLineAlarmConfProfileEntry_pt->adslAtucThreshFastRateDown;
3525            }
3526            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_THRESH_INTERLEAVE_RATEDOWN_FLAG)){
3527                AlarmConfProfile.adslAtucThreshInterleaveRateDown=pts.adslLineAlarmConfProfileEntry_pt->adslAtucThreshInterleaveRateDown;
3528            }
3529            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUC_INIT_FAILURE_TRAP_ENABLE_FLAG)){
3530                AlarmConfProfile.adslAtucInitFailureTrapEnable=pts.adslLineAlarmConfProfileEntry_pt->adslAtucInitFailureTrapEnable;
3531            }
3532            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_15MIN_LOFS_FLAG)){
3533                AlarmConfProfile.adslAturThresh15MinLofs=pts.adslLineAlarmConfProfileEntry_pt->adslAturThresh15MinLofs;
3534            }
3535            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_15MIN_LOSS_FLAG)){
3536                AlarmConfProfile.adslAturThresh15MinLoss=pts.adslLineAlarmConfProfileEntry_pt->adslAturThresh15MinLoss;
3537            }
3538            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_15MIN_LPRS_FLAG)){
3539                AlarmConfProfile.adslAturThresh15MinLprs=pts.adslLineAlarmConfProfileEntry_pt->adslAturThresh15MinLprs;
3540            }
3541            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_15MIN_ESS_FLAG)){
3542                AlarmConfProfile.adslAturThresh15MinESs=pts.adslLineAlarmConfProfileEntry_pt->adslAturThresh15MinESs;
3543            }
3544            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_FAST_RATEUP_FLAG)){
3545                AlarmConfProfile.adslAturThreshFastRateUp=pts.adslLineAlarmConfProfileEntry_pt->adslAturThreshFastRateUp;
3546            }
3547            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_INTERLEAVE_RATEUP_FLAG)){
3548                AlarmConfProfile.adslAturThreshInterleaveRateUp=pts.adslLineAlarmConfProfileEntry_pt->adslAturThreshInterleaveRateUp;
3549            }
3550            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_FAST_RATEDOWN_FLAG)){
3551                AlarmConfProfile.adslAturThreshFastRateDown=pts.adslLineAlarmConfProfileEntry_pt->adslAturThreshFastRateDown;
3552            }
3553            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), ATUR_THRESH_INTERLEAVE_RATEDOWN_FLAG)){
3554                AlarmConfProfile.adslAturThreshInterleaveRateDown=pts.adslLineAlarmConfProfileEntry_pt->adslAturThreshInterleaveRateDown;
3555            }
3556            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileEntry_pt->flags)), LINE_ALARM_CONF_PROFILE_ROWSTATUS_FLAG)){
3557                AlarmConfProfile.adslLineAlarmConfProfileRowStatus=pts.adslLineAlarmConfProfileEntry_pt->adslLineAlarmConfProfileRowStatus;
3558            }
3559            copy_to_user((char *)lon, (char *)pts.adslLineAlarmConfProfileEntry_pt, sizeof(adslLineAlarmConfProfileEntry));
3560            kfree(pts.adslLineAlarmConfProfileEntry_pt);
3561            break;
3562            
3563#ifdef AMAZON_MEI_MIB_RFC3440
3564        case SET_ADSL_ALRM_CONF_PROF_EXT:
3565            pts.adslLineAlarmConfProfileExtEntry_pt = (adslLineAlarmConfProfileExtEntry *)kmalloc(sizeof(adslLineAlarmConfProfileExtEntry), GFP_KERNEL);
3566            copy_from_user((char *)pts.adslLineAlarmConfProfileExtEntry_pt, (char *)lon, sizeof(adslLineAlarmConfProfileExtEntry));
3567            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileExtEntry_pt->flags)), ATUC_THRESH_15MIN_FAILED_FASTR_FLAG)){
3568                AlarmConfProfileExt.adslAtucThreshold15MinFailedFastR=pts.adslLineAlarmConfProfileExtEntry_pt->adslAtucThreshold15MinFailedFastR;
3569            }
3570            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileExtEntry_pt->flags)), ATUC_THRESH_15MIN_SESL_FLAG)){
3571                AlarmConfProfileExt.adslAtucThreshold15MinSesL=pts.adslLineAlarmConfProfileExtEntry_pt->adslAtucThreshold15MinSesL;
3572            }
3573            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileExtEntry_pt->flags)), ATUC_THRESH_15MIN_UASL_FLAG)){
3574                AlarmConfProfileExt.adslAtucThreshold15MinUasL=pts.adslLineAlarmConfProfileExtEntry_pt->adslAtucThreshold15MinUasL;
3575            }
3576            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileExtEntry_pt->flags)), ATUR_THRESH_15MIN_SESL_FLAG)){
3577                AlarmConfProfileExt.adslAturThreshold15MinSesL=pts.adslLineAlarmConfProfileExtEntry_pt->adslAturThreshold15MinSesL;
3578            }
3579            if(IS_FLAG_SET((&(pts.adslLineAlarmConfProfileExtEntry_pt->flags)), ATUR_THRESH_15MIN_UASL_FLAG)){
3580                AlarmConfProfileExt.adslAturThreshold15MinUasL=pts.adslLineAlarmConfProfileExtEntry_pt->adslAturThreshold15MinUasL;
3581            }
3582            copy_to_user((char *)lon, (char *)pts.adslLineAlarmConfProfileExtEntry_pt, sizeof(adslLineAlarmConfProfileExtEntry));
3583            kfree(pts.adslLineAlarmConfProfileExtEntry_pt);
3584            break;
3585#endif
3586
3587        case ADSL_ATUR_TRAPS:
3588            if(down_interruptible(&mei_sema))
3589                        return -ERESTARTSYS;
3590            
3591            trapsflag=0;
3592            if(AlarmConfProfile.adslAtucThresh15MinLofs!=0 && current_intvl->AtucPerfLof>=AlarmConfProfile.adslAtucThresh15MinLofs)
3593                trapsflag|=ATUC_PERF_LOFS_THRESH_FLAG;
3594            if(AlarmConfProfile.adslAtucThresh15MinLoss!=0 && current_intvl->AtucPerfLos>=AlarmConfProfile.adslAtucThresh15MinLoss)
3595                trapsflag|=ATUC_PERF_LOSS_THRESH_FLAG;
3596            if(AlarmConfProfile.adslAtucThresh15MinESs!=0 && current_intvl->AtucPerfEs>=AlarmConfProfile.adslAtucThresh15MinESs)
3597                trapsflag|=ATUC_PERF_ESS_THRESH_FLAG;
3598            if(chantype.fast==1){
3599                if(AlarmConfProfile.adslAtucThreshFastRateUp!=0 || AlarmConfProfile.adslAtucThreshFastRateDown!=0){
3600                    ATUC_CHAN_CURR_TX_RATE_FLAG_MAKECMV;
3601                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3602#ifdef AMAZON_MEI_DEBUG_ON
3603                        printk("\n\nCMV fail, Group 6 Address 1 Index 0");
3604#endif
3605                    }
3606                    else{
3607                        temp = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
3608                        if((AlarmConfProfile.adslAtucThreshFastRateUp!=0) && (temp>=PrevTxRate.adslAtucChanPrevTxRate+AlarmConfProfile.adslAtucThreshFastRateUp)){
3609                            trapsflag|=ATUC_RATE_CHANGE_FLAG;
3610                            PrevTxRate.adslAtucChanPrevTxRate = temp;
3611                        }
3612                        if((AlarmConfProfile.adslAtucThreshFastRateDown!=0) && (temp<=PrevTxRate.adslAtucChanPrevTxRate-AlarmConfProfile.adslAtucThreshFastRateDown)){
3613                            trapsflag|=ATUC_RATE_CHANGE_FLAG;
3614                            PrevTxRate.adslAtucChanPrevTxRate = temp;
3615                        }
3616                    }
3617                }
3618            }
3619            if(chantype.interleave==1){
3620                if(AlarmConfProfile.adslAtucThreshInterleaveRateUp!=0 || AlarmConfProfile.adslAtucThreshInterleaveRateDown!=0){
3621                    ATUC_CHAN_CURR_TX_RATE_FLAG_MAKECMV;
3622                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3623#ifdef AMAZON_MEI_DEBUG_ON
3624                        printk("\n\nCMV fail, Group 6 Address 1 Index 0");
3625#endif
3626                    }
3627                    else{
3628                        temp = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
3629                        if((AlarmConfProfile.adslAtucThreshInterleaveRateUp!=0) && (temp>=PrevTxRate.adslAtucChanPrevTxRate+AlarmConfProfile.adslAtucThreshInterleaveRateUp)){
3630                            trapsflag|=ATUC_RATE_CHANGE_FLAG;
3631                            PrevTxRate.adslAtucChanPrevTxRate = temp;
3632                        }
3633                        if((AlarmConfProfile.adslAtucThreshInterleaveRateDown!=0) && (temp<=PrevTxRate.adslAtucChanPrevTxRate-AlarmConfProfile.adslAtucThreshInterleaveRateDown)){
3634                            trapsflag|=ATUC_RATE_CHANGE_FLAG;
3635                            PrevTxRate.adslAtucChanPrevTxRate = temp;
3636                        }
3637                    }
3638                }
3639            }
3640            if(AlarmConfProfile.adslAturThresh15MinLofs!=0 && current_intvl->AturPerfLof>=AlarmConfProfile.adslAturThresh15MinLofs)
3641                trapsflag|=ATUR_PERF_LOFS_THRESH_FLAG;
3642            if(AlarmConfProfile.adslAturThresh15MinLoss!=0 && current_intvl->AturPerfLos>=AlarmConfProfile.adslAturThresh15MinLoss)
3643                trapsflag|=ATUR_PERF_LOSS_THRESH_FLAG;
3644            if(AlarmConfProfile.adslAturThresh15MinLprs!=0 && current_intvl->AturPerfLpr>=AlarmConfProfile.adslAturThresh15MinLprs)
3645                trapsflag|=ATUR_PERF_LPRS_THRESH_FLAG;
3646            if(AlarmConfProfile.adslAturThresh15MinESs!=0 && current_intvl->AturPerfEs>=AlarmConfProfile.adslAturThresh15MinESs)
3647                trapsflag|=ATUR_PERF_ESS_THRESH_FLAG;
3648            if(chantype.fast==1){
3649                if(AlarmConfProfile.adslAturThreshFastRateUp!=0 || AlarmConfProfile.adslAturThreshFastRateDown!=0){
3650                    ATUR_CHAN_CURR_TX_RATE_FLAG_MAKECMV;
3651                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3652#ifdef AMAZON_MEI_DEBUG_ON
3653                        printk("\n\nCMV fail, Group 6 Address 0 Index 0");
3654#endif
3655                    }
3656                    else{
3657                        temp = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
3658                        if((AlarmConfProfile.adslAturThreshFastRateUp!=0) && (temp>=PrevTxRate.adslAturChanPrevTxRate+AlarmConfProfile.adslAturThreshFastRateUp)){
3659                            trapsflag|=ATUR_RATE_CHANGE_FLAG;
3660                            PrevTxRate.adslAturChanPrevTxRate = temp;
3661                        }
3662                        if((AlarmConfProfile.adslAturThreshFastRateDown!=0) && (temp<=PrevTxRate.adslAturChanPrevTxRate-AlarmConfProfile.adslAturThreshFastRateDown)){
3663                            trapsflag|=ATUR_RATE_CHANGE_FLAG;
3664                            PrevTxRate.adslAturChanPrevTxRate = temp;
3665                        }
3666                    }
3667                }
3668            }
3669            if(chantype.interleave==1){
3670                if(AlarmConfProfile.adslAturThreshInterleaveRateUp!=0 || AlarmConfProfile.adslAturThreshInterleaveRateDown!=0){
3671                    ATUR_CHAN_CURR_TX_RATE_FLAG_MAKECMV;
3672                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3673#ifdef AMAZON_MEI_DEBUG_ON
3674                        printk("\n\nCMV fail, Group 6 Address 0 Index 0");
3675#endif
3676                    }
3677                    else{
3678                        temp = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
3679                        if((AlarmConfProfile.adslAturThreshInterleaveRateUp!=0) && (temp>=PrevTxRate.adslAturChanPrevTxRate+AlarmConfProfile.adslAturThreshInterleaveRateUp)){
3680                            trapsflag|=ATUR_RATE_CHANGE_FLAG;
3681                            PrevTxRate.adslAturChanPrevTxRate = temp;
3682                        }
3683                        if((AlarmConfProfile.adslAturThreshInterleaveRateDown!=0) && (temp<=PrevTxRate.adslAturChanPrevTxRate-AlarmConfProfile.adslAturThreshInterleaveRateDown)){
3684                            trapsflag|=ATUR_RATE_CHANGE_FLAG;
3685                            PrevTxRate.adslAturChanPrevTxRate = temp;
3686                        }
3687                    }
3688                }
3689            }
3690            copy_to_user((char *)lon, (char *)(&trapsflag), 2);
3691            
3692            up(&mei_sema);
3693            break;
3694            
3695#ifdef AMAZON_MEI_MIB_RFC3440
3696        case ADSL_ATUR_EXT_TRAPS:
3697            trapsflag=0;
3698            if(AlarmConfProfileExt.adslAtucThreshold15MinFailedFastR!=0 && current_intvl->AtucPerfStatFailedFastR>=AlarmConfProfileExt.adslAtucThreshold15MinFailedFastR)
3699                trapsflag|=ATUC_15MIN_FAILED_FASTR_TRAP_FLAG;
3700            if(AlarmConfProfileExt.adslAtucThreshold15MinSesL!=0 && current_intvl->AtucPerfStatSesL>=AlarmConfProfileExt.adslAtucThreshold15MinSesL)
3701                trapsflag|=ATUC_15MIN_SESL_TRAP_FLAG;
3702            if(AlarmConfProfileExt.adslAtucThreshold15MinUasL!=0 && current_intvl->AtucPerfStatUasL>=AlarmConfProfileExt.adslAtucThreshold15MinUasL)
3703                trapsflag|=ATUC_15MIN_UASL_TRAP_FLAG;
3704            if(AlarmConfProfileExt.adslAturThreshold15MinSesL!=0 && current_intvl->AturPerfStatSesL>=AlarmConfProfileExt.adslAturThreshold15MinSesL)
3705                trapsflag|=ATUR_15MIN_SESL_TRAP_FLAG;
3706            if(AlarmConfProfileExt.adslAturThreshold15MinUasL!=0 && current_intvl->AturPerfStatUasL>=AlarmConfProfileExt.adslAturThreshold15MinUasL)
3707                trapsflag|=ATUR_15MIN_UASL_TRAP_FLAG;
3708            copy_to_user((char *)lon, (char *)(&trapsflag), 2);
3709            break;
3710#endif
3711
3712// 603221:tc.chen start
3713        case GET_ADSL_LINE_STATUS:
3714            if(down_interruptible(&mei_sema))
3715                        return -ERESTARTSYS;
3716            
3717            pts.adslLineStatusInfo_pt = (adslLineStatusInfo *)kmalloc(sizeof(adslLineStatusInfo), GFP_KERNEL);
3718            copy_from_user((char *)pts.adslLineStatusInfo_pt, (char *)lon, sizeof(adslLineStatusInfo));
3719            
3720            if(IS_FLAG_SET((&(pts.adslLineStatusInfo_pt->flags)), LINE_STAT_MODEM_STATUS_FLAG)){
3721                LINE_STAT_MODEM_STATUS_FLAG_MAKECMV;
3722                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3723#ifdef AMAZON_MEI_DEBUG_ON
3724                    printk("\n\nCMV fail, Group STAT Address 0 Index 0");
3725#endif
3726                    pts.adslLineStatusInfo_pt->adslModemStatus = 0;
3727                }
3728                else{
3729                    pts.adslLineStatusInfo_pt->adslModemStatus = RxMessage[4];
3730                }
3731            }
3732            
3733            if(IS_FLAG_SET((&(pts.adslLineStatusInfo_pt->flags)), LINE_STAT_MODE_SEL_FLAG)){
3734                LINE_STAT_MODE_SEL_FLAG_MAKECMV;
3735                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3736#ifdef AMAZON_MEI_DEBUG_ON
3737                    printk("\n\nCMV fail, Group STAT Address 1 Index 0");
3738#endif
3739                    pts.adslLineStatusInfo_pt->adslModeSelected = 0;
3740                }
3741                else{
3742                    pts.adslLineStatusInfo_pt->adslModeSelected = RxMessage[4];
3743                }
3744            }
3745            
3746            if(IS_FLAG_SET((&(pts.adslLineStatusInfo_pt->flags)), LINE_STAT_TRELLCOD_ENABLE_FLAG)){
3747                LINE_STAT_TRELLCOD_ENABLE_FLAG_MAKECMV;
3748                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3749#ifdef AMAZON_MEI_DEBUG_ON
3750                    printk("\n\nCMV fail, Group OPTN Address 2 Index 0");
3751#endif
3752                    pts.adslLineStatusInfo_pt->adslTrellisCodeEnable = 0;
3753                }
3754                else{
3755                    
3756                    pts.adslLineStatusInfo_pt->adslTrellisCodeEnable = (RxMessage[4]>>13)&0x1==0x1?0:1;
3757                }
3758            }
3759            
3760            if(IS_FLAG_SET((&(pts.adslLineStatusInfo_pt->flags)), LINE_STAT_LATENCY_FLAG)){
3761                LINE_STAT_LATENCY_FLAG_MAKECMV;
3762                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3763#ifdef AMAZON_MEI_DEBUG_ON
3764                    printk("\n\nCMV fail, Group STAT Address 12 Index 0");
3765#endif
3766                    pts.adslLineStatusInfo_pt->adslLatency = 0;
3767                }
3768                else{
3769                    pts.adslLineStatusInfo_pt->adslLatency = RxMessage[4];
3770                }
3771            }
3772            
3773            copy_to_user((char *)lon, (char *)pts.adslLineStatusInfo_pt, sizeof(adslLineStatusInfo));
3774            kfree(pts.adslLineStatusInfo_pt);
3775            
3776            up(&mei_sema);
3777            break;
3778
3779
3780        case GET_ADSL_LINE_RATE:
3781            if (showtime!=1)
3782                return -ERESTARTSYS;
3783            if(down_interruptible(&mei_sema))
3784                        return -ERESTARTSYS;
3785            
3786            pts.adslLineRateInfo_pt = (adslLineRateInfo *)kmalloc(sizeof(adslLineRateInfo), GFP_KERNEL);
3787            copy_from_user((char *)pts.adslLineRateInfo_pt, (char *)lon, sizeof(adslLineRateInfo));
3788            
3789            if(IS_FLAG_SET((&(pts.adslLineRateInfo_pt->flags)), LINE_RATE_DATA_RATEDS_FLAG)){
3790                if (adsl_mode <=8 && adsl_mode_extend==0) // adsl mode
3791                {
3792                    if (chantype.interleave)
3793                        LINE_RATE_DATA_RATEDS_FLAG_ADSL1_LP0_MAKECMV;
3794                    else
3795                        LINE_RATE_DATA_RATEDS_FLAG_ADSL1_LP1_MAKECMV;
3796                        
3797                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3798#ifdef AMAZON_MEI_DEBUG_ON
3799                        printk("\n\nCMV fail, Group RATE Address 1 Index 0");
3800#endif
3801                        pts.adslLineRateInfo_pt->adslDataRateds = 0;
3802                    }
3803                    else{
3804                        pts.adslLineRateInfo_pt->adslDataRateds = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
3805                    }
3806                }else // adsl 2/2+
3807                {
3808                    unsigned long Mp,Lp,Tp,Rp,Kp,Bpn,DataRate,DataRate_remain;
3809                    Mp=Lp=Tp=Rp=Kp=Bpn=DataRate=DataRate_remain=0;
3810                    //// up stream data rate
3811                      
3812                        if (chantype.interleave)
3813                        {
3814                                LINE_RATE_DATA_RATEUS_FLAG_ADSL2_LP_LP0_MAKECMV;
3815                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3816#ifdef AMAZON_MEI_DEBUG_ON
3817                            printk("\n\nCMV fail, Group CNFG Address 25 Index 0");
3818#endif
3819                            Lp = 0;
3820                            }else
3821                                        Lp=RxMessage[4];
3822                   
3823                                    LINE_RATE_DATA_RATEUS_FLAG_ADSL2_RP_LP0_MAKECMV;
3824                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3825#ifdef AMAZON_MEI_DEBUG_ON
3826                            printk("\n\nCMV fail, Group CNFG Address 23 Index 0");
3827#endif
3828                            Rp = 0;
3829                            }else
3830                                        Rp=RxMessage[4];
3831                
3832                                    LINE_RATE_DATA_RATEUS_FLAG_ADSL2_MP_LP0_MAKECMV;
3833                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3834#ifdef AMAZON_MEI_DEBUG_ON
3835                            printk("\n\nCMV fail, Group CNFG Address 24 Index 0");
3836#endif
3837                            Mp = 0;
3838                            }else
3839                                        Mp=RxMessage[4];
3840                
3841                                    LINE_RATE_DATA_RATEUS_FLAG_ADSL2_TP_LP0_MAKECMV;
3842                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3843#ifdef AMAZON_MEI_DEBUG_ON
3844                            printk("\n\nCMV fail, Group CNFG Address 26 Index 0");
3845#endif
3846                            Tp = 0;
3847                            }else
3848                                        Tp=RxMessage[4];
3849                
3850                                    LINE_RATE_DATA_RATEUS_FLAG_ADSL2_KP_LP0_MAKECMV;
3851                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3852#ifdef AMAZON_MEI_DEBUG_ON
3853                            printk("\n\nCMV fail, Group CNFG Address 28 Index 0");
3854#endif
3855                            Kp = 0;
3856                            }else
3857                            {
3858                                        Kp=RxMessage[4]+ RxMessage[5]+1;
3859                                        Bpn=RxMessage[4]+ RxMessage[5];
3860                                    }
3861                                }else
3862                                {
3863                                        LINE_RATE_DATA_RATEUS_FLAG_ADSL2_LP_LP1_MAKECMV;
3864                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3865#ifdef AMAZON_MEI_DEBUG_ON
3866                            printk("\n\nCMV fail, Group CNFG Address 25 Index 1");
3867#endif
3868                            Lp = 0;
3869                            }else
3870                                        Lp=RxMessage[4];
3871                   
3872                                    LINE_RATE_DATA_RATEUS_FLAG_ADSL2_RP_LP1_MAKECMV;
3873                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3874#ifdef AMAZON_MEI_DEBUG_ON
3875                            printk("\n\nCMV fail, Group CNFG Address 23 Index 1");
3876#endif
3877                            Rp = 0;
3878                            }else
3879                                        Rp=RxMessage[4];
3880                
3881                                    LINE_RATE_DATA_RATEUS_FLAG_ADSL2_MP_LP1_MAKECMV;
3882                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3883#ifdef AMAZON_MEI_DEBUG_ON
3884                            printk("\n\nCMV fail, Group CNFG Address 24 Index 1");
3885#endif
3886                            Mp = 0;
3887                            }else
3888                                        Mp=RxMessage[4];
3889                
3890                                    LINE_RATE_DATA_RATEUS_FLAG_ADSL2_TP_LP1_MAKECMV;
3891                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3892#ifdef AMAZON_MEI_DEBUG_ON
3893                            printk("\n\nCMV fail, Group CNFG Address 26 Index 1");
3894#endif
3895                            Tp = 0;
3896                            }else
3897                                        Tp=RxMessage[4];
3898                
3899                                    LINE_RATE_DATA_RATEUS_FLAG_ADSL2_KP_LP1_MAKECMV;
3900                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3901#ifdef AMAZON_MEI_DEBUG_ON
3902                            printk("\n\nCMV fail, Group CNFG Address 28 Index 2");
3903#endif
3904                            Kp = 0;
3905                            }else
3906                            {
3907                                        Kp=RxMessage[4]+ RxMessage[5]+1;
3908                                        Bpn=RxMessage[4]+ RxMessage[5];
3909                                    }
3910                                }
3911                          DataRate=((Tp*(Bpn+1)-1)*Mp*Lp*4)/(Tp*(Kp*Mp+Rp));
3912                                //DataRate_remain=((((Tp*(Bpn+1)-1)*Mp*Lp*4)%(Tp*(Kp*Mp+Rp)))*1000)/(Tp*(Kp*Mp+Rp));
3913                                //pts.adslLineRateInfo_pt->adslDataRateds = DataRate * 1000 + DataRate_remain;
3914                                pts.adslLineRateInfo_pt->adslDataRateds = DataRate;
3915                }
3916            }
3917            
3918            if(IS_FLAG_SET((&(pts.adslLineRateInfo_pt->flags)), LINE_RATE_DATA_RATEUS_FLAG)){
3919                if (adsl_mode <=8 && adsl_mode_extend==0) // adsl mode
3920                {
3921                    if (chantype.interleave)
3922                        LINE_RATE_DATA_RATEUS_FLAG_ADSL1_LP0_MAKECMV;
3923                    else
3924                        LINE_RATE_DATA_RATEUS_FLAG_ADSL1_LP1_MAKECMV;
3925                        
3926                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3927    #ifdef AMAZON_MEI_DEBUG_ON
3928                        printk("\n\nCMV fail, Group RATE Address 0 Index 0");
3929    #endif
3930                        pts.adslLineRateInfo_pt->adslDataRateus = 0;
3931                    }
3932                    else{
3933                        pts.adslLineRateInfo_pt->adslDataRateus = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
3934                    }
3935                }else // adsl 2/2+
3936                {
3937                    unsigned long Mp,Lp,Tp,Rp,Kp,Bpn,DataRate,DataRate_remain;
3938                    Mp=Lp=Tp=Rp=Kp=Bpn=DataRate=DataRate_remain=0;
3939                    //// down stream data rate
3940                       
3941                         if (chantype.interleave)
3942                        {
3943                                LINE_RATE_DATA_RATEDS_FLAG_ADSL2_LP_LP0_MAKECMV;
3944                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3945#ifdef AMAZON_MEI_DEBUG_ON
3946                            printk("\n\nCMV fail, Group CNFG Address 14 Index 0");
3947#endif
3948                            Lp = 0;
3949                            }else
3950                                        Lp=RxMessage[4];
3951                   
3952                                    LINE_RATE_DATA_RATEDS_FLAG_ADSL2_RP_LP0_MAKECMV;
3953                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3954#ifdef AMAZON_MEI_DEBUG_ON
3955                            printk("\n\nCMV fail, Group CNFG Address 12 Index 0");
3956#endif
3957                            Rp = 0;
3958                            }else
3959                                        Rp=RxMessage[4];
3960                
3961                                    LINE_RATE_DATA_RATEDS_FLAG_ADSL2_MP_LP0_MAKECMV;
3962                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3963#ifdef AMAZON_MEI_DEBUG_ON
3964                            printk("\n\nCMV fail, Group CNFG Address 13 Index 0");
3965#endif
3966                            Mp = 0;
3967                            }else
3968                                        Mp=RxMessage[4];
3969                
3970                                    LINE_RATE_DATA_RATEDS_FLAG_ADSL2_TP_LP0_MAKECMV;
3971                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3972#ifdef AMAZON_MEI_DEBUG_ON
3973                            printk("\n\nCMV fail, Group CNFG Address 15 Index 0");
3974#endif
3975                            Tp = 0;
3976                            }else
3977                                        Tp=RxMessage[4];
3978                
3979                                    LINE_RATE_DATA_RATEDS_FLAG_ADSL2_KP_LP0_MAKECMV;
3980                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3981#ifdef AMAZON_MEI_DEBUG_ON
3982                            printk("\n\nCMV fail, Group CNFG Address 17 Index 0");
3983#endif
3984                            Kp = 0;
3985                            }else
3986                            {
3987                                        Kp=RxMessage[4]+ RxMessage[5]+1;
3988                                        Bpn=RxMessage[4]+ RxMessage[5];
3989                                    }
3990                                }else
3991                                {
3992                                        LINE_RATE_DATA_RATEDS_FLAG_ADSL2_LP_LP1_MAKECMV;
3993                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
3994#ifdef AMAZON_MEI_DEBUG_ON
3995                            printk("\n\nCMV fail, Group CNFG Address 14 Index 1");
3996#endif
3997                            Lp = 0;
3998                            }else
3999                                        Lp=RxMessage[4];
4000                   
4001                                    LINE_RATE_DATA_RATEDS_FLAG_ADSL2_RP_LP1_MAKECMV;
4002                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4003#ifdef AMAZON_MEI_DEBUG_ON
4004                            printk("\n\nCMV fail, Group CNFG Address 12 Index 1");
4005#endif
4006                            Rp = 0;
4007                            }else
4008                                        Rp=RxMessage[4];
4009                
4010                                    LINE_RATE_DATA_RATEDS_FLAG_ADSL2_MP_LP1_MAKECMV;
4011                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4012#ifdef AMAZON_MEI_DEBUG_ON
4013                            printk("\n\nCMV fail, Group CNFG Address 13 Index 1");
4014#endif
4015                            Mp = 0;
4016                            }else
4017                                        Mp=RxMessage[4];
4018                
4019                                    LINE_RATE_DATA_RATEDS_FLAG_ADSL2_TP_LP1_MAKECMV;
4020                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4021#ifdef AMAZON_MEI_DEBUG_ON
4022                            printk("\n\nCMV fail, Group CNFG Address 15 Index 1");
4023#endif
4024                            Tp = 0;
4025                            }else
4026                                        Tp=RxMessage[4];
4027                
4028                                    LINE_RATE_DATA_RATEDS_FLAG_ADSL2_KP_LP1_MAKECMV;
4029                                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4030#ifdef AMAZON_MEI_DEBUG_ON
4031                            printk("\n\nCMV fail, Group CNFG Address 17 Index 2");
4032#endif
4033                            Kp = 0;
4034                            }else
4035                            {
4036                                        Kp=RxMessage[4]+ RxMessage[5]+1;
4037                                        Bpn=RxMessage[4]+ RxMessage[5];
4038                                    }
4039                                }
4040                                DataRate=((Tp*(Bpn+1)-1)*Mp*Lp*4)/(Tp*(Kp*Mp+Rp));
4041                                //DataRate_remain=((((Tp*(Bpn+1)-1)*Mp*Lp*4)%(Tp*(Kp*Mp+Rp)))*1000)/(Tp*(Kp*Mp+Rp));
4042                                //pts.adslLineRateInfo_pt->adslDataRateus = DataRate * 1000 + DataRate_remain;
4043                                pts.adslLineRateInfo_pt->adslDataRateus = DataRate;
4044                }
4045            }
4046            
4047            if(IS_FLAG_SET((&(pts.adslLineRateInfo_pt->flags)), LINE_RATE_ATTNDRDS_FLAG)){
4048                LINE_RATE_ATTNDRDS_FLAG_MAKECMV;
4049                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4050#ifdef AMAZON_MEI_DEBUG_ON
4051                    printk("\n\nCMV fail, Group INFO Address 68 Index 4");
4052#endif
4053                    pts.adslLineRateInfo_pt->adslATTNDRds = 0;
4054                }
4055                else{
4056                    pts.adslLineRateInfo_pt->adslATTNDRds = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
4057                }
4058            }
4059            
4060            if(IS_FLAG_SET((&(pts.adslLineRateInfo_pt->flags)), LINE_RATE_ATTNDRUS_FLAG)){
4061                if (adsl_mode <=8 && adsl_mode_extend==0) // adsl mode
4062                {
4063                    LINE_RATE_ATTNDRUS_FLAG_MAKECMV;
4064                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4065    #ifdef AMAZON_MEI_DEBUG_ON
4066                        printk("\n\nCMV fail, Group INFO Address 69 Index 4");
4067    #endif
4068                        pts.adslLineRateInfo_pt->adslATTNDRus = 0;
4069                    }
4070                    else{
4071                        pts.adslLineRateInfo_pt->adslATTNDRus = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
4072                    }
4073                }else
4074                {
4075                    hdlc_cmd[0]=0x0181;
4076                    hdlc_cmd[1]=0x24;
4077                    up(&mei_sema);
4078                    if (ifx_me_hdlc_send((unsigned char *)&hdlc_cmd[0],4)!= -EBUSY)
4079                    {
4080                        set_current_state(TASK_INTERRUPTIBLE);
4081                        schedule_timeout(1);
4082                        hdlc_rx_len=0;
4083                        hdlc_rx_len = ifx_mei_hdlc_read(&hdlc_rx_buffer,32*2);
4084                        if (hdlc_rx_len <=0)
4085                        {
4086                                    meierr = -ERESTARTSYS;
4087                                    goto GET_ADSL_LINE_RATE_END;
4088                                }
4089                        pts.adslLineRateInfo_pt->adslATTNDRus = (u32)le16_to_cpu(hdlc_rx_buffer[1])<<16 | (u32)le16_to_cpu(hdlc_rx_buffer[2]);
4090                    }
4091                    if(down_interruptible(&mei_sema))
4092                    {
4093                                meierr = -ERESTARTSYS;
4094                                goto GET_ADSL_LINE_RATE_END;
4095                            }
4096                }
4097            }
4098            copy_to_user((char *)lon, (char *)pts.adslLineRateInfo_pt, sizeof(adslLineRateInfo));
4099            up(&mei_sema);
4100            
4101GET_ADSL_LINE_RATE_END:
4102            kfree(pts.adslLineRateInfo_pt);
4103            break;
4104
4105        case GET_ADSL_LINE_INFO:
4106            if (showtime!=1)
4107                return -ERESTARTSYS;
4108            if(down_interruptible(&mei_sema))
4109                        return -ERESTARTSYS;
4110            
4111            pts.adslLineInfo_pt = (adslLineInfo *)kmalloc(sizeof(adslLineInfo), GFP_KERNEL);
4112            copy_from_user((char *)pts.adslLineInfo_pt, (char *)lon, sizeof(adslLineInfo));
4113            
4114            if(IS_FLAG_SET((&(pts.adslLineInfo_pt->flags)), LINE_INFO_INTLV_DEPTHDS_FLAG)){
4115                if (chantype.interleave)
4116                    LINE_INFO_INTLV_DEPTHDS_FLAG_LP0_MAKECMV;
4117                else
4118                    LINE_INFO_INTLV_DEPTHDS_FLAG_LP1_MAKECMV;
4119                    
4120                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4121#ifdef AMAZON_MEI_DEBUG_ON
4122                    printk("\n\nCMV fail, Group CNFG Address 27 Index 0");
4123#endif
4124                    pts.adslLineInfo_pt->adslInterleaveDepthds = 0;
4125                }
4126                else{
4127                    pts.adslLineInfo_pt->adslInterleaveDepthds = RxMessage[4];
4128                }
4129            }
4130            
4131            if(IS_FLAG_SET((&(pts.adslLineInfo_pt->flags)), LINE_INFO_INTLV_DEPTHUS_FLAG)){
4132                if (chantype.interleave)
4133                    LINE_INFO_INTLV_DEPTHUS_FLAG_LP0_MAKECMV;
4134                else
4135                    LINE_INFO_INTLV_DEPTHUS_FLAG_LP1_MAKECMV;
4136                    
4137                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4138#ifdef AMAZON_MEI_DEBUG_ON
4139                    printk("\n\nCMV fail, Group CNFG Address 16 Index 0");
4140#endif
4141                    pts.adslLineInfo_pt->adslInterleaveDepthus = 0;
4142                }
4143                else{
4144                    pts.adslLineInfo_pt->adslInterleaveDepthus = RxMessage[4];
4145                }
4146            }
4147            
4148            if(IS_FLAG_SET((&(pts.adslLineInfo_pt->flags)), LINE_INFO_LATNDS_FLAG)){
4149                LINE_INFO_LATNDS_FLAG_MAKECMV;
4150                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4151#ifdef AMAZON_MEI_DEBUG_ON
4152                    printk("\n\nCMV fail, Group INFO Address 68 Index 1");
4153#endif
4154                    pts.adslLineInfo_pt->adslLATNds = 0;
4155                }
4156                else{
4157                    pts.adslLineInfo_pt->adslLATNds = RxMessage[4];
4158                }
4159            }
4160            
4161            if(IS_FLAG_SET((&(pts.adslLineInfo_pt->flags)), LINE_INFO_LATNUS_FLAG)){
4162                if (adsl_mode <=8 && adsl_mode_extend==0) // adsl mode
4163                {
4164                    LINE_INFO_LATNUS_FLAG_MAKECMV;
4165                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4166#ifdef AMAZON_MEI_DEBUG_ON
4167                        printk("\n\nCMV fail, Group INFO Address 69 Index 1");
4168#endif
4169                        pts.adslLineInfo_pt->adslLATNus = 0;
4170                    }
4171                    else{
4172                        pts.adslLineInfo_pt->adslLATNus = RxMessage[4];
4173                    }
4174                }else
4175                {
4176                    hdlc_cmd[0]=0x0181;
4177                    hdlc_cmd[1]=0x21;
4178                    up(&mei_sema);
4179                    if (ifx_me_hdlc_send((unsigned char *)&hdlc_cmd[0],4)!= -EBUSY)
4180                    {
4181                        set_current_state(TASK_INTERRUPTIBLE);
4182                        schedule_timeout(1);
4183                        hdlc_rx_len=0;
4184                        hdlc_rx_len = ifx_mei_hdlc_read(&hdlc_rx_buffer,32*2);
4185                        if (hdlc_rx_len <=0)
4186                        {
4187                                    meierr = -ERESTARTSYS;
4188                                    goto GET_ADSL_LINE_INFO_END;
4189                                }
4190                        pts.adslLineInfo_pt->adslLATNus = le16_to_cpu(hdlc_rx_buffer[1]);
4191                    }
4192                    if(down_interruptible(&mei_sema))
4193                    {
4194                                meierr = -ERESTARTSYS;
4195                                goto GET_ADSL_LINE_INFO_END;
4196                            }
4197                }
4198            }
4199            
4200            if(IS_FLAG_SET((&(pts.adslLineInfo_pt->flags)), LINE_INFO_SATNDS_FLAG)){
4201                LINE_INFO_SATNDS_FLAG_MAKECMV;
4202                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4203#ifdef AMAZON_MEI_DEBUG_ON
4204                    printk("\n\nCMV fail, Group INFO Address 68 Index 2");
4205#endif
4206                    pts.adslLineInfo_pt->adslSATNds = 0;
4207                }
4208                else{
4209                    pts.adslLineInfo_pt->adslSATNds = RxMessage[4];
4210                }
4211            }
4212            
4213            if(IS_FLAG_SET((&(pts.adslLineInfo_pt->flags)), LINE_INFO_SATNUS_FLAG)){
4214                if (adsl_mode <=8 && adsl_mode_extend==0) // adsl mode
4215                {
4216                    LINE_INFO_SATNUS_FLAG_MAKECMV;
4217                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4218#ifdef AMAZON_MEI_DEBUG_ON
4219                        printk("\n\nCMV fail, Group INFO Address 69 Index 2");
4220#endif
4221                        pts.adslLineInfo_pt->adslSATNus = 0;
4222                    }
4223                    else{
4224                        pts.adslLineInfo_pt->adslSATNus = RxMessage[4];
4225                    }
4226                }else
4227                {
4228                    hdlc_cmd[0]=0x0181;
4229                    hdlc_cmd[1]=0x22;
4230                    up(&mei_sema);
4231                    if (ifx_me_hdlc_send((unsigned char *)&hdlc_cmd[0],4)!= -EBUSY)
4232                    {
4233                        set_current_state(TASK_INTERRUPTIBLE);
4234                        schedule_timeout(1);
4235                        hdlc_rx_len=0;
4236                        hdlc_rx_len = ifx_mei_hdlc_read(&hdlc_rx_buffer,32*2);
4237                        if (hdlc_rx_len <=0)
4238                        {
4239                                    meierr = -ERESTARTSYS;
4240                                    goto GET_ADSL_LINE_INFO_END;
4241                                }
4242                        pts.adslLineInfo_pt->adslSATNus = le16_to_cpu(hdlc_rx_buffer[1]);
4243                    }
4244                    if(down_interruptible(&mei_sema))
4245                            {
4246                                meierr = -ERESTARTSYS;
4247                                goto GET_ADSL_LINE_INFO_END;
4248                            }
4249                }
4250            }
4251            
4252            if(IS_FLAG_SET((&(pts.adslLineInfo_pt->flags)), LINE_INFO_SNRMNDS_FLAG)){
4253                if (adsl_mode <=8 && adsl_mode_extend==0) // adsl mode
4254                {
4255                    LINE_INFO_SNRMNDS_FLAG_ADSL1_MAKECMV;
4256                }
4257                else if ((adsl_mode == 0x4000) || (adsl_mode == 0x8000) || adsl_mode_extend > 0)
4258                {
4259                    LINE_INFO_SNRMNDS_FLAG_ADSL2PLUS_MAKECMV;
4260                }
4261                else
4262                {
4263                    LINE_INFO_SNRMNDS_FLAG_ADSL2_MAKECMV;
4264                }
4265                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4266#ifdef AMAZON_MEI_DEBUG_ON
4267                    printk("\n\nCMV fail, Group INFO Address 68 Index 3");
4268#endif
4269                    pts.adslLineInfo_pt->adslSNRMds = 0;
4270                }
4271                else{
4272                    if (adsl_mode>8 || adsl_mode_extend>0)
4273                    {
4274                        int SNRMds,SNRMds_remain;
4275                        SNRMds=RxMessage[4];
4276                        SNRMds_remain=((SNRMds&0xff)*1000)/256;
4277                        SNRMds=(SNRMds>>8)&0xff;
4278                        if ((SNRMds_remain%100)>=50) SNRMds_remain=(SNRMds_remain/100)+1;
4279                        else SNRMds_remain=(SNRMds_remain/100);
4280                        pts.adslLineInfo_pt->adslSNRMds = SNRMds*10 + SNRMds_remain;
4281                    }else
4282                    {
4283                        pts.adslLineInfo_pt->adslSNRMds = RxMessage[4];
4284                    }
4285                }
4286            }
4287            
4288            if(IS_FLAG_SET((&(pts.adslLineInfo_pt->flags)), LINE_INFO_SNRMNUS_FLAG)){
4289                if (adsl_mode <=8 && adsl_mode_extend == 0)
4290                {
4291                    LINE_INFO_SNRMNUS_FLAG_MAKECMV;
4292                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4293#ifdef AMAZON_MEI_DEBUG_ON
4294                        printk("\n\nCMV fail, Group INFO Address 69 Index 3");
4295#endif
4296                        pts.adslLineInfo_pt->adslSNRMus = 0;
4297                    }
4298                    else{
4299                        pts.adslLineInfo_pt->adslSNRMus = RxMessage[4];
4300                    }
4301                }else
4302                {
4303                    hdlc_cmd[0]=0x0181;
4304                    hdlc_cmd[1]=0x23;
4305                    up(&mei_sema);
4306                    if (ifx_me_hdlc_send((unsigned char *)&hdlc_cmd[0],4)!= -EBUSY)
4307                    {
4308                        set_current_state(TASK_INTERRUPTIBLE);
4309                        schedule_timeout(1);
4310                        hdlc_rx_len=0;
4311                        hdlc_rx_len = ifx_mei_hdlc_read(&hdlc_rx_buffer,32*2);
4312                        if (hdlc_rx_len <=0)
4313                        {
4314                                    meierr = -ERESTARTSYS;
4315                                    goto GET_ADSL_LINE_INFO_END;
4316                                }
4317                        pts.adslLineInfo_pt->adslSNRMus = le16_to_cpu(hdlc_rx_buffer[1]);
4318                    }
4319                    if(down_interruptible(&mei_sema))
4320                            {
4321                                meierr = -ERESTARTSYS;
4322                                goto GET_ADSL_LINE_INFO_END;
4323                            }
4324                }
4325            }
4326            
4327            if(IS_FLAG_SET((&(pts.adslLineInfo_pt->flags)), LINE_INFO_ACATPDS_FLAG)){
4328                if (adsl_mode <=8 && adsl_mode_extend == 0)
4329                {
4330                    LINE_INFO_ACATPDS_FLAG_MAKECMV;
4331                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4332    #ifdef AMAZON_MEI_DEBUG_ON
4333                        printk("\n\nCMV fail, Group INFO Address 68 Index 6");
4334    #endif
4335                        pts.adslLineInfo_pt->adslACATPds = 0;
4336                    }
4337                    else{
4338                        pts.adslLineInfo_pt->adslACATPds = RxMessage[4];
4339                    }
4340                }else
4341                {
4342                    hdlc_cmd[0]=0x0181;
4343                    hdlc_cmd[1]=0x25;
4344                    up(&mei_sema);
4345                    if (ifx_me_hdlc_send((unsigned char *)&hdlc_cmd[0],4)!= -EBUSY)
4346                    {
4347                        set_current_state(TASK_INTERRUPTIBLE);
4348                        schedule_timeout(1);
4349                        hdlc_rx_len=0;
4350                        hdlc_rx_len = ifx_mei_hdlc_read(&hdlc_rx_buffer,32*2);
4351                        if (hdlc_rx_len <=0)
4352                        {
4353                                    meierr = -ERESTARTSYS;
4354                                    goto GET_ADSL_LINE_INFO_END;
4355                                }
4356                        pts.adslLineInfo_pt->adslACATPds = le16_to_cpu(hdlc_rx_buffer[1]);
4357                    }
4358                    if(down_interruptible(&mei_sema))
4359                    {
4360                                meierr = -ERESTARTSYS;
4361                                goto GET_ADSL_LINE_INFO_END;
4362                            }
4363                }
4364            }
4365            
4366            if(IS_FLAG_SET((&(pts.adslLineInfo_pt->flags)), LINE_INFO_ACATPUS_FLAG)){
4367                if (adsl_mode <=8 && adsl_mode_extend == 0)
4368                {
4369                    LINE_INFO_ACATPUS_FLAG_MAKECMV;
4370                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4371#ifdef AMAZON_MEI_DEBUG_ON
4372                        printk("\n\nCMV fail, Group INFO Address 69 Index 6");
4373#endif
4374                        pts.adslLineInfo_pt->adslACATPus = 0;
4375                    }
4376                    else{
4377                        pts.adslLineInfo_pt->adslACATPus = RxMessage[4];
4378                    }
4379                }else
4380                {
4381                    hdlc_cmd[0]=0x0181;
4382                    hdlc_cmd[1]=0x26;
4383                    up(&mei_sema);
4384                    if (ifx_me_hdlc_send((unsigned char *)&hdlc_cmd[0],4)!= -EBUSY)
4385                    {
4386                        set_current_state(TASK_INTERRUPTIBLE);
4387                        schedule_timeout(1);
4388                        hdlc_rx_len=0;
4389                        hdlc_rx_len = ifx_mei_hdlc_read(&hdlc_rx_buffer,32*2);
4390                        if (hdlc_rx_len <=0)
4391                        {
4392                                    meierr = -ERESTARTSYS;
4393                                    goto GET_ADSL_LINE_INFO_END;
4394                                }
4395                        pts.adslLineInfo_pt->adslACATPus = le16_to_cpu(hdlc_rx_buffer[1]);
4396                    }
4397                    if(down_interruptible(&mei_sema))
4398                    {
4399                                meierr = -ERESTARTSYS;
4400                                goto GET_ADSL_LINE_INFO_END;
4401                            }
4402                }
4403            }
4404            
4405            copy_to_user((char *)lon, (char *)pts.adslLineInfo_pt, sizeof(adslLineInfo));
4406            up(&mei_sema);
4407
4408GET_ADSL_LINE_INFO_END:
4409            kfree(pts.adslLineInfo_pt);
4410            break;
4411
4412        case GET_ADSL_NEAREND_STATS:
4413            if (showtime!=1)
4414                return -ERESTARTSYS;
4415            if(down_interruptible(&mei_sema))
4416                        return -ERESTARTSYS;
4417            
4418            pts.adslNearEndPerfStats_pt = (adslNearEndPerfStats *)kmalloc(sizeof(adslNearEndPerfStats), GFP_KERNEL);
4419            copy_from_user((char *)pts.adslNearEndPerfStats_pt, (char *)lon, sizeof(adslNearEndPerfStats));
4420            
4421            if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_SUPERFRAME_FLAG)){
4422                NEAREND_PERF_SUPERFRAME_FLAG_LSW_MAKECMV;
4423                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4424#ifdef AMAZON_MEI_DEBUG_ON
4425                    printk("\n\nCMV fail, Group PLAM Address 20 Index 0");
4426#endif
4427                    pts.adslNearEndPerfStats_pt->adslSuperFrames = 0;
4428                }
4429                else{
4430                    pts.adslNearEndPerfStats_pt->adslSuperFrames = (u32)(RxMessage[4]);
4431                }
4432                NEAREND_PERF_SUPERFRAME_FLAG_MSW_MAKECMV;
4433                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4434#ifdef AMAZON_MEI_DEBUG_ON
4435                    printk("\n\nCMV fail, Group PLAM Address 21 Index 0");
4436#endif
4437                    pts.adslNearEndPerfStats_pt->adslSuperFrames = 0;
4438                }
4439                else{
4440                    pts.adslNearEndPerfStats_pt->adslSuperFrames += (((u32)(RxMessage[4]))<<16);
4441                }
4442            }
4443            
4444            if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_LOS_FLAG) ||
4445               IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_LOF_FLAG) ||
4446               IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_LPR_FLAG) ||
4447               IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_NCD_FLAG) ||
4448               IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_LCD_FLAG) ){
4449                NEAREND_PERF_LOS_FLAG_MAKECMV;
4450                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4451#ifdef AMAZON_MEI_DEBUG_ON
4452                    printk("\n\nCMV fail, Group PLAM Address 0 Index 0");
4453#endif
4454                    RxMessage[4] = 0;
4455                }
4456                if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_LOS_FLAG)){
4457                    if( (RxMessage[4]&0x1) == 0x1)
4458                        pts.adslNearEndPerfStats_pt->adslneLOS = 1;
4459                    else
4460                        pts.adslNearEndPerfStats_pt->adslneLOS = 0;
4461                }
4462                
4463                if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_LOF_FLAG)){
4464                    if( (RxMessage[4]&0x2) == 0x2)
4465                        pts.adslNearEndPerfStats_pt->adslneLOF = 1;
4466                    else
4467                        pts.adslNearEndPerfStats_pt->adslneLOF = 0;
4468                }
4469                
4470                if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_LPR_FLAG)){
4471                    if( (RxMessage[4]&0x4) == 0x4)
4472                        pts.adslNearEndPerfStats_pt->adslneLPR = 1;
4473                    else
4474                        pts.adslNearEndPerfStats_pt->adslneLPR = 0;
4475                }
4476                
4477                if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_NCD_FLAG)){
4478                    pts.adslNearEndPerfStats_pt->adslneNCD = (RxMessage[4]>>4)&0x3;
4479                }
4480                
4481                if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_LCD_FLAG)){
4482                    pts.adslNearEndPerfStats_pt->adslneLCD = (RxMessage[4]>>6)&0x3;
4483                }
4484            }
4485                        
4486            if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_CRC_FLAG)){
4487                if (chantype.interleave)
4488                    NEAREND_PERF_CRC_FLAG_LP0_MAKECMV;
4489                else
4490                    NEAREND_PERF_CRC_FLAG_LP1_MAKECMV;
4491                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4492#ifdef AMAZON_MEI_DEBUG_ON
4493                    printk("\n\nCMV fail, Group PLAM Address 2 Index 0");
4494#endif
4495                    pts.adslNearEndPerfStats_pt->adslneCRC = 0;
4496                }
4497                else{
4498                    pts.adslNearEndPerfStats_pt->adslneCRC = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
4499                }
4500            }
4501            
4502            if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_RSCORR_FLAG)){
4503                if (chantype.interleave)
4504                    NEAREND_PERF_RSCORR_FLAG_LP0_MAKECMV;
4505                else
4506                    NEAREND_PERF_RSCORR_FLAG_LP1_MAKECMV;
4507                    
4508                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4509#ifdef AMAZON_MEI_DEBUG_ON
4510                    printk("\n\nCMV fail, Group PLAM Address 3 Index 0");
4511#endif
4512                    pts.adslNearEndPerfStats_pt->adslneRSCorr = 0;
4513                }
4514                else{
4515                    pts.adslNearEndPerfStats_pt->adslneRSCorr = RxMessage[4];
4516                }
4517            }
4518            
4519            if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_FECS_FLAG)){
4520                NEAREND_PERF_FECS_FLAG_MAKECMV;
4521                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4522#ifdef AMAZON_MEI_DEBUG_ON
4523                    printk("\n\nCMV fail, Group PLAM Address 6 Index 0");
4524#endif
4525                    pts.adslNearEndPerfStats_pt->adslneFECS = 0;
4526                }
4527                else{
4528                    pts.adslNearEndPerfStats_pt->adslneFECS = RxMessage[4];
4529                }
4530            }
4531            
4532            if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_ES_FLAG)){
4533                NEAREND_PERF_ES_FLAG_MAKECMV;
4534                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4535#ifdef AMAZON_MEI_DEBUG_ON
4536                    printk("\n\nCMV fail, Group PLAM Address 7 Index 0");
4537#endif
4538                    pts.adslNearEndPerfStats_pt->adslneES = 0;
4539                }
4540                else{
4541                    pts.adslNearEndPerfStats_pt->adslneES = RxMessage[4];
4542                }
4543            }
4544            
4545            if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_SES_FLAG)){
4546                NEAREND_PERF_SES_FLAG_MAKECMV;
4547                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4548#ifdef AMAZON_MEI_DEBUG_ON
4549                    printk("\n\nCMV fail, Group PLAM Address 8 Index 0");
4550#endif
4551                    pts.adslNearEndPerfStats_pt->adslneSES = 0;
4552                }
4553                else{
4554                    pts.adslNearEndPerfStats_pt->adslneSES = RxMessage[4];
4555                }
4556            }
4557            
4558            if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_LOSS_FLAG)){
4559                NEAREND_PERF_LOSS_FLAG_MAKECMV;
4560                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4561#ifdef AMAZON_MEI_DEBUG_ON
4562                    printk("\n\nCMV fail, Group PLAM Address 9 Index 0");
4563#endif
4564                    pts.adslNearEndPerfStats_pt->adslneLOSS = 0;
4565                }
4566                else{
4567                    pts.adslNearEndPerfStats_pt->adslneLOSS = RxMessage[4];
4568                }
4569            }
4570            
4571            if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_UAS_FLAG)){
4572                NEAREND_PERF_UAS_FLAG_MAKECMV;
4573                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4574#ifdef AMAZON_MEI_DEBUG_ON
4575                    printk("\n\nCMV fail, Group PLAM Address 10 Index 0");
4576#endif
4577                    pts.adslNearEndPerfStats_pt->adslneUAS = 0;
4578                }
4579                else{
4580                    pts.adslNearEndPerfStats_pt->adslneUAS = RxMessage[4];
4581                }
4582            }
4583            
4584            if(IS_FLAG_SET((&(pts.adslNearEndPerfStats_pt->flags)), NEAREND_PERF_HECERR_FLAG)){
4585                if (chantype.bearchannel0)
4586                {
4587                    NEAREND_PERF_HECERR_FLAG_BC0_MAKECMV;
4588                }else if (chantype.bearchannel1)
4589                {
4590                    NEAREND_PERF_HECERR_FLAG_BC1_MAKECMV;
4591                }
4592                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4593#ifdef AMAZON_MEI_DEBUG_ON
4594                    printk("\n\nCMV fail, Group PLAM Address 11 Index 0");
4595#endif
4596                    pts.adslNearEndPerfStats_pt->adslneHECErrors = 0;
4597                }
4598                else{
4599                    pts.adslNearEndPerfStats_pt->adslneHECErrors = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
4600                }
4601            }
4602            
4603            copy_to_user((char *)lon, (char *)pts.adslNearEndPerfStats_pt, sizeof(adslNearEndPerfStats));
4604            kfree(pts.adslNearEndPerfStats_pt);
4605            
4606            up(&mei_sema);
4607            break;
4608
4609        case GET_ADSL_FAREND_STATS:
4610
4611                    if (showtime!=1)
4612                        return -ERESTARTSYS;
4613            
4614            if (adsl_mode>8 || adsl_mode_extend > 0)
4615            {
4616                do_gettimeofday(&time_now);
4617                if( FarendData_acquire_time.tv_sec==0 || time_now.tv_sec - FarendData_acquire_time.tv_sec>=1)
4618                {
4619                    hdlc_cmd[0]=0x105;
4620                    
4621                    if (ifx_me_hdlc_send((unsigned char *)&hdlc_cmd[0],2)!= -EBUSY)
4622                    {
4623                        set_current_state(TASK_INTERRUPTIBLE);
4624                        schedule_timeout(1);
4625                        hdlc_rx_len=0;
4626                        hdlc_rx_len = ifx_mei_hdlc_read(&hdlc_rx_buffer,32*2);
4627                        if (hdlc_rx_len <=0)
4628                        {
4629                            return -ERESTARTSYS;
4630                        }
4631                        FarendStatsData.adslfeRSCorr = ((u32)le16_to_cpu(hdlc_rx_buffer[1]) << 16) + (u32)le16_to_cpu(hdlc_rx_buffer[2]);
4632                        FarendStatsData.adslfeCRC = ((u32)le16_to_cpu(hdlc_rx_buffer[3]) << 16) + (u32)le16_to_cpu(hdlc_rx_buffer[4]);
4633                        FarendStatsData.adslfeFECS = ((u32)le16_to_cpu(hdlc_rx_buffer[5]) << 16) + (u32)le16_to_cpu(hdlc_rx_buffer[6]);
4634                        FarendStatsData.adslfeES = ((u32)le16_to_cpu(hdlc_rx_buffer[7]) << 16) + (u32)le16_to_cpu(hdlc_rx_buffer[8]);
4635                        FarendStatsData.adslfeSES = ((u32)le16_to_cpu(hdlc_rx_buffer[9]) << 16) + (u32)le16_to_cpu(hdlc_rx_buffer[10]);
4636                        FarendStatsData.adslfeLOSS = ((u32)le16_to_cpu(hdlc_rx_buffer[11]) << 16) + (u32)le16_to_cpu(hdlc_rx_buffer[12]);
4637                        FarendStatsData.adslfeUAS = ((u32)le16_to_cpu(hdlc_rx_buffer[13]) << 16) + (u32)le16_to_cpu(hdlc_rx_buffer[14]);
4638                        do_gettimeofday(&FarendData_acquire_time);
4639                    }
4640                    
4641                }
4642            }
4643            
4644            if(down_interruptible(&mei_sema))
4645                        return -ERESTARTSYS;
4646                    pts.adslFarEndPerfStats_pt = (adslFarEndPerfStats *)kmalloc(sizeof(adslFarEndPerfStats), GFP_KERNEL);
4647            copy_from_user((char *)pts.adslFarEndPerfStats_pt, (char *)lon, sizeof(adslFarEndPerfStats));
4648            if(IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_LOS_FLAG) ||
4649               IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_LOF_FLAG) ||
4650               IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_LPR_FLAG) ||
4651               IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_NCD_FLAG) ||
4652               IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_LCD_FLAG) ){
4653                FAREND_PERF_LOS_FLAG_MAKECMV;
4654                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4655#ifdef AMAZON_MEI_DEBUG_ON
4656                    printk("\n\nCMV fail, Group PLAM Address 1 Index 0");
4657#endif
4658                    RxMessage[4] = 0;
4659                }
4660                if(IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_LOS_FLAG)){
4661                    if((RxMessage[4]&0x1) == 0x1)
4662                        pts.adslFarEndPerfStats_pt->adslfeLOS = 1;
4663                    else
4664                        pts.adslFarEndPerfStats_pt->adslfeLOS = 0;
4665                }
4666                
4667                if(IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_LOF_FLAG)){
4668                    if((RxMessage[4]&0x2) == 0x2)
4669                        pts.adslFarEndPerfStats_pt->adslfeLOF = 1;
4670                    else
4671                        pts.adslFarEndPerfStats_pt->adslfeLOF = 0;
4672                }
4673                
4674                if(IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_LPR_FLAG)){
4675                    if((RxMessage[4]&0x4) == 0x4)
4676                        pts.adslFarEndPerfStats_pt->adslfeLPR = 1;
4677                    else
4678                        pts.adslFarEndPerfStats_pt->adslfeLPR = 0;
4679                }
4680                
4681                if(IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_NCD_FLAG)){
4682                    pts.adslFarEndPerfStats_pt->adslfeNCD = (RxMessage[4]>>4)&0x3;
4683                }
4684                
4685                if(IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_LCD_FLAG)){
4686                    pts.adslFarEndPerfStats_pt->adslfeLCD = (RxMessage[4]>>6)&0x3;
4687                }
4688            }
4689                        
4690            if(IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_CRC_FLAG)){
4691                if (adsl_mode<=8 && adsl_mode_extend == 0)
4692                {
4693                    if (chantype.interleave)
4694                    {
4695                        FAREND_PERF_CRC_FLAG_LP0_MAKECMV;
4696                    }
4697                    else
4698                    {
4699                        FAREND_PERF_CRC_FLAG_LP1_MAKECMV;
4700                    }
4701                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4702#ifdef AMAZON_MEI_DEBUG_ON
4703                        printk("\n\nCMV fail, Group PLAM Address 24 Index 0");
4704#endif
4705                        pts.adslFarEndPerfStats_pt->adslfeCRC = 0;
4706                    }
4707                    else{
4708                        pts.adslFarEndPerfStats_pt->adslfeCRC = RxMessage[4];
4709                    }
4710                }else
4711                {
4712                    pts.adslFarEndPerfStats_pt->adslfeCRC = FarendStatsData.adslfeCRC;
4713                }
4714            }
4715            
4716            if(IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_RSCORR_FLAG)){
4717                if (adsl_mode<=8 && adsl_mode_extend == 0)
4718                {
4719                    if (chantype.interleave)
4720                        FAREND_PERF_RSCORR_FLAG_LP0_MAKECMV;
4721                    else
4722                        FAREND_PERF_RSCORR_FLAG_LP1_MAKECMV;
4723                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4724#ifdef AMAZON_MEI_DEBUG_ON
4725                        printk("\n\nCMV fail, Group PLAM Address 28 Index 0");
4726#endif
4727                        pts.adslFarEndPerfStats_pt->adslfeRSCorr = 0;
4728                    }
4729                    else{
4730                        pts.adslFarEndPerfStats_pt->adslfeRSCorr = RxMessage[4];
4731                        
4732                    }
4733                }
4734                else
4735                {
4736                    pts.adslFarEndPerfStats_pt->adslfeRSCorr = FarendStatsData.adslfeRSCorr;
4737                }
4738            }
4739            
4740            if(IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_FECS_FLAG)){
4741                if (adsl_mode<=8 && adsl_mode_extend == 0)
4742                {
4743                    FAREND_PERF_FECS_FLAG_MAKECMV;
4744                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4745#ifdef AMAZON_MEI_DEBUG_ON
4746                        printk("\n\nCMV fail, Group PLAM Address 32 Index 0");
4747#endif
4748                        pts.adslFarEndPerfStats_pt->adslfeFECS = 0;
4749                    }
4750                    else{
4751                        pts.adslFarEndPerfStats_pt->adslfeFECS = RxMessage[4];
4752                    }
4753                }else {
4754                    pts.adslFarEndPerfStats_pt->adslfeFECS = FarendStatsData.adslfeFECS;
4755                }
4756            }
4757            
4758            if(IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_ES_FLAG)){
4759                if (adsl_mode<=8 && adsl_mode_extend == 0)
4760                {
4761                    FAREND_PERF_ES_FLAG_MAKECMV;
4762                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4763#ifdef AMAZON_MEI_DEBUG_ON
4764                        printk("\n\nCMV fail, Group PLAM Address 33 Index 0");
4765#endif
4766                        pts.adslFarEndPerfStats_pt->adslfeES = 0;
4767                    }
4768                    else{
4769                        pts.adslFarEndPerfStats_pt->adslfeES = RxMessage[4];
4770                    }
4771                }else
4772                {
4773                    pts.adslFarEndPerfStats_pt->adslfeES = FarendStatsData.adslfeES;
4774                }
4775            }
4776            
4777            if(IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_SES_FLAG)){
4778                if (adsl_mode<=8 && adsl_mode_extend == 0)
4779                {
4780                    FAREND_PERF_SES_FLAG_MAKECMV;
4781                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4782#ifdef AMAZON_MEI_DEBUG_ON
4783                        printk("\n\nCMV fail, Group PLAM Address 34 Index 0");
4784#endif
4785                        pts.adslFarEndPerfStats_pt->adslfeSES = 0;
4786                    }
4787                    else{
4788                        pts.adslFarEndPerfStats_pt->adslfeSES = RxMessage[4];
4789                        
4790                    }
4791                }else
4792                {
4793                    pts.adslFarEndPerfStats_pt->adslfeSES = FarendStatsData.adslfeSES;
4794                }
4795            }
4796            
4797            if(IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_LOSS_FLAG)){
4798                if (adsl_mode<=8 && adsl_mode_extend == 0)
4799                {
4800                    FAREND_PERF_LOSS_FLAG_MAKECMV;
4801                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4802#ifdef AMAZON_MEI_DEBUG_ON
4803                        printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
4804#endif
4805                        pts.adslFarEndPerfStats_pt->adslfeLOSS = 0;
4806                    }
4807                    else{
4808                        pts.adslFarEndPerfStats_pt->adslfeLOSS = RxMessage[4];
4809                        
4810                    }
4811                }else
4812                {
4813                    pts.adslFarEndPerfStats_pt->adslfeLOSS = FarendStatsData.adslfeLOSS;
4814                }
4815            }
4816            
4817            if(IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_UAS_FLAG)){
4818                if (adsl_mode<=8 && adsl_mode_extend == 0)
4819                {
4820                    FAREND_PERF_UAS_FLAG_MAKECMV;
4821                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4822#ifdef AMAZON_MEI_DEBUG_ON
4823                        printk("\n\nCMV fail, Group PLAM Address 36 Index 0");
4824#endif
4825                        pts.adslFarEndPerfStats_pt->adslfeUAS = 0;
4826                    }
4827                    else{
4828                        pts.adslFarEndPerfStats_pt->adslfeUAS = RxMessage[4];
4829                        
4830                    }
4831                }else
4832                {
4833                    pts.adslFarEndPerfStats_pt->adslfeUAS = FarendStatsData.adslfeUAS;
4834                }
4835            }
4836            
4837            if(IS_FLAG_SET((&(pts.adslFarEndPerfStats_pt->flags)), FAREND_PERF_HECERR_FLAG)){
4838                if (chantype.bearchannel0)
4839                {
4840                    FAREND_PERF_HECERR_FLAG_BC0_MAKECMV;
4841                }else if (chantype.bearchannel1)
4842                {
4843                    FAREND_PERF_HECERR_FLAG_BC1_MAKECMV;
4844                }
4845                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4846#ifdef AMAZON_MEI_DEBUG_ON
4847                    printk("\n\nCMV fail, Group PLAM Address 37 Index 0");
4848#endif
4849                    pts.adslFarEndPerfStats_pt->adslfeHECErrors = 0;
4850                }
4851                else{
4852                    pts.adslFarEndPerfStats_pt->adslfeHECErrors = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
4853                }
4854            }
4855            
4856            copy_to_user((char *)lon, (char *)pts.adslFarEndPerfStats_pt, sizeof(adslFarEndPerfStats));
4857            kfree(pts.adslFarEndPerfStats_pt);
4858            
4859            up(&mei_sema);
4860            
4861            break;
4862// 603221:tc.chen end
4863        case GET_ADSL_LOOP_DIAGNOSTICS_MODE:
4864            //lon = loop_diagnostics_mode;
4865            copy_to_user((char *)lon, (char *)&loop_diagnostics_mode, sizeof(int));
4866            break;
4867//>> SHC
4868        case IS_ADSL_LOOP_DIAGNOSTICS_MODE_COMPLETE:
4869            copy_to_user((char *)lon, (char *)&loop_diagnostics_completed, sizeof(int));
4870            break;
4871            
4872//<< end SHC
4873        case LOOP_DIAGNOSTIC_MODE_COMPLETE:
4874            loop_diagnostics_completed = 1;
4875            // read adsl mode
4876            makeCMV(H2D_CMV_READ, STAT, 1, 0, 1, data);
4877            if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4878#ifdef AMAZON_MEI_DEBUG_ON
4879                printk("\n\nCMV fail, Group STAT Address 1 Index 0");
4880#endif
4881            }
4882            adsl_mode = RxMessage[4];
4883
4884            makeCMV(H2D_CMV_READ, STAT, 17, 0, 1, data);
4885            if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4886#ifdef AMAZON_MEI_DEBUG_ON
4887                printk("\n\nCMV fail, Group STAT Address 1 Index 0");
4888#endif
4889            }
4890            adsl_mode_extend = RxMessage[4];
4891            wake_up_interruptible(&wait_queue_loop_diagnostic);
4892            break;
4893        case SET_ADSL_LOOP_DIAGNOSTICS_MODE:
4894            if (lon != loop_diagnostics_mode)
4895            {
4896                loop_diagnostics_completed = 0;
4897                loop_diagnostics_mode = lon;
4898
4899                mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_REBOOT, NULL);
4900                
4901            }
4902            break;
4903        case GET_ADSL_ATUR_SUBCARRIER_STATS:
4904            if (loop_diagnostics_completed == 0)
4905            {
4906                interruptible_sleep_on_timeout(&wait_queue_loop_diagnostic,300*HZ);
4907                if (loop_diagnostics_completed==0)
4908                {
4909                    return -ERESTARTSYS;
4910                }
4911            }
4912            if(down_interruptible(&mei_sema))
4913                        return -ERESTARTSYS;
4914                        
4915                    pts.adslATURSubcarrierInfo_pt = (adslATURSubcarrierInfo *)kmalloc(sizeof(adslATURSubcarrierInfo), GFP_KERNEL);
4916            copy_from_user((char *)pts.adslATURSubcarrierInfo_pt, (char *)lon, sizeof(adslATURSubcarrierInfo));
4917            
4918            if(IS_FLAG_SET((&(pts.adslATURSubcarrierInfo_pt->flags)), FAREND_HLINSC)){
4919                FAREND_HLINSC_MAKECMV(H2D_CMV_READ);
4920                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4921#ifdef AMAZON_MEI_DEBUG_ON
4922                    printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
4923#endif
4924                    pts.adslATURSubcarrierInfo_pt->HLINSCds = 0;
4925                }
4926                else{
4927                    pts.adslATURSubcarrierInfo_pt->HLINSCds = RxMessage[4];
4928                    
4929                }
4930            }
4931            if(IS_FLAG_SET((&(pts.adslATURSubcarrierInfo_pt->flags)), FAREND_HLINPS)){
4932                int index=0,size=12;
4933                //printk("FAREND_HLINPS\n");
4934                for (index=0;index<1024;index+=size)
4935                {
4936                    if (index+size>=1024)
4937                        size = 1024-index;
4938                    FAREND_HLINPS_MAKECMV(H2D_CMV_READ,index,size);
4939                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4940#ifdef AMAZON_MEI_DEBUG_ON
4941                        printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
4942#endif
4943                    }
4944                    else{
4945                        memcpy(&pts.adslATURSubcarrierInfo_pt->HLINpsds[index],&RxMessage[4],size*2);
4946#if 0
4947                        int msg_idx;
4948                        for(msg_idx=0;msg_idx<size;msg_idx++)
4949                            printk("index:%d ,cmv_result: %04X\n",index+msg_idx,RxMessage[4+msg_idx]);
4950#endif
4951                    }
4952                }
4953            }
4954            
4955            if(IS_FLAG_SET((&(pts.adslATURSubcarrierInfo_pt->flags)), FAREND_HLOGMT)){
4956                FAREND_HLOGMT_MAKECMV(H2D_CMV_READ);
4957                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4958#ifdef AMAZON_MEI_DEBUG_ON
4959                    printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
4960#endif
4961                    pts.adslATURSubcarrierInfo_pt->HLOGMTds = 0;
4962                }
4963                else{
4964                    pts.adslATURSubcarrierInfo_pt->HLOGMTds = RxMessage[4];
4965                    
4966                }
4967            }
4968            
4969            /////////////////////////////////////////////////////////////////////////
4970            if(IS_FLAG_SET((&(pts.adslATURSubcarrierInfo_pt->flags)), FAREND_HLOGPS)){
4971                //printk("FAREND_HLOGPS\n");
4972                int index=0,size=12;
4973                for (index=0;index<256;index+=size)
4974                {
4975                    if (index+size>=256)
4976                        size = 256-index;
4977
4978                    FAREND_HLOGPS_MAKECMV(H2D_CMV_READ,index,size);
4979                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
4980#ifdef AMAZON_MEI_DEBUG_ON
4981                        printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
4982#endif
4983                    }
4984                    else{
4985                        if (adsl_mode < 0x4000 && adsl_mode_extend==0)//adsl2 mode
4986                        {
4987                            memcpy(&pts.adslATURSubcarrierInfo_pt->HLOGpsds[index],&RxMessage[4],size*2);
4988                        }else
4989                        {
4990                            int msg_idx=0;
4991                            for (msg_idx=0;msg_idx<size;msg_idx++)
4992                            {
4993                                pts.adslATURSubcarrierInfo_pt->HLOGpsds[(index+msg_idx)*2+1] = RxMessage[4+msg_idx];
4994                                //printk("index:%d ,cmv_result: %04X\n",index+msg_idx,RxMessage[4+msg_idx]);
4995                            }
4996                        }
4997                    }
4998                }
4999                if (adsl_mode >= 0x4000 || adsl_mode_extend >0)//adsl2+ mode
5000                {
5001                    pts.adslATURSubcarrierInfo_pt->HLOGpsds[0] = pts.adslATURSubcarrierInfo_pt->HLOGpsds[1];
5002                    for (index=1;index<256;index++)
5003                    {
5004                        pts.adslATURSubcarrierInfo_pt->HLOGpsds[index*2] = (pts.adslATURSubcarrierInfo_pt->HLOGpsds[(index)*2-1] + pts.adslATURSubcarrierInfo_pt->HLOGpsds[(index)*2+1] +1) >>1;
5005                    }
5006                }
5007            }
5008            if(IS_FLAG_SET((&(pts.adslATURSubcarrierInfo_pt->flags)), FAREND_QLNMT)){
5009                FAREND_QLNMT_MAKECMV(H2D_CMV_READ);
5010                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5011#ifdef AMAZON_MEI_DEBUG_ON
5012                    printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
5013#endif
5014                    pts.adslATURSubcarrierInfo_pt->QLNMTds = 0;
5015                }
5016                else{
5017                    pts.adslATURSubcarrierInfo_pt->QLNMTds = RxMessage[4];
5018                }
5019            }
5020            
5021            /////////////////////////////////////////////////////////////////////////
5022            if(IS_FLAG_SET((&(pts.adslATURSubcarrierInfo_pt->flags)), FAREND_QLNPS)){
5023                int index=0,size=12;
5024                //printk("FAREND_QLNPS\n");
5025                for (index=0;index<128;index+=size)
5026                {
5027                    if (index+size>=128)
5028                        size = 128-index;
5029                    FAREND_QLNPS_MAKECMV(H2D_CMV_READ,index,size);
5030                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5031#ifdef AMAZON_MEI_DEBUG_ON
5032                        printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
5033#endif
5034                    }
5035                    else{
5036                        int msg_idx=0;
5037                        for (msg_idx=0;msg_idx<size;msg_idx++)
5038                        {
5039                            //memcpy(&pts.adslATURSubcarrierInfo_pt->QLNpsds[index],&RxMessage[4],size*2);
5040                            if (adsl_mode < 0x4000 && adsl_mode_extend==0)//adsl2 mode
5041                            {
5042                                pts.adslATURSubcarrierInfo_pt->QLNpsds[(index+msg_idx)*2] = (u16)(RxMessage[4+msg_idx]&0xFF);
5043                                pts.adslATURSubcarrierInfo_pt->QLNpsds[(index+msg_idx)*2+1] = (u16)((RxMessage[4+msg_idx]>>8)&0xFF);
5044                            }else
5045                            {
5046                                pts.adslATURSubcarrierInfo_pt->QLNpsds[(index+msg_idx)*4+1] = (u16)(RxMessage[4+msg_idx]&0xFF);
5047                                pts.adslATURSubcarrierInfo_pt->QLNpsds[(index+msg_idx)*4+3] = (u16)((RxMessage[4+msg_idx]>>8)&0xFF);
5048                                //printk("index:%d ,cmv_result: %04X\n",index+msg_idx,RxMessage[4+msg_idx]);
5049                            }
5050                        }
5051
5052                        
5053                    }
5054                }
5055                if (adsl_mode >= 0x4000 || adsl_mode_extend >0)//adsl2+ mode
5056                {
5057                    pts.adslATURSubcarrierInfo_pt->QLNpsds[0] = pts.adslATURSubcarrierInfo_pt->QLNpsds[1];
5058                    for (index=1;index<256;index++)
5059                    {
5060                        pts.adslATURSubcarrierInfo_pt->QLNpsds[index*2] = (pts.adslATURSubcarrierInfo_pt->QLNpsds[(index)*2-1] + pts.adslATURSubcarrierInfo_pt->QLNpsds[(index)*2+1]) >>1;
5061                    }
5062                }
5063            }
5064            if(IS_FLAG_SET((&(pts.adslATURSubcarrierInfo_pt->flags)), FAREND_SNRMT)){
5065                FAREND_SNRMT_MAKECMV(H2D_CMV_READ);
5066                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5067#ifdef AMAZON_MEI_DEBUG_ON
5068                    printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
5069#endif
5070                    pts.adslATURSubcarrierInfo_pt->SNRMTds = 0;
5071                }
5072                else{
5073                    pts.adslATURSubcarrierInfo_pt->SNRMTds = RxMessage[4];
5074                }
5075            }
5076            if(IS_FLAG_SET((&(pts.adslATURSubcarrierInfo_pt->flags)), FAREND_SNRPS)){
5077                int index=0,size=12;
5078                //printk("FAREND_SNRPS\n");
5079                for (index=0;index<512;index+=size)
5080                {
5081                    if (index+size>=512)
5082                        size = 512-index;
5083                    FAREND_SNRPS_MAKECMV(H2D_CMV_READ,index,size);
5084                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5085#ifdef AMAZON_MEI_DEBUG_ON
5086                        printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
5087#endif
5088                    }
5089                    else{
5090                        //memcpy(&pts.adslATURSubcarrierInfo_pt->SNRpsds[index],&RxMessage[4],size*2);
5091                        int msg_idx=0;
5092                        for (msg_idx=0;msg_idx<size;msg_idx++)
5093                        {
5094                            pts.adslATURSubcarrierInfo_pt->SNRpsds[index+msg_idx] = (u16)(RxMessage[4+msg_idx]&0xFF);
5095                            //printk("index:%d ,cmv_result: %04X\n",index+msg_idx,RxMessage[4+msg_idx]);
5096                        }
5097                        
5098                    }
5099                }
5100            }
5101            if(IS_FLAG_SET((&(pts.adslATURSubcarrierInfo_pt->flags)), FAREND_BITPS)){
5102                int index=0,size=12;
5103                //printk("FAREND_BITPS\n");
5104                for (index=0;index<256;index+=size)
5105                {
5106                    if (index+size>=256)
5107                        size = 256-index;
5108                    FAREND_BITPS_MAKECMV(H2D_CMV_READ,index,size);
5109                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5110#ifdef AMAZON_MEI_DEBUG_ON
5111                        printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
5112#endif
5113                    }
5114                    else{
5115                        int msg_idx=0;
5116                        for (msg_idx=0;msg_idx<size;msg_idx++)
5117                        {
5118                            pts.adslATURSubcarrierInfo_pt->BITpsds[(index+msg_idx)*2] = (u16)(RxMessage[4+msg_idx]&0xFF);
5119                            pts.adslATURSubcarrierInfo_pt->BITpsds[(index+msg_idx)*2+1] = (u16)((RxMessage[4+msg_idx]>>8)&0xFF);
5120                            //printk("index:%d ,cmv_result: %04X, %d\n",index+msg_idx,RxMessage[4+msg_idx],RxMessage[4+msg_idx]);
5121                            
5122                        }
5123                        
5124                    }
5125                }
5126            }
5127            if(IS_FLAG_SET((&(pts.adslATURSubcarrierInfo_pt->flags)), FAREND_GAINPS)){
5128                int index=0,size=12;
5129                //printk("FAREND_GAINPS\n");
5130                for (index=0;index<512;index+=size)
5131                {
5132                    FAREND_GAINPS_MAKECMV(H2D_CMV_READ,index,size);
5133                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5134#ifdef AMAZON_MEI_DEBUG_ON
5135                        printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
5136#endif
5137                    }
5138                    else{
5139                    /*
5140                        int msg_idx=0;
5141                        for (msg_idx=0;msg_idx<size;msg_idx++)
5142                        {
5143                            pts.adslATURSubcarrierInfo_pt->GAINpsds[(index+msg_idx)*2] = RxMessage[4+msg_idx]&0xFF;
5144                            pts.adslATURSubcarrierInfo_pt->GAINpsds[(index+msg_idx)*2+1] = (RxMessage[4+msg_idx]>>8)&0xFF;
5145                            
5146                        }
5147                        */
5148                        memcpy(&pts.adslATURSubcarrierInfo_pt->GAINpsds[index],&RxMessage[4],size*2);
5149#if 0
5150                        int msg_idx=0;
5151                        for (msg_idx=0;msg_idx<size;msg_idx++)
5152                        {
5153                            printk("index:%d ,cmv_result: %04X\n",index+msg_idx,RxMessage[4+msg_idx]);
5154                            
5155                        }
5156#endif
5157                    }
5158                }
5159            }
5160            copy_to_user((char *)lon, (char *)pts.adslATURSubcarrierInfo_pt, sizeof(adslATURSubcarrierInfo));
5161            kfree(pts.adslATURSubcarrierInfo_pt);
5162            
5163            up(&mei_sema);
5164            break;
5165        case GET_ADSL_ATUC_SUBCARRIER_STATS:
5166            if (loop_diagnostics_completed == 0)
5167            {
5168                interruptible_sleep_on_timeout(&wait_queue_loop_diagnostic,300*HZ);
5169                if (loop_diagnostics_completed==0)
5170                {
5171                    return -ERESTARTSYS;
5172                }
5173            }
5174            if(down_interruptible(&mei_sema))
5175                        return -ERESTARTSYS;
5176                    pts.adslATUCSubcarrierInfo_pt = (adslATUCSubcarrierInfo *)kmalloc(sizeof(adslATUCSubcarrierInfo), GFP_KERNEL);
5177            copy_from_user((char *)pts.adslATUCSubcarrierInfo_pt, (char *)lon, sizeof(adslATUCSubcarrierInfo));
5178            
5179            
5180            if(IS_FLAG_SET((&(pts.adslATUCSubcarrierInfo_pt->flags)), NEAREND_HLINSC)){
5181                NEAREND_HLINSC_MAKECMV(H2D_CMV_READ);
5182                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5183#ifdef AMAZON_MEI_DEBUG_ON
5184                    printk("\n\nCMV fail, Group INFO Address 71 Index 2");
5185#endif
5186                    pts.adslATUCSubcarrierInfo_pt->HLINSCus = 0;
5187                }
5188                else{
5189                    pts.adslATUCSubcarrierInfo_pt->HLINSCus = RxMessage[4];
5190                    
5191                }
5192            }
5193            if(IS_FLAG_SET((&(pts.adslATUCSubcarrierInfo_pt->flags)), NEAREND_HLINPS)){
5194                int index=0,size=12;
5195                //printk("NEAREND_HLINPS\n");
5196                for (index=0;index<128;index+=size)
5197                {
5198                    if (index+size>=128)
5199                        size = 128-index;
5200                    NEAREND_HLINPS_MAKECMV(H2D_CMV_READ,index,size);
5201                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5202#ifdef AMAZON_MEI_DEBUG_ON
5203                        printk("\n\nCMV fail, Group INFO Address 73 Index 0");
5204#endif
5205                    }
5206                    else{
5207                        memcpy(&pts.adslATUCSubcarrierInfo_pt->HLINpsus[index],&RxMessage[4],size*2);
5208#if 0
5209                        int msg_idx;
5210                        for (msg_idx=0;msg_idx<size;msg_idx++)
5211                        {
5212                            printk("index:%d ,cmv_result: %04X\n",index+msg_idx,RxMessage[4+msg_idx]);
5213                        }
5214#endif
5215                    }
5216                }
5217            }
5218            
5219            if(IS_FLAG_SET((&(pts.adslATUCSubcarrierInfo_pt->flags)), NEAREND_HLOGMT)){
5220                NEAREND_HLOGMT_MAKECMV(H2D_CMV_READ);
5221                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5222#ifdef AMAZON_MEI_DEBUG_ON
5223                    printk("\n\nCMV fail, Group INFO Address 80 Index 0");
5224#endif
5225                    pts.adslATUCSubcarrierInfo_pt->HLOGMTus = 0;
5226                }
5227                else{
5228                    pts.adslATUCSubcarrierInfo_pt->HLOGMTus = RxMessage[4];
5229                    
5230                }
5231            }
5232            
5233            /////////////////////////////////////////////////////////////////////////
5234            if(IS_FLAG_SET((&(pts.adslATUCSubcarrierInfo_pt->flags)), NEAREND_HLOGPS)){
5235                int index=0,size=12;
5236                //printk("NEAREND_HLOGPS\n");
5237                for (index=0;index<64;index+=size)
5238                {
5239                    if (index+size>=64)
5240                        size = 64-index;
5241                    NEAREND_HLOGPS_MAKECMV(H2D_CMV_READ,index,size);
5242                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5243#ifdef AMAZON_MEI_DEBUG_ON
5244                        printk("\n\nCMV fail, Group INFO Address 75 Index 0");
5245#endif
5246                    }
5247                    else{
5248#if 0
5249                        if (adsl_mode <0x4000)//adsl /adsl2 mode
5250                        {
5251#endif
5252                        memcpy(&pts.adslATUCSubcarrierInfo_pt->HLOGpsus[index],&RxMessage[4],size*2);
5253#if 0
5254                        }else
5255                        {
5256                            int msg_idx=0;
5257                            for (msg_idx=0;msg_idx<size;msg_idx++)
5258                            {
5259                                //pts.adslATUCSubcarrierInfo_pt->HLOGpsus[(index+msg_idx)*2+1] = RxMessage[4+msg_idx];
5260                                pts.adslATUCSubcarrierInfo_pt->HLOGpsus[(index+msg_idx)] = RxMessage[4+msg_idx];
5261                            }
5262                        }
5263#endif
5264                    }
5265                }
5266#if 0
5267                if (adsl_mode >= 0x4000)//adsl2 mode
5268                {
5269                    pts.adslATUCSubcarrierInfo_pt->HLOGpsus[0] = pts.adslATUCSubcarrierInfo_pt->HLOGpsus[1];
5270                    for (index=1;index<64;index++)
5271                    {
5272                        pts.adslATUCSubcarrierInfo_pt->HLOGpsus[index*2] = (pts.adslATUCSubcarrierInfo_pt->HLOGpsus[(index)*2-1] + pts.adslATUCSubcarrierInfo_pt->HLOGpsus[(index)*2+1]) >>1;
5273                    }
5274                }
5275#endif
5276            }
5277            if(IS_FLAG_SET((&(pts.adslATUCSubcarrierInfo_pt->flags)), NEAREND_QLNMT)){
5278                NEAREND_QLNMT_MAKECMV(H2D_CMV_READ);
5279                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5280#ifdef AMAZON_MEI_DEBUG_ON
5281                    printk("\n\nCMV fail, Group INFO Address 80 Index 1");
5282#endif
5283                    pts.adslATUCSubcarrierInfo_pt->QLNMTus = 0;
5284                }
5285                else{
5286                    pts.adslATUCSubcarrierInfo_pt->QLNMTus = RxMessage[4];
5287                }
5288            }
5289            
5290            /////////////////////////////////////////////////////////////////////////
5291            if(IS_FLAG_SET((&(pts.adslATUCSubcarrierInfo_pt->flags)), NEAREND_QLNPS)){
5292                int index=0,size=12;
5293                //printk("NEAREND_QLNPS\n");
5294                for (index=0;index<32;index+=size)
5295                {
5296                    if (index+size>=32)
5297                        size = 32-index;
5298                    NEAREND_QLNPS_MAKECMV(H2D_CMV_READ,index,size);
5299                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5300#ifdef AMAZON_MEI_DEBUG_ON
5301                        printk("\n\nCMV fail, Group INFO Address 77 Index 0");
5302#endif
5303                    }
5304                    else{
5305                        int msg_idx=0;
5306                        for (msg_idx=0;msg_idx<size;msg_idx++)
5307                        {
5308
5309#if 0
5310                            //memcpy(&pts.adslATUCSubcarrierInfo_pt->QLNpsds[index],&RxMessage[4],size*2);
5311                            if (adsl_mode == 0x200 || adsl_mode == 0x800 || adsl_mode ==0x2000 || adsl_mode ==0x4000 || (adsl_mode == 0 && (adsl_mode_extend == 0x4 || adsl_mode_extend == 0x2))//ADSL 2 Annex B(0x200)/J(0x800)/M(0x2000) //ADSL 2+ B,J,M
5312                            if (adsl_mode < 0x4000 && adsl_mode_extend==0)//adsl2 mode
5313                            {
5314                                pts.adslATUCSubcarrierInfo_pt->QLNpsus[(index+msg_idx)*4+1] = (u16)(RxMessage[4+msg_idx]&0xFF);
5315                                pts.adslATUCSubcarrierInfo_pt->QLNpsus[(index+msg_idx)*4+3] = (u16)((RxMessage[4+msg_idx]>>8)&0xFF);
5316                            }else
5317#endif
5318                            {
5319                                pts.adslATUCSubcarrierInfo_pt->QLNpsus[(index+msg_idx)*2] = (u16)(RxMessage[4+msg_idx]&0xFF);
5320                                pts.adslATUCSubcarrierInfo_pt->QLNpsus[(index+msg_idx)*2+1] = (u16)((RxMessage[4+msg_idx]>>8)&0xFF);
5321                            //printk("index:%d ,cmv_result: %04X\n",index+msg_idx,RxMessage[4+msg_idx]);
5322                            }
5323                        }
5324
5325                        
5326                    }
5327                }
5328#if 0
5329                //if (adsl_mode <0x4000)//Annex I/J/L/M
5330                if (adsl_mode == 0x200 || adsl_mode == 0x800 || adsl_mode ==0x2000 || adsl_mode ==0x4000 || (adsl_mode == 0 && (adsl_mode_extend == 0x4 || adsl_mode_extend == 0x2))//ADSL 2 Annex B(0x200)/J(0x800)/M(0x2000) //ADSL 2+ B,J,M
5331                {
5332                    pts.adslATUCSubcarrierInfo_pt->QLNpsus[0] = pts.adslATUCSubcarrierInfo_pt->QLNpsus[1];
5333                    for (index=1;index<64;index++)
5334                    {
5335                        pts.adslATUCSubcarrierInfo_pt->QLNpsus[index*2] = (pts.adslATUCSubcarrierInfo_pt->QLNpsus[(index)*2-1] + pts.adslATUCSubcarrierInfo_pt->QLNpsus[(index)*2+1]) >>1;
5336                    }
5337                }
5338#endif
5339            }
5340            if(IS_FLAG_SET((&(pts.adslATUCSubcarrierInfo_pt->flags)), NEAREND_SNRMT)){
5341                NEAREND_SNRMT_MAKECMV(H2D_CMV_READ);
5342                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5343#ifdef AMAZON_MEI_DEBUG_ON
5344                    printk("\n\nCMV fail, Group INFO Address 80 Index 2");
5345#endif
5346                    pts.adslATUCSubcarrierInfo_pt->SNRMTus = 0;
5347                }
5348                else{
5349                    pts.adslATUCSubcarrierInfo_pt->SNRMTus = RxMessage[4];
5350                }
5351            }
5352            if(IS_FLAG_SET((&(pts.adslATUCSubcarrierInfo_pt->flags)), NEAREND_SNRPS)){
5353                int index=0,size=12;
5354                //printk("NEAREND_SNRPS\n");
5355                for (index=0;index<64;index+=size)
5356                {
5357                    if (index+size>=64)
5358                        size = 64-index;
5359                    NEAREND_SNRPS_MAKECMV(H2D_CMV_READ,index,size);
5360                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5361#ifdef AMAZON_MEI_DEBUG_ON
5362                        printk("\n\nCMV fail, Group INFO Address 78 Index 0");
5363#endif
5364                    }
5365                    else{
5366                        //memcpy(&pts.adslATUCSubcarrierInfo_pt->SNRpsus[index],&RxMessage[4],size*2);
5367                        int msg_idx=0;
5368                        for (msg_idx=0;msg_idx<size;msg_idx++)
5369                        {
5370                            pts.adslATUCSubcarrierInfo_pt->SNRpsus[index+msg_idx] = (u16)(RxMessage[4+msg_idx]&0xFF);
5371                            //printk("index:%d ,cmv_result: %04X\n",index+msg_idx,RxMessage[4+msg_idx]);
5372                        }
5373                        
5374                    }
5375                }
5376            }
5377            if(IS_FLAG_SET((&(pts.adslATUCSubcarrierInfo_pt->flags)), NEAREND_BITPS)){
5378                int index=0,size=12;
5379                //printk("NEAREND_BITPS\n");
5380                for (index=0;index<32;index+=size)
5381                {
5382                    if (index+size>=32)
5383                        size = 32-index;
5384                    NEAREND_BITPS_MAKECMV(H2D_CMV_READ,index,size);
5385                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5386#ifdef AMAZON_MEI_DEBUG_ON
5387                        printk("\n\nCMV fail, Group INFO Address 22 Index 0");
5388#endif
5389                    }
5390                    else{
5391                        int msg_idx=0;
5392                        for (msg_idx=0;msg_idx<size;msg_idx++)
5393                        {
5394                            pts.adslATUCSubcarrierInfo_pt->BITpsus[(index+msg_idx)*2] = (u16)(RxMessage[4+msg_idx]&0xFF);
5395                            pts.adslATUCSubcarrierInfo_pt->BITpsus[(index+msg_idx)*2+1] = (u16)((RxMessage[4+msg_idx]>>8)&0xFF);
5396                            //printk("index:%d ,cmv_result: %04X\n",index+msg_idx,RxMessage[4+msg_idx]);
5397                        }
5398                        
5399                    }
5400                }
5401            }
5402            if(IS_FLAG_SET((&(pts.adslATUCSubcarrierInfo_pt->flags)), NEAREND_GAINPS)){
5403                int index=0,size=12;
5404                //printk("NEAREND_GAINPS\n");
5405                for (index=0;index<64;index+=size)
5406                {
5407                    if (index+size>=64)
5408                        size = 64-index;
5409                    NEAREND_GAINPS_MAKECMV(H2D_CMV_READ,index,size);
5410                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5411#ifdef AMAZON_MEI_DEBUG_ON
5412                        printk("\n\nCMV fail, Group INFO Address 24 Index 0");
5413#endif
5414                    }
5415                    else{
5416                    /*
5417                        int msg_idx=0;
5418                        for (msg_idx=0;msg_idx<size;msg_idx++)
5419                        {
5420                            pts.adslATUCSubcarrierInfo_pt->GAINpsds[(index+msg_idx)*2] = RxMessage[4+msg_idx]&0xFF;
5421                            pts.adslATUCSubcarrierInfo_pt->GAINpsds[(index+msg_idx)*2+1] = (RxMessage[4+msg_idx]>>8)&0xFF;
5422                            
5423                        }
5424                        */
5425                        memcpy(&pts.adslATUCSubcarrierInfo_pt->GAINpsus[index],&RxMessage[4],size*2);
5426#if 0
5427                        int msg_idx;
5428                        for (msg_idx=0;msg_idx<size;msg_idx++)
5429                        {
5430                            printk("index:%d ,cmv_result: %04X\n",index+msg_idx,RxMessage[4+msg_idx]);
5431                        }
5432#endif
5433                    }
5434                }
5435            }
5436            copy_to_user((char *)lon, (char *)pts.adslATUCSubcarrierInfo_pt, sizeof(adslATUCSubcarrierInfo));
5437            kfree(pts.adslATUCSubcarrierInfo_pt);
5438            up(&mei_sema);
5439            break;
5440        case GET_ADSL_LINE_INIT_STATS:
5441            copy_to_user((char *)lon, (char *)&AdslInitStatsData, sizeof(AdslInitStatsData));
5442            break;
5443        
5444        case GET_ADSL_POWER_SPECTRAL_DENSITY:
5445            if(down_interruptible(&mei_sema))
5446                        return -ERESTARTSYS;
5447            i=0;
5448            pts.adslPowerSpectralDensity_pt = (adslPowerSpectralDensity *)kmalloc(sizeof(adslPowerSpectralDensity), GFP_KERNEL);
5449            memset((char *)pts.adslPowerSpectralDensity_pt, 0, sizeof(adslPowerSpectralDensity));
5450
5451            //US
5452            NOMPSD_US_MAKECMV;
5453            if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5454#ifdef AMAZON_MEI_DEBUG_ON
5455                printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
5456#endif
5457                i=-1;
5458            }
5459            else{
5460                j=RxMessage[4];
5461            }
5462            PCB_US_MAKECMV;
5463            if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5464#ifdef AMAZON_MEI_DEBUG_ON
5465                printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
5466#endif
5467                i=-1;
5468            }
5469            else{
5470                temp=RxMessage[4];
5471            }
5472            RMSGI_US_MAKECMV;
5473            if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5474#ifdef AMAZON_MEI_DEBUG_ON
5475                printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
5476#endif
5477                i=-1;
5478            }
5479            else{
5480                k=(int16_t)RxMessage[4];
5481            }
5482            if (i==0)
5483            {
5484                pts.adslPowerSpectralDensity_pt->ACTPSDus = ((int )(j*256 - temp*10*256 + k*10)) /256;
5485            }
5486            // DS
5487            i=0;
5488            j=temp=temp2=0;
5489            NOMPSD_DS_MAKECMV;
5490            if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5491#ifdef AMAZON_MEI_DEBUG_ON
5492                printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
5493#endif
5494                i=-1;
5495            }
5496            else{
5497                j=RxMessage[4];
5498            }
5499            PCB_DS_MAKECMV;
5500            if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5501#ifdef AMAZON_MEI_DEBUG_ON
5502                printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
5503#endif
5504                i=-1;
5505            }
5506            else{
5507                temp=RxMessage[4];
5508            }
5509            RMSGI_DS_MAKECMV;
5510            if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5511#ifdef AMAZON_MEI_DEBUG_ON
5512                printk("\n\nCMV fail, Group PLAM Address 35 Index 0");
5513#endif
5514                i=-1;
5515            }
5516            else{
5517                //temp2=RxMessage[4];
5518                k=(int16_t)RxMessage[4];
5519            }
5520            if (i==0)
5521            {
5522                pts.adslPowerSpectralDensity_pt->ACTPSDds = ((int )(j*256 - temp*10*256 + k*10)) /256;
5523            }
5524            copy_to_user((char *)lon, (char *)pts.adslPowerSpectralDensity_pt, sizeof(adslPowerSpectralDensity));
5525            kfree(pts.adslPowerSpectralDensity_pt);
5526            up(&mei_sema);
5527            break;
5528                case AMAZON_MEI_START:
5529            showtime=0;
5530            loop_diagnostics_completed = 0;
5531#ifdef ARC_READY_ACK
5532#ifdef LOCK_RETRY
5533            i=0;
5534lock_retry:
5535            if(down_trylock(&mei_sema)!=0)
5536            {
5537                reboot_lock = 1;
5538                printk("lock fail\n");
5539                i++;
5540                if (i <=5)
5541                {
5542                        set_current_state(TASK_INTERRUPTIBLE);
5543                            schedule_timeout(10);
5544                    goto lock_retry;
5545                }else
5546                {
5547                    printk("Force to Reboot ADSL!\n");
5548                    up(&mei_sema);
5549                        set_current_state(TASK_INTERRUPTIBLE);
5550                            schedule_timeout(1000);
5551                        sema_init(&mei_sema, 1); // semaphore initialization, mutex
5552                }
5553            }else
5554            {
5555                reboot_lock = 1;
5556            }
5557#else
5558            if(down_interruptible(&mei_sema)) //disable CMV access until ARC ready
5559            {
5560                        return -ERESTARTSYS;
5561            }
5562#endif
5563#endif
5564                    //CLEAR_BIT((*((volatile u32 *)0xB0100B40)), 0x40); //Warning LED GPIO ON
5565            if(chantype.interleave==1){
5566                kfree(interleave_mei_net.priv);
5567                unregister_netdev(&interleave_mei_net);
5568            }
5569            else if(chantype.fast==1){
5570                kfree(fast_mei_net.priv);
5571                unregister_netdev(&fast_mei_net);
5572            }
5573            chantype.interleave=0;
5574            chantype.fast=0;
5575            meiMailboxInterruptsDisable(); //disable all MEI interrupts
5576            if(mei_arc_swap_buff == NULL){
5577            mei_arc_swap_buff = (u32 *)kmalloc(MAXSWAPSIZE*4, GFP_KERNEL);
5578            if(mei_arc_swap_buff==NULL){
5579#ifdef AMAZON_MEI_DEBUG_ON
5580                printk("\n\n malloc fail for codeswap buff");
5581#endif
5582                meierr=MEI_FAILURE;
5583            }
5584            }
5585                        if(meiForceRebootAdslModem() != MEI_SUCCESS){
5586#ifdef AMAZON_MEI_DEBUG_ON
5587                                printk("\n\n meiForceRebootAdslModem() error...");
5588#endif
5589                                meierr=MEI_FAILURE;
5590                        }
5591            interruptible_sleep_on(&wait_queue_codeswap);
5592            // reset is called
5593                        break;
5594        case AMAZON_MEI_MIB_DAEMON:
5595#ifdef IFX_SMALL_FOOTPRINT /* [ */
5596            return -1;
5597#else /* ][ !IFX_SMALL_FOOTPRINT */
5598            i=0;
5599            while(1){
5600                if(i<MIB_INTERVAL)
5601                    interruptible_sleep_on_timeout(&wait_queue_mibdaemon, ((MIB_INTERVAL-i)/(1000/HZ)));
5602                i=0;
5603                if(showtime==1){
5604// printk("\n\n update mib");
5605                    
5606                    do_gettimeofday(&time_now);
5607                    if(time_now.tv_sec - current_intvl->start_time.tv_sec>=900){
5608                        if(current_intvl->list.next!=&interval_list){
5609                            current_intvl = list_entry(current_intvl->list.next, amazon_mei_mib, list);
5610                            do_gettimeofday(&(current_intvl->start_time));
5611                        }
5612                        else{
5613                            mib_ptr = list_entry(interval_list.next, amazon_mei_mib, list);
5614                            list_del(interval_list.next);
5615                            memset(mib_ptr, 0, sizeof(amazon_mei_mib));
5616                            list_add_tail(&(mib_ptr->list), &interval_list);
5617                            if(current_intvl->list.next==&interval_list)
5618#ifdef AMAZON_MEI_DEBUG_ON
5619                                printk("\n\nlink list error");
5620#endif
5621                            current_intvl = list_entry(current_intvl->list.next, amazon_mei_mib, list);
5622                            do_gettimeofday(&(current_intvl->start_time));
5623                        }
5624                    }
5625                    
5626                    if(down_interruptible(&mei_sema))
5627                                return -ERESTARTSYS;
5628/*
5629                    ATUC_PERF_LO_FLAG_MAKECMV;
5630                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5631#ifdef AMAZON_MEI_DEBUG_ON
5632                        printk("\n\nCMV fail, Group 7 Address 0 Index 0");
5633#endif
5634                    }
5635                    else{
5636                        if(RxMessage[4]&PLAM_LOS_FailureBit){
5637                            current_intvl->AtucPerfLos++;
5638                            ATUC_PERF_LOSS++;
5639                            CurrStatus.adslAtucCurrStatus = 2;
5640                        }
5641                        if(RxMessage[4]&PLAM_LOF_FailureBit){
5642                            current_intvl->AtucPerfLof++;
5643                            ATUC_PERF_LOFS++;
5644                            CurrStatus.adslAtucCurrStatus = 1;
5645                        }
5646                        if(!(RxMessage[4]&(PLAM_LOS_FailureBit|PLAM_LOF_FailureBit)))
5647                            CurrStatus.adslAtucCurrStatus = 0;
5648                    }
5649*/
5650                    ATUC_PERF_ESS_FLAG_MAKECMV;
5651                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5652#ifdef AMAZON_MEI_DEBUG_ON
5653                        printk("\n\nCMV fail, Group 7 Address 7 Index 0");
5654#endif
5655                    }
5656                    else{
5657                        temp = RxMessage[4]-mib_pread.ATUC_PERF_ESS;
5658                        if(temp>=0){
5659                            current_intvl->AtucPerfEs+=temp;
5660                            ATUC_PERF_ESS+=temp;
5661                            mib_pread.ATUC_PERF_ESS = RxMessage[4];
5662                        }
5663                        else{
5664                            current_intvl->AtucPerfEs+=0xffff-mib_pread.ATUC_PERF_ESS+RxMessage[4];
5665                            ATUC_PERF_ESS+=0xffff-mib_pread.ATUC_PERF_ESS+RxMessage[4];
5666                            mib_pread.ATUC_PERF_ESS = RxMessage[4];
5667                        }
5668                    }
5669/*
5670                    ATUR_PERF_LO_FLAG_MAKECMV;
5671                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5672#ifdef AMAZON_MEI_DEBUG_ON
5673                        printk("\n\nCMV fail, Group 7 Address 1 Index 0");
5674#endif
5675                    }
5676                    else{
5677                        if(RxMessage[4]&PLAM_LOS_FailureBit){
5678                            current_intvl->AturPerfLos++;
5679                            ATUR_PERF_LOSS++;
5680                            CurrStatus.adslAturCurrStatus = 2;
5681                        }
5682                        if(RxMessage[4]&PLAM_LOF_FailureBit){
5683                            current_intvl->AturPerfLof++;
5684                            ATUR_PERF_LOFS++;
5685                            CurrStatus.adslAturCurrStatus = 1;
5686                        }
5687                        if(RxMessage[4]&PLAM_LPR_FailureBit){
5688                            current_intvl->AturPerfLpr++;
5689                            ATUR_PERF_LPR++;
5690                            CurrStatus.adslAturCurrStatus = 3;
5691                        }
5692                        if(!(RxMessage[4]&(PLAM_LOS_FailureBit|PLAM_LOF_FailureBit|PLAM_LPR_FailureBit)))
5693                            CurrStatus.adslAturCurrStatus = 0;
5694                    }
5695*/
5696                    ATUR_PERF_ESS_FLAG_MAKECMV;
5697                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5698#ifdef AMAZON_MEI_DEBUG_ON
5699                        printk("\n\nCMV fail, Group 7 Address 33 Index 0");
5700#endif
5701                    }
5702                    else{
5703                        temp = RxMessage[4]-mib_pread.ATUR_PERF_ESS;
5704                        if(temp>=0){
5705                            current_intvl->AturPerfEs+=temp;
5706                            ATUR_PERF_ESS+=temp;
5707                            mib_pread.ATUR_PERF_ESS = RxMessage[4];
5708                        }
5709                        else{
5710                            current_intvl->AturPerfEs+=0xffff-mib_pread.ATUR_PERF_ESS+RxMessage[4];
5711                            ATUR_PERF_ESS+= 0xffff-mib_pread.ATUR_PERF_ESS+RxMessage[4];
5712                            mib_pread.ATUR_PERF_ESS=RxMessage[4];
5713                        }
5714                    }
5715                    // to update rx/tx blocks
5716                    ATUR_CHAN_RECV_BLK_FLAG_MAKECMV_LSW;
5717                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5718#ifdef AMAZON_MEI_DEBUG_ON
5719                        printk("\n\nCMV fail, Group 7 Address 20 Index 0");
5720#endif
5721                    }
5722                    else{
5723                        temp = RxMessage[4];
5724                    }
5725                    ATUR_CHAN_RECV_BLK_FLAG_MAKECMV_MSW;
5726                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5727#ifdef AMAZON_MEI_DEBUG_ON
5728                        printk("\n\nCMV fail, Group 7 Address 21 Index 0");
5729#endif
5730                    }
5731                    else{
5732                        temp2 = RxMessage[4];
5733                    }
5734                    if((temp + (temp2<<16) - mib_pread.ATUR_CHAN_RECV_BLK)>=0){
5735                        current_intvl->AturChanPerfRxBlk+=temp + (temp2<<16) - mib_pread.ATUR_CHAN_RECV_BLK;
5736                        ATUR_CHAN_RECV_BLK+=temp + (temp2<<16) - mib_pread.ATUR_CHAN_RECV_BLK;
5737                        mib_pread.ATUR_CHAN_RECV_BLK = temp + (temp2<<16);
5738                        }
5739                    else{
5740                        current_intvl->AturChanPerfRxBlk+=0xffffffff - mib_pread.ATUR_CHAN_RECV_BLK +(temp + (temp2<<16));
5741                        ATUR_CHAN_RECV_BLK+=0xffffffff - mib_pread.ATUR_CHAN_RECV_BLK +(temp + (temp2<<16));
5742                        mib_pread.ATUR_CHAN_RECV_BLK = temp + (temp2<<16);
5743                    }
5744                    current_intvl->AturChanPerfTxBlk = current_intvl->AturChanPerfRxBlk;
5745                    ATUR_CHAN_TX_BLK = ATUR_CHAN_RECV_BLK;
5746/*
5747                    ATUR_CHAN_TX_BLK_FLAG_MAKECMV_LSW;
5748                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS)
5749                        printk("\n\nCMV fail, Group 7 Address 20 Index 0");
5750                    else{
5751                        if(RxMessage[4]){
5752                            current_intvl->AturChanPerfTxBlk+=RxMessage[4];
5753                            ATUR_CHAN_TX_BLK+=RxMessage[4];
5754                        }
5755                    }
5756                    ATUR_CHAN_TX_BLK_FLAG_MAKECMV_MSW;
5757                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS)
5758                        printk("\n\nCMV fail, Group 7 Address 21 Index 0");
5759                    else{
5760                        if(RxMessage[4]){
5761                            current_intvl->AturChanPerfTxBlk+=(int)((RxMessage[4])<<16);
5762                            ATUR_CHAN_TX_BLK+=(int)((RxMessage[4])<<16);
5763                        }
5764                    }
5765*/
5766                    if(chantype.interleave == 1){
5767                        ATUR_CHAN_CORR_BLK_FLAG_MAKECMV_INTL;
5768                        if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5769#ifdef AMAZON_MEI_DEBUG_ON
5770                            printk("\n\nCMV fail, Group 7 Address 3 Index 0");
5771#endif
5772                        }
5773                        else{
5774                            temp = RxMessage[4] - mib_pread.ATUR_CHAN_CORR_BLK_INTL;
5775                            if(temp>=0){
5776                                current_intvl->AturChanPerfCorrBlk+=temp;
5777                                ATUR_CHAN_CORR_BLK+=temp;
5778                                mib_pread.ATUR_CHAN_CORR_BLK_INTL = RxMessage[4];
5779                            }
5780                            else{
5781                                current_intvl->AturChanPerfCorrBlk+=0xffff - mib_pread.ATUR_CHAN_CORR_BLK_INTL +RxMessage[4];
5782                                ATUR_CHAN_CORR_BLK+=0xffff - mib_pread.ATUR_CHAN_CORR_BLK_INTL +RxMessage[4];
5783                                mib_pread.ATUR_CHAN_CORR_BLK_INTL = RxMessage[4];
5784                            }
5785                        }
5786                    }
5787                    else if(chantype.fast == 1){
5788                        ATUR_CHAN_CORR_BLK_FLAG_MAKECMV_FAST;
5789                        if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5790#ifdef AMAZON_MEI_DEBUG_ON
5791                            printk("\n\nCMV fail, Group 7 Address 3 Index 1");
5792#endif
5793                        }
5794                        else{
5795                            temp = RxMessage[4] - mib_pread.ATUR_CHAN_CORR_BLK_FAST;
5796                            if(temp>=0){
5797                                current_intvl->AturChanPerfCorrBlk+=temp;
5798                                ATUR_CHAN_CORR_BLK+=temp;
5799                                mib_pread.ATUR_CHAN_CORR_BLK_FAST = RxMessage[4];
5800                            }
5801                            else{
5802                                current_intvl->AturChanPerfCorrBlk+=0xffff - mib_pread.ATUR_CHAN_CORR_BLK_FAST + RxMessage[4];
5803                                ATUR_CHAN_CORR_BLK+=0xffff - mib_pread.ATUR_CHAN_CORR_BLK_FAST + RxMessage[4];
5804                                mib_pread.ATUR_CHAN_CORR_BLK_FAST = RxMessage[4];
5805                            }
5806                        }
5807                    }
5808                    
5809                    if(chantype.interleave == 1){
5810                        ATUR_CHAN_UNCORR_BLK_FLAG_MAKECMV_INTL;
5811                        if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5812#ifdef AMAZON_MEI_DEBUG_ON
5813                            printk("\n\nCMV fail, Group 7 Address 2 Index 0");
5814#endif
5815                        }
5816                        else{
5817                            temp = RxMessage[4] - mib_pread.ATUR_CHAN_UNCORR_BLK_INTL;
5818                            if(temp>=0){
5819                                current_intvl->AturChanPerfUncorrBlk+=temp;
5820                                ATUR_CHAN_UNCORR_BLK+=temp;
5821                                mib_pread.ATUR_CHAN_UNCORR_BLK_INTL = RxMessage[4];
5822                            }
5823                            else{
5824                                current_intvl->AturChanPerfUncorrBlk+=0xffff - mib_pread.ATUR_CHAN_UNCORR_BLK_INTL + RxMessage[4];
5825                                ATUR_CHAN_UNCORR_BLK+=0xffff - mib_pread.ATUR_CHAN_UNCORR_BLK_INTL + RxMessage[4];
5826                                mib_pread.ATUR_CHAN_UNCORR_BLK_INTL = RxMessage[4];
5827                            }
5828                        }
5829                    }
5830                    else if(chantype.fast == 1){
5831                        ATUR_CHAN_UNCORR_BLK_FLAG_MAKECMV_FAST;
5832                        if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5833#ifdef AMAZON_MEI_DEBUG_ON
5834                            printk("\n\nCMV fail, Group 7 Address 2 Index 1");
5835#endif
5836                        }
5837                        else{
5838                            temp = RxMessage[4] - mib_pread.ATUR_CHAN_UNCORR_BLK_FAST;
5839                            if(temp>=0){
5840                                current_intvl->AturChanPerfUncorrBlk+=temp;
5841                                ATUR_CHAN_UNCORR_BLK+=temp;
5842                                mib_pread.ATUR_CHAN_UNCORR_BLK_FAST = RxMessage[4];
5843                            }
5844                            else{
5845                                current_intvl->AturChanPerfUncorrBlk+=0xffff - mib_pread.ATUR_CHAN_UNCORR_BLK_FAST + RxMessage[4];
5846                                ATUR_CHAN_UNCORR_BLK+=0xffff - mib_pread.ATUR_CHAN_UNCORR_BLK_FAST + RxMessage[4];
5847                                mib_pread.ATUR_CHAN_UNCORR_BLK_FAST = RxMessage[4];
5848                            }
5849                        }
5850                    }
5851                    
5852                    //RFC-3440
5853
5854#ifdef AMAZON_MEI_MIB_RFC3440
5855                    ATUC_PERF_STAT_FASTR_FLAG_MAKECMV; //???
5856                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5857#ifdef AMAZON_MEI_DEBUG_ON
5858                        printk("\n\nCMV fail, Group 0 Address 0 Index 0");
5859#endif
5860                    }
5861                    else{
5862                        temp = RxMessage[4] - mib_pread.ATUC_PERF_STAT_FASTR;
5863                        if(temp>=0){
5864                            current_intvl->AtucPerfStatFastR+=temp;
5865                            ATUC_PERF_STAT_FASTR+=temp;
5866                            mib_pread.ATUC_PERF_STAT_FASTR = RxMessage[4];
5867                        }
5868                        else{
5869                            current_intvl->AtucPerfStatFastR+=0xffff - mib_pread.ATUC_PERF_STAT_FASTR + RxMessage[4];
5870                            ATUC_PERF_STAT_FASTR+=0xffff - mib_pread.ATUC_PERF_STAT_FASTR + RxMessage[4];
5871                            mib_pread.ATUC_PERF_STAT_FASTR = RxMessage[4];
5872                        }
5873                    }
5874                    ATUC_PERF_STAT_FAILED_FASTR_FLAG_MAKECMV; //???
5875                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5876#ifdef AMAZON_MEI_DEBUG_ON
5877                        printk("\n\nCMV fail, Group 0 Address 0 Index 0");
5878#endif
5879                    }
5880                    else{
5881                        temp = RxMessage[4] - mib_pread.ATUC_PERF_STAT_FAILED_FASTR;
5882                        if(temp>=0){
5883                            current_intvl->AtucPerfStatFailedFastR+=temp;
5884                            ATUC_PERF_STAT_FAILED_FASTR+=temp;
5885                            mib_pread.ATUC_PERF_STAT_FAILED_FASTR = RxMessage[4];
5886                        }
5887                        else{
5888                            current_intvl->AtucPerfStatFailedFastR+=0xffff - mib_pread.ATUC_PERF_STAT_FAILED_FASTR + RxMessage[4];
5889                            ATUC_PERF_STAT_FAILED_FASTR+=0xffff - mib_pread.ATUC_PERF_STAT_FAILED_FASTR + RxMessage[4];
5890                            mib_pread.ATUC_PERF_STAT_FAILED_FASTR = RxMessage[4];
5891                        }
5892                    }
5893                    ATUC_PERF_STAT_SESL_FLAG_MAKECMV;
5894                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5895#ifdef AMAZON_MEI_DEBUG_ON
5896                        printk("\n\nCMV fail, Group 7 Address 8 Index 0");
5897#endif
5898                    }
5899                    else{
5900                        temp = RxMessage[4] - mib_pread.ATUC_PERF_STAT_SESL;
5901                        if(temp>=0){
5902                            current_intvl->AtucPerfStatSesL+=temp;
5903                            ATUC_PERF_STAT_SESL+=temp;
5904                            mib_pread.ATUC_PERF_STAT_SESL = RxMessage[4];
5905                        }
5906                        else{
5907                            current_intvl->AtucPerfStatSesL+=0xffff - mib_pread.ATUC_PERF_STAT_SESL + RxMessage[4];
5908                            ATUC_PERF_STAT_SESL+=0xffff - mib_pread.ATUC_PERF_STAT_SESL + RxMessage[4];
5909                            mib_pread.ATUC_PERF_STAT_SESL = RxMessage[4];
5910                        }
5911                    }
5912                    ATUC_PERF_STAT_UASL_FLAG_MAKECMV;
5913                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5914#ifdef AMAZON_MEI_DEBUG_ON
5915                        printk("\n\nCMV fail, Group 7 Address 10 Index 0");
5916#endif
5917                    }
5918                    else{
5919                        temp = RxMessage[4] - mib_pread.ATUC_PERF_STAT_UASL;
5920                        if(temp>=0){
5921                            current_intvl->AtucPerfStatUasL+=temp;
5922                            ATUC_PERF_STAT_UASL+=temp;
5923                            mib_pread.ATUC_PERF_STAT_UASL = RxMessage[4];
5924                        }
5925                        else{
5926                            current_intvl->AtucPerfStatUasL+=0xffff - mib_pread.ATUC_PERF_STAT_UASL + RxMessage[4];
5927                            ATUC_PERF_STAT_UASL+=0xffff - mib_pread.ATUC_PERF_STAT_UASL + RxMessage[4];
5928                            mib_pread.ATUC_PERF_STAT_UASL = RxMessage[4];
5929                        }
5930                    }
5931                    ATUR_PERF_STAT_SESL_FLAG_MAKECMV;
5932                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
5933#ifdef AMAZON_MEI_DEBUG_ON
5934                        printk("\n\nCMV fail, Group 7 Address 34 Index 0");
5935#endif
5936                    }
5937                    else{
5938                        temp = RxMessage[4] - mib_pread.ATUR_PERF_STAT_SESL;
5939                        if(temp>=0){
5940                            current_intvl->AtucPerfStatUasL+=temp;
5941                            ATUC_PERF_STAT_UASL+=temp;
5942                            mib_pread.ATUR_PERF_STAT_SESL = RxMessage[4];
5943                        }
5944                        else{
5945                            current_intvl->AtucPerfStatUasL+=0xffff - mib_pread.ATUR_PERF_STAT_SESL + RxMessage[4];
5946                            ATUC_PERF_STAT_UASL+=0xffff - mib_pread.ATUR_PERF_STAT_SESL + RxMessage[4];
5947                            mib_pread.ATUR_PERF_STAT_SESL = RxMessage[4];
5948                        }
5949                    }
5950                    
5951#endif
5952                    up(&mei_sema);
5953                    
5954                    do_gettimeofday(&time_fini);
5955                    i = ((int)((time_fini.tv_sec-time_now.tv_sec)*1000)) + ((int)((time_fini.tv_usec-time_now.tv_usec)/1000)) ; //msec
5956                }//showtime==1
5957            }
5958            break;
5959#endif /* ] !IFX_SMALL_FOOTPRINT */
5960        case AMAZON_MEI_RESET:
5961        case AMAZON_MEI_REBOOT:
5962        case AMAZON_MEI_SHOWTIME:
5963/* if(mei_arc_swap_buff !=NULL){
5964                kfree(mei_arc_swap_buff);
5965                mei_arc_swap_buff=NULL;
5966            }
5967            if(image_buffer !=NULL){
5968// kfree(image_buffer);
5969                vfree(image_buffer);
5970                image_buffer =NULL;
5971            }
5972*/
5973            if(clreoc_command_pkt !=NULL){
5974                kfree(clreoc_command_pkt);
5975                clreoc_command_pkt =NULL;
5976            }
5977            for(i=0;i<CLREOC_BUFF_SIZE;i++)
5978                clreoc_pkt[i].len=0; //flush all remaining clreoc commands in buffer
5979/*
5980            memset(mei_mib, 0, (sizeof(amazon_mei_mib)*INTERVAL_NUM));
5981            INIT_LIST_HEAD(&interval_list);
5982            for(i=0;i<INTERVAL_NUM;i++)
5983                list_add_tail(&(mei_mib[i].list), &interval_list);
5984            current_intvl = list_entry(interval_list.next, amazon_mei_mib, list);
5985            do_gettimeofday(&(current_intvl->start_time));
5986            ATUC_PERF_LOFS=0;
5987            ATUC_PERF_LOSS=0;
5988            ATUC_PERF_ESS=0;
5989             ATUC_PERF_INITS=0;
5990             ATUR_PERF_LOFS=0;
5991             ATUR_PERF_LOSS=0;
5992             ATUR_PERF_LPR=0;
5993             ATUR_PERF_ESS=0;
5994             ATUR_CHAN_RECV_BLK=0;
5995             ATUR_CHAN_TX_BLK=0;
5996             ATUR_CHAN_CORR_BLK=0;
5997             ATUR_CHAN_UNCORR_BLK=0;
5998            memset((((u8 *)&AlarmConfProfile)+32), 0, 16*4);
5999            AlarmConfProfile.adslLineAlarmConfProfileRowStatus=1;
6000*/
6001            PrevTxRate.adslAtucChanPrevTxRate=0;
6002            PrevTxRate.adslAturChanPrevTxRate=0;
6003            CurrStatus.adslAtucCurrStatus=0;
6004            CurrStatus.adslAturCurrStatus=0;
6005            
6006            if((command==AMAZON_MEI_RESET) || (command==AMAZON_MEI_REBOOT)){
6007#ifdef AMAZON_CHECK_LINK
6008                if (adsl_link_notify){
6009                    (*adsl_link_notify)(0);
6010                }
6011#endif
6012                showtime=0;
6013                //CLEAR_BIT((*((volatile u32 *)0xB0100B40)), 0x40); //Warning LED GPIO ON
6014                // disconnect net_dev
6015                if(chantype.interleave==1){
6016                    kfree(interleave_mei_net.priv);
6017                    unregister_netdev(&interleave_mei_net);
6018// if(unregister_netdev(&interleave_mei_net)!=0)
6019// printk("\n unregister interleave fail");
6020                }
6021                else if(chantype.fast==1){
6022                    kfree(fast_mei_net.priv);
6023                    unregister_netdev(&fast_mei_net);
6024// if(unregister_netdev(&fast_mei_net)!=0)
6025// printk("\n unregister fast fail");
6026                }
6027                chantype.interleave=0;
6028                chantype.fast=0;
6029// 603221:tc.chen start
6030                chantype.bearchannel0 = 0;
6031                chantype.bearchannel1 = 0;
6032                adsl_mode = 0;
6033// 603221:tc.chen end
6034                
6035                while(1){
6036                    
6037                    makeCMV(H2D_CMV_READ, STAT, 0, 0, 1, NULL); //maximum allowed tx message length, in bytes
6038                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
6039                        //printk("AdslInitStatsData.FullInitializationCount++\n");
6040                        AdslInitStatsData.FullInitializationCount++;
6041                        //printk("AdslInitStatsData.FailedFullInitializationCount++\n");
6042                        AdslInitStatsData.FailedFullInitializationCount++;
6043                        //printk("AdslInitStatsData.LINIT_Errors++\n");
6044                        AdslInitStatsData.LINIT_Errors++;
6045                    }else
6046                    {
6047                        //printk("RxMessage=%X\n",RxMessage[4]);
6048                        if ( RxMessage[4]!=0x1)
6049                        {
6050                            //printk("AdslInitStatsData.FullInitializationCount++\n");
6051                            AdslInitStatsData.FullInitializationCount++;
6052                            if ( RxMessage[4] != 0x7)
6053                            {
6054                                //printk("AdslInitStatsData.LINIT_Errors++\n");
6055                                AdslInitStatsData.LINIT_Errors++;
6056                                //printk("AdslInitStatsData.FailedFullInitializationCount++\n");
6057                                AdslInitStatsData.FailedFullInitializationCount++;
6058                                
6059                            }
6060                        }
6061                    }
6062
6063                    reboot_flag=0;
6064                    wake_up_interruptible(&wait_queue_codeswap); //wake up codeswap daemon
6065
6066                    interruptible_sleep_on_timeout(&wait_queue_reboot, 1*HZ); // sleep until arc ready
6067#ifdef ARC_READY_ACK
6068                    if(reboot_flag!=0)
6069                        break;
6070                    else
6071                    {
6072                        up(&mei_sema);
6073                        printk("\n reboot retry");
6074                    }
6075#else
6076                    break;
6077#endif
6078                }
6079            }
6080            else{ //AMAZON_MEI_SHOWTIME
6081                if(down_interruptible(&mei_sema))
6082                            return -ERESTARTSYS;
6083                
6084                // clreoc stuff
6085                makeCMV(H2D_CMV_READ, INFO, 83, 0, 1, data); //maximum allowed tx message length, in bytes
6086                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
6087#ifdef AMAZON_MEI_DEBUG_ON
6088                    printk("\n\nCMV fail, Group 3 Address 83 Index 0");
6089#endif
6090                }
6091                else{
6092                    clreoc_max_tx_len = (int)RxMessage[4];
6093                    clreoc_command_pkt = kmalloc((clreoc_max_tx_len*CLREOC_BUFF_SIZE), GFP_KERNEL);
6094                    if(clreoc_command_pkt == NULL){
6095#ifdef AMAZON_MEI_DEBUG_ON
6096                        printk("kmalloc error for clreoc_command_pkt\n\n");
6097#endif
6098                        up(&mei_sema);
6099                        return -1;
6100                    }
6101                    for(i=0;i<CLREOC_BUFF_SIZE;i++){
6102                        clreoc_pkt[i].command = (u8 *)(((u8 *)clreoc_command_pkt) + (clreoc_max_tx_len*i));
6103                        clreoc_pkt[i].len=0;
6104                    }
6105                }
6106                
6107                // decide what channel, then register
6108                makeCMV(H2D_CMV_READ, STAT, 12, 0, 1, data);
6109                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
6110#ifdef AMAZON_MEI_DEBUG_ON
6111                    printk("\n\nCMV fail, Group 2 Address 12 Index 0");
6112#endif
6113                }
6114                else{
6115                    if((RxMessage[4]&0x1)==1){
6116                        if(register_netdev(&interleave_mei_net)!=0){
6117#ifdef AMAZON_MEI_DEBUG_ON
6118                                    printk("\n\n Register interleave Device Failed.");
6119#endif
6120                            }
6121                        else{
6122                            chantype.interleave = 1;
6123                            chantype.fast= 0;
6124#ifdef AMAZON_MEI_DEBUG_ON
6125                            printk("\n channel is interleave");
6126#endif
6127                        }
6128                    }
6129                    else if((RxMessage[4]&0x2)==2){
6130                        if(register_netdev(&fast_mei_net)!=0){
6131#ifdef AMAZON_MEI_DEBUG_ON
6132                                    printk("\n\n Register fast Device Failed.");
6133#endif
6134                            }
6135                        else{
6136                            chantype.fast = 1;
6137                            chantype.interleave = 0;
6138#ifdef AMAZON_MEI_DEBUG_ON
6139                            printk("\n channel is fast");
6140#endif
6141                        }
6142                    }
6143                    else{
6144#ifdef AMAZON_MEI_DEBUG_ON
6145                        printk("\nunknown channel type, 0x%8x", RxMessage[4]);
6146#endif
6147                    }
6148// 603221:tc.chen start
6149                    if ( (RxMessage[4]&0x100) == 0x100)
6150                    {
6151                        chantype.bearchannel0 = 1;
6152                    }else if ( (RxMessage[4]&0x100) == 0x200)
6153                    {
6154                        chantype.bearchannel1 = 1;
6155                    }
6156// 603221:tc.chen end
6157                }
6158// 603221:tc.chen start
6159                // read adsl mode
6160                makeCMV(H2D_CMV_READ, STAT, 1, 0, 1, data);
6161                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
6162#ifdef AMAZON_MEI_DEBUG_ON
6163                    printk("\n\nCMV fail, Group STAT Address 1 Index 0");
6164#endif
6165                }
6166                adsl_mode = RxMessage[4];
6167// 603221:tc.chen end
6168                makeCMV(H2D_CMV_READ, STAT, 17, 0, 1, data);
6169                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
6170#ifdef AMAZON_MEI_DEBUG_ON
6171                    printk("\n\nCMV fail, Group STAT Address 1 Index 0");
6172#endif
6173                }
6174                adsl_mode_extend = RxMessage[4];
6175                
6176                // update previous channel tx rate
6177                ATUC_CHAN_CURR_TX_RATE_FLAG_MAKECMV;
6178                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
6179#ifdef AMAZON_MEI_DEBUG_ON
6180                    printk("\n\nCMV fail, Group 6 Address 1 Index 0");
6181#endif
6182                    PrevTxRate.adslAtucChanPrevTxRate = 0;
6183                }
6184                else{
6185                    PrevTxRate.adslAtucChanPrevTxRate = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
6186                }
6187                ATUR_CHAN_CURR_TX_RATE_FLAG_MAKECMV;
6188                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
6189#ifdef AMAZON_MEI_DEBUG_ON
6190                    printk("\n\nCMV fail, Group 6 Address 0 Index 0");
6191#endif
6192                    PrevTxRate.adslAturChanPrevTxRate = 0;
6193                }
6194                else{
6195                    PrevTxRate.adslAturChanPrevTxRate = (u32)(RxMessage[4]) + (((u32)(RxMessage[5]))<<16);
6196                }
6197                
6198// up(&mei_sema);
6199                
6200// showtime=1;
6201                //SET_BIT((*((volatile u32 *)0xB0100B40)), 0x40); //Warning LED GPIO OFF
6202//dying gasp -start
6203#ifdef IFX_DYING_GASP
6204                lop_debugwr.buffer[0]=0xffffffff; //dying gasp
6205                lop_debugwr.iCount=1; //dying gasp
6206                makeCMV(H2D_CMV_READ, INFO, 66, 4, 1, NULL);
6207                //mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, &RxMessage);
6208                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
6209#ifdef AMAZON_MEI_DEBUG_ON
6210                    printk("\n\nCMV fail, Group 3 Address 66 Index 4");
6211                }
6212#endif
6213                lop_debugwr.iAddress=(u32)RxMessage[4];
6214                makeCMV(H2D_CMV_READ, INFO, 66, 5, 1, NULL);
6215                //mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, &RxMessage);
6216                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
6217#ifdef AMAZON_MEI_DEBUG_ON
6218                    printk("\n\nCMV fail, Group 3 Address 66 Index 5");
6219                }
6220#endif
6221                lop_debugwr.iAddress+=((u32)RxMessage[4])<<16;
6222                
6223//dying gasp -end
6224#endif // IFX_DYING_GASP
6225
6226//joelin 04/16/2005-start
6227                makeCMV(H2D_CMV_WRITE, PLAM, 10, 0, 1, &unavailable_seconds);
6228                //mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, &RxMessage);
6229                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
6230#ifdef AMAZON_MEI_DEBUG_ON
6231                    printk("\n\nCMV fail, Group 7 Address 10 Index 0");
6232                
6233#endif
6234                }
6235                
6236
6237//joelin 04/16/2005-end
6238                showtime=1;
6239                up(&mei_sema);
6240#ifdef AMAZON_CHECK_LINK
6241                if (adsl_link_notify){
6242                    (*adsl_link_notify)(1);
6243                }
6244#endif
6245                
6246                
6247            }
6248            break;
6249/*
6250                case AMAZON_MEI_REPLY:
6251                        copy_from_user((char *)buff, (char *)lon, MSG_LENGTH * 2);
6252                        if(meiCMV(buff, YES_REPLY) != MEI_SUCCESS){
6253                                printk("\n\n meiCMV no reply back");
6254                                meierr=MEI_FAILURE;
6255                        }
6256                        else
6257                                copy_to_user((char *)lon, (char *)RxMessage, MSG_LENGTH * 2);
6258                        break;
6259                case AMAZON_MEI_NOREPLY:
6260                        copy_from_user((char *)buff, (char *)lon, MSG_LENGTH * 2);
6261                        if(meiCMV(buff, NO_REPLY) != MEI_SUCCESS){
6262                                printk("\n\n meiCMV Host to DSP failed");
6263                                meierr=MEI_FAILURE;
6264                        }
6265                        break;
6266*/
6267        
6268        case AMAZON_MEI_HALT:
6269            meiHaltArc();
6270            break;
6271        case AMAZON_MEI_CMV_WINHOST:
6272            if(down_interruptible(&mei_sema))
6273                        return -ERESTARTSYS;
6274
6275            if (!from_kernel )
6276                copy_from_user((char *)TxMessage, (char *)lon, MSG_LENGTH*2);//joelin
6277            else
6278                memcpy(TxMessage,(char *)lon,MSG_LENGTH*2);
6279                
6280#if 0
6281// if((TxMessage[0]&0xff0)==0x0a0){
6282                for(i=0;i<16;i++){
6283                    printk("\nTxMessage[%i]=%8x", i, TxMessage[i]);
6284                }
6285// }
6286#endif
6287            
6288            if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
6289#ifdef AMAZON_MEI_DEBUG_ON
6290// printk("\n\n WINHOST CMV fail ");
6291                                printk("\n\nWINHOST CMV fail :TxMessage:%X %X %X %X, RxMessage:%X %X %X %X %X\n",TxMessage[0],TxMessage[1],TxMessage[2],TxMessage[3],RxMessage[0],RxMessage[1],RxMessage[2],RxMessage[3],RxMessage[4]);
6292#endif
6293                meierr = MEI_FAILURE;
6294            }
6295            else
6296            {
6297                if (!from_kernel ) //joelin
6298                copy_to_user((char *)lon, (char *)RxMessage, MSG_LENGTH*2);
6299                else
6300                    memcpy((char *)lon,(char *)RxMessage,MSG_LENGTH*2);
6301            }
6302                
6303            up(&mei_sema);
6304            break;
6305#ifdef AMAZON_MEI_CMV_EXTRA
6306        case AMAZON_MEI_CMV_READ:
6307            copy_from_user((char *)(&regrdwr), (char *)lon, sizeof(meireg));
6308            meiLongwordRead(regrdwr.iAddress, &(regrdwr.iData));
6309            {
6310// printk("\n\n iAddress = %8x",regrdwr.iAddress);
6311            }
6312            copy_to_user((char *)lon, (char *)(&regrdwr), sizeof(meireg));
6313            {
6314// printk("\n\n iData readback = %8x", regrdwr.iData);
6315            }
6316            break;
6317#endif
6318
6319#ifdef AMAZON_MEI_CMV_EXTRA
6320        case AMAZON_MEI_CMV_WRITE:
6321            copy_from_user((char *)(&regrdwr), (char *)lon, sizeof(meireg));
6322            {
6323// printk("\n\n iAddress = %8x",regrdwr.iAddress);
6324// printk("\n\n iData = %8x",regrdwr.iData);
6325            }
6326            meiLongwordWrite(regrdwr.iAddress, regrdwr.iData);
6327            break;
6328#endif
6329
6330#ifdef AMAZON_MEI_CMV_EXTRA
6331        case AMAZON_MEI_REMOTE:
6332            copy_from_user((char *)(&i), (char *)lon, sizeof(int));
6333            if(i==0){
6334                meiMailboxInterruptsEnable();
6335                    
6336                up(&mei_sema);
6337            }
6338            else if(i==1){
6339                meiMailboxInterruptsDisable();
6340                if(down_interruptible(&mei_sema))
6341                            return -ERESTARTSYS;
6342            }
6343            else{
6344#ifdef AMAZON_MEI_DEBUG_ON
6345                printk("\n\n AMAZON_MEI_REMOTE argument error");
6346#endif
6347                meierr=MEI_FAILURE;
6348            }
6349            break;
6350#endif
6351
6352#ifdef AMAZON_MEI_CMV_EXTRA
6353        case AMAZON_MEI_READDEBUG:
6354        case AMAZON_MEI_WRITEDEBUG:
6355            if(down_interruptible(&mei_sema))
6356                        return -ERESTARTSYS;
6357#ifdef IFX_DYING_GASP
6358    if (!from_kernel) copy_from_user((char *)(&debugrdwr), (char *)lon, sizeof(debugrdwr));//dying gasp
6359                else memcpy((char *)(&debugrdwr), (char *)lon, sizeof(debugrdwr));
6360#else //IFX_DYING_GASP
6361            copy_from_user((char *)(&debugrdwr), (char *)lon, sizeof(debugrdwr));
6362
6363#endif //IFX_DYING_GASP
6364#if 0
6365            printk("\nIN iAddress: %8x, iCount:%8x\n", debugrdwr.iAddress, debugrdwr.iCount);
6366#endif
6367            
6368            if(command==AMAZON_MEI_READDEBUG)
6369                meiDebugRead(debugrdwr.iAddress, debugrdwr.buffer, debugrdwr.iCount);
6370            else
6371                meiDebugWrite(debugrdwr.iAddress, debugrdwr.buffer, debugrdwr.iCount);
6372                
6373#ifdef IFX_DYING_GASP
6374            if (!from_kernel) copy_to_user((char *)lon, (char*)(&debugrdwr), sizeof(debugrdwr));//dying gasp
6375#else //IFX_DYING_GASP
6376            copy_to_user((char *)lon, (char*)(&debugrdwr), sizeof(debugrdwr));
6377#endif //IFX_DYING_GASP
6378            up(&mei_sema);
6379            
6380#if 0
6381            printk("\nOUT iAddress: %8x, iCount:%8x\n", debugrdwr.iAddress, debugrdwr.iCount);
6382            for(i=0;i<debugrdwr.iCount;i++)
6383                printk("\n %8x",debugrdwr.buffer[i]);
6384#endif
6385            break;
6386#endif
6387
6388        case AMAZON_MEI_LOP:
6389        //GPIO31 :dying gasp event indication
6390        // (1) logic high: dying gasp event is false (default)
6391        // (2) logic low: dying gasp event is true
6392#ifdef IFX_DYING_GASP
6393            break;
6394#else
6395            CLEAR_BIT((*((volatile u32 *)0xB0100B48)), 0x8000);
6396            CLEAR_BIT((*((volatile u32 *)0xB0100B4C)), 0x8000);
6397            CLEAR_BIT((*((volatile u32 *)0xB0100B50)), 0x8000);
6398            SET_BIT((*((volatile u32 *)0xB0100B54)), 0x8000);
6399            asm("SYNC");
6400            if(((*((volatile u32 *)0xB0100B44))&0x8000)==0x0)
6401                meierr=MEI_FAILURE; //return - to indicate loss of power
6402            break;
6403#endif //#ifdef IFX_DYING_GASP
6404            
6405                    //for PCM
6406        case AMAZON_MEI_PCM_SETUP:
6407            //gpio
6408            
6409            *AMAZON_GPIO_P0_DIR |=1<<15;
6410                *AMAZON_GPIO_P0_ALTSEL0 |=1<<15;
6411                *AMAZON_GPIO_P0_ALTSEL1 &=~(1<<15);
6412                *AMAZON_GPIO_P0_OD |=1<<15;
6413                                                                                
6414                /*GPIO 16 TDM_DI*/
6415                *AMAZON_GPIO_P1_DIR &=~1;
6416                *AMAZON_GPIO_P1_ALTSEL0 |=1;
6417                *AMAZON_GPIO_P1_ALTSEL1 &=~1;
6418                                                                                
6419                /*GPIO 17 TDM_DCL */
6420                *AMAZON_GPIO_P1_DIR|=0x02;
6421                *AMAZON_GPIO_P1_ALTSEL0|=0x02;
6422                *AMAZON_GPIO_P1_ALTSEL1 &=(u32)~0x02;
6423                *AMAZON_GPIO_P1_OD|=0x02;
6424                                                                                
6425                /*GPIO 18 TDM FSC*/
6426                *AMAZON_GPIO_P1_DIR|=0x04;
6427                *AMAZON_GPIO_P1_ALTSEL0|=0x04;
6428                *AMAZON_GPIO_P1_ALTSEL1 &=(u32)~0x04;
6429                *AMAZON_GPIO_P1_OD|=0x04;
6430            
6431            for(i=0;i<2;i++){
6432                for(j=0;j<256;j++)
6433                    sampledata[i*256+j]=j;
6434            }
6435            
6436            pcm_start_addr = lon;
6437            
6438            printk("\n\n pcm_start_addr is %8x", lon);
6439            
6440            for(i=0;i<PCM_CHANNEL_NUM;i++){
6441#ifdef PCM_ACCESS_DEBUG
6442                meiDebugRead_16((pcm_start_addr+i*16), (u32*)(pcm_data+i), 4);
6443#else
6444                meiDMARead_16((pcm_start_addr+i*16), (u32*)(pcm_data+i), 4);
6445#endif
6446                if((pcm_data[i].S!=8)||(pcm_data[i].len<1)||(pcm_data[i].rdindex!=0)||(pcm_data[i].wrindex!=0)||(pcm_data[i].flow!=0))
6447                    printk("\n\n pcm_data fill in wrongly\n\n");
6448                printk("\npcm_data %d",i);
6449                printk("\n S = %d", pcm_data[i].S);
6450                printk("\n LSW = %4x", pcm_data[i].LSW);
6451                printk("\n MSW = %4x", pcm_data[i].MSW);
6452                printk("\n len = %d", pcm_data[i].len);
6453                printk("\n rdindex = %d", pcm_data[i].rdindex);
6454                printk("\n wrindex = %d", pcm_data[i].wrindex);
6455                printk("\n flow = %d", pcm_data[i].flow);
6456                pcm_data[i].finish=0;
6457                if(i%2==0){//tx channel
6458                    for(j=0;j<PCM_BUFF_SIZE/256;j++){
6459                        for(k=0;k<256;k++){
6460                            pcm_data[i].buff[j*256+k]=k;
6461                        /* if(k%2==0)
6462                                pcm_data[i].buff[j*256+k]=0xaa;
6463                            else
6464                                pcm_data[i].buff[j*256+k]=0x55;*/
6465                        }
6466                    }
6467#ifdef PCM_ACCESS_DEBUG
6468                    meiDebugWrite_8((((u32)(pcm_data[i].LSW))+(((u32)(pcm_data[i].MSW))<<16)), (u32*)(pcm_data[i].buff),((pcm_data[i].len/4)/2));//fill half first
6469// meiDebugWrite_8((((u32)(pcm_data[i].LSW))+(((u32)(pcm_data[i].MSW))<<16)), (u32*)(pcm_data[i].buff),2);//fill half first
6470#else
6471                    meiDMAWrite_8((((u32)(pcm_data[i].LSW))+(((u32)(pcm_data[i].MSW))<<16)), (u32*)(pcm_data[i].buff),((pcm_data[i].len/4)/2));//fill half first
6472// meiDMAWrite_8((((u32)(pcm_data[i].LSW))+(((u32)(pcm_data[i].MSW))<<16)), (u32*)(pcm_data[i].buff),2);//fill half first
6473#endif
6474                    pcm_data[i].point=(pcm_data[i].len)/2;
6475// pcm_data[i].point=8;
6476#ifdef PCM_ACCESS_DEBUG
6477                    meiDebugRead_16(pcm_start_addr+i*16+12, &temp, 1);
6478#else
6479                    meiDMARead_16(pcm_start_addr+i*16+12, &temp, 1);
6480#endif
6481                    temp = (temp &0xffff) + (((u32)(pcm_data[i].point))<<16);
6482#ifdef PCM_ACCESS_DEBUG
6483                    meiDebugWrite_16(pcm_start_addr+i*16+12,&temp, 1);//update wrindex
6484#else
6485                    meiDMAWrite_16(pcm_start_addr+i*16+12,&temp, 1);//update wrindex
6486#endif
6487                }
6488                else{// rx channel
6489                    pcm_data[i].point=0;
6490                }
6491            }
6492            break;
6493        case AMAZON_MEI_PCM_START_TIMER:
6494                /* GPTU timer 6 */
6495            /* enable the timer in the PMU */
6496                *(AMAZON_PMU_PWDCR) = (*(AMAZON_PMU_PWDCR))| AMAZON_PMU_PWDCR_GPT|AMAZON_PMU_PWDCR_FPI;
6497            /* setup the GPTU for timer tick f_fpi == f_gptu*/
6498            *(AMAZON_GPTU_CLC) = 0x100;
6499            //reload value = fpi/(HZ * P), timer mode, Prescaler = 4 ( T6I = 000, T6BPS2 = 0)
6500            *(AMAZON_GPTU_CAPREL) = (int)(117500000/(lon*4));
6501            *(AMAZON_GPTU_T6CON) = 0x80C0;
6502            
6503            if (request_irq(AMAZON_TIMER6_INT, amazon_timer6_interrupt_MEI,0, "hrt", NULL)!=0){
6504#ifdef AMAZON_MEI_DEBUG_ON
6505                        printk("\n\n unable to register irq for hrt!!!");
6506#endif
6507                        return -1;
6508                }
6509            enable_irq(AMAZON_TIMER6_INT);
6510            break;
6511        case AMAZON_MEI_PCM_STOP_TIMER:
6512            disable_irq(AMAZON_TIMER6_INT);
6513            free_irq(AMAZON_TIMER6_INT, NULL);
6514            break;
6515        case AMAZON_MEI_PCM_CHECK:
6516            for(i=0;i<PCM_CHANNEL_NUM;i++){
6517                if(pcm_data[i].finish!=1)
6518                    return 0;
6519            }
6520            for(i=0;i<PCM_CHANNEL_NUM/2;i++){
6521                j=0;
6522                while(1){
6523                    if((pcm_data[i*2+1].buff[j]==0x0) && (pcm_data[i*2+1].buff[j+1]==0x1)&& (pcm_data[i*2+1].buff[j+2]==0x2))
6524                        break;
6525                    else
6526                        j++;
6527                }
6528                printk("\n j=%d", j);
6529                temp=0;
6530                for(k=0;k<((PCM_BUFF_SIZE-j)/4);k++){
6531                    if(memcmp(pcm_data[i*2].buff+k*4, pcm_data[i*2+1].buff+j+k*4, 4)!=0){
6532                        temp++;
6533                        printk("\n\n%2x %2x %2x %2x %2x %2x %2x %2x\n\n", *((u8*)(pcm_data[i*2].buff+k*4)), *((u8*)(pcm_data[i*2].buff+k*4+1)),*((u8*)(pcm_data[i*2].buff+k*4+2)),*((u8*)(pcm_data[i*2].buff+k*4+3)),*((u8*)(pcm_data[i*2+1].buff+j+k*4)),*((u8*)(pcm_data[i*2+1].buff+j+k*4+1)),*((u8*)(pcm_data[i*2+1].buff+j+k*4+2)),*((u8*)(pcm_data[i*2+1].buff+j+k*4+3)));
6534                        break;
6535                    }
6536                }
6537                if(temp!=0)
6538                    printk("\n\n Channel pair %d not match: err32 %d\n\n", i, temp);
6539                else
6540                    printk("\n\n Channel pair %d match\n\n", i);
6541            }
6542            for(i=0;i<PCM_CHANNEL_NUM;i++){
6543                if(i%2==1){//rx channel
6544#ifdef PCM_ACCESS_DEBUG
6545                    meiDebugRead_16(pcm_start_addr+i*16+12, &temp, 1);
6546#else
6547                    meiDMARead_16(pcm_start_addr+i*16+12, &temp, 1);
6548#endif
6549                    printk("\n\nRx channel %d: Overflow Bytes %d", i, (temp&0xffff));
6550                }
6551                else{//tx channel
6552#ifdef PCM_ACCESS_DEBUG
6553                    meiDebugRead_16(pcm_start_addr+i*16, &temp, 1);
6554#else
6555                    meiDMARead_16(pcm_start_addr+i*16, &temp, 1);
6556#endif
6557                    printk("\n\nElectra Err: %d",(temp&0xffff));
6558                }
6559            }
6560            //check electra overflow
6561            
6562            meierr=1;
6563            break;
6564        case AMAZON_MEI_PCM_GETDATA:
6565            copy_to_user(lon, pcm_data[1].buff, PCM_BUFF_SIZE);
6566            break;
6567        case AMAZON_MEI_PCM_GPIO:
6568            //gpio
6569            
6570            *AMAZON_GPIO_P0_DIR |=1<<15;
6571                *AMAZON_GPIO_P0_ALTSEL0 |=1<<15;
6572                *AMAZON_GPIO_P0_ALTSEL1 &=~(1<<15);
6573                *AMAZON_GPIO_P0_OD |=1<<15;
6574                                                                                
6575                /*GPIO 16 TDM_DI*/
6576                *AMAZON_GPIO_P1_DIR &=~1;
6577                *AMAZON_GPIO_P1_ALTSEL0 |=1;
6578                *AMAZON_GPIO_P1_ALTSEL1 &=~1;
6579                                                                                
6580                /*GPIO 17 TDM_DCL */
6581                *AMAZON_GPIO_P1_DIR|=0x02;
6582                *AMAZON_GPIO_P1_ALTSEL0|=0x02;
6583                *AMAZON_GPIO_P1_ALTSEL1 &=(u32)~0x02;
6584                *AMAZON_GPIO_P1_OD|=0x02;
6585                                                                                
6586                /*GPIO 18 TDM FSC*/
6587                *AMAZON_GPIO_P1_DIR|=0x04;
6588                *AMAZON_GPIO_P1_ALTSEL0|=0x04;
6589                *AMAZON_GPIO_P1_ALTSEL1 &=(u32)~0x04;
6590                *AMAZON_GPIO_P1_OD|=0x04;
6591            break;
6592            
6593            
6594            
6595                //for clearEoC
6596#ifdef AMAZON_CLEAR_EOC
6597        case AMAZON_MEI_GET_EOC_LEN:
6598            while(1){
6599                current_clreoc = list_entry(clreoc_list.next, amazon_clreoc_pkt, list);
6600                if((current_clreoc->len)>0){
6601                    copy_to_user((char *)lon, (char*)(&(current_clreoc->len)), 4);
6602                    break;
6603                }
6604                else//wait for eoc data from higher layer
6605                    interruptible_sleep_on(&wait_queue_clreoc);
6606            }
6607            break;
6608        case AMAZON_MEI_GET_EOC_DATA:
6609            current_clreoc = list_entry(clreoc_list.next, amazon_clreoc_pkt, list);
6610            if((current_clreoc->len)>0){
6611                copy_to_user((char*)lon, (char*)(current_clreoc->command), current_clreoc->len);
6612                meierr=1;
6613                list_del(clreoc_list.next); //remove and add to end of list
6614                current_clreoc->len = 0;
6615                list_add_tail(&(current_clreoc->list), &clreoc_list);
6616            }
6617            else
6618                meierr=-1;
6619            break;
6620        case AMAZON_MEI_EOC_SEND:
6621            copy_from_user((char *)(&debugrdwr), (char *)lon, sizeof(debugrdwr));
6622            eoc_skb = dev_alloc_skb(debugrdwr.iCount*4);
6623            if(eoc_skb==NULL){
6624                printk("\n\nskb alloc fail");
6625                break;
6626            }
6627            
6628            eoc_skb->len=debugrdwr.iCount*4;
6629            memcpy(skb_put(eoc_skb, debugrdwr.iCount*4), (char *)debugrdwr.buffer, debugrdwr.iCount*4);
6630            
6631            ifx_push_eoc(eoc_skb); //pass data to higher layer
6632            break;
6633#endif //#ifdef AMAZON_CLEAR_EOC
6634        case AMAZON_MIB_LO_ATUC:
6635            do_gettimeofday(&time_now);
6636            if(lon&0x1){
6637                if((time_now.tv_sec-(mib_pflagtime.ATUC_PERF_LOSS_PTIME).tv_sec)>2){
6638                    current_intvl->AtucPerfLos++;
6639                    ATUC_PERF_LOSS++;
6640                    CurrStatus.adslAtucCurrStatus = 2;
6641                }
6642                (mib_pflagtime.ATUC_PERF_LOSS_PTIME).tv_sec = time_now.tv_sec;
6643            }
6644            if(lon&0x2){
6645                if((time_now.tv_sec-(mib_pflagtime.ATUC_PERF_LOFS_PTIME).tv_sec)>2){
6646                    current_intvl->AtucPerfLof++;
6647                    ATUC_PERF_LOFS++;
6648                    CurrStatus.adslAtucCurrStatus = 1;
6649                }
6650                (mib_pflagtime.ATUC_PERF_LOFS_PTIME).tv_sec = time_now.tv_sec;
6651            }
6652            if(!(lon&0x3))
6653                CurrStatus.adslAtucCurrStatus = 0;
6654            break;
6655        case AMAZON_MIB_LO_ATUR:
6656            do_gettimeofday(&time_now);
6657            if(lon&0x1){
6658                if((time_now.tv_sec-(mib_pflagtime.ATUR_PERF_LOSS_PTIME).tv_sec)>2){
6659                    current_intvl->AturPerfLos++;
6660                    ATUR_PERF_LOSS++;
6661                    CurrStatus.adslAturCurrStatus = 2;
6662            }
6663                (mib_pflagtime.ATUR_PERF_LOSS_PTIME).tv_sec = time_now.tv_sec;
6664            }
6665            if(lon&0x2){
6666                if((time_now.tv_sec-(mib_pflagtime.ATUR_PERF_LOFS_PTIME).tv_sec)>2){
6667                    current_intvl->AturPerfLof++;
6668                    ATUR_PERF_LOFS++;
6669                    CurrStatus.adslAturCurrStatus = 1;
6670                }
6671                (mib_pflagtime.ATUR_PERF_LOFS_PTIME).tv_sec = time_now.tv_sec;
6672            }
6673            if(lon&0x4){
6674                if((time_now.tv_sec-(mib_pflagtime.ATUR_PERF_LPR_PTIME).tv_sec)>2){
6675                    current_intvl->AturPerfLpr++;
6676                    ATUR_PERF_LPR++;
6677                    CurrStatus.adslAturCurrStatus = 3;
6678                }
6679                (mib_pflagtime.ATUR_PERF_LPR_PTIME).tv_sec = time_now.tv_sec;
6680            }
6681            if(!(lon&0x7))
6682                CurrStatus.adslAturCurrStatus = 0;
6683            break;
6684        case AMAZON_MEI_DOWNLOAD:
6685            // DMA the boot code page(s)
6686#ifdef AMAZON_MEI_DEBUG_ON
6687            printk("\n\n start download pages");
6688#endif
6689            for( boot_loop = 0; boot_loop < img_hdr->count; boot_loop++){
6690                if( img_hdr->page[boot_loop].p_size & BOOT_FLAG){
6691                    page_size = meiGetPage( boot_loop, GET_PROG, MAXSWAPSIZE, mei_arc_swap_buff, &dest_addr);
6692                    if( page_size > 0){
6693                        meiDMAWrite(dest_addr, mei_arc_swap_buff, page_size);
6694                    }
6695                }
6696                if( img_hdr->page[boot_loop].d_size & BOOT_FLAG){
6697                    page_size = meiGetPage( boot_loop, GET_DATA, MAXSWAPSIZE, mei_arc_swap_buff, &dest_addr);
6698                    if( page_size > 0){
6699                        meiDMAWrite( dest_addr, mei_arc_swap_buff, page_size);
6700                    }
6701                }
6702            }
6703#ifdef AMAZON_MEI_DEBUG_ON
6704            printk("\n\n pages downloaded");
6705#endif
6706            break;
6707        //509221:tc.chen start
6708                case AMAZON_MEI_DEBUG_MODE:
6709                        mei_debug_mode = lon;
6710            break;
6711        //509221:tc.chen end
6712        }
6713        return meierr;
6714}
6715
6716
6717////////////////////// Interrupt handler /////////////////////////////////////////////////////
6718static void mei_interrupt_arcmsgav(int,void *,struct pt_regs *);
6719static void mei_interrupt_arcmsgav(int int1, void * void0, struct pt_regs * regs)
6720{
6721        u32 scratch;
6722        u32 fetchpage;
6723        u32 size;
6724        u32 dest_addr;
6725    u32 temp;
6726    int i;
6727        
6728        meiDebugRead(ARC_MEI_MAILBOXR, &scratch, 1);
6729        if(scratch & OMB_CODESWAP_MESSAGE_MSG_TYPE_MASK)
6730        {
6731        if(showtime==1){
6732#ifdef AMAZON_MEI_DEBUG_ON
6733            printk("\n\n Code Swap Request After ShowTime !!!");
6734#endif
6735        }
6736        else{
6737#ifdef AMAZON_MEI_DEBUG_ON
6738// printk("\n\n Code Swap Request");
6739#endif
6740            fetchpage = scratch & ~OMB_CODESWAP_MESSAGE_MSG_TYPE_MASK;
6741            size = meiGetPage( fetchpage, GET_PROG, MAXSWAPSIZE, mei_arc_swap_buff, &dest_addr);
6742            if( size > 0)
6743            {
6744#ifdef AMAZON_MEI_DEBUG_ON
6745// printk(" : prom page num %d",fetchpage);
6746#endif
6747                meiDMAWrite( dest_addr, mei_arc_swap_buff, size);
6748            }
6749
6750                    size = meiGetPage( fetchpage, GET_DATA, MAXSWAPSIZE, mei_arc_swap_buff, &dest_addr);
6751            if( size > 0)
6752            {
6753#ifdef AMAZON_MEI_DEBUG_ON
6754// printk(" : data page num %d",fetchpage);
6755#endif
6756                meiDMAWrite( dest_addr, mei_arc_swap_buff, size);
6757            }
6758        }
6759                        // Notify arc that mailbox read complete
6760         meiLongwordWrite(ARC_TO_MEI_INT, ARC_TO_MEI_MSGAV);
6761
6762        // Tell ARC Codeswap is done
6763        meiLongwordWrite(MEI_TO_ARC_INT, MEI_TO_ARC_CS_DONE);
6764        asm("SYNC");
6765        i=0;
6766        while(i<WHILE_DELAY){
6767            meiLongwordRead(MEI_TO_ARC_INT, &temp);
6768            if((temp & MEI_TO_ARC_CS_DONE) ==0){
6769#ifdef AMAZON_MEI_DEBUG_ON
6770// printk("\n\n Code Swap Done");
6771#endif
6772                break;
6773            }
6774            i++;
6775            if(i==WHILE_DELAY){
6776#ifdef AMAZON_MEI_DEBUG_ON
6777                printk("\n\n MEI_TO_ARC_CS_DONE not cleared by ARC");
6778                //509221:tc.chen start
6779                if (!mei_debug_mode)
6780                {
6781                    //printk("Reset Arc!\n");
6782                    //printk("AdslInitStatsData.FullInitializationCount++\n");
6783                    AdslInitStatsData.FullInitializationCount++;
6784                    if (!showtime)
6785                    {
6786                        //printk("AdslInitStatsData.FailedFullInitializationCount++\n");
6787                        AdslInitStatsData.FailedFullInitializationCount++;
6788                        //printk("AdslInitStatsData.LINIT_Errors++\n");
6789                        AdslInitStatsData.LINIT_Errors++;
6790                    }
6791
6792                    wake_up_interruptible(&wait_queue_codeswap); // wait up ioctl reboot
6793                }
6794                //509221:tc.chen end
6795#endif
6796            }
6797        }
6798        }
6799        else{ // normal message
6800// printk("\n\n interrupt");
6801                        meiMailboxRead(RxMessage, MSG_LENGTH);
6802                        if(cmv_waiting==1){
6803                                arcmsgav=1;
6804                                cmv_waiting=0;
6805                                wake_up_interruptible(&wait_queue_arcmsgav);
6806                        }
6807                        else{
6808                                indicator_count++;
6809                                memcpy((char *)Recent_indicator, (char *)RxMessage, MSG_LENGTH *2);
6810#ifdef ARC_READY_ACK
6811                if(((RxMessage[0]&0xff0)>>4)==D2H_AUTONOMOUS_MODEM_READY_MSG){ //check ARC ready message
6812                    
6813#ifdef LOCK_RETRY
6814                    if (reboot_lock)
6815                    {
6816                        reboot_lock = 0;
6817                        up(&mei_sema); // allow cmv access
6818                    }
6819#else
6820                        up(&mei_sema); // allow cmv access
6821#endif
6822                    reboot_flag=1;
6823//#ifdef ADSL_LED_SUPPORT
6824#if 0
6825                    led_support_check=1;//adsl led for 1.1.2.7.1.1
6826                    adsl_led_flash();//adsl led for 1.1.2.7.1.1
6827#endif
6828                    wake_up_interruptible(&wait_queue_reboot); // wait up ioctl reboot
6829                }
6830#endif
6831                  }
6832        }
6833// meiLongwordWrite(ARC_TO_MEI_INT, ARC_TO_MEI_MSGAV);
6834    mask_and_ack_amazon_irq(AMAZON_MEI_INT);
6835        return;
6836}
6837
6838// 603221:tc.chen start
6839////////////////////////hdlc ////////////////
6840
6841// get hdlc status
6842static unsigned int ifx_me_hdlc_status(void)
6843{
6844    u16 CMVMSG[MSG_LENGTH];
6845    int ret;
6846
6847    if (showtime!=1)
6848        return -ENETRESET;
6849    
6850    makeCMV_local(H2D_CMV_READ, STAT, 14, 0, 1, NULL,CMVMSG); //Get HDLC status
6851    ret = mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, CMVMSG);
6852    if (ret != 0)
6853    {
6854        return -EIO;
6855    }
6856    return CMVMSG[4]&0x0F;
6857}
6858
6859int ifx_me_is_resloved(int status)
6860{
6861    u16 CMVMSG[MSG_LENGTH];
6862    int ret;
6863    
6864    if (status == ME_HDLC_MSG_QUEUED || status == ME_HDLC_MSG_SENT)
6865        return ME_HDLC_UNRESOLVED;
6866    if (status == ME_HDLC_IDLE)
6867    {
6868        makeCMV_local(H2D_CMV_READ, CNTL, 2, 0, 1, NULL,CMVMSG); //Get ME-HDLC Control
6869        ret = mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, CMVMSG);
6870        if (ret != 0)
6871        {
6872            return IFX_POP_EOC_FAIL;
6873        }
6874        if (CMVMSG[4]&(1<<0))
6875        {
6876            return ME_HDLC_UNRESOLVED;
6877        }
6878        
6879    }
6880    return ME_HDLC_RESOLVED;
6881}
6882
6883int _ifx_me_hdlc_send(unsigned char *hdlc_pkt,int len,int max_length)
6884{
6885    int ret;
6886    u16 CMVMSG[MSG_LENGTH];
6887    u16 data=0;
6888    u16 pkt_len=len;
6889    if (pkt_len > max_length)
6890    {
6891        printk("Exceed maximum eoc message length\n");
6892        return -ENOBUFS;
6893    }
6894    //while(pkt_len > 0)
6895    {
6896        makeCMV_local(H2D_CMV_WRITE, INFO, 81, 0, (pkt_len+1)/2,(u16 *)hdlc_pkt,CMVMSG); //Write clear eoc message to ARC
6897        ret = mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, CMVMSG);
6898        if (ret != 0)
6899        {
6900            return -EIO;
6901        }
6902        
6903        makeCMV_local(H2D_CMV_WRITE, INFO, 83, 2, 1,&pkt_len,CMVMSG); //Update tx message length
6904        ret = mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, CMVMSG);
6905        if (ret != 0)
6906        {
6907            return -EIO;
6908        }
6909        
6910        data = (1<<0);
6911        makeCMV_local(H2D_CMV_WRITE, CNTL, 2, 0, 1,&data,CMVMSG); //Start to send
6912        ret = mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, CMVMSG);
6913        if (ret != 0)
6914        {
6915            return -EIO;
6916        }
6917        return 0;
6918    }
6919}
6920
6921static int ifx_me_hdlc_send(unsigned char *hdlc_pkt,int hdlc_pkt_len)
6922{
6923    int hdlc_status=0;
6924    u16 CMVMSG[MSG_LENGTH];
6925    int max_hdlc_tx_length=0,ret=0,retry=0;
6926    
6927    while(retry<10)
6928    {
6929        hdlc_status = ifx_me_hdlc_status();
6930        if (ifx_me_is_resloved(hdlc_status)==ME_HDLC_RESOLVED) // arc ready to send HDLC message
6931        {
6932            makeCMV_local(H2D_CMV_READ, INFO, 83, 0, 1, NULL,CMVMSG); //Get Maximum Allowed HDLC Tx Message Length
6933            ret = mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, CMVMSG);
6934            if (ret != 0)
6935            {
6936                return -EIO;
6937            }
6938            max_hdlc_tx_length = CMVMSG[4];
6939            ret = _ifx_me_hdlc_send(hdlc_pkt,hdlc_pkt_len,max_hdlc_tx_length);
6940            return ret;
6941        }
6942        set_current_state(TASK_INTERRUPTIBLE);
6943        schedule_timeout(10);
6944    }
6945    return -EBUSY;
6946}
6947
6948int ifx_mei_hdlc_read(char *hdlc_pkt,int max_hdlc_pkt_len)
6949{
6950    u16 CMVMSG[MSG_LENGTH];
6951    int msg_read_len,ret=0,pkt_len=0,retry = 0;
6952        
6953    while(retry<10)
6954    {
6955        ret = ifx_me_hdlc_status();
6956        if (ret == ME_HDLC_RESP_RCVD)
6957        {
6958            int current_size=0;
6959            makeCMV_local(H2D_CMV_READ, INFO, 83, 3, 1, NULL,CMVMSG); //Get EoC packet length
6960            ret = mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, CMVMSG);
6961            if (ret != 0)
6962            {
6963                return -EIO;
6964            }
6965    
6966            pkt_len = CMVMSG[4];
6967            if (pkt_len > max_hdlc_pkt_len)
6968            {
6969                ret = -ENOMEM;
6970                goto error;
6971            }
6972            while( current_size < pkt_len)
6973            {
6974                if (pkt_len - current_size >(MSG_LENGTH*2-8))
6975                    msg_read_len = (MSG_LENGTH*2-8);
6976                else
6977                    msg_read_len = pkt_len - (current_size);
6978                makeCMV_local(H2D_CMV_READ, INFO, 82, 0 + (current_size/2), (msg_read_len+1)/2, NULL,CMVMSG); //Get hdlc packet
6979                ret = mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, CMVMSG);
6980                if (ret != 0)
6981                {
6982                    goto error;
6983                }
6984                memcpy(hdlc_pkt+current_size,&CMVMSG[4],msg_read_len);
6985                current_size +=msg_read_len;
6986            }
6987            ret = current_size;
6988            break;
6989        }else
6990        {
6991            ret = -ENODATA;
6992        }
6993        
6994        retry++;
6995        set_current_state(TASK_INTERRUPTIBLE);
6996        schedule_timeout(10);
6997        
6998    }
6999    return ret;
7000error:
7001    
7002    return ret;
7003}
7004
7005////////////////////////hdlc ////////////////
7006// 603221:tc.chen end
7007
7008/////////////////////// clearEoC, int ifx_pop_eoc(sk_buff * pkt) //////////
7009int ifx_pop_eoc(struct sk_buff * pkt);
7010int ifx_pop_eoc(struct sk_buff * pkt)
7011{
7012    amazon_clreoc_pkt * current;
7013    if(showtime!=1){
7014        dev_kfree_skb(pkt);
7015        return IFX_POP_EOC_FAIL;
7016    }
7017    if((pkt->len)>clreoc_max_tx_len){
7018        dev_kfree_skb(pkt);
7019        return IFX_POP_EOC_FAIL;
7020    }
7021    current = list_entry(clreoc_list.next, amazon_clreoc_pkt, list);
7022    while(1){
7023        if(current->len==0){
7024            memcpy(current->command, pkt->data, pkt->len);
7025            current->len=pkt->len;
7026            break;
7027        }
7028        else{
7029            if((current->list).next==&clreoc_list){
7030                dev_kfree_skb(pkt);
7031                return IFX_POP_EOC_FAIL; //buffer full
7032            }
7033            current = list_entry((current->list).next,amazon_clreoc_pkt, list);
7034        }
7035    }
7036    wake_up_interruptible(&wait_queue_clreoc);
7037    
7038    dev_kfree_skb(pkt);
7039    return IFX_POP_EOC_DONE;
7040}
7041/* this is used in circular fifo mode */
7042/*
7043int ifx_pop_eoc(sk_buff * pkt);
7044int ifx_pop_eoc(sk_buff * pkt)
7045{
7046    int buff_space,i;
7047    if(showtime!=1)
7048        return IFX_POP_EOC_FAIL;
7049    
7050    if(clreoc_wr>=clreoc_rd)
7051        buff_space = (MEI_CLREOC_BUFF_SIZE-1)-(clreoc_wr - clreoc_rd);
7052    else
7053        buff_space = clreoc_rd - clreoc_wr - 1;
7054    if((pkt->len)>buff_space)
7055        return IFX_POP_EOC_FAIL;
7056                    
7057    if((clreoc_wr+pkt->len)>MEI_CLREOC_BUFF_SIZE){
7058        memcpy((clreoc+clreoc_wr), pkt->data, ((clreoc_wr+pkt->len)-MEI_CLREOC_BUFF_SIZE+1));
7059        memcpy(clreoc, (pkt->data)+((clreoc_wr+pkt->len)-MEI_CLREOC_BUFF_SIZE+1), (pkt->len)-((clreoc_wr+pkt->len)-MEI_CLREOC_BUFF_SIZE+1));
7060        clreoc_wr=(clreoc_wr+pkt->len)-MEI_CLREOC_BUFF_SIZE;
7061    }
7062    else{
7063        memcpy((clreoc+clreoc_wr), pkt->data, pkt->len);
7064        if((clreoc_wr+pkt->len)=MEI_CLREOC_BUFF_SIZE)
7065            clreoc_wr=0;
7066        else
7067            clreoc_wr+=pkt->len;
7068    }
7069    wake_up_interruptible(&wait_queue_clreoc);
7070    return IFX_POP_EOC_DONE;
7071}
7072*/
7073
7074
7075////////////////////////////////////////////////////////////////////////////
7076//int amazon_mei_init_module (void);
7077//void amazon_mei_cleanup_module (void);
7078//int __init init_module (void);
7079//void __exit cleanup_module (void);
7080
7081int __init amazon_mei_init_module(void)
7082//int __init init_module(void)
7083{
7084        struct proc_dir_entry *entry;
7085        int i;
7086    
7087//dying gasp-start
7088#ifdef IFX_DYING_GASP
7089
7090//000003:fchang Start
7091#ifdef CONFIG_CPU_AMAZON_E
7092        //GPIO31 :dying gasp event indication
7093        // (1) logic high: dying gasp event is false (default)
7094        // (2) logic low: dying gasp event is true
7095            CLEAR_BIT((*((volatile u32 *)0xB0100B18)), 0x4);
7096            CLEAR_BIT((*((volatile u32 *)0xB0100B1c)), 0x4);
7097            CLEAR_BIT((*((volatile u32 *)0xB0100B20)), 0x4);
7098            SET_BIT((*((volatile u32 *)0xB0100B24)), 0x4);
7099            asm("SYNC");
7100#else //000003:fchang End
7101
7102        //GPIO31 :dying gasp event indication
7103        // (1) logic high: dying gasp event is false (default)
7104        // (2) logic low: dying gasp event is true
7105            CLEAR_BIT((*((volatile u32 *)0xB0100B48)), 0x8000);
7106            CLEAR_BIT((*((volatile u32 *)0xB0100B4C)), 0x8000);
7107            CLEAR_BIT((*((volatile u32 *)0xB0100B50)), 0x8000);
7108            SET_BIT((*((volatile u32 *)0xB0100B54)), 0x8000);
7109#if 0
7110//warning-led-start
7111//GPIO 22
7112            SET_BIT ((*((volatile u32 *)0xB0100B48)), 0x40);
7113            CLEAR_BIT((*((volatile u32 *)0xB0100B4C)), 0x40);
7114            CLEAR_BIT((*((volatile u32 *)0xB0100B50)), 0x40);
7115            SET_BIT((*((volatile u32 *)0xB0100B54)), 0x40);
7116            CLEAR_BIT((*((volatile u32 *)0xB0100B40)), 0x40); //GPIO ON
7117            printk("LED ON ON ON ON ON ON.....");
7118//warning-led-end
7119#endif
7120            asm("SYNC");
7121#endif //000003:fchang
7122
7123#endif //IFX_DYING_GASP
7124//dying gasp -end
7125        
7126    
7127        reg_entry_t regs_temp[PROC_ITEMS] = // Items being debugged
7128        {
7129        /* { flag, name, description } */
7130    { &arcmsgav, "arcmsgav", "arc to mei message ", 0 },
7131            { &cmv_reply, "cmv_reply", "cmv needs reply", 0},
7132            { &cmv_waiting, "cmv_waiting", "waiting for cmv reply from arc", 0},
7133            { &indicator_count, "indicator_count", "ARC to MEI indicator count", 0},
7134            { &cmv_count, "cmv_count", "MEI to ARC CMVs", 0},
7135            { &reply_count, "reply_count", "ARC to MEI Reply", 0},
7136            { (int *)Recent_indicator, "Recent_indicator", "most recent indicator", 0},
7137        { (int *)8, "version", "version of firmware", 0},
7138        };
7139        memcpy((char *)regs, (char *)regs_temp, sizeof(regs_temp));
7140
7141
7142        //sema_init(&mei_sema, 0); // semaphore initialization, mutex
7143        sema_init(&mei_sema, 1); // semaphore initialization, mutex
7144    
7145        init_waitqueue_head(&wait_queue_arcmsgav); // for ARCMSGAV
7146    init_waitqueue_head(&wait_queue_codeswap); // for codeswap daemon
7147    init_waitqueue_head(&wait_queue_mibdaemon); // for mib daemon
7148    init_waitqueue_head(&wait_queue_reboot); // for ioctl reboot
7149    init_waitqueue_head(&wait_queue_clreoc); // for clreoc_wr function
7150    init_waitqueue_head(&wait_queue_loop_diagnostic); // for loop diagnostic function
7151#ifdef ADSL_LED_SUPPORT
7152    init_waitqueue_head(&wait_queue_led); // adsl led for led function
7153    init_waitqueue_head(&wait_queue_led_polling); // adsl led for led function
7154    led_task.routine = adsl_led_flash_task; // adsl led for led function
7155    led_poll_init(); // adsl led for led function
7156#endif //ADSL_LED_SUPPORT
7157#ifdef IFX_DYING_GASP
7158    init_waitqueue_head(&wait_queue_dying_gasp); // IFX_DYING_GASP
7159    lop_poll_init(); // IFX_DYING_GASP
7160#endif //IFX_DYING_GASP
7161 
7162    init_waitqueue_head(&wait_queue_uas_poll);//joelin 04/16/2005
7163    unavailable_seconds_poll_init();//joelin 04/16/2005
7164    memset(&mib_pflagtime, 0, (sizeof(mib_flags_pretime)));
7165    
7166    // initialize link list for intervals
7167    mei_mib = (amazon_mei_mib *)kmalloc((sizeof(amazon_mei_mib)*INTERVAL_NUM), GFP_KERNEL);
7168    if(mei_mib == NULL){
7169#ifdef AMAZON_MEI_DEBUG_ON
7170        printk("kmalloc error for amazon_mei_mib\n\n");
7171#endif
7172        return -1;
7173    }
7174    memset(mei_mib, 0, (sizeof(amazon_mei_mib)*INTERVAL_NUM));
7175    INIT_LIST_HEAD(&interval_list);
7176    for(i=0;i<INTERVAL_NUM;i++)
7177        list_add_tail(&(mei_mib[i].list), &interval_list);
7178    current_intvl = list_entry(interval_list.next, amazon_mei_mib, list);
7179    do_gettimeofday(&(current_intvl->start_time));
7180    // initialize clreoc list
7181    clreoc_pkt = (amazon_clreoc_pkt *)kmalloc((sizeof(amazon_clreoc_pkt)*CLREOC_BUFF_SIZE), GFP_KERNEL);
7182    if(clreoc_pkt == NULL){
7183#ifdef AMAZON_MEI_DEBUG_ON
7184        printk("kmalloc error for clreoc_pkt\n\n");
7185#endif
7186        return -1;
7187    }
7188    memset(clreoc_pkt, 0, (sizeof(amazon_clreoc_pkt)*CLREOC_BUFF_SIZE));
7189    INIT_LIST_HEAD(&clreoc_list);
7190    for(i=0;i<CLREOC_BUFF_SIZE;i++)
7191        list_add_tail(&(clreoc_pkt[i].list), &clreoc_list);
7192        
7193        memset(&AdslInitStatsData, 0, sizeof(AdslInitStatsData));
7194        if (register_chrdev(major, "amazon_mei", &mei_operations)!=0) {
7195#ifdef AMAZON_MEI_DEBUG_ON
7196                printk("\n\n unable to register major for amazon_mei!!!");
7197#endif
7198                return -1;
7199        }
7200        if (request_irq(AMAZON_MEI_INT, mei_interrupt_arcmsgav,0, "amazon_mei_arcmsgav", NULL)!=0){
7201#ifdef AMAZON_MEI_DEBUG_ON
7202                printk("\n\n unable to register irq for amazon_mei!!!");
7203#endif
7204                return -1;
7205        }
7206// disable_irq(AMAZON_MEI_INT);
7207    enable_irq(AMAZON_MEI_INT);
7208        // procfs
7209        meidir=proc_mkdir(MEI_DIRNAME, &proc_root);
7210        if ( meidir == NULL) {
7211#ifdef AMAZON_MEI_DEBUG_ON
7212        printk(KERN_ERR ": can't create /proc/" MEI_DIRNAME "\n\n");
7213#endif
7214        return(-ENOMEM);
7215        }
7216
7217        for(i=0;i<NUM_OF_REG_ENTRY;i++) {
7218        entry = create_proc_entry(regs[i].name,
7219                S_IWUSR |S_IRUSR | S_IRGRP | S_IROTH,
7220                meidir);
7221        if(entry) {
7222            regs[i].low_ino = entry->low_ino;
7223            entry->proc_fops = &proc_operations;
7224        } else {
7225#ifdef AMAZON_MEI_DEBUG_ON
7226            printk( KERN_ERR
7227                ": can't create /proc/" MEI_DIRNAME
7228                "/%s\n\n", regs[i].name);
7229#endif
7230            return(-ENOMEM);
7231        }
7232        }
7233        ///////////////////////////////// register net device ////////////////////////////
7234        if(register_netdev(&phy_mei_net)!=0){
7235#ifdef AMAZON_MEI_DEBUG_ON
7236                printk("\n\n Register phy Device Failed.");
7237#endif
7238                return -1;
7239        }
7240/*
7241    if(register_netdev(&interleave_mei_net)!=0){
7242                printk("\n\n Register interleave Device Failed.");
7243                return -1;
7244        }
7245    if(register_netdev(&fast_mei_net)!=0){
7246                printk("\n\n Register fast Device Failed.");
7247                return -1;
7248        }
7249*/
7250#ifdef DFE_LOOPBACK
7251    mei_arc_swap_buff = (u32 *)kmalloc(MAXSWAPSIZE*4, GFP_KERNEL);
7252    if (mei_arc_swap_buff){
7253#ifdef ARC_READY_ACK
7254        if(down_interruptible(&mei_sema)) //disable CMV access until ARC ready
7255        {
7256                    return -ERESTARTSYS;
7257        }
7258#ifdef LOCK_RETRY
7259        reboot_lock = 1;
7260#endif
7261#endif
7262        meiForceRebootAdslModem();
7263        kfree(mei_arc_swap_buff);
7264    }else{
7265#ifdef AMAZON_MEI_DEBUG_ON
7266        printk("cannot load image: no memory\n\n");
7267#endif
7268    }
7269#endif
7270#ifdef IFX_SMALL_FOOTPRINT
7271    mib_poll_init();
7272#endif
7273        return 0;
7274}
7275
7276void __exit amazon_mei_cleanup_module(void)
7277//void __exit cleanup_module(void)
7278{
7279        int i;
7280#ifdef ADSL_LED_SUPPORT
7281        stop_led_module=1; //wake up and clean led module
7282        led_support_check=0;//joelin , clear task
7283        showtime=0;//joelin,clear task
7284        //CLEAR_BIT((*((volatile u32 *)0xB0100B40)), 0x40); //Warning LED GPIO ON
7285        firmware_support_led=0;//joelin ,clear task
7286        wake_up_interruptible(&wait_queue_led); //wake up and clean led module
7287        wake_up_interruptible(&wait_queue_led_polling); //wake up and clean led module
7288#endif
7289        for(i=0;i<NUM_OF_REG_ENTRY;i++)
7290        remove_proc_entry(regs[i].name, meidir);
7291        remove_proc_entry(MEI_DIRNAME, &proc_root);
7292    
7293        disable_irq(AMAZON_MEI_INT);
7294        free_irq(AMAZON_MEI_INT, NULL);
7295        unregister_chrdev(major, "amazon_mei");
7296
7297        kfree(mei_mib);
7298    kfree(clreoc_pkt);
7299    
7300    kfree(phy_mei_net.priv);
7301        unregister_netdev(&phy_mei_net);
7302    
7303        return;
7304}
7305#ifdef IFX_SMALL_FOOTPRINT
7306
7307
7308int adsl_mib_poll(void *unused)
7309{
7310    struct task_struct *tsk = current;
7311    int i=0;
7312    struct timeval time_now;
7313    struct timeval time_fini;
7314    u32 temp,temp2;
7315
7316    amazon_mei_mib * mib_ptr;
7317// u16 buff[MSG_LENGTH]__attribute__ ((aligned(4)));
7318    u16 * data=NULL; //used in makeCMV, to pass in payload when CMV set, ignored when CMV read.
7319
7320    daemonize();
7321    strcpy(tsk->comm, "kmibpoll");
7322    sigfillset(&tsk->blocked);
7323
7324    printk("Inside mib poll loop ...\n");
7325    i=0;
7326    while(1){
7327        if(i<MIB_INTERVAL)
7328            interruptible_sleep_on_timeout(&wait_queue_mibdaemon, ((MIB_INTERVAL-i)/(1000/HZ)));
7329        i=0;
7330        if(showtime==1){
7331// printk("\n\n update mib");
7332                    
7333            do_gettimeofday(&time_now);
7334            if(time_now.tv_sec - current_intvl->start_time.tv_sec>=900){
7335                if(current_intvl->list.next!=&interval_list){
7336                    current_intvl = list_entry(current_intvl->list.next, amazon_mei_mib, list);
7337                    do_gettimeofday(&(current_intvl->start_time));
7338                }
7339                else{
7340                    mib_ptr = list_entry(interval_list.next, amazon_mei_mib, list);
7341                    list_del(interval_list.next);
7342                    memset(mib_ptr, 0, sizeof(amazon_mei_mib));
7343                    list_add_tail(&(mib_ptr->list), &interval_list);
7344                    if(current_intvl->list.next==&interval_list)
7345#ifdef AMAZON_MEI_DEBUG_ON
7346                    printk("\n\nlink list error");
7347#endif
7348                    current_intvl = list_entry(current_intvl->list.next, amazon_mei_mib, list);
7349                    do_gettimeofday(&(current_intvl->start_time));
7350                }
7351            }
7352                    
7353            if(down_interruptible(&mei_sema))
7354                      return -ERESTARTSYS;
7355/*
7356            ATUC_PERF_LO_FLAG_MAKECMV;
7357            if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7358#ifdef AMAZON_MEI_DEBUG_ON
7359                printk("\n\nCMV fail, Group 7 Address 0 Index 0");
7360#endif
7361            }
7362            else{
7363                if(RxMessage[4]&PLAM_LOS_FailureBit){
7364                    current_intvl->AtucPerfLos++;
7365                    ATUC_PERF_LOSS++;
7366                    CurrStatus.adslAtucCurrStatus = 2;
7367                }
7368                if(RxMessage[4]&PLAM_LOF_FailureBit){
7369                    current_intvl->AtucPerfLof++;
7370                    ATUC_PERF_LOFS++;
7371                    CurrStatus.adslAtucCurrStatus = 1;
7372                }
7373                if(!(RxMessage[4]&(PLAM_LOS_FailureBit|PLAM_LOF_FailureBit)))
7374                    CurrStatus.adslAtucCurrStatus = 0;
7375                }
7376*/
7377                
7378                if(showtime!=1)
7379                    goto mib_poll_end;
7380                ATUC_PERF_ESS_FLAG_MAKECMV;
7381                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7382#ifdef AMAZON_MEI_DEBUG_ON
7383                    printk("\n\nCMV fail, Group 7 Address 7 Index 0");
7384#endif
7385                }
7386                else{
7387                        temp = RxMessage[4]-mib_pread.ATUC_PERF_ESS;
7388                        if(temp>=0){
7389                            current_intvl->AtucPerfEs+=temp;
7390                            ATUC_PERF_ESS+=temp;
7391                            mib_pread.ATUC_PERF_ESS = RxMessage[4];
7392                        }
7393                        else{
7394                            current_intvl->AtucPerfEs+=0xffff-mib_pread.ATUC_PERF_ESS+RxMessage[4];
7395                            ATUC_PERF_ESS+=0xffff-mib_pread.ATUC_PERF_ESS+RxMessage[4];
7396                            mib_pread.ATUC_PERF_ESS = RxMessage[4];
7397                    }
7398                }
7399/*
7400                ATUR_PERF_LO_FLAG_MAKECMV;
7401                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7402#ifdef AMAZON_MEI_DEBUG_ON
7403                    printk("\n\nCMV fail, Group 7 Address 1 Index 0");
7404#endif
7405                }
7406                else{
7407                    if(RxMessage[4]&PLAM_LOS_FailureBit){
7408                        current_intvl->AturPerfLos++;
7409                        ATUR_PERF_LOSS++;
7410                        CurrStatus.adslAturCurrStatus = 2;
7411                    }
7412                    if(RxMessage[4]&PLAM_LOF_FailureBit){
7413                        current_intvl->AturPerfLof++;
7414                        ATUR_PERF_LOFS++;
7415                        CurrStatus.adslAturCurrStatus = 1;
7416                    }
7417                    if(RxMessage[4]&PLAM_LPR_FailureBit){
7418                        current_intvl->AturPerfLpr++;
7419                        ATUR_PERF_LPR++;
7420                        CurrStatus.adslAturCurrStatus = 3;
7421                    }
7422                    if(!(RxMessage[4]&(PLAM_LOS_FailureBit|PLAM_LOF_FailureBit|PLAM_LPR_FailureBit)))
7423                        CurrStatus.adslAturCurrStatus = 0;
7424                }
7425*/
7426                if(showtime!=1)
7427                    goto mib_poll_end;
7428                ATUR_PERF_ESS_FLAG_MAKECMV;
7429                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7430#ifdef AMAZON_MEI_DEBUG_ON
7431                    printk("\n\nCMV fail, Group 7 Address 33 Index 0");
7432#endif
7433                }
7434                else{
7435                        temp = RxMessage[4]-mib_pread.ATUR_PERF_ESS;
7436                        if(temp>=0){
7437                            current_intvl->AturPerfEs+=temp;
7438                            ATUR_PERF_ESS+=temp;
7439                            mib_pread.ATUR_PERF_ESS = RxMessage[4];
7440                        }
7441                        else{
7442                            current_intvl->AturPerfEs+=0xffff-mib_pread.ATUR_PERF_ESS+RxMessage[4];
7443                            ATUR_PERF_ESS+= 0xffff-mib_pread.ATUR_PERF_ESS+RxMessage[4];
7444                            mib_pread.ATUR_PERF_ESS=RxMessage[4];
7445                    }
7446                }
7447                if(showtime!=1)
7448                    goto mib_poll_end;
7449                // to update rx/tx blocks
7450                ATUR_CHAN_RECV_BLK_FLAG_MAKECMV_LSW;
7451                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7452#ifdef AMAZON_MEI_DEBUG_ON
7453                    printk("\n\nCMV fail, Group 7 Address 20 Index 0");
7454#endif
7455                }
7456                else{
7457                        temp = RxMessage[4];
7458                }
7459                if(showtime!=1)
7460                    goto mib_poll_end;
7461                ATUR_CHAN_RECV_BLK_FLAG_MAKECMV_MSW;
7462                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7463#ifdef AMAZON_MEI_DEBUG_ON
7464                    printk("\n\nCMV fail, Group 7 Address 21 Index 0");
7465#endif
7466                }
7467                else{
7468                        temp2 = RxMessage[4];
7469                    }
7470                    if((temp + (temp2<<16) - mib_pread.ATUR_CHAN_RECV_BLK)>=0){
7471                        current_intvl->AturChanPerfRxBlk+=temp + (temp2<<16) - mib_pread.ATUR_CHAN_RECV_BLK;
7472                        ATUR_CHAN_RECV_BLK+=temp + (temp2<<16) - mib_pread.ATUR_CHAN_RECV_BLK;
7473                        mib_pread.ATUR_CHAN_RECV_BLK = temp + (temp2<<16);
7474                    }
7475                    else{
7476                        current_intvl->AturChanPerfRxBlk+=0xffffffff - mib_pread.ATUR_CHAN_RECV_BLK +(temp + (temp2<<16));
7477                        ATUR_CHAN_RECV_BLK+=0xffffffff - mib_pread.ATUR_CHAN_RECV_BLK +(temp + (temp2<<16));
7478                        mib_pread.ATUR_CHAN_RECV_BLK = temp + (temp2<<16);
7479                }
7480                current_intvl->AturChanPerfTxBlk = current_intvl->AturChanPerfRxBlk;
7481                ATUR_CHAN_TX_BLK = ATUR_CHAN_RECV_BLK;
7482/*
7483                ATUR_CHAN_TX_BLK_FLAG_MAKECMV_LSW;
7484                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS)
7485                    printk("\n\nCMV fail, Group 7 Address 20 Index 0");
7486                else{
7487                    if(RxMessage[4]){
7488                        current_intvl->AturChanPerfTxBlk+=RxMessage[4];
7489                        ATUR_CHAN_TX_BLK+=RxMessage[4];
7490                    }
7491                }
7492                ATUR_CHAN_TX_BLK_FLAG_MAKECMV_MSW;
7493                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS)
7494                    printk("\n\nCMV fail, Group 7 Address 21 Index 0");
7495                else{
7496                    if(RxMessage[4]){
7497                        current_intvl->AturChanPerfTxBlk+=(int)((RxMessage[4])<<16);
7498                        ATUR_CHAN_TX_BLK+=(int)((RxMessage[4])<<16);
7499                    }
7500                }
7501*/
7502                if(chantype.interleave == 1){
7503                if(showtime!=1)
7504                    goto mib_poll_end;
7505                    ATUR_CHAN_CORR_BLK_FLAG_MAKECMV_INTL;
7506                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7507#ifdef AMAZON_MEI_DEBUG_ON
7508                        printk("\n\nCMV fail, Group 7 Address 3 Index 0");
7509#endif
7510                    }
7511                    else{
7512                            temp = RxMessage[4] - mib_pread.ATUR_CHAN_CORR_BLK_INTL;
7513                            if(temp>=0){
7514                                current_intvl->AturChanPerfCorrBlk+=temp;
7515                                ATUR_CHAN_CORR_BLK+=temp;
7516                                mib_pread.ATUR_CHAN_CORR_BLK_INTL = RxMessage[4];
7517                            }
7518                            else{
7519                                current_intvl->AturChanPerfCorrBlk+=0xffff - mib_pread.ATUR_CHAN_CORR_BLK_INTL +RxMessage[4];
7520                                ATUR_CHAN_CORR_BLK+=0xffff - mib_pread.ATUR_CHAN_CORR_BLK_INTL +RxMessage[4];
7521                                mib_pread.ATUR_CHAN_CORR_BLK_INTL = RxMessage[4];
7522                        }
7523                    }
7524                }
7525                else if(chantype.fast == 1){
7526                if(showtime!=1)
7527                    goto mib_poll_end;
7528                    ATUR_CHAN_CORR_BLK_FLAG_MAKECMV_FAST;
7529                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7530#ifdef AMAZON_MEI_DEBUG_ON
7531                        printk("\n\nCMV fail, Group 7 Address 3 Index 1");
7532#endif
7533                    }
7534                    else{
7535                            temp = RxMessage[4] - mib_pread.ATUR_CHAN_CORR_BLK_FAST;
7536                            if(temp>=0){
7537                                current_intvl->AturChanPerfCorrBlk+=temp;
7538                                ATUR_CHAN_CORR_BLK+=temp;
7539                                mib_pread.ATUR_CHAN_CORR_BLK_FAST = RxMessage[4];
7540                            }
7541                            else{
7542                                current_intvl->AturChanPerfCorrBlk+=0xffff - mib_pread.ATUR_CHAN_CORR_BLK_FAST + RxMessage[4];
7543                                ATUR_CHAN_CORR_BLK+=0xffff - mib_pread.ATUR_CHAN_CORR_BLK_FAST + RxMessage[4];
7544                                mib_pread.ATUR_CHAN_CORR_BLK_FAST = RxMessage[4];
7545                        }
7546                    }
7547                }
7548                
7549                if(chantype.interleave == 1){
7550                if(showtime!=1)
7551                    goto mib_poll_end;
7552                    ATUR_CHAN_UNCORR_BLK_FLAG_MAKECMV_INTL;
7553                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7554#ifdef AMAZON_MEI_DEBUG_ON
7555                        printk("\n\nCMV fail, Group 7 Address 2 Index 0");
7556#endif
7557                    }
7558                    else{
7559                            temp = RxMessage[4] - mib_pread.ATUR_CHAN_UNCORR_BLK_INTL;
7560                            if(temp>=0){
7561                                current_intvl->AturChanPerfUncorrBlk+=temp;
7562                                ATUR_CHAN_UNCORR_BLK+=temp;
7563                                mib_pread.ATUR_CHAN_UNCORR_BLK_INTL = RxMessage[4];
7564                            }
7565                            else{
7566                                current_intvl->AturChanPerfUncorrBlk+=0xffff - mib_pread.ATUR_CHAN_UNCORR_BLK_INTL + RxMessage[4];
7567                                ATUR_CHAN_UNCORR_BLK+=0xffff - mib_pread.ATUR_CHAN_UNCORR_BLK_INTL + RxMessage[4];
7568                                mib_pread.ATUR_CHAN_UNCORR_BLK_INTL = RxMessage[4];
7569                        }
7570                    }
7571                }
7572                else if(chantype.fast == 1){
7573                if(showtime!=1)
7574                    goto mib_poll_end;
7575                    ATUR_CHAN_UNCORR_BLK_FLAG_MAKECMV_FAST;
7576                    if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7577#ifdef AMAZON_MEI_DEBUG_ON
7578                        printk("\n\nCMV fail, Group 7 Address 2 Index 1");
7579#endif
7580                    }
7581                    else{
7582                            temp = RxMessage[4] - mib_pread.ATUR_CHAN_UNCORR_BLK_FAST;
7583                            if(temp>=0){
7584                                current_intvl->AturChanPerfUncorrBlk+=temp;
7585                                ATUR_CHAN_UNCORR_BLK+=temp;
7586                                mib_pread.ATUR_CHAN_UNCORR_BLK_FAST = RxMessage[4];
7587                            }
7588                            else{
7589                                current_intvl->AturChanPerfUncorrBlk+=0xffff - mib_pread.ATUR_CHAN_UNCORR_BLK_FAST + RxMessage[4];
7590                                ATUR_CHAN_UNCORR_BLK+=0xffff - mib_pread.ATUR_CHAN_UNCORR_BLK_FAST + RxMessage[4];
7591                                mib_pread.ATUR_CHAN_UNCORR_BLK_FAST = RxMessage[4];
7592                        }
7593                    }
7594                }
7595                    
7596                //RFC-3440
7597
7598#ifdef AMAZON_MEI_MIB_RFC3440
7599                if(showtime!=1)
7600                    goto mib_poll_end;
7601                ATUC_PERF_STAT_FASTR_FLAG_MAKECMV; //???
7602                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7603#ifdef AMAZON_MEI_DEBUG_ON
7604                    printk("\n\nCMV fail, Group 0 Address 0 Index 0");
7605#endif
7606                }
7607                else{
7608                        temp = RxMessage[4] - mib_pread.ATUC_PERF_STAT_FASTR;
7609                        if(temp>=0){
7610                            current_intvl->AtucPerfStatFastR+=temp;
7611                            ATUC_PERF_STAT_FASTR+=temp;
7612                            mib_pread.ATUC_PERF_STAT_FASTR = RxMessage[4];
7613                        }
7614                        else{
7615                            current_intvl->AtucPerfStatFastR+=0xffff - mib_pread.ATUC_PERF_STAT_FASTR + RxMessage[4];
7616                            ATUC_PERF_STAT_FASTR+=0xffff - mib_pread.ATUC_PERF_STAT_FASTR + RxMessage[4];
7617                            mib_pread.ATUC_PERF_STAT_FASTR = RxMessage[4];
7618                    }
7619                }
7620                if(showtime!=1)
7621                    goto mib_poll_end;
7622                ATUC_PERF_STAT_FAILED_FASTR_FLAG_MAKECMV; //???
7623                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7624#ifdef AMAZON_MEI_DEBUG_ON
7625                    printk("\n\nCMV fail, Group 0 Address 0 Index 0");
7626#endif
7627                }
7628                else{
7629                        temp = RxMessage[4] - mib_pread.ATUC_PERF_STAT_FAILED_FASTR;
7630                        if(temp>=0){
7631                            current_intvl->AtucPerfStatFailedFastR+=temp;
7632                            ATUC_PERF_STAT_FAILED_FASTR+=temp;
7633                            mib_pread.ATUC_PERF_STAT_FAILED_FASTR = RxMessage[4];
7634                        }
7635                        else{
7636                            current_intvl->AtucPerfStatFailedFastR+=0xffff - mib_pread.ATUC_PERF_STAT_FAILED_FASTR + RxMessage[4];
7637                            ATUC_PERF_STAT_FAILED_FASTR+=0xffff - mib_pread.ATUC_PERF_STAT_FAILED_FASTR + RxMessage[4];
7638                            mib_pread.ATUC_PERF_STAT_FAILED_FASTR = RxMessage[4];
7639                    }
7640                }
7641                if(showtime!=1)
7642                    goto mib_poll_end;
7643                ATUC_PERF_STAT_SESL_FLAG_MAKECMV;
7644                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7645#ifdef AMAZON_MEI_DEBUG_ON
7646                    printk("\n\nCMV fail, Group 7 Address 8 Index 0");
7647#endif
7648                }
7649                else{
7650                        temp = RxMessage[4] - mib_pread.ATUC_PERF_STAT_SESL;
7651                        if(temp>=0){
7652                            current_intvl->AtucPerfStatSesL+=temp;
7653                            ATUC_PERF_STAT_SESL+=temp;
7654                            mib_pread.ATUC_PERF_STAT_SESL = RxMessage[4];
7655                        }
7656                        else{
7657                            current_intvl->AtucPerfStatSesL+=0xffff - mib_pread.ATUC_PERF_STAT_SESL + RxMessage[4];
7658                            ATUC_PERF_STAT_SESL+=0xffff - mib_pread.ATUC_PERF_STAT_SESL + RxMessage[4];
7659                            mib_pread.ATUC_PERF_STAT_SESL = RxMessage[4];
7660                    }
7661                }
7662                if(showtime!=1)
7663                    goto mib_poll_end;
7664                ATUC_PERF_STAT_UASL_FLAG_MAKECMV;
7665                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7666#ifdef AMAZON_MEI_DEBUG_ON
7667                    printk("\n\nCMV fail, Group 7 Address 10 Index 0");
7668#endif
7669                }
7670                else{
7671                        temp = RxMessage[4] - mib_pread.ATUC_PERF_STAT_UASL;
7672                        if(temp>=0){
7673                            current_intvl->AtucPerfStatUasL+=temp;
7674                            ATUC_PERF_STAT_UASL+=temp;
7675                            mib_pread.ATUC_PERF_STAT_UASL = RxMessage[4];
7676                        }
7677                        else{
7678                            current_intvl->AtucPerfStatUasL+=0xffff - mib_pread.ATUC_PERF_STAT_UASL + RxMessage[4];
7679                            ATUC_PERF_STAT_UASL+=0xffff - mib_pread.ATUC_PERF_STAT_UASL + RxMessage[4];
7680                            mib_pread.ATUC_PERF_STAT_UASL = RxMessage[4];
7681                    }
7682                }
7683                if(showtime!=1)
7684                    goto mib_poll_end;
7685                ATUR_PERF_STAT_SESL_FLAG_MAKECMV;
7686                if(meiCMV(TxMessage, YES_REPLY)!=MEI_SUCCESS){
7687#ifdef AMAZON_MEI_DEBUG_ON
7688                    printk("\n\nCMV fail, Group 7 Address 34 Index 0");
7689#endif
7690                }
7691                else{
7692                        temp = RxMessage[4] - mib_pread.ATUR_PERF_STAT_SESL;
7693                        if(temp>=0){
7694                            current_intvl->AtucPerfStatUasL+=temp;
7695                            ATUC_PERF_STAT_UASL+=temp;
7696                            mib_pread.ATUR_PERF_STAT_SESL = RxMessage[4];
7697                        }
7698                        else{
7699                            current_intvl->AtucPerfStatUasL+=0xffff - mib_pread.ATUR_PERF_STAT_SESL + RxMessage[4];
7700                            ATUC_PERF_STAT_UASL+=0xffff - mib_pread.ATUR_PERF_STAT_SESL + RxMessage[4];
7701                            mib_pread.ATUR_PERF_STAT_SESL = RxMessage[4];
7702                    }
7703                }
7704                    
7705#endif
7706mib_poll_end:
7707                up(&mei_sema);
7708                
7709                do_gettimeofday(&time_fini);
7710                i = ((int)((time_fini.tv_sec-time_now.tv_sec)*1000)) + ((int)((time_fini.tv_usec-time_now.tv_usec)/1000)) ; //msec
7711            }//showtime==1
7712        }
7713    
7714}
7715int mib_poll_init(void)
7716{
7717    printk("Starting mib_poll...\n");
7718
7719    kernel_thread(adsl_mib_poll, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGNAL);
7720    return 0;
7721}
7722#endif //IFX_SMALL_FOOTPRINT
7723//EXPORT_NO_SYMBOLS;
7724
7725#ifdef ADSL_LED_SUPPORT
7726// adsl led -start
7727int led_status_on=0,led_need_to_flash=0;
7728int led_current_flashing=0;
7729unsigned long led_delay=0;
7730static int led_poll(void *unused)
7731{
7732    stop_led_module=0; //begin polling ...
7733    while(!stop_led_module){
7734        if ((!led_status_on)&&(!led_need_to_flash)) interruptible_sleep_on_timeout (&wait_queue_led_polling,1000); //10 seconds timeout for waiting wakeup
7735// else printk("direct running task, no waiting");
7736        run_task_queue(&tq_ifx_led);//joelin task
7737// printk("led and LOP polling...\n");
7738        }
7739    return 0;
7740}
7741static int led_poll_init(void)
7742{
7743// printk("Starting adsl led polling...\n");
7744
7745//warning-led-start
7746// CLEAR_BIT((*((volatile u32 *)0xB0100B40)), 0x40); //Warning LED GPIO ON
7747//warning-led-end
7748
7749    kernel_thread(led_poll, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGNAL);
7750    return 0;
7751}
7752
7753int adsl_led_flash(void)
7754{
7755    int i;
7756    if (!firmware_support_led) return 0; //joelin version check
7757
7758    if (led_status_on == 0 && led_need_to_flash == 0)
7759    {
7760        queue_task(&led_task, &tq_ifx_led);//joelin task
7761        wake_up_interruptible(&wait_queue_led_polling); //wake up and clean led module
7762// printk("queue Task 1...\n"); //joelin test
7763    }
7764    led_need_to_flash=1;//asking to flash led
7765
7766    return 0;
7767}
7768
7769int adsl_led_flash_task(void *ptr)
7770{
7771
7772    u16 one=1;
7773    u16 zero=0;
7774    u16 data=0x0600;
7775    int kernel_use=1;
7776    u16 CMVMSG[MSG_LENGTH];
7777//adsl-led-start for >v1.1.2.7.1.1
7778// printk("Task Running...\n"); //joelin test
7779    if ((firmware_support_led==2)&&(led_support_check))
7780    {
7781    led_support_check=0;
7782    data=0x0600;
7783    makeCMV_local(H2D_CMV_WRITE, INFO, 91, 0, 1, &data,CMVMSG); //configure GPIO9 GPIO10 as outputs
7784    mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, CMVMSG);
7785
7786    makeCMV_local(H2D_CMV_WRITE, INFO, 91, 2, 1, &data,CMVMSG); //enable writing to bit 9 and bit10
7787    mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, CMVMSG);
7788    
7789    data=0x0a01;
7790    makeCMV_local(H2D_CMV_WRITE, INFO, 91, 4, 1, &data,CMVMSG); //use GPIO10 for TR68 .Enable and don't invert.
7791    mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, CMVMSG);
7792    
7793#ifdef DATA_LED_ON_MODE
7794    data=0x0903;//tecom //use GPIO9 for TR68 data led .turn on.
7795#else
7796    data=0x0900;
7797#endif
7798    makeCMV_local(H2D_CMV_WRITE, INFO, 91, 5, 1, &data,CMVMSG); //use GPIO9 for TR68 data led .turn off.
7799    mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, CMVMSG);
7800    
7801    }
7802    if (!showtime) {led_need_to_flash=0; return 0;}
7803//adsl-led-end for >v1.1.2.7.1.1
7804
7805    if (led_status_on == 0 || led_need_to_flash == 1)
7806    {
7807
7808        if (led_current_flashing==0)
7809        {
7810            if (firmware_support_led==1){//>1.1.2.3.1.1
7811            makeCMV_local(H2D_CMV_WRITE, INFO, 91, 0, 1, &one,CMVMSG); //flash
7812            mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, &CMVMSG);
7813        }
7814            else if (firmware_support_led==2){//>1.1.2.7.1.1
7815                data=0x0901;//flash
7816                makeCMV_local(H2D_CMV_WRITE, INFO, 91, 5, 1, &data,CMVMSG); //use GPIO9 for TR68 data led .flash.
7817                mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, &CMVMSG);
7818                
7819            }//(firmware_support_led==2)
7820            led_current_flashing = 1;//turn on led
7821        }
7822        led_status_on=1;
7823
7824        do{//do nothing , waiting untill no data traffic
7825            led_need_to_flash=0;
7826            interruptible_sleep_on_timeout(&wait_queue_led, 25); //the time for LED Off , if no data traffic
7827        }while(led_need_to_flash==1);
7828        
7829    }else if (led_status_on == 1 && led_need_to_flash==0)
7830    {
7831        if (led_current_flashing==1)
7832        {//turn off led
7833            if (firmware_support_led==1){//>1.1.2.3.1.1
7834            makeCMV_local(H2D_CMV_WRITE, INFO, 91, 0, 1, &zero,CMVMSG);//off
7835            mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, &CMVMSG);
7836            } //>1.1.2.3.1.1
7837            else if (firmware_support_led==2){//>1.1.2.7.1.1
7838#ifdef DATA_LED_ON_MODE
7839                data=0x0903;//tecom //use GPIO9 for TR68 data led .turn on.
7840#else
7841                data=0x0900;//off
7842#endif
7843                makeCMV_local(H2D_CMV_WRITE, INFO, 91, 5, 1, &data,CMVMSG); //use GPIO9 for TR68 data led .off.
7844            mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_CMV_WINHOST, &CMVMSG);
7845                
7846            }//(firmware_support_led==2)
7847            led_status_on=0;
7848            led_current_flashing = 0;
7849        }
7850        }
7851    
7852    if (led_status_on == 1 || led_need_to_flash)
7853    {//led flash job on going or led need to flash
7854        queue_task(&led_task, &tq_ifx_led); //joelin task
7855// printk("queue Task 2...\n"); //joelin test
7856    }
7857    return 0;
7858}
7859//joelin adsl led-end
7860#else
7861int adsl_led_flash(void)
7862{
7863    return 0;
7864}
7865#endif //ADSL_LED_SUPPORT
7866#ifdef IFX_DYING_GASP
7867static int lop_poll(void *unused)
7868{
7869    
7870    while(1)
7871    {
7872    interruptible_sleep_on_timeout(&wait_queue_dying_gasp, 1);
7873#ifdef CONFIG_CPU_AMAZON_E //000003:fchang
7874        if(showtime&&((*((volatile u32 *)0xB0100B14))&0x4)==0x0) {//000003:fchang
7875#else //000003:fchang
7876    if(showtime&&((*((volatile u32 *)0xB0100B44))&0x8000)==0x0) {
7877#endif //CONFIG_CPU_AMAZON_E
7878        mei_ioctl((struct inode *)0,NULL, AMAZON_MEI_WRITEDEBUG, &lop_debugwr);
7879        printk("send dying gasp..\n");}
7880        
7881    }
7882    return 0;
7883    }
7884static int lop_poll_init(void)
7885{
7886// printk("Starting LOP polling...\n");
7887    kernel_thread(lop_poll, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGNAL);
7888    return 0;
7889}
7890
7891#endif //IFX_DYING_GASP
7892
7893//joelin 04/16/2005-satrt
7894static int unavailable_seconds_poll(void *unused)
7895{
7896    while(1){
7897        interruptible_sleep_on_timeout (&wait_queue_uas_poll,100); //1 second timeout for waiting wakeup
7898           if (!showtime) unavailable_seconds++;
7899    }
7900    return 0;
7901}
7902static int unavailable_seconds_poll_init(void)
7903{
7904  
7905    kernel_thread(unavailable_seconds_poll, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGNAL);
7906    return 0;
7907}
7908
7909
7910//joelin 04/16/2005-end
7911EXPORT_SYMBOL(meiDebugWrite);
7912EXPORT_SYMBOL(ifx_pop_eoc);
7913
7914MODULE_LICENSE("GPL");
7915
7916module_init(amazon_mei_init_module);
7917module_exit(amazon_mei_cleanup_module);
7918
7919

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive