make DEVICEDB depending on model type
[enigma2.git] / lib / python / Components / Harddisk.py
old mode 100644 (file)
new mode 100755 (executable)
index febd16d..18616bf
@@ -2,6 +2,8 @@ from os import system, listdir, statvfs, popen, makedirs, readlink, stat, major,
 from Tools.Directories import SCOPE_HDD, resolveFilename
 from Tools.CList import CList
 from SystemInfo import SystemInfo
+import time
+from Components.Console import Console
 
 def tryOpen(filename):
        try:
@@ -17,6 +19,9 @@ class Harddisk:
                tmp = procfile.readline().split(':')
                s_major = int(tmp[0])
                s_minor = int(tmp[1])
+               self.max_idle_time = 0
+               self.idle_running = False
+               self.timer = None
                for disc in listdir("/dev/discs"):
                        path = readlink('/dev/discs/'+disc)
                        devidex = '/dev/discs/'+disc+'/'
@@ -27,14 +32,20 @@ class Harddisk:
                                self.devidex = devidex
                                self.devidex2 = devidex2
                                print "new Harddisk", device, '->', self.devidex, '->', self.devidex2
+                               self.startIdle()
                                break
 
        def __lt__(self, ob):
                return self.device < ob.device
 
+       def stop(self):
+               if self.timer:
+                       self.timer.stop()
+                       self.timer.callback.remove(self.runIdle)
+
        def bus(self):
-               ide_cf = self.device.find("hd") == 0 and self.devidex2.find("host0") == -1 # 7025 specific
-               internal = self.device.find("hd") == 0
+               ide_cf = self.device[:2] == "hd" and "host0" not in self.devidex2 # 7025 specific
+               internal = self.device[:2] == "hd"
                if ide_cf:
                        ret = "External (CF)"
                elif internal:
@@ -59,17 +70,17 @@ class Harddisk:
                cap = self.diskSize()
                if cap == 0:
                        return ""
-               return "%d.%03d GB" % (cap/1024, cap%1024)
+               return "%d.%03d GB" % (cap/1000, cap%1000)
 
        def model(self):
-               if self.device.find("hd") == 0:
+               if self.device[:2] == "hd":
                        procfile = tryOpen("/proc/ide/"+self.device+"/model")
                        if procfile == "":
                                return ""
                        line = procfile.readline()
                        procfile.close()
                        return line.strip()
-               elif self.device.find("sd") == 0:
+               elif self.device[:2] == "sd":
                        procfile = tryOpen("/sys/block/"+self.device+"/device/vendor")
                        if procfile == "":
                                return ""
@@ -92,7 +103,7 @@ class Harddisk:
                        line = procfile.readline()
                        if line == "":
                                break
-                       if line.startswith(self.devidex):
+                       if line.startswith(self.devidex) or line.startswith(self.devidex2):
                                parts = line.strip().split(" ")
                                try:
                                        stat = statvfs(parts[1])
@@ -125,7 +136,7 @@ class Harddisk:
                cmd = "/bin/umount"
 
                for line in procfile:
-                       if line.startswith(self.devidex):
+                       if line.startswith(self.devidex) or line.startswith(self.devidex2):
                                parts = line.split()
                                cmd = ' '.join([cmd, parts[1]])
 
@@ -145,14 +156,20 @@ class Harddisk:
                cmd = "/sbin/mkfs.ext3 "
                if self.diskSize() > 4 * 1024:
                        cmd += "-T largefile "
-               cmd += "-m0 " + self.devidex + "part1"
+               cmd += "-m0 -O dir_index " + self.devidex + "part1"
                res = system(cmd)
                return (res >> 8)
 
        def mount(self):
-               cmd = "/bin/mount -t ext3 " + self.devidex + "part1"
-               res = system(cmd)
-               return (res >> 8)
+               res = -1
+               #we don't know which type of devicename is used in fstab, try both
+               for device in [self.devidex, self.devidex2]:
+                       cmd = "/bin/mount -t ext3 " + device + "part1"
+                       res = system(cmd)
+                       res >>= 8
+                       if not res:
+                               break
+               return res
 
        def createMovieFolder(self):
                try:
