#!/bin/sh

#
# Copyright (C) 2015 shibby
#


PREFIX=$1

PID=$$
PIDFILE="/var/run/switch4g.pid"
READYFILE="/tmp/4g.ready"
DETECTFILE="/tmp/4g.detect"
MODE=`nvram get "$PREFIX"_proto`


if [ -z "$PREFIX" ]; then
    echo "usage: switch4g INTERFACE [connect|disconnect|signal]"
    exit 0
fi

if [ ! "$MODE" == "lte" ]; then
    exit 0
fi


connect() {
    APN=`nvram get "$PREFIX"_modem_apn`
    DEV=`nvram get modem_dev4g`
    TYPE=`nvram get modem_type`
    IFA=`nvram get wan_4g`
    SPEED=`nvram get "$PREFIX"_modem_speed`
    BAND=`nvram get "$PREFIX"_modem_band`
    ROAMING=`nvram get "$PREFIX"_modem_roam`
    CLID=$(nvram get modem_clid)

    logger -t switch4g[$PID] "4G MODEM - connecting ..."

    # non-hilink/1st type
    if [ "$TYPE" == "non-hilink" -o "$TYPE" == "hw-ether" ]; then
        CONNECTED=0
        COUNT=0

        if [ -z "$DEV" ]; then
            logger -t switch4g[$PID] "4G MODEM - DIAG interface not found - connection terminated!"
            rm -f $PIDFILE > /dev/null 2>&1
            exit 0
        fi

        case "$SPEED" in
             "00")   SPD1="Auto" ;;
             "03")   SPD1="4G only" ;;
             "02")   SPD1="3G only" ;;
             "0302") SPD1="4G/3G only" ;;
             "030201") SPD1="4G/3G/2G" ;;
             *) SPD1="unknown" ;;
        esac

        case "$ROAMING" in
             "0")  ROAM3="Disabled"  ;;
             "1")  ROAM3="Supported" ;;
             "2")  ROAM3="No change" ;;
             "3")  ROAM3="Roam only" ;;
             *)    ROAM3="unknown"   ;;
        esac

        case "$BAND" in
             "80000")  BAND2="B20 (800 MHz)" ;;
              "80")    BAND2="B8 (900 MHz)"  ;;
              "4")     BAND2="B3 (1800 MHz)" ;;
              "1")     BAND2="B1 (2100 MHz)" ;;
              "40")    BAND2="B7 (2600 MHz)" ;;
              "7FFFFFFFFFFFFFFF") BAND2="All supported" ;;
              *)       BAND2="unknown"       ;;
        esac

        #we try use last diag iface first. If it failed then we try use any other ttyUSB device
        TTY=`ls /dev/ttyUSB* | grep -v $DEV`
        DEVS="$DEV $TTY $DEV $TTY $DEV $TTY"  # let's triple this (try 3x on every interface)

        while [ "$CONNECTED" -eq 0 ]; do
            for i in $DEVS; do

                #disconnect first
                MODE="AT^NDISDUP=1,0" gcom -d "$i" -s /etc/gcom/setmode.gcom
                sleep 3

                # check for current type of network
                MODE="AT^SYSCFGEX?" gcom -d "$i" -s /etc/gcom/setverbose.gcom > /tmp/4g.mode

                RESULT=`cat /tmp/4g.mode | grep SYSCFGEX | grep '"' | cut -d '"' -f2`
                RESROAM=`cat /tmp/4g.mode | grep SYSCFGEX | grep ',' | cut -d ',' -f3`
                RESBAND=`cat /tmp/4g.mode | grep SYSCFGEX | grep ',' | cut -d ',' -f5 | tr -d '\r'`

                case "$RESULT" in
                     "00")   RES1="Auto" ;;
                     "03")   RES1="4G only" ;;
                     "02")   RES1="3G only" ;;
                     "0302") RES1="4G/3G only" ;;
                     "030201") RES1="4G/3G/2G" ;;
                     *) RES1="unknown" ;;
                esac

                case "$RESROAM" in
                     "0")  RES3="Disabled"  ;;
                     "1")  RES3="Supported" ;;
                     "2")  RES3="No change" ;;
                     "3")  RES3="Roam only" ;;
                     *)    RES3="unknown"   ;;
                esac

                case "$RESBAND" in
                     "80000") RES2="B20 (800 MHz)" ;;
                     "80")    RES2="B8 (900 MHz)"  ;;
                     "4")     RES2="B3 (1800 MHz)" ;;
                     "1")     RES2="B1 (2100 MHz)" ;;
                     "40")    RES2="B7 (2600 MHz)" ;;
                     "7FFFFFFFFFFFFFFF") RES2="All supported" ;;
                     *)       RES2="unknown"       ;;
                esac

                # change network type, band and roaming if required
                if [ "$RESULT" != "$SPEED" ]; then
                    TXTLOG="Network type changed: was $RES1, now $SPD1."
                    MODESPEED=$SPEED
                else
                    TXTLOG="Network type is $RES1."
                    MODESPEED=$RESULT
                fi
                if [ "$ROAMING" != "$RESROAM" ]; then
                    TXTLOG="$TXTLOG Roaming changed: was '$RES3', now '$ROAM3'."
                    MODEROAM=$ROAMING
                else
                    TXTLOG="$TXTLOG Roaming is '$RES3'."
                    MODEROAM=$RESROAM
                fi
                if [ "$SPEED" == "03" -a "$BAND" != "$RESBAND" ]; then
                    TXTLOG="$TXTLOG Band changed: was '$RES2', now '$BAND2'"
                    MODEBAND=$BAND
                else
                    TXTLOG="$TXTLOG Band is '$RES2'"
                    MODEBAND=$RESBAND
                fi

                logger -t switch4g[$PID] "4G MODEM - $TXTLOG (device $i)"


                if [ "$RESULT" != "$SPEED" ] ||  [ "$ROAMING" != "$RESROAM" ] || ([ "$SPEED" == "03" ] && [ "$BAND" != "$RESBAND" ]); then
                    MODE="AT^SYSCFGEX=\"$MODESPEED\",3fffffff,$MODEROAM,4,$MODEBAND,," gcom -d "$i" -s /etc/gcom/setverbose.gcom
                    sleep 5
                fi

                #connect
                MODE="AT^NDISDUP=1,1,\"$APN\"" gcom -d "$i" -s /etc/gcom/setverbose.gcom
                sleep 3

                MODE="AT+CGPADDR=1" gcom -d "$i" -s /etc/gcom/setverbose.gcom > /tmp/4g.mode

                CHECK=`cat /tmp/4g.mode | grep "+CGPADDR:" | cut -d '"' -f2 | wc -l`
                if [ "$CHECK" -eq 1 ]; then
                    logger -t switch4g[$PID] "4G MODEM - connected (device $i) ..."
                    CONNECTED=1
                    nvram set modem_dev4g="$i"
                    break
                else
                    logger -t switch4g[$PID] "4G MODEM - connection failed (device $i) [$COUNT]"
                    COUNT=`expr $COUNT + 1`
                    sleep 3
                fi
            done

            # checked all devices but still not connected?
            if [ "$CONNECTED" -eq 0 ]; then

                INTERVAL=`nvram get mwan_cktime`
                if [ "$INTERVAL" -gt 0 ]; then
                    logger -t switch4g[$PID] "4G MODEM - connection failed - watchdog enabled"

                    # try to redetect and connect again in next cycle
                    rm -f $READYFILE > /dev/null 2>&1
                    watchdog add
                else
                    logger -t switch4g[$PID] "4G MODEM - connection failed - process terminated!"
                    watchdog del
                fi
                rm -f $PIDFILE > /dev/null 2>&1
                exit 0
            fi
        done

    # non-hilink/2nd type
    elif [ "$TYPE" == "qmi_wwan" ]; then
        CONNECTED=0
        COUNT=0

        case "$SPEED" in
             "00")   SPD1="all" ;;
             "03")   SPD1="lte" ;;
             "02")   SPD1="all" ;;
             "0302") SPD1="all" ;;
             "030201") SPD1="all" ;;
             *) SPD1="all" ;;
        esac

        case "$ROAMING" in
             "3")  ROAM3="only" ;;
             *)    ROAM3="any"  ;;
        esac

        sleep 3
        uqmi -s -d /dev/"$devnr" --sync
        sleep 1

        # wait till registered
        while [ `uqmi -s -d "$DEV" --get-serving-system | grep searching | wc -l` -ne 0 ]; do
            sleep 5
        done

        sleep 1
        # set lte mode (all,lte,umts,cdma,td-scdma), implemented only all/lte
        uqmi -s -d "$DEV" --set-network-modes "$SPD1"
        sleep 1
 
        # set roaming
        uqmi -s -d "$DEV" --set-network-roaming "$ROAM3"
        logger -t switch4g[$PID] "4G MODEM - Roaming is set to '$ROAM3'"
        sleep 1

        # get client id for wds
        CLID=`uqmi -s -d "$DEV" --get-client-id wds`

        [ $? -ne 0 ] && {
            logger -t switch4g[$pid] "4G MODEM - unable to obtain client ID!"
            rm -f $pidfile > /dev/null 2>&1
            exit 0
        }
        sleep 1
        nvram set modem_clid=$CLID
        logger -t switch4g[$PID] "4G MODEM - got new Client ID: $CLID"

		# try to clear previous autoconnect state
        uqmi -s -d "$DEV" --set-client-id wds,"$CLID" --stop-network 0xffffffff --autoconnect > /dev/null
		sleep 1

        uqmi -s -d "$DEV" --set-data-format 802.3
        sleep 1
        uqmi -s -d "$DEV" --wda-set-data-format 802.3
        sleep 1

        while [ "$CONNECTED" -eq 0 ]; do
            if [ "$COUNT" -lt 5 ]; then
                #connect...
                PDH=$(uqmi -s -d "$DEV" --set-client-id wds,"$CLID" \
                     --start-network \
                     ${apn:+--apn "$apn"})

                case $PDH in
                ''|*[!0-9]*)
                    logger -t switch4g[$PID] "4G MODEM - connection failed (device $DEV) [$COUNT]"
                    COUNT=`expr $COUNT + 1`
                    sleep 5
                    ;;
                *)
                    logger -t switch4g[$PID] "4G MODEM - connected (device $DEV) ..."
                    CONNECTED=1
                    COUNT=6
                    logger -t switch4g[$PID] "4G MODEM - Session ID: $PDH"
                    nvram set modem_pdh=$PDH
                    break
                    ;;
                esac
            else
                # checked 5 times but still not connected?
                sleep 1
                uqmi -s -d "$DEV" --set-client-id wds,"$CLID" --release-client-id wds

                INTERVAL=`nvram get mwan_cktime`
                if [ "$INTERVAL" -gt 0 ]; then
                    logger -t switch4g[$PID] "4G MODEM - connection failed - watchdog enabled"
                    watchdog add
                else
                    logger -t switch4g[$PID] "4G MODEM - connection failed - process terminated!"
                    watchdog del
                fi
                rm -f $PIDFILE > /dev/null 2>&1
                exit 0
            fi
        done
    fi
    # end-if (non-hilink/type)

    DONE=0
    COUNT=1

    while [ "$DONE" -eq 0 ]; do
        if [ "$COUNT" -lt 5 ]; then

            dhcpc-release $PREFIX
            sleep 1
            dhcpc-renew $PREFIX
	    sleep 1

            CHECKIFA=`ifconfig | grep "$IFA" | wc -l`
            if [ "$CHECKIFA" -eq 1 ]; then
                echo "1" > /tmp/state_$PREFIX
                DONE=1
                logger -t switch4g[$PID] "4G MODEM - WAN IFACE configured ($IFA) ..."
                watchdog add
                signal
            else
                logger -t switch4g[$PID] "4G MODEM - WAN IFACE not ready ($IFA) [$COUNT]"
                COUNT=`expr $COUNT + 1`
                sleep 2
            fi
        else
            INTERVAL=`nvram get mwan_cktime`
            if [ "$INTERVAL" -gt 0 ]; then
                logger -t switch4g[$PID] "4G MODEM - WAN IFACE failed - watchdog enabled"
                watchdog add
            else
                logger -t switch4g[$PID] "4G MODEM - WAN IFACE failed - connection process terminated!"
                watchdog del
            fi
            rm -f $PIDFILE > /dev/null 2>&1
            exit 0
        fi
    done
}

