linux/drivers/hwmon/gl520sm.c
<<
>>
Prefs
   1/*
   2 * gl520sm.c - Part of lm_sensors, Linux kernel modules for hardware
   3 *             monitoring
   4 * Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>,
   5 *                           Kyösti Mälkki <kmalkki@cc.hut.fi>
   6 * Copyright (c) 2005   Maarten Deprez <maartendeprez@users.sourceforge.net>
   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; either version 2 of the License, or
  11 * (at your option) any later version.
  12 *
  13 * This program is distributed in the hope that it will be useful,
  14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 * GNU General Public License for more details.
  17 *
  18 * You should have received a copy of the GNU General Public License
  19 * along with this program; if not, write to the Free Software
  20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 *
  22 */
  23
  24#include <linux/module.h>
  25#include <linux/init.h>
  26#include <linux/slab.h>
  27#include <linux/jiffies.h>
  28#include <linux/i2c.h>
  29#include <linux/hwmon.h>
  30#include <linux/hwmon-sysfs.h>
  31#include <linux/hwmon-vid.h>
  32#include <linux/err.h>
  33#include <linux/mutex.h>
  34#include <linux/sysfs.h>
  35
  36/* Type of the extra sensor */
  37static unsigned short extra_sensor_type;
  38module_param(extra_sensor_type, ushort, 0);
  39MODULE_PARM_DESC(extra_sensor_type, "Type of extra sensor (0=autodetect, 1=temperature, 2=voltage)");
  40
  41/* Addresses to scan */
  42static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };
  43
  44/*
  45 * Many GL520 constants specified below
  46 * One of the inputs can be configured as either temp or voltage.
  47 * That's why _TEMP2 and _IN4 access the same register
  48 */
  49
  50/* The GL520 registers */
  51#define GL520_REG_CHIP_ID               0x00
  52#define GL520_REG_REVISION              0x01
  53#define GL520_REG_CONF                  0x03
  54#define GL520_REG_MASK                  0x11
  55
  56#define GL520_REG_VID_INPUT             0x02
  57
  58static const u8 GL520_REG_IN_INPUT[]    = { 0x15, 0x14, 0x13, 0x0d, 0x0e };
  59static const u8 GL520_REG_IN_LIMIT[]    = { 0x0c, 0x09, 0x0a, 0x0b };
  60static const u8 GL520_REG_IN_MIN[]      = { 0x0c, 0x09, 0x0a, 0x0b, 0x18 };
  61static const u8 GL520_REG_IN_MAX[]      = { 0x0c, 0x09, 0x0a, 0x0b, 0x17 };
  62
  63static const u8 GL520_REG_TEMP_INPUT[]          = { 0x04, 0x0e };
  64static const u8 GL520_REG_TEMP_MAX[]            = { 0x05, 0x17 };
  65static const u8 GL520_REG_TEMP_MAX_HYST[]       = { 0x06, 0x18 };
  66
  67#define GL520_REG_FAN_INPUT             0x07
  68#define GL520_REG_FAN_MIN               0x08
  69#define GL520_REG_FAN_DIV               0x0f
  70#define GL520_REG_FAN_OFF               GL520_REG_FAN_DIV
  71
  72#define GL520_REG_ALARMS                0x12
  73#define GL520_REG_BEEP_MASK             0x10
  74#define GL520_REG_BEEP_ENABLE           GL520_REG_CONF
  75
  76/*
  77 * Function declarations
  78 */
  79
  80static int gl520_probe(struct i2c_client *client,
  81                       const struct i2c_device_id *id);
  82static int gl520_detect(struct i2c_client *client, struct i2c_board_info *info);
  83static void gl520_init_client(struct i2c_client *client);
  84static int gl520_remove(struct i2c_client *client);
  85static int gl520_read_value(struct i2c_client *client, u8 reg);
  86static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value);
  87static struct gl520_data *gl520_update_device(struct device *dev);
  88
  89/* Driver data */
  90static const struct i2c_device_id gl520_id[] = {
  91        { "gl520sm", 0 },
  92        { }
  93};
  94MODULE_DEVICE_TABLE(i2c, gl520_id);
  95
  96static struct i2c_driver gl520_driver = {
  97        .class          = I2C_CLASS_HWMON,
  98        .driver = {
  99                .name   = "gl520sm",
 100        },
 101        .probe          = gl520_probe,
 102        .remove         = gl520_remove,
 103        .id_table       = gl520_id,
 104        .detect         = gl520_detect,
 105        .address_list   = normal_i2c,
 106};
 107
 108/* Client data */
 109struct gl520_data {
 110        struct device *hwmon_dev;
 111        struct mutex update_lock;
 112        char valid;             /* zero until the following fields are valid */
 113        unsigned long last_updated;     /* in jiffies */
 114
 115        u8 vid;
 116        u8 vrm;
 117        u8 in_input[5];         /* [0] = VVD */
 118        u8 in_min[5];           /* [0] = VDD */
 119        u8 in_max[5];           /* [0] = VDD */
 120        u8 fan_input[2];
 121        u8 fan_min[2];
 122        u8 fan_div[2];
 123        u8 fan_off;
 124        u8 temp_input[2];
 125        u8 temp_max[2];
 126        u8 temp_max_hyst[2];
 127        u8 alarms;
 128        u8 beep_enable;
 129        u8 beep_mask;
 130        u8 alarm_mask;
 131        u8 two_temps;
 132};
 133
 134/*
 135 * Sysfs stuff
 136 */
 137
 138static ssize_t get_cpu_vid(struct device *dev, struct device_attribute *attr,
 139                           char *buf)
 140{
 141        struct gl520_data *data = gl520_update_device(dev);
 142        return sprintf(buf, "%u\n", vid_from_reg(data->vid, data->vrm));
 143}
 144static DEVICE_ATTR(cpu0_vid, S_IRUGO, get_cpu_vid, NULL);
 145
 146#define VDD_FROM_REG(val) (((val) * 95 + 2) / 4)
 147#define VDD_TO_REG(val) clamp_val((((val) * 4 + 47) / 95), 0, 255)
 148
 149#define IN_FROM_REG(val) ((val) * 19)
 150#define IN_TO_REG(val) clamp_val((((val) + 9) / 19), 0, 255)
 151
 152static ssize_t get_in_input(struct device *dev, struct device_attribute *attr,
 153                            char *buf)
 154{
 155        int n = to_sensor_dev_attr(attr)->index;
 156        struct gl520_data *data = gl520_update_device(dev);
 157        u8 r = data->in_input[n];
 158
 159        if (n == 0)
 160                return sprintf(buf, "%d\n", VDD_FROM_REG(r));
 161        else
 162                return sprintf(buf, "%d\n", IN_FROM_REG(r));
 163}
 164
 165static ssize_t get_in_min(struct device *dev, struct device_attribute *attr,
 166                          char *buf)
 167{
 168        int n = to_sensor_dev_attr(attr)->index;
 169        struct gl520_data *data = gl520_update_device(dev);
 170        u8 r = data->in_min[n];
 171
 172        if (n == 0)
 173                return sprintf(buf, "%d\n", VDD_FROM_REG(r));
 174        else
 175                return sprintf(buf, "%d\n", IN_FROM_REG(r));
 176}
 177
 178static ssize_t get_in_max(struct device *dev, struct device_attribute *attr,
 179                          char *buf)
 180{
 181        int n = to_sensor_dev_attr(attr)->index;
 182        struct gl520_data *data = gl520_update_device(dev);
 183        u8 r = data->in_max[n];
 184
 185        if (n == 0)
 186                return sprintf(buf, "%d\n", VDD_FROM_REG(r));
 187        else
 188                return sprintf(buf, "%d\n", IN_FROM_REG(r));
 189}
 190
 191static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
 192                          const char *buf, size_t count)
 193{
 194        struct i2c_client *client = to_i2c_client(dev);
 195        struct gl520_data *data = i2c_get_clientdata(client);
 196        int n = to_sensor_dev_attr(attr)->index;
 197        u8 r;
 198        long v;
 199        int err;
 200
 201        err = kstrtol(buf, 10, &v);
 202        if (err)
 203                return err;
 204
 205        mutex_lock(&data->update_lock);
 206
 207        if (n == 0)
 208                r = VDD_TO_REG(v);
 209        else
 210                r = IN_TO_REG(v);
 211
 212        data->in_min[n] = r;
 213
 214        if (n < 4)
 215                gl520_write_value(client, GL520_REG_IN_MIN[n],
 216                                  (gl520_read_value(client, GL520_REG_IN_MIN[n])
 217                                   & ~0xff) | r);
 218        else
 219                gl520_write_value(client, GL520_REG_IN_MIN[n], r);
 220
 221        mutex_unlock(&data->update_lock);
 222        return count;
 223}
 224
 225static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
 226                          const char *buf, size_t count)
 227{
 228        struct i2c_client *client = to_i2c_client(dev);
 229        struct gl520_data *data = i2c_get_clientdata(client);
 230        int n = to_sensor_dev_attr(attr)->index;
 231        u8 r;
 232        long v;
 233        int err;
 234
 235        err = kstrtol(buf, 10, &v);
 236        if (err)
 237                return err;
 238
 239        if (n == 0)
 240                r = VDD_TO_REG(v);
 241        else
 242                r = IN_TO_REG(v);
 243
 244        mutex_lock(&data->update_lock);
 245
 246        data->in_max[n] = r;
 247
 248        if (n < 4)
 249                gl520_write_value(client, GL520_REG_IN_MAX[n],
 250                                  (gl520_read_value(client, GL520_REG_IN_MAX[n])
 251                                   & ~0xff00) | (r << 8));
 252        else
 253                gl520_write_value(client, GL520_REG_IN_MAX[n], r);
 254
 255        mutex_unlock(&data->update_lock);
 256        return count;
 257}
 258
 259static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, get_in_input, NULL, 0);
 260static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, get_in_input, NULL, 1);
 261static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, get_in_input, NULL, 2);
 262static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, get_in_input, NULL, 3);
 263static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, get_in_input, NULL, 4);
 264static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR,
 265                get_in_min, set_in_min, 0);
 266static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO | S_IWUSR,
 267                get_in_min, set_in_min, 1);
 268static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO | S_IWUSR,
 269                get_in_min, set_in_min, 2);
 270static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO | S_IWUSR,
 271                get_in_min, set_in_min, 3);
 272static SENSOR_DEVICE_ATTR(in4_min, S_IRUGO | S_IWUSR,
 273                get_in_min, set_in_min, 4);
 274static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR,
 275                get_in_max, set_in_max, 0);
 276static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO | S_IWUSR,
 277                get_in_max, set_in_max, 1);
 278static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO | S_IWUSR,
 279                get_in_max, set_in_max, 2);
 280static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO | S_IWUSR,
 281                get_in_max, set_in_max, 3);
 282static SENSOR_DEVICE_ATTR(in4_max, S_IRUGO | S_IWUSR,
 283                get_in_max, set_in_max, 4);
 284
 285#define DIV_FROM_REG(val) (1 << (val))
 286#define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : (480000 / ((val) << (div))))
 287#define FAN_TO_REG(val, div) ((val) <= 0 ? 0 : \
 288        clamp_val((480000 + ((val) << ((div)-1))) / ((val) << (div)), 1, 255))
 289
 290static ssize_t get_fan_input(struct device *dev, struct device_attribute *attr,
 291                             char *buf)
 292{
 293        int n = to_sensor_dev_attr(attr)->index;
 294        struct gl520_data *data = gl520_update_device(dev);
 295
 296        return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_input[n],
 297                                                 data->fan_div[n]));
 298}
 299
 300static ssize_t get_fan_min(struct device *dev, struct device_attribute *attr,
 301                           char *buf)
 302{
 303        int n = to_sensor_dev_attr(attr)->index;
 304        struct gl520_data *data = gl520_update_device(dev);
 305
 306        return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[n],
 307                                                 data->fan_div[n]));
 308}
 309
 310static ssize_t get_fan_div(struct device *dev, struct device_attribute *attr,
 311                           char *buf)
 312{
 313        int n = to_sensor_dev_attr(attr)->index;
 314        struct gl520_data *data = gl520_update_device(dev);
 315
 316        return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[n]));
 317}
 318
 319static ssize_t get_fan_off(struct device *dev, struct device_attribute *attr,
 320                           char *buf)
 321{
 322        struct gl520_data *data = gl520_update_device(dev);
 323        return sprintf(buf, "%d\n", data->fan_off);
 324}
 325
 326static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
 327                           const char *buf, size_t count)
 328{
 329        struct i2c_client *client = to_i2c_client(dev);
 330        struct gl520_data *data = i2c_get_clientdata(client);
 331        int n = to_sensor_dev_attr(attr)->index;
 332        u8 r;
 333        unsigned long v;
 334        int err;
 335
 336        err = kstrtoul(buf, 10, &v);
 337        if (err)
 338                return err;
 339
 340        mutex_lock(&data->update_lock);
 341        r = FAN_TO_REG(v, data->fan_div[n]);
 342        data->fan_min[n] = r;
 343
 344        if (n == 0)
 345                gl520_write_value(client, GL520_REG_FAN_MIN,
 346                                  (gl520_read_value(client, GL520_REG_FAN_MIN)
 347                                   & ~0xff00) | (r << 8));
 348        else
 349                gl520_write_value(client, GL520_REG_FAN_MIN,
 350                                  (gl520_read_value(client, GL520_REG_FAN_MIN)
 351                                   & ~0xff) | r);
 352
 353        data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
 354        if (data->fan_min[n] == 0)
 355                data->alarm_mask &= (n == 0) ? ~0x20 : ~0x40;
 356        else
 357                data->alarm_mask |= (n == 0) ? 0x20 : 0x40;
 358        data->beep_mask &= data->alarm_mask;
 359        gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
 360
 361        mutex_unlock(&data->update_lock);
 362        return count;
 363}
 364
 365static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
 366                           const char *buf, size_t count)
 367{
 368        struct i2c_client *client = to_i2c_client(dev);
 369        struct gl520_data *data = i2c_get_clientdata(client);
 370        int n = to_sensor_dev_attr(attr)->index;
 371        u8 r;
 372        unsigned long v;
 373        int err;
 374
 375        err = kstrtoul(buf, 10, &v);
 376        if (err)
 377                return err;
 378
 379        switch (v) {
 380        case 1:
 381                r = 0;
 382                break;
 383        case 2:
 384                r = 1;
 385                break;
 386        case 4:
 387                r = 2;
 388                break;
 389        case 8:
 390                r = 3;
 391                break;
 392        default:
 393                dev_err(&client->dev,
 394        "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n", v);
 395                return -EINVAL;
 396        }
 397
 398        mutex_lock(&data->update_lock);
 399        data->fan_div[n] = r;
 400
 401        if (n == 0)
 402                gl520_write_value(client, GL520_REG_FAN_DIV,
 403                                  (gl520_read_value(client, GL520_REG_FAN_DIV)
 404                                   & ~0xc0) | (r << 6));
 405        else
 406                gl520_write_value(client, GL520_REG_FAN_DIV,
 407                                  (gl520_read_value(client, GL520_REG_FAN_DIV)
 408                                   & ~0x30) | (r << 4));
 409
 410        mutex_unlock(&data->update_lock);
 411        return count;
 412}
 413
 414static ssize_t set_fan_off(struct device *dev, struct device_attribute *attr,
 415                           const char *buf, size_t count)
 416{
 417        struct i2c_client *client = to_i2c_client(dev);
 418        struct gl520_data *data = i2c_get_clientdata(client);
 419        u8 r;
 420        unsigned long v;
 421        int err;
 422
 423        err = kstrtoul(buf, 10, &v);
 424        if (err)
 425                return err;
 426
 427        r = (v ? 1 : 0);
 428
 429        mutex_lock(&data->update_lock);
 430        data->fan_off = r;
 431        gl520_write_value(client, GL520_REG_FAN_OFF,
 432                          (gl520_read_value(client, GL520_REG_FAN_OFF)
 433                           & ~0x0c) | (r << 2));
 434        mutex_unlock(&data->update_lock);
 435        return count;
 436}
 437
 438static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan_input, NULL, 0);
 439static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, get_fan_input, NULL, 1);
 440static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
 441                get_fan_min, set_fan_min, 0);
 442static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR,
 443                get_fan_min, set_fan_min, 1);
 444static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
 445                get_fan_div, set_fan_div, 0);
 446static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
 447                get_fan_div, set_fan_div, 1);
 448static DEVICE_ATTR(fan1_off, S_IRUGO | S_IWUSR,
 449                get_fan_off, set_fan_off);
 450
 451#define TEMP_FROM_REG(val) (((val) - 130) * 1000)
 452#define TEMP_TO_REG(val) clamp_val(((((val) < 0 ? \
 453                        (val) - 500 : (val) + 500) / 1000) + 130), 0, 255)
 454
 455static ssize_t get_temp_input(struct device *dev, struct device_attribute *attr,
 456                              char *buf)
 457{
 458        int n = to_sensor_dev_attr(attr)->index;
 459        struct gl520_data *data = gl520_update_device(dev);
 460
 461        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_input[n]));
 462}
 463
 464static ssize_t get_temp_max(struct device *dev, struct device_attribute *attr,
 465                            char *buf)
 466{
 467        int n = to_sensor_dev_attr(attr)->index;
 468        struct gl520_data *data = gl520_update_device(dev);
 469
 470        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[n]));
 471}
 472
 473static ssize_t get_temp_max_hyst(struct device *dev,
 474                                 struct device_attribute *attr, char *buf)
 475{
 476        int n = to_sensor_dev_attr(attr)->index;
 477        struct gl520_data *data = gl520_update_device(dev);
 478
 479        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[n]));
 480}
 481
 482static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
 483                            const char *buf, size_t count)
 484{
 485        struct i2c_client *client = to_i2c_client(dev);
 486        struct gl520_data *data = i2c_get_clientdata(client);
 487        int n = to_sensor_dev_attr(attr)->index;
 488        long v;
 489        int err;
 490
 491        err = kstrtol(buf, 10, &v);
 492        if (err)
 493                return err;
 494
 495        mutex_lock(&data->update_lock);
 496        data->temp_max[n] = TEMP_TO_REG(v);
 497        gl520_write_value(client, GL520_REG_TEMP_MAX[n], data->temp_max[n]);
 498        mutex_unlock(&data->update_lock);
 499        return count;
 500}
 501
 502static ssize_t set_temp_max_hyst(struct device *dev, struct device_attribute
 503                                 *attr, const char *buf, size_t count)
 504{
 505        struct i2c_client *client = to_i2c_client(dev);
 506        struct gl520_data *data = i2c_get_clientdata(client);
 507        int n = to_sensor_dev_attr(attr)->index;
 508        long v;
 509        int err;
 510
 511        err = kstrtol(buf, 10, &v);
 512        if (err)
 513                return err;
 514
 515        mutex_lock(&data->update_lock);
 516        data->temp_max_hyst[n] = TEMP_TO_REG(v);
 517        gl520_write_value(client, GL520_REG_TEMP_MAX_HYST[n],
 518                          data->temp_max_hyst[n]);
 519        mutex_unlock(&data->update_lock);
 520        return count;
 521}
 522
 523static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, get_temp_input, NULL, 0);
 524static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, get_temp_input, NULL, 1);
 525static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
 526                get_temp_max, set_temp_max, 0);
 527static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR,
 528                get_temp_max, set_temp_max, 1);
 529static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
 530                get_temp_max_hyst, set_temp_max_hyst, 0);
 531static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR,
 532                get_temp_max_hyst, set_temp_max_hyst, 1);
 533
 534static ssize_t get_alarms(struct device *dev, struct device_attribute *attr,
 535                          char *buf)
 536{
 537        struct gl520_data *data = gl520_update_device(dev);
 538        return sprintf(buf, "%d\n", data->alarms);
 539}
 540
 541static ssize_t get_beep_enable(struct device *dev, struct device_attribute
 542                               *attr, char *buf)
 543{
 544        struct gl520_data *data = gl520_update_device(dev);
 545        return sprintf(buf, "%d\n", data->beep_enable);
 546}
 547
 548static ssize_t get_beep_mask(struct device *dev, struct device_attribute *attr,
 549                             char *buf)
 550{
 551        struct gl520_data *data = gl520_update_device(dev);
 552        return sprintf(buf, "%d\n", data->beep_mask);
 553}
 554
 555static ssize_t set_beep_enable(struct device *dev, struct device_attribute
 556                               *attr, const char *buf, size_t count)
 557{
 558        struct i2c_client *client = to_i2c_client(dev);
 559        struct gl520_data *data = i2c_get_clientdata(client);
 560        u8 r;
 561        unsigned long v;
 562        int err;
 563
 564        err = kstrtoul(buf, 10, &v);
 565        if (err)
 566                return err;
 567
 568        r = (v ? 0 : 1);
 569
 570        mutex_lock(&data->update_lock);
 571        data->beep_enable = !r;
 572        gl520_write_value(client, GL520_REG_BEEP_ENABLE,
 573                          (gl520_read_value(client, GL520_REG_BEEP_ENABLE)
 574                           & ~0x04) | (r << 2));
 575        mutex_unlock(&data->update_lock);
 576        return count;
 577}
 578
 579static ssize_t set_beep_mask(struct device *dev, struct device_attribute *attr,
 580                             const char *buf, size_t count)
 581{
 582        struct i2c_client *client = to_i2c_client(dev);
 583        struct gl520_data *data = i2c_get_clientdata(client);
 584        unsigned long r;
 585        int err;
 586
 587        err = kstrtoul(buf, 10, &r);
 588        if (err)
 589                return err;
 590
 591        mutex_lock(&data->update_lock);
 592        r &= data->alarm_mask;
 593        data->beep_mask = r;
 594        gl520_write_value(client, GL520_REG_BEEP_MASK, r);
 595        mutex_unlock(&data->update_lock);
 596        return count;
 597}
 598
 599static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);
 600static DEVICE_ATTR(beep_enable, S_IRUGO | S_IWUSR,
 601                get_beep_enable, set_beep_enable);
 602static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUSR,
 603                get_beep_mask, set_beep_mask);
 604
 605static ssize_t get_alarm(struct device *dev, struct device_attribute *attr,
 606                         char *buf)
 607{
 608        int bit_nr = to_sensor_dev_attr(attr)->index;
 609        struct gl520_data *data = gl520_update_device(dev);
 610
 611        return sprintf(buf, "%d\n", (data->alarms >> bit_nr) & 1);
 612}
 613
 614static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, get_alarm, NULL, 0);
 615static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, get_alarm, NULL, 1);
 616static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, get_alarm, NULL, 2);
 617static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, get_alarm, NULL, 3);
 618static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, get_alarm, NULL, 4);
 619static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, get_alarm, NULL, 5);
 620static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, get_alarm, NULL, 6);
 621static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, get_alarm, NULL, 7);
 622static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, get_alarm, NULL, 7);
 623
 624static ssize_t get_beep(struct device *dev, struct device_attribute *attr,
 625                        char *buf)
 626{
 627        int bitnr = to_sensor_dev_attr(attr)->index;
 628        struct gl520_data *data = gl520_update_device(dev);
 629
 630        return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1);
 631}
 632
 633static ssize_t set_beep(struct device *dev, struct device_attribute *attr,
 634                        const char *buf, size_t count)
 635{
 636        struct i2c_client *client = to_i2c_client(dev);
 637        struct gl520_data *data = i2c_get_clientdata(client);
 638        int bitnr = to_sensor_dev_attr(attr)->index;
 639        unsigned long bit;
 640
 641        int err;
 642
 643        err = kstrtoul(buf, 10, &bit);
 644        if (err)
 645                return err;
 646        if (bit & ~1)
 647                return -EINVAL;
 648
 649        mutex_lock(&data->update_lock);
 650        data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
 651        if (bit)
 652                data->beep_mask |= (1 << bitnr);
 653        else
 654                data->beep_mask &= ~(1 << bitnr);
 655        gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
 656        mutex_unlock(&data->update_lock);
 657        return count;
 658}
 659
 660static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 0);
 661static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 1);
 662static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 2);
 663static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 3);
 664static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 4);
 665static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 5);
 666static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 6);
 667static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7);
 668static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7);
 669
 670static struct attribute *gl520_attributes[] = {
 671        &dev_attr_cpu0_vid.attr,
 672
 673        &sensor_dev_attr_in0_input.dev_attr.attr,
 674        &sensor_dev_attr_in0_min.dev_attr.attr,
 675        &sensor_dev_attr_in0_max.dev_attr.attr,
 676        &sensor_dev_attr_in0_alarm.dev_attr.attr,
 677        &sensor_dev_attr_in0_beep.dev_attr.attr,
 678        &sensor_dev_attr_in1_input.dev_attr.attr,
 679        &sensor_dev_attr_in1_min.dev_attr.attr,
 680        &sensor_dev_attr_in1_max.dev_attr.attr,
 681        &sensor_dev_attr_in1_alarm.dev_attr.attr,
 682        &sensor_dev_attr_in1_beep.dev_attr.attr,
 683        &sensor_dev_attr_in2_input.dev_attr.attr,
 684        &sensor_dev_attr_in2_min.dev_attr.attr,
 685        &sensor_dev_attr_in2_max.dev_attr.attr,
 686        &sensor_dev_attr_in2_alarm.dev_attr.attr,
 687        &sensor_dev_attr_in2_beep.dev_attr.attr,
 688        &sensor_dev_attr_in3_input.dev_attr.attr,
 689        &sensor_dev_attr_in3_min.dev_attr.attr,
 690        &sensor_dev_attr_in3_max.dev_attr.attr,
 691        &sensor_dev_attr_in3_alarm.dev_attr.attr,
 692        &sensor_dev_attr_in3_beep.dev_attr.attr,
 693
 694        &sensor_dev_attr_fan1_input.dev_attr.attr,
 695        &sensor_dev_attr_fan1_min.dev_attr.attr,
 696        &sensor_dev_attr_fan1_div.dev_attr.attr,
 697        &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 698        &sensor_dev_attr_fan1_beep.dev_attr.attr,
 699        &dev_attr_fan1_off.attr,
 700        &sensor_dev_attr_fan2_input.dev_attr.attr,
 701        &sensor_dev_attr_fan2_min.dev_attr.attr,
 702        &sensor_dev_attr_fan2_div.dev_attr.attr,
 703        &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 704        &sensor_dev_attr_fan2_beep.dev_attr.attr,
 705
 706        &sensor_dev_attr_temp1_input.dev_attr.attr,
 707        &sensor_dev_attr_temp1_max.dev_attr.attr,
 708        &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
 709        &sensor_dev_attr_temp1_alarm.dev_attr.attr,
 710        &sensor_dev_attr_temp1_beep.dev_attr.attr,
 711
 712        &dev_attr_alarms.attr,
 713        &dev_attr_beep_enable.attr,
 714        &dev_attr_beep_mask.attr,
 715        NULL
 716};
 717
 718static const struct attribute_group gl520_group = {
 719        .attrs = gl520_attributes,
 720};
 721
 722static struct attribute *gl520_attributes_in4[] = {
 723        &sensor_dev_attr_in4_input.dev_attr.attr,
 724        &sensor_dev_attr_in4_min.dev_attr.attr,
 725        &sensor_dev_attr_in4_max.dev_attr.attr,
 726        &sensor_dev_attr_in4_alarm.dev_attr.attr,
 727        &sensor_dev_attr_in4_beep.dev_attr.attr,
 728        NULL
 729};
 730
 731static struct attribute *gl520_attributes_temp2[] = {
 732        &sensor_dev_attr_temp2_input.dev_attr.attr,
 733        &sensor_dev_attr_temp2_max.dev_attr.attr,
 734        &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
 735        &sensor_dev_attr_temp2_alarm.dev_attr.attr,
 736        &sensor_dev_attr_temp2_beep.dev_attr.attr,
 737        NULL
 738};
 739
 740static const struct attribute_group gl520_group_in4 = {
 741        .attrs = gl520_attributes_in4,
 742};
 743
 744static const struct attribute_group gl520_group_temp2 = {
 745        .attrs = gl520_attributes_temp2,
 746};
 747
 748
 749/*
 750 * Real code
 751 */
 752
 753/* Return 0 if detection is successful, -ENODEV otherwise */
 754static int gl520_detect(struct i2c_client *client, struct i2c_board_info *info)
 755{
 756        struct i2c_adapter *adapter = client->adapter;
 757
 758        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
 759                                     I2C_FUNC_SMBUS_WORD_DATA))
 760                return -ENODEV;
 761
 762        /* Determine the chip type. */
 763        if ((gl520_read_value(client, GL520_REG_CHIP_ID) != 0x20) ||
 764            ((gl520_read_value(client, GL520_REG_REVISION) & 0x7f) != 0x00) ||
 765            ((gl520_read_value(client, GL520_REG_CONF) & 0x80) != 0x00)) {
 766                dev_dbg(&client->dev, "Unknown chip type, skipping\n");
 767                return -ENODEV;
 768        }
 769
 770        strlcpy(info->type, "gl520sm", I2C_NAME_SIZE);
 771
 772        return 0;
 773}
 774
 775static int gl520_probe(struct i2c_client *client,
 776                       const struct i2c_device_id *id)
 777{
 778        struct gl520_data *data;
 779        int err;
 780
 781        data = devm_kzalloc(&client->dev, sizeof(struct gl520_data),
 782                            GFP_KERNEL);
 783        if (!data)
 784                return -ENOMEM;
 785
 786        i2c_set_clientdata(client, data);
 787        mutex_init(&data->update_lock);
 788
 789        /* Initialize the GL520SM chip */
 790        gl520_init_client(client);
 791
 792        /* Register sysfs hooks */
 793        err = sysfs_create_group(&client->dev.kobj, &gl520_group);
 794        if (err)
 795                return err;
 796
 797        if (data->two_temps)
 798                err = sysfs_create_group(&client->dev.kobj, &gl520_group_temp2);
 799        else
 800                err = sysfs_create_group(&client->dev.kobj, &gl520_group_in4);
 801
 802        if (err)
 803                goto exit_remove_files;
 804
 805        data->hwmon_dev = hwmon_device_register(&client->dev);
 806        if (IS_ERR(data->hwmon_dev)) {
 807                err = PTR_ERR(data->hwmon_dev);
 808                goto exit_remove_files;
 809        }
 810
 811        return 0;
 812
 813exit_remove_files:
 814        sysfs_remove_group(&client->dev.kobj, &gl520_group);
 815        sysfs_remove_group(&client->dev.kobj, &gl520_group_in4);
 816        sysfs_remove_group(&client->dev.kobj, &gl520_group_temp2);
 817        return err;
 818}
 819
 820
 821/* Called when we have found a new GL520SM. */
 822static void gl520_init_client(struct i2c_client *client)
 823{
 824        struct gl520_data *data = i2c_get_clientdata(client);
 825        u8 oldconf, conf;
 826
 827        conf = oldconf = gl520_read_value(client, GL520_REG_CONF);
 828
 829        data->alarm_mask = 0xff;
 830        data->vrm = vid_which_vrm();
 831
 832        if (extra_sensor_type == 1)
 833                conf &= ~0x10;
 834        else if (extra_sensor_type == 2)
 835                conf |= 0x10;
 836        data->two_temps = !(conf & 0x10);
 837
 838        /* If IRQ# is disabled, we can safely force comparator mode */
 839        if (!(conf & 0x20))
 840                conf &= 0xf7;
 841
 842        /* Enable monitoring if needed */
 843        conf |= 0x40;
 844
 845        if (conf != oldconf)
 846                gl520_write_value(client, GL520_REG_CONF, conf);
 847
 848        gl520_update_device(&(client->dev));
 849
 850        if (data->fan_min[0] == 0)
 851                data->alarm_mask &= ~0x20;
 852        if (data->fan_min[1] == 0)
 853                data->alarm_mask &= ~0x40;
 854
 855        data->beep_mask &= data->alarm_mask;
 856        gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
 857}
 858
 859static int gl520_remove(struct i2c_client *client)
 860{
 861        struct gl520_data *data = i2c_get_clientdata(client);
 862
 863        hwmon_device_unregister(data->hwmon_dev);
 864        sysfs_remove_group(&client->dev.kobj, &gl520_group);
 865        sysfs_remove_group(&client->dev.kobj, &gl520_group_in4);
 866        sysfs_remove_group(&client->dev.kobj, &gl520_group_temp2);
 867
 868        return 0;
 869}
 870
 871
 872/*
 873 * Registers 0x07 to 0x0c are word-sized, others are byte-sized
 874 * GL520 uses a high-byte first convention
 875 */
 876static int gl520_read_value(struct i2c_client *client, u8 reg)
 877{
 878        if ((reg >= 0x07) && (reg <= 0x0c))
 879                return i2c_smbus_read_word_swapped(client, reg);
 880        else
 881                return i2c_smbus_read_byte_data(client, reg);
 882}
 883
 884static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value)
 885{
 886        if ((reg >= 0x07) && (reg <= 0x0c))
 887                return i2c_smbus_write_word_swapped(client, reg, value);
 888        else
 889                return i2c_smbus_write_byte_data(client, reg, value);
 890}
 891
 892
 893static struct gl520_data *gl520_update_device(struct device *dev)
 894{
 895        struct i2c_client *client = to_i2c_client(dev);
 896        struct gl520_data *data = i2c_get_clientdata(client);
 897        int val, i;
 898
 899        mutex_lock(&data->update_lock);
 900
 901        if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
 902
 903                dev_dbg(&client->dev, "Starting gl520sm update\n");
 904
 905                data->alarms = gl520_read_value(client, GL520_REG_ALARMS);
 906                data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
 907                data->vid = gl520_read_value(client,
 908                                             GL520_REG_VID_INPUT) & 0x1f;
 909
 910                for (i = 0; i < 4; i++) {
 911                        data->in_input[i] = gl520_read_value(client,
 912                                                        GL520_REG_IN_INPUT[i]);
 913                        val = gl520_read_value(client, GL520_REG_IN_LIMIT[i]);
 914                        data->in_min[i] = val & 0xff;
 915                        data->in_max[i] = (val >> 8) & 0xff;
 916                }
 917
 918                val = gl520_read_value(client, GL520_REG_FAN_INPUT);
 919                data->fan_input[0] = (val >> 8) & 0xff;
 920                data->fan_input[1] = val & 0xff;
 921
 922                val = gl520_read_value(client, GL520_REG_FAN_MIN);
 923                data->fan_min[0] = (val >> 8) & 0xff;
 924                data->fan_min[1] = val & 0xff;
 925
 926                data->temp_input[0] = gl520_read_value(client,
 927                                                GL520_REG_TEMP_INPUT[0]);
 928                data->temp_max[0] = gl520_read_value(client,
 929                                                GL520_REG_TEMP_MAX[0]);
 930                data->temp_max_hyst[0] = gl520_read_value(client,
 931                                                GL520_REG_TEMP_MAX_HYST[0]);
 932
 933                val = gl520_read_value(client, GL520_REG_FAN_DIV);
 934                data->fan_div[0] = (val >> 6) & 0x03;
 935                data->fan_div[1] = (val >> 4) & 0x03;
 936                data->fan_off = (val >> 2) & 0x01;
 937
 938                data->alarms &= data->alarm_mask;
 939
 940                val = gl520_read_value(client, GL520_REG_CONF);
 941                data->beep_enable = !((val >> 2) & 1);
 942
 943                /* Temp1 and Vin4 are the same input */
 944                if (data->two_temps) {
 945                        data->temp_input[1] = gl520_read_value(client,
 946                                                GL520_REG_TEMP_INPUT[1]);
 947                        data->temp_max[1] = gl520_read_value(client,
 948                                                GL520_REG_TEMP_MAX[1]);
 949                        data->temp_max_hyst[1] = gl520_read_value(client,
 950                                                GL520_REG_TEMP_MAX_HYST[1]);
 951                } else {
 952                        data->in_input[4] = gl520_read_value(client,
 953                                                GL520_REG_IN_INPUT[4]);
 954                        data->in_min[4] = gl520_read_value(client,
 955                                                GL520_REG_IN_MIN[4]);
 956                        data->in_max[4] = gl520_read_value(client,
 957                                                GL520_REG_IN_MAX[4]);
 958                }
 959
 960                data->last_updated = jiffies;
 961                data->valid = 1;
 962        }
 963
 964        mutex_unlock(&data->update_lock);
 965
 966        return data;
 967}
 968
 969module_i2c_driver(gl520_driver);
 970
 971MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
 972        "Kyösti Mälkki <kmalkki@cc.hut.fi>, "
 973        "Maarten Deprez <maartendeprez@users.sourceforge.net>");
 974MODULE_DESCRIPTION("GL520SM driver");
 975MODULE_LICENSE("GPL");
 976
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.