code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Plugins/SystemPlugins/FPGAUpgrade/plugin.py

   1 import os, fcntl, thread
   2
   3 from enigma import eTimer
   4
   5 from urllib import urlretrieve
   6 import urllib
   7
   8 from Screens.Screen import Screen
   9 from Screens.MessageBox import MessageBox
  10
  11 from Plugins.Plugin import PluginDescriptor
  12
  13 from Tools.Directories import fileExists
  14
  15 from Components.Label import Label
  16 from Components.Slider import Slider
  17 from Components.Pixmap import Pixmap
  18 from Components.FileList import FileList
  19 from Components.ActionMap import ActionMap
  20 from Components.PluginComponent import plugins
  21 from Components.Sources.StaticText import StaticText
  22
  23 STATUS_READY            = 0
  24 STATUS_DONE             = 1
  25 STATUS_ERROR            = 2
  26 STATUS_PREPARED         = 3
  27 STATUS_PROGRAMMING      = 4
  28
  29 class FPGAUpgradeCore() :
  30         status = STATUS_READY
  31         errmsg = ''
  32         callcount       = 0
  33         MAX_CALL_COUNT  = 1500
  34         def __init__(self, firmwarefile, devicefile):
  35                 print '[FPGAUpgrade]'
  36                 self.devicefile = devicefile
  37                 self.firmwarefile = firmwarefile
  38
  39         def doUpgrade(self):
  40                 firmware,device = None,None
  41                 def closefpga(fp, fd):
  42                         if fd is not None: os.close(fd)
  43                         if fp is not None: fp.close()
  44                 try:
  45                         size = os.path.getsize(self.firmwarefile)
  46                         if size == 0: raise Exception, 'data_size is zero'
  47                         #print '[FPGAUpgradeCore] data_size :',size
  48
  49                         firmware = open(self.firmwarefile, 'rb')
  50                         device = os.open(self.devicefile, os.O_RDWR)
  51                         #print '[FPGAUpgradeCore] open >> [ok]'
  52
  53                         rc = fcntl.ioctl(device, 0, size)
  54                         if rc < 0: raise Exception, 'fail to set size : %d'%(rc)
  55                         #print '[FPGAUpgradeCore] set size >> [ok]'
  56
  57                         rc = fcntl.ioctl(device, 2, 5)
  58                         if rc < 0: raise Exception, 'fail to set programming mode : %d'%(rc)
  59                         #print '[FPGAUpgradeCore] programming mode >> [ok]'
  60                         self.status = STATUS_PREPARED
  61
  62                         while True:
  63                                 data = firmware.read(1024)
  64                                 if data == '': break
  65                                 os.write(device, data)
  66                         #print '[FPGAUpgradeCore] write data >> [ok]'
  67
  68                         self.status = STATUS_PROGRAMMING
  69                         rc = fcntl.ioctl(device, 1, 0)
  70                         if rc < 0: raise Exception, 'fail to programming : %d'%(rc)
  71                         #print '[FPGAUpgradeCore] upgrade done.'
  72                         if self.callcount < 100: raise Exception, 'wrong fpga file.'
  73                 except Exception, msg:
  74                         self.errmsg = msg
  75                         print '[FPGAUpgradeCore] ERROR >>',msg
  76                         closefpga(firmware, device)
  77                         return STATUS_ERROR
  78                 closefpga(firmware, device)
  79                 return STATUS_DONE
  80
  81         def upgradeMain(self):
  82                 self.status = STATUS_READY
  83                 self.status = self.doUpgrade()
  84                 if self.status == STATUS_DONE:
  85                         print '[FPGAUpgrade] upgrade done.'
  86                 elif self.status == STATUS_ERROR:
  87                         print '[FPGAUpgrade] occur error.'
  88                 else:   print '[FPGAUpgrade] occur unknown error.'
  89
  90 class FPGAUpgradeManager:
  91         fu = None
  92         def get_interval(self):
  93                 return 200
  94
  95         def fpga_upgrade(self, datafile, device):
  96                 self.fu = FPGAUpgradeCore(firmwarefile=datafile, devicefile=device)
  97                 thread.start_new_thread(self.fu.upgradeMain, ())
  98
  99         def checkError(self):
 100                 if self.fu.status == STATUS_ERROR:
 101                         self.fu.callcount = 0
 102                         return True
 103                 return False
 104
 105         def get_status(self):
 106                 if self.fu.status == STATUS_READY:
 107                         return 0
 108                 elif self.fu.status == STATUS_ERROR:
 109                         return -1
 110                 elif self.fu.status == STATUS_PREPARED:
 111                         return 2
 112                 elif self.fu.status == STATUS_PROGRAMMING:
 113                         self.fu.callcount += 1
 114                         ret = (self.fu.callcount * 100) / self.fu.MAX_CALL_COUNT + 2
 115                         if ret >= 100: ret = 99
 116                         #print "callcount : [%d]"%(self.fu.callcount);
 117                         return ret
 118                 elif self.fu.status == STATUS_DONE:
 119                         return 100
 120
 121         def get_error_msg(self, errno, errmsg):
 122                 return str(self.fu.errmsg)
 123
 124 class UpgradeStatus(Screen):
 125         skin =  """
 126                 <screen position="center,center" size="450,130" title="FPGA Upgrade">
 127                         <widget name="name" position="10,0" size="430,20" font="Regular;18" halign="left" valign="bottom"/>
 128                         <widget name="slider" position="10,25" size="430,30" backgroundColor="white"/>
 129                         <widget name="status" position="10,25" zPosition="1" size="430,30" font="Regular;18" halign="center" valign="center" foregroundColor="black" backgroundColor="black" transparent="1"/>
 130                         <widget source="info" render="Label" position="10,70" zPosition="1" size="430,60" font="Regular;22" halign="center" valign="center" backgroundColor="#a08500" transparent="1"/>
 131                 </screen>
 132                 """
 133         def __init__(self, session, parent, timeout = 20):
 134                 Screen.__init__(self,session)
 135                 self.session = session
 136
 137                 self["actions"] = ActionMap(["OkCancelActions"],
 138                 {
 139                         "ok": self.keyExit,
 140                 }, -2)
 141
 142                 self.is_done = 0
 143                 self.exit_count = 0
 144                 self.timeout = 20
 145                 self.title_str = "FPGA Upgrade"
 146
 147                 #self["name"] = Label(_("Upgrade status"))
 148                 self["name"] = Label(_(" "))
 149                 self["info"] = StaticText(_("Can't cancel during upgrade!!"))
 150
 151                 self["status"] = Label(_("Status : 0%"))
 152                 self.status_bar = self["status"]
 153
 154                 self.slider = Slider(0, 100)
 155                 self["slider"] = self.slider
 156
 157                 self.parent = parent
 158                 self.timer_check_progress = eTimer()
 159                 self.timer_check_progress.callback.append(self.callbackDoCheckProgress)
 160                 interval = self.parent.FPGA.get_interval()
 161                 self.timer_check_progress.start(interval)
 162                 self.need_restart = False
 163
 164         def callbackDoCheckProgress(self):
 165                 self.status = self.parent.FPGA.get_status()
 166
 167                 if self.status > 0:
 168                         self.slider.setValue(self.status)
 169
 170                 if self.status == 100:
 171                         #print "fpga-upgrade done!!"
 172                         self.status_bar.setText(_("Succeed"))
 173                         #self.status_bar.setText(_("%d / 100" % (self.status)))
 174                         self.timer_check_progress.stop()
 175                         self.is_done = 1
 176                         self.timer_exit = eTimer()
 177                         self.timer_exit.callback.append(self.callbackExit)
 178                         self.timer_exit.start(1000)
 179
 180                 elif self.status < 0:#elif self.status == -1 or self.status == -2:
 181                         #print "fpga-upgrade error >> errno : [%d]" % (self.status)
 182                         ERROR_MSG = ''
 183                         ERROR_CODE = int(self.status) * -1
 184                         ERROR_MSG = self.parent.FPGA.get_error_msg(ERROR_CODE, ERROR_MSG)
 185                         self.status_bar.setText("Fail to update!!")
 186                         self["info"].setText(_("Error[%d] : %s.\nPress OK to exit." % (self.status, ERROR_MSG)))
 187                         self.timer_check_progress.stop()
 188                         self.is_done = 1
 189
 190                 else:
 191                         #print "fpga-upgrade status : %d" % self.status
 192                         self.status_bar.setText(_("%d / 100" % (self.status)))
 193
 194         def callbackExit(self):
 195                 self.need_restart = True
 196                 if self.exit_count == self.timeout:
 197                         self.timer_exit.stop()
 198                         self.keyExit()
 199                 self.exit_count = self.exit_count + 1
 200                 #self.instance.setTitle("%s (%d)" % (self.title_str, (self.timeout-self.exit_count)))
 201                 self["info"].setText("Reboot after %d seconds.\nPress the OK to reboot now." %(self.timeout-self.exit_count))
 202
 203         def keyExit(self):
 204                 if self.need_restart:
 205                         from Screens.Standby import TryQuitMainloop
 206                         self.session.open(TryQuitMainloop, 2)
 207                 if self.is_done :
 208                         self.close()
 209
 210 class FPGAUpgrade(Screen):
 211         skin =  """
 212                 <screen position="center,center" size="560,440" title="FPGA Upgrade" >
 213                         <ePixmap pixmap="Vu_HD/buttons/red.png" position="0,7" size="80,40" alphatest="blend" />
 214                         <ePixmap pixmap="Vu_HD/buttons/green.png" position="186,7" size="80,40" alphatest="blend" />
 215                         <ePixmap pixmap="Vu_HD/buttons/blue.png" position="372,7" size="80,40" alphatest="blend" />
 216
 217                         <widget source="key_red" render="Label" position="28,0" zPosition="1" size="160,40" font="Regular;20" halign="center" valign="center" transparent="1"/>
 218                         <widget source="key_green" render="Label" position="213,0" zPosition="1" size="160,40" font="Regular;20" halign="center" valign="center" transparent="1"/>
 219                         <widget source="key_blue" render="Label" position="400,0" zPosition="1" size="160,40" font="Regular;20" halign="center" valign="center" transparent="1"/>
 220
 221                         <widget source="status" render="Label" position="15,45" zPosition="1" size="540,40" font="Regular;18" halign="left" valign="center" backgroundColor="#a08500" transparent="1" />
 222                         <widget name="file_list" position="0,100" size="555,325" scrollbarMode="showOnDemand" />
 223                 </screen>
 224                 """
 225
 226         def __init__(self, session):
 227                 Screen.__init__(self, session)
 228                 self.session = session
 229
 230                 self["key_red"] = StaticText(_("Close"))
 231                 self["key_green"] = StaticText(_("Upgrade"))
 232                 self["key_blue"] = StaticText(_("Download"))
 233
 234                 self["status"] = StaticText(_(" "))
 235                 self["file_list"] = FileList("/", matchingPattern = "^.*")
 236
 237                 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", ],
 238                 {
 239                         "red": self.onClickRed,
 240                         "green": self.onClickGreen,
 241                         "blue": self.onClickBlue,
 242                         "back": self.onClickRed,
 243                         "ok": self.onClickOk,
 244                         "up": self.onClickUp,
 245                         "down": self.onClickDown,
 246                         "left": self.onClickLeft,
 247                         "right": self.onClickRight,
 248                 }, -1)
 249                 self.onLayoutFinish.append(self.doLayoutFinish)
 250
 251                 self.ERROR_MSG = ''
 252                 self.ERROR_CODE = 0
 253                 self.SOURCELIST = self["file_list"]
 254                 self.STATUS_BAR = self["status"]
 255                 self.STATUS_BAR.setText(_(self.SOURCELIST.getCurrentDirectory()))
 256
 257                 self.DEVICE_LIST = '/dev/fpga_dp;/dev/misc/dp;'
 258                 self.DOWNLOAD_TAR_PATH = '/tmp/'
 259                 self.DOWNLOAD_FILE_NAME = 'TS_PRO.dat'
 260                 self.DOWNLOAD_URL = ''
 261                 self.doLoadConf()
 262                 self.FPGA = FPGAUpgradeManager()
 263                 print self.DEVICE_LIST
 264                 print self.DOWNLOAD_TAR_PATH
 265                 print self.DOWNLOAD_FILE_NAME
 266                 print self.DOWNLOAD_URL
 267
 268         def doLayoutFinish(self):
 269                 return
 270
 271         def doExit(self):
 272                 if fileExists(self.DOWNLOAD_TAR_PATH + self.DOWNLOAD_FILE_NAME):
 273                         os.remove(self.DOWNLOAD_TAR_PATH + self.DOWNLOAD_FILE_NAME)
 274                 self.close()
 275
 276         def doLoadConf(self):
 277                 if fileExists("/proc/stb/info/vumodel"):
 278                         model = open("/proc/stb/info/vumodel").read().strip()
 279                         download_uri_header = open('/usr/lib/enigma2/python/Plugins/SystemPlugins/FPGAUpgrade/fpga.conf').readline().strip()
 280                         self.DOWNLOAD_URL = str(download_uri_header) + "vu" + str(model) + "/" + self.DOWNLOAD_FILE_NAME
 281
 282         def doHook(self, blockNumber, blockSize, totalSize) :
 283                 if blockNumber*blockSize > totalSize :
 284                         self.STATUS_BAR.setText(_("Downloaded " + self.DOWNLOAD_TAR_PATH + self.DOWNLOAD_FILE_NAME))
 285                 else :
 286                         self.STATUS_BAR.setText(_("Downloading..."))
 287
 288         def onCallbackHandler(self, confirmed):
 289                 if confirmed:
 290                         self.doExit()
 291
 292         def doUpgradeHandler(self, confirmed):
 293                 if confirmed == False:
 294                         return
 295
 296                 path = ''
 297                 try:
 298                         path = self.SOURCELIST.getCurrentDirectory() + self.SOURCELIST.getFilename()
 299                 except:
 300                         #self.session.open(MessageBox, _("Can't select directory."), MessageBox.TYPE_INFO, timeout = 5)
 301                         return
 302
 303                 device = ""
 304                 device_list = self.DEVICE_LIST.split(";")
 305
 306                 for d in device_list:
 307                         if os.path.exists(d):
 308                                 device = d
 309                                 break
 310
 311                 if device == None or len(device) == 0:
 312                         message = "Fail to upgrade.\nCause : Can't found device.\nDo you want to exit?"
 313                         self.session.openWithCallback(self.onCallbackHandler, MessageBox, _(message), MessageBox.TYPE_YESNO, timeout = 10, default = True)
 314                         print "DEVICE_LIST : ", device_list
 315
 316                 print "DEVICE : ", device
 317                 self.ERROR_CODE = self.FPGA.fpga_upgrade(path, device)
 318                 if self.ERROR_CODE > 0:
 319                         self.ERROR_MSG = self.FPGA.get_error_msg(self.ERROR_CODE, self.ERROR_MSG)
 320                         message = "Fail to upgrade.\nCause : " + self.ERROR_MSG + "\nDo you want to exit?"
 321                         self.session.openWithCallback(self.onCallbackHandler, MessageBox, _(message), MessageBox.TYPE_YESNO, timeout = 10, default = True)
 322                         print "DEVICE : ", device
 323                         print "FILE : ", path
 324                 else:
 325                         #self.session.open(MessageBox, _("Success!!"), MessageBox.TYPE_INFO, timeout = 5)
 326                         self.session.open(UpgradeStatus, self, timeout = 20)
 327
 328         def onClickRed(self):
 329                 self.doExit()
 330
 331         # run upgrade!!
 332         def onClickGreen(self):
 333                 #self.session.open(MessageBox, _("Upgrade will take about 5 minutes to finish."), MessageBox.TYPE_INFO, timeout = 10)
 334                 message = "Upgrade will take about 5 minutes to finish.\nDo you want to upgrade?"
 335                 self.session.openWithCallback(self.doUpgradeHandler, MessageBox, _(message), MessageBox.TYPE_YESNO, timeout = 10, default = True)
 336
 337         def onClickBlue(self):
 338                 fname = ''
 339                 header = ''
 340                 test_opener = urllib.URLopener()
 341                 try:
 342                         test_opener.open(self.DOWNLOAD_URL)
 343                 except:
 344                         self.session.open(MessageBox, _('File not found'), MessageBox.TYPE_INFO, timeout = 5)
 345                         del test_opener
 346                         return
 347                 try :
 348                         fname, header = urlretrieve(self.DOWNLOAD_URL, self.DOWNLOAD_TAR_PATH + self.DOWNLOAD_FILE_NAME, self.doHook)
 349                 except IOError, msg:
 350                         self.session.open(MessageBox, _(str(msg)), MessageBox.TYPE_INFO, timeout = 5)
 351                         del test_opener
 352                         return
 353                 del test_opener
 354
 355                 before_name = ''
 356                 self.SOURCELIST.changeDir(self.DOWNLOAD_TAR_PATH)
 357                 self.SOURCELIST.moveToIndex(0)
 358                 while cmp(self.SOURCELIST.getFilename(), self.DOWNLOAD_FILE_NAME) != 0 :
 359                         self.SOURCELIST.down()
 360                         if cmp(before_name, self.SOURCELIST.getFilename()) == 0:
 361                                 break
 362                         before_name = self.SOURCELIST.getFilename()
 363
 364         def onClickOk(self):
 365                 if self.SOURCELIST.canDescent() : # isDir
 366                         self.SOURCELIST.descent()
 367                         if self.SOURCELIST.getCurrentDirectory():
 368                                 self.STATUS_BAR.setText(_(self.SOURCELIST.getCurrentDirectory()))
 369                 else:
 370                         self.onClickGreen()
 371
 372         def onClickUp(self):
 373                 self.SOURCELIST.up()
 374                 self.STATUS_BAR.setText(_(self.SOURCELIST.getCurrentDirectory()))
 375
 376         def onClickDown(self):
 377                 self.SOURCELIST.down()
 378                 self.STATUS_BAR.setText(_(self.SOURCELIST.getCurrentDirectory()))
 379
 380         def onClickLeft(self):
 381                 self.SOURCELIST.pageUp()
 382                 self.STATUS_BAR.setText(_(self.SOURCELIST.getCurrentDirectory()))
 383
 384         def onClickRight(self):
 385                 self.SOURCELIST.pageDown()
 386                 self.STATUS_BAR.setText(_(self.SOURCELIST.getCurrentDirectory()))
 387
 388 def main(session, **kwargs):
 389         session.open(FPGAUpgrade)
 390
 391 def Plugins(**kwargs):
 392         return PluginDescriptor(name=_("FPGA Upgrade"), description="Upgrade FPGA..", where = PluginDescriptor.WHERE_PLUGINMENU, fnc=main)
 393