disconnect() {
    DEV=`nvram get modem_dev4g`
    TYPE=`nvram get modem_type`
    CLID=`nvram get modem_clid`
    PDH=`nvram get modem_pdh`

    logger -t switch4g[$PID] "4G MODEM - disconnecting ..."
    watchdog del
    dhcpc-release $PREFIX

    if [ "$TYPE" == "non-hilink" -o "$TYPE" == "hw-ether" ]; then
        MODE="AT^NDISDUP=1,0" gcom -d "$DEV" -s /etc/gcom/setmode.gcom
        sleep 1
    elif [ "$TYPE" == "qmi_wwan" ]; then
        if [ "$CLID" != "" ]; then
            uqmi -s -d "$DEV" --set-client-id wds,"$CLID" --stop-network 0xffffffff --autoconnect > /dev/null
            sleep 1

            if [ "$PDH" != "" ]; then
                uqmi -s -d "$DEV" --set-client-id wds,"$CLID" --stop-network "$PDH"
                sleep 1
            fi
            uqmi -s -d "$DEV" --set-client-id wds,"$CLID" --release-client-id wds
            logger -t switch4g[$pid] "4G MODEM - release Client ID: $CLID"
            nvram unset modem_pdh
            nvram unset modem_clid
        fi
    fi

    logger -t switch4g[$PID] "4G MODEM - disconnected ..."
}

