HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorerPlugins Commit - r5:15c638a85130

An other Win32 dirty fix tentative.

Jeandet Alexis -

r5:15c638a85130 default

parent child

Context file:

r5:15c638a85130

Collapse all files

APBUARTPLUGIN/APBUARTPLUGIN.cpp +12 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "APBUARTPLUGIN.h"
             #include <socexplorerengine.h>
             ApbUartPlugin::ApbUartPlugin(QWidget *parent):socexplorerplugin(parent)
             {
                 this->UI = new ApbUartPluginUi();
                 this->setWindowTitle(tr("APBUART"));
                 this->setWidget((QWidget*)this->UI);
                 this->useLoopBack = false;
                 connect(this->UI,SIGNAL(loopbackChkBxStateChanged(int)),this,SLOT(loopbackChangeState(int)));
                 connect(this,SIGNAL(apbUartTextReceived(QString)),this->UI,SIGNAL(apbUartTextReceived(QString)));
                 connect(&this->loopBackTimer,SIGNAL(timeout()),this,SLOT(uartReadout()));
             }
             ApbUartPlugin::~ApbUartPlugin()
             {
             }
             void ApbUartPlugin::closeMe()
             {
                 emit this->closePlugin(this);
             }
             void ApbUartPlugin::postInstantiationTrigger()
             {
                 if(this->isEnabled())
                 {
                     this->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,this->VID(),this->PID(),0));
                     loopbackChangeState(Qt::Checked);
                 }
             }
             void ApbUartPlugin::loopbackChangeState(int state)
             {
                 if(state==Qt::Checked)
                 {
                     enableLoopback();
                 }
                 else
                 {
                     disableLoopback();
                 }
             }
             void ApbUartPlugin::uartReadout()
             {
+            #ifdef WIN32
+                int readcnt=0;
+            #endif
                 if(this->isEnabled() && parent!=NULL)
                 {
                     if(this->useLoopBack)
                     {
                         if(this->baseAddress()!=-1)
                         {
                             this->loopBackTimer.stop();
                             unsigned int status_reg,data;
                             char ch;
                             QString printdata="";
                             parent->Read(&status_reg,1,this->baseAddress()+APB_UART_STATUS_REG);
                             while ((status_reg&4)==0) {
                                 parent->Read(&data,1,this->baseAddress()+APB_UART_FIFO_DEBUG_REG);
                                 ch = (char)(0xff & data);
                                 printdata+=ch;
+            #ifdef WIN32
+                                readcnt++;
+                                if(readcnt>=32)
+                                {
+                                    qApp->processEvents();
+                                    break;
+                                }
+            #endif
                                 parent->Read(&status_reg,1,this->baseAddress()+APB_UART_STATUS_REG);
                             }
                             if(printdata!="")
                                 emit apbUartTextReceived(printdata);
-                            this->loopBackTimer.start();
+                            this->loopBackTimer.start(200);
                         }
                         else
                         {
                             this->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,this->VID(),this->PID(),0));
                             this->enableLoopback();
                         }
                     }
                 }
             }
             void ApbUartPlugin::activate(bool flag)
             {
                 this->setEnabled(flag);
                 emit this->activateSig(flag);
                 if(this->isEnabled())
                 {this->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,this->VID(),this->PID(),0));
                     loopbackChangeState(Qt::Checked);
                 }
             }
             void ApbUartPlugin::activateScan(bool flag)
             {
                 if(flag)
                     this->loopBackTimer.start(200);
                 else
                     this->loopBackTimer.stop();
             }
             int ApbUartPlugin::enableLoopback()
             {
                 this->useLoopBack = true;
                 this->loopBackTimer.start(200);
                 SocExplorerEngine::message(this,"Set FiFo debug mode mode");
                 if(parent==NULL)
                 {
                     SocExplorerEngine::message(this,"Can't set FiFo debug mode no parent driver accessible");
                     return -1;
                 }
                 if(this->baseAddress()==-1)
                 {
                     this->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,this->VID(),this->PID(),0));
                     if(this->baseAddress()==-1)
                         return -1;
                 }
                 unsigned int ctrl_reg= 0x843;
                 parent->Write(&ctrl_reg,1,this->baseAddress()+APB_UART_CONTROL_REG);
                 return 0;
             }
             int ApbUartPlugin::disableLoopback()
             {
                 SocExplorerEngine::message(this,"Disable FiFo debug mode mode");
                 if(parent==NULL)
                 {
                     SocExplorerEngine::message(this,"Can't disable FiFo debug mode no parent driver accessible");
                     return -1;
                 }
                 if(this->baseAddress()==-1)
                 {
                     this->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,this->VID(),this->PID(),0));
                     if(this->baseAddress()==-1)
                         return -1;
                 }
                 unsigned int ctrl_reg;
                 this->loopBackTimer.stop();
                 /* Firts get Control reg value*/
                 parent->Read(&ctrl_reg,1,this->baseAddress()+APB_UART_CONTROL_REG);
                 ctrl_reg = ctrl_reg & (~(1<<11));
                 parent->Write(&ctrl_reg,1,this->baseAddress()+APB_UART_CONTROL_REG);
                 this->useLoopBack = false;
                 return 0;
             }
             unsigned int ApbUartPlugin::Read(unsigned int *Value,unsigned int count,unsigned int address)
             {
                 if(parent!=NULL)
                     return parent->Read(Value,count,address);
                 return 0;
             }
             unsigned int ApbUartPlugin::Write(unsigned int *Value,unsigned int count, unsigned int address)
             {
                 if(parent!=NULL)
                     return parent->Write(Value,count,address);
                 return 0;
             }