@@ -212,12 +229,76 @@ class Harddisk:
        def getDeviceName(self):
                return self.getDeviceDir() + "disc"
 
+       # the HDD idle poll daemon.
+       # as some harddrives have a buggy standby timer, we are doing this by hand here.
+       # first, we disable the hardware timer. then, we check every now and then if
+       # any access has been made to the disc. If there has been no access over a specifed time,
+       # we set the hdd into standby.
+       def readStats(self):
+               l = open("/sys/block/%s/stat" % self.device).read()
+               (nr_read, _, _, _, nr_write) = l.split()[:5]
+               return int(nr_read), int(nr_write)
+
+       def startIdle(self):
+               self.last_access = time.time()
+               self.last_stat = 0
+               self.is_sleeping = False
+               from enigma import eTimer
+
+               # disable HDD standby timer
+               Console().ePopen(("hdparm", "hdparm", "-S0", (self.devidex + "disc")))
+               self.timer = eTimer()
+               self.timer.callback.append(self.runIdle)
+               self.idle_running = True
+               self.setIdleTime(self.max_idle_time) # kick the idle polling loop
+
+       def runIdle(self):
+               if not self.max_idle_time:
+                       return
+               t = time.time()
+
+               idle_time = t - self.last_access
+
+               stats = self.readStats()
+               print "nr_read", stats[0], "nr_write", stats[1]
+               l = sum(stats)
+               print "sum", l, "prev_sum", self.last_stat
+
+               if l != self.last_stat: # access
+                       print "hdd was accessed since previous check!"
+                       self.last_stat = l
+                       self.last_access = t
+                       idle_time = 0
+                       self.is_sleeping = False
+               else:
+                       print "hdd IDLE!"
+
+               print "[IDLE]", idle_time, self.max_idle_time, self.is_sleeping
+               if idle_time >= self.max_idle_time and not self.is_sleeping:
+                       self.setSleep()
+                       self.is_sleeping = True
+
+       def setSleep(self):
+               Console().ePopen(("hdparm", "hdparm", "-y", (self.devidex + "disc")))
+
+       def setIdleTime(self, idle):
+               self.max_idle_time = idle
+               if self.idle_running:
+                       if not idle:
+                               self.timer.stop()
+                       else:
+                               self.timer.start(idle * 100, False)  # poll 10 times per period.
+
+       def isSleeping(self):
+               return self.is_sleeping
+
 class Partition:
-       def __init__(self, mountpoint, description = "", force_mounted = False):
+       def __init__(self, mountpoint, device = None, description = "", force_mounted = False):
                self.mountpoint = mountpoint
                self.description = description
                self.force_mounted = force_mounted
                self.is_hotplug = force_mounted # so far; this might change.
+               self.device = device
 
        def stat(self):
                return statvfs(self.mountpoint)
@@ -247,6 +328,29 @@ class Partition:
                                return True
                return False
 
+DEVICEDB =  \
+       {"dm8000":
+               {
+                       # dm8000:
+                       "/devices/platform/brcm-ehci.0/usb1/1-1/1-1.1/1-1.1:1.0": "Front USB Slot",
+                       "/devices/platform/brcm-ehci.0/usb1/1-1/1-1.2/1-1.2:1.0": "Back, upper USB Slot",
+                       "/devices/platform/brcm-ehci.0/usb1/1-1/1-1.3/1-1.3:1.0": "Back, lower USB Slot",
+                       "/devices/platform/brcm-ehci-1.1/usb2/2-1/2-1:1.0/host1/target1:0:0/1:0:0:0": "DVD Drive",
+               },
+       "dm800":
+       {
+               # dm800:
+               "/devices/platform/brcm-ehci.0/usb1/1-2/1-2:1.0": "Upper USB Slot",
+               "/devices/platform/brcm-ehci.0/usb1/1-1/1-1:1.0": "Lower USB Slot",
+       },
+       "dm7025":
+       {
+               # dm7025:
+               "/devices/pci0000:00/0000:00:14.1/ide1/1.0": "CF Card Slot", #hdc
+               "/devices/pci0000:00/0000:00:14.1/ide0/0.0": "Internal Harddisk"
+       }
+       }
+
 class HarddiskManager:
        def __init__(self):
                self.hdd = [ ]