checkPid() {
    if [ -f $PIDFILE ]; then

        PIDNO=$(cat $PIDFILE)
        cat "/proc/$PIDNO/cmdline" > /dev/null 2>&1

        if [ $? -eq 0 ]; then
            logger -t switch4g[$PID] "4G MODEM - another proces in action - exiting"
            exit 0
        else
            # Process not found assume not running
            echo $PID > $PIDFILE
            if [ $? -ne 0 ]; then
                logger -t switch4g[$PID] "4G MODEM - could not create PID file"
                exit 0
            fi
        fi
    else
        echo $PID > $PIDFILE
        if [ $? -ne 0 ]; then
            logger -t switch4g[$PID] "4G MODEM - could not create PID file"
            exit 0
        fi
    fi
}

setPIN() {
    PIN=`nvram get "$PREFIX"_modem_pin`
    IS_PIN=`nvram get "$PREFIX"_modem_pin | wc -w`

    if [ "$IS_PIN" -eq 1 ]; then #only for non-hilink

        if [ "$TYPE" == "non-hilink" -o "$TYPE" == "hw-ether" ]; then
            #we try use last diag iface first. If it failed then we try use any other ttyUSB device
            TTY=`ls /dev/ttyUSB* | grep -v $DEV`
            DEVS="$DEV $TTY"
            COUNT=1

            if [ "$COUNT" -lt 5 ]; then
                for i in $DEVS; do
                    PINCODE="$PIN" gcom -d $i -s /etc/gcom/setpin.gcom > /tmp/4g.pin
                    IS_READY=`cat /tmp/4g.pin | grep successfully | wc -l`
                    if [ "$IS_READY" == "1" ]; then
                        logger -t switch4g[$PID] "4G MODEM - SIM ready"
                        nvram set modem_dev4g="$i"
                        break
                    else
                        logger -t switch4g[$PID] "4G MODEM - SIM not ready ($COUNT) ..."
                        COUNT=`expr $COUNT + 1`
                        sleep 5
                    fi
                done
            else
                logger -t switch4g[$PID] "4G MODEM - SIM locked - connection process terminated!"
                watchdog del
                rm -f $PIDFILE > /dev/null 2>&1
                exit 0
            fi
        elif [ "$TYPE" == "qmi_wwan" ]; then
            # get pin status
            PINSTATUS = `uqmi -s -d "$DEVNR" --get-pin-status | cut -d "," -f 1 | cut -d ":" -f 2 | cut -d "\"" -f2`
            if [ "$PINSTATUS" != 'disabled' ]; then
                uqmi -s -d "$DEVNR" --verify-pin1 "$PIN"
            fi
        fi
    fi
}