ahbuartplugin/ahbuartplugin.cpp +9 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include <socexplorerengine.h>
             #include "ahbuartplugin.h"
             #include <unistd.h>
             #include <errno.h>
             #include <QApplication>
             #include <QProgressBar>
             #include <stdio.h>
             #include <QThread>
             #include "ahbuartpywrapper.h"
             #include <QCompleter>
             #include <QStringList>
             #include <QLineEdit>
             #include <socexplorerproxy.h>
             ahbuartplugin::ahbuartplugin(QWidget *parent):socexplorerplugin(parent,false)
             {
                 this->port =(rs232port_t)NULL;
                 this->portMutex = new QMutex(QMutex::Recursive);
                 this->UI = new ahbUartPluginUI();
                 this->setWidget((QWidget*)this->UI);
                 this->setWindowTitle(tr("AHB UART"));
                 QObject::connect(this,SIGNAL(activateSig(bool)),this->UI,SLOT(setConnected(bool)));
                 QObject::connect(this->UI,SIGNAL(connectPortsig(QString,int)),this,SLOT(togglePort(QString,int)));
                 this->pyObject = new ahbuartPywrapper(this);
                 QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(open(QString,int)),this,SLOT(open(QString,int)));
                 QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(close()),this,SLOT(close()));
                 QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(ReadBytes(uint,uint)),this,SLOT(ReadBytes(uint,uint)));
                 QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(WriteBytes(uint,QList<QVariant>)),this,SLOT(WriteBytes(uint,QList<QVariant>)));
                 QObject::connect(this->UI,SIGNAL(rescanPorts()),this,SLOT(updatePortList()));
                 this->portListcompleter = NULL;
                 this->scanDone = false;
                 updatePortList();
             }
             ahbuartplugin::~ahbuartplugin()
             {
                 if(this->port!=(rs232port_t)NULL)
                 {
                     rs232close(this->port);
                     this->port = (rs232port_t)NULL;
                 }
                 this->UI->close();
                 this->UI->~ahbUartPluginUI();
             }
             void ahbuartplugin::closeMe()
             {
                 if(this->port!=(rs232port_t)NULL)
                 {
                     rs232close(this->port);
                     this->port = (rs232port_t)NULL;
                 }
                 emit this->closePlugin(this);
             }
             int ahbuartplugin::registermenu(QMainWindow *menuHolder)
             {
                 this->menu = menuHolder->menuBar()->addMenu(tr("&AHB UART"));
                 this->closeAction = this->menu->addAction(tr("Close plugin"));
                 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
                 return 1;
             }
             bool ahbuartplugin::checkConnection()
             {
                 QTime timeout;
                 char test[5] ={(char)0x80,(char)0x80,(char)0,(char)0,(char)0};
                 char test2[1024];
                 int writen =0;
                 int read = 0;
                 timeout.start();
                 SocExplorerEngine::message(this,"Check connection",2);
                 while(writen!=5)
                 {
                     writen+=rs232write(this->port,test+writen,5-writen);
                     if(timeout.elapsed()>1000)
                     {
                         SocExplorerEngine::message(this,"Can't write any data on serial port",2);
                         return false;
                     }
                 }
+            #ifdef WIN32
+                        usleep(1000);
+            #endif
                 timeout.restart();
                 while(read!=4)
                 {
                     read += rs232read(this->port,test2,4-read);
                     if(timeout.elapsed()>1000) break;
                 }
                 if(read>0)
                 {
                     SocExplorerEngine::message(this,"Connection Ok",2);
                     return true;
                 }
                 else
                 {
                     SocExplorerEngine::message(this,"Connection Error",2);
                     return false;
                 }
             }
             void ahbuartplugin::connectPort(QString PortName, int baudrate)
             {
                 QTime timeout;
                 SocExplorerEngine::message(this,"Try to connect to port "+PortName,2);
                 timeout.start();
                 if(this->port==(rs232port_t)NULL)
                 {
                     SocExplorerEngine::message(this,"Open port "+PortName,2);
                     this->port=rs232open((char*)PortName.toStdString().c_str());
                 }
                 if(this->port!=badPortValue)
                 {
                     SocExplorerEngine::message(this,"Port opened "+PortName,2);
                     SocExplorerEngine::message(this,"Configure port "+PortName,2);
                     rs232setup(this->port,8,baudrate,rs232parityNo,rs232OneStop);
                     char test[7] ={(char)0x55,(char)0x51,(char)0x80,(char)0x80,(char)0x0,(char)0x0,(char)0x14};
                     char test2[1024];
                     SAFEWRITE(test,1,timeout,2000,return);
                     SAFEWRITE((test+1),1,timeout,2000,return);
                     APPENDTOLOG(QString("Flush port "));
                     rs232read(this->port,test2,512);
                     int read = 0;
                     for(int i=0;i<10;i++)
                     {
                         SocExplorerEngine::message(this,"Send test patern :0x55,0x55,0x80,0x80,0x0,0x0,0x14",2);
                         SAFEWRITE(test+2,5,timeout,2000,return);
                         SocExplorerEngine::message(this,"Read Result",2);
                         read=rs232read(this->port,test2+read,16);
                         SocExplorerEngine::message(this,QString("Get ") + QString::number(read) + " bytes",2);
                         if(read>0)
                         {
                             SocExplorerEngine::message(this,"Flush port ",2);
                             while(rs232read(this->port,test2,1)>0);
                             this->Connected = true;
                             SocExplorerEngine::message(this,QString("Connection success on ")+PortName,2);
                             emit this->activate(true);
                             if(this->scanDone==false)
                             {
                                 socexplorerproxy::loadChildSysDriver(this,"AMBA_PLUGIN");
                                 this->scanDone=true;
                             }
                             break;
                         }
                     }
                 }
                 else
                 {
                     SocExplorerEngine::message(this,QString("Port not opened ")+PortName,2);
                     this->port = (rs232port_t)NULL;
                     this->Connected = false;
                     emit this->activateSig(false);
                     return;
                 }
                 if(this->Connected == false)
                 {
                     SocExplorerEngine::message(this,QString("Port not opened ")+PortName,2);
                     rs232close(this->port);
                     this->port = (rs232port_t)NULL;
                     emit this->activateSig(false);
                 }
             }
             bool ahbuartplugin::open(QString PortName,int baudrate)
             {
                 if(this->port!=(rs232port_t)NULL)
                     this->close();
                 this->UI->setconfig(PortName,baudrate);
                 this->connectPort(PortName,baudrate);
                 return (this->port!=(rs232port_t)NULL);
             }
             void ahbuartplugin::close()
             {
                 if(this->port!=(rs232port_t)NULL)
                 {
                     rs232close(this->port);
                     this->port = (rs232port_t)NULL;
                     this->Connected = false;
                     emit this->activateSig(false);
                 }
             }
             void ahbuartplugin::togglePort(QString PortName,int baudrate)
             {
                 if(this->port!=(rs232port_t)NULL)
                 {
                     this->close();
                 }
                 else
                 {
                     this->connectPort(PortName,baudrate);
                 }
             }
             unsigned int ahbuartplugin::Read(unsigned int *Value,unsigned int count,unsigned int address)
             {
                 QTime timeout;
                 timeout.start();
                 unsigned int read=0;
                 unsigned int cnt=count;
                 unsigned int nextUpdateTrig=0,updateStep=512;
                 SocExplorerEngine::message(this,QString("Read ")+ QString::number(count) + QString(" words @0x")+ QString::number(address,16),2);
                 if((this->port!= badPortValue)||(this->port!=(rs232port_t)NULL))
                 {
                     if(!this->portMutex->tryLock())
                         return 0;
                     if(!this->checkConnection())
                     {
                         this->Connected = false;
                         emit this->activateSig(false);
                         this->portMutex->unlock();
                         return 0;
                     }
                     QProgressBar* progress=NULL;
                     if(cnt>128)
                         progress= SocExplorerEngine::getProgressBar("Reading on uart @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                     char CMD[5];
                     char* result = (char*)malloc(count*4);
                     while(count>32)
                     {
                         CMD[0] = 0x80 |  (32-1);
                         CMD[1] = (char)((address>>24)&0xFF);
                         CMD[2] = (char)((address>>16)&0xFF);
                         CMD[3] = (char)((address>>8)&0xFF);
                         CMD[4] = (char)((address)&0xFF);
             //            APENDTABLETOLOG(CMD,5,logmessage,"Write CMD : ");
                         SAFEWRITE(CMD,5,timeout,1000,return 0);
+            #ifdef WIN32
+                        usleep(1000);
+            #endif
                         SAFEREAD(result+((cnt-count)*4),32*4,timeout,1000,return 0);
             //            APENDTABLETOLOG((result+((cnt-count)*4)),32*4,logmessage, QString("Get ") + QString::number(32*4) + " Bytes : ");
                         count-=32;
                         address+=32*4;
                         if(cnt>128)
                         {
                             if((cnt-count)>=nextUpdateTrig)
                             {
                                 progress->setValue(cnt-count);
                                 qApp->processEvents();
                                 nextUpdateTrig+=updateStep;
                             }
                         }
                     }
                     if(count>0)
                     {
                         CMD[0] = 0x80 |  (count-1);
                         CMD[1] = (char)((address>>24)&0xFF);
                         CMD[2] = (char)((address>>16)&0xFF);
                         CMD[3] = (char)((address>>8)&0xFF);
                         CMD[4] = (char)((address)&0xFF);
                         SAFEWRITE(CMD,5,timeout,1000,return 0);
+            #ifdef WIN32
+                        usleep(1000);
+            #endif
                         SAFEREAD(result+((cnt-count)*4),(count*4),timeout,1000,return 0);
             //            APENDTABLETOLOG((result+((cnt-count)*4)),(count*4),logmessage, QString("Get ") + QString::number(32*4) + " Bytes : ");
                     }
                     if(cnt>128)
                     {
                         progress->setValue(cnt-count);
                         qApp->processEvents();
                     }
                     for(int i=0;(unsigned int)i<cnt;i++)
                     {
                         for(int j =0;j<4;j++)
                         {
                             Value[i]= ((unsigned char)(result[i*4+j])) + Value[i]*256;
                         }
                         read = cnt*4;
                     }
                     if(cnt>128)
                         SocExplorerEngine::deleteProgressBar(progress);
                     free(result);
                     this->portMutex->unlock();
                 }
                 return read/4;
             }
             unsigned int ahbuartplugin::Write(unsigned int *Value,unsigned int count, unsigned int address)
             {
                 QTime timeout;
                 timeout.start();
                 unsigned int writen=0;
                 unsigned int nextUpdateTrig=0,updateStep=512;
                 SocExplorerEngine::message(this,QString("Write ")+ QString::number(count) + QString(" words @0x")+ QString::number(address,16),2);
                 if((this->port!= badPortValue)||(this->port!=(rs232port_t)NULL))
                 {
                     if(!this->portMutex->tryLock())
                         return 0;
                     if(!this->checkConnection())
                     {
                         emit this->activateSig(false);
                         this->Connected = false;
                         this->portMutex->unlock();
                         return 0;
                     }
                     QProgressBar* progress = NULL;
                     if(count>128)
                         progress = SocExplorerEngine::getProgressBar("Writing on uart @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                     int offset = 0;
                     char* CMD= (char*)malloc((32*4)+5);
                     while(count>32)
                     {
                         writen=0;
                         CMD[0] = 0xC0 |  (32-1);
                         CMD[1] = (char)(((unsigned int)address>>24)&0xFF);
                         CMD[2] = (char)(((unsigned int)address>>16)&0xFF);
                         CMD[3] = (char)(((unsigned int)address>>8)&0xFF);
                         CMD[4] = (char)(((unsigned int)address)&0xFF);
                         for(int i=0;i<32;i++)
                         {
                             CMD[(i*4)+5] = (char)(((unsigned int)Value[i+offset]>>24)&0xFF);
                             CMD[(i*4)+6] = (char)(((unsigned int)Value[i+offset]>>16)&0xFF);
                             CMD[(i*4)+7] = (char)(((unsigned int)Value[i+offset]>>8)&0xFF);
                             CMD[(i*4)+8] = (char)(((unsigned int)Value[i+offset])&0xFF);
                         }
                         SAFEWRITE(CMD,((32*4)+5),timeout,1000,return 0);
                         writen+=32;
                         count-=32;
                         offset+=32;
                         address+=32*4;
                         if(offset>=nextUpdateTrig && progress!=NULL)
                         {
                             progress->setValue(offset);
                             qApp->processEvents();
                             nextUpdateTrig +=updateStep;
                         }
                     }
                     if(count>0)
                     {
                         CMD[0] = 0xC0 |  (count-1);
                         CMD[1] = (char)(((unsigned int)address>>24)&0xFF);
                         CMD[2] = (char)(((unsigned int)address>>16)&0xFF);
                         CMD[3] = (char)(((unsigned int)address>>8)&0xFF);
                         CMD[4] = (char)(((unsigned int)address)&0xFF);
                         for(int i=0;(unsigned int) i<(count);i++)
                         {
                             CMD[(i*4)+5] = (char)(((unsigned int)Value[i+offset]>>24)&0xFF);
                             CMD[(i*4)+6] = (char)(((unsigned int)Value[i+offset]>>16)&0xFF);
                             CMD[(i*4)+7] = (char)(((unsigned int)Value[i+offset]>>8)&0xFF);
                             CMD[(i*4)+8] = (char)(((unsigned int)Value[i+offset])&0xFF);
                         }
                         SAFEWRITE(CMD,((count*4)+5),timeout,1000,return 0);
                         writen+=count;
                     }
                     if(progress!=NULL)
                     {
                         progress->setValue(writen);
                         qApp->processEvents();
                         SocExplorerEngine::deleteProgressBar(progress);
                     }
                     free(CMD);
                     this->portMutex->unlock();
                     return writen;
                 }
                 return 0;
             }
             void ahbuartplugin::updatePortList()
             {
                 if(this->portListcompleter==(QCompleter*)NULL)
                 {
                     this->portListcompleter=new QCompleter(this);
                     this->portListcompleter->setCaseSensitivity(Qt::CaseInsensitive);
                     this->portListcompleterModel = new QStringListModel(this);
                     this->portListcompleter->setModel(this->portListcompleterModel);
                     this->UI->setCompleter(this->portListcompleter);
                 }
                 rs232portslist_t* portlist = rs232getportlist();
                 rs232portslist_t* portlistenum = portlist;
                 QStringList wordList;
                 while(portlistenum!=NULL)
                 {
                     wordList << portlistenum->name;
                     portlistenum = portlistenum->next;
                 }
                 rs232deleteportlist(portlist);
                 this->portListcompleterModel->setStringList(wordList);
             }
             QVariantList ahbuartplugin::ReadBytes(unsigned int address, unsigned int count)
             {
                 unsigned int data[(count/4)+1];
                 QVariantList result;
                 this->Read(data,(count/4)+1,address);
                 for(unsigned int i = 0;i<count/4;i++)
                 {
                     result.append(QVariant((int)(0x0FF&(data[i]>>24))));
                     result.append(QVariant((int)(0x0FF&(data[i]>>16))));
                     result.append(QVariant((int)(0x0FF&(data[i]>>8))));
                     result.append(QVariant((int)(0x0FF&(data[i]))));
                 }
                 for(int i=0;i<(count%4);i++)
                 {
                     result.append(QVariant((int)(0x0FF&(data[count/4]>>((3-i)*8)))));
                 }
                 return result;
             }
             void ahbuartplugin::WriteBytes(unsigned int address, QList<QVariant> dataList)
             {
                 unsigned int data[dataList.count()/4];
                 for(int i = 0;i<(dataList.count()/4);i++)
                 {
                     data[i] = 0x0FF & ((unsigned int)dataList.at(4*i).toUInt());
                     data[i] =  (data[i]<<8) + (0x0FF & ((unsigned int)dataList.at((4*i)+1).toUInt()));
                     data[i] =  (data[i]<<8) + (0x0FF & ((unsigned int)dataList.at((4*i)+2).toUInt()));
                     data[i] =  (data[i]<<8) + (0x0FF & ((unsigned int)dataList.at((4*i)+3).toUInt()));
                 }
                 this->Write(data,dataList.count()/4,address);
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages