HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorerPlugins Commit - r60:dbbb04783771

dsu3plugin:...

jeandet -

r60:dbbb04783771 default

parent child

Context file:

r60:dbbb04783771

dsu3plugin/dsu3plugin.cpp +20 -22

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - 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 "dsu3plugin.h"
             #include <QFileDialog>
             #include <QDir>
             #include <socexplorerengine.h>
             struct acceptedMemctrlr_str
             {
                 int vid;
                 int pid;
                 const char* name;
             };
             const struct acceptedMemctrlr_str acceptedMemctrlr[]=
             {
             {0x04,0x0f,"MCTRL"},
             {0x01,0x51,"FTSRCTRL"},
             {0x20,0x01,"SRCTRLE_0WS" },
             {0x20,0x02,"SRCTRLE_1WS" }
             };
             #define acceptedMemctrlrCnt 4
             dsu3plugin::dsu3plugin(QWidget *parent):socexplorerplugin(parent,false)
             {
                 this->UI = new dsu3pluginui();
                 this->setWidget((QWidget*)this->UI);
-                this->elfparserInst = new elfparser();
+                this->elfFile = new ElfFile();
-            //    this->pyObject = new dsu3pluginPywrapper(this);
-            //    QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(openFile(QString)),this,SLOT(openFile(QString)));
-            //    QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(loadFile()),this,SLOT(flashTarget()));
-            //    QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(run()),this,SLOT(run()));
-            //    QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(stop()),this,SLOT(stop()));
-            //    QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(cacheEnable()),this,SLOT(cacheEnable()));
-            //    QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(cacheDisable()),this,SLOT(cacheDisable()));
-            //    QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(setCacheEnable(bool)),this,SLOT(setCacheEnable(bool)));
                 connect(this->UI,SIGNAL(openFile()),this,SLOT(openFile()));
                 connect(this->UI,SIGNAL(flashTarget()),this,SLOT(flashTarget()));
                 connect(this->UI,SIGNAL(run()),this,SLOT(toggleRun()));
-                connect(this,SIGNAL(updateInfo(elfparser*)),this->UI,SIGNAL(updateInfo(elfparser*)));
+                connect(this,SIGNAL(updateInfo(ElfFile*)),this->UI,SLOT(updateInfo(ElfFile*)));
                 this->running = false;
             }
             dsu3plugin::~dsu3plugin()
             {
             }
             void dsu3plugin::openFile()
             {
                 QString filename = QFileDialog::getOpenFileName(this,tr("Open elf File"), QDir::homePath(), tr("Elf Files (*)"));
                 if(filename!="")
                 {
                     this->openFile(filename);
                 }
             }
             void dsu3plugin::openFile(QString fileName)
             {
-                this->elfparserInst->setFilename(fileName);
+                this->elfFile->openFile(fileName);
-                emit this->updateInfo(this->elfparserInst);
+                emit this->updateInfo(this->elfFile);
             }
             bool dsu3plugin::configureTarget()
             {
                 int detectedMctrlr=-1;
                 if(parent==NULL)
                     return false;
                 unsigned int DSUBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x004,0);
                 if(DSUBASEADDRESS == (unsigned int)-1)
                     DSUBASEADDRESS = 0x90000000;
                 unsigned int MCTRLBASEADDRESS =-1;
                 for(int i=0; i<acceptedMemctrlrCnt;i++)
                 {
                     MCTRLBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,acceptedMemctrlr[i].vid , acceptedMemctrlr[i].pid,0);
                     if(MCTRLBASEADDRESS != (unsigned int)-1)
                     {
                         SocExplorerEngine::message(this,QString("Found %1 @%2").arg(acceptedMemctrlr[i].name).arg(MCTRLBASEADDRESS,8,16),1);
                         detectedMctrlr=i;
                         break;
                     }
                 }
                 if(MCTRLBASEADDRESS == (unsigned int)-1)
                 {
                     SocExplorerEngine::message(this,"Can't any compatible memory controller",1);
                     return false;
                 }
                 //Force a debug break
                 WriteRegs(uIntlist()<<0x0000002f,(unsigned int)DSUBASEADDRESS);
                 WriteRegs(uIntlist()<<0x0000ffff,(unsigned int)DSUBASEADDRESS+0x20);
                 //Clear time tag counter
                 WriteRegs(uIntlist()<<0,(unsigned int)DSUBASEADDRESS+0x8);
                 //Clear ASR registers
                 WriteRegs(uIntlist()<<0<<0<<0,(unsigned int)DSUBASEADDRESS+0x400040);
                 WriteRegs(uIntlist()<<0x2,(unsigned int)DSUBASEADDRESS+0x400024);
                 WriteRegs(uIntlist()<<0<<0<<0<<0<<0<<0<<0<<0,(unsigned int)DSUBASEADDRESS+0x400060);
                 WriteRegs(uIntlist()<<0,(unsigned int)DSUBASEADDRESS+0x48);
                 WriteRegs(uIntlist()<<0,(unsigned int)DSUBASEADDRESS+0x000004C);
                 WriteRegs(uIntlist()<<0,(unsigned int)DSUBASEADDRESS+0x400040);
             //    {0x04,0x0f,"MCTRL"},
             //    {0x01,0x51,"FTSRCTRL"},
             //    {0x20,0x01,"SRCTRLE_0WS" },
             //    {0x20,0x02,"SRCTRLE_1WS" }
                 if(QString(acceptedMemctrlr[detectedMctrlr].name)=="MCTRL" || QString(acceptedMemctrlr[detectedMctrlr].name)=="FTSRCTRL" )
                 {
                     WriteRegs(uIntlist()<<0x2FF<<0xE60<<0,(unsigned int)MCTRLBASEADDRESS);
                 }
                 if(QString(acceptedMemctrlr[detectedMctrlr].name)=="SRCTRLE_0WS" || QString(acceptedMemctrlr[detectedMctrlr].name)=="SRCTRLE_1WS" )
                 {
                     //let's perform a mem Wash
                     unsigned int val = ReadReg(MCTRLBASEADDRESS);
                     val |=1<<31;
                     WriteRegs(uIntlist()<<val,(unsigned int)MCTRLBASEADDRESS);
                     usleep(1000*1000);
                 }
                 WriteRegs(uIntlist()<<0<<0<<0<<0,(unsigned int)DSUBASEADDRESS+0x400060);
                 WriteRegs(uIntlist()<<0x0000FFFF,(unsigned int)DSUBASEADDRESS+0x24);
                 memSet(DSUBASEADDRESS+0x300000,0,1567);
                 WriteRegs(uIntlist()<<0<<0xF30000E0<<0x00000002<<0x40000000<<0x40000000<<0x40000004<<0x1000000,(unsigned int)DSUBASEADDRESS+0x400000);
                 WriteRegs(uIntlist()<<0<<0<<0<<0<<0<<0<<0x403ffff0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0,(unsigned int)DSUBASEADDRESS+0x300020);
                 WriteRegs(uIntlist()<<0x000002EF,(unsigned int)DSUBASEADDRESS);
                 //Disable interrupts
                 unsigned int APBIRQCTRLRBASEADD = (unsigned int)SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,1,0x0d,0);
                 if(APBIRQCTRLRBASEADD == (unsigned int)-1)
                     return false;
                 WriteRegs(uIntlist()<<0x00000000,APBIRQCTRLRBASEADD+0x040);
                 WriteRegs(uIntlist()<<0xFFFE0000,APBIRQCTRLRBASEADD+0x080);
                 WriteRegs(uIntlist()<<0<<0,APBIRQCTRLRBASEADD);
                 //Set up timer
                 unsigned int APBTIMERBASEADD = (unsigned int)SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,1,0x11,0);
                 if(APBTIMERBASEADD == (unsigned int)-1)
                     return false;
                 WriteRegs(uIntlist()<<0xffffffff,APBTIMERBASEADD+0x014);
                 WriteRegs(uIntlist()<<0x00000018,APBTIMERBASEADD+0x04);
                 WriteRegs(uIntlist()<<0x00000007,APBTIMERBASEADD+0x018);
                 return true;
             }
             bool dsu3plugin::cacheDisable()
             {
                 return setCacheEnable(false);
             }
             bool dsu3plugin::cacheEnable()
             {
                 return setCacheEnable(true);
             }
             bool dsu3plugin::setCacheEnable(bool enabled)
             {
                 if(parent==NULL)
                     return false;
                 unsigned int DSUBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x004,0);
                 if(DSUBASEADDRESS == (unsigned int)-1)
                     DSUBASEADDRESS = 0x90000000;
                 WriteRegs(uIntlist()<<2,DSUBASEADDRESS+0x400024);
                 unsigned int reg = ReadReg(DSUBASEADDRESS+0x700000);
                 if(enabled)
                 {
                     WriteRegs(uIntlist()<<(0x0001000F|reg),DSUBASEADDRESS+0x700000);
                     //flushes cache.
                     WriteRegs(uIntlist()<<(0x0061000F|reg),DSUBASEADDRESS+0x700000);
                 }
                 else
                 {
                     WriteRegs(uIntlist()<<((!0x0001000F)&reg),DSUBASEADDRESS+0x700000);
                     WriteRegs(uIntlist()<<(0x00600000|reg),DSUBASEADDRESS+0x700000);
                 }
                 return true;
             }
             bool dsu3plugin::flashTarget()
             {
                 stop();
                 cacheDisable();
                 configureTarget();
                 /*Write .text*/
                 this->writeSection(".text");
                 /*Write .data*/
                 this->writeSection(".data");
                 return true;
             }
             void dsu3plugin::run()
             {
                 unsigned int DSUBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x004,0);
                 if(DSUBASEADDRESS == (unsigned int)-1)
                     DSUBASEADDRESS = 0x90000000;
                 WriteRegs(uIntlist()<<0,DSUBASEADDRESS+0x020);
                 this->running = true;
                 this->UI->setRunning(true);
             }
             void dsu3plugin::stop()
             {
                 unsigned int DSUBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x004,0);
                 if(DSUBASEADDRESS == (unsigned int)-1)
                     DSUBASEADDRESS = 0x90000000;
                 WriteRegs(uIntlist()<<0xFFFF,DSUBASEADDRESS+0x020);
                 this->running = false;
                 this->UI->setRunning(false);
             }
             void dsu3plugin::toggleRun()
             {
                 if(this->running)
                     this->stop();
                 else
                     this->run();
             }
