add preliminary support for the Motorola EZX Linux phone platform

see http://openezx.org

5 files changed, 448 insertions, 13 deletions

diff --git a/libopie2/opiecore/device/device.pro b/libopie2/opiecore/device/device.pro
index 0954733..b517032 100644
--- a/libopie2/opiecore/device/device.pro
+++ b/libopie2/opiecore/device/device.pro
@@ -1,28 +1,30 @@
 HEADERS    += device/odevice.h          \
               device/odevicebutton.h    \
 	      device/odevice_abstractmobiledevice.h \
 	      device/odevice_beagle.h   \
               device/odevice_ipaq.h     \
               device/odevice_jornada.h  \
               device/odevice_ramses.h   \
               device/odevice_simpad.h   \
               device/odevice_zaurus.h   \
               device/odevice_genuineintel.h   \
               device/odevice_yopy.h  \
               device/odevice_mypal.h \
-              device/odevice_htc.h
+              device/odevice_htc.h \
+              device/odevice_motorola_ezx.h
 
 SOURCES    += device/odevice.cpp        \
               device/odevicebutton.cpp  \
 	      device/odevice_abstractmobiledevice.cpp \
 	      device/odevice_beagle.cpp \
               device/odevice_ipaq.cpp   \
               device/odevice_jornada.cpp\
               device/odevice_ramses.cpp \
               device/odevice_simpad.cpp \
               device/odevice_zaurus.cpp \
               device/odevice_genuineintel.cpp   \
               device/odevice_yopy.cpp \
               device/odevice_mypal.cpp \
-              device/odevice_htc.cpp
+              device/odevice_htc.cpp \
+              device/odevice_motorola_ezx.cpp
 