switchMode() {
    MODULES="qmi_wwan cdc_ether huawei_ether cdc_ncm"

    for MODULE in $MODULES; do  # remove modules
        modprobe -r $MODULE
    done

    logger -t switch4g[$PID] "4G MODEM - detecting ..."

    COUNT=0
    FOUND=0

    while [ $FOUND -eq 0 ]; do
        #modem not found, try to detect
        DEVICES=`lsusb | awk '{print $6}'`

        for SWITCH in $DEVICES; do
            SEARCH=`ls /etc/usb_modeswitch.d/$SWITCH | wc -l`

            # vendor:product

            if [ "$SEARCH" -eq 1 ]; then
                logger -t switch4g[$PID] "4G MODEM FOUND - $SWITCH - Switching ..."
                DV=`echo $SWITCH | cut -d ":" -f1`
                DP=`echo $SWITCH | cut -d ":" -f2`
                /usr/sbin/usb_modeswitch -Q -c /etc/usb_modeswitch.d/$SWITCH -v $DV -p $DP

                # need few seconds before modem will be detected once again after switch
                sleep 10

                VENDOR=`cat /etc/usb_modeswitch.d/$SWITCH | grep "TargetVendor" | cut -d "=" -f2 | cut -d "x" -f2`
                if [ "$VENDOR" == "" ]; then
                    VENDOR=`echo $SWITCH | cut -d ":" -f1`
                fi

                PRODUCT=`lsusb | awk '{print $6}' | grep $VENDOR | cut -d ":" -f2`
                if [ "$PRODUCT" != "" ]; then
                    logger -t switch4g[$PID] "4G MODEM ready - $VENDOR:$PRODUCT"
                    echo "$VENDOR:$PRODUCT" > $DETECTFILE
                fi
            fi
        done

        # is modem ready?
        for MODULE in $MODULES; do
            modprobe $MODULE
            sleep 1

            SEARCH=`cat /proc/bus/usb/devices | grep Driver | grep $MODULE | wc -l`

            if [ "$SEARCH" -gt 0 ]; then
                if [ "$MODULE" == "cdc_ether" ]; then
                    TYPE="hilink"
                elif [ "$MODULE" == "cdc_ncm" ]; then
                    TYPE="non-hilink"
                elif [ "$MODULE" == "huawei_ether" ]; then
                    TYPE="hw-ether"
                elif [ "$MODULE" == "qmi_wwan" ]; then
                    TYPE="qmi_wwan"
                else
                    TYPE="unknown"
                fi

                logger -t switch4g[$PID] "4G MODEM NDIS ($TYPE) found - using $MODULE module"
                nvram set 4g_module=$MODULE
                FOUND=1
                break
            else
                if [ "$COUNT" -eq 5 ]; then
                    logger -t switch4g[$PID] "4G MODEM NDIS not found - process terminated!"
                    rm -f $PIDFILE > /dev/null 2>&1
                    exit 0
                else
                    logger -t switch4g[$PID] "4G MODEM NDIS ($MODULE) not found [$COUNT] ..."
                    modprobe -r $MODULE
                    COUNT=`expr $COUNT + 1`
                    sleep 3
                fi
            fi
        done
    done
}

