(mds) add simple ddc monitor module 'ddcmon'.

git-svn-id: http://lm-sensors.org/svn/lm-sensors/trunk@713 7894878c-1315-0410-8ee3-d5d059ff63e0
2026-10-24 12:04:33 +00:00 · 2000-01-30 01:05:47 +00:00
1 parent d6c9ee0be1
commit 27f0db257c
@@ -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 <geert@linux-m68k.org>
  Author of the i2c-hydra driver.
@@ -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 <frodol@dds.nl>, Philip Edelbrock <phil@netroedge.com>,
+        and Mark Studebaker <mdsxyz123@yahoo.com>
+
+Special assistance on DDC provided by Petr Vandrovec <vandrove@vc.cvut.cz>
+
+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.
@@ -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
@@ -0,0 +1,435 @@
+/*
+    ddcmon.c - Part of lm_sensors, Linux kernel modules for hardware
+               monitoring
+    Copyright (c) 1998, 1999, 2000  Frodo Looijaard <frodol@dds.nl>,
+    Philip Edelbrock <phil@netroedge.com>,
+    and Mark Studebaker <mdsxyz123@yahoo.com>
+
+    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 <linux/module.h>
+#include <linux/version.h>
+#include <linux/malloc.h>
+#include <linux/i2c.h>
+#include "sensors.h"
+#include "i2c-isa.h"
+#include "version.h"
+
+#include <linux/init.h>
+
+#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 <frodol@dds.nl>, "
+	      "Philip Edelbrock <phil@netroedge .com>, "
+	      "and Mark Studebaker <mdsxyz123@yahoo.com>");
+MODULE_DESCRIPTION("DDCMON driver");
+
+int init_module(void)
+{
+	return sensors_ddcmon_init();
+}
+
+int cleanup_module(void)
+{
+	return ddcmon_cleanup();
+}
+
+#endif				/* MODULE */