newrpl/usbselector.cpp

#include <QMessageBox>
#include <QTreeWidget>
#include <QTimer>
#include <QStandardPaths>
#include <QFileDialog>

#include "string.h"
#include "hidapi.h"
#include "usbselector.h"
#include "ui_usbselector.h"

extern "C" {
#include "newrpl.h"
#include "libraries.h"

extern hid_device *__usb_curdevice;
extern volatile int __usb_paused;
int __fwupdate_progress;
int __fwupdate_address;
int __fwupdate_nwords;
BYTEPTR __fwupdate_buffer;


BINT64 rplObjChecksum(WORDPTR object);
}


USBSelector::USBSelector(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::USBSelector),
    update_thread(this)
{
    ui->setupUi(this);


    SelectedDevicePath.clear();
    ui->updateFirmware->hide();
    ui->updateProgress->hide();

    RefreshList();

    tmr = new QTimer(this);
    if(tmr) {
    connect(tmr, SIGNAL(timeout()), this, SLOT(refresh()));
    tmr->start(500);
    }


}

USBSelector::~USBSelector()
{
    if(tmr) {
        tmr->stop();
        delete tmr;
        tmr=0;
    }

    delete ui;
}

void USBSelector::on_USBtreeWidget_itemSelectionChanged()
{


    QString result;

    result.clear();
    QTreeWidgetItem *newitem;

    if(ui->USBtreeWidget->selectedItems().count()>=1) newitem=ui->USBtreeWidget->selectedItems().first();
    else {
        return;
    }

    if(newitem->text(2)==QString("[Device not responding]")) {
        ui->buttonBox->setStandardButtons( QDialogButtonBox::Cancel);
        SelectedDevicePath.clear();
        SelectedDeviceName.clear();
        ui->selectedCalc->setText(QString("No device selected."));
        ui->updateFirmware->hide();

    }
    else {
        ui->buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
        SelectedDevicePath=newitem->data(0,Qt::UserRole+3).toString();
        SelectedDeviceName=newitem->text(0)+QString("[build ")+newitem->text(2).right(4)+QString("]");
        ui->selectedCalc->setText(SelectedDeviceName);
        ui->updateFirmware->show();

    }

}

QString& USBSelector::getSelectedDevicePath()
{
    return SelectedDevicePath;
}

QString& USBSelector::getSelectedDeviceName()
{
    return SelectedDeviceName;
}

