[deliverable/linux.git] / drivers / hwmon / hwmon.c

/*
 * hwmon.c - part of lm_sensors, Linux kernel modules for hardware monitoring
 *
 * This file defines the sysfs class "hwmon", for use by sensors drivers.
 *
 * Copyright (C) 2005 Mark M. Hoffman <mhoffman@lightlink.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; version 2 of the License.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/kdev_t.h>
#include <linux/idr.h>
#include <linux/hwmon.h>
#include <linux/gfp.h>
#include <linux/spinlock.h>
#include <linux/pci.h>

#define HWMON_ID_PREFIX "hwmon"
#define HWMON_ID_FORMAT HWMON_ID_PREFIX "%d"

static struct class *hwmon_class;

static DEFINE_IDA(hwmon_ida);

/**
 * hwmon_device_register - register w/ hwmon
 * @dev: the device to register
 *
 * hwmon_device_unregister() must be called when the device is no
 * longer needed.
 *
 * Returns the pointer to the new device.
 */
struct device *hwmon_device_register(struct device *dev)
{
	struct device *hwdev;
	int id;

	id = ida_simple_get(&hwmon_ida, 0, 0, GFP_KERNEL);
	if (id < 0)
		return ERR_PTR(id);

	hwdev = device_create(hwmon_class, dev, MKDEV(0, 0), NULL,
			      HWMON_ID_FORMAT, id);

	if (IS_ERR(hwdev))
		ida_simple_remove(&hwmon_ida, id);

	return hwdev;
}
EXPORT_SYMBOL_GPL(hwmon_device_register);

/**
 * hwmon_device_unregister - removes the previously registered class device
 *
 * @dev: the class device to destroy
 */
void hwmon_device_unregister(struct device *dev)
{
	int id;

	if (likely(sscanf(dev_name(dev), HWMON_ID_FORMAT, &id) == 1)) {
		device_unregister(dev);
		ida_simple_remove(&hwmon_ida, id);
	} else
		dev_dbg(dev->parent,
			"hwmon_device_unregister() failed: bad class ID!\n");
}
EXPORT_SYMBOL_GPL(hwmon_device_unregister);

static void __init hwmon_pci_quirks(void)
{
#if defined CONFIG_X86 && defined CONFIG_PCI
	struct pci_dev *sb;
	u16 base;
	u8 enable;

	/* Open access to 0x295-0x296 on MSI MS-7031 */
	sb = pci_get_device(PCI_VENDOR_ID_ATI, 0x436c, NULL);
	if (sb) {
		if (sb->subsystem_vendor == 0x1462 &&	/* MSI */
		    sb->subsystem_device == 0x0031) {	/* MS-7031 */
			pci_read_config_byte(sb, 0x48, &enable);
			pci_read_config_word(sb, 0x64, &base);

			if (base == 0 && !(enable & BIT(2))) {
				dev_info(&sb->dev,
					 "Opening wide generic port at 0x295\n");
				pci_write_config_word(sb, 0x64, 0x295);
				pci_write_config_byte(sb, 0x48,
						      enable | BIT(2));
			}
		}
		pci_dev_put(sb);
	}
#endif
}

static int __init hwmon_init(void)
{
	hwmon_pci_quirks();

	hwmon_class = class_create(THIS_MODULE, "hwmon");
	if (IS_ERR(hwmon_class)) {
		pr_err("couldn't create sysfs class\n");
		return PTR_ERR(hwmon_class);
	}
	return 0;
}

static void __exit hwmon_exit(void)
{
	class_destroy(hwmon_class);
}

subsys_initcall(hwmon_init);
module_exit(hwmon_exit);

MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>");
MODULE_DESCRIPTION("hardware monitoring sysfs/class support");
MODULE_LICENSE("GPL");
Commit	Line	Data
	1	/*
	2	* hwmon.c - part of lm_sensors, Linux kernel modules for hardware monitoring
	3	*
	4	* This file defines the sysfs class "hwmon", for use by sensors drivers.
	5	*
	6	* Copyright (C) 2005 Mark M. Hoffman <mhoffman@lightlink.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; version 2 of the License.
	11	*/
	12
	13	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	14
	15	#include <linux/module.h>
	16	#include <linux/device.h>
	17	#include <linux/err.h>
	18	#include <linux/kdev_t.h>
	19	#include <linux/idr.h>
	20	#include <linux/hwmon.h>
	21	#include <linux/gfp.h>
	22	#include <linux/spinlock.h>
	23	#include <linux/pci.h>
	24
	25	#define HWMON_ID_PREFIX "hwmon"
	26	#define HWMON_ID_FORMAT HWMON_ID_PREFIX "%d"
	27
	28	static struct class *hwmon_class;
	29
	30	static DEFINE_IDA(hwmon_ida);
	31
	32	/**
	33	* hwmon_device_register - register w/ hwmon
	34	* @dev: the device to register
	35	*
	36	* hwmon_device_unregister() must be called when the device is no
	37	* longer needed.
	38	*
	39	* Returns the pointer to the new device.
	40	*/
	41	struct device hwmon_device_register(struct device dev)
	42	{
	43	struct device *hwdev;
	44	int id;
	45
	46	id = ida_simple_get(&hwmon_ida, 0, 0, GFP_KERNEL);
	47	if (id < 0)
	48	return ERR_PTR(id);
	49
	50	hwdev = device_create(hwmon_class, dev, MKDEV(0, 0), NULL,
	51	HWMON_ID_FORMAT, id);
	52
	53	if (IS_ERR(hwdev))
	54	ida_simple_remove(&hwmon_ida, id);
	55
	56	return hwdev;
	57	}
	58	EXPORT_SYMBOL_GPL(hwmon_device_register);
	59
	60	/**
	61	* hwmon_device_unregister - removes the previously registered class device
	62	*
	63	* @dev: the class device to destroy
	64	*/
	65	void hwmon_device_unregister(struct device *dev)
	66	{
	67	int id;
	68
	69	if (likely(sscanf(dev_name(dev), HWMON_ID_FORMAT, &id) == 1)) {
	70	device_unregister(dev);
	71	ida_simple_remove(&hwmon_ida, id);
	72	} else
	73	dev_dbg(dev->parent,
	74	"hwmon_device_unregister() failed: bad class ID!\n");
	75	}
	76	EXPORT_SYMBOL_GPL(hwmon_device_unregister);
	77
	78	static void __init hwmon_pci_quirks(void)
	79	{
	80	#if defined CONFIG_X86 && defined CONFIG_PCI
	81	struct pci_dev *sb;
	82	u16 base;
	83	u8 enable;
	84
	85	/* Open access to 0x295-0x296 on MSI MS-7031 */
	86	sb = pci_get_device(PCI_VENDOR_ID_ATI, 0x436c, NULL);
	87	if (sb) {
	88	if (sb->subsystem_vendor == 0x1462 && /* MSI */
	89	sb->subsystem_device == 0x0031) { /* MS-7031 */
	90	pci_read_config_byte(sb, 0x48, &enable);
	91	pci_read_config_word(sb, 0x64, &base);
	92
	93	if (base == 0 && !(enable & BIT(2))) {
	94	dev_info(&sb->dev,
	95	"Opening wide generic port at 0x295\n");
	96	pci_write_config_word(sb, 0x64, 0x295);
	97	pci_write_config_byte(sb, 0x48,
	98	enable \| BIT(2));
	99	}
	100	}
	101	pci_dev_put(sb);
	102	}
	103	#endif
	104	}
	105
	106	static int __init hwmon_init(void)
	107	{
	108	hwmon_pci_quirks();
	109
	110	hwmon_class = class_create(THIS_MODULE, "hwmon");
	111	if (IS_ERR(hwmon_class)) {
	112	pr_err("couldn't create sysfs class\n");
	113	return PTR_ERR(hwmon_class);
	114	}
	115	return 0;
	116	}
	117
	118	static void __exit hwmon_exit(void)
	119	{
	120	class_destroy(hwmon_class);
	121	}
	122
	123	subsys_initcall(hwmon_init);
	124	module_exit(hwmon_exit);
	125
	126	MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>");
	127	MODULE_DESCRIPTION("hardware monitoring sysfs/class support");
	128	MODULE_LICENSE("GPL");
	129