+            bool dsu3plugin::dumpSymbol(const QString &symbolName, QString file, const QString &format)
+            {
+                if(this->elfFile->isopened())
+                {
+                    int symbolIndex=this->elfFile->getSymbolIndex(symbolName);
+                    if(symbolIndex!=-1)
+                        return this->dumpMemory(this->elfFile->getSymbolAddress(symbolIndex),this->elfFile->getSymbolSize(symbolIndex)/4,file,format);
+                }
+                return false;
+            }
             void dsu3plugin::WriteRegs(uIntlist Values, unsigned int address)
             {
                 unsigned int* buff;
                 buff = (unsigned int*)malloc(Values.count()*sizeof(unsigned int));
                 for(int i=0;i<Values.count();i++)
                 {
                     buff[i]=Values.at(i);
                 }
                 parent->Write(buff,(unsigned int)Values.count(),address);
                 free(buff);
             }
             unsigned int dsu3plugin::ReadReg(unsigned int address)
             {
                 unsigned int buff;
                 parent->Read(&buff,1,address);
                 return buff;
             }
             void dsu3plugin::writeSection(int index)
             {
                 char* buffch=NULL;
                 unsigned int* buff;
-                int size = this->elfparserInst->getSectionDatasz(index);
+                int size = this->elfFile->getSectionDatasz(index);
                 int sizeInt = size/4;
                 if(parent==NULL)
                     return;
-                this->elfparserInst->getSectionData(index,&buffch);
+                this->elfFile->getSectionData(index,&buffch);
                 buff = (unsigned int*)malloc(((size/4)+1)*sizeof(unsigned int));
                 for(int i=0;i<sizeInt;i++)
                 {
                     buff[i] = 0x0FF & ((unsigned int)buffch[4*i]);
                     buff[i] =  (buff[i]<<8) + (0x0FF & ((unsigned int)buffch[(4*i)+1]));
                     buff[i] =  (buff[i]<<8) + (0x0FF & ((unsigned int)buffch[(4*i)+2]));
                     buff[i] =  (buff[i]<<8) + (0x0FF & ((unsigned int)buffch[(4*i)+3]));
                 }
                 if(size%4)
                 {
                     buff[sizeInt]=0;
                     for(int i=(size%4);i>0;i--)
                     {
                         buff[sizeInt] =  (buff[sizeInt]<<8) + (0x0FF & ((unsigned int)buffch[size-i]));
                     }
                     sizeInt++;
                 }
-                parent->Write(buff,(unsigned int)sizeInt,(unsigned int)this->elfparserInst->getSectionPaddr(index));
+                parent->Write(buff,(unsigned int)sizeInt,(unsigned int)this->elfFile->getSectionPaddr(index));
                 free(buff);
             }
             void dsu3plugin::writeSection(const QString &name)
             {
-                for(int i=0;i<this->elfparserInst->getSectioncount();i++)
+                if(elfFile->isopened())
-                    if(!this->elfparserInst->getSectionName(i).compare(name))
                 {
-                        printf("about to write section %s @ 0x%x size = %d\n",elfparserInst->getSectionName(i).toStdString().c_str(),elfparserInst->getSectionPaddr(i),elfparserInst->getSectionMemsz(i));
+                    writeSection(this->elfFile->getSectionIndex(name));
-                        writeSection(i);
                 }
             }
             unsigned int dsu3plugin::Write(unsigned int *Value,unsigned int count,unsigned  int address)
             {
                 if(parent!=NULL)
                     return parent->Write(Value,count,address);
                 return 0;
             }
             bool dsu3plugin::memSet(unsigned int address,int value, unsigned int count)
             {
                 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
                 if(buffer!=NULL)
                 {
                     memset((void*)buffer,value,count*sizeof(unsigned int));
                     parent->Write(buffer,count,address);
                     free(buffer );
                     return true;
                 }
                 return false;
             }
             unsigned int dsu3plugin::Read(unsigned int *Value,unsigned int count, unsigned int address)
             {
                 if(parent!=NULL)
                     return parent->Read(Value,count,address);
                 return 0;
             }