void USBSelector::RefreshList()
{
    struct hid_device_info *devs, *cur_dev;
    QTreeWidgetItem *newitem;


        if (hid_init())
        {
            ui->USBtreeWidget->clear();
            return;
        }

        devs = hid_enumerate(0x0, 0x0);
        if(!devs) {
            ui->USBtreeWidget->clear();
        return;
        }

        cur_dev = devs;
        QString result;
        result.clear();

        {
        // FIRST DISABLE ALL ITEMS IN THE LIST

        QTreeWidgetItemIterator it(ui->USBtreeWidget);
        while(*it) {
            (*it)->setDisabled(true);
            ++it;
        }

        }

        while (cur_dev) {

            QString manuf;

            if(cur_dev->manufacturer_string) manuf=QString::fromStdWString(cur_dev->manufacturer_string);

            if(manuf.startsWith("newRPL")) {
            QTreeWidgetItemIterator it(ui->USBtreeWidget);

            newitem=0;
            while(*it) {
                if( ((*it)->data(0,Qt::UserRole+1).toInt()==cur_dev->vendor_id)
                        && ((*it)->data(0,Qt::UserRole+2).toInt()==cur_dev->product_id)
                        && ((*it)->data(0,Qt::UserRole+3).toString()==QString(cur_dev->path))
                        )
                {
                    // FOUND THE SAME ITEM AGAIN
                    newitem=*it;
                    (*it)->setDisabled(false);
                }
                ++it;

            }

            if(!newitem) {
                newitem=new QTreeWidgetItem(ui->USBtreeWidget);

                if(!newitem) return;
            }

            QString tmp;

            if(cur_dev->product_string) tmp=QString::fromStdWString(cur_dev->product_string);
            else tmp="[Unknown]";
            if(cur_dev->serial_number) tmp+=QString("|SN=")+QString::fromStdWString(cur_dev->serial_number);

                newitem->setText(0,tmp);

                if(cur_dev->manufacturer_string) tmp=QString::fromStdWString(cur_dev->manufacturer_string);
                else tmp="[Unknown]";

                    newitem->setText(1,tmp);

                        newitem->setData(0,Qt::UserRole+1,QVariant(cur_dev->vendor_id));
                        newitem->setData(0,Qt::UserRole+2,QVariant(cur_dev->product_id));
                        newitem->setData(0,Qt::UserRole+3,QVariant(QString(cur_dev->path)));
                        newitem->setData(0,Qt::UserRole+4,QVariant(QString::fromStdWString(cur_dev->serial_number)));

                        hid_device *thisdev;

                        thisdev=hid_open_path(cur_dev->path);

                        if(thisdev)
                        {
                            unsigned char buffer[1024];
                            int res,datalen;
                            int available=0;

                            do {



                             // ASK IF REMOTE IS READY TO RECEIVE DATA
                             memset(buffer,0,RAWHID_TX_SIZE+1);
                             buffer[0]=0;    // REPORT ID
                             buffer[1]=USB_BLOCKMARK_GETSTATUS;   // CHECK IF REMOTE IS AVAILABLE TO ANSWER

                             res=hid_write(thisdev,buffer,RAWHID_TX_SIZE+1);

                             if(res<0) break;

                             res=hid_read_timeout(thisdev,buffer,RAWHID_RX_SIZE,100);

                             if(res<0) break;
                             // WE GOT A RESPONSE, IGNORE IT AND SEND THE REQUEST

                            // ATTEMPT TO SEND SOMETHING TO SEE IF IT'S ACTIVELY RESPONDING
                            uint32_t getversion[16]={
                                0,          // 0 = DON'T USE REPORT ID'S - THIS IS REQUIRED ONLY FOR HIDAPI
                                USB_BLOCKMARK_SINGLE,       // BLOCK SIZE AND MARKER
                                0,         // CRC32
                                MKPROLOG(SECO,5),  // ACTUAL DATA
                                CMD_VERSION,
                                CMD_DROP,
                                CMD_USBSEND,
                                CMD_DROP,
                                CMD_QSEMI,
                                0,0,0,0,0,0,0
                            };

                            getversion[1]|=(1+OBJSIZE(getversion[3]))<<10;
                            getversion[2]=usb_crc32roll(0,(BYTEPTR) &(getversion[3]),(1+OBJSIZE(getversion[3]))*4);

                            res=hid_write(thisdev,((const unsigned char *)getversion)+3,RAWHID_TX_SIZE+1);

                            if(res<0) break;

                            res=hid_read_timeout(thisdev,buffer,RAWHID_RX_SIZE,100);

                            if(res<0) break;
                            // WE GOT A RESPONSE OR IT TIMED OUT, IGNORE IT
                            while((res>0) &&(buffer[0]!=USB_BLOCKMARK_GETSTATUS)) res=hid_read_timeout(thisdev,buffer,RAWHID_RX_SIZE,100);

                            if(res<0) break;
                             // WE GOT A RESPONSE, THE DEVICE IS ALIVE!

                             if(buffer[0]==USB_BLOCKMARK_GETSTATUS) {
                                        // REMOTE IS ASKING IF WE ARE READY TO RECEIVE DATA

                                        // SAVE THE SIZE OF WHATEVER IS TRYING TO SEND FOR LATER USE
                                        datalen=buffer[1];
                                        datalen|=(buffer[2])<<8;
                                        datalen|=(buffer[3])<<16;
                                        datalen|=(buffer[4])<<24;


                                        memset(buffer,0,RAWHID_TX_SIZE+1);
                                        buffer[0]=0;    // REPORT ID
                                        buffer[1]=USB_BLOCKMARK_RESPONSE;   // RE ARE RESPONDING TO THE REQUEST
                                        buffer[2]=0;    // WE ARE NOT BUSY

                                        res=hid_write(thisdev,buffer,RAWHID_TX_SIZE+1);
                             } else break;


                             while((res>0) &&(buffer[0]!=USB_BLOCKMARK_SINGLE)) res=hid_read_timeout(thisdev,buffer,RAWHID_RX_SIZE,100);

                             if(res<0) break;

                             // WE GOT A RESPONSE, THE DEVICE IS ALIVE!
                             // RECEIVE THE DATA
                             if(buffer[0]==USB_BLOCKMARK_SINGLE) {
                                                unsigned int strprolog;
                                                strprolog=buffer[8]+(buffer[9]<<8)+(buffer[10]<<16)+(buffer[11]<<24);

                                                tmp=QString::fromUtf8((const char *)(buffer+12),rplStrSize(&strprolog));
                                                newitem->setText(2,tmp);
                                                available=1;

                                                // REMOTE NEEDS CONFIRMATION THAT WE GOT ALL THE DATA
                                                memset(buffer,0,RAWHID_TX_SIZE+1);
                                                buffer[0]=0;    // REPORT ID
                                                buffer[1]=USB_BLOCKMARK_RESPONSE;   // RE ARE RESPONDING TO THE REQUEST
                                                buffer[2]=0;    // WE ARE NOT BUSY
                                                buffer[7]=buffer[3]=datalen&0xff;  // DATALEN HAS TO BE < PACKET SIZE FOR THIS TO WORK

                                                res=hid_write(thisdev,buffer,RAWHID_TX_SIZE+1);
                              }
                             else break;

                            } while(!available);




                        hid_close(thisdev);

                        if(!available) {

                            tmp="[Device not responding]";
                            newitem->setText(2,tmp);
                        }

                        }
                        }

                            cur_dev = cur_dev->next;
        }
        hid_free_enumeration(devs);

        // NOW ELIMINATE ANY ITEMS THAT ARE NOT ENABLED
        {

        QTreeWidgetItemIterator it(ui->USBtreeWidget);
        while(*it) {
            if((*it)->isDisabled()) {
                if(SelectedDevicePath==(*it)->data(0,Qt::UserRole+3).toString()) {

                    ui->buttonBox->setStandardButtons( QDialogButtonBox::Cancel);
                    SelectedDevicePath.clear();
                    ui->selectedCalc->setText(QString("No device selected."));
                    ui->USBtreeWidget->clearSelection();
                    ui->updateFirmware->hide();
                }


                delete (*it);
            }
            ++it;
        }

        }

        // DONE, THE LIST WAS REFRESHED

}