@@ -273,8 +377,7 @@ class HarddiskManager:
                                        ("/", _("Internal Flash"))
                                ]
                
-               for x in p:
-                       self.partitions.append(Partition(mountpoint = x[0], description = x[1]))
+               self.partitions.extend([ Partition(mountpoint = x[0], description = x[1]) for x in p ])
 
        def getBlockDevInfo(self, blockdev):
                devpath = "/sys/block/" + blockdev
@@ -286,14 +389,14 @@ class HarddiskManager:
                try:
                        removable = bool(int(open(devpath + "/removable").read()))
                        dev = int(open(devpath + "/dev").read().split(':')[0])
-                       if dev in [7, 31]: # loop, mtdblock
+                       if dev in (7, 31): # loop, mtdblock
                                blacklisted = True
                        if blockdev[0:2] == 'sr':
                                is_cdrom = True
                        if blockdev[0:2] == 'hd':
                                try:
                                        media = open("/proc/ide/%s/media" % blockdev).read()
-                                       if media.find("cdrom") != -1:
+                                       if "cdrom" in media:
                                                is_cdrom = True
                                except IOError:
                                        error = True
@@ -307,37 +410,62 @@ class HarddiskManager:
                                self.cd = blockdev
                except IOError:
                        error = True
-               return error, blacklisted, removable, is_cdrom, partitions
+               # check for medium
+               medium_found = True
+               try:
+                       open("/dev/" + blockdev).close()
+               except IOError, err:
+                       if err.errno == 159: # no medium present
+                               medium_found = False
+                       
+               return error, blacklisted, removable, is_cdrom, partitions, medium_found
 
        def enumerateBlockDevices(self):
                print "enumerating block devices..."
                for blockdev in listdir("/sys/block"):
-                       error, blacklisted, removable, is_cdrom, partitions = self.getBlockDevInfo(blockdev)
+                       error, blacklisted, removable, is_cdrom, partitions, medium_found = self.getBlockDevInfo(blockdev)
                        print "found block device '%s':" % blockdev, 
                        if error:
                                print "error querying properties"
                        elif blacklisted:
                                print "blacklisted"
+                       elif not medium_found:
+                               print "no medium"
                        else:
                                print "ok, removable=%s, cdrom=%s, partitions=%s, device=%s" % (removable, is_cdrom, partitions, blockdev)
-                               self.addHotplugPartition(blockdev, blockdev)
+
+                               self.addHotplugPartition(blockdev)
                                for part in partitions:
-                                       self.addHotplugPartition(part, part)
+                                       self.addHotplugPartition(part)
 
        def getAutofsMountpoint(self, device):
                return "/autofs/%s/" % (device)
 
-       def addHotplugPartition(self, device, description):
-               p = Partition(mountpoint = self.getAutofsMountpoint(device), description = description, force_mounted = True)
+       def addHotplugPartition(self, device, physdev = None):
+               if not physdev:
+                       dev, part = self.splitDeviceName(device)
+                       try:
+                               physdev = readlink("/sys/block/" + dev + "/device")[5:]
+                       except OSError:
+                               physdev = dev
+                               print "couldn't determine blockdev physdev for device", device
+
+               # device is the device name, without /dev 
+               # physdev is the physical device path, which we (might) use to determine the userfriendly name
+               description = self.getUserfriendlyDeviceName(device, physdev)
+               
+               p = Partition(mountpoint = self.getAutofsMountpoint(device), description = description, force_mounted = True, device = device)
                self.partitions.append(p)
                self.on_partition_list_change("add", p)
+
+               # see if this is a harddrive
                l = len(device)