dsu3plugin/dsu3plugin.h +5 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2012, Plasma Physics Laboratory - 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
             ----------------------------------------------------------------------------*/
             #ifndef DSU3PLUGIN_H
             #define DSU3PLUGIN_H
             #include "dsu3pluginui.h"
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QMainWindow>
             #include <QList>
             #include "elfparser.h"
+            #include <elffile.h>
             #include <socexplorerplugin.h>
             #include <socexplorerengine.h>
             typedef QList<unsigned int> uIntlist;
             class dsu3plugin : public socexplorerplugin
             {
                 Q_OBJECT
             public:
                 explicit dsu3plugin(QWidget *parent = 0);
                 ~dsu3plugin();
                 bool memSet(unsigned int address, int value, unsigned int count);
             public slots:
                 unsigned int Write(unsigned int *Value,unsigned int count,unsigned  int address=0);
                 unsigned int Read(unsigned int *Value,unsigned int count, unsigned int address=0);
                 void openFile();
                 void openFile(QString fileName);
                 bool configureTarget();
                 bool cacheDisable();
                 bool cacheEnable();
                 bool setCacheEnable(bool enabled);
                 bool flashTarget();
                 void run();
                 void stop();
                 void toggleRun();
                 //added for python backward compatibility
                 void loadFile(){this->flashTarget();}
+                bool dumpSymbol(const QString& symbolName,QString file,const QString& format);
             signals:
-                void updateInfo(elfparser* parser);
+                void updateInfo(ElfFile* elfFile);
             private:
                 void WriteRegs(uIntlist Values, unsigned int address);
                 unsigned int ReadReg(unsigned int address);
                 void writeSection(int index);
                 void writeSection(const QString& name);
                 dsu3pluginui* UI;
-                elfparser* elfparserInst;
+                ElfFile* elfFile;
                 bool running;
             };
             #endif // DSU3PLUGIN_H

