aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/base/power/main.c9
-rw-r--r--drivers/cpuidle/governors/menu.c12
-rw-r--r--drivers/gpio/Kconfig9
-rw-r--r--drivers/gpio/Makefile1
-rw-r--r--drivers/gpio/adp5588-gpio.c266
-rw-r--r--drivers/gpio/gpiolib.c2
-rw-r--r--drivers/gpu/drm/i915/i915_drv.c2
-rw-r--r--drivers/hwmon/Kconfig10
-rw-r--r--drivers/hwmon/Makefile1
-rw-r--r--drivers/hwmon/amc6821.c1116
-rw-r--r--drivers/mmc/card/block.c8
-rw-r--r--drivers/mmc/card/queue.c18
-rw-r--r--drivers/mmc/core/mmc.c2
-rw-r--r--drivers/rtc/rtc-cmos.c9
-rw-r--r--drivers/video/backlight/omap1_bl.c2
15 files changed, 1440 insertions, 27 deletions
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 48adf80926a0..a5142bddef41 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -446,8 +446,8 @@ EXPORT_SYMBOL_GPL(dpm_resume_noirq);
446 446
447/** 447/**
448 * legacy_resume - Execute a legacy (bus or class) resume callback for device. 448 * legacy_resume - Execute a legacy (bus or class) resume callback for device.
449 * dev: Device to resume. 449 * @dev: Device to resume.
450 * cb: Resume callback to execute. 450 * @cb: Resume callback to execute.
451 */ 451 */
452static int legacy_resume(struct device *dev, int (*cb)(struct device *dev)) 452static int legacy_resume(struct device *dev, int (*cb)(struct device *dev))
453{ 453{
@@ -711,8 +711,9 @@ EXPORT_SYMBOL_GPL(dpm_suspend_noirq);
711 711
712/** 712/**
713 * legacy_suspend - Execute a legacy (bus or class) suspend callback for device. 713 * legacy_suspend - Execute a legacy (bus or class) suspend callback for device.
714 * dev: Device to suspend. 714 * @dev: Device to suspend.
715 * cb: Suspend callback to execute. 715 * @state: PM transition of the system being carried out.
716 * @cb: Suspend callback to execute.
716 */ 717 */
717static int legacy_suspend(struct device *dev, pm_message_t state, 718static int legacy_suspend(struct device *dev, pm_message_t state,
718 int (*cb)(struct device *dev, pm_message_t state)) 719 int (*cb)(struct device *dev, pm_message_t state))
diff --git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c
index 68104434ebb5..73655aeb3a60 100644
--- a/drivers/cpuidle/governors/menu.c
+++ b/drivers/cpuidle/governors/menu.c
@@ -18,6 +18,7 @@
18#include <linux/hrtimer.h> 18#include <linux/hrtimer.h>
19#include <linux/tick.h> 19#include <linux/tick.h>
20#include <linux/sched.h> 20#include <linux/sched.h>
21#include <linux/math64.h>
21 22
22#define BUCKETS 12 23#define BUCKETS 12
23#define RESOLUTION 1024 24#define RESOLUTION 1024
@@ -169,6 +170,12 @@ static DEFINE_PER_CPU(struct menu_device, menu_devices);
169 170
170static void menu_update(struct cpuidle_device *dev); 171static void menu_update(struct cpuidle_device *dev);
171 172
173/* This implements DIV_ROUND_CLOSEST but avoids 64 bit division */
174static u64 div_round64(u64 dividend, u32 divisor)
175{
176 return div_u64(dividend + (divisor / 2), divisor);
177}
178
172/** 179/**
173 * menu_select - selects the next idle state to enter 180 * menu_select - selects the next idle state to enter
174 * @dev: the CPU 181 * @dev: the CPU
@@ -209,9 +216,8 @@ static int menu_select(struct cpuidle_device *dev)
209 data->correction_factor[data->bucket] = RESOLUTION * DECAY; 216 data->correction_factor[data->bucket] = RESOLUTION * DECAY;
210 217
211 /* Make sure to round up for half microseconds */ 218 /* Make sure to round up for half microseconds */
212 data->predicted_us = DIV_ROUND_CLOSEST( 219 data->predicted_us = div_round64(data->expected_us * data->correction_factor[data->bucket],
213 data->expected_us * data->correction_factor[data->bucket], 220 RESOLUTION * DECAY);
214 RESOLUTION * DECAY);
215 221
216 /* 222 /*
217 * We want to default to C1 (hlt), not to busy polling 223 * We want to default to C1 (hlt), not to busy polling
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index a019b49ecc9b..1f1d88ae68d6 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -172,6 +172,15 @@ config GPIO_ADP5520
172 To compile this driver as a module, choose M here: the module will 172 To compile this driver as a module, choose M here: the module will
173 be called adp5520-gpio. 173 be called adp5520-gpio.
174 174
175config GPIO_ADP5588
176 tristate "ADP5588 I2C GPIO expander"
177 depends on I2C
178 help
179 This option enables support for 18 GPIOs found
180 on Analog Devices ADP5588 GPIO Expanders.
181 To compile this driver as a module, choose M here: the module will be
182 called adp5588-gpio.
183
175comment "PCI GPIO expanders:" 184comment "PCI GPIO expanders:"
176 185
177config GPIO_CS5535 186config GPIO_CS5535
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 52fe4cf734c7..48687238edb1 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -5,6 +5,7 @@ ccflags-$(CONFIG_DEBUG_GPIO) += -DDEBUG
5obj-$(CONFIG_GPIOLIB) += gpiolib.o 5obj-$(CONFIG_GPIOLIB) += gpiolib.o
6 6
7obj-$(CONFIG_GPIO_ADP5520) += adp5520-gpio.o 7obj-$(CONFIG_GPIO_ADP5520) += adp5520-gpio.o
8obj-$(CONFIG_GPIO_ADP5588) += adp5588-gpio.o
8obj-$(CONFIG_GPIO_LANGWELL) += langwell_gpio.o 9obj-$(CONFIG_GPIO_LANGWELL) += langwell_gpio.o
9obj-$(CONFIG_GPIO_MAX7301) += max7301.o 10obj-$(CONFIG_GPIO_MAX7301) += max7301.o
10obj-$(CONFIG_GPIO_MAX732X) += max732x.o 11obj-$(CONFIG_GPIO_MAX732X) += max732x.o
diff --git a/drivers/gpio/adp5588-gpio.c b/drivers/gpio/adp5588-gpio.c
new file mode 100644
index 000000000000..afc097a16b33
--- /dev/null
+++ b/drivers/gpio/adp5588-gpio.c
@@ -0,0 +1,266 @@
1/*
2 * GPIO Chip driver for Analog Devices
3 * ADP5588 I/O Expander and QWERTY Keypad Controller
4 *
5 * Copyright 2009 Analog Devices Inc.
6 *
7 * Licensed under the GPL-2 or later.
8 */
9
10#include <linux/module.h>
11#include <linux/kernel.h>
12#include <linux/init.h>
13#include <linux/i2c.h>
14#include <linux/gpio.h>
15
16#include <linux/i2c/adp5588.h>
17
18#define DRV_NAME "adp5588-gpio"
19#define MAXGPIO 18
20#define ADP_BANK(offs) ((offs) >> 3)
21#define ADP_BIT(offs) (1u << ((offs) & 0x7))
22
23struct adp5588_gpio {
24 struct i2c_client *client;
25 struct gpio_chip gpio_chip;
26 struct mutex lock; /* protect cached dir, dat_out */
27 unsigned gpio_start;
28 uint8_t dat_out[3];
29 uint8_t dir[3];
30};
31
32static int adp5588_gpio_read(struct i2c_client *client, u8 reg)
33{
34 int ret = i2c_smbus_read_byte_data(client, reg);
35
36 if (ret < 0)
37 dev_err(&client->dev, "Read Error\n");
38
39 return ret;
40}
41
42static int adp5588_gpio_write(struct i2c_client *client, u8 reg, u8 val)
43{
44 int ret = i2c_smbus_write_byte_data(client, reg, val);
45
46 if (ret < 0)
47 dev_err(&client->dev, "Write Error\n");
48
49 return ret;
50}
51
52static int adp5588_gpio_get_value(struct gpio_chip *chip, unsigned off)
53{
54 struct adp5588_gpio *dev =
55 container_of(chip, struct adp5588_gpio, gpio_chip);
56
57 return !!(adp5588_gpio_read(dev->client, GPIO_DAT_STAT1 + ADP_BANK(off))
58 & ADP_BIT(off));
59}
60
61static void adp5588_gpio_set_value(struct gpio_chip *chip,
62 unsigned off, int val)
63{
64 unsigned bank, bit;
65 struct adp5588_gpio *dev =
66 container_of(chip, struct adp5588_gpio, gpio_chip);
67
68 bank = ADP_BANK(off);
69 bit = ADP_BIT(off);
70
71 mutex_lock(&dev->lock);
72 if (val)
73 dev->dat_out[bank] |= bit;
74 else
75 dev->dat_out[bank] &= ~bit;
76
77 adp5588_gpio_write(dev->client, GPIO_DAT_OUT1 + bank,
78 dev->dat_out[bank]);
79 mutex_unlock(&dev->lock);
80}
81
82static int adp5588_gpio_direction_input(struct gpio_chip *chip, unsigned off)
83{
84 int ret;
85 unsigned bank;
86 struct adp5588_gpio *dev =
87 container_of(chip, struct adp5588_gpio, gpio_chip);
88
89 bank = ADP_BANK(off);
90
91 mutex_lock(&dev->lock);
92 dev->dir[bank] &= ~ADP_BIT(off);
93 ret = adp5588_gpio_write(dev->client, GPIO_DIR1 + bank, dev->dir[bank]);
94 mutex_unlock(&dev->lock);
95
96 return ret;
97}
98
99static int adp5588_gpio_direction_output(struct gpio_chip *chip,
100 unsigned off, int val)
101{
102 int ret;
103 unsigned bank, bit;
104 struct adp5588_gpio *dev =
105 container_of(chip, struct adp5588_gpio, gpio_chip);
106
107 bank = ADP_BANK(off);
108 bit = ADP_BIT(off);
109
110 mutex_lock(&dev->lock);
111 dev->dir[bank] |= bit;
112
113 if (val)
114 dev->dat_out[bank] |= bit;
115 else
116 dev->dat_out[bank] &= ~bit;
117
118 ret = adp5588_gpio_write(dev->client, GPIO_DAT_OUT1 + bank,
119 dev->dat_out[bank]);
120 ret |= adp5588_gpio_write(dev->client, GPIO_DIR1 + bank,
121 dev->dir[bank]);
122 mutex_unlock(&dev->lock);
123
124 return ret;
125}
126
127static int __devinit adp5588_gpio_probe(struct i2c_client *client,
128 const struct i2c_device_id *id)
129{
130 struct adp5588_gpio_platform_data *pdata = client->dev.platform_data;
131 struct adp5588_gpio *dev;
132 struct gpio_chip *gc;
133 int ret, i, revid;
134
135 if (pdata == NULL) {
136 dev_err(&client->dev, "missing platform data\n");
137 return -ENODEV;
138 }
139
140 if (!i2c_check_functionality(client->adapter,
141 I2C_FUNC_SMBUS_BYTE_DATA)) {
142 dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
143 return -EIO;
144 }
145
146 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
147 if (dev == NULL) {
148 dev_err(&client->dev, "failed to alloc memory\n");
149 return -ENOMEM;
150 }
151
152 dev->client = client;
153
154 gc = &dev->gpio_chip;
155 gc->direction_input = adp5588_gpio_direction_input;
156 gc->direction_output = adp5588_gpio_direction_output;
157 gc->get = adp5588_gpio_get_value;
158 gc->set = adp5588_gpio_set_value;
159 gc->can_sleep = 1;
160
161 gc->base = pdata->gpio_start;
162 gc->ngpio = MAXGPIO;
163 gc->label = client->name;
164 gc->owner = THIS_MODULE;
165
166 mutex_init(&dev->lock);
167
168
169 ret = adp5588_gpio_read(dev->client, DEV_ID);
170 if (ret < 0)
171 goto err;
172
173 revid = ret & ADP5588_DEVICE_ID_MASK;
174
175 for (i = 0, ret = 0; i <= ADP_BANK(MAXGPIO); i++) {
176 dev->dat_out[i] = adp5588_gpio_read(client, GPIO_DAT_OUT1 + i);
177 dev->dir[i] = adp5588_gpio_read(client, GPIO_DIR1 + i);
178 ret |= adp5588_gpio_write(client, KP_GPIO1 + i, 0);
179 ret |= adp5588_gpio_write(client, GPIO_PULL1 + i,
180 (pdata->pullup_dis_mask >> (8 * i)) & 0xFF);
181
182 if (ret)
183 goto err;
184 }
185
186 ret = gpiochip_add(&dev->gpio_chip);
187 if (ret)
188 goto err;
189
190 dev_info(&client->dev, "gpios %d..%d on a %s Rev. %d\n",
191 gc->base, gc->base + gc->ngpio - 1,
192 client->name, revid);
193
194 if (pdata->setup) {
195 ret = pdata->setup(client, gc->base, gc->ngpio, pdata->context);
196 if (ret < 0)
197 dev_warn(&client->dev, "setup failed, %d\n", ret);
198 }
199
200 i2c_set_clientdata(client, dev);
201 return 0;
202
203err:
204 kfree(dev);
205 return ret;
206}
207
208static int __devexit adp5588_gpio_remove(struct i2c_client *client)
209{
210 struct adp5588_gpio_platform_data *pdata = client->dev.platform_data;
211 struct adp5588_gpio *dev = i2c_get_clientdata(client);
212 int ret;
213
214 if (pdata->teardown) {
215 ret = pdata->teardown(client,
216 dev->gpio_chip.base, dev->gpio_chip.ngpio,
217 pdata->context);
218 if (ret < 0) {
219 dev_err(&client->dev, "teardown failed %d\n", ret);
220 return ret;
221 }
222 }
223
224 ret = gpiochip_remove(&dev->gpio_chip);
225 if (ret) {
226 dev_err(&client->dev, "gpiochip_remove failed %d\n", ret);
227 return ret;
228 }
229
230 kfree(dev);
231 return 0;
232}
233
234static const struct i2c_device_id adp5588_gpio_id[] = {
235 {DRV_NAME, 0},
236 {}
237};
238
239MODULE_DEVICE_TABLE(i2c, adp5588_gpio_id);
240
241static struct i2c_driver adp5588_gpio_driver = {
242 .driver = {
243 .name = DRV_NAME,
244 },
245 .probe = adp5588_gpio_probe,
246 .remove = __devexit_p(adp5588_gpio_remove),
247 .id_table = adp5588_gpio_id,
248};
249
250static int __init adp5588_gpio_init(void)
251{
252 return i2c_add_driver(&adp5588_gpio_driver);
253}
254
255module_init(adp5588_gpio_init);
256
257static void __exit adp5588_gpio_exit(void)
258{
259 i2c_del_driver(&adp5588_gpio_driver);
260}
261
262module_exit(adp5588_gpio_exit);
263
264MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
265MODULE_DESCRIPTION("GPIO ADP5588 Driver");
266MODULE_LICENSE("GPL");
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index a25ad284a272..350842ad3632 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -858,8 +858,6 @@ int gpio_sysfs_set_active_low(unsigned gpio, int value)
858 desc = &gpio_desc[gpio]; 858 desc = &gpio_desc[gpio];
859 859
860 if (test_bit(FLAG_EXPORT, &desc->flags)) { 860 if (test_bit(FLAG_EXPORT, &desc->flags)) {
861 struct device *dev;
862
863 dev = class_find_device(&gpio_class, NULL, desc, match_export); 861 dev = class_find_device(&gpio_class, NULL, desc, match_export);
864 if (dev == NULL) { 862 if (dev == NULL) {
865 status = -ENODEV; 863 status = -ENODEV;
diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
index 2ffffd7ae09a..be631cc3e4dc 100644
--- a/drivers/gpu/drm/i915/i915_drv.c
+++ b/drivers/gpu/drm/i915/i915_drv.c
@@ -464,6 +464,8 @@ static struct drm_driver driver = {
464 .lastclose = i915_driver_lastclose, 464 .lastclose = i915_driver_lastclose,
465 .preclose = i915_driver_preclose, 465 .preclose = i915_driver_preclose,
466 .postclose = i915_driver_postclose, 466 .postclose = i915_driver_postclose,
467 .suspend = i915_suspend,
468 .resume = i915_resume,
467 .device_is_agp = i915_driver_device_is_agp, 469 .device_is_agp = i915_driver_device_is_agp,
468 .enable_vblank = i915_enable_vblank, 470 .enable_vblank = i915_enable_vblank,
469 .disable_vblank = i915_disable_vblank, 471 .disable_vblank = i915_disable_vblank,
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 435ae72fc47a..68cf87749a42 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -792,6 +792,16 @@ config SENSORS_ADS7828
792 This driver can also be built as a module. If so, the module 792 This driver can also be built as a module. If so, the module
793 will be called ads7828. 793 will be called ads7828.
794 794
795config SENSORS_AMC6821
796 tristate "Texas Instruments AMC6821"
797 depends on I2C && EXPERIMENTAL
798 help
799 If you say yes here you get support for the Texas Instruments
800 AMC6821 hardware monitoring chips.
801
802 This driver can also be build as a module. If so, the module
803 will be called amc6821.
804
795config SENSORS_THMC50 805config SENSORS_THMC50
796 tristate "Texas Instruments THMC50 / Analog Devices ADM1022" 806 tristate "Texas Instruments THMC50 / Analog Devices ADM1022"
797 depends on I2C && EXPERIMENTAL 807 depends on I2C && EXPERIMENTAL
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 450c8e894277..4bc215c0953f 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -86,6 +86,7 @@ obj-$(CONFIG_SENSORS_SIS5595) += sis5595.o
86obj-$(CONFIG_SENSORS_SMSC47B397)+= smsc47b397.o 86obj-$(CONFIG_SENSORS_SMSC47B397)+= smsc47b397.o
87obj-$(CONFIG_SENSORS_SMSC47M1) += smsc47m1.o 87obj-$(CONFIG_SENSORS_SMSC47M1) += smsc47m1.o
88obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o 88obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o
89obj-$(CONFIG_SENSORS_AMC6821) += amc6821.o
89obj-$(CONFIG_SENSORS_THMC50) += thmc50.o 90obj-$(CONFIG_SENSORS_THMC50) += thmc50.o
90obj-$(CONFIG_SENSORS_TMP401) += tmp401.o 91obj-$(CONFIG_SENSORS_TMP401) += tmp401.o
91obj-$(CONFIG_SENSORS_TMP421) += tmp421.o 92obj-$(CONFIG_SENSORS_TMP421) += tmp421.o
diff --git a/drivers/hwmon/amc6821.c b/drivers/hwmon/amc6821.c
new file mode 100644
index 000000000000..1c89d922d619
--- /dev/null
+++ b/drivers/hwmon/amc6821.c
@@ -0,0 +1,1116 @@
1/*
2 amc6821.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring
4 Copyright (C) 2009 T. Mertelj <tomaz.mertelj@guest.arnes.si>
5
6 Based on max6650.c:
7 Copyright (C) 2007 Hans J. Koch <hjk@linutronix.de>
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22*/
23
24
25#include <linux/kernel.h> /* Needed for KERN_INFO */
26#include <linux/module.h>
27#include <linux/init.h>
28#include <linux/slab.h>
29#include <linux/jiffies.h>
30#include <linux/i2c.h>
31#include <linux/hwmon.h>
32#include <linux/hwmon-sysfs.h>
33#include <linux/err.h>
34#include <linux/mutex.h>
35
36
37/*
38 * Addresses to scan.
39 */
40
41static const unsigned short normal_i2c[] = {0x18, 0x19, 0x1a, 0x2c, 0x2d, 0x2e,
42 0x4c, 0x4d, 0x4e, I2C_CLIENT_END};
43
44
45
46/*
47 * Insmod parameters
48 */
49
50static int pwminv = 0; /*Inverted PWM output. */
51module_param(pwminv, int, S_IRUGO);
52
53static int init = 1; /*Power-on initialization.*/
54module_param(init, int, S_IRUGO);
55
56
57enum chips { amc6821 };
58
59#define AMC6821_REG_DEV_ID 0x3D
60#define AMC6821_REG_COMP_ID 0x3E
61#define AMC6821_REG_CONF1 0x00
62#define AMC6821_REG_CONF2 0x01
63#define AMC6821_REG_CONF3 0x3F
64#define AMC6821_REG_CONF4 0x04
65#define AMC6821_REG_STAT1 0x02
66#define AMC6821_REG_STAT2 0x03
67#define AMC6821_REG_TDATA_LOW 0x08
68#define AMC6821_REG_TDATA_HI 0x09
69#define AMC6821_REG_LTEMP_HI 0x0A
70#define AMC6821_REG_RTEMP_HI 0x0B
71#define AMC6821_REG_LTEMP_LIMIT_MIN 0x15
72#define AMC6821_REG_LTEMP_LIMIT_MAX 0x14
73#define AMC6821_REG_RTEMP_LIMIT_MIN 0x19
74#define AMC6821_REG_RTEMP_LIMIT_MAX 0x18
75#define AMC6821_REG_LTEMP_CRIT 0x1B
76#define AMC6821_REG_RTEMP_CRIT 0x1D
77#define AMC6821_REG_PSV_TEMP 0x1C
78#define AMC6821_REG_DCY 0x22
79#define AMC6821_REG_LTEMP_FAN_CTRL 0x24
80#define AMC6821_REG_RTEMP_FAN_CTRL 0x25
81#define AMC6821_REG_DCY_LOW_TEMP 0x21
82
83#define AMC6821_REG_TACH_LLIMITL 0x10
84#define AMC6821_REG_TACH_LLIMITH 0x11
85#define AMC6821_REG_TACH_HLIMITL 0x12
86#define AMC6821_REG_TACH_HLIMITH 0x13
87
88#define AMC6821_CONF1_START 0x01
89#define AMC6821_CONF1_FAN_INT_EN 0x02
90#define AMC6821_CONF1_FANIE 0x04
91#define AMC6821_CONF1_PWMINV 0x08
92#define AMC6821_CONF1_FAN_FAULT_EN 0x10
93#define AMC6821_CONF1_FDRC0 0x20
94#define AMC6821_CONF1_FDRC1 0x40
95#define AMC6821_CONF1_THERMOVIE 0x80
96
97#define AMC6821_CONF2_PWM_EN 0x01
98#define AMC6821_CONF2_TACH_MODE 0x02
99#define AMC6821_CONF2_TACH_EN 0x04
100#define AMC6821_CONF2_RTFIE 0x08
101#define AMC6821_CONF2_LTOIE 0x10
102#define AMC6821_CONF2_RTOIE 0x20
103#define AMC6821_CONF2_PSVIE 0x40
104#define AMC6821_CONF2_RST 0x80
105
106#define AMC6821_CONF3_THERM_FAN_EN 0x80
107#define AMC6821_CONF3_REV_MASK 0x0F
108
109#define AMC6821_CONF4_OVREN 0x10
110#define AMC6821_CONF4_TACH_FAST 0x20
111#define AMC6821_CONF4_PSPR 0x40
112#define AMC6821_CONF4_MODE 0x80
113
114#define AMC6821_STAT1_RPM_ALARM 0x01
115#define AMC6821_STAT1_FANS 0x02
116#define AMC6821_STAT1_RTH 0x04
117#define AMC6821_STAT1_RTL 0x08
118#define AMC6821_STAT1_R_THERM 0x10
119#define AMC6821_STAT1_RTF 0x20
120#define AMC6821_STAT1_LTH 0x40
121#define AMC6821_STAT1_LTL 0x80
122
123#define AMC6821_STAT2_RTC 0x08
124#define AMC6821_STAT2_LTC 0x10
125#define AMC6821_STAT2_LPSV 0x20
126#define AMC6821_STAT2_L_THERM 0x40
127#define AMC6821_STAT2_THERM_IN 0x80
128
129enum {IDX_TEMP1_INPUT = 0, IDX_TEMP1_MIN, IDX_TEMP1_MAX,
130 IDX_TEMP1_CRIT, IDX_TEMP2_INPUT, IDX_TEMP2_MIN,
131 IDX_TEMP2_MAX, IDX_TEMP2_CRIT,
132 TEMP_IDX_LEN, };
133
134static const u8 temp_reg[] = {AMC6821_REG_LTEMP_HI,
135 AMC6821_REG_LTEMP_LIMIT_MIN,
136 AMC6821_REG_LTEMP_LIMIT_MAX,
137 AMC6821_REG_LTEMP_CRIT,
138 AMC6821_REG_RTEMP_HI,
139 AMC6821_REG_RTEMP_LIMIT_MIN,
140 AMC6821_REG_RTEMP_LIMIT_MAX,
141 AMC6821_REG_RTEMP_CRIT, };
142
143enum {IDX_FAN1_INPUT = 0, IDX_FAN1_MIN, IDX_FAN1_MAX,
144 FAN1_IDX_LEN, };
145
146static const u8 fan_reg_low[] = {AMC6821_REG_TDATA_LOW,
147 AMC6821_REG_TACH_LLIMITL,
148 AMC6821_REG_TACH_HLIMITL, };
149
150
151static const u8 fan_reg_hi[] = {AMC6821_REG_TDATA_HI,
152 AMC6821_REG_TACH_LLIMITH,
153 AMC6821_REG_TACH_HLIMITH, };
154
155static int amc6821_probe(
156 struct i2c_client *client,
157 const struct i2c_device_id *id);
158static int amc6821_detect(
159 struct i2c_client *client,
160 struct i2c_board_info *info);
161static int amc6821_init_client(struct i2c_client *client);
162static int amc6821_remove(struct i2c_client *client);
163static struct amc6821_data *amc6821_update_device(struct device *dev);
164
165/*
166 * Driver data (common to all clients)
167 */
168
169static const struct i2c_device_id amc6821_id[] = {
170 { "amc6821", amc6821 },
171 { }
172};
173
174MODULE_DEVICE_TABLE(i2c, amc6821_id);
175
176static struct i2c_driver amc6821_driver = {
177 .class = I2C_CLASS_HWMON,
178 .driver = {
179 .name = "amc6821",
180 },
181 .probe = amc6821_probe,
182 .remove = amc6821_remove,
183 .id_table = amc6821_id,
184 .detect = amc6821_detect,
185 .address_list = normal_i2c,
186};
187
188
189/*
190 * Client data (each client gets its own)
191 */
192
193struct amc6821_data {
194 struct device *hwmon_dev;
195 struct mutex update_lock;
196 char valid; /* zero until following fields are valid */
197 unsigned long last_updated; /* in jiffies */
198
199 /* register values */
200 int temp[TEMP_IDX_LEN];
201
202 u16 fan[FAN1_IDX_LEN];
203 u8 fan1_div;
204
205 u8 pwm1;
206 u8 temp1_auto_point_temp[3];
207 u8 temp2_auto_point_temp[3];
208 u8 pwm1_auto_point_pwm[3];
209 u8 pwm1_enable;
210 u8 pwm1_auto_channels_temp;
211
212 u8 stat1;
213 u8 stat2;
214};
215
216
217static ssize_t get_temp(
218 struct device *dev,
219 struct device_attribute *devattr,
220 char *buf)
221{
222 struct amc6821_data *data = amc6821_update_device(dev);
223 int ix = to_sensor_dev_attr(devattr)->index;
224
225 return sprintf(buf, "%d\n", data->temp[ix] * 1000);
226}
227
228
229
230static ssize_t set_temp(
231 struct device *dev,
232 struct device_attribute *attr,
233 const char *buf,
234 size_t count)
235{
236 struct i2c_client *client = to_i2c_client(dev);
237 struct amc6821_data *data = i2c_get_clientdata(client);
238 int ix = to_sensor_dev_attr(attr)->index;
239 long val;
240
241 int ret = strict_strtol(buf, 10, &val);
242 if (ret)
243 return ret;
244 val = SENSORS_LIMIT(val / 1000, -128, 127);
245
246 mutex_lock(&data->update_lock);
247 data->temp[ix] = val;
248 if (i2c_smbus_write_byte_data(client, temp_reg[ix], data->temp[ix])) {
249 dev_err(&client->dev, "Register write error, aborting.\n");
250 count = -EIO;
251 }
252 mutex_unlock(&data->update_lock);
253 return count;
254}
255
256
257
258
259static ssize_t get_temp_alarm(
260 struct device *dev,
261 struct device_attribute *devattr,
262 char *buf)
263{
264 struct amc6821_data *data = amc6821_update_device(dev);
265 int ix = to_sensor_dev_attr(devattr)->index;
266 u8 flag;
267
268 switch (ix) {
269 case IDX_TEMP1_MIN:
270 flag = data->stat1 & AMC6821_STAT1_LTL;
271 break;
272 case IDX_TEMP1_MAX:
273 flag = data->stat1 & AMC6821_STAT1_LTH;
274 break;
275 case IDX_TEMP1_CRIT:
276 flag = data->stat2 & AMC6821_STAT2_LTC;
277 break;
278 case IDX_TEMP2_MIN:
279 flag = data->stat1 & AMC6821_STAT1_RTL;
280 break;
281 case IDX_TEMP2_MAX:
282 flag = data->stat1 & AMC6821_STAT1_RTH;
283 break;
284 case IDX_TEMP2_CRIT:
285 flag = data->stat2 & AMC6821_STAT2_RTC;
286 break;
287 default:
288 dev_dbg(dev, "Unknown attr->index (%d).\n", ix);
289 return -EINVAL;
290 }
291 if (flag)
292 return sprintf(buf, "1");
293 else
294 return sprintf(buf, "0");
295}
296
297
298
299
300static ssize_t get_temp2_fault(
301 struct device *dev,
302 struct device_attribute *devattr,
303 char *buf)
304{
305 struct amc6821_data *data = amc6821_update_device(dev);
306 if (data->stat1 & AMC6821_STAT1_RTF)
307 return sprintf(buf, "1");
308 else
309 return sprintf(buf, "0");
310}
311
312static ssize_t get_pwm1(
313 struct device *dev,
314 struct device_attribute *devattr,
315 char *buf)
316{
317 struct amc6821_data *data = amc6821_update_device(dev);
318 return sprintf(buf, "%d\n", data->pwm1);
319}
320
321static ssize_t set_pwm1(
322 struct device *dev,
323 struct device_attribute *devattr,
324 const char *buf,
325 size_t count)
326{
327 struct i2c_client *client = to_i2c_client(dev);
328 struct amc6821_data *data = i2c_get_clientdata(client);
329 long val;
330 int ret = strict_strtol(buf, 10, &val);
331 if (ret)
332 return ret;
333
334 mutex_lock(&data->update_lock);
335 data->pwm1 = SENSORS_LIMIT(val , 0, 255);
336 i2c_smbus_write_byte_data(client, AMC6821_REG_DCY, data->pwm1);
337 mutex_unlock(&data->update_lock);
338 return count;
339}
340
341static ssize_t get_pwm1_enable(
342 struct device *dev,
343 struct device_attribute *devattr,
344 char *buf)
345{
346 struct amc6821_data *data = amc6821_update_device(dev);
347 return sprintf(buf, "%d\n", data->pwm1_enable);
348}
349
350static ssize_t set_pwm1_enable(
351 struct device *dev,
352 struct device_attribute *attr,
353 const char *buf,
354 size_t count)
355{
356 struct i2c_client *client = to_i2c_client(dev);
357 struct amc6821_data *data = i2c_get_clientdata(client);
358 long val;
359 int config = strict_strtol(buf, 10, &val);
360 if (config)
361 return config;
362
363 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
364 if (config < 0) {
365 dev_err(&client->dev,
366 "Error reading configuration register, aborting.\n");
367 return -EIO;
368 }
369
370 switch (val) {
371 case 1:
372 config &= ~AMC6821_CONF1_FDRC0;
373 config &= ~AMC6821_CONF1_FDRC1;
374 break;
375 case 2:
376 config &= ~AMC6821_CONF1_FDRC0;
377 config |= AMC6821_CONF1_FDRC1;
378 break;
379 case 3:
380 config |= AMC6821_CONF1_FDRC0;
381 config |= AMC6821_CONF1_FDRC1;
382 break;
383 default:
384 return -EINVAL;
385 }
386 mutex_lock(&data->update_lock);
387 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF1, config)) {
388 dev_err(&client->dev,
389 "Configuration register write error, aborting.\n");
390 count = -EIO;
391 }
392 mutex_unlock(&data->update_lock);
393 return count;
394}
395
396
397static ssize_t get_pwm1_auto_channels_temp(
398 struct device *dev,
399 struct device_attribute *devattr,
400 char *buf)
401{
402 struct amc6821_data *data = amc6821_update_device(dev);
403 return sprintf(buf, "%d\n", data->pwm1_auto_channels_temp);
404}
405
406
407static ssize_t get_temp_auto_point_temp(
408 struct device *dev,
409 struct device_attribute *devattr,
410 char *buf)
411{
412 int ix = to_sensor_dev_attr_2(devattr)->index;
413 int nr = to_sensor_dev_attr_2(devattr)->nr;
414 struct amc6821_data *data = amc6821_update_device(dev);
415 switch (nr) {
416 case 1:
417 return sprintf(buf, "%d\n",
418 data->temp1_auto_point_temp[ix] * 1000);
419 break;
420 case 2:
421 return sprintf(buf, "%d\n",
422 data->temp2_auto_point_temp[ix] * 1000);
423 break;
424 default:
425 dev_dbg(dev, "Unknown attr->nr (%d).\n", nr);
426 return -EINVAL;
427 }
428}
429
430
431static ssize_t get_pwm1_auto_point_pwm(
432 struct device *dev,
433 struct device_attribute *devattr,
434 char *buf)
435{
436 int ix = to_sensor_dev_attr(devattr)->index;
437 struct amc6821_data *data = amc6821_update_device(dev);
438 return sprintf(buf, "%d\n", data->pwm1_auto_point_pwm[ix]);
439}
440
441
442static inline ssize_t set_slope_register(struct i2c_client *client,
443 u8 reg,
444 u8 dpwm,
445 u8 *ptemp)
446{
447 int dt;
448 u8 tmp;
449
450 dt = ptemp[2]-ptemp[1];
451 for (tmp = 4; tmp > 0; tmp--) {
452 if (dt * (0x20 >> tmp) >= dpwm)
453 break;
454 }
455 tmp |= (ptemp[1] & 0x7C) << 1;
456 if (i2c_smbus_write_byte_data(client,
457 reg, tmp)) {
458 dev_err(&client->dev, "Register write error, aborting.\n");
459 return -EIO;
460 }
461 return 0;
462}
463
464
465
466static ssize_t set_temp_auto_point_temp(
467 struct device *dev,
468 struct device_attribute *attr,
469 const char *buf,
470 size_t count)
471{
472 struct i2c_client *client = to_i2c_client(dev);
473 struct amc6821_data *data = amc6821_update_device(dev);
474 int ix = to_sensor_dev_attr_2(attr)->index;
475 int nr = to_sensor_dev_attr_2(attr)->nr;
476 u8 *ptemp;
477 u8 reg;
478 int dpwm;
479 long val;
480 int ret = strict_strtol(buf, 10, &val);
481 if (ret)
482 return ret;
483
484 switch (nr) {
485 case 1:
486 ptemp = data->temp1_auto_point_temp;
487 reg = AMC6821_REG_LTEMP_FAN_CTRL;
488 break;
489 case 2:
490 ptemp = data->temp2_auto_point_temp;
491 reg = AMC6821_REG_RTEMP_FAN_CTRL;
492 break;
493 default:
494 dev_dbg(dev, "Unknown attr->nr (%d).\n", nr);
495 return -EINVAL;
496 }
497
498 data->valid = 0;
499 mutex_lock(&data->update_lock);
500 switch (ix) {
501 case 0:
502 ptemp[0] = SENSORS_LIMIT(val / 1000, 0,
503 data->temp1_auto_point_temp[1]);
504 ptemp[0] = SENSORS_LIMIT(ptemp[0], 0,
505 data->temp2_auto_point_temp[1]);
506 ptemp[0] = SENSORS_LIMIT(ptemp[0], 0, 63);
507 if (i2c_smbus_write_byte_data(
508 client,
509 AMC6821_REG_PSV_TEMP,
510 ptemp[0])) {
511 dev_err(&client->dev,
512 "Register write error, aborting.\n");
513 count = -EIO;
514 }
515 goto EXIT;
516 break;
517 case 1:
518 ptemp[1] = SENSORS_LIMIT(
519 val / 1000,
520 (ptemp[0] & 0x7C) + 4,
521 124);
522 ptemp[1] &= 0x7C;
523 ptemp[2] = SENSORS_LIMIT(
524 ptemp[2], ptemp[1] + 1,
525 255);
526 break;
527 case 2:
528 ptemp[2] = SENSORS_LIMIT(
529 val / 1000,
530 ptemp[1]+1,
531 255);
532 break;
533 default:
534 dev_dbg(dev, "Unknown attr->index (%d).\n", ix);
535 count = -EINVAL;
536 goto EXIT;
537 }
538 dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1];
539 if (set_slope_register(client, reg, dpwm, ptemp))
540 count = -EIO;
541
542EXIT:
543 mutex_unlock(&data->update_lock);
544 return count;
545}
546
547
548
549static ssize_t set_pwm1_auto_point_pwm(
550 struct device *dev,
551 struct device_attribute *attr,
552 const char *buf,
553 size_t count)
554{
555 struct i2c_client *client = to_i2c_client(dev);
556 struct amc6821_data *data = i2c_get_clientdata(client);
557 int dpwm;
558 long val;
559 int ret = strict_strtol(buf, 10, &val);
560 if (ret)
561 return ret;
562
563 mutex_lock(&data->update_lock);
564 data->pwm1_auto_point_pwm[1] = SENSORS_LIMIT(val, 0, 254);
565 if (i2c_smbus_write_byte_data(client, AMC6821_REG_DCY_LOW_TEMP,
566 data->pwm1_auto_point_pwm[1])) {
567 dev_err(&client->dev, "Register write error, aborting.\n");
568 count = -EIO;
569 goto EXIT;
570 }
571 dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1];
572 if (set_slope_register(client, AMC6821_REG_LTEMP_FAN_CTRL, dpwm,
573 data->temp1_auto_point_temp)) {
574 count = -EIO;
575 goto EXIT;
576 }
577 if (set_slope_register(client, AMC6821_REG_RTEMP_FAN_CTRL, dpwm,
578 data->temp2_auto_point_temp)) {
579 count = -EIO;
580 goto EXIT;
581 }
582
583EXIT:
584 data->valid = 0;
585 mutex_unlock(&data->update_lock);
586 return count;
587}
588
589static ssize_t get_fan(
590 struct device *dev,
591 struct device_attribute *devattr,
592 char *buf)
593{
594 struct amc6821_data *data = amc6821_update_device(dev);
595 int ix = to_sensor_dev_attr(devattr)->index;
596 if (0 == data->fan[ix])
597 return sprintf(buf, "0");
598 return sprintf(buf, "%d\n", (int)(6000000 / data->fan[ix]));
599}
600
601
602
603static ssize_t get_fan1_fault(
604 struct device *dev,
605 struct device_attribute *devattr,
606 char *buf)
607{
608 struct amc6821_data *data = amc6821_update_device(dev);
609 if (data->stat1 & AMC6821_STAT1_FANS)
610 return sprintf(buf, "1");
611 else
612 return sprintf(buf, "0");
613}
614
615
616
617static ssize_t set_fan(
618 struct device *dev,
619 struct device_attribute *attr,
620 const char *buf, size_t count)
621{
622 struct i2c_client *client = to_i2c_client(dev);
623 struct amc6821_data *data = i2c_get_clientdata(client);
624 long val;
625 int ix = to_sensor_dev_attr(attr)->index;
626 int ret = strict_strtol(buf, 10, &val);
627 if (ret)
628 return ret;
629 val = 1 > val ? 0xFFFF : 6000000/val;
630
631 mutex_lock(&data->update_lock);
632 data->fan[ix] = (u16) SENSORS_LIMIT(val, 1, 0xFFFF);
633 if (i2c_smbus_write_byte_data(client, fan_reg_low[ix],
634 data->fan[ix] & 0xFF)) {
635 dev_err(&client->dev, "Register write error, aborting.\n");
636 count = -EIO;
637 goto EXIT;
638 }
639 if (i2c_smbus_write_byte_data(client,
640 fan_reg_hi[ix], data->fan[ix] >> 8)) {
641 dev_err(&client->dev, "Register write error, aborting.\n");
642 count = -EIO;
643 }
644EXIT:
645 mutex_unlock(&data->update_lock);
646 return count;
647}
648
649
650
651static ssize_t get_fan1_div(
652 struct device *dev,
653 struct device_attribute *devattr,
654 char *buf)
655{
656 struct amc6821_data *data = amc6821_update_device(dev);
657 return sprintf(buf, "%d\n", data->fan1_div);
658}
659
660static ssize_t set_fan1_div(
661 struct device *dev,
662 struct device_attribute *attr,
663 const char *buf, size_t count)
664{
665 struct i2c_client *client = to_i2c_client(dev);
666 struct amc6821_data *data = i2c_get_clientdata(client);
667 long val;
668 int config = strict_strtol(buf, 10, &val);
669 if (config)
670 return config;
671
672 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4);
673 if (config < 0) {
674 dev_err(&client->dev,
675 "Error reading configuration register, aborting.\n");
676 return -EIO;
677 }
678 mutex_lock(&data->update_lock);
679 switch (val) {
680 case 2:
681 config &= ~AMC6821_CONF4_PSPR;
682 data->fan1_div = 2;
683 break;
684 case 4:
685 config |= AMC6821_CONF4_PSPR;
686 data->fan1_div = 4;
687 break;
688 default:
689 mutex_unlock(&data->update_lock);
690 count = -EINVAL;
691 goto EXIT;
692 }
693 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4, config)) {
694 dev_err(&client->dev,
695 "Configuration register write error, aborting.\n");
696 count = -EIO;
697 }
698EXIT:
699 mutex_unlock(&data->update_lock);
700 return count;
701}
702
703
704
705static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
706 get_temp, NULL, IDX_TEMP1_INPUT);
707static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR, get_temp,
708 set_temp, IDX_TEMP1_MIN);
709static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, get_temp,
710 set_temp, IDX_TEMP1_MAX);
711static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR, get_temp,
712 set_temp, IDX_TEMP1_CRIT);
713static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO,
714 get_temp_alarm, NULL, IDX_TEMP1_MIN);
715static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO,
716 get_temp_alarm, NULL, IDX_TEMP1_MAX);
717static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO,
718 get_temp_alarm, NULL, IDX_TEMP1_CRIT);
719static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO | S_IWUSR,
720 get_temp, NULL, IDX_TEMP2_INPUT);
721static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR, get_temp,
722 set_temp, IDX_TEMP2_MIN);
723static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, get_temp,
724 set_temp, IDX_TEMP2_MAX);
725static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO | S_IWUSR, get_temp,
726 set_temp, IDX_TEMP2_CRIT);
727static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO,
728 get_temp2_fault, NULL, 0);
729static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO,
730 get_temp_alarm, NULL, IDX_TEMP2_MIN);
731static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO,
732 get_temp_alarm, NULL, IDX_TEMP2_MAX);
733static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO,
734 get_temp_alarm, NULL, IDX_TEMP2_CRIT);
735static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan, NULL, IDX_FAN1_INPUT);
736static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
737 get_fan, set_fan, IDX_FAN1_MIN);
738static SENSOR_DEVICE_ATTR(fan1_max, S_IRUGO | S_IWUSR,
739 get_fan, set_fan, IDX_FAN1_MAX);
740static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, get_fan1_fault, NULL, 0);
741static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
742 get_fan1_div, set_fan1_div, 0);
743
744static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, get_pwm1, set_pwm1, 0);
745static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
746 get_pwm1_enable, set_pwm1_enable, 0);
747static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IRUGO,
748 get_pwm1_auto_point_pwm, NULL, 0);
749static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
750 get_pwm1_auto_point_pwm, set_pwm1_auto_point_pwm, 1);
751static SENSOR_DEVICE_ATTR(pwm1_auto_point3_pwm, S_IRUGO,
752 get_pwm1_auto_point_pwm, NULL, 2);
753static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IRUGO,
754 get_pwm1_auto_channels_temp, NULL, 0);
755static SENSOR_DEVICE_ATTR_2(temp1_auto_point1_temp, S_IRUGO,
756 get_temp_auto_point_temp, NULL, 1, 0);
757static SENSOR_DEVICE_ATTR_2(temp1_auto_point2_temp, S_IWUSR | S_IRUGO,
758 get_temp_auto_point_temp, set_temp_auto_point_temp, 1, 1);
759static SENSOR_DEVICE_ATTR_2(temp1_auto_point3_temp, S_IWUSR | S_IRUGO,
760 get_temp_auto_point_temp, set_temp_auto_point_temp, 1, 2);
761
762static SENSOR_DEVICE_ATTR_2(temp2_auto_point1_temp, S_IWUSR | S_IRUGO,
763 get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 0);
764static SENSOR_DEVICE_ATTR_2(temp2_auto_point2_temp, S_IWUSR | S_IRUGO,
765 get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 1);
766static SENSOR_DEVICE_ATTR_2(temp2_auto_point3_temp, S_IWUSR | S_IRUGO,
767 get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 2);
768
769
770
771static struct attribute *amc6821_attrs[] = {
772 &sensor_dev_attr_temp1_input.dev_attr.attr,
773 &sensor_dev_attr_temp1_min.dev_attr.attr,
774 &sensor_dev_attr_temp1_max.dev_attr.attr,
775 &sensor_dev_attr_temp1_crit.dev_attr.attr,
776 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
777 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
778 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
779 &sensor_dev_attr_temp2_input.dev_attr.attr,
780 &sensor_dev_attr_temp2_min.dev_attr.attr,
781 &sensor_dev_attr_temp2_max.dev_attr.attr,
782 &sensor_dev_attr_temp2_crit.dev_attr.attr,
783 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
784 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
785 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
786 &sensor_dev_attr_temp2_fault.dev_attr.attr,
787 &sensor_dev_attr_fan1_input.dev_attr.attr,
788 &sensor_dev_attr_fan1_min.dev_attr.attr,
789 &sensor_dev_attr_fan1_max.dev_attr.attr,
790 &sensor_dev_attr_fan1_fault.dev_attr.attr,
791 &sensor_dev_attr_fan1_div.dev_attr.attr,
792 &sensor_dev_attr_pwm1.dev_attr.attr,
793 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
794 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
795 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
796 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
797 &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
798 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
799 &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
800 &sensor_dev_attr_temp1_auto_point3_temp.dev_attr.attr,
801 &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
802 &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
803 &sensor_dev_attr_temp2_auto_point3_temp.dev_attr.attr,
804 NULL
805};
806
807static struct attribute_group amc6821_attr_grp = {
808 .attrs = amc6821_attrs,
809};
810
811
812
813/* Return 0 if detection is successful, -ENODEV otherwise */
814static int amc6821_detect(
815 struct i2c_client *client,
816 struct i2c_board_info *info)
817{
818 struct i2c_adapter *adapter = client->adapter;
819 int address = client->addr;
820 int dev_id, comp_id;
821
822 dev_dbg(&adapter->dev, "amc6821_detect called.\n");
823
824 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
825 dev_dbg(&adapter->dev,
826 "amc6821: I2C bus doesn't support byte mode, "
827 "skipping.\n");
828 return -ENODEV;
829 }
830
831 dev_id = i2c_smbus_read_byte_data(client, AMC6821_REG_DEV_ID);
832 comp_id = i2c_smbus_read_byte_data(client, AMC6821_REG_COMP_ID);
833 if (dev_id != 0x21 || comp_id != 0x49) {
834 dev_dbg(&adapter->dev,
835 "amc6821: detection failed at 0x%02x.\n",
836 address);
837 return -ENODEV;
838 }
839
840 /* Bit 7 of the address register is ignored, so we can check the
841 ID registers again */
842 dev_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_DEV_ID);
843 comp_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_COMP_ID);
844 if (dev_id != 0x21 || comp_id != 0x49) {
845 dev_dbg(&adapter->dev,
846 "amc6821: detection failed at 0x%02x.\n",
847 address);
848 return -ENODEV;
849 }
850
851 dev_info(&adapter->dev, "amc6821: chip found at 0x%02x.\n", address);
852 strlcpy(info->type, "amc6821", I2C_NAME_SIZE);
853
854 return 0;
855}
856
857static int amc6821_probe(
858 struct i2c_client *client,
859 const struct i2c_device_id *id)
860{
861 struct amc6821_data *data;
862 int err;
863
864 data = kzalloc(sizeof(struct amc6821_data), GFP_KERNEL);
865 if (!data) {
866 dev_err(&client->dev, "out of memory.\n");
867 return -ENOMEM;
868 }
869
870
871 i2c_set_clientdata(client, data);
872 mutex_init(&data->update_lock);
873
874 /*
875 * Initialize the amc6821 chip
876 */
877 err = amc6821_init_client(client);
878 if (err)
879 goto err_free;
880
881 err = sysfs_create_group(&client->dev.kobj, &amc6821_attr_grp);
882 if (err)
883 goto err_free;
884
885 data->hwmon_dev = hwmon_device_register(&client->dev);
886 if (!IS_ERR(data->hwmon_dev))
887 return 0;
888
889 err = PTR_ERR(data->hwmon_dev);
890 dev_err(&client->dev, "error registering hwmon device.\n");
891 sysfs_remove_group(&client->dev.kobj, &amc6821_attr_grp);
892err_free:
893 kfree(data);
894 return err;
895}
896
897static int amc6821_remove(struct i2c_client *client)
898{
899 struct amc6821_data *data = i2c_get_clientdata(client);
900
901 hwmon_device_unregister(data->hwmon_dev);
902 sysfs_remove_group(&client->dev.kobj, &amc6821_attr_grp);
903
904 kfree(data);
905
906 return 0;
907}
908
909
910static int amc6821_init_client(struct i2c_client *client)
911{
912 int config;
913 int err = -EIO;
914
915 if (init) {
916 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4);
917
918 if (config < 0) {
919 dev_err(&client->dev,
920 "Error reading configuration register, aborting.\n");
921 return err;
922 }
923
924 config |= AMC6821_CONF4_MODE;
925
926 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4,
927 config)) {
928 dev_err(&client->dev,
929 "Configuration register write error, aborting.\n");
930 return err;
931 }
932
933 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF3);
934
935 if (config < 0) {
936 dev_err(&client->dev,
937 "Error reading configuration register, aborting.\n");
938 return err;
939 }
940
941 dev_info(&client->dev, "Revision %d\n", config & 0x0f);
942
943 config &= ~AMC6821_CONF3_THERM_FAN_EN;
944
945 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF3,
946 config)) {
947 dev_err(&client->dev,
948 "Configuration register write error, aborting.\n");
949 return err;
950 }
951
952 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF2);
953
954 if (config < 0) {
955 dev_err(&client->dev,
956 "Error reading configuration register, aborting.\n");
957 return err;
958 }
959
960 config &= ~AMC6821_CONF2_RTFIE;
961 config &= ~AMC6821_CONF2_LTOIE;
962 config &= ~AMC6821_CONF2_RTOIE;
963 if (i2c_smbus_write_byte_data(client,
964 AMC6821_REG_CONF2, config)) {
965 dev_err(&client->dev,
966 "Configuration register write error, aborting.\n");
967 return err;
968 }
969
970 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
971
972 if (config < 0) {
973 dev_err(&client->dev,
974 "Error reading configuration register, aborting.\n");
975 return err;
976 }
977
978 config &= ~AMC6821_CONF1_THERMOVIE;
979 config &= ~AMC6821_CONF1_FANIE;
980 config |= AMC6821_CONF1_START;
981 if (pwminv)
982 config |= AMC6821_CONF1_PWMINV;
983 else
984 config &= ~AMC6821_CONF1_PWMINV;
985
986 if (i2c_smbus_write_byte_data(
987 client, AMC6821_REG_CONF1, config)) {
988 dev_err(&client->dev,
989 "Configuration register write error, aborting.\n");
990 return err;
991 }
992 }
993 return 0;
994}
995
996
997static struct amc6821_data *amc6821_update_device(struct device *dev)
998{
999 struct i2c_client *client = to_i2c_client(dev);
1000 struct amc6821_data *data = i2c_get_clientdata(client);
1001 int timeout = HZ;
1002 u8 reg;
1003 int i;
1004
1005 mutex_lock(&data->update_lock);
1006
1007 if (time_after(jiffies, data->last_updated + timeout) ||
1008 !data->valid) {
1009
1010 for (i = 0; i < TEMP_IDX_LEN; i++)
1011 data->temp[i] = i2c_smbus_read_byte_data(client,
1012 temp_reg[i]);
1013
1014 data->stat1 = i2c_smbus_read_byte_data(client,
1015 AMC6821_REG_STAT1);
1016 data->stat2 = i2c_smbus_read_byte_data(client,
1017 AMC6821_REG_STAT2);
1018
1019 data->pwm1 = i2c_smbus_read_byte_data(client,
1020 AMC6821_REG_DCY);
1021 for (i = 0; i < FAN1_IDX_LEN; i++) {
1022 data->fan[i] = i2c_smbus_read_byte_data(
1023 client,
1024 fan_reg_low[i]);
1025 data->fan[i] += i2c_smbus_read_byte_data(
1026 client,
1027 fan_reg_hi[i]) << 8;
1028 }
1029 data->fan1_div = i2c_smbus_read_byte_data(client,
1030 AMC6821_REG_CONF4);
1031 data->fan1_div = data->fan1_div & AMC6821_CONF4_PSPR ? 4 : 2;
1032
1033 data->pwm1_auto_point_pwm[0] = 0;
1034 data->pwm1_auto_point_pwm[2] = 255;
1035 data->pwm1_auto_point_pwm[1] = i2c_smbus_read_byte_data(client,
1036 AMC6821_REG_DCY_LOW_TEMP);
1037
1038 data->temp1_auto_point_temp[0] =
1039 i2c_smbus_read_byte_data(client,
1040 AMC6821_REG_PSV_TEMP);
1041 data->temp2_auto_point_temp[0] =
1042 data->temp1_auto_point_temp[0];
1043 reg = i2c_smbus_read_byte_data(client,
1044 AMC6821_REG_LTEMP_FAN_CTRL);
1045 data->temp1_auto_point_temp[1] = (reg & 0xF8) >> 1;
1046 reg &= 0x07;
1047 reg = 0x20 >> reg;
1048 if (reg > 0)
1049 data->temp1_auto_point_temp[2] =
1050 data->temp1_auto_point_temp[1] +
1051 (data->pwm1_auto_point_pwm[2] -
1052 data->pwm1_auto_point_pwm[1]) / reg;
1053 else
1054 data->temp1_auto_point_temp[2] = 255;
1055
1056 reg = i2c_smbus_read_byte_data(client,
1057 AMC6821_REG_RTEMP_FAN_CTRL);
1058 data->temp2_auto_point_temp[1] = (reg & 0xF8) >> 1;
1059 reg &= 0x07;
1060 reg = 0x20 >> reg;
1061 if (reg > 0)
1062 data->temp2_auto_point_temp[2] =
1063 data->temp2_auto_point_temp[1] +
1064 (data->pwm1_auto_point_pwm[2] -
1065 data->pwm1_auto_point_pwm[1]) / reg;
1066 else
1067 data->temp2_auto_point_temp[2] = 255;
1068
1069 reg = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
1070 reg = (reg >> 5) & 0x3;
1071 switch (reg) {
1072 case 0: /*open loop: software sets pwm1*/
1073 data->pwm1_auto_channels_temp = 0;
1074 data->pwm1_enable = 1;
1075 break;
1076 case 2: /*closed loop: remote T (temp2)*/
1077 data->pwm1_auto_channels_temp = 2;
1078 data->pwm1_enable = 2;
1079 break;
1080 case 3: /*closed loop: local and remote T (temp2)*/
1081 data->pwm1_auto_channels_temp = 3;
1082 data->pwm1_enable = 3;
1083 break;
1084 case 1: /*semi-open loop: software sets rpm, chip controls pwm1,
1085 *currently not implemented
1086 */
1087 data->pwm1_auto_channels_temp = 0;
1088 data->pwm1_enable = 0;
1089 break;
1090 }
1091
1092 data->last_updated = jiffies;
1093 data->valid = 1;
1094 }
1095 mutex_unlock(&data->update_lock);
1096 return data;
1097}
1098
1099
1100static int __init amc6821_init(void)
1101{
1102 return i2c_add_driver(&amc6821_driver);
1103}
1104
1105static void __exit amc6821_exit(void)
1106{
1107 i2c_del_driver(&amc6821_driver);
1108}
1109
1110module_init(amc6821_init);
1111module_exit(amc6821_exit);
1112
1113
1114MODULE_LICENSE("GPL");
1115MODULE_AUTHOR("T. Mertelj <tomaz.mertelj@guest.arnes.si>");
1116MODULE_DESCRIPTION("Texas Instruments amc6821 hwmon driver");
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 85f0e8cd875b..1f552c6e7579 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -85,7 +85,14 @@ static void mmc_blk_put(struct mmc_blk_data *md)
85 mutex_lock(&open_lock); 85 mutex_lock(&open_lock);
86 md->usage--; 86 md->usage--;
87 if (md->usage == 0) { 87 if (md->usage == 0) {
88 int devmaj = MAJOR(disk_devt(md->disk));
88 int devidx = MINOR(disk_devt(md->disk)) >> MMC_SHIFT; 89 int devidx = MINOR(disk_devt(md->disk)) >> MMC_SHIFT;
90
91 if (!devmaj)
92 devidx = md->disk->first_minor >> MMC_SHIFT;
93
94 blk_cleanup_queue(md->queue.queue);
95
89 __clear_bit(devidx, dev_use); 96 __clear_bit(devidx, dev_use);
90 97
91 put_disk(md->disk); 98 put_disk(md->disk);
@@ -613,6 +620,7 @@ static int mmc_blk_probe(struct mmc_card *card)
613 return 0; 620 return 0;
614 621
615 out: 622 out:
623 mmc_cleanup_queue(&md->queue);
616 mmc_blk_put(md); 624 mmc_blk_put(md);
617 625
618 return err; 626 return err;
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index 49e582356c65..c5a7a855f4b1 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -90,9 +90,10 @@ static void mmc_request(struct request_queue *q)
90 struct request *req; 90 struct request *req;
91 91
92 if (!mq) { 92 if (!mq) {
93 printk(KERN_ERR "MMC: killing requests for dead queue\n"); 93 while ((req = blk_fetch_request(q)) != NULL) {
94 while ((req = blk_fetch_request(q)) != NULL) 94 req->cmd_flags |= REQ_QUIET;
95 __blk_end_request_all(req, -EIO); 95 __blk_end_request_all(req, -EIO);
96 }
96 return; 97 return;
97 } 98 }
98 99
@@ -223,17 +224,18 @@ void mmc_cleanup_queue(struct mmc_queue *mq)
223 struct request_queue *q = mq->queue; 224 struct request_queue *q = mq->queue;
224 unsigned long flags; 225 unsigned long flags;
225 226
226 /* Mark that we should start throwing out stragglers */
227 spin_lock_irqsave(q->queue_lock, flags);
228 q->queuedata = NULL;
229 spin_unlock_irqrestore(q->queue_lock, flags);
230
231 /* Make sure the queue isn't suspended, as that will deadlock */ 227 /* Make sure the queue isn't suspended, as that will deadlock */
232 mmc_queue_resume(mq); 228 mmc_queue_resume(mq);
233 229
234 /* Then terminate our worker thread */ 230 /* Then terminate our worker thread */
235 kthread_stop(mq->thread); 231 kthread_stop(mq->thread);
236 232
233 /* Empty the queue */
234 spin_lock_irqsave(q->queue_lock, flags);
235 q->queuedata = NULL;
236 blk_start_queue(q);
237 spin_unlock_irqrestore(q->queue_lock, flags);
238
237 if (mq->bounce_sg) 239 if (mq->bounce_sg)
238 kfree(mq->bounce_sg); 240 kfree(mq->bounce_sg);
239 mq->bounce_sg = NULL; 241 mq->bounce_sg = NULL;
@@ -245,8 +247,6 @@ void mmc_cleanup_queue(struct mmc_queue *mq)
245 kfree(mq->bounce_buf); 247 kfree(mq->bounce_buf);
246 mq->bounce_buf = NULL; 248 mq->bounce_buf = NULL;
247 249
248 blk_cleanup_queue(mq->queue);
249
250 mq->card = NULL; 250 mq->card = NULL;
251} 251}
252EXPORT_SYMBOL(mmc_cleanup_queue); 252EXPORT_SYMBOL(mmc_cleanup_queue);
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index c11189446a1f..0eac6c814904 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -207,7 +207,7 @@ static int mmc_read_ext_csd(struct mmc_card *card)
207 } 207 }
208 208
209 card->ext_csd.rev = ext_csd[EXT_CSD_REV]; 209 card->ext_csd.rev = ext_csd[EXT_CSD_REV];
210 if (card->ext_csd.rev > 3) { 210 if (card->ext_csd.rev > 5) {
211 printk(KERN_ERR "%s: unrecognised EXT_CSD structure " 211 printk(KERN_ERR "%s: unrecognised EXT_CSD structure "
212 "version %d\n", mmc_hostname(card->host), 212 "version %d\n", mmc_hostname(card->host),
213 card->ext_csd.rev); 213 card->ext_csd.rev);
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index c8c12325e69b..e9aa814ddd23 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -1096,9 +1096,9 @@ static int cmos_pnp_resume(struct pnp_dev *pnp)
1096#define cmos_pnp_resume NULL 1096#define cmos_pnp_resume NULL
1097#endif 1097#endif
1098 1098
1099static void cmos_pnp_shutdown(struct device *pdev) 1099static void cmos_pnp_shutdown(struct pnp_dev *pnp)
1100{ 1100{
1101 if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(pdev)) 1101 if (system_state == SYSTEM_POWER_OFF && !cmos_poweroff(&pnp->dev))
1102 return; 1102 return;
1103 1103
1104 cmos_do_shutdown(); 1104 cmos_do_shutdown();
@@ -1117,15 +1117,12 @@ static struct pnp_driver cmos_pnp_driver = {
1117 .id_table = rtc_ids, 1117 .id_table = rtc_ids,
1118 .probe = cmos_pnp_probe, 1118 .probe = cmos_pnp_probe,
1119 .remove = __exit_p(cmos_pnp_remove), 1119 .remove = __exit_p(cmos_pnp_remove),
1120 .shutdown = cmos_pnp_shutdown,
1120 1121
1121 /* flag ensures resume() gets called, and stops syslog spam */ 1122 /* flag ensures resume() gets called, and stops syslog spam */
1122 .flags = PNP_DRIVER_RES_DO_NOT_CHANGE, 1123 .flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
1123 .suspend = cmos_pnp_suspend, 1124 .suspend = cmos_pnp_suspend,
1124 .resume = cmos_pnp_resume, 1125 .resume = cmos_pnp_resume,
1125 .driver = {
1126 .name = (char *)driver_name,
1127 .shutdown = cmos_pnp_shutdown,
1128 }
1129}; 1126};
1130 1127
1131#endif /* CONFIG_PNP */ 1128#endif /* CONFIG_PNP */
diff --git a/drivers/video/backlight/omap1_bl.c b/drivers/video/backlight/omap1_bl.c
index 409ca9643528..a3a7f8938175 100644
--- a/drivers/video/backlight/omap1_bl.c
+++ b/drivers/video/backlight/omap1_bl.c
@@ -139,8 +139,6 @@ static int omapbl_probe(struct platform_device *pdev)
139 if (!pdata) 139 if (!pdata)
140 return -ENXIO; 140 return -ENXIO;
141 141
142 omapbl_ops.check_fb = pdata->check_fb;
143
144 bl = kzalloc(sizeof(struct omap_backlight), GFP_KERNEL); 142 bl = kzalloc(sizeof(struct omap_backlight), GFP_KERNEL);
145 if (unlikely(!bl)) 143 if (unlikely(!bl))
146 return -ENOMEM; 144 return -ENOMEM;
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-01 10:17:58 -0500