frequency change works now

4 files changed, 61 insertions, 23 deletions

diff --git a/core/settings/light-and-power/light.cpp b/core/settings/light-and-power/light.cpp
index 8b98672..68c2929 100644
--- a/core/settings/light-and-power/light.cpp
+++ b/core/settings/light-and-power/light.cpp
@@ -1,257 +1,283 @@
 /*
                              This file is part of the OPIE Project
                =.            Copyright (c)  2002 Maximilian Reiss <harlekin@handhelds.org>
              .=l.            Copyright (c)  2002 Robert Griebl <sandman@handhelds.org>
            .>+-=
  _;:,     .>    :=|.         This file is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This file is distributed in the hope that
      +  .  -:.       =       it will be useful, but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU General
 ..}^=.=       =       ;      Public License for more details.
 ++=   -.     .`     .:       
  :     =  ...= . :.=-        You should have received a copy of the GNU
  -.   .:....=;==+<;          General Public License along with this file;
   -_. . .   )=.  =           see the file COPYING. If not, write to the
     --        :-=`           Free Software Foundation, Inc.,
                              59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #include "light.h"
 
 #include <qpe/config.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/power.h>
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
 #include <qpe/qcopenvelope_qws.h>
 #endif
 
 #include <qcheckbox.h>
 #include <qtabwidget.h>
 #include <qslider.h>
 #include <qtimer.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qgroupbox.h>
+#include <qcombobox.h>
 
 #include <opie/odevice.h>
 
 #include "sensor.h"
 
 using namespace Opie;
 
 LightSettings::LightSettings( QWidget* parent,  const char* name, WFlags )
 	: LightSettingsBase( parent, name, false, WStyle_ContextHelp )
 {
 	m_bres = ODevice::inst ( )-> displayBrightnessResolution ( );
 	m_cres = ODevice::inst ( )-> displayContrastResolution ( );
 
 	if ( !ODevice::inst ( )-> hasLightSensor ( )) {
 		auto_brightness-> hide ( );
 		CalibrateLightSensor-> hide ( );
 		auto_brightness_ac-> hide ( );
 		CalibrateLightSensor_ac-> hide ( );
 	}
 	if (m_cres) {
-		GroupLight->setTitle(tr("Backlight & Contrast"));
+		GroupLight->setTitle(tr("Backlight && Contrast"));
+		GroupLight_ac->setTitle(GroupLight->title());
 	} else {
 		contrast->hide();
 		contrast_ac->hide();
 	}
 
+	QStrList freq = ODevice::inst()->cpuFrequencies();
+	if ( freq.count() ) {
+		frequency->insertStrList( freq );
+		frequency_ac->insertStrList( freq );
+	} else {
+		frequency->hide();
+		frequency_ac->hide();
+	}
+
 	Config config ( "apm" );
 	config. setGroup ( "Battery" );
 
 	// battery spinboxes
 	interval_dim->      setValue ( config. readNumEntry ( "Dim", 30 ));
 	interval_lightoff-> setValue ( config. readNumEntry ( "LightOff", 20 ));
 	interval_suspend->  setValue ( config. readNumEntry ( "Suspend", 60 ));
 
 	// battery check and slider
-	LcdOffOnly-> setChecked ( config. readBoolEntry ( "LcdOffOnly", false ));
+	LcdOffOnly->setChecked ( config. readBoolEntry ( "LcdOffOnly", false ));
+
+	// CPU frequency
+	frequency->setCurrentItem( config.readNumEntry("Freq", 0) );
 
 	int bright = config. readNumEntry ( "Brightness", 127 );
 	int contr  = m_oldcontrast = config. readNumEntry ( "Contrast", 127 );
 	brightness-> setTickInterval ( QMAX( 16, 256 / m_bres ));
 	brightness-> setLineStep ( QMAX( 1, 256 / m_bres ));
 	brightness-> setPageStep ( QMAX( 1, 256 / m_bres ));
 	brightness-> setValue ( bright );
 
 	if (m_cres) {
 		contrast-> setTickInterval ( QMAX( 16, 256 / m_cres ));
 		contrast-> setLineStep ( QMAX( 1, 256 / m_cres ));
 		contrast-> setPageStep ( QMAX( 1, 256 / m_cres ));
 		contrast-> setValue ( contr );
 	}
 
 	// light sensor
 	auto_brightness-> setChecked ( config. readBoolEntry ( "LightSensor", false ));
 	m_sensordata = config. readListEntry ( "LightSensorData", ';' );
 
 	config. setGroup ( "AC" );
 	
 	// ac spinboxes
 	interval_dim_ac->      setValue ( config. readNumEntry ( "Dim", 60 ));
 	interval_lightoff_ac-> setValue ( config. readNumEntry ( "LightOff", 120 ));
 	interval_suspend_ac->  setValue ( config. readNumEntry ( "Suspend", 0 ));
 
 	// ac check and slider
 	LcdOffOnly_ac-> setChecked ( config. readBoolEntry ( "LcdOffOnly", false ));
 
+	// CPU frequency
+	frequency_ac->setCurrentItem( config.readNumEntry("Freq", 0) );
+
 	bright = config. readNumEntry ( "Brightness", 255 );
 	brightness_ac-> setTickInterval ( QMAX( 16, 256 / m_bres ));
 	brightness_ac-> setLineStep ( QMAX( 1, 256 / m_bres ));
 	brightness_ac-> setPageStep ( QMAX( 1, 256 / m_bres ));
 	brightness_ac-> setValue ( bright );
 
 	if (m_cres) {
 		contr = config. readNumEntry ( "Contrast", 127);
 		contrast_ac-> setTickInterval ( QMAX( 16, 256 / m_cres ));
 		contrast_ac-> setLineStep ( QMAX( 1, 256 / m_cres ));
 		contrast_ac-> setPageStep ( QMAX( 1, 256 / m_cres ));
 		contrast_ac-> setValue ( contr );
 	}
 
 	// light sensor
 	auto_brightness_ac-> setChecked ( config. readBoolEntry ( "LightSensor", false ));
 	m_sensordata_ac = config. readListEntry ( "LightSensorData", ';' );
 	
 	// advanced settings
 	config. setGroup ( "Warnings" );
 	warnintervalBox-> setValue ( config. readNumEntry ( "checkinterval", 10000 ) / 1000 );
 	lowSpinBox->      setValue ( config. readNumEntry ( "powerverylow", 10 ) );
 	criticalSpinBox-> setValue ( config. readNumEntry ( "powercritical", 5 ) );
 
 	m_resettimer = new QTimer ( this );
 	connect ( m_resettimer, SIGNAL( timeout ( )), this, SLOT( resetBacklight ( )));
 
 	if ( PowerStatusManager::readStatus ( ). acStatus ( ) != PowerStatus::Online ) {
 		tabs-> setCurrentPage ( 0 );		
 	}
 	else {
 		tabs-> setCurrentPage ( 1 );
 	}
 	
 	connect ( brightness, SIGNAL( valueChanged ( int )), this, SLOT( setBacklight ( int )));
 	connect ( brightness_ac, SIGNAL( valueChanged ( int )), this, SLOT( setBacklight ( int )));
 	if (m_cres) {
 		connect ( contrast,    SIGNAL( valueChanged ( int )), this, SLOT( setContrast ( int )));
 		connect ( contrast_ac, SIGNAL( valueChanged ( int )), this, SLOT( setContrast ( int )));
 	}
+        connect( frequency, SIGNAL( activated(int) ),          this, SLOT( setFrequency(int) ) );
 }
 
 LightSettings::~LightSettings ( ) 
 {
 }
 
 void LightSettings::calibrateSensor ( )
 {
 	Sensor *s = new Sensor ( m_sensordata, this );
 	connect ( s, SIGNAL( viewBacklight ( int )), this, SLOT( setBacklight ( int )));
 	s-> showMaximized ( );
 	s-> exec ( );
 	delete s;
 }
 
 void LightSettings::calibrateSensorAC ( )
 {
 	Sensor *s = new Sensor ( m_sensordata_ac, this );
 	connect ( s, SIGNAL( viewBacklight ( int )), this, SLOT( setBacklight ( int )));
 	s-> showMaximized ( );
 	s-> exec ( );
 	delete s;
 }
 
 void LightSettings::setBacklight ( int bright )
 {
 	QCopEnvelope e ( "QPE/System", "setBacklight(int)" );
 	e << bright;
 	
 	if ( bright != -1 ) {
 		m_resettimer-> stop ( );
 		m_resettimer-> start ( 4000, true );
 	}	
 }
 
 void LightSettings::setContrast ( int contr )
 {
 	if (contr == -1) contr = m_oldcontrast;
 	
 	ODevice::inst ( )-> setDisplayContrast(contr);
 }
 
+void LightSettings::setFrequency ( int index )
+{
+qWarning("LightSettings::setFrequency(%d)", index);
+	ODevice::inst ( )-> setCpuFrequency(index);
+}
+
 void LightSettings::resetBacklight ( )
 {
 	setBacklight ( -1 );
 	setContrast ( -1 );
 }
 
 void LightSettings::accept ( )
 {
 	Config config ( "apm" );
 
 	// bat
 	config. setGroup ( "Battery" );
 	config. writeEntry ( "LcdOffOnly", LcdOffOnly-> isChecked ( ));
 	config. writeEntry ( "Dim",        interval_dim-> value ( ));
 	config. writeEntry ( "LightOff",   interval_lightoff-> value ( ));
 	config. writeEntry ( "Suspend",    interval_suspend-> value ( ));
 	config. writeEntry ( "Brightness", brightness-> value () );
 	if (m_cres)
 	config. writeEntry ( "Contrast",   contrast-> value () );
+	config. writeEntry ( "Freq",       frequency->currentItem() );
 
 	// ac
 	config. setGroup ( "AC" );
 	config. writeEntry ( "LcdOffOnly", LcdOffOnly_ac-> isChecked ( ));
 	config. writeEntry ( "Dim",        interval_dim_ac-> value ( ));
 	config. writeEntry ( "LightOff",   interval_lightoff_ac-> value ( ));
 	config. writeEntry ( "Suspend",    interval_suspend_ac-> value ( ));
 	config. writeEntry ( "Brightness", brightness_ac-> value () );
 	if (m_cres)
 	config. writeEntry ( "Contrast",   contrast_ac-> value () );
+	config. writeEntry ( "Freq",       frequency_ac->currentItem() );
 
 	// only make light sensor stuff appear if the unit has a sensor	
 	if ( ODevice::inst ( )-> hasLightSensor ( )) {
 		config. setGroup ( "Battery" );
 		config. writeEntry ( "LightSensor", auto_brightness->isChecked() );
 		config. writeEntry ( "LightSensorData", m_sensordata, ';' );
 		config. setGroup ( "AC" );
 		config. writeEntry ( "LightSensor", auto_brightness_ac->isChecked() );
 		config. writeEntry ( "LightSensorData", m_sensordata_ac, ';' );
 	}
 
 	// advanced
 	config. setGroup ( "Warnings" );
 	config. writeEntry ( "check_interval", warnintervalBox-> value ( ) * 1000 );
 	config. writeEntry ( "power_verylow",  lowSpinBox-> value ( ));
 	config. writeEntry ( "power_critical", criticalSpinBox-> value ( ));
 	config. write ( );
 
 	// notify the launcher
 	{
 		QCopEnvelope e ( "QPE/System", "reloadPowerWarnSettings()" );
 	}
 	{
 		QCopEnvelope e ( "QPE/System", "setScreenSaverInterval(int)" );
 		e << -1;
 	}
 	LightSettingsBase::accept ( );
 }
 
 void LightSettings::done ( int r )
 {
 	m_resettimer-> stop ( );
 	resetBacklight ( );
 	
 	LightSettingsBase::done ( r );
 	close ( );
 }
diff --git a/core/settings/light-and-power/light.h b/core/settings/light-and-power/light.h
index 4a8bf6b..c48e5f6 100644
--- a/core/settings/light-and-power/light.h
+++ b/core/settings/light-and-power/light.h
@@ -1,67 +1,70 @@
 /*
                              This file is part of the OPIE Project
                =.            Copyright (c)  2002 Maximilian Reiss <harlekin@handhelds.org>
              .=l.            Copyright (c)  2002 Robert Griebl <sandman@handhelds.org>
            .>+-=
  _;:,     .>    :=|.         This file is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This file is distributed in the hope that
      +  .  -:.       =       it will be useful, but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU General
 ..}^=.=       =       ;      Public License for more details.
 ++=   -.     .`     .:       
  :     =  ...= . :.=-        You should have received a copy of the GNU
  -.   .:....=;==+<;          General Public License along with this file;
   -_. . .   )=.  =           see the file COPYING. If not, write to the
     --        :-=`           Free Software Foundation, Inc.,
                              59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 #ifndef __LIGHT_H__
 #define __LIGHT_H__
 
 
 #include <qstringlist.h>
+#include <qlistbox.h>
 #include "lightsettingsbase.h"
 
 class QTimer;
 
 class LightSettings : public LightSettingsBase
 {
     Q_OBJECT
 
 public:
     LightSettings( QWidget* parent = 0, const char* name = 0, WFlags fl = 0 );
     ~LightSettings();
 
 protected:
     virtual void accept();
     virtual void done ( int r );
 
 protected slots:
     virtual void calibrateSensor ( );
     virtual void calibrateSensorAC ( );
     void setBacklight ( int );
     void setContrast ( int );
+    void setFrequency ( int );
     void resetBacklight ( );
 
 private:
     int m_bres;
     int m_cres;
     int m_oldcontrast;
+    int m_oldfreq;
     QTimer *m_resettimer;
     QStringList m_sensordata;
     QStringList m_sensordata_ac;
 };
 
 
 #endif
 
diff --git a/libopie/odevice.cpp b/libopie/odevice.cpp
index 4b5a54e..4c33a0e 100644
--- a/libopie/odevice.cpp
+++ b/libopie/odevice.cpp
@@ -686,227 +686,223 @@ void ODevice::alarmSound ( )
 }
 
 /**
  * This plays a key sound
  */
 void ODevice::keySound ( )
 {
 #ifndef QT_NO_SOUND
 	static Sound snd ( "keysound" );
 
 	if ( snd. isFinished ( ))
 		snd. play ( );
 #endif
 }
 
 /**
  * This plays a touch sound
  */
 void ODevice::touchSound ( )
 {
 #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 senso
  */
 int ODevice::readLightSensor ( )
 {
 	return -1;
 }
 
 /**
  * @return the light sensor resolution whatever that is ;)
  */
 int ODevice::lightSensorResolution ( ) const
 {
 	return 0;
 }
 
 /**
  * @return a list with valid CPU frequency
  */
 QStrList &ODevice::cpuFrequencies ( ) const
 {
-qWarning("ODevice::cpuFrequencies: m_cpu_frequencies is %d", (int) d->m_cpu_frequencies);
 	return *d->m_cpu_frequencies;
 }
 
 
 /**
  * Set desired cpu frequency
  * 
  * @param index index into d->m_cpu_frequencies of the frequency to be set
  */
 bool ODevice::setCpuFrequency(uint index)
 {
 	if (index >= d->m_cpu_frequencies->count())
 		return false;
 
 	char *freq = d->m_cpu_frequencies->at(index);
 	qWarning("set freq to %s", freq);
 
-	//TODO: do the change in /proc/sys/cpu/0/speed
-
-	return false;
-}
+	int fd;
 
-/**
- * Returns current frequency index out of d->m_cpu_frequencies
- */
-uint ODevice::cpuFrequency() const
-{
-	// TODO: get freq from /proc/sys/cpu/0/speed and return index
+	if ((fd = ::open("/proc/sys/cpu/0/speed", O_WRONLY)) >= 0) {
+		char writeCommand[50];
+		const int count = sprintf(writeCommand, "%s\n", freq);
+		int res = (::write(fd, writeCommand, count) != -1);
+		::close(fd);
+		return res;
+	}
 
-	return 0;
+	return false;
 }
 
 
-
 /**
  * @return a list of hardware buttons
  */
 const QValueList <ODeviceButton> &ODevice::buttons ( )
 {
 	initButtons ( );
 
 	return *d-> m_buttons;
 }
 
 /**
  * @return The amount of time that would count as a hold
  */
 uint ODevice::buttonHoldTime ( ) const
 {
 	return d-> m_holdtime;
 }
 
 /**
  * This method return a ODeviceButton for a key code
  * or 0 if no special hardware button is available for the device
  *
  * @return The devicebutton or 0l
  * @see ODeviceButton
  */
 const ODeviceButton *ODevice::buttonForKeycode ( ushort code )
 {
 	initButtons ( );
 
 	for ( QValueListConstIterator<ODeviceButton> it = d-> m_buttons-> begin ( ); it != d-> m_buttons-> end ( ); ++it ) {
 		if ( (*it). keycode ( ) == code )
 			return &(*it);
 	}
 	return 0;
 }
 
 void ODevice::reloadButtonMapping ( )
 {
 	initButtons ( );
 
 	Config cfg ( "ButtonSettings" );
 
 	for ( uint i = 0; i < d-> m_buttons-> count ( ); i++ ) {
 		ODeviceButton &b = ( *d-> m_buttons ) [i];
 		QString group = "Button" + QString::number ( i );
 
 		QCString pch, hch;
 		QCString pm, hm;
 		QByteArray pdata, hdata;
 
 		if ( cfg. hasGroup ( group )) {
 			cfg. setGroup ( group );
 			pch = cfg. readEntry ( "PressedActionChannel" ). latin1 ( );
 			pm  = cfg. readEntry ( "PressedActionMessage" ). latin1 ( );
 			// pdata = decodeBase64 ( buttonFile. readEntry ( "PressedActionArgs" ));
 
 			hch = cfg. readEntry ( "HeldActionChannel" ). latin1 ( );
 			hm  = cfg. readEntry ( "HeldActionMessage" ). latin1 ( );
 			// hdata = decodeBase64 ( buttonFile. readEntry ( "HeldActionArgs" ));
 		}
 
 		b. setPressedAction ( OQCopMessage ( pch, pm, pdata ));
 
 		b. setHeldAction ( OQCopMessage ( hch, hm, hdata ));
 	}
 }
 
 void ODevice::remapPressedAction ( int button, const OQCopMessage &action )
 {
 	initButtons ( );
 
 	QString mb_chan;
 
 	if ( button >= (int) d-> m_buttons-> count ( ))
 		return;
 
 	ODeviceButton &b = ( *d-> m_buttons ) [button];
         b. setPressedAction ( action );
 
 	mb_chan=b. pressedAction ( ). channel ( );
 
 	Config buttonFile ( "ButtonSettings" );
 	buttonFile. setGroup ( "Button" + QString::number ( button ));
 	buttonFile. writeEntry ( "PressedActionChannel", (const char*) mb_chan);
 	buttonFile. writeEntry ( "PressedActionMessage", (const char*) b. pressedAction ( ). message ( ));
 
 //	buttonFile. writeEntry ( "PressedActionArgs", encodeBase64 ( b. pressedAction ( ). data ( )));
 
 	QCopEnvelope ( "QPE/System", "deviceButtonMappingChanged()" );
 }
 
 void ODevice::remapHeldAction ( int button, const OQCopMessage &action )
 {
 	initButtons ( );
 
 	if ( button >= (int) d-> m_buttons-> count ( ))
@@ -1899,259 +1895,272 @@ bool SIMpad::suspend ( ) // Must override because SIMpad does NOT have apm
 bool SIMpad::setSoftSuspend ( bool soft )
 {
 	qDebug( "ODevice for SIMpad: UNHANDLED setSoftSuspend(%s)", soft? "on" : "off" );
 	return false;
 }
 
 
 bool SIMpad::setDisplayStatus ( bool on )
 {
 	qDebug( "ODevice for SIMpad: setDisplayStatus(%s)", on? "on" : "off" );
 
 	bool res = false;
 	int fd;
 
 	QString cmdline = QString().sprintf( "echo %s > /proc/cs3", on ? "0xd41a" : "0xd40a" ); //TODO make better :)
 
 	if (( fd = ::open ( "/dev/fb0", O_RDWR )) >= 0 ) {
 		res = ( ::system( (const char*) cmdline ) == 0 );
 		::close ( fd );
 	}
 	return res;
 }
 
 
 bool SIMpad::setDisplayBrightness ( int bright )
 {
 	qDebug( "ODevice for SIMpad: setDisplayBrightness( %d )", bright );
 	bool res = false;
 	int fd;
 
 	if ( bright > 255 )
 		bright = 255;
 	if ( bright < 0 )
 		bright = 0;
 
 	if (( fd = ::open ( SIMPAD_BACKLIGHT_CONTROL, O_WRONLY )) >= 0 ) {
 		int value = 255 - bright;
 		const int mask = SIMPAD_BACKLIGHT_MASK;
 		value = value << 8;
 		value += mask;
 		char writeCommand[100];
 		const int count = sprintf( writeCommand, "0x%x\n", value );
 		res = ( ::write ( fd, writeCommand, count ) != -1 );
 		::close ( fd );
 	}
 	return res;
 }
 
 
 int SIMpad::displayBrightnessResolution ( ) const
 {
 	switch ( model ( )) {
 		case Model_SIMpad_CL4:
 		case Model_SIMpad_SL4:
 		case Model_SIMpad_SLC:
 		case Model_SIMpad_TSinus:
 			return 255; //TODO find out if this is save
 
 		default:
 			return 2;
 	}
 }
 
 /**************************************************
  *
  * Ramses
  *
  **************************************************/
 
 void Ramses::init()
 {
 	d->m_vendorstr = "M und N";
 	d->m_vendor = Vendor_MundN;
 
 	QFile f("/proc/sys/board/ramses");
 
 	d->m_modelstr = "Ramses";
 	d->m_model = Model_Ramses_MNCI;
 
 	d->m_rotation = Rot0;
 	d->m_holdtime = 1000;
 
 	f.setName("/etc/oz_version");
 
 	if (f.open(IO_ReadOnly)) {
 	   	d->m_systemstr = "OpenEmbedded/Ramses";
 	    	d->m_system = System_OpenZaurus;
 
 		QTextStream ts(&f);
 		ts.setDevice(&f);
 		d->m_sysverstr = ts.readLine();
 		f.close();
 	}
 
 	m_power_timer = 0;
 
-qWarning("adding freq");
-	d->m_cpu_frequencies->append("100");
-	d->m_cpu_frequencies->append("200");
-	d->m_cpu_frequencies->append("300");
-	d->m_cpu_frequencies->append("400");
+#ifdef QT_QWS_ALLOW_OVERCLOCK
+#warning *** Overclocking enabled - this may fry your hardware - you have been warned ***
+#define OC(x...)        x
+#else
+#define OC(x...)
+#endif
+
+
+	// This table is true for a Intel XScale PXA 255
+
+	d->m_cpu_frequencies->append("99000");      // mem= 99, run= 99, turbo= 99, PXbus= 50
+OC(	d->m_cpu_frequencies->append("118000"); )   // mem=118, run=118, turbo=118, PXbus= 59 OC'd mem
+	d->m_cpu_frequencies->append("199100");     // mem= 99, run=199, turbo=199, PXbus= 99
+OC(	d->m_cpu_frequencies->append("236000"); )   // mem=118, run=236, turbo=236, PXbus=118 OC'd mem
+	d->m_cpu_frequencies->append("298600");     // mem= 99, run=199, turbo=298, PXbus= 99
+OC(	d->m_cpu_frequencies->append("354000"); )   // mem=118, run=236, turbo=354, PXbus=118 OC'd mem
+	d->m_cpu_frequencies->append("398099");     // mem= 99, run=199, turbo=398, PXbus= 99
+	d->m_cpu_frequencies->append("398100");     // mem= 99, run=398, turbo=398, PXbus=196
+OC(	d->m_cpu_frequencies->append("471000"); )   // mem=118, run=471, turbo=471, PXbus=236 OC'd mem/core/bus
+
 }
 
 bool Ramses::filter(int /*unicode*/, int keycode, int modifiers, bool isPress, bool autoRepeat)
 {
         Q_UNUSED( keycode );
         Q_UNUSED( modifiers );
         Q_UNUSED( isPress );
         Q_UNUSED( autoRepeat );
 	return false;
 }
 
 void Ramses::timerEvent(QTimerEvent *)
 {
 	killTimer(m_power_timer);
 	m_power_timer = 0;
 	QWSServer::sendKeyEvent(-1, HardKey_Backlight, 0, true, false);
 	QWSServer::sendKeyEvent(-1, HardKey_Backlight, 0, false, false);
 }
 
 
 bool Ramses::setSoftSuspend(bool soft)
 {
 	qDebug("Ramses::setSoftSuspend(%d)", soft);
 #if 0
 	bool res = false;
 	int fd;
 
 	if (((fd = ::open("/dev/apm_bios", O_RDWR)) >= 0) ||
         ((fd = ::open("/dev/misc/apm_bios",O_RDWR)) >= 0)) {
 
 		int sources = ::ioctl(fd, APM_IOCGEVTSRC, 0); // get current event sources
 
 		if (sources >= 0) {
 			if (soft)
 				sources &= ~APM_EVT_POWER_BUTTON;
 			else
 				sources |= APM_EVT_POWER_BUTTON;
 
 			if (::ioctl(fd, APM_IOCSEVTSRC, sources) >= 0) // set new event sources
 				res = true;
 			else
 				perror("APM_IOCGEVTSRC");
 		}
 		else
 			perror("APM_IOCGEVTSRC");
 
 		::close(fd);
 	}
 	else
 		perror("/dev/apm_bios or /dev/misc/apm_bios");
 
     return res;
 #else
     return true;
 #endif
 }
 
 bool Ramses::suspend ( )
 {
 	qDebug("Ramses::suspend");
 	return false;
 }
 
 /**
  * This sets the display on or off
  */
 bool Ramses::setDisplayStatus(bool on)
 {
 	qDebug("Ramses::setDisplayStatus(%d)", on);
 #if 0
 	bool res = false;
 	int fd;
 
 	if ((fd = ::open ("/dev/fb/0", O_RDWR)) >= 0) {
 		res = (::ioctl(fd, FBIOBLANK, on ? VESA_NO_BLANKING : VESA_POWERDOWN) == 0);
 		::close(fd);
 	}
 	return res;
 #else
 	return true;
 #endif
 }
 
 
 /*
  * We get something between 0..255 into us
 */
 bool Ramses::setDisplayBrightness(int bright)
 {
 	qDebug("Ramses::setDisplayBrightness(%d)", bright);
 	bool res = false;
 	int fd;
 
 	// pwm1 brighness: 20 steps 500..0 (dunkel->hell)
 
 	if (bright > 255 )
 		bright = 255;
 	if (bright < 0)
 		bright = 0;
 
 	// Turn backlight completely off
 	if ((fd = ::open("/proc/sys/board/lcd_backlight", O_WRONLY)) >= 0) {
 		char writeCommand[10];
 		const int count = sprintf(writeCommand, "%d\n", bright ? 1 : 0);
 		res = (::write(fd, writeCommand, count) != -1);
 		::close(fd);
 	}
 
 	// scale backlight brightness to hardware
 	bright = 500-(bright * 500 / 255);
 	if ((fd = ::open("/proc/sys/board/pwm1", O_WRONLY)) >= 0) {
 		qDebug(" %d -> pwm1", bright);
 		char writeCommand[100];
 		const int count = sprintf(writeCommand, "%d\n", bright);
 		res = (::write(fd, writeCommand, count) != -1);
 		::close(fd);
 	}
 	return res;
 }
 
 
 int Ramses::displayBrightnessResolution() const
 {
 	return 32;
 }
 
 bool Ramses::setDisplayContrast(int contr)
 {
 	qDebug("Ramses::setDisplayContrast(%d)", contr);
 	bool res = false;
 	int fd;
 
 	// pwm0 contrast: 20 steps 79..90 (dunkel->hell)
 
 	if (contr > 255 )
 		contr = 255;
 	if (contr < 0)
 		contr = 0;
 	contr = 90 - (contr * 20 / 255);
 
 	if ((fd = ::open("/proc/sys/board/pwm0", O_WRONLY)) >= 0) {
 		qDebug(" %d -> pwm0", contr);
 		char writeCommand[100];
 		const int count = sprintf(writeCommand, "%d\n", contr);
 		res = (::write(fd, writeCommand, count) != -1);
 		res = true;
 		::close(fd);
-	} else {
-		qWarning("no write");
 	}
 	return res;
 }
 
 
 int Ramses::displayContrastResolution() const
 {
 	return 20;
 }
diff --git a/libopie/odevice.h b/libopie/odevice.h
index 7f6f856..18ff5f1 100644
--- a/libopie/odevice.h
+++ b/libopie/odevice.h
@@ -107,143 +107,143 @@ enum OLed {
 	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,
 };
 
 enum ODirection {
 	CW   = 0,
 	CCW  = 1,
 	Flip = 2,
 };
 
 /**
  * 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 specefic 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 ( );
 	virtual void initButtons ( );
 
 	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;
 
 	Transformation rotation ( ) const;
 	ODirection direction ( ) const;
 
 // system
 
 	virtual bool setSoftSuspend ( bool on );
 	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;
 
 // input / output
         //FIXME playAlarmSound and al might be better -zecke
 	virtual void alarmSound ( );
 	virtual void keySound ( );
 	virtual void touchSound ( );
 
 	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;
 
 	QStrList &cpuFrequencies() const;
 	bool setCpuFrequency(uint index);
-	uint cpuFrequency() const;
+	int cpuFrequency() const;
 
 	/**
 	 * 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.
 	 */
 	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 & );
 
 protected:
 	void reloadButtonMapping ( );
 };
 
 }
 
 #endif