dsu3plugin/dsu3pluginui.cpp +7 -3

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2013, Plasma Physics Laboratory - 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 <dsu3pluginui.h>
             dsu3pluginui::dsu3pluginui(QWidget *parent)
                 :QWidget(parent)
             {
                 this->openFileQpb = new QPushButton(tr("Open File"));
                 this->flashTargetQpb = new QPushButton(tr("Flash Target"));
                 this->runQpb = new QPushButton(tr("Run"));
                 this->mainLayout = new QGridLayout();
-                this->elfInfoWdgtInst = new elfInfoWdgt;
+                this->elfFileWidgetInst = new elfFileWidget();
                 this->mainLayout->addWidget(this->openFileQpb,0,0,1,1);
                 this->mainLayout->addWidget(this->flashTargetQpb,0,1,1,1);
                 this->mainLayout->addWidget(this->runQpb,0,2,1,1);
-                this->mainLayout->addWidget(this->elfInfoWdgtInst,1,0,1,-1);
+                this->mainLayout->addWidget(this->elfFileWidgetInst,1,0,1,-1);
                 this->setLayout(this->mainLayout);
                 connect(this->openFileQpb,SIGNAL(clicked()),this,SIGNAL(openFile()));
                 connect(this->flashTargetQpb,SIGNAL(clicked()),this,SIGNAL(flashTarget()));
                 connect(this->runQpb,SIGNAL(clicked()),this,SIGNAL(run()));
-                connect(this,SIGNAL(updateInfo(elfparser*)),this->elfInfoWdgtInst,SLOT(updateInfo(elfparser*)));
             }
             void dsu3pluginui::setRunning(bool running)
             {
                 if(running)
                     this->runQpb->setText("Stop");
                 else
                     this->runQpb->setText("Run");
             }