-               if l and device[l-1] not in ('0','1','2','3','4','5','6','7','8','9'):
-                       error, blacklisted, removable, is_cdrom, partitions = self.getBlockDevInfo(device)
-                       if not blacklisted and not removable and not is_cdrom:
+               if l and not device[l-1].isdigit():
+                       error, blacklisted, removable, is_cdrom, partitions, medium_found = self.getBlockDevInfo(device)
+                       if not blacklisted and not removable and not is_cdrom and medium_found:
                                self.hdd.append(Harddisk(device))
                                self.hdd.sort()
-                               SystemInfo["Harddisc"] = len(self.hdd) > 0
+                               SystemInfo["Harddisk"] = len(self.hdd) > 0
 
        def removeHotplugPartition(self, device):
                mountpoint = self.getAutofsMountpoint(device)
@@ -346,13 +474,13 @@ class HarddiskManager:
                                self.partitions.remove(x)
                                self.on_partition_list_change("remove", x)
                l = len(device)
-               if l and device[l-1] not in ('0','1','2','3','4','5','6','7','8','9'):
-                       idx = 0
+               if l and not device[l-1].isdigit():
                        for hdd in self.hdd:
                                if hdd.device == device:
-                                       del self.hdd[idx]
+                                       hdd.stop()
+                                       self.hdd.remove(hdd)
                                        break
-                       SystemInfo["Harddisc"] = len(self.hdd) > 0
+                       SystemInfo["Harddisk"] = len(self.hdd) > 0
 
        def HDDCount(self):
                return len(self.hdd)
@@ -371,6 +499,56 @@ class HarddiskManager:
                return self.cd
 
        def getMountedPartitions(self, onlyhotplug = False):
-               return [x for x in self.partitions if (x.is_hotplug or not onlyhotplug) and x.mounted()]
+               parts = [x for x in self.partitions if (x.is_hotplug or not onlyhotplug) and x.mounted()]
+               devs = set([x.device for x in parts])
+               for devname in devs.copy():
+                       if not devname:
+                               continue
+                       dev, part = self.splitDeviceName(devname)
+                       if part and dev in devs: # if this is a partition and we still have the wholedisk, remove wholedisk
+                               devs.remove(dev)
+
+               # return all devices which are not removed due to being a wholedisk when a partition exists
+               return [x for x in parts if not x.device or x.device in devs]
+
+       def splitDeviceName(self, devname):
+               # this works for: sdaX, hdaX, sr0 (which is in fact dev="sr0", part=""). It doesn't work for other names like mtdblock3, but they are blacklisted anyway.
+               dev = devname[:3]
+               part = devname[3:]
+               for p in part:
+                       if not p.isdigit():
+                               return devname, 0
+               return dev, part and int(part) or 0
+
+       def getUserfriendlyDeviceName(self, dev, phys):
+               dev, part = self.splitDeviceName(dev)
+               description = "External Storage %s" % dev
+               try:
+                       description = open("/sys" + phys + "/model").read().strip()
+               except IOError, s:
+                       print "couldn't read model: ", s
+               from Tools.HardwareInfo import HardwareInfo
+               for physdevprefix, pdescription in DEVICEDB.get(HardwareInfo().device_name,{}).items():
+                       if phys.startswith(physdevprefix):
+                               description = pdescription
+
+               # not wholedisk and not partition 1
+               if part and part != 1:
+                       description += " (Partition %d)" % part
+               return description
+
+       def addMountedPartition(self, device, desc):
+               already_mounted = False
+               for x in self.partitions[:]:
+                       if x.mountpoint == device:
+                               already_mounted = True
+               if not already_mounted:
+                       self.partitions.append(Partition(mountpoint = device, description = desc))
+               
+       def removeMountedPartition(self, mountpoint):
+               for x in self.partitions[:]:
+                       if x.mountpoint == mountpoint:
+                               self.partitions.remove(x)
+                               self.on_partition_list_change("remove", x)
 
 harddiskmanager = HarddiskManager()