Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 1 | /* |
| 2 | * max6650.c - Part of lm_sensors, Linux kernel modules for hardware |
| 3 | * monitoring. |
| 4 | * |
Hans J. Koch | 2aa25c2 | 2010-11-15 21:38:56 +0100 | [diff] [blame] | 5 | * (C) 2007 by Hans J. Koch <hjk@hansjkoch.de> |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 6 | * |
| 7 | * based on code written by John Morris <john.morris@spirentcom.com> |
| 8 | * Copyright (c) 2003 Spirent Communications |
| 9 | * and Claus Gindhart <claus.gindhart@kontron.com> |
| 10 | * |
| 11 | * This module has only been tested with the MAX6650 chip. It should |
| 12 | * also work with the MAX6651. It does not distinguish max6650 and max6651 |
| 13 | * chips. |
| 14 | * |
Christian Engelmayer | 52b5226 | 2009-06-15 18:39:52 +0200 | [diff] [blame] | 15 | * The datasheet was last seen at: |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 16 | * |
| 17 | * http://pdfserv.maxim-ic.com/en/ds/MAX6650-MAX6651.pdf |
| 18 | * |
| 19 | * This program is free software; you can redistribute it and/or modify |
| 20 | * it under the terms of the GNU General Public License as published by |
| 21 | * the Free Software Foundation; either version 2 of the License, or |
| 22 | * (at your option) any later version. |
| 23 | * |
| 24 | * This program is distributed in the hope that it will be useful, |
| 25 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 26 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 27 | * GNU General Public License for more details. |
| 28 | * |
| 29 | * You should have received a copy of the GNU General Public License |
| 30 | * along with this program; if not, write to the Free Software |
| 31 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| 32 | */ |
| 33 | |
| 34 | #include <linux/module.h> |
| 35 | #include <linux/init.h> |
| 36 | #include <linux/slab.h> |
| 37 | #include <linux/jiffies.h> |
| 38 | #include <linux/i2c.h> |
| 39 | #include <linux/hwmon.h> |
| 40 | #include <linux/hwmon-sysfs.h> |
| 41 | #include <linux/err.h> |
| 42 | |
| 43 | /* |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 44 | * Insmod parameters |
| 45 | */ |
| 46 | |
| 47 | /* fan_voltage: 5=5V fan, 12=12V fan, 0=don't change */ |
| 48 | static int fan_voltage; |
| 49 | /* prescaler: Possible values are 1, 2, 4, 8, 16 or 0 for don't change */ |
| 50 | static int prescaler; |
| 51 | /* clock: The clock frequency of the chip the driver should assume */ |
| 52 | static int clock = 254000; |
| 53 | |
| 54 | module_param(fan_voltage, int, S_IRUGO); |
| 55 | module_param(prescaler, int, S_IRUGO); |
| 56 | module_param(clock, int, S_IRUGO); |
| 57 | |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 58 | /* |
| 59 | * MAX 6650/6651 registers |
| 60 | */ |
| 61 | |
| 62 | #define MAX6650_REG_SPEED 0x00 |
| 63 | #define MAX6650_REG_CONFIG 0x02 |
| 64 | #define MAX6650_REG_GPIO_DEF 0x04 |
| 65 | #define MAX6650_REG_DAC 0x06 |
| 66 | #define MAX6650_REG_ALARM_EN 0x08 |
| 67 | #define MAX6650_REG_ALARM 0x0A |
| 68 | #define MAX6650_REG_TACH0 0x0C |
| 69 | #define MAX6650_REG_TACH1 0x0E |
| 70 | #define MAX6650_REG_TACH2 0x10 |
| 71 | #define MAX6650_REG_TACH3 0x12 |
| 72 | #define MAX6650_REG_GPIO_STAT 0x14 |
| 73 | #define MAX6650_REG_COUNT 0x16 |
| 74 | |
| 75 | /* |
| 76 | * Config register bits |
| 77 | */ |
| 78 | |
| 79 | #define MAX6650_CFG_V12 0x08 |
| 80 | #define MAX6650_CFG_PRESCALER_MASK 0x07 |
| 81 | #define MAX6650_CFG_PRESCALER_2 0x01 |
| 82 | #define MAX6650_CFG_PRESCALER_4 0x02 |
| 83 | #define MAX6650_CFG_PRESCALER_8 0x03 |
| 84 | #define MAX6650_CFG_PRESCALER_16 0x04 |
| 85 | #define MAX6650_CFG_MODE_MASK 0x30 |
| 86 | #define MAX6650_CFG_MODE_ON 0x00 |
| 87 | #define MAX6650_CFG_MODE_OFF 0x10 |
| 88 | #define MAX6650_CFG_MODE_CLOSED_LOOP 0x20 |
| 89 | #define MAX6650_CFG_MODE_OPEN_LOOP 0x30 |
| 90 | #define MAX6650_COUNT_MASK 0x03 |
| 91 | |
Christian Engelmayer | 52b5226 | 2009-06-15 18:39:52 +0200 | [diff] [blame] | 92 | /* |
| 93 | * Alarm status register bits |
| 94 | */ |
| 95 | |
| 96 | #define MAX6650_ALRM_MAX 0x01 |
| 97 | #define MAX6650_ALRM_MIN 0x02 |
| 98 | #define MAX6650_ALRM_TACH 0x04 |
| 99 | #define MAX6650_ALRM_GPIO1 0x08 |
| 100 | #define MAX6650_ALRM_GPIO2 0x10 |
| 101 | |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 102 | /* Minimum and maximum values of the FAN-RPM */ |
| 103 | #define FAN_RPM_MIN 240 |
| 104 | #define FAN_RPM_MAX 30000 |
| 105 | |
| 106 | #define DIV_FROM_REG(reg) (1 << (reg & 7)) |
| 107 | |
Jean Delvare | 0d57abd | 2008-07-16 19:30:16 +0200 | [diff] [blame] | 108 | static int max6650_probe(struct i2c_client *client, |
| 109 | const struct i2c_device_id *id); |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 110 | static int max6650_init_client(struct i2c_client *client); |
Jean Delvare | 0d57abd | 2008-07-16 19:30:16 +0200 | [diff] [blame] | 111 | static int max6650_remove(struct i2c_client *client); |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 112 | static struct max6650_data *max6650_update_device(struct device *dev); |
| 113 | |
| 114 | /* |
| 115 | * Driver data (common to all clients) |
| 116 | */ |
| 117 | |
Jean Delvare | 0d57abd | 2008-07-16 19:30:16 +0200 | [diff] [blame] | 118 | static const struct i2c_device_id max6650_id[] = { |
Jean Delvare | 9c084da | 2011-05-25 20:43:32 +0200 | [diff] [blame] | 119 | { "max6650", 1 }, |
| 120 | { "max6651", 4 }, |
Jean Delvare | 0d57abd | 2008-07-16 19:30:16 +0200 | [diff] [blame] | 121 | { } |
| 122 | }; |
| 123 | MODULE_DEVICE_TABLE(i2c, max6650_id); |
| 124 | |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 125 | static struct i2c_driver max6650_driver = { |
| 126 | .driver = { |
| 127 | .name = "max6650", |
| 128 | }, |
Jean Delvare | 0d57abd | 2008-07-16 19:30:16 +0200 | [diff] [blame] | 129 | .probe = max6650_probe, |
| 130 | .remove = max6650_remove, |
| 131 | .id_table = max6650_id, |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 132 | }; |
| 133 | |
| 134 | /* |
| 135 | * Client data (each client gets its own) |
| 136 | */ |
| 137 | |
Guenter Roeck | bafda5d | 2012-01-14 21:32:21 -0800 | [diff] [blame] | 138 | struct max6650_data { |
Tony Jones | 1beeffe | 2007-08-20 13:46:20 -0700 | [diff] [blame] | 139 | struct device *hwmon_dev; |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 140 | struct mutex update_lock; |
Jean Delvare | 9c084da | 2011-05-25 20:43:32 +0200 | [diff] [blame] | 141 | int nr_fans; |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 142 | char valid; /* zero until following fields are valid */ |
| 143 | unsigned long last_updated; /* in jiffies */ |
| 144 | |
| 145 | /* register values */ |
| 146 | u8 speed; |
| 147 | u8 config; |
| 148 | u8 tach[4]; |
| 149 | u8 count; |
| 150 | u8 dac; |
Christian Engelmayer | 52b5226 | 2009-06-15 18:39:52 +0200 | [diff] [blame] | 151 | u8 alarm; |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 152 | }; |
| 153 | |
| 154 | static ssize_t get_fan(struct device *dev, struct device_attribute *devattr, |
| 155 | char *buf) |
| 156 | { |
| 157 | struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); |
| 158 | struct max6650_data *data = max6650_update_device(dev); |
| 159 | int rpm; |
| 160 | |
| 161 | /* |
Guenter Roeck | 703af96 | 2012-01-19 11:02:22 -0800 | [diff] [blame] | 162 | * Calculation details: |
| 163 | * |
| 164 | * Each tachometer counts over an interval given by the "count" |
| 165 | * register (0.25, 0.5, 1 or 2 seconds). This module assumes |
| 166 | * that the fans produce two pulses per revolution (this seems |
| 167 | * to be the most common). |
| 168 | */ |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 169 | |
| 170 | rpm = ((data->tach[attr->index] * 120) / DIV_FROM_REG(data->count)); |
| 171 | return sprintf(buf, "%d\n", rpm); |
| 172 | } |
| 173 | |
| 174 | /* |
| 175 | * Set the fan speed to the specified RPM (or read back the RPM setting). |
| 176 | * This works in closed loop mode only. Use pwm1 for open loop speed setting. |
| 177 | * |
| 178 | * The MAX6650/1 will automatically control fan speed when in closed loop |
| 179 | * mode. |
| 180 | * |
| 181 | * Assumptions: |
| 182 | * |
| 183 | * 1) The MAX6650/1 internal 254kHz clock frequency is set correctly. Use |
| 184 | * the clock module parameter if you need to fine tune this. |
| 185 | * |
| 186 | * 2) The prescaler (low three bits of the config register) has already |
| 187 | * been set to an appropriate value. Use the prescaler module parameter |
| 188 | * if your BIOS doesn't initialize the chip properly. |
| 189 | * |
| 190 | * The relevant equations are given on pages 21 and 22 of the datasheet. |
| 191 | * |
| 192 | * From the datasheet, the relevant equation when in regulation is: |
| 193 | * |
| 194 | * [fCLK / (128 x (KTACH + 1))] = 2 x FanSpeed / KSCALE |
| 195 | * |
| 196 | * where: |
| 197 | * |
| 198 | * fCLK is the oscillator frequency (either the 254kHz internal |
| 199 | * oscillator or the externally applied clock) |
| 200 | * |
| 201 | * KTACH is the value in the speed register |
| 202 | * |
| 203 | * FanSpeed is the speed of the fan in rps |
| 204 | * |
| 205 | * KSCALE is the prescaler value (1, 2, 4, 8, or 16) |
| 206 | * |
| 207 | * When reading, we need to solve for FanSpeed. When writing, we need to |
| 208 | * solve for KTACH. |
| 209 | * |
| 210 | * Note: this tachometer is completely separate from the tachometers |
| 211 | * used to measure the fan speeds. Only one fan's speed (fan1) is |
| 212 | * controlled. |
| 213 | */ |
| 214 | |
| 215 | static ssize_t get_target(struct device *dev, struct device_attribute *devattr, |
| 216 | char *buf) |
| 217 | { |
| 218 | struct max6650_data *data = max6650_update_device(dev); |
| 219 | int kscale, ktach, rpm; |
| 220 | |
| 221 | /* |
Guenter Roeck | 703af96 | 2012-01-19 11:02:22 -0800 | [diff] [blame] | 222 | * Use the datasheet equation: |
| 223 | * |
| 224 | * FanSpeed = KSCALE x fCLK / [256 x (KTACH + 1)] |
| 225 | * |
| 226 | * then multiply by 60 to give rpm. |
| 227 | */ |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 228 | |
| 229 | kscale = DIV_FROM_REG(data->config); |
| 230 | ktach = data->speed; |
| 231 | rpm = 60 * kscale * clock / (256 * (ktach + 1)); |
| 232 | return sprintf(buf, "%d\n", rpm); |
| 233 | } |
| 234 | |
| 235 | static ssize_t set_target(struct device *dev, struct device_attribute *devattr, |
| 236 | const char *buf, size_t count) |
| 237 | { |
| 238 | struct i2c_client *client = to_i2c_client(dev); |
| 239 | struct max6650_data *data = i2c_get_clientdata(client); |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 240 | int kscale, ktach; |
Guenter Roeck | bafda5d | 2012-01-14 21:32:21 -0800 | [diff] [blame] | 241 | unsigned long rpm; |
| 242 | int err; |
| 243 | |
| 244 | err = kstrtoul(buf, 10, &rpm); |
| 245 | if (err) |
| 246 | return err; |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 247 | |
Guenter Roeck | 2a844c1 | 2013-01-09 08:09:34 -0800 | [diff] [blame] | 248 | rpm = clamp_val(rpm, FAN_RPM_MIN, FAN_RPM_MAX); |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 249 | |
| 250 | /* |
Guenter Roeck | 703af96 | 2012-01-19 11:02:22 -0800 | [diff] [blame] | 251 | * Divide the required speed by 60 to get from rpm to rps, then |
| 252 | * use the datasheet equation: |
| 253 | * |
| 254 | * KTACH = [(fCLK x KSCALE) / (256 x FanSpeed)] - 1 |
| 255 | */ |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 256 | |
| 257 | mutex_lock(&data->update_lock); |
| 258 | |
| 259 | kscale = DIV_FROM_REG(data->config); |
| 260 | ktach = ((clock * kscale) / (256 * rpm / 60)) - 1; |
| 261 | if (ktach < 0) |
| 262 | ktach = 0; |
| 263 | if (ktach > 255) |
| 264 | ktach = 255; |
| 265 | data->speed = ktach; |
| 266 | |
| 267 | i2c_smbus_write_byte_data(client, MAX6650_REG_SPEED, data->speed); |
| 268 | |
| 269 | mutex_unlock(&data->update_lock); |
| 270 | |
| 271 | return count; |
| 272 | } |
| 273 | |
| 274 | /* |
| 275 | * Get/set the fan speed in open loop mode using pwm1 sysfs file. |
| 276 | * Speed is given as a relative value from 0 to 255, where 255 is maximum |
| 277 | * speed. Note that this is done by writing directly to the chip's DAC, |
| 278 | * it won't change the closed loop speed set by fan1_target. |
| 279 | * Also note that due to rounding errors it is possible that you don't read |
| 280 | * back exactly the value you have set. |
| 281 | */ |
| 282 | |
| 283 | static ssize_t get_pwm(struct device *dev, struct device_attribute *devattr, |
| 284 | char *buf) |
| 285 | { |
| 286 | int pwm; |
| 287 | struct max6650_data *data = max6650_update_device(dev); |
| 288 | |
Guenter Roeck | 703af96 | 2012-01-19 11:02:22 -0800 | [diff] [blame] | 289 | /* |
| 290 | * Useful range for dac is 0-180 for 12V fans and 0-76 for 5V fans. |
| 291 | * Lower DAC values mean higher speeds. |
| 292 | */ |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 293 | if (data->config & MAX6650_CFG_V12) |
| 294 | pwm = 255 - (255 * (int)data->dac)/180; |
| 295 | else |
| 296 | pwm = 255 - (255 * (int)data->dac)/76; |
| 297 | |
| 298 | if (pwm < 0) |
| 299 | pwm = 0; |
| 300 | |
| 301 | return sprintf(buf, "%d\n", pwm); |
| 302 | } |
| 303 | |
| 304 | static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr, |
| 305 | const char *buf, size_t count) |
| 306 | { |
| 307 | struct i2c_client *client = to_i2c_client(dev); |
| 308 | struct max6650_data *data = i2c_get_clientdata(client); |
Guenter Roeck | bafda5d | 2012-01-14 21:32:21 -0800 | [diff] [blame] | 309 | unsigned long pwm; |
| 310 | int err; |
| 311 | |
| 312 | err = kstrtoul(buf, 10, &pwm); |
| 313 | if (err) |
| 314 | return err; |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 315 | |
Guenter Roeck | 2a844c1 | 2013-01-09 08:09:34 -0800 | [diff] [blame] | 316 | pwm = clamp_val(pwm, 0, 255); |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 317 | |
| 318 | mutex_lock(&data->update_lock); |
| 319 | |
| 320 | if (data->config & MAX6650_CFG_V12) |
| 321 | data->dac = 180 - (180 * pwm)/255; |
| 322 | else |
| 323 | data->dac = 76 - (76 * pwm)/255; |
| 324 | |
| 325 | i2c_smbus_write_byte_data(client, MAX6650_REG_DAC, data->dac); |
| 326 | |
| 327 | mutex_unlock(&data->update_lock); |
| 328 | |
| 329 | return count; |
| 330 | } |
| 331 | |
| 332 | /* |
| 333 | * Get/Set controller mode: |
| 334 | * Possible values: |
| 335 | * 0 = Fan always on |
| 336 | * 1 = Open loop, Voltage is set according to speed, not regulated. |
| 337 | * 2 = Closed loop, RPM for all fans regulated by fan1 tachometer |
| 338 | */ |
| 339 | |
| 340 | static ssize_t get_enable(struct device *dev, struct device_attribute *devattr, |
| 341 | char *buf) |
| 342 | { |
| 343 | struct max6650_data *data = max6650_update_device(dev); |
| 344 | int mode = (data->config & MAX6650_CFG_MODE_MASK) >> 4; |
| 345 | int sysfs_modes[4] = {0, 1, 2, 1}; |
| 346 | |
| 347 | return sprintf(buf, "%d\n", sysfs_modes[mode]); |
| 348 | } |
| 349 | |
| 350 | static ssize_t set_enable(struct device *dev, struct device_attribute *devattr, |
| 351 | const char *buf, size_t count) |
| 352 | { |
| 353 | struct i2c_client *client = to_i2c_client(dev); |
| 354 | struct max6650_data *data = i2c_get_clientdata(client); |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 355 | int max6650_modes[3] = {0, 3, 2}; |
Guenter Roeck | bafda5d | 2012-01-14 21:32:21 -0800 | [diff] [blame] | 356 | unsigned long mode; |
| 357 | int err; |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 358 | |
Guenter Roeck | bafda5d | 2012-01-14 21:32:21 -0800 | [diff] [blame] | 359 | err = kstrtoul(buf, 10, &mode); |
| 360 | if (err) |
| 361 | return err; |
| 362 | |
| 363 | if (mode > 2) |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 364 | return -EINVAL; |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 365 | |
| 366 | mutex_lock(&data->update_lock); |
| 367 | |
| 368 | data->config = i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG); |
| 369 | data->config = (data->config & ~MAX6650_CFG_MODE_MASK) |
| 370 | | (max6650_modes[mode] << 4); |
| 371 | |
| 372 | i2c_smbus_write_byte_data(client, MAX6650_REG_CONFIG, data->config); |
| 373 | |
| 374 | mutex_unlock(&data->update_lock); |
| 375 | |
| 376 | return count; |
| 377 | } |
| 378 | |
| 379 | /* |
| 380 | * Read/write functions for fan1_div sysfs file. The MAX6650 has no such |
| 381 | * divider. We handle this by converting between divider and counttime: |
| 382 | * |
| 383 | * (counttime == k) <==> (divider == 2^k), k = 0, 1, 2, or 3 |
| 384 | * |
| 385 | * Lower values of k allow to connect a faster fan without the risk of |
| 386 | * counter overflow. The price is lower resolution. You can also set counttime |
| 387 | * using the module parameter. Note that the module parameter "prescaler" also |
| 388 | * influences the behaviour. Unfortunately, there's no sysfs attribute |
| 389 | * defined for that. See the data sheet for details. |
| 390 | */ |
| 391 | |
| 392 | static ssize_t get_div(struct device *dev, struct device_attribute *devattr, |
| 393 | char *buf) |
| 394 | { |
| 395 | struct max6650_data *data = max6650_update_device(dev); |
| 396 | |
| 397 | return sprintf(buf, "%d\n", DIV_FROM_REG(data->count)); |
| 398 | } |
| 399 | |
| 400 | static ssize_t set_div(struct device *dev, struct device_attribute *devattr, |
| 401 | const char *buf, size_t count) |
| 402 | { |
| 403 | struct i2c_client *client = to_i2c_client(dev); |
| 404 | struct max6650_data *data = i2c_get_clientdata(client); |
Guenter Roeck | bafda5d | 2012-01-14 21:32:21 -0800 | [diff] [blame] | 405 | unsigned long div; |
| 406 | int err; |
| 407 | |
| 408 | err = kstrtoul(buf, 10, &div); |
| 409 | if (err) |
| 410 | return err; |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 411 | |
| 412 | mutex_lock(&data->update_lock); |
| 413 | switch (div) { |
| 414 | case 1: |
| 415 | data->count = 0; |
| 416 | break; |
| 417 | case 2: |
| 418 | data->count = 1; |
| 419 | break; |
| 420 | case 4: |
| 421 | data->count = 2; |
| 422 | break; |
| 423 | case 8: |
| 424 | data->count = 3; |
| 425 | break; |
| 426 | default: |
Jiri Slaby | 025dc74 | 2009-07-11 13:42:37 +0200 | [diff] [blame] | 427 | mutex_unlock(&data->update_lock); |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 428 | return -EINVAL; |
| 429 | } |
| 430 | |
| 431 | i2c_smbus_write_byte_data(client, MAX6650_REG_COUNT, data->count); |
| 432 | mutex_unlock(&data->update_lock); |
| 433 | |
| 434 | return count; |
| 435 | } |
| 436 | |
Christian Engelmayer | 52b5226 | 2009-06-15 18:39:52 +0200 | [diff] [blame] | 437 | /* |
| 438 | * Get alarm stati: |
| 439 | * Possible values: |
| 440 | * 0 = no alarm |
| 441 | * 1 = alarm |
| 442 | */ |
| 443 | |
| 444 | static ssize_t get_alarm(struct device *dev, struct device_attribute *devattr, |
| 445 | char *buf) |
| 446 | { |
| 447 | struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); |
| 448 | struct max6650_data *data = max6650_update_device(dev); |
| 449 | struct i2c_client *client = to_i2c_client(dev); |
| 450 | int alarm = 0; |
| 451 | |
| 452 | if (data->alarm & attr->index) { |
| 453 | mutex_lock(&data->update_lock); |
| 454 | alarm = 1; |
| 455 | data->alarm &= ~attr->index; |
| 456 | data->alarm |= i2c_smbus_read_byte_data(client, |
| 457 | MAX6650_REG_ALARM); |
| 458 | mutex_unlock(&data->update_lock); |
| 459 | } |
| 460 | |
| 461 | return sprintf(buf, "%d\n", alarm); |
| 462 | } |
| 463 | |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 464 | static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan, NULL, 0); |
| 465 | static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, get_fan, NULL, 1); |
| 466 | static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, get_fan, NULL, 2); |
| 467 | static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, get_fan, NULL, 3); |
| 468 | static DEVICE_ATTR(fan1_target, S_IWUSR | S_IRUGO, get_target, set_target); |
| 469 | static DEVICE_ATTR(fan1_div, S_IWUSR | S_IRUGO, get_div, set_div); |
| 470 | static DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, get_enable, set_enable); |
| 471 | static DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, get_pwm, set_pwm); |
Christian Engelmayer | 52b5226 | 2009-06-15 18:39:52 +0200 | [diff] [blame] | 472 | static SENSOR_DEVICE_ATTR(fan1_max_alarm, S_IRUGO, get_alarm, NULL, |
| 473 | MAX6650_ALRM_MAX); |
| 474 | static SENSOR_DEVICE_ATTR(fan1_min_alarm, S_IRUGO, get_alarm, NULL, |
| 475 | MAX6650_ALRM_MIN); |
| 476 | static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, get_alarm, NULL, |
| 477 | MAX6650_ALRM_TACH); |
| 478 | static SENSOR_DEVICE_ATTR(gpio1_alarm, S_IRUGO, get_alarm, NULL, |
| 479 | MAX6650_ALRM_GPIO1); |
| 480 | static SENSOR_DEVICE_ATTR(gpio2_alarm, S_IRUGO, get_alarm, NULL, |
| 481 | MAX6650_ALRM_GPIO2); |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 482 | |
Al Viro | 587a1f1 | 2011-07-23 23:11:19 -0400 | [diff] [blame] | 483 | static umode_t max6650_attrs_visible(struct kobject *kobj, struct attribute *a, |
Christian Engelmayer | 52b5226 | 2009-06-15 18:39:52 +0200 | [diff] [blame] | 484 | int n) |
| 485 | { |
| 486 | struct device *dev = container_of(kobj, struct device, kobj); |
| 487 | struct i2c_client *client = to_i2c_client(dev); |
| 488 | u8 alarm_en = i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM_EN); |
| 489 | struct device_attribute *devattr; |
| 490 | |
| 491 | /* |
| 492 | * Hide the alarms that have not been enabled by the firmware |
| 493 | */ |
| 494 | |
| 495 | devattr = container_of(a, struct device_attribute, attr); |
| 496 | if (devattr == &sensor_dev_attr_fan1_max_alarm.dev_attr |
| 497 | || devattr == &sensor_dev_attr_fan1_min_alarm.dev_attr |
| 498 | || devattr == &sensor_dev_attr_fan1_fault.dev_attr |
| 499 | || devattr == &sensor_dev_attr_gpio1_alarm.dev_attr |
| 500 | || devattr == &sensor_dev_attr_gpio2_alarm.dev_attr) { |
| 501 | if (!(alarm_en & to_sensor_dev_attr(devattr)->index)) |
| 502 | return 0; |
| 503 | } |
| 504 | |
| 505 | return a->mode; |
| 506 | } |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 507 | |
| 508 | static struct attribute *max6650_attrs[] = { |
| 509 | &sensor_dev_attr_fan1_input.dev_attr.attr, |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 510 | &dev_attr_fan1_target.attr, |
| 511 | &dev_attr_fan1_div.attr, |
| 512 | &dev_attr_pwm1_enable.attr, |
| 513 | &dev_attr_pwm1.attr, |
Christian Engelmayer | 52b5226 | 2009-06-15 18:39:52 +0200 | [diff] [blame] | 514 | &sensor_dev_attr_fan1_max_alarm.dev_attr.attr, |
| 515 | &sensor_dev_attr_fan1_min_alarm.dev_attr.attr, |
| 516 | &sensor_dev_attr_fan1_fault.dev_attr.attr, |
| 517 | &sensor_dev_attr_gpio1_alarm.dev_attr.attr, |
| 518 | &sensor_dev_attr_gpio2_alarm.dev_attr.attr, |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 519 | NULL |
| 520 | }; |
| 521 | |
| 522 | static struct attribute_group max6650_attr_grp = { |
| 523 | .attrs = max6650_attrs, |
Christian Engelmayer | 52b5226 | 2009-06-15 18:39:52 +0200 | [diff] [blame] | 524 | .is_visible = max6650_attrs_visible, |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 525 | }; |
| 526 | |
Jean Delvare | 9c084da | 2011-05-25 20:43:32 +0200 | [diff] [blame] | 527 | static struct attribute *max6651_attrs[] = { |
| 528 | &sensor_dev_attr_fan2_input.dev_attr.attr, |
| 529 | &sensor_dev_attr_fan3_input.dev_attr.attr, |
| 530 | &sensor_dev_attr_fan4_input.dev_attr.attr, |
| 531 | NULL |
| 532 | }; |
| 533 | |
| 534 | static const struct attribute_group max6651_attr_grp = { |
| 535 | .attrs = max6651_attrs, |
| 536 | }; |
| 537 | |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 538 | /* |
| 539 | * Real code |
| 540 | */ |
| 541 | |
Jean Delvare | 0d57abd | 2008-07-16 19:30:16 +0200 | [diff] [blame] | 542 | static int max6650_probe(struct i2c_client *client, |
| 543 | const struct i2c_device_id *id) |
| 544 | { |
| 545 | struct max6650_data *data; |
| 546 | int err; |
| 547 | |
Guenter Roeck | 94cd520 | 2012-06-02 09:58:13 -0700 | [diff] [blame] | 548 | data = devm_kzalloc(&client->dev, sizeof(struct max6650_data), |
| 549 | GFP_KERNEL); |
Guenter Roeck | bafda5d | 2012-01-14 21:32:21 -0800 | [diff] [blame] | 550 | if (!data) { |
Jean Delvare | 0d57abd | 2008-07-16 19:30:16 +0200 | [diff] [blame] | 551 | dev_err(&client->dev, "out of memory.\n"); |
| 552 | return -ENOMEM; |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 553 | } |
| 554 | |
Jean Delvare | 0d57abd | 2008-07-16 19:30:16 +0200 | [diff] [blame] | 555 | i2c_set_clientdata(client, data); |
| 556 | mutex_init(&data->update_lock); |
Jean Delvare | 9c084da | 2011-05-25 20:43:32 +0200 | [diff] [blame] | 557 | data->nr_fans = id->driver_data; |
Jean Delvare | 0d57abd | 2008-07-16 19:30:16 +0200 | [diff] [blame] | 558 | |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 559 | /* |
| 560 | * Initialize the max6650 chip |
| 561 | */ |
Jean Delvare | 0d57abd | 2008-07-16 19:30:16 +0200 | [diff] [blame] | 562 | err = max6650_init_client(client); |
| 563 | if (err) |
Guenter Roeck | 94cd520 | 2012-06-02 09:58:13 -0700 | [diff] [blame] | 564 | return err; |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 565 | |
| 566 | err = sysfs_create_group(&client->dev.kobj, &max6650_attr_grp); |
| 567 | if (err) |
Guenter Roeck | 94cd520 | 2012-06-02 09:58:13 -0700 | [diff] [blame] | 568 | return err; |
Jean Delvare | 9c084da | 2011-05-25 20:43:32 +0200 | [diff] [blame] | 569 | /* 3 additional fan inputs for the MAX6651 */ |
| 570 | if (data->nr_fans == 4) { |
| 571 | err = sysfs_create_group(&client->dev.kobj, &max6651_attr_grp); |
| 572 | if (err) |
| 573 | goto err_remove; |
| 574 | } |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 575 | |
Tony Jones | 1beeffe | 2007-08-20 13:46:20 -0700 | [diff] [blame] | 576 | data->hwmon_dev = hwmon_device_register(&client->dev); |
| 577 | if (!IS_ERR(data->hwmon_dev)) |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 578 | return 0; |
| 579 | |
Tony Jones | 1beeffe | 2007-08-20 13:46:20 -0700 | [diff] [blame] | 580 | err = PTR_ERR(data->hwmon_dev); |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 581 | dev_err(&client->dev, "error registering hwmon device.\n"); |
Jean Delvare | 9c084da | 2011-05-25 20:43:32 +0200 | [diff] [blame] | 582 | if (data->nr_fans == 4) |
| 583 | sysfs_remove_group(&client->dev.kobj, &max6651_attr_grp); |
| 584 | err_remove: |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 585 | sysfs_remove_group(&client->dev.kobj, &max6650_attr_grp); |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 586 | return err; |
| 587 | } |
| 588 | |
Jean Delvare | 0d57abd | 2008-07-16 19:30:16 +0200 | [diff] [blame] | 589 | static int max6650_remove(struct i2c_client *client) |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 590 | { |
| 591 | struct max6650_data *data = i2c_get_clientdata(client); |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 592 | |
Tony Jones | 1beeffe | 2007-08-20 13:46:20 -0700 | [diff] [blame] | 593 | hwmon_device_unregister(data->hwmon_dev); |
Jean Delvare | 9c084da | 2011-05-25 20:43:32 +0200 | [diff] [blame] | 594 | if (data->nr_fans == 4) |
| 595 | sysfs_remove_group(&client->dev.kobj, &max6651_attr_grp); |
| 596 | sysfs_remove_group(&client->dev.kobj, &max6650_attr_grp); |
Jean Delvare | 0d57abd | 2008-07-16 19:30:16 +0200 | [diff] [blame] | 597 | return 0; |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 598 | } |
| 599 | |
| 600 | static int max6650_init_client(struct i2c_client *client) |
| 601 | { |
| 602 | struct max6650_data *data = i2c_get_clientdata(client); |
| 603 | int config; |
| 604 | int err = -EIO; |
| 605 | |
| 606 | config = i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG); |
| 607 | |
| 608 | if (config < 0) { |
| 609 | dev_err(&client->dev, "Error reading config, aborting.\n"); |
| 610 | return err; |
| 611 | } |
| 612 | |
| 613 | switch (fan_voltage) { |
Guenter Roeck | bafda5d | 2012-01-14 21:32:21 -0800 | [diff] [blame] | 614 | case 0: |
| 615 | break; |
| 616 | case 5: |
| 617 | config &= ~MAX6650_CFG_V12; |
| 618 | break; |
| 619 | case 12: |
| 620 | config |= MAX6650_CFG_V12; |
| 621 | break; |
| 622 | default: |
| 623 | dev_err(&client->dev, "illegal value for fan_voltage (%d)\n", |
| 624 | fan_voltage); |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 625 | } |
| 626 | |
| 627 | dev_info(&client->dev, "Fan voltage is set to %dV.\n", |
| 628 | (config & MAX6650_CFG_V12) ? 12 : 5); |
| 629 | |
| 630 | switch (prescaler) { |
Guenter Roeck | bafda5d | 2012-01-14 21:32:21 -0800 | [diff] [blame] | 631 | case 0: |
| 632 | break; |
| 633 | case 1: |
| 634 | config &= ~MAX6650_CFG_PRESCALER_MASK; |
| 635 | break; |
| 636 | case 2: |
| 637 | config = (config & ~MAX6650_CFG_PRESCALER_MASK) |
| 638 | | MAX6650_CFG_PRESCALER_2; |
| 639 | break; |
| 640 | case 4: |
| 641 | config = (config & ~MAX6650_CFG_PRESCALER_MASK) |
| 642 | | MAX6650_CFG_PRESCALER_4; |
| 643 | break; |
| 644 | case 8: |
| 645 | config = (config & ~MAX6650_CFG_PRESCALER_MASK) |
| 646 | | MAX6650_CFG_PRESCALER_8; |
| 647 | break; |
| 648 | case 16: |
| 649 | config = (config & ~MAX6650_CFG_PRESCALER_MASK) |
| 650 | | MAX6650_CFG_PRESCALER_16; |
| 651 | break; |
| 652 | default: |
| 653 | dev_err(&client->dev, "illegal value for prescaler (%d)\n", |
| 654 | prescaler); |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 655 | } |
| 656 | |
| 657 | dev_info(&client->dev, "Prescaler is set to %d.\n", |
| 658 | 1 << (config & MAX6650_CFG_PRESCALER_MASK)); |
| 659 | |
Guenter Roeck | 703af96 | 2012-01-19 11:02:22 -0800 | [diff] [blame] | 660 | /* |
| 661 | * If mode is set to "full off", we change it to "open loop" and |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 662 | * set DAC to 255, which has the same effect. We do this because |
LABBE Corentin | 84fb029 | 2013-09-27 14:36:04 +0200 | [diff] [blame] | 663 | * there's no "full off" mode defined in hwmon specifications. |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 664 | */ |
| 665 | |
| 666 | if ((config & MAX6650_CFG_MODE_MASK) == MAX6650_CFG_MODE_OFF) { |
| 667 | dev_dbg(&client->dev, "Change mode to open loop, full off.\n"); |
| 668 | config = (config & ~MAX6650_CFG_MODE_MASK) |
| 669 | | MAX6650_CFG_MODE_OPEN_LOOP; |
| 670 | if (i2c_smbus_write_byte_data(client, MAX6650_REG_DAC, 255)) { |
| 671 | dev_err(&client->dev, "DAC write error, aborting.\n"); |
| 672 | return err; |
| 673 | } |
| 674 | } |
| 675 | |
| 676 | if (i2c_smbus_write_byte_data(client, MAX6650_REG_CONFIG, config)) { |
| 677 | dev_err(&client->dev, "Config write error, aborting.\n"); |
| 678 | return err; |
| 679 | } |
| 680 | |
| 681 | data->config = config; |
| 682 | data->count = i2c_smbus_read_byte_data(client, MAX6650_REG_COUNT); |
| 683 | |
| 684 | return 0; |
| 685 | } |
| 686 | |
| 687 | static const u8 tach_reg[] = { |
| 688 | MAX6650_REG_TACH0, |
| 689 | MAX6650_REG_TACH1, |
| 690 | MAX6650_REG_TACH2, |
| 691 | MAX6650_REG_TACH3, |
| 692 | }; |
| 693 | |
| 694 | static struct max6650_data *max6650_update_device(struct device *dev) |
| 695 | { |
| 696 | int i; |
| 697 | struct i2c_client *client = to_i2c_client(dev); |
| 698 | struct max6650_data *data = i2c_get_clientdata(client); |
| 699 | |
| 700 | mutex_lock(&data->update_lock); |
| 701 | |
| 702 | if (time_after(jiffies, data->last_updated + HZ) || !data->valid) { |
| 703 | data->speed = i2c_smbus_read_byte_data(client, |
| 704 | MAX6650_REG_SPEED); |
| 705 | data->config = i2c_smbus_read_byte_data(client, |
| 706 | MAX6650_REG_CONFIG); |
Jean Delvare | 9c084da | 2011-05-25 20:43:32 +0200 | [diff] [blame] | 707 | for (i = 0; i < data->nr_fans; i++) { |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 708 | data->tach[i] = i2c_smbus_read_byte_data(client, |
| 709 | tach_reg[i]); |
| 710 | } |
| 711 | data->count = i2c_smbus_read_byte_data(client, |
| 712 | MAX6650_REG_COUNT); |
| 713 | data->dac = i2c_smbus_read_byte_data(client, MAX6650_REG_DAC); |
| 714 | |
Guenter Roeck | 703af96 | 2012-01-19 11:02:22 -0800 | [diff] [blame] | 715 | /* |
| 716 | * Alarms are cleared on read in case the condition that |
Christian Engelmayer | 52b5226 | 2009-06-15 18:39:52 +0200 | [diff] [blame] | 717 | * caused the alarm is removed. Keep the value latched here |
Guenter Roeck | 703af96 | 2012-01-19 11:02:22 -0800 | [diff] [blame] | 718 | * for providing the register through different alarm files. |
| 719 | */ |
Christian Engelmayer | 52b5226 | 2009-06-15 18:39:52 +0200 | [diff] [blame] | 720 | data->alarm |= i2c_smbus_read_byte_data(client, |
| 721 | MAX6650_REG_ALARM); |
| 722 | |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 723 | data->last_updated = jiffies; |
| 724 | data->valid = 1; |
| 725 | } |
| 726 | |
| 727 | mutex_unlock(&data->update_lock); |
| 728 | |
| 729 | return data; |
| 730 | } |
| 731 | |
Axel Lin | f0967ee | 2012-01-20 15:38:18 +0800 | [diff] [blame] | 732 | module_i2c_driver(max6650_driver); |
Hans-Juergen Koch | d20620d | 2007-05-08 17:22:00 +0200 | [diff] [blame] | 733 | |
| 734 | MODULE_AUTHOR("Hans J. Koch"); |
| 735 | MODULE_DESCRIPTION("MAX6650 sensor driver"); |
| 736 | MODULE_LICENSE("GPL"); |