void USBSelector::on_USBSelector_accepted()
{
    if(tmr) {
        tmr->stop();
        delete tmr;
        tmr=0;
    }


}

void USBSelector::on_USBSelector_rejected()
{
    if(tmr) {
        tmr->stop();
        delete tmr;
        tmr=0;
    }
}

void USBSelector::refresh()
{
   RefreshList();
}

void USBSelector::reconnect()
{
    if(!__usb_curdevice) {
   RefreshList();
   if(!SelectedDevicePath.isEmpty()) {
       // CONNECT TO THE USB DEVICE
       __usb_curdevice=hid_open_path(SelectedDevicePath.toUtf8().constData());
   }
    }

    if(!__usb_curdevice) {
        ++numberoftries;
        if(numberoftries>10) {
            if(tmr) {
                tmr->stop();
                delete tmr;
                tmr=0;
            }
            // FAILED TO RECONNECT AFTER 5 SECONDS

            // TODO: SHOW SOME ERROR DIALOG
        }
        return;    // WAIT FOR ANOTHER TRY
    }

    // THE DEVICE IS BACK!

    if(tmr) {
        tmr->stop();
        delete tmr;
        tmr=0;
    }

    // TODO: ASK THE USER IF HE WANTS TO RESTORE FIRMWARE AFTER SUCCE

    return;
}

extern "C" int usbremotefwupdatestart();
extern "C" int usbsendtoremote(uint32_t *data,int nwords);
extern "C" void usbflush();


