3 files changed, 64 insertions, 40 deletions

diff --git a/libopie2/opiecore/device/odevice.h b/libopie2/opiecore/device/odevice.h
index 93d7d22..bbc32fa 100644
--- a/libopie2/opiecore/device/odevice.h
+++ b/libopie2/opiecore/device/odevice.h
@@ -71,24 +71,25 @@ enum OModel {
 
     Model_Jornada       = ( 6 << 24 ),
     Model_Jornada_56x   = ( Model_Jornada | 0x000001 ),
 
     Model_Zaurus        = ( 2 << 24 ),
 
     Model_Zaurus_SL5000 = ( Model_Zaurus | 0x000001 ),
     Model_Zaurus_SL5500 = ( Model_Zaurus | 0x000002 ),
     Model_Zaurus_SLA300 = ( Model_Zaurus | 0x000003 ),
     Model_Zaurus_SLB600 = ( Model_Zaurus | 0x000004 ),
     Model_Zaurus_SLC7x0 = ( Model_Zaurus | 0x000005 ),
     Model_Zaurus_SL6000 = ( Model_Zaurus | 0x000006 ),
+    Model_Zaurus_SLC3000 = ( Model_Zaurus | 0x000007 ),
 
     Model_SIMpad        = ( 3 << 24 ),
 
     Model_SIMpad_All    = ( Model_SIMpad | 0xffffff ),
     Model_SIMpad_CL4    = ( Model_SIMpad | 0x000001 ),
     Model_SIMpad_SL4    = ( Model_SIMpad | 0x000002 ),
     Model_SIMpad_SLC    = ( Model_SIMpad | 0x000004 ),
     Model_SIMpad_TSinus = ( Model_SIMpad | 0x000008 ),
 
     Model_Ramses        = ( 4 << 24 ),
 
     Model_Ramses_All    = ( Model_Ramses | 0xffffff ),
@@ -352,25 +353,25 @@ class ODeviceData {
 
     QString m_systemstr;
     OSystem m_system;
 
     QString m_sysverstr;
 
     Transformation m_rotation;
     ODirection m_direction;
 
     QValueList <ODeviceButton> *m_buttons;
     uint                        m_holdtime;
     QStrList                   *m_cpu_frequencies;
-            boolm_initializedButtonQcop : 1;
+    bool    m_initializedButtonQcop : 1;
 
     /* values for changeMixerForAlarm */
     int m_sound, m_vol, m_mixer;
 };
 
 extern bool isQWS();
 extern QCString makeChannel ( const char *str );
 }
 }
 
 
 
diff --git a/libopie2/opiecore/device/odevice_zaurus.cpp b/libopie2/opiecore/device/odevice_zaurus.cpp
index fb23e1d..75a2fdc 100644
--- a/libopie2/opiecore/device/odevice_zaurus.cpp
+++ b/libopie2/opiecore/device/odevice_zaurus.cpp
@@ -160,56 +160,63 @@ void Zaurus::init(const QString& cpu_info)
     else
         model = cpu_info;
 
     if ( model == "SHARP Corgi" ) {
         d->m_model = Model_Zaurus_SLC7x0;
         d->m_modelstr = "Zaurus SL-C700";
     } else if ( model == "SHARP Shepherd" ) {
         d->m_model = Model_Zaurus_SLC7x0;
         d->m_modelstr = "Zaurus SL-C750";
     } else if ( model == "SHARP Husky" ) {
         d->m_model = Model_Zaurus_SLC7x0;
         d->m_modelstr = "Zaurus SL-C760 or SL-C860";
+    } else if ( model == "SHARP Boxer" ) {
+        d->m_model = Model_Zaurus_SLC7x0;
+        d->m_modelstr = "Zaurus SL-C760 or SL-C860";
     } else if ( model == "SHARP Poodle" ) {
         d->m_model = Model_Zaurus_SLB600;
         d->m_modelstr = "Zaurus SL-B500 or SL-5600";
     } else if ( model == "Sharp-Collie" || model == "Collie" ) {
         d->m_model = Model_Zaurus_SL5500;
         d->m_modelstr = "Zaurus SL-5500 or SL-5000d";
     } else if ( model == "SHARP Tosa" ) {
         d->m_model = Model_Zaurus_SL6000;
         d->m_modelstr = "Zaurus SL-6000";
+    } else if ( model == "SHARP Spitz" ) {
+        d->m_model = Model_Zaurus_SLC3000;
+        d->m_modelstr = "Zaurus SL-C3000";
     } else {
         d->m_model = Model_Zaurus_SL5500;
-        d->m_modelstr = "Unkown Zaurus";
+        d->m_modelstr = "Unknown Zaurus";
     }
 
     // set initial rotation
     switch( d->m_model ) {
         case Model_Zaurus_SL6000: // fallthrough
         case Model_Zaurus_SLA300:
             d->m_rotation = Rot0;
             break;
+        case Model_Zaurus_SLC3000: // fallthrough
         case Model_Zaurus_SLC7x0:
             d->m_rotation = rotation();
             d->m_direction = direction();
             break;
         case Model_Zaurus_SLB600: // fallthrough
+        case Model_Zaurus_SL5000: // fallthrough
         case Model_Zaurus_SL5500: // fallthrough
-        case Model_Zaurus_SL5000:
         default:
             d->m_rotation = Rot270;
             break;
     }
-    m_leds [0] = Led_Off;
+    m_leds[0] = Led_Off;
 }
 
 void Zaurus::initButtons()
 {
     if ( d->m_buttons )
         return;
 
     d->m_buttons = new QValueList <ODeviceButton>;
 
     struct z_button * pz_buttons;
     int buttoncount;
     switch ( d->m_model ) {
@@ -244,45 +251,44 @@ void Zaurus::initButtons()
 
 
 typedef struct sharp_led_status {
     int which;   /* select which LED status is wanted. */
     int status;  /* set new led status if you call SHARP_LED_SETSTATUS */
 } sharp_led_status;
 
 void Zaurus::buzzer( int sound )
 {
 #ifndef QT_NO_SOUND
     Sound *snd = 0;
 
-    // Not all devices have real sound
-    if ( d->m_model == Model_Zaurus_SLC7x0
-      || d->m_model == Model_Zaurus_SLB600 
-      || d->m_model == Model_Zaurus_SL6000 ) {
+    // All devices except SL5500 have a DSP device
+    if ( d->m_model != Model_Zaurus_SL5000
+      && d->m_model != Model_Zaurus_SL5500 ) {
 
         switch ( sound ){
         case SHARP_BUZ_TOUCHSOUND: {
             static Sound touch_sound("touchsound");
             snd = &touch_sound;
-        }
+    }
             break;
         case SHARP_BUZ_KEYSOUND: {
             static Sound key_sound( "keysound" );
             snd = &key_sound;
-        }
+    }
             break;
         case SHARP_BUZ_SCHEDULE_ALARM:
         default: {
             static Sound alarm_sound("alarm");
             snd = &alarm_sound;
-                }    
+    }
             break;
         }
     }
 
     // If a soundname is defined, we expect that this device has
     // sound capabilities.. Otherwise we expect to have the buzzer
     // device..
     if ( snd && snd->isFinished() ){
         changeMixerForAlarm( 0, "/dev/sound/mixer", snd );
         snd->play();
     } else if( !snd ) {
         int fd = ::open ( "/dev/sharp_buz", O_WRONLY|O_NONBLOCK );
@@ -311,45 +317,49 @@ void Zaurus::playKeySound()
 {
     buzzer( SHARP_BUZ_KEYSOUND );
 }
 
 
 QValueList <OLed> Zaurus::ledList() const
 {
     QValueList <OLed> vl;
     vl << Led_Mail;
     return vl;
 }
 
-QValueList <OLedState> Zaurus::ledStateList ( OLed l ) const
+QValueList <OLedState> Zaurus::ledStateList( OLed l ) const
 {
     QValueList <OLedState> vl;
 
     if ( l == Led_Mail )
         vl << Led_Off << Led_On << Led_BlinkSlow;
     return vl;
 }
 
-OLedState Zaurus::ledState ( OLed which ) const
+OLedState Zaurus::ledState( OLed which ) const
 {
     if ( which == Led_Mail )
         return m_leds [0];
     else
         return Led_Off;
 }
 
-bool Zaurus::setLedState ( OLed which, OLedState st )
+bool Zaurus::setLedState( OLed which, OLedState st )
 {
-    if (!m_embedix) // Currently not supported on non_embedix kernels
+     // Currently not supported on non_embedix kernels
+    if (!m_embedix)
+    {
+        qDebug( "Zaurus::setLedState: ODevice handling for non-embedix kernels not yet implemented" );
         return false;
+    }
 
     static int fd = ::open ( "/dev/sharp_led", O_RDWR|O_NONBLOCK );
 
     if ( which == Led_Mail ) {
         if ( fd >= 0 ) {
             struct sharp_led_status leds;
             ::memset ( &leds, 0, sizeof( leds ));
             leds. which = SHARP_LED_MAIL_EXISTS;
             bool ok = true;
 
             switch ( st ) {
                 case Led_Off      : leds. status = LED_MAIL_NO_UNREAD_MAIL; break;
@@ -406,58 +416,58 @@ bool Zaurus::setSoftSuspend ( bool soft )
 
 bool Zaurus::setDisplayBrightness( int bright )
 {
     //qDebug( "Zaurus::setDisplayBrightness( %d )", bright );
     bool res = false;
 
     if ( bright > 255 ) bright = 255;
     if ( bright < 0 ) bright = 0;
 
     if ( m_embedix )
     {
         int numberOfSteps = displayBrightnessResolution();
-        int fd = ::open( SHARP_FL_IOCTL_DEVICE, O_WRONLY|O_NONBLOCK );       
+        int fd = ::open( SHARP_FL_IOCTL_DEVICE, O_WRONLY|O_NONBLOCK );
         if ( fd )
         {
             int val = ( bright * numberOfSteps ) / 255;
             res = ( ::ioctl ( fd, SHARP_FL_IOCTL_STEP_CONTRAST, val ) == 0 );
             ::close ( fd );
         }
     }
     else
     {
-        qDebug( "ODevice handling for non-embedix kernels not yet implemented" );
+        qDebug( "Zaurus::setDisplayBrightness: ODevice handling for non-embedix kernels not yet implemented" );
     }
     return res;
 }
 
 bool Zaurus::setDisplayStatus( bool on )
 {
     bool res = false;
     if ( m_embedix )
     {
-        int fd = ::open( SHARP_FL_IOCTL_DEVICE, O_WRONLY|O_NONBLOCK );       
+        int fd = ::open( SHARP_FL_IOCTL_DEVICE, O_WRONLY|O_NONBLOCK );
         if ( fd )
         {
             int ioctlnum = on ? SHARP_FL_IOCTL_ON : SHARP_FL_IOCTL_OFF;
             res = ( ::ioctl ( fd, ioctlnum, 0 ) == 0 );
             ::close ( fd );
         }
     }
     else
     {
-        qDebug( "ODevice handling for non-embedix kernels not yet implemented" );
+        qDebug( "Zaurus::setDisplayStatus: ODevice handling for non-embedix kernels not yet implemented" );
     }
     return res;
-}    
+}
 
 bool Zaurus::suspend()
 {
     qDebug("ODevice::suspend");
     if ( !isQWS( ) ) // only qwsserver is allowed to suspend
         return false;
 
     if ( d->m_model == Model_Unknown ) // better don't suspend in qvfb / on unkown devices
         return false;
 
     bool res = false;
     ODevice::sendSuspendmsg();
@@ -480,111 +490,123 @@ bool Zaurus::suspend()
     QCopEnvelope ( "QPE/Rotation", "rotateDefault()" );
     return res;
 }
 
 
 Transformation Zaurus::rotation() const
 {
     Transformation rot;
     int handle = 0;
     int retval = 0;
 
     switch ( d->m_model ) {
+        case Model_Zaurus_SLC3000: // fallthrough
         case Model_Zaurus_SLC7x0:
             handle = ::open("/dev/apm_bios", O_RDWR|O_NONBLOCK);
             if (handle == -1) {
                 return Rot270;
             } else {
                 retval = ::ioctl(handle, SHARP_IOCTL_GET_ROTATION);
                 ::close (handle);
 
                 if (retval == 2 )
                     rot = Rot0;
                 else
                     rot = Rot270;
             }
             break;
-        case Model_Zaurus_SLA300:
+        case Model_Zaurus_SL6000:
         case Model_Zaurus_SLB600:
+        case Model_Zaurus_SLA300:
         case Model_Zaurus_SL5500:
         case Model_Zaurus_SL5000:
         default:
             rot = d->m_rotation;
             break;
     }
 
     return rot;
 }
 ODirection Zaurus::direction() const
 {
     ODirection dir;
     int handle = 0;
     int retval = 0;
     switch ( d->m_model ) {
+        case Model_Zaurus_SLC3000: // fallthrough
         case Model_Zaurus_SLC7x0:
             handle = ::open( "/dev/apm_bios", O_RDWR|O_NONBLOCK );
             if (handle == -1) {
                 dir = CW;
             } else {
                 retval = ::ioctl( handle, SHARP_IOCTL_GET_ROTATION );
                 ::close (handle);
                 if (retval == 2 )
                     dir = CCW;
                 else
                     dir = CW;
             }
             break;
+        case Model_Zaurus_SL6000:
         case Model_Zaurus_SLA300:
         case Model_Zaurus_SLB600:
         case Model_Zaurus_SL5500:
         case Model_Zaurus_SL5000:
-        default: dir = d->m_direction; 
+        default: dir = d->m_direction;
             break;
     }
     return dir;
 
 }
 
 int Zaurus::displayBrightnessResolution() const
 {
     if (m_embedix)
     {
         int handle = ::open( SHARP_FL_IOCTL_DEVICE, O_RDWR|O_NONBLOCK );
         if ( handle != -1 ) return ::ioctl( handle, SHARP_FL_IOCTL_GET_STEP, 0 );
         else return 1;
     }
     else
     {
-        qDebug( "ODevice handling for non-embedix kernels not yet implemented" );
+        qDebug( "Zaurus::displayBrightnessResolution: ODevice handling for non-embedix kernels not yet implemented" );
         return 1;
     }
 }
 
 bool Zaurus::hasHingeSensor() const
 {
-    return d->m_model == Model_Zaurus_SLC7x0;
+    return d->m_model == Model_Zaurus_SLC7x0 || d->m_model == Model_Zaurus_SLC3000;
 }
 
 OHingeStatus Zaurus::readHingeSensor()
 {
-    int handle = ::open("/dev/apm_bios", O_RDWR|O_NONBLOCK);
-    if (handle == -1)
-    {
-        qWarning("Zaurus::readHingeSensor() - failed (%s)", "unknown reason" ); //FIXME: use strerror
-        return CASE_UNKNOWN;
-    }
-    else
+    if (m_embedix)
     {
-        int retval = ::ioctl(handle, SHARP_IOCTL_GET_ROTATION);
-        ::close (handle);
-        if ( retval == CASE_CLOSED || retval == CASE_PORTRAIT || retval == CASE_LANDSCAPE )
+        int handle = ::open("/dev/apm_bios", O_RDWR|O_NONBLOCK);
+        if (handle == -1)
         {
-            qDebug( "Zaurus::readHingeSensor() - result = %d", retval );
-            return static_cast<OHingeStatus>( retval );
+            qWarning("Zaurus::readHingeSensor() - failed (%s)", "unknown reason" ); //FIXME: use strerror
+            return CASE_UNKNOWN;
         }
         else
         {
-            qWarning("Zaurus::readHingeSensor() - couldn't compute hinge status!" );
-            return CASE_UNKNOWN;
+            int retval = ::ioctl(handle, SHARP_IOCTL_GET_ROTATION);
+            ::close (handle);
+            if ( retval == CASE_CLOSED || retval == CASE_PORTRAIT || retval == CASE_LANDSCAPE )
+            {
+                qDebug( "Zaurus::readHingeSensor() - result = %d", retval );
+                return static_cast<OHingeStatus>( retval );
+            }
+            else
+            {
+                qWarning("Zaurus::readHingeSensor() - couldn't compute hinge status!" );
+                return CASE_UNKNOWN;
+            }
         }
     }
+    else
+    {
+        qDebug( "Zaurus::readHingeSensor: ODevice handling for non-embedix kernels not yet implemented" );
+        return CASE_UNKNOWN;
+    }
 }
diff --git a/libopie2/opiecore/device/odevice_zaurus.h b/libopie2/opiecore/device/odevice_zaurus.h
index 37ab876..ed9cf67 100644
--- a/libopie2/opiecore/device/odevice_zaurus.h
+++ b/libopie2/opiecore/device/odevice_zaurus.h
@@ -77,24 +77,25 @@
 
 // Brightness
 #define SHARP_FL_IOCTL_DEVICE   "/dev/sharp_fl"
 #define SHARP_FL_IOCTL_ON                  1
 #define SHARP_FL_IOCTL_OFF                 2
 #define SHARP_FL_IOCTL_STEP_CONTRAST     100
 #define SHARP_FL_IOCTL_GET_STEP_CONTRAST 101
 #define SHARP_FL_IOCTL_GET_STEP          102
 
 namespace Opie {
 namespace Core {
 namespace Internal {
+
 class Zaurus : public ODevice
 {
   protected:
     virtual void init(const QString&);
     virtual void initButtons();
 
   public:
     virtual bool setSoftSuspend( bool soft );
 
     virtual bool setDisplayBrightness( int b );
     virtual bool setDisplayStatus( bool on );
     virtual int displayBrightnessResolution() const;
@@ -107,27 +108,27 @@ class Zaurus : public ODevice
     virtual QValueList <OLedState> ledStateList ( OLed led ) const;
     virtual OLedState ledState( OLed led ) const;
     virtual bool setLedState( OLed led, OLedState st );
 
     virtual bool hasHingeSensor() const;
     virtual OHingeStatus readHingeSensor();
 
     virtual bool suspend();
     virtual Transformation rotation() const;
     virtual ODirection direction() const;
 
   protected:
-    virtual void buzzer ( int snd );
+    virtual void buzzer( int snd );
 
-    OLedState m_leds [1];
+    OLedState m_leds[1];
     bool m_embedix;
 };
 
 struct z_button {
     Qt::Key code;
     char *utext;
     char *pix;
     char *fpressedservice;
     char *fpressedaction;
     char *fheldservice;
     char *fheldaction;
 };