diff --git a/libopie2/opiecore/device/odevice.cpp b/libopie2/opiecore/device/odevice.cpp
index c6e031f..8f5be8b 100644
--- a/libopie2/opiecore/device/odevice.cpp
+++ b/libopie2/opiecore/device/odevice.cpp
@@ -1,532 +1,534 @@
 /*
                              This file is part of the Opie Project
-             =.              (C) 2002-2005 The Opie Team <opie-devel@handhelds.org>
+             =.              (C) 2002-2006 The Opie Team <opie-devel@handhelds.org>
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; version 2 of the License.
      ._= =}       :
     .%`+i>       _;_.
     .i_,=:_.      -<s.       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
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 
 #include "odevice_beagle.h"
 #include "odevice_ipaq.h"
 #include "odevice_mypal.h"
 #include "odevice_jornada.h"
 #include "odevice_ramses.h"
 #include "odevice_simpad.h"
 #include "odevice_yopy.h"
 #include "odevice_zaurus.h"
 #include "odevice_genuineintel.h"
 #include "odevice_htc.h"
+#include "odevice_motorola_ezx.h"
 
 /* QT */
 #include <qapplication.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qwindowsystem_qws.h>
 
 /* OPIE */
 #include <qpe/config.h>
 #include <qpe/sound.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/sound.h>
 
 #include <opie2/okeyfilter.h>
 #include <opie2/oresource.h>
 
 /* STD */
 #include <fcntl.h>
 #include <math.h>
 #include <stdlib.h>
 #include <signal.h>
 #include <sys/ioctl.h>
 #include <sys/time.h>
 #include <unistd.h>
 #ifndef QT_NO_SOUND
 #include <linux/soundcard.h>
 #endif
 
 namespace Opie {
 namespace Core {
 
 static const char* PATH_PROC_CPUINFO = "/proc/cpuinfo";
 
 
 /* STATIC and common implementation */
 /* EXPORT */ ODistribution distributions[] = {
     { System_Familiar,        "FamiliarLinux",   "/etc/familiar-version" },
     { System_OpenZaurus,      "OpenZaurus",      "/etc/openzaurus-version" },
     { System_OpenEmbedded,    "OpenEmbedded",    "/etc/oe-version" },
     { System_Unknown,         "Linux",           "/etc/issue" },
 };
 
 
 /* EXPORT */ bool isQWS(){
     return qApp ? ( qApp->type() == QApplication::GuiServer ) : false;
 }
 
 /* EXPORT */ QCString makeChannel ( const char *str ){
     if ( str && !::strchr ( str, '/' ))
         return QCString ( "QPE/Application/" ) + str;
     else
         return str;
 }
 
 
 
 /* Now the default implementation of ODevice */
 
 struct default_button default_buttons [] =  {
     { Qt::Key_F9, QT_TRANSLATE_NOOP("Button", "Calendar Button"),
     "devicebuttons/z_calendar",
     "datebook", "nextView()",
     "today", "raise()" },
     { Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Contacts Button"),
     "devicebuttons/z_contact",
     "addressbook", "raise()",
     "addressbook", "beamBusinessCard()" },
     { Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Home Button"),
     "devicebuttons/z_home",
     "QPE/Launcher", "home()",
     "buttonsettings", "raise()" },
     { Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Menu Button"),
     "devicebuttons/z_menu",
     "QPE/TaskBar", "toggleMenu()",
     "QPE/TaskBar", "toggleStartMenu()" },
     { Qt::Key_F13, QT_TRANSLATE_NOOP("Button", "Mail Button"),
     "devicebuttons/z_mail",
     "opiemail", "raise()",
     "opiemail", "newMail()" },
 };
 
 ODevice *ODevice::inst()
 {
     static ODevice *dev = 0;
     QString cpu_info;
 
     if ( !dev )
     {
         QFile f( PATH_PROC_CPUINFO );
         if ( f.open( IO_ReadOnly ) )
         {
             QTextStream s( &f );
             while ( !s.atEnd() )
             {
                 QString line;
                 line = s.readLine();
                 if ( line.startsWith( "Hardware" ) )
                 {
                     qDebug( "ODevice() - found '%s'", (const char*) line );
                     cpu_info = line;
                     if ( line.contains( "sharp", false ) ) dev = new Internal::Zaurus();
                     else if ( line.contains( "ipaq", false ) ) dev = new Internal::iPAQ();
                     else if ( line.contains( "mypal", false ) ) dev = new Internal::MyPal();
                     else if ( line.contains( "simpad", false ) ) dev = new Internal::SIMpad();
                     else if ( line.contains( "jornada", false ) ) dev = new Internal::Jornada();
                     else if ( line.contains( "ramses", false ) ) dev = new Internal::Ramses();
                     else if ( line.contains( "Tradesquare.NL", false ) ) dev = new Internal::Beagle();
                     else if ( line.contains( "HTC", false ) ) dev = new Internal::HTC();
+                    else if ( line.contains( "Motorola", false ) ) dev = new Internal::Motorola_EZX();
 
                     else qWarning( "ODevice() - unknown hardware - using default." );
                     break;
                 } else if ( line.startsWith( "vendor_id" ) ) {
                     qDebug( "ODevice() - found '%s'", (const char*) line );
                     cpu_info = line;
                     if( line.contains( "genuineintel", false ) ) {
                       dev = new Internal::GenuineIntel();
                       break;
                     }
                 }
             }
         }
         else
         {
             qWarning( "ODevice() - can't open '%s' - unknown hardware - using default.", PATH_PROC_CPUINFO );
         }
         if ( !dev ) dev = new ODevice();
         dev->init(cpu_info);
     }
     return dev;
 }
 
 ODevice::ODevice()
 {
     d = new ODeviceData;
 
     d->m_modelstr = "Unknown";
     d->m_model = Model_Unknown;
     d->m_vendorstr = "Unknown";
     d->m_vendor = Vendor_Unknown;
     d->m_systemstr = "Unknown";
     d->m_system = System_Unknown;
     d->m_sysverstr = "0.0";
     d->m_rotation = Rot0;
     d->m_direction = CW;
     d->m_qteDriver = "Transformed";
 
     d->m_holdtime = 1000; // 1000ms
     d->m_buttons = 0;
     d->m_cpu_frequencies = new QStrList;
 
 
     /* mixer */
     d->m_sound = d->m_vol   = d->m_mixer = -1;
 
     /* System QCopChannel created */
     d->m_initializedButtonQcop = false;
 
     // New distribution detection code first checks for legacy distributions,
     // identified by /etc/familiar-version or /etc/oz_version.
     // Then check for OpenEmbedded and lastly, read /etc/issue
 
     for ( unsigned int i = 0; i < sizeof(distributions)/sizeof(ODistribution); ++i )
     {
         if ( QFile::exists( distributions[i].sysvfile ) )
         {
             d->m_systemstr = distributions[i].sysstr;
             d->m_system = distributions[i].system;
             d->m_sysverstr = "<Unknown>";
             QFile f( distributions[i].sysvfile );
             if ( f.open( IO_ReadOnly ) )
             {
                 QTextStream ts( &f );
                 d->m_sysverstr = ts.readLine().replace( QRegExp( "\\\\." ), "" );
             }
             break;
         }
     }
 }
 
 void ODevice::systemMessage( const QCString &msg, const QByteArray & )
 {
     if ( msg == "deviceButtonMappingChanged()" ) {
         reloadButtonMapping();
     }
 }
 
 void ODevice::init(const QString&)
 {
 }
 
 /**
 * This method initialises the button mapping
 */
 void ODevice::initButtons()
 {
     if ( d->m_buttons )
         return;
 
     qDebug ( "init Buttons" );
     d->m_buttons = new QValueList <ODeviceButton>;
     for ( uint i = 0; i < ( sizeof( default_buttons ) / sizeof( default_button )); i++ ) {
         default_button *db = default_buttons + i;
         ODeviceButton b;
         b. setKeycode ( db->code );
         b. setUserText ( QObject::tr ( "Button", db->utext ));
         b. setPixmap ( OResource::loadPixmap ( db->pix ));
         b. setFactoryPresetPressedAction ( OQCopMessage ( makeChannel ( db->fpressedservice ), db->fpressedaction ));
         b. setFactoryPresetHeldAction ( OQCopMessage ( makeChannel ( db->fheldservice ), db->fheldaction ));
         d->m_buttons->append ( b );
     }
 
     reloadButtonMapping();
 }
 
 ODevice::~ODevice()
 {
 // we leak m_devicebuttons and m_cpu_frequency
 // but it's a singleton and it is not so importantant
 // -zecke
     delete d;
 }
 
 /**
 * This method will try to suspend the device
 * It only works if the user is the QWS Server and the apm application
 * is installed.
 * It tries to suspend and then waits some time cause some distributions
 * do have asynchronus apm implementations.
 * This method will either fail and return false or it'll suspend the
 * device and return once the device got woken up
 *
 * @return if the device got suspended
 */
 bool ODevice::suspend()
 {
     return false; // default implementation == unknown device or qvfb
 }
 
 /**
 * This sets the display on or off
 */
 bool ODevice::setDisplayStatus( bool on )
 {
     qDebug( "ODevice::setDisplayStatus( %d ) - please override me.", on );
     return false; // don't do anything for unknown models
 }
 
 /**
 * This sets the display brightness
 *
 * @param b The brightness to be set on a scale from 0 to 255
 * @return success or failure
 */
 bool ODevice::setDisplayBrightness( int b )
 {
     qDebug( "ODevice::setDisplayBrightness( %d ) - please override me.", b );
     return false;
 }
 
 /**
  *
  * @returns the number of steppings on the brightness slider
  * in the Light-'n-Power settings. Values smaller than zero and bigger
  * than 255 do not make sense.
  *
  * \sa QSlider::setLineStep
  * \sa QSlider::setPageStep
  */
 int ODevice::displayBrightnessResolution() const
 {
     qDebug( "ODevice::displayBrightnessResolution() - please override me." );
     return 16;
 }
 
 /**
 * This sets the display contrast
 * @param p The contrast to be set on a scale from 0 to 255
 * @returns success or failure
 */
 bool ODevice::setDisplayContrast( int p )
 {
     qDebug( "ODevice::setDisplayContrast( %d ) - please override me.", p );
     return false;
 }
 
 /**
 * @returns the maximum value for the contrast settings slider
 *         or 0 if the device doesn't support setting of a contrast
 */
 int ODevice::displayContrastResolution() const
 {
     qDebug( "ODevice::displayBrightnessResolution() - please override me." );
     return 0;
 }
 
 /**
 * This returns the vendor as string
 * @return Vendor as QString
 */
 QString ODevice::vendorString() const
 {
     return d->m_vendorstr;
 }
 
 /**
 * This returns the vendor as one of the values of OVendor
 * @return OVendor
 */
 OVendor ODevice::vendor() const
 {
     return d->m_vendor;
 }
 
 /**
 * This returns the model as a string
 * @return A string representing the model
 */
 QString ODevice::modelString() const
 {
     return d->m_modelstr;
 }
 
 /**
 * This does return the OModel used
 */
 OModel ODevice::model() const
 {
     return d->m_model;
 }
 
 /**
 * This does return the systen name
 */
 QString ODevice::systemString() const
 {
     return d->m_systemstr;
 }
 
 /**
 * Return System as OSystem value
 */
 OSystem ODevice::system() const
 {
     return d->m_system;
 }
 
 /**
 * @return the version string of the base system
 */
 QString ODevice::systemVersionString() const
 {
     return d->m_sysverstr;
 }
 
 /**
 *  @return the current Transformation
 */
 Transformation ODevice::rotation() const
 {
     return d->m_rotation;
 }
 
 /**
 *  @return the current rotation direction
 */
 ODirection ODevice::direction() const
 {
     return d->m_direction;
 }
 
 QString ODevice::qteDriver() const
 {
     return d->m_qteDriver;
 }
 
 /**
 * This plays an alarm sound
 */
 void ODevice::playAlarmSound()
 {
 #ifndef QT_NO_SOUND
     static Sound snd ( "alarm" );
 
     if ( snd. isFinished())
         snd. play();
 #endif
 }
 
 /**
 * This plays a key sound
 */
 void ODevice::playKeySound()
 {
 #ifndef QT_NO_SOUND
     static Sound snd ( "keysound" );
 
     if ( snd. isFinished())
         snd. play();
 #endif
 }
 
 /**
 * This plays a touch sound
 */
 void ODevice::playTouchSound()
 {
 #ifndef QT_NO_SOUND
     static Sound snd ( "touchsound" );
 
     if ( snd. isFinished())
         snd. play();
 #endif
 }
 
 /**
 * This method will return a list of leds
 * available on this device
 * @return a list of LEDs.
 */
 QValueList <OLed> ODevice::ledList() const
 {
     return QValueList <OLed>();
 }
 
 /**
 * This does return the state of the LEDs
 */
 QValueList <OLedState> ODevice::ledStateList ( OLed /*which*/ ) const
 {
     return QValueList <OLedState>();
 }
 
 /**
 * @return the state for a given OLed
 */
 OLedState ODevice::ledState ( OLed /*which*/ ) const
 {
     return Led_Off;
 }
 
 /**
 * Set the state for a LED
 * @param which Which OLed to use
 * @param st The state to set
 * @return success or failure
 */
 bool ODevice::setLedState ( OLed which, OLedState st )
 {
         Q_UNUSED( which )
         Q_UNUSED( st    )
     return false;
 }
 
 /**
 * @return if the device has a light sensor
 */
 bool ODevice::hasLightSensor() const
 {
     return false;
 }
 
 /**
 * @return a value from the light sensor
 */
 int ODevice::readLightSensor()
 {
     return -1;
 }
 
 /**
 * @return the light sensor resolution
 */
 int ODevice::lightSensorResolution() const
 {
     return 0;
 }
 
 /**
 * @return if the device has a hinge sensor
 */
 bool ODevice::hasHingeSensor() const
 {
     return false;
 }
 
 /**
 * @return a value from the hinge sensor
 */
 OHingeStatus ODevice::readHingeSensor()const
 {
     return CASE_UNKNOWN;
 }
diff --git a/libopie2/opiecore/device/odevice.h b/libopie2/opiecore/device/odevice.h
index 2566979..9afb92d 100644
--- a/libopie2/opiecore/device/odevice.h
+++ b/libopie2/opiecore/device/odevice.h
@@ -1,397 +1,401 @@
 /*
                              This file is part of the Opie Project
-                             Copyright (C) The Opie Team <opie-devel@handhelds.org>
+                             (C) 2002-2006 The Opie Team <opie-devel@handhelds.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
- - .   .-<_>     .<>         Foundation; either version 2 of the License,
-     ._= =}       :          or (at your option) any later version.
+ - .   .-<_>     .<>         Foundation; version 2 of the License.
+     ._= =}       :
     .%`+i>       _;_.
     .i_,=:_.      -<s.       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
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 
 #ifndef ODEVICE_H_
 #define ODEVICE_H_
 
 /* OPIE */
 #include <opie2/odevicebutton.h>
 #include <qpe/qpeapplication.h> /* for Transformation enum.. */
 
 /* QT */
 #include <qnamespace.h>
 #include <qobject.h>
 #include <qstring.h>
 
 
 #include <qstrlist.h>
 #include <qwindowsystem_qws.h>
 
 
 class Sound;
 
 namespace Opie{
 namespace Core{
 
 class ODeviceData;
 /**
  * The available devices
  */
 enum OModel {
     Model_Unknown, // = 0
 
     Model_Series_Mask   = 0xffff0000,
 
     Model_iPAQ          = ( 1 << 16 ),
 
     Model_iPAQ_All      = ( Model_iPAQ | 0xffff ),
     Model_iPAQ_H31xx    = ( Model_iPAQ | 0x0001 ),
     Model_iPAQ_H36xx    = ( Model_iPAQ | 0x0002 ),
     Model_iPAQ_H37xx    = ( Model_iPAQ | 0x0003 ),
     Model_iPAQ_H38xx    = ( Model_iPAQ | 0x0004 ),
     Model_iPAQ_H39xx    = ( Model_iPAQ | 0x0005 ),
     Model_iPAQ_H5xxx    = ( Model_iPAQ | 0x0006 ),
     Model_iPAQ_H22xx    = ( Model_iPAQ | 0x0007 ),
     Model_iPAQ_H191x    = ( Model_iPAQ | 0x0008 ),
     Model_iPAQ_H1940    = ( Model_iPAQ | 0x0009 ),
     Model_iPAQ_HX4700   = ( Model_iPAQ | 0x000A ),
     Model_Jornada       = ( 6 << 16 ),
     Model_Jornada_56x   = ( Model_Jornada | 0x0001 ),
     Model_Jornada_720   = ( Model_Jornada | 0x0002 ),
 
     Model_Zaurus        = ( 2 << 16 ),
 
     Model_Zaurus_SL5000 = ( Model_Zaurus | 0x0001 ),
     Model_Zaurus_SL5500 = ( Model_Zaurus | 0x0002 ),
     Model_Zaurus_SLA300 = ( Model_Zaurus | 0x0003 ),
     Model_Zaurus_SLB600 = ( Model_Zaurus | 0x0004 ),
     Model_Zaurus_SLC7x0 = ( Model_Zaurus | 0x0005 ),
     Model_Zaurus_SL6000 = ( Model_Zaurus | 0x0006 ),
     Model_Zaurus_SLC3000 = ( Model_Zaurus | 0x0007 ),
     Model_Zaurus_SLC1000 = ( Model_Zaurus | 0x0008 ),
     Model_Zaurus_SLC3100 = ( Model_Zaurus | 0x0009 ),
 
     Model_SIMpad        = ( 3 << 16 ),
 
     Model_SIMpad_All    = ( Model_SIMpad | 0xffff ),
     Model_SIMpad_CL4    = ( Model_SIMpad | 0x0001 ),
     Model_SIMpad_SL4    = ( Model_SIMpad | 0x0002 ),
     Model_SIMpad_SLC    = ( Model_SIMpad | 0x0003 ),
     Model_SIMpad_TSinus = ( Model_SIMpad | 0x0004 ),
 
     Model_Ramses        = ( 4 << 16 ),
 
     Model_Ramses_All    = ( Model_Ramses | 0xffff ),
     Model_Ramses_MNCI   = ( Model_Ramses | 0x0001 ),
     Model_Ramses_MNCIRX = ( Model_Ramses | 0x0002 ),
 
     Model_Yopy          = ( 5 << 16 ),
 
     Model_Yopy_All      = ( Model_Yopy | 0xffff ),
     Model_Yopy_3000     = ( Model_Yopy | 0x0001 ),
     Model_Yopy_3500     = ( Model_Yopy | 0x0002 ),
     Model_Yopy_3700     = ( Model_Yopy | 0x0003 ),
 
     Model_Beagle        = ( 6 << 16 ),
 
     Model_Beagle_All    = ( Model_Beagle | 0xffff ),
     Model_Beagle_PA100  = ( Model_Beagle | 0x0001 ),
 
     Model_GenuineIntel  = ( 7 << 16 ),
 
     Model_MyPal         = ( 8 << 16 ),
 
     Model_MyPal_All     = ( Model_MyPal | 0xffff ),
     Model_MyPal_620     = ( Model_MyPal | 0x0001 ),
     Model_MyPal_716     = ( Model_MyPal | 0x0002 ),
     Model_MyPal_730     = ( Model_MyPal | 0x0003 ),
 
     Model_HTC           = ( 9 << 16 ),
     Model_HTC_All       = ( Model_HTC | 0xffff ),
-    Model_HTC_Universal = ( Model_HTC | 0x0001 )
+    Model_HTC_Universal = ( Model_HTC | 0x0001 ),
+
+    Model_Motorola      = ( 9 << 17 ),
+    Model_Motorola_All  = ( Model_Motorola | 0xffff ),
+    Model_Motorola_EZX  = ( Model_Motorola | 0x0001 ),
+
 };
 
 /**
  * The vendor of the device
  */
 enum OVendor {
     Vendor_Unknown,
 
     Vendor_HP,
     Vendor_Sharp,
     Vendor_SIEMENS,
     Vendor_MundN,
     Vendor_GMate,
     Vendor_MasterIA,
     Vendor_GenuineIntel,
     Vendor_Asus,
-    Vendor_HTC
+    Vendor_HTC,
+    Vendor_Motorola,
 };
 
 /**
  * The System used
  */
 enum OSystem {
     System_Unknown,
 
     System_Familiar,
     System_Zaurus,
     System_OpenZaurus,
     System_Linupy,
     System_OpenEmbedded,
-    System_PC
+    System_PC,
+    System_OpenEZX,
+    System_Angstrom,
 };
 
 typedef struct {
     OSystem system;
     char* sysstr;
     char* sysvfile;
 } ODistribution;
 
 extern ODistribution distributions[];
 
 
 enum OLedState {
     Led_Off,
     Led_On,
     Led_BlinkSlow,
     Led_BlinkFast
 };
 
 enum OLed {
     Led_Mail,
     Led_Power,
     Led_BlueTooth
 };
 
 enum OHardKey {
     HardKey_Datebook  = Qt::Key_F9,
     HardKey_Contacts  = Qt::Key_F10,
     HardKey_Menu      = Qt::Key_F11,
     HardKey_Home      = Qt::Key_F12,
     HardKey_Mail      = Qt::Key_F13,
     HardKey_Record    = Qt::Key_F24,
     HardKey_Suspend   = Qt::Key_F34,
     HardKey_Backlight = Qt::Key_F35,
     HardKey_Action    = Qt::Key_F10,
     HardKey_OK        = Qt::Key_F11,
     HardKey_End       = Qt::Key_F12,
 };
 
 enum ODirection {
     CW   = 0,
     CCW  = 1,
     Flip = 2,
 };
 
 enum OHingeStatus {
     CASE_CLOSED = 3,
     CASE_PORTRAIT = 2,
     CASE_LANDSCAPE = 0,
     CASE_UNKNOWN = 1,
 };
 
 /* default button for qvfb or such
  * see odevice.cpp for details.
  * hint: manage a user defined button for qvfb?
  * alwin
  */
 struct default_button {
     Qt::Key code;
     char *utext;
     char *pix;
     char *fpressedservice;
     char *fpressedaction;
     char *fheldservice;
     char *fheldaction;
 };
 
 /**
  * A singleton which gives informations about device specefic option
  * like the Hardware used, LEDs, the Base Distribution and
  * hardware key mappings.
  *
  * @short A small class for device specific options
  * @see QObject
  * @author Robert Griebl
  * @version 1.0
  */
 class ODevice : public QObject
 {
     Q_OBJECT
 
 private:
     /* disable copy */
     ODevice ( const ODevice & );
 
 protected:
     ODevice();
     virtual void init(const QString&);
     virtual void initButtons();
     static void sendSuspendmsg();
 
     ODeviceData *d;
 
 public:
     // sandman do we want to allow destructions? -zecke?
     virtual ~ODevice();
     static ODevice *inst();
 
     // information
     QString modelString() const;
     OModel model() const;
     inline OModel series() const { return (OModel) ( model() & Model_Series_Mask ); }
 
     QString vendorString() const;
     OVendor vendor() const;
 
     QString systemString() const;
     OSystem system() const;
 
     QString systemVersionString() const;
 
     virtual Transformation rotation() const;
     virtual ODirection direction() const;
 
     QString qteDriver() const;
 
     // system
     virtual bool suspend();
 
     virtual bool setDisplayStatus ( bool on );
     virtual bool setDisplayBrightness ( int brightness );
     virtual int displayBrightnessResolution() const;
     virtual bool setDisplayContrast ( int contrast );
     virtual int displayContrastResolution() const;
 
     // don't add new virtual methods, use this:
     //  /*virtual */ void boo(int i ) { return virtual_hook(1,&i); };
     // and in your subclass do overwrite
     //  protected virtual int virtual_hook(int, void *)
     // which is defined below
 
     // input / output
     virtual void playAlarmSound();
     virtual void playKeySound();
     virtual void playTouchSound();
 
     virtual QValueList <OLed> ledList() const;
     virtual QValueList <OLedState> ledStateList ( OLed led ) const;
     virtual OLedState ledState ( OLed led ) const;
     virtual bool setLedState ( OLed led, OLedState st );
 
     virtual bool hasLightSensor() const;
     virtual int readLightSensor();
     virtual int lightSensorResolution() const;
 
     virtual bool hasHingeSensor() const;
     virtual OHingeStatus readHingeSensor()const;
 
     const QStrList &allowedCpuFrequencies() const;
     bool setCurrentCpuFrequency(uint index);
 
     /**
      * Returns the available buttons on this device.  The number and location
      * of buttons will vary depending on the device.  Button numbers will be assigned
      * by the device manufacturer and will be from most preferred button to least preffered
      * button.  Note that this list only contains "user mappable" buttons.
      *
      * @todo Make method const and take care of calling initButtons or make that const too
      *
      */
     const QValueList<ODeviceButton> &buttons();
 
     /**
      * Returns the DeviceButton for the \a keyCode.  If \a keyCode is not found, it
      * returns 0L
      */
     const ODeviceButton *buttonForKeycode ( ushort keyCode );
 
     /**
      * Reassigns the pressed action for \a button.  To return to the factory
      * default pass an empty string as \a qcopMessage.
      */
     void remapPressedAction ( int button, const OQCopMessage &qcopMessage );
 
     /**
      * Reassigns the held action for \a button.  To return to the factory
      * default pass an empty string as \a qcopMessage.
      */
     void remapHeldAction ( int button, const OQCopMessage &qcopMessage );
 
     /**
      * How long (in ms) you have to press a button for a "hold" action
      */
     uint buttonHoldTime() const;
 
 signals:
     void buttonMappingChanged();
 
 private slots:
     void systemMessage ( const QCString &, const QByteArray & );
     void playingStopped();
 
 protected:
     void addPreHandler(QWSServer::KeyboardFilter*aFilter);
     void remPreHandler(QWSServer::KeyboardFilter*aFilter);
     void reloadButtonMapping();
     void changeMixerForAlarm( int mixer, const char* file, Sound *snd);
 
     /*  ugly virtual hook */
     virtual void virtual_hook( int id, void* data );
 };
 
 class ODeviceData {
 
   public:
     QString m_vendorstr;
     OVendor m_vendor;
 
     QString m_modelstr;
     OModel m_model;
 
     QString m_systemstr;
     OSystem m_system;
 
     QString m_sysverstr;
 
     Transformation m_rotation;
     ODirection m_direction;
 
     QString m_qteDriver;
 
     QValueList <ODeviceButton> *m_buttons;
     uint                        m_holdtime;
     QStrList                   *m_cpu_frequencies;
     bool    m_initializedButtonQcop : 1;
 
     /* values for changeMixerForAlarm */
     int m_sound, m_vol, m_mixer;
 };
 
 extern bool isQWS();
 extern QCString makeChannel ( const char *str );
 }
 }
 
-
-
-
 #endif
-
diff --git a/libopie2/opiecore/device/odevice_motorola_ezx.cpp b/libopie2/opiecore/device/odevice_motorola_ezx.cpp
new file mode 100644
index 0000000..69256dd
--- a/dev/null
+++ b/libopie2/opiecore/device/odevice_motorola_ezx.cpp
@@ -0,0 +1,325 @@
+/*
+                             This file is part of the Opie Project
+              =.             (C) 2006 Michael 'Mickey' Lauer <mickey@Vanille.de>
+            .=l.
+           .>+-=
+ _;:,     .>    :=|.         This program is free software; you can
+.> <`_,   >  .   <=          redistribute it and/or  modify it under
+:`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
+.="- .-=="i,     .._         License as published by the Free Software
+ - .   .-<_>     .<>         Foundation; version 2 of the License.
+     ._= =}       :
+    .%`+i>       _;_.
+    .i_,=:_.      -<s.       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
+..}^=.=       =       ;      Library General Public License for more
+++=   -.     .`     .:       details.
+ :     =  ...= . :.=-
+ -.   .:....=;==+<;          You should have received a copy of the GNU
+  -_. . .   )=.  =           Library General Public License along with
+    --        :-=`           this library; see the file COPYING.LIB.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+*/
+
+#include "odevice_motorola_ezx.h"
+
+/* OPIE */
+#include <opie2/oinputsystem.h>
+#include <opie2/oresource.h>
+
+#include <qpe/config.h>
+#include <qpe/sound.h>
+
+/* QT */
+#include <qapplication.h>
+#include <qfile.h>
+#include <qtextstream.h>
+#include <qwindowsystem_qws.h>
+#include <qcopchannel_qws.h>
+
+/* STD */
+#include <assert.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <math.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <unistd.h>
+#ifndef QT_NO_SOUND
+#include <linux/soundcard.h>
+#endif
+
+using namespace Opie::Core;
+using namespace Opie::Core::Internal;
+
+struct ezx_button ezx_buttons [] = {
+    { Qt::Key_F9, QT_TRANSLATE_NOOP("Button", "Calendar Button"),
+    "devicebuttons/z_calendar",
+    "datebook", "nextView()",
+    "today", "raise()" },
+    { Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Contacts Button"),
+    "devicebuttons/z_contact",
+    "addressbook", "raise()",
+    "addressbook", "beamBusinessCard()" },
+    { Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Home Button"),
+    "devicebuttons/z_home",
+    "QPE/Launcher", "home()",
+    "buttonsettings", "raise()" },
+    { Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Menu Button"),
+    "devicebuttons/z_menu",
+    "QPE/TaskBar", "toggleMenu()",
+    "QPE/TaskBar", "toggleStartMenu()" },
+    { Qt::Key_F13, QT_TRANSLATE_NOOP("Button", "Mail Button"),
+    "devicebuttons/z_mail",
+    "opiemail", "raise()",
+    "opiemail", "newMail()" },
+};
+
+void Motorola_EZX::init(const QString& cpu_info)
+{
+    qDebug( "Motorola_EZX::init()" );
+    // Set the time to wait until the system is really suspended
+    // the delta between apm --suspend and sleeping
+    setAPMTimeOut( 15000 );
+
+    d->m_vendorstr = "OpenEZX Team";
+    d->m_systemstr = "OpenEZX";
+    d->m_system = System_OpenEZX;
+    // sysver already gathered
+
+    // check the Motorola_EZX model
+    QString model;
+    int loc = cpu_info.find( ":" );
+    if ( loc != -1 )
+        model = cpu_info.mid( loc+2 ).simplifyWhiteSpace();
+    else
+        model = cpu_info;
+
+    if ( model == "Motorola Ezx Platform" ) {
+        d->m_model = Model_Motorola_EZX;
+        d->m_modelstr = "Motorola_EZX";
+    } else assert( 0 );
+
+    // set path to backlight device in kernel 2.6
+    m_backlightdev = "/sys/class/backlight/ezx-bl/";
+    d->m_rotation = Rot0;
+    //initHingeSensor();
+
+    // set default qte driver and led state
+    d->m_qteDriver = "Transformed";
+    m_leds[0] = Led_Off;
+
+    qDebug( "Motorola_EZX::init() - Using the 2.6 OpenEZX HAL on a %s", (const char*) d->m_modelstr );
+}
+
+void Motorola_EZX::initButtons()
+{
+    qDebug( "Motorola_EZX::initButtons()" );
+    if ( d->m_buttons )
+        return;
+
+    d->m_buttons = new QValueList <ODeviceButton>;
+
+    struct ezx_button * ezx_buttons;
+    int buttoncount;
+
+/*
+
+    switch ( d->m_model )
+    {
+        case Model_Motorola_EZX_SL6000:
+            pezx_buttons = ezx_buttons_6000;
+            buttoncount = ARRAY_SIZE(ezx_buttons_6000);
+            break;
+        case Model_Motorola_EZX_SLC3100: // fallthrough
+        case Model_Motorola_EZX_SLC3000: // fallthrough
+        case Model_Motorola_EZX_SLC1000: // fallthrough
+        case Model_Motorola_EZX_SLC7x0:
+            if ( isQWS( ) )
+            {
+                addPreHandler(this);
+            }
+            pezx_buttons = ezx_buttons_c700;
+            buttoncount = ARRAY_SIZE(ezx_buttons_c700);
+            break;
+        default:
+            pezx_buttons = ezx_buttons;
+            buttoncount = ARRAY_SIZE(ezx_buttons);
+            break;
+    }
+
+    for ( int i = 0; i < buttoncount; i++ ) {
+        struct ezx_button *zb = pezx_buttons + i;
+        ODeviceButton b;
+
+        b.setKeycode( zb->code );
+        b.setUserText( QObject::tr( "Button", zb->utext ));
+        b.setPixmap( OResource::loadPixmap( zb->pix ));
+        b.setFactoryPresetPressedAction( OQCopMessage( makeChannel ( zb->fpressedservice ), zb->fpressedaction ));
+        b.setFactoryPresetHeldAction( OQCopMessage( makeChannel ( zb->fheldservice ), zb->fheldaction ));
+        d->m_buttons->append( b );
+    }
+*/
+    reloadButtonMapping();
+}
+
+void Motorola_EZX::playAlarmSound()
+{
+#ifndef QT_NO_SOUND
+    static Sound snd ( "alarm" );
+    if(!snd.isFinished())
+    return;
+
+    changeMixerForAlarm(0, "/dev/sound/mixer", &snd );
+    snd. play();
+#endif
+}
+
+QValueList <OLed> Motorola_EZX::ledList() const
+{
+    QValueList <OLed> vl;
+    vl << Led_Mail;
+    return vl;
+}
+
+QValueList <OLedState> Motorola_EZX::ledStateList( OLed l ) const
+{
+    QValueList <OLedState> vl;
+
+    if ( l == Led_Mail )
+        vl << Led_Off << Led_On << Led_BlinkSlow;
+    return vl;
+}
+
+OLedState Motorola_EZX::ledState( OLed which ) const
+{
+    if ( which == Led_Mail )
+        return m_leds [0];
+    else
+        return Led_Off;
+}
+
+bool Motorola_EZX::setLedState( OLed which, OLedState st )
+{
+     // Currently not supported
+    qDebug( "Motorola_EZX::setLedState: ODevice handling not yet implemented" );
+    return false;
+}
+
+int Motorola_EZX::displayBrightnessResolution() const
+{
+     // Currently not supported
+    qDebug( "Motorola_EZX::displayBrightnessResolution: ODevice handling not yet implemented" );
+    return 100;
+
+#if 0
+    int res = 1;
+    if (m_embedix)
+    {
+        int fd = ::open( SHARP_FL_IOCTL_DEVICE, O_RDWR|O_NONBLOCK );
+        if ( fd )
+        {
+            int value = ::ioctl( fd, SHARP_FL_IOCTL_GET_STEP, 0 );
+            ::close( fd );
+            return value ? value : res;
+        }
+    }
+    else
+    {
+        int fd = ::open( m_backlightdev + "max_brightness", O_RDONLY|O_NONBLOCK );
+        if ( fd )
+        {
+            char buf[100];
+            if ( ::read( fd, &buf[0], sizeof buf ) ) ::sscanf( &buf[0], "%d", &res );
+            ::close( fd );
+        }
+    }
+    return res;
+#endif
+}
+
+bool Motorola_EZX::setDisplayBrightness( int bright )
+{
+    qDebug( "Motorola_EZX::setDisplayBrightness( %d )", bright );
+    return false;
+
+#if 0
+    bool res = false;
+
+    if ( bright > 255 ) bright = 255;
+    if ( bright < 0 ) bright = 0;
+
+    int numberOfSteps = displayBrightnessResolution();
+    int val = ( bright == 1 ) ? 1 : ( bright * numberOfSteps ) / 255;
+
+    if ( m_embedix )
+    {
+        int fd = ::open( SHARP_FL_IOCTL_DEVICE, O_WRONLY|O_NONBLOCK );
+        if ( fd )
+        {
+            res = ( ::ioctl( fd, SHARP_FL_IOCTL_STEP_CONTRAST, val ) == 0 );
+            ::close( fd );
+        }
+    }
+    else
+    {
+        int fd = ::open( m_backlightdev + "brightness", O_WRONLY|O_NONBLOCK );
+        if ( fd )
+        {
+            char buf[100];
+            int len = ::snprintf( &buf[0], sizeof buf, "%d", val );
+            res = ( ::write( fd, &buf[0], len ) == 0 );
+            ::close( fd );
+        }
+    }
+    return res;
+#endif
+}
+
+bool Motorola_EZX::setDisplayStatus( bool on )
+{
+    bool res = false;
+    int fd = ::open( m_backlightdev + "power", O_WRONLY|O_NONBLOCK );
+    if ( fd )
+    {
+        char buf[10];
+        buf[0] = on ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
+        buf[1] = '\0';
+        res = ( ::write( fd, &buf[0], 2 ) == 0 );
+        ::close( fd );
+    }
+    return res;
+}
+
+void Motorola_EZX::systemMessage( const QCString &msg, const QByteArray & )
+{
+    if ( msg == "deviceButtonMappingChanged()" ) {
+        reloadButtonMapping();
+    }
+}
+
+bool Motorola_EZX::suspend() {
+    if ( !isQWS( ) ) // only qwsserver is allowed to suspend
+        return false;
+
+    bool res = false;
+    QCopChannel::send( "QPE/System", "aboutToSuspend()" );
+
+    struct timeval tvs, tvn;
+    ::gettimeofday ( &tvs, 0 );
+
+    ::sync(); // flush fs caches
+    res = ( ::system ( "apm --suspend" ) == 0 );
+
+    QCopChannel::send( "QPE/System", "returnFromSuspend()" );
+
+    return res;
+}
diff --git a/libopie2/opiecore/device/odevice_motorola_ezx.h b/libopie2/opiecore/device/odevice_motorola_ezx.h
new file mode 100644
index 0000000..c0bd6c7
--- a/dev/null
+++ b/libopie2/opiecore/device/odevice_motorola_ezx.h
@@ -0,0 +1,102 @@
+/*
+                             This file is part of the Opie Project
+              =.             (C) 2006 Michael 'Mickey' Lauer <mickey@Vanille.de>
+            .=l.
+           .>+-=
+ _;:,     .>    :=|.         This program is free software; you can
+.> <`_,   >  .   <=          redistribute it and/or  modify it under
+:`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
+.="- .-=="i,     .._         License as published by the Free Software
+ - .   .-<_>     .<>         Foundation; version 2 of the License.
+     ._= =}       :
+    .%`+i>       _;_.
+    .i_,=:_.      -<s.       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
+..}^=.=       =       ;      Library General Public License for more
+++=   -.     .`     .:       details.
+ :     =  ...= . :.=-
+ -.   .:....=;==+<;          You should have received a copy of the GNU
+  -_. . .   )=.  =           Library General Public License along with
+    --        :-=`           this library; see the file COPYING.LIB.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+*/
+
+#ifndef ODEVICE_MOTOROLA_EZX
+#define ODEVICE_MOTOROLA_EZX
+
+#include "odevice_abstractmobiledevice.h"
+
+/* QT */
+#include <qfile.h>
+#include <qwindowsystem_qws.h>
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+#endif
+
+// Audio
+// LED
+// Power Management
+#define APM_IOCGEVTSRC          OD_IOR( 'A', 203, int )
+#define APM_IOCSEVTSRC          OD_IORW( 'A', 204, int )
+#define APM_EVT_POWER_BUTTON    (1 << 0)
+
+// Vesa Standard
+#define FB_BLANK_UNBLANK            0
+#define FB_BLANK_POWERDOWN          4
+
+namespace Opie {
+namespace Core {
+namespace Internal {
+
+class Motorola_EZX : public OAbstractMobileDevice
+{
+  Q_OBJECT
+
+  protected:
+    virtual void init(const QString&);
+    virtual void initButtons();
+    //void initHingeSensor();
+
+  protected slots:
+    //void hingeSensorTriggered();
+    void systemMessage( const QCString &msg, const QByteArray & );
+
+  public:
+    virtual bool setDisplayBrightness( int b );
+    virtual bool setDisplayStatus( bool on );
+    virtual int displayBrightnessResolution() const;
+
+    virtual void playAlarmSound();
+
+    virtual QValueList <OLed> ledList() const;
+    virtual QValueList <OLedState> ledStateList ( OLed led ) const;
+    virtual OLedState ledState( OLed led ) const;
+    virtual bool setLedState( OLed led, OLedState st );
+
+    virtual bool suspend();
+
+  protected:
+    QString m_backlightdev;
+    OLedState m_leds[1];
+    QFile m_hinge;
+};
+
+struct ezx_button {
+    Qt::Key code;
+    char *utext;
+    char *pix;
+    char *fpressedservice;
+    char *fpressedaction;
+    char *fheldservice;
+    char *fheldaction;
+};
+}
+}
+}
+#endif