void USBSelector::on_updateFirmware_clicked()
{


    // STOP REFRESHING THE LIST

    if(tmr) {
        tmr->stop();
        delete tmr;
        tmr=0;
    }



        QString path;
        // THIS IS ONLY FOR 50g/40g/39g HARDWARE
        // TODO: IMPROVE ON THIS FOR OTHER HARDWARE PLATFORMS
        unsigned int address;
        unsigned int nwords;

        path=QStandardPaths::locate(QStandardPaths::DocumentsLocation,"newRPL",QStandardPaths::LocateDirectory);
        if(path.isEmpty()) path=QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);

        QString fname=QFileDialog::getOpenFileName(this,"Select firmware file to send to calculator",path,"firmware binary files (*.bin *.* *)");

        if(!fname.isEmpty()) {
            QFile file(fname);

            if(!file.open(QIODevice::ReadOnly)) {
                QMessageBox a(QMessageBox::Warning,"Error while opening","Cannot open file "+ fname,QMessageBox::Ok,this);
                a.exec();


                // START REFRESHING THE LIST AGAIN
                tmr = new QTimer(this);
                if(tmr) {
                connect(tmr, SIGNAL(timeout()), this, SLOT(reconnect()));
                tmr->start(500);
                }


                return;
            }


            // FILE IS OPEN AND READY FOR READING


            filedata=file.readAll();

            file.close();

            // THIS IS ONLY VALID FOR 50G AND COUSINS, FIX LATER

            if((strncmp(filedata.constData(),"KINPOHP39G+IMAGE",16)==0)||
               (strncmp(filedata.constData(),"KINPOHP40G+IMAGE",16)==0)||
               (strncmp(filedata.constData(),"KINPOUPDATEIMAGE",16)==0)) {
                address=0x4000;
                nwords=filedata.size()>>2;

                filedata.replace(0,16,"Kinposhcopyright");
            }
            else {
                QMessageBox a(QMessageBox::Warning,"Invalid firmware image","Invalid firmware image",QMessageBox::Ok,this);
                a.exec();
                // START REFRESHING THE LIST AGAIN
                tmr = new QTimer(this);
                if(tmr) {
                connect(tmr, SIGNAL(timeout()), this, SLOT(reconnect()));
                tmr->start(500);
                }

                return;
            }

            QMessageBox warn(QMessageBox::Warning,"Firmware update","Firmware on the remote device is about to be updated. Do NOT disconnect the device. OK to proceed?",QMessageBox::Yes | QMessageBox::No,this);

            if(warn.exec()==QMessageBox::No) {
                // START REFRESHING THE LIST AGAIN
                tmr = new QTimer(this);
                if(tmr) {
                connect(tmr, SIGNAL(timeout()), this, SLOT(reconnect()));
                tmr->start(500);
                }

                return;
            }

        } else {

            // START REFRESHING THE LIST AGAIN
            tmr = new QTimer(this);
            if(tmr) {
            connect(tmr, SIGNAL(timeout()), this, SLOT(reconnect()));
            tmr->start(500);
            }

            return;
        }




        ui->USBtreeWidget->setEnabled(false);

        ui->updateFirmware->setEnabled(false);
        ui->updateProgress->setRange(0,nwords);
        ui->updateProgress->show();
        ui->updateProgress->setValue(0);
        ui->buttonBox->setEnabled(false);


        // CONNECT TO THE USB DEVICE
        __usb_curdevice=hid_open_path(SelectedDevicePath.toUtf8().constData());

        if(!__usb_curdevice) {
            // TODO: ERROR PROCESS
            // START REFRESHING THE LIST AGAIN
            tmr = new QTimer(this);
            if(tmr) {
            connect(tmr, SIGNAL(timeout()), this, SLOT(reconnect()));
            tmr->start(500);
            }

            return;
        }

   __fwupdate_progress=0;
   __fwupdate_address=address;
   __fwupdate_nwords=nwords;
   __fwupdate_buffer=(BYTEPTR)filedata.constData();

    connect(&update_thread,SIGNAL(finished()),this,SLOT(finishedupdate()));

    update_thread.start();

    while(!update_thread.isRunning());  // WAIT FOR THE THREAD TO START

    // START REPORTING PROGRESS
    QTimer::singleShot(0, this, SLOT(updateprogress()));


}


void USBSelector::finishedupdate()
{
    // PUT THE USB DRIVER TO REST
    __usb_paused=1;

    // AT THIS POINT, THE CALC MUST'VE RESET TO LOAD THE NEW FIRMWARE
    hid_close(__usb_curdevice);
    __usb_curdevice=0;


   int result=__fwupdate_address;

    if(!result) {
        QMessageBox a(QMessageBox::Warning,"Communication error while sending firmware","USB communication error",QMessageBox::Ok,this);
        a.exec();
    }


    ui->USBtreeWidget->clear();
    ui->USBtreeWidget->setEnabled(true);

    ui->updateFirmware->setEnabled(true);
    ui->updateProgress->hide();
    ui->updateProgress->setValue(0);
    ui->buttonBox->setEnabled(true);


    numberoftries=0;

    // START REFRESHING THE LIST AGAIN
    tmr = new QTimer(this);
    if(tmr) {
    connect(tmr, SIGNAL(timeout()), this, SLOT(reconnect()));
    tmr->start(500);
    }


    // AND JUST HOPE IT WILL RECONENCT SOME TIME

}

void USBSelector::updateprogress()
{
    if(!update_thread.isRunning()) return;

    ui->updateProgress->setValue(__fwupdate_progress);

    QTimer::singleShot(0, this, SLOT(updateprogress()));
}