searchWAN() {

    #search WAN interface (usbX or ethX)
    FOUND=0
    COUNT=0

    KERNEL=`uname -r | cut -d "." -f1,2,3`

    while [ "$FOUND" -eq 0 ]; do
        if [ "$TYPE" == "hw-ether" ]; then
            WAN=`dmesg | grep huawei_ether | grep Device | grep register | cut -d ":" -f1 | tail -1`
        elif [ "$KERNEL" == "2.6.36" ]; then #ARM
            WAN=`dmesg | grep $MODULE | grep register | grep "'" | cut -d " " -f3 | cut -d ":" -f1 | tail -1`
        else #MIPSEL
            WAN=`dmesg | grep $MODULE | grep register | grep "'" | cut -d ":" -f1 | tail -1`
        fi

        IS_WAN=`echo $WAN | wc -w`

        if [ "$IS_WAN" -gt 0 ]; then
            logger -t switch4g[$PID] "4G MODEM WAN ($TYPE) found - using $WAN as WAN"
            nvram set wan_4g="$WAN"
            nvram set modem_type="$TYPE"
            FOUND=1
            echo "$WAN" > $READYFILE
        else
            if [ "$COUNT" -eq 5 ]; then
                logger -t switch4g[$PID] "4G MODEM WAN not found - connection process terminated!"
                rm -f $PIDFILE > /dev/null 2>&1
                exit 0
            else
                logger -t switch4g[$PID] "4G MODEM WAN not found [$COUNT] ..."
                COUNT=`expr $COUNT + 1`
                sleep 5
            fi
        fi
    done
}