+            void dsu3pluginui::updateInfo(ElfFile *file)
+            {
+                this->elfFileWidgetInst->setFile(file);
+            }

dsu3plugin/dsu3pluginui.h +4 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2012, Plasma Physics Laboratory - 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
             ----------------------------------------------------------------------------*/
             #ifndef DSU3PLUGINUI_H
             #define DSU3PLUGINUI_H
             #include <QWidget>
             #include <QHBoxLayout>
             #include <QPushButton>
             #include <qhexedit.h>
             #include <QSplitter>
             #include <QVBoxLayout>
             #include <QGridLayout>
             #include "elfinfowdgt.h"
+            #include <elffile.h>
+            #include <elffilewidget.h>
             class dsu3pluginui : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit dsu3pluginui(QWidget *parent = 0);
             public slots:
                 void setRunning(bool running);
+                void updateInfo(ElfFile* file);
             signals:
                 void openFile();
-                void updateInfo(elfparser* parser);
                 bool flashTarget();
                 void run();
             private:
                 QGridLayout* mainLayout;
                 QPushButton* openFileQpb;
                 QPushButton* flashTargetQpb;
                 QPushButton* runQpb;
-                elfInfoWdgt* elfInfoWdgtInst;
+                elfFileWidget* elfFileWidgetInst;
             };
             #endif // DSU3PLUGINUI_H

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