// ****************************************** USB DRIVER ON A SEPARATE THREAD

FWThread::FWThread(QObject *parent)
    : QThread(parent)
{
}

FWThread::~FWThread()
{
}


void FWThread::run()
{
    int nwords=__fwupdate_nwords;
    __fwupdate_progress=0;



    // START USB DRIVER
    __usb_paused=0;
    // TODO: SHOW NICE WINDOW WITH UPDATE STEPS

    // SEND CMD_USBFWUPDATE TO THE CALC
    if(!usbremotefwupdatestart()) {
        __fwupdate_address=0;
        return;
    }


    int result=1,offset=0;


    while(nwords>1024) {

    if(!usb_transmitlong_start()) {
        // TODO: SOME KIND OF ERROR
        result=0;
        break;
    }

    // SEND FIRMWARE BLOCK MARKER
    if(result && (!usb_transmitlong_word(TEXT2WORD('F','W','U','P')))) {
        // TODO: SOME KIND OF ERROR
        result=0;
        break;
    }

    // SEND ADDRESS TO BURN THIS BLOCK
    if(result && (!usb_transmitlong_word(__fwupdate_address+(offset<<2)))) {
        // TODO: SOME KIND OF ERROR
            result=0;
            break;
    }

    // SEND SIZE OF THE BLOCK
    if(result && (!usb_transmitlong_word(1024))) {
        // TODO: SOME KIND OF ERROR
        result=0;
        break;
    }

    if(result) {
    int k;
    WORDPTR buffer=(WORDPTR)__fwupdate_buffer;
    for(k=0;k<1024;++k)
    {
        if(result && (!usb_transmitlong_word(buffer[offset]))) {
            // TODO: SOME KIND OF ERROR
            result=0;
            break;
        }
        ++offset;
    }
    }



    if(result && (!usb_transmitlong_finish())) {
        // TODO: SOME KIND OF ERROR
       result=0;
       break;
    }

    nwords-=1024;

    __fwupdate_progress=offset;

    }

    if(nwords) {
        if(!usb_transmitlong_start()) {
            // TODO: SOME KIND OF ERROR
            result=0;
        }

        // SEND FIRMWARE BLOCK MARKER
        if(result && (!usb_transmitlong_word(TEXT2WORD('F','W','U','P')))) {
            // TODO: SOME KIND OF ERROR
            result=0;
        }

        // SEND ADDRESS TO BURN THIS BLOCK
        if(result && (!usb_transmitlong_word(__fwupdate_address+(offset<<2)))) {
            // TODO: SOME KIND OF ERROR
                result=0;
        }

        // SEND SIZE OF THE BLOCK
        if(result && (!usb_transmitlong_word(nwords))) {
            // TODO: SOME KIND OF ERROR
            result=0;
        }

        if(result) {
        int k;
        WORDPTR buffer=(WORDPTR)__fwupdate_buffer;
        for(k=0;k<nwords;++k)
        {
            if(result && (!usb_transmitlong_word(buffer[offset]))) {
                // TODO: SOME KIND OF ERROR
                result=0;
                break;
            }
            ++offset;
        }
        __fwupdate_progress=offset;

        }



        if(result && (!usb_transmitlong_finish())) {
            // TODO: SOME KIND OF ERROR
           result=0;
        }


        // DONE SENDING THE LAST BLOCK
    }


    {
    // WAIT ONE FULL SECOND BEFORE STARTING ANOTHER CONVERSATION WITH THE DEVICE
    tmr_t start,end;
    start=tmr_ticks();
    do end=tmr_ticks(); while(tmr_ticks2ms(start,end)<1000);
    }


    // NOW FINISH THE TEST BY RESETTING

    if(result && (!usb_transmitlong_start())) {
        // TODO: SOME KIND OF ERROR
       result=0;
    }

    if(result && (!usb_transmitlong_word(TEXT2WORD('F','W','U','P')))) {
        // TODO: SOME KIND OF ERROR
       result=0;
    }

    // FOR DEBUG, JUST WRITE ONE WORD TO THIS ADDRESS
    if(result && (!usb_transmitlong_word(0xFFFFFFFF))) {
        // TODO: SOME KIND OF ERROR
       result=0;
    }
    if(result && (!usb_transmitlong_word(0x0))) {
        // TODO: SOME KIND OF ERROR
       result=0;
    }

    if(result && (!usb_transmitlong_finish())) {
        // TODO: SOME KIND OF ERROR
       result=0;
    }

    __fwupdate_address=result;

}