Bonjour à toutes et tous.
Pour répondre à ceux qui ont des problèmes avec la création du module, voici le fichier eee.c et son makefile associé. Ceux-ci fonctionnent parfaitement pour mon Eee PC 701 tournant sous Ubuntu 10.04 LTS (Lucid Lynx), noyau 2.6.32-38-generic.
eee.c modifié comme mentionné plus haut dans ce post pour la compatibilité avec les noyaux récents:
/*
* eee.c - Asus eeePC extras V0.1
*
* Copyright (C) 2007 Andrew Tipton
* Copyright (C) 2011 Jerome JAQUIN
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* Ths program is distributed in the hope that it will be useful,
* but WITOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTAILITY 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 program; if not, write to the Free Software
* Foundation, Inc., 59 Template Place, Suite 330, Boston, MA 02111-1307 USA
*
* ---------
*
* WARNING: This is an extremely *experimental* module! This code has been
* developed through trial-and-error, which means I don't really understand
* 100% what's going on here... That means there's a chance that there could
* be unintended side-effects which might cause data loss or even physical
* damage!
*
* Again, this code comes WITHOUT ANY WARRANTY whatsoever.
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
#include <asm/uaccess.h>
#include <asm/io.h> // For inb() and outb()
#include <linux/i2c.h>
#include <linux/mutex.h>
/* Module info */
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Andrew Tipton");
MODULE_DESCRIPTION("Support for eeePC-specific functionality.");
#define EEE_VERSION "0.2"
/* PLL access functions.
*
* Note that this isn't really the "proper" way to use the I2C API... :)
* I2C_SMBUS_BLOCK_MAX is 32, the maximum size of a block read/write.
*/
static int eee_pll_init(void);
static void eee_pll_read(void);
static void eee_pll_write(void);
static void eee_pll_cleanup(void);
static struct i2c_client eee_pll_smbus_client = {
.adapter = NULL,
.addr = 0x69,
.flags = 0,
};
static char eee_pll_data[I2C_SMBUS_BLOCK_MAX];
static int eee_pll_datalen = 0;
static int eee_pll_init(void) {
int i = 0;
int found = 0;
struct i2c_adapter * adapt;
while ( (adapt = i2c_get_adapter(i)) != NULL) {
printk("Found adapter %s\n", adapt->name);
if (strstr(adapt->name, "I801")) {
found = 1;
break;
}
i++;
}
if ( found )
eee_pll_smbus_client.adapter = adapt;
else {
printk("No i801 adapter found. is i2c_i801 inserted ?\n");
return -1;
}
// Fill the eee_pll_data buffer.
eee_pll_read();
return 0;
}
// Takes approx 150ms to execute.
static void eee_pll_read(void) {
memset(eee_pll_data, 0, I2C_SMBUS_BLOCK_MAX);
eee_pll_datalen = i2c_smbus_read_block_data(&eee_pll_smbus_client, 0, eee_pll_data);
}
// Takes approx 150ms to execute ???
static void eee_pll_write(void) {
i2c_smbus_write_block_data(&eee_pll_smbus_client, 0, eee_pll_datalen, eee_pll_data);
}
static void eee_pll_cleanup(void) {
i2c_put_adapter(eee_pll_smbus_client.adapter);
}
/* Embedded controller access functions.
*
* The ENE KB3310 embedded controller has a feature known as "Index IO"
* which allows the entire 64KB address space of the controller to be
* accessed via a set of ISA I/O ports at 0x380-0x384. This allows us
* direct access to all of the controller's ROM, RAM, SFRs, and peripheral
* registers; this access bypasses the EC firmware entirely.
*
* This is much faster than using ec_transaction(), and it also allows us to
* do things which are not possible through the EC's official interface.
*
* An Indexed IO write to an EC register takes approx. 90us, while an EC
* transaction takes approx. 2500ms.
*/
#define EC_IDX_ADDRH 0x381
#define EC_IDX_ADDRL 0x382
#define EC_IDX_DATA 0x383
#define HIGH_BYTE(x) ((x & 0xff00) >> 8)
#define LOW_BYTE(x) (x & 0x00ff)
static DEFINE_MUTEX(eee_ec_mutex);
static unsigned char eee_ec_read(unsigned short addr) {
unsigned char data;
mutex_lock(&eee_ec_mutex);
outb(HIGH_BYTE(addr), EC_IDX_ADDRH);
outb(LOW_BYTE(addr), EC_IDX_ADDRL);
data = inb(EC_IDX_DATA);
mutex_unlock(&eee_ec_mutex);
return data;
}
static void eee_ec_write(unsigned short addr, unsigned char data) {
mutex_lock(&eee_ec_mutex);
outb(HIGH_BYTE(addr), EC_IDX_ADDRH);
outb(LOW_BYTE(addr), EC_IDX_ADDRL);
outb(data, EC_IDX_DATA);
mutex_unlock(&eee_ec_mutex);
}
static void eee_ec_gpio_set(int pin, int value) {
unsigned short port;
unsigned char mask;
port = 0xFC20 + ((pin >> 3) & 0x1f);
mask = 1 << (pin & 0x07);
if (value) {
eee_ec_write(port, eee_ec_read(port) | mask);
} else {
eee_ec_write(port, eee_ec_read(port) & ~mask);
}
}
static int eee_ec_gpio_get(int pin) {
unsigned short port;
unsigned char mask;
unsigned char status;
port = 0xfc20 + ((pin >> 3) & 0x1f);
mask = 1 << (pin & 0x07);
status = eee_ec_read(port) & mask;
return (status) ? 1 : 0;
}
/*** Fan and temperature functions ***/
#define EC_ST00 0xF451 // Temperature of CPU (C)
#define EC_SC02 0xF463 // Fan PWM duty cycle (%)
#define EC_SC05 0xF466 // High byte of fan speed (RPM)
#define EC_SC06 0xF467 // Low byte of fan speed (RPM)
#define EC_SFB3 0xF4D3 // Flag byte containing SF25 (FANctrl)
static unsigned int eee_get_temperature(void) {
return eee_ec_read(EC_ST00);
}
static unsigned int eee_fan_get_rpm(void) {
return (eee_ec_read(EC_SC05) << 8) | eee_ec_read(EC_SC06);
}
// 1 if fan is in manual mode, 0 if controlled by the EC
static int eee_fan_get_manual(void) {
return (eee_ec_read(EC_SFB3) & 0x02) ? 1 : 0;
}
static void eee_fan_set_manual(int manual) {
if (manual) {
// SF25=1: Prevent the EC from controlling the fan.
eee_ec_write(EC_SFB3, eee_ec_read(EC_SFB3) | 0x02);
} else {
// SF25=0: Allow the EC to control the fan.
eee_ec_write(EC_SFB3, eee_ec_read(EC_SFB3) & ~0x02);
}
}
static void eee_fan_set_speed(unsigned int speed) {
eee_ec_write(EC_SC02, (speed > 100) ? 100 : speed);
}
static unsigned int eee_fan_get_speed(void) {
return eee_ec_read(EC_SC02);
}
/*** Voltage functions ***/
#define EC_VOLTAGE_PIN 0x66
enum eee_voltage { Low=0, High=1 };
static enum eee_voltage eee_get_voltage(void) {
return eee_ec_gpio_get(EC_VOLTAGE_PIN);
}
static void eee_set_voltage(enum eee_voltage voltage) {
eee_ec_gpio_set(EC_VOLTAGE_PIN, voltage);
}
/*** FSB functions ***/
static void eee_get_freq(int *n, int *m) {
*m = eee_pll_data[11] & 0x3F;
*n = eee_pll_data[12];
}
static void eee_set_freq(int n, int m) {
int current_n = 0, current_m = 0;
eee_get_freq(¤t_n, ¤t_m);
if (current_n != n || current_m != m) {
eee_pll_data[11] = m & 0x3F;
eee_pll_data[12] = n & 0xFF;
eee_pll_write();
}
}
/*** /proc file functions ***/
static struct proc_dir_entry *eee_proc_rootdir;
#define EEE_PROC_READFUNC(NAME) \
void eee_proc_readfunc_##NAME (char *buf, int buflen, int *bufpos)
#define EEE_PROC_WRITEFUNC(NAME) \
void eee_proc_writefunc_##NAME (const char *buf, int buflen, int *bufpos)
#define EEE_PROC_PRINTF(FMT, ARGS...) \
*bufpos += snprintf(buf + *bufpos, buflen - *bufpos, FMT, ##ARGS)
#define EEE_PROC_SCANF(COUNT, FMT, ARGS...) \
do { \
int len = 0; \
int cnt = sscanf(buf + *bufpos, FMT "%n", ##ARGS, &len); \
if (cnt < COUNT) { \
printk(KERN_DEBUG "eee: scanf(\"%s\") wanted %d args, but got %d.\n", FMT, COUNT, cnt); \
return; \
} \
*bufpos += len; \
} while (0)
#define EEE_PROC_MEMCPY(SRC, SRCLEN) \
do { \
int len = SRCLEN; \
if (len > (buflen - *bufpos)) \
len = buflen - *bufpos; \
memcpy(buf + *bufpos, SRC, (SRCLEN > (buflen - *bufpos)) ? (buflen - *bufpos) : SRCLEN); \
*bufpos += len; \
} while (0)
#define EEE_PROC_FILES_BEGIN \
static struct eee_proc_file eee_proc_files[] = {
#define EEE_PROC_RW(NAME, MODE) \
{ #NAME, MODE, &eee_proc_readfunc_##NAME, &eee_proc_writefunc_##NAME }
#define EEE_PROC_RO(NAME, MODE) \
{ #NAME, MODE, &eee_proc_readfunc_##NAME, NULL }
#define EEE_PROC_FILES_END \
{ NULL, 0, NULL, NULL } };
struct eee_proc_file {
char *name;
int mode;
void (*readfunc)(char *buf, int buflen, int *bufpos);
void (*writefunc)(const char *buf, int buflen, int *bufpos);
};
EEE_PROC_READFUNC(fsb) {
int n = 0;
int m = 0;
int voltage = 0;
eee_get_freq(&n, &m);
voltage = (int)eee_get_voltage();
EEE_PROC_PRINTF("%d %d %d\n", n, m, voltage);
}
EEE_PROC_WRITEFUNC(fsb) {
int n = 70; // sensible defaults
int m = 24;
int voltage = 0;
EEE_PROC_SCANF(3, "%i %i %i", &n, &m, &voltage);
eee_set_freq(n, m);
eee_set_voltage(voltage);
}
EEE_PROC_READFUNC(pll) {
eee_pll_read();
EEE_PROC_MEMCPY(eee_pll_data, eee_pll_datalen);
}
EEE_PROC_READFUNC(fan_speed) {
int speed = eee_fan_get_speed();
EEE_PROC_PRINTF("%d\n", speed);
}
EEE_PROC_WRITEFUNC(fan_speed) {
unsigned int speed = 0;
EEE_PROC_SCANF(1, "%u", &speed);
eee_fan_set_speed(speed);
}
EEE_PROC_READFUNC(fan_rpm) {
int rpm = eee_fan_get_rpm();
EEE_PROC_PRINTF("%d\n", rpm);
}
EEE_PROC_READFUNC(fan_manual) {
EEE_PROC_PRINTF("%d\n", eee_fan_get_manual());
}
EEE_PROC_WRITEFUNC(fan_manual) {
int manual = 0;
EEE_PROC_SCANF(1, "%i", &manual);
eee_fan_set_manual(manual);
}
#if 0
EEE_PROC_READFUNC(fan_mode) {
enum eee_fan_mode mode = eee_fan_get_mode();
switch (mode) {
case Manual: EEE_PROC_PRINTF("manual\n");
break;
case Automatic: EEE_PROC_PRINTF("auto\n");
break;
case Embedded: EEE_PROC_PRINTF("embedded\n");
break;
}
}
EEE_PROC_WRITEFUNC(fan_mode) {
enum eee_fan_mode mode = Automatic;
char inputstr[16];
EEE_PROC_SCANF(1, "%15s", inputstr);
if (strcmp(inputstr, "manual") == 0) {
mode = Manual;
} else if (strcmp(inputstr, "auto") == 0) {
mode = Automatic;
} else if (strcmp(inputstr, "embedded") == 0) {
mode = Embedded;
}
eee_fan_set_mode(mode);
}
#endif
EEE_PROC_READFUNC(temperature) {
unsigned int t = eee_get_temperature();
EEE_PROC_PRINTF("%d\n", t);
}
EEE_PROC_FILES_BEGIN
EEE_PROC_RW(fsb, 0644),
EEE_PROC_RO(pll, 0400),
EEE_PROC_RW(fan_speed, 0644),
EEE_PROC_RO(fan_rpm, 0444),
EEE_PROC_RW(fan_manual, 0644),
EEE_PROC_RO(temperature, 0444),
EEE_PROC_FILES_END
int eee_proc_readfunc(char *buffer, char **buffer_location, off_t offset,
int buffer_length, int *eof, void *data)
{
struct eee_proc_file *procfile = (struct eee_proc_file *)data;
int bufpos = 0;
if (!procfile || !procfile->readfunc) {
return -EIO;
}
*eof = 1;
if (offset > 0) {
return 0;
}
(*procfile->readfunc)(buffer, buffer_length, &bufpos);
return bufpos;
}
int eee_proc_writefunc(struct file *file, const char *buffer,
unsigned long count, void *data)
{
char userdata[129];
int bufpos = 0;
struct eee_proc_file *procfile = (struct eee_proc_file *)data;
if (!procfile || !procfile->writefunc) {
return -EIO;
}
if (copy_from_user(userdata, buffer, (count > 128) ? 128 : count)) {
printk(KERN_DEBUG "eee: copy_from_user() failed\n");
return -EIO;
}
userdata[128] = 0; // So that sscanf() doesn't overflow...
(*procfile->writefunc)(userdata, count, &bufpos);
return count;
}
int eee_proc_init(void) {
int i;
/* Create the /proc/eee directory. */
eee_proc_rootdir = proc_mkdir("eee", NULL);
if (!eee_proc_rootdir) {
printk(KERN_ERR "eee: Unable to create /proc/eee\n");
return false;
}
/* Create the individual proc files. */
for (i=0; eee_proc_files[i].name; i++) {
struct proc_dir_entry *proc_file;
struct eee_proc_file *f = &eee_proc_files[i];
proc_file = create_proc_entry(f->name, f->mode, eee_proc_rootdir);
if (!proc_file) {
printk(KERN_ERR "eee: Unable to create /proc/eee/%s", f->name);
goto proc_init_cleanup;
}
proc_file->read_proc = &eee_proc_readfunc;
if (f->writefunc) {
proc_file->write_proc = &eee_proc_writefunc;
}
proc_file->data = f;
proc_file->mode = S_IFREG | f->mode;
proc_file->uid = 0;
proc_file->gid = 0;
}
return true;
/* We had an error, so cleanup all of the proc files... */
proc_init_cleanup:
for (; i >= 0; i--) {
remove_proc_entry(eee_proc_files[i].name, eee_proc_rootdir);
}
remove_proc_entry("eee", NULL);
return false;
}
void eee_proc_cleanup(void) {
int i;
for (i = 0; eee_proc_files[i].name; i++) {
remove_proc_entry(eee_proc_files[i].name, eee_proc_rootdir);
}
remove_proc_entry("eee", NULL);
}
/*** Module initialization ***/
int init_module(void) {
int ret;
ret = eee_pll_init();
if(ret) return ret;
eee_proc_init();
printk(KERN_NOTICE "Asus eeePC extras, version %s\n", EEE_VERSION);
return 0;
}
void cleanup_module(void) {
eee_pll_cleanup();
eee_proc_cleanup();
}
Makefile inchangé:
obj-m += eee.o
all:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
J'ajoute ensuite ma dernière révision du script proceee.sh, remanié selon mes besoins, d'après le script original de fiasko:
#/bin/sh
#PROCEEE V1.3 FEB 2012
#7corp
#by JAQUIN J.
clear
echo -e "\033[32;7;1m PROCEEE "
echo -e "\033[0;32m"
INIT=$(cut -c1-8 /proc/eee/fsb)
if [ "$INIT" = "70 24 0" ]
then CONF="def";VSET=0;CL=32
else CONF="man";VSET=1;CL=33
fi
FSB=$(cut -c1-3 /proc/eee/fsb)
FREQ=$(((900*$FSB)/100))
if [ $FREQ -gt 900 ]
then CPU="\033[33;5;1m"
else CPU="\033[32;1m"
fi
ROT=$(cut -c1-5 /proc/eee/fan_rpm)
TEMP=$(cut -c1-2 /proc/eee/temperature)
grep -q 0 /proc/eee/fan_manual
if [ $? -eq 0 ]
then CLV="\033[0;32;1m"
VENT="(auto.)"
else VENT="(manu.)";CLV="\033[0;33;5;1m"
fi
echo
echo "PROCESSEUR(MHz) FSB(MHz) V(set) CONF. VENTILATEUR(T/min) TEMPERATURE(°C)"
echo -e -n "$CPU $FREQ"
echo -e -n "\033[0;32;1m $FSB"
echo -e -n "\033[0;32;1m $VSET"
echo -e -n "\033[$CL;1m $CONF"
echo -e -n "\033[0;32;1m $ROT";echo -e -n "$CLV$VENT"
echo -e -n "\033[0;32;1m $TEMP"
echo
echo
echo
echo
echo -e "\033[1m 1-configuration par défaut"
echo
echo -e "\033[1m 2-configuration débridée"
echo
echo -e "\033[1m 3-configuration manuelle "
echo
echo -e "\033[1m 4-ventilateur "
echo
echo -e "\033[1m 5-benchmark"
echo
echo -e "\033[1m 6-rafraichir "
echo
echo -e "\033[1m 7-quitter "
echo
echo
read M
case $M in
1) MM=1;;
2) MM=2;;
3) MM=3;;
4) MM=4;;
5) MM=5;;
6) bash proceee.sh;;
7) clear;echo -e "\033[32;7;5;1m";echo -e "\033[0;32m";exit;exit;;
*) bash proceee.sh;;
esac
#CONFIGURATION PAR DEFAUT#
if [ $MM -eq 1 ]
then
FSB1=70
COND=0
VV=0
k=0
if [ $FSB1 -le $FSB ] #DIMINUER LA FREQUENCE DU BUS PAR PAS DE 1MHZ#
then FSB2=$FSB
while [ $FSB2 -gt $FSB1 ]
do
FSB2="$(($FSB2-1))"
sudo echo "$FSB2 24 1" >> /proc/eee/fsb
sleep 1
if [ $k -eq 0 ]
then FREQ0=$(((900*$FSB)/100))
clear;echo -e "\033[0;33;7;5;1m PROCEEE...ING ";echo;echo
echo -n -e "\033[0;32;1m$FREQ0 "
fi
echo -n -e "\033[0;32;1m="
k="$(($k+1))"
FREQ=$(((900*$FSB2)/100))
done
echo -n -e "\033[0;32;1m> $FREQ"
echo -n -e "\033[0;32;1m DEF.V(set)=0"
fi
if [ $FSB1 -ge $FSB ] #AUGMENTER LA FREQUENCE DU BUS PAR PAS DE 1MHZ#
then FSB2=$FSB
while [ $FSB2 -lt $FSB1 ]
do
FSB2="$(($FSB2+1))"
sudo echo "$FSB2 24 0" >> /proc/eee/fsb
sleep 1
if [ $k -eq 0 ]
then FREQ0=$(((900*$FSB)/100))
clear;echo -e "\033[0;33;7;5;1m PROCEEE....ING ";echo;echo
echo -n -e "\033[0;32;1m$FREQ0 "
fi
echo -n -e "\033[0;32;1m="
k="$(($k+1))"
FREQ=$(((900*$FSB2)/100))
done
echo -n -e "\033[0;32;1m> $FREQ"
echo -n -e "\033[0;32;1m DEF.V(set)=0"
fi
sudo echo "70 24 0" >> /proc/eee/fsb
sudo echo "0" >> /proc/eee/fan_manual
sleep 3
bash proceee.sh
fi
#CONFIGURATION DÉBRIDÉE#
if [ $MM -eq 2 ]
then
FSB1=100
k=0
if [ $FSB1 -le $FSB ] #DIMINUER LA FREQUENCE DU BUS PAR PAS DE 1MHZ#
then FSB2=$FSB
while [ $FSB2 -gt $FSB1 ]
do
FSB2="$(($FSB2-1))"
sudo echo "$FSB2 24 1" >> /proc/eee/fsb
sleep 1
if [ $k -eq 0 ]
then FREQ0=$(((900*$FSB)/100))
clear;echo -e "\033[0;33;7;5;1m PROCEEE...ING ";echo;echo
echo -n -e "\033[0;32;1m$FREQ0 "
fi
echo -n -e "\033[0;32;1m="
k="$(($k+1))"
FREQ=$(((900*$FSB2)/100))
done
echo -n -e "\033[0;32;1m> $FREQ"
echo -n -e "\033[0;32;1m V(set)=1"
fi
if [ $FSB1 -ge $FSB ] #AUGMENTER LA FREQUENCE DU BUS PAR PAS DE 1MHZ#
then FSB2=$FSB
while [ $FSB2 -lt $FSB1 ]
do
FSB2="$(($FSB2+1))"
sudo echo "$FSB2 24 1" >> /proc/eee/fsb
sleep 1
if [ $k -eq 0 ]
then FREQ0=$(((900*$FSB)/100))
clear;echo -e "\033[0;33;7;5;1m PROCEEE....ING ";echo;echo
echo -n -e "\033[0;32;1m$FREQ0 "
fi
echo -n -e "\033[0;32;1m="
k="$(($k+1))"
FREQ=$(((900*$FSB2)/100))
done
echo -n -e "\033[0;32;1m> $FREQ"
echo -n -e "\033[0;32;1m V(set)=1"
fi
sudo echo "100 24 1" >> /proc/eee/fsb
sudo echo "0" >> /proc/eee/fan_manual
sleep 3
bash proceee.sh
fi
#CONFIGURATION MANUELLE#
if [ $MM -eq 3 ]
then
clear
SEC=0
while [ $SEC -eq 0 ]
do
clear
echo -e "\033[32;5;7;1m PROCEEE "
echo -e "\033[0;32m";echo
echo -n -e "\033[0;32;1mVotre cpu est cadencé à: ";echo -e -n "\033[32;7;1m $FREQ MHz ";echo -e "\033[0;32m";echo
echo -n -e "\033[0;32;1mRéglage souhaité(360<R<990)? :";echo -e -n "\033[32;7;1m";read FREQ1
FSB1=$(echo "scale=0; ((($FREQ1*100)/900)*100)/100"|bc)
VV=1
if [ $FSB1 -le 110 ] #FSB MAX#
then SEC=1
if [ $FSB1 -ge 40 ] #FSB MIN#
then SEC=1
else SEC=0
fi
fi
done
k=0
if [ $FSB1 -le $FSB ]
then FSB2=$FSB
while [ $FSB2 -gt $FSB1 ]
do
FSB2="$(($FSB2-1))"
sudo echo "$FSB2 24 1" >> /proc/eee/fsb
sleep 1
if [ $k -eq 0 ]
then FREQ0=$(((900*$FSB)/100))
clear;echo -e "\033[0;33;7;5;1m PROCEEE...ING ";echo;echo
echo -n -e "\033[0;32;1m$FREQ0 "
fi
FREQ=$(((900*$FSB2)/100))
echo -n -e "\033[0;32;1m="
k="$(($k+1))"
done
echo -n -e "\033[0;32;1m> $FREQ"
FREQ=$(((900*$FSB2)/100))
echo
echo
echo -e -n "\033[0;32;1mSuccesfull!! :-) processeur cadencé à :";echo -e -n "\033[33;7;1;5m$FREQ MHz"
echo -e "\033[0;32m"
fi
if [ $FSB1 -ge $FSB ]
then FSB2=$FSB
while [ $FSB2 -lt $FSB1 ]
do
FSB2="$(($FSB2+1))"
sudo echo "$FSB2 24 1" >> /proc/eee/fsb
sleep 1
if [ $k -eq 0 ]
then FREQ0=$(((900*$FSB)/100))
clear;echo -e "\033[0;33;7;5;1m PROCEEE...ING ";echo;echo
echo -n -e "\033[0;32;1m$FREQ0 "
fi
FREQ=$(((900*$FSB2)/100))
echo -n -e "\033[0;32;1m="
k="$(($k+1))"
done
echo -n -e "\033[0;32;1m> $FREQ"
FREQ=$(((900*$FSB2)/100))
echo
echo
echo -e -n "\033[0;32;1mSuccesfull!! :-) processeur cadencé à :";echo -e -n "\033[33;7;1;5m$FREQ MHz"
echo -e "\033[0;32m"
fi
echo
echo
echo -n -e "\033[0;32;1mVoulez vous régler votre ventilateur:(o/n)?";echo -e -n "\033[32;7;1m";read REGV
case $REGV in
"o") MM=4;;
*) bash proceee.sh;;
esac
sleep 3
bash proceee.sh
fi
#VENTILATEUR#
if [ $MM -eq 4 ]
then ROT=$(cut -c1-5 /proc/eee/fan_rpm);TEMP=$(cut -c1-2 /proc/eee/temperature)
clear
echo -e "\033[32;7;1m FANEEE "
echo
echo -e -n "\033[0;32;1m$ROT(T/min) ";echo -e -n "$CLV$VENT";echo -e -n "\033[0;32;1m TEMP: $TEMP°C "
echo
echo
manu=1
grep -q 0 /proc/eee/fan_manual
if [ $? -eq 1 ]
then
echo
echo
echo -e -n "\033[0;32;1mMettre le ventilateur en auto(o/n)?:";echo -e -n "\033[32;7;1m";read AUTO
if [ "$AUTO" = "o" ]
then
sudo sh -c 'echo 0 > /proc/eee/fan_manual'
manu=0
fi
fi
SECV=0
if [ $manu -eq 1 ]
then
while [ $SECV -eq 0 ]
do
echo
echo
echo -e -n "\033[0;32;1mValeur indice (30<V<100)?:";echo -e -n "\033[32;7;1m";read MAN;echo
if [ $MAN -le 100 ]
then SECV=1
if [ $MAN -ge 30 ]
then SECV=1
else SECV=0
fi
fi
done
MAN0=$(cut -c1-3 /proc/eee/fan_speed)
if [ $MAN -le $MAN0 ]
then MAN1=$MAN0
while [ $MAN1 -gt $MAN ]
do
MAN1="$(($MAN1-1))"
sudo echo "1" >> /proc/eee/fan_manual
sudo echo "$MAN1" >> /proc/eee/fan_speed
done
fi
if [ $MAN -ge $MAN0 ]
if [ $MAN0 -eq 0 ]
then MAN0=30
fi
then MAN1=$MAN0
while [ $MAN1 -lt $MAN ]
do
MAN1="$(($MAN1+1))"
sudo echo "1" >> /proc/eee/fan_manual
sudo echo "$MAN1" >> /proc/eee/fan_speed
done
fi
fi
sleep 3
bash proceee.sh
fi
#BENCHMARK#
if [ $MM -eq 5 ]
then
clear
echo -e "\033[32;7;1m TESTEEE "
echo -e "\033[0;32m"
INIT=$(cut -c1-8 /proc/eee/fsb)
if [ "$INIT" = "70 24 0" ]
then CONF="def";VSET=0;CL=32
else CONF="man";VSET=1;CL=33
fi
FSB=$(cut -c1-3 /proc/eee/fsb)
FREQ=$(((900*$FSB)/100))
if [ $FREQ -gt 900 ]
then CPU="\033[33;1m"
else CPU="\033[32;1m"
fi
ROT=$(cut -c1-5 /proc/eee/fan_rpm)
TEMP=$(cut -c1-2 /proc/eee/temperature)
grep -q 0 /proc/eee/fan_manual
if [ $? -eq 0 ]
then CLV="\033[0;32;1m"
VENT="(auto.)"
else VENT="(manu.)";CLV="\033[0;33;1m"
fi
echo
echo "PROCESSEUR(MHz) FSB(MHz) V(set) CONF. VENTILATEUR(T/min) TEMPERATURE(°C)"
echo -e -n "$CPU $FREQ"
echo -e -n "\033[0;32;1m $FSB"
echo -e -n "\033[0;32;1m $VSET"
echo -e -n "\033[$CL;1m $CONF"
echo -e -n "\033[0;32;1m $ROT";echo -e -n "$CLV$VENT"
echo -e -n "\033[0;32;1m $TEMP"
echo
echo
echo -e "\033[0;32;1m --> Arrêtez les roues en appuyant sur la touche ÉCHAP pour revenir au menu "
echo;sleep 3
glxgears -info;sleep 3;bash proceee.sh
fi
A des fins de compatibilité, je vous conseille de lancer ce script avec bash et non sh. Je vous passe les étapes de bases citées dans ce post.
Je travaille sur une automatisation du processus overclock/underclock en fonction de l'usage de l'Eee PC: 630MHz si veille, hibernation, batterie ou écran rabattu; 900MHz sinon. Ce travail est basé sur les scripts de motard13500 et fredr et sur le chapitre "Hibernating/suspending overclocked PC" de la page suivante:
howto:overclockfsb.
Je mettrai le résultat en ligne une fois les tests terminés. D'ici là, faites bon usage de tout ceci.