searchDiag() {
    FOUND=0

    if [ "$TYPE" == "non-hilink" -o "$TYPE" == "hw-ether" ]; then
        US=`cat /proc/bus/usb/devices | grep Driver | grep usbserial | wc -l`

        if [ "$US" -gt 0 ]; then
            logger -t switch4g[$PID] "4G MODEM found - Diagnostic interface - using usbserial module"
            break
        else
            IS_VENDOR=`echo $VENDOR | wc -w`
            if [ "$IS_VENDOR" -gt 0 ]; then
                IS_PRODUCT=`echo $PRODUCT | wc -w`
                if [ "$IS_PRODUCT" -gt 0 ]; then
                    logger -t switch4g[$PID] "4G MODEM - loading module usbserial ($VENDOR:$PRODUCT)"
                    modprobe -r usbserial
                    insmod usbserial vendor=0x$VENDOR product=0x$PRODUCT
                    echo "$VENDOR:$PRODUCT" > $DETECTFILE
                    sleep 1
                fi
            fi

            DEV=`cat /proc/bus/usb/devices | grep Driver | grep usbserial | wc -l`
            if [ "$DEV" -gt 0 ]; then
                logger -t switch4g[$PID] "4G MODEM ready - using usbserial module"
                FOUND=1
                nvram set 4g_module=usbserial
            else
                #last change. try load usbserial for each usb devices
                DEVICES=`lsusb | awk '{print $6}'`
                for SWITCH in $DEVICES; do
                    if [ "$FOUND" -eq 0 ]; then
                        VENDOR=`echo $SWITCH | cut -d ":" -f1`
                        PRODUCT=`echo $SWITCH | cut -d ":" -f2`
                        modprobe -r usbserial
                        insmod usbserial vendor=0x$VENDOR product=0x$PRODUCT
                        sleep 1

                        DEV=`cat /proc/bus/usb/devices | grep Driver | grep usbserial | wc -l`
                        if [ "$DEV" -gt 0 ]; then
                            logger -t switch4g[$PID] "4G MODEM ready - using usbserial module ($VENDOR:$PRODUCT)"
                            nvram set 4g_module=usbserial
                            echo "$VENDOR:$PRODUCT" > $DETECTFILE
                            FOUND=1
                            break
                        fi
                    fi
                done
            fi
        fi

        #search diagnostic device
        sleep 5
        TTY=`ls /dev/ttyUSB*`

        for i in $TTY; do
            CHECKTTY=`gcom -d "$i" -s /etc/gcom/getcardinfo.gcom | grep OK | wc -l`
            if [ "$CHECKTTY" == "1" ]; then #found working interface
                logger -t switch4g[$PID] "4G MODEM DIAG found (device $i)"
                nvram set modem_dev4g="$i"
                DEVNR=$i
            else
                logger -t switch4g[$PID] "4G MODEM DIAG not found"
            fi
        done

    elif [ "$TYPE" == "qmi_wwan" ]; then
        #search diagnostic device
        TTY=`ls /dev/cdc-wdm*`

        for i in $TTY; do
            CHECKTTY=`uqmi -s -d "$i" --get-versions | grep service | wc -l`
            if [ "$CHECKTTY" -eq 1 ]; then #found working interface
                logger -t switch4g[$PID] "4G MODEM DIAG found (device $i)"
                nvram set modem_dev4g="$i"
                DEVNR=$i
            else
                logger -t switch4g[$PID] "4G MODEM DIAG not found"
            fi
        done
    fi
}

signal() {
    DEVNR=`nvram get modem_dev4g`
    TYPE=`nvram get modem_type`


    if [ "$TYPE" == "non-hilink" -o "$TYPE" == "hw-ether" ]; then
        HCSQ=`MODE="AT^HCSQ?" gcom -d $DEVNR -s /etc/gcom/setverbose.gcom | grep "HCSQ:" | tr -d '\r'`
        SPEED=`echo $HCSQ | cut -d "," -f1 | cut -d '"' -f2`
        case "$SPEED" in
            "LTE")
                    VALUE=`echo $HCSQ | cut -d "," -f2`
                    RSSI=`awk "BEGIN {print -120+$VALUE}"` #dBm
                    VALUE=`echo $HCSQ | cut -d "," -f3`
                    RSRP=`awk "BEGIN {print -140+$VALUE}"` #dBm
                    VALUE=`echo $HCSQ | cut -d "," -f4`
                    SINR=`awk "BEGIN {print -20+$VALUE*0.2}"` #dB
                    VALUE=`echo $HCSQ | cut -d "," -f5`
                    RSRQ=`awk "BEGIN {print -19.5+$VALUE*0.5}"` #dB

                    CERSSI=`MODE="AT^CERSSI?" gcom -d $DEVNR -s /etc/gcom/setverbose.gcom | grep "CERSSI:" | tr -d '\r'`
                    if [ "$CERSSI" != "" ]; then
                        CQI1=`echo $CERSSI | cut -d "," -f10`
                        CQI2=`echo $CERSSI | cut -d "," -f11`
                    fi

                    HFREQINFO=`MODE="AT^HFREQINFO?" gcom -d $DEVNR -s /etc/gcom/setverbose.gcom | grep "HFREQINFO:" | tr -d '\r'`
                    if [ "$HFREQINFO" != "" ]; then
                        BAND=`echo $HFREQINFO | cut -d "," -f3`
                        VALUE=`echo $HFREQINFO | cut -d "," -f6`
                        DOWNWIDTH=`awk "BEGIN {print $VALUE/1000}"`  # MHz
                        VALUE=`echo $HFREQINFO | cut -d "," -f5`
                        DOWNFREQ=`awk "BEGIN {print $VALUE/10}"`  # MHz
                        VALUE=`echo $HFREQINFO | cut -d "," -f9`
                        UPWIDTH=`awk "BEGIN {print $VALUE/1000}"`  # MHz
                        VALUE=`echo $HFREQINFO | cut -d "," -f8`
                        UPFREQ=`awk "BEGIN {print $VALUE/10}"`  # MHz

                        case "$BAND" in
                             "1")  BBAND="B1 (2100 MHz)" ;;
                             "3")  BBAND="B3 (1800 MHz)" ;;
                             "7")  BBAND="B7 (2600 MHz)" ;;
                             "8")  BBAND="B8 (900 MHz)" ;;
                             "13") BBAND="B13 (750 MHz)" ;;
                             "17") BBAND="B17 (700 MHz)" ;;
                             "20") BBAND="B20 (800 MHz)" ;;
                             "38") BBAND="B38 (2600 MHz TDD)" ;;
                             "40") BBAND="B40 (2300 MHz TDD)" ;;
                             "41") BBAND="B41 (2500 MHz TDD)" ;;
                             *)    BBAND="unknown"       ;;
                        esac
                    fi

                    LOCINFO=`MODE="AT^LOCINFO?" gcom -d $DEVNR -s /etc/gcom/setverbose.gcom | grep "LOCINFO:" | tr -d '\r'`
                    if [ "$LOCINFO" != "" ]; then
                        MCCMNC=`echo $LOCINFO | cut -d "," -f1 | cut -d ':' -f2`
                        LAC=`echo $LOCINFO | cut -d "," -f2`  # hex
                        CID=`echo $LOCINFO | cut -d "," -f3`  # hex
                        CELL=`echo $LOCINFO | cut -d "," -f4`  # hex
                    fi

                    logger -t switch4g[$PID] "4G MODEM Current Mode: $SPEED"
                    if [ "$CERSSI" != "" ]; then
                        logger -t switch4g[$PID] "4G MODEM Signal Strength: RSSI $RSSI dBm, RSRP $RSRP dBm, RSRQ $RSRQ dB, SINR $SINR dB, CQI1 $CQI1, CQI2 $CQI2"
                    else
                        logger -t switch4g[$PID] "4G MODEM Signal Strength: RSSI $RSSI dBm, RSRP $RSRP dBm, RSRQ $RSRQ dB, SINR $SINR dB"
                    fi
                    if [ "$HFREQINFO" != "" ]; then
                        logger -t switch4g[$PID] "4G MODEM Carrier: $BBAND, Downlink FQ $DOWNFREQ MHz, Uplink FQ $UPFREQ MHz, Downlink BW $DOWNWIDTH MHz, Uplink BW $UPWIDTH MHz"
                    fi
                    if [ "$LOCINFO" != "" ]; then
                        logger -t switch4g[$PID] "4G MODEM BTS: MCCMNC $MCCMNC, LAC $LAC (`printf "%d" $LAC`), CID $CID (`printf "%d" $CID`), Cell ID $CELL (`printf "%d" $CELL`)"
                    fi
            ;;
            "WCDMA")
                    VALUE=`echo $HCSQ | cut -d "," -f2`
                    RSSI=`awk "BEGIN {print -120+$VALUE}"` #dBm
                    VALUE=`echo $HCSQ | cut -d "," -f3`
                    RSRP=`awk "BEGIN {print -120+$VALUE}"` #dBm
                    VALUE=`echo $HCSQ | cut -d "," -f4`
                    ECIO=`awk "BEGIN {print -32+$VALUE*0.5}"` #dB

                    LOCINFO=`MODE="AT^LOCINFO?" gcom -d $DEVNR -s /etc/gcom/setverbose.gcom | grep "LOCINFO:" | tr -d '\r'`
                    if [ "$LOCINFO" != "" ]; then
                        MCCMNC=`echo $LOCINFO | cut -d "," -f1 | cut -d ':' -f2`
                        LAC=`echo $LOCINFO | cut -d "," -f2`
                        CID=`echo $LOCINFO | cut -d "," -f3`
                        CELL=`echo $LOCINFO | cut -d "," -f4`
                    fi
                    logger -t switch4g[$PID] "4G MODEM Current Mode: $SPEED"
                    logger -t switch4g[$PID] "4G MODEM Signal Strength: RSSI $RSSI dBm, RSSP $RSRP dBm, ECIO $ECIO dB"
                    if [ "$LOCINFO" != "" ]; then
                        logger -t switch4g[$PID] "4G MODEM BTS: MCCMNC $MCCMNC, LAC $LAC (`printf "%d" $LAC`), CID $CID (`printf "%d" $CID`), Cell ID $CELL (`printf "%d" $CELL`)"
                    fi
            ;;
            "GSM")
                    VALUE=`echo $HCSQ | cut -d "," -f2`
                    RSSI=`awk "BEGIN {print -120+$VALUE}"` #dBm
                    logger -t switch4g[$PID] "4G MODEM Current Mode: $SPEED"
                    logger -t switch4g[$PID] "4G MODEM Signal Strength: RSSI $RSSI dBm"
            ;;
            *)
                    logger -t switch4g[$PID] "4G MODEM Current Mode: unknown"
                    logger -t switch4g[$PID] "4G MODEM Signal Strength: no data"
            ;;
        esac
    elif [ "$TYPE" == "qmi_wwan" ]; then
        SIGNAL=`uqmi -s -d "$DEVNR" --get-signal-info`
        RSSI=`echo $SIGNAL | cut -d "," -f2 | cut -d ":" -f2`
        RSRQ=`echo $SIGNAL | cut -d "," -f3 | cut -d ":" -f2`
        RSRP=`echo $SIGNAL | cut -d "," -f4 | cut -d ":" -f2`
        SNR=`echo $SIGNAL | cut -d ":" -f6 | cut -d "}" -f1`
        logger -t switch4g[$PID] "4G MODEM Signal Strength: RSSI $RSSI dBm, RSRP $RSRP dB, RSRQ $RSRQ dB, SNR $SNR dB"
        sleep 1
    fi
}


###################################################


if [ "$2" == "connect" ]; then
    connect
elif [ "$2" == "disconnect" ]; then
    disconnect
elif [ "$2" == "signal" ]; then
    signal
else
    #check pid file
    checkPid

    if [ ! -f $READYFILE ]; then #modem not detected
        switchMode

        searchWAN

        if [ "$TYPE" == "non-hilink" -o "$TYPE" == "hw-ether" -o "$TYPE" == "qmi_wwan" ]; then #only for non-hilink
            searchDiag

            setPIN
        fi
    fi

    #force connection after detect 4G modem
    connect

    #remove pid file
    rm -f $PIDFILE > /dev/null 2>&1
fi
