diff --git a/CONTRIBUTORS b/CONTRIBUTORS index 3639f07a..f091b8eb 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -28,6 +28,7 @@ problems. Added w83782d, w83783s, w83627hf, and as99127f support to the w83781d driver. Added max1617, thmc10, gl523sm, and lm84 support to the adm1021 driver. Added lm81 support to the adm9240 driver. + Added DDC support to the i2c-voodoo3 bus driver. Author of the decode-xeon.pl xeon EEPROM decoder. * Geert Uytterhoeven Author of the i2c-hydra driver. diff --git a/doc/chips/ddcmon b/doc/chips/ddcmon new file mode 100644 index 00000000..7795647d --- /dev/null +++ b/doc/chips/ddcmon @@ -0,0 +1,112 @@ +Kernel driver `ddcmon.o' +======================== + +Status: Beta + +Supported chips: + * Any DDC Monitor EDID EEPROM chip at 0x50 + Prefix `ddcmon' + Addresses scanned: I2C 0x50 + Standards: available for purchase from VESA http://www.vesa.org + +Authors: Frodo Looijaard , Philip Edelbrock , + and Mark Studebaker + +Special assistance on DDC provided by Petr Vandrovec + +Module Parameters +----------------- + +* force: short array (min = 1, max = 48) + List of adapter,address pairs to boldly assume to be present +* force_ddcmon: short array (min = 1, max = 48) + List of adapter,address pairs which are unquestionably assumed to contain + a `ddcmon' chip +* ignore: short array (min = 1, max = 48) + List of adapter,address pairs not to scan +* ignore_range: short array (min = 1, max = 48) + List of adapter,start-addr,end-addr triples not to scan +* probe: short array (min = 1, max = 48) + List of adapter,address pairs to scan additionally +* probe_range: short array (min = 1, max = 48) + List of adapter,start-addr,end-addr triples to scan additionally + + +Description +----------- + +This is a simple module for reading the EEPROM on a DDC-compliant monitor. +DDC (Display Data Channel) is the I2C-based communication channel +to the monitor. The EEPROM contains a 128-byte data structure defined +by the EDID (Extended Display Identification Data) standard. + +Use: + +After inserting the module (and any other required smbus/i2c modules), you +should have a directory in /proc/sys/dev/sensors/ with a name such +as "ddcmon-i2c-3-50". Inside each of these is a series of files which +represent interesting data from the DDC monitor. + +/proc entries: + + ID: Encoded Monitor ID string. + For encoding, see 'sensors' + source ../../prog/sensors/chips.c. + + serial: 1 integer + serial number + + size: 2 integers + vertical monitor size (cm) + horizontal monitor size (cm) + + sync: 4 integers + minimum vertical sync frequency (Hz) + maximum vertical sync frequency (Hz) + minimum horizontal sync frequency (KHz) + maximum horizontal sync frequency (KHz) + + timings: supported timings (bitmask) + 0x000001 720x400@70Hz (VGA 640x400, IBM) + 0x000002 720x400@88Hz (XGA2) + 0x000004 640x480@60Hz (VGA) + 0x000008 640x480@67Hz (Mac II, Apple) + 0x000010 640x480@72Hz (VESA) + 0x000020 640x480@75Hz (VESA) + 0x000040 800x600@56Hz (VESA) + 0x000080 800x600@60Hz (VESA) + 0x000100 800x600@72Hz (VESA) + 0x000200 800x600@75Hz (VESA) + 0x000400 832x624@75Hz (Mac II) + 0x000800 1024x768@87Hz interlaced (8514A) + 0x001000 1024x768@60Hz (VESA) + 0x002000 1024x768@70Hz (VESA) + 0x004000 1024x768@75Hz (VESA) + 0x008000 1280x1024@75Hz (VESA) + 0x010000 - 0x800000 Manufacturer reserved + +Notes: + +- The eeprom.o module will also attach to a DDC monitor. Install the + ddcmon.o module before the eeprom.o module to prevent this. + Alternatively, give the eeprom.o module an ignore= parameter or + a checksum= parameter. The ddcmon.o module will not attach to non-DDC + eeproms because it checks for a DDC 'signature' at the beginning + of the DDC Monitor's eeprom. + +- This module requires a bus driver for your video chip to access the + DDC bus. Currently drivers exist for Voodoo3/Banshee chips and + Matrox chips only. See documentation for those drivers in ../busses. + +- There is a checksum over the 128 bytes in the eeprom but the driver + does not check it. + +- More information is available in the eeprom which could be made + available by enhancing the driver. + To see the entire eeprom, use the eeprom.o module instead of ddcmon.o. + +- This driver does not support the DDC/CI (DDC2Bi) bidirectional + communications channel to the monitor for controlling the monitor. + +- The driver caches the data from the monitor and only rereads it + from the eeprom if the cache is more than 5 minutes old. diff --git a/kernel/chips/Module.mk b/kernel/chips/Module.mk index 5973433a..f3d8dc58 100644 --- a/kernel/chips/Module.mk +++ b/kernel/chips/Module.mk @@ -25,7 +25,8 @@ KERNELCHIPSDIR := $(MODULE_DIR) # defined value verbatim into the command-list of rules... KERNELCHIPSTARGETS := $(MODULE_DIR)/bt869.o $(MODULE_DIR)/gl520sm.o \ $(MODULE_DIR)/matorb.o $(MODULE_DIR)/maxilife.o \ - $(MODULE_DIR)/thmc50.o + $(MODULE_DIR)/thmc50.o \ + $(MODULE_DIR)/ddcmon.o ifneq ($(shell if grep -q '^CONFIG_SENSORS_ADM1021=y' $(LINUX)/.config; then echo 1; fi),1) KERNELCHIPSTARGETS += $(MODULE_DIR)/adm1021.o endif diff --git a/kernel/chips/ddcmon.c b/kernel/chips/ddcmon.c new file mode 100644 index 00000000..cb8cbe59 --- /dev/null +++ b/kernel/chips/ddcmon.c @@ -0,0 +1,435 @@ +/* + ddcmon.c - Part of lm_sensors, Linux kernel modules for hardware + monitoring + Copyright (c) 1998, 1999, 2000 Frodo Looijaard , + Philip Edelbrock , + and Mark Studebaker + + 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. + + 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 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., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#include +#include +#include +#include +#include "sensors.h" +#include "i2c-isa.h" +#include "version.h" + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,1)) +#define init_MUTEX(s) do { *(s) = MUTEX; } while(0) +#endif + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,13) +#define THIS_MODULE NULL +#endif + +/* Addresses to scan */ +static unsigned short normal_i2c[] = { SENSORS_I2C_END }; +static unsigned short normal_i2c_range[] = { 0x50, SENSORS_I2C_END }; +static unsigned int normal_isa[] = { SENSORS_ISA_END }; +static unsigned int normal_isa_range[] = { SENSORS_ISA_END }; + +/* Insmod parameters */ +SENSORS_INSMOD_1(ddcmon); + +/* Many constants specified below */ + +/* DDCMON registers */ +#define DDCMON_REG_ID 0x08 +#define DDCMON_REG_SERIAL 0x0C +#define DDCMON_REG_HORSIZE 0x15 +#define DDCMON_REG_VERSIZE 0x16 +#define DDCMON_REG_TIMINGS 0x23 +#define DDCMON_REG_TIMBASE 0x36 +#define DDCMON_REG_TIMINCR 18 +#define DDCMON_REG_TIMNUM 4 +#define DDCMON_REG_TIMOFFSET 5 +#define DDCMON_REG_CHECKSUM 0x7f + +/* Size of DDCMON in bytes */ +#define DDCMON_SIZE 128 + +/* Each client has this additional data */ +struct ddcmon_data { + int sysctl_id; + + struct semaphore update_lock; + char valid; /* !=0 if following fields are valid */ + unsigned long last_updated; /* In jiffies */ + + u8 data[DDCMON_SIZE]; /* Register values */ + int memtype; +}; + +#ifdef MODULE +extern int init_module(void); +extern int cleanup_module(void); +#endif /* MODULE */ + +#ifdef MODULE +static +#else +extern +#endif +int __init sensors_ddcmon_init(void); +static int __init ddcmon_cleanup(void); + +static int ddcmon_attach_adapter(struct i2c_adapter *adapter); +static int ddcmon_detect(struct i2c_adapter *adapter, int address, + unsigned short flags, int kind); +static int ddcmon_detach_client(struct i2c_client *client); +static int ddcmon_command(struct i2c_client *client, unsigned int cmd, + void *arg); + +static void ddcmon_inc_use(struct i2c_client *client); +static void ddcmon_dec_use(struct i2c_client *client); + +static void ddcmon_idcall(struct i2c_client *client, int operation, + int ctl_name, int *nrels_mag, long *results); +static void ddcmon_size(struct i2c_client *client, int operation, + int ctl_name, int *nrels_mag, long *results); +static void ddcmon_sync(struct i2c_client *client, int operation, + int ctl_name, int *nrels_mag, long *results); +static void ddcmon_timings(struct i2c_client *client, int operation, + int ctl_name, int *nrels_mag, long *results); +static void ddcmon_serial(struct i2c_client *client, int operation, + int ctl_name, int *nrels_mag, long *results); +static void ddcmon_update_client(struct i2c_client *client); + + +/* This is the driver that will be inserted */ +static struct i2c_driver ddcmon_driver = { + /* name */ "DDCMON READER", + /* id */ I2C_DRIVERID_DDCMON, + /* flags */ I2C_DF_NOTIFY, + /* attach_adapter */ &ddcmon_attach_adapter, + /* detach_client */ &ddcmon_detach_client, + /* command */ &ddcmon_command, + /* inc_use */ &ddcmon_inc_use, + /* dec_use */ &ddcmon_dec_use +}; + +/* These files are created for each detected DDCMON. This is just a template; + though at first sight, you might think we could use a statically + allocated list, we need some way to get back to the parent - which + is done through one of the 'extra' fields which are initialized + when a new copy is allocated. */ +static ctl_table ddcmon_dir_table_template[] = { + {DDCMON_SYSCTL_ID, "ID", NULL, 0, 0444, NULL, &sensors_proc_real, + &sensors_sysctl_real, NULL, &ddcmon_idcall}, + {DDCMON_SYSCTL_SIZE, "size", NULL, 0, 0444, NULL, &sensors_proc_real, + &sensors_sysctl_real, NULL, &ddcmon_size}, + {DDCMON_SYSCTL_SYNC, "sync", NULL, 0, 0444, NULL, + &sensors_proc_real, &sensors_sysctl_real, NULL, &ddcmon_sync}, + {DDCMON_SYSCTL_TIMINGS, "timings", NULL, 0, 0444, NULL, + &sensors_proc_real, &sensors_sysctl_real, NULL, &ddcmon_timings}, + {DDCMON_SYSCTL_SERIAL, "serial", NULL, 0, 0444, NULL, + &sensors_proc_real, &sensors_sysctl_real, NULL, &ddcmon_serial}, + {0} +}; + +/* Used by init/cleanup */ +static int __initdata ddcmon_initialized = 0; + +static int ddcmon_id = 0; + +int ddcmon_attach_adapter(struct i2c_adapter *adapter) +{ + return sensors_detect(adapter, &addr_data, ddcmon_detect); +} + +/* This function is called by sensors_detect */ +int ddcmon_detect(struct i2c_adapter *adapter, int address, + unsigned short flags, int kind) +{ + int i, cs; + struct i2c_client *new_client; + struct ddcmon_data *data; + int err = 0; + const char *type_name, *client_name; + + if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) + goto ERROR0; + + /* OK. For now, we presume we have a valid client. We now create the + client structure, even though we cannot fill it completely yet. + But it allows us to access ddcmon_{read,write}_value. */ + if (!(new_client = kmalloc(sizeof(struct i2c_client) + + sizeof(struct ddcmon_data), + GFP_KERNEL))) { + err = -ENOMEM; + goto ERROR0; + } + + data = (struct ddcmon_data *) (new_client + 1); + new_client->addr = address; + new_client->data = data; + new_client->adapter = adapter; + new_client->driver = &ddcmon_driver; + new_client->flags = 0; + + /* Now, we do the remaining detection. */ + /* Verify the first 8 locations 0x00FFFFFFFFFFFF00 */ + for(i = 0; i < 8; i++) { + cs = i2c_smbus_read_byte_data(new_client, i); + if(i == 0 || i == 7) { + if(cs != 0) + goto ERROR1; + } else if(cs != 0xff) + goto ERROR1; + } + + type_name = "ddcmon"; + client_name = "DDC Monitor"; + + /* Fill in the remaining client fields and put it in the global list */ + strcpy(new_client->name, client_name); + + new_client->id = ddcmon_id++; + data->valid = 0; + init_MUTEX(&data->update_lock); + + /* Tell the I2C layer a new client has arrived */ + if ((err = i2c_attach_client(new_client))) + goto ERROR3; + + /* Register a new directory entry with module sensors */ + if ((i = sensors_register_entry(new_client, type_name, + ddcmon_dir_table_template, + THIS_MODULE)) < 0) { + err = i; + goto ERROR4; + } + data->sysctl_id = i; + + return 0; + + ERROR4: + i2c_detach_client(new_client); + ERROR3: + ERROR1: + kfree(new_client); + ERROR0: + return err; +} + +int ddcmon_detach_client(struct i2c_client *client) +{ + int err; + + sensors_deregister_entry(((struct ddcmon_data *) (client->data))-> + sysctl_id); + if ((err = i2c_detach_client(client))) { + printk + ("ddcmon.o: Client deregistration failed, client not detached.\n"); + return err; + } + kfree(client); + return 0; +} + +/* No commands defined yet */ +int ddcmon_command(struct i2c_client *client, unsigned int cmd, void *arg) +{ + return 0; +} + +void ddcmon_inc_use(struct i2c_client *client) +{ +#ifdef MODULE + MOD_INC_USE_COUNT; +#endif +} + +void ddcmon_dec_use(struct i2c_client *client) +{ +#ifdef MODULE + MOD_DEC_USE_COUNT; +#endif +} + +void ddcmon_update_client(struct i2c_client *client) +{ + struct ddcmon_data *data = client->data; + int i; + + down(&data->update_lock); + + if ((jiffies - data->last_updated > 300 * HZ) || + (jiffies < data->last_updated) || !data->valid) { + if (i2c_smbus_write_byte(client, 0)) { +#ifdef DEBUG + printk("ddcmon read start has failed!\n"); +#endif + } + for (i = 0; i < DDCMON_SIZE; i++) { + data->data[i] = (u8) i2c_smbus_read_byte(client); + } + + data->last_updated = jiffies; + data->valid = 1; + } + + up(&data->update_lock); +} + + +void ddcmon_idcall(struct i2c_client *client, int operation, + int ctl_name, int *nrels_mag, long *results) +{ + struct ddcmon_data *data = client->data; + + if (operation == SENSORS_PROC_REAL_INFO) + *nrels_mag = 0; + else if (operation == SENSORS_PROC_REAL_READ) { + ddcmon_update_client(client); + results[0] = data->data[DDCMON_REG_ID + 1] | + (data->data[DDCMON_REG_ID] << 8) | + (data->data[DDCMON_REG_ID + 3] << 16) | + (data->data[DDCMON_REG_ID + 2] << 24); + *nrels_mag = 1; + } +} + +void ddcmon_size(struct i2c_client *client, int operation, + int ctl_name, int *nrels_mag, long *results) +{ + struct ddcmon_data *data = client->data; + + if (operation == SENSORS_PROC_REAL_INFO) + *nrels_mag = 0; + else if (operation == SENSORS_PROC_REAL_READ) { + ddcmon_update_client(client); + results[0] = data->data[DDCMON_REG_VERSIZE]; + results[1] = data->data[DDCMON_REG_HORSIZE]; + *nrels_mag = 2; + } +} + +void ddcmon_sync(struct i2c_client *client, int operation, + int ctl_name, int *nrels_mag, long *results) +{ + int i, j; + struct ddcmon_data *data = client->data; + + if (operation == SENSORS_PROC_REAL_INFO) + *nrels_mag = 0; + else if (operation == SENSORS_PROC_REAL_READ) { + ddcmon_update_client(client); + *nrels_mag = 4; + /* look for sync entry */ + for(i = DDCMON_REG_TIMBASE; + i < DDCMON_REG_TIMBASE + + (DDCMON_REG_TIMNUM * DDCMON_REG_TIMINCR); + i += DDCMON_REG_TIMINCR) { + if(data->data[i] == 0) { + for(j = 0; j < 4; j++) + results[j] = data->data[i + j + + DDCMON_REG_TIMOFFSET]; + return; + } + } + for(j = 0; j < 4; j++) + results[j] = 0; + } +} + +void ddcmon_timings(struct i2c_client *client, int operation, + int ctl_name, int *nrels_mag, long *results) +{ + struct ddcmon_data *data = client->data; + + if (operation == SENSORS_PROC_REAL_INFO) + *nrels_mag = 0; + else if (operation == SENSORS_PROC_REAL_READ) { + ddcmon_update_client(client); + results[0] = data->data[DDCMON_REG_TIMINGS] | + (data->data[DDCMON_REG_TIMINGS + 1] << 8) | + (data->data[DDCMON_REG_TIMINGS + 2] << 16); + *nrels_mag = 1; + } +} + +void ddcmon_serial(struct i2c_client *client, int operation, + int ctl_name, int *nrels_mag, long *results) +{ + struct ddcmon_data *data = client->data; + + if (operation == SENSORS_PROC_REAL_INFO) + *nrels_mag = 0; + else if (operation == SENSORS_PROC_REAL_READ) { + ddcmon_update_client(client); + results[0] = data->data[DDCMON_REG_SERIAL] | + (data->data[DDCMON_REG_SERIAL + 1] << 8) | + (data->data[DDCMON_REG_SERIAL + 2] << 16) | + (data->data[DDCMON_REG_SERIAL + 3] << 24); + *nrels_mag = 1; + } +} + +int __init sensors_ddcmon_init(void) +{ + int res; + + printk("ddcmon.o version %s (%s)\n", LM_VERSION, LM_DATE); + ddcmon_initialized = 0; + if ((res = i2c_add_driver(&ddcmon_driver))) { + printk + ("ddcmon.o: Driver registration failed, module not inserted.\n"); + ddcmon_cleanup(); + return res; + } + ddcmon_initialized++; + return 0; +} + +int __init ddcmon_cleanup(void) +{ + int res; + + if (ddcmon_initialized >= 1) { + if ((res = i2c_del_driver(&ddcmon_driver))) { + printk + ("ddcmon.o: Driver deregistration failed, module not removed.\n"); + return res; + } + } else + ddcmon_initialized--; + return 0; +} + +EXPORT_NO_SYMBOLS; + +#ifdef MODULE + +MODULE_AUTHOR("Frodo Looijaard , " + "Philip Edelbrock , " + "and Mark Studebaker "); +MODULE_DESCRIPTION("DDCMON driver"); + +int init_module(void) +{ + return sensors_ddcmon_init(); +} + +int cleanup_module(void) +{ + return ddcmon_cleanup(); +} + +#endif /* MODULE */