drivers/hwmon/abituguru.c

   1 /*
   2     abituguru.c Copyright (c) 2005-2006 Hans de Goede <hdegoede@redhat.com>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18 /*
  19     This driver supports the sensor part of the first and second revision of
  20     the custom Abit uGuru chip found on Abit uGuru motherboards. Note: because
  21     of lack of specs the CPU/RAM voltage & frequency control is not supported!
  22 */
  23
  24 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  25
  26 #include <linux/module.h>
  27 #include <linux/sched.h>
  28 #include <linux/init.h>
  29 #include <linux/slab.h>
  30 #include <linux/jiffies.h>
  31 #include <linux/mutex.h>
  32 #include <linux/err.h>
  33 #include <linux/delay.h>
  34 #include <linux/platform_device.h>
  35 #include <linux/hwmon.h>
  36 #include <linux/hwmon-sysfs.h>
  37 #include <linux/dmi.h>
  38 #include <linux/io.h>
  39
  40 /* Banks */
  41 #define ABIT_UGURU_ALARM_BANK                   0x20 /* 1x 3 bytes */
  42 #define ABIT_UGURU_SENSOR_BANK1                 0x21 /* 16x volt and temp */
  43 #define ABIT_UGURU_FAN_PWM                      0x24 /* 3x 5 bytes */
  44 #define ABIT_UGURU_SENSOR_BANK2                 0x26 /* fans */
  45 /* max nr of sensors in bank1, a bank1 sensor can be in, temp or nc */
  46 #define ABIT_UGURU_MAX_BANK1_SENSORS            16
  47 /* Warning if you increase one of the 2 MAX defines below to 10 or higher you
  48    should adjust the belonging _NAMES_LENGTH macro for the 2 digit number! */
  49 /* max nr of sensors in bank2, currently mb's with max 6 fans are known */
  50 #define ABIT_UGURU_MAX_BANK2_SENSORS            6
  51 /* max nr of pwm outputs, currently mb's with max 5 pwm outputs are known */
  52 #define ABIT_UGURU_MAX_PWMS                     5
  53 /* uGuru sensor bank 1 flags */                      /* Alarm if: */
  54 #define ABIT_UGURU_TEMP_HIGH_ALARM_ENABLE       0x01 /*  temp over warn */
  55 #define ABIT_UGURU_VOLT_HIGH_ALARM_ENABLE       0x02 /*  volt over max */
  56 #define ABIT_UGURU_VOLT_LOW_ALARM_ENABLE        0x04 /*  volt under min */
  57 #define ABIT_UGURU_TEMP_HIGH_ALARM_FLAG         0x10 /* temp is over warn */
  58 #define ABIT_UGURU_VOLT_HIGH_ALARM_FLAG         0x20 /* volt is over max */
  59 #define ABIT_UGURU_VOLT_LOW_ALARM_FLAG          0x40 /* volt is under min */
  60 /* uGuru sensor bank 2 flags */                      /* Alarm if: */
  61 #define ABIT_UGURU_FAN_LOW_ALARM_ENABLE         0x01 /*   fan under min */
  62 /* uGuru sensor bank common flags */
  63 #define ABIT_UGURU_BEEP_ENABLE                  0x08 /* beep if alarm */
  64 #define ABIT_UGURU_SHUTDOWN_ENABLE              0x80 /* shutdown if alarm */
  65 /* uGuru fan PWM (speed control) flags */
  66 #define ABIT_UGURU_FAN_PWM_ENABLE               0x80 /* enable speed control */
  67 /* Values used for conversion */
  68 #define ABIT_UGURU_FAN_MAX                      15300 /* RPM */
  69 /* Bank1 sensor types */
  70 #define ABIT_UGURU_IN_SENSOR                    0
  71 #define ABIT_UGURU_TEMP_SENSOR                  1
  72 #define ABIT_UGURU_NC                           2
  73 /* In many cases we need to wait for the uGuru to reach a certain status, most
  74    of the time it will reach this status within 30 - 90 ISA reads, and thus we
  75    can best busy wait. This define gives the total amount of reads to try. */
  76 #define ABIT_UGURU_WAIT_TIMEOUT                 125
  77 /* However sometimes older versions of the uGuru seem to be distracted and they
  78    do not respond for a long time. To handle this we sleep before each of the
  79    last ABIT_UGURU_WAIT_TIMEOUT_SLEEP tries. */
  80 #define ABIT_UGURU_WAIT_TIMEOUT_SLEEP           5
  81 /* Normally all expected status in abituguru_ready, are reported after the
  82    first read, but sometimes not and we need to poll. */
  83 #define ABIT_UGURU_READY_TIMEOUT                5
  84 /* Maximum 3 retries on timedout reads/writes, delay 200 ms before retrying */
  85 #define ABIT_UGURU_MAX_RETRIES                  3
  86 #define ABIT_UGURU_RETRY_DELAY                  (HZ/5)
  87 /* Maximum 2 timeouts in abituguru_update_device, iow 3 in a row is an error */
  88 #define ABIT_UGURU_MAX_TIMEOUTS                 2
  89 /* utility macros */
  90 #define ABIT_UGURU_NAME                         "abituguru"
  91 #define ABIT_UGURU_DEBUG(level, format, arg...)                         \
  92         if (level <= verbose)                                           \
  93                 printk(KERN_DEBUG ABIT_UGURU_NAME ": "  format , ## arg)
  94 /* Macros to help calculate the sysfs_names array length */
  95 /* sum of strlen of: in??_input\0, in??_{min,max}\0, in??_{min,max}_alarm\0,
  96    in??_{min,max}_alarm_enable\0, in??_beep\0, in??_shutdown\0 */
  97 #define ABITUGURU_IN_NAMES_LENGTH       (11 + 2 * 9 + 2 * 15 + 2 * 22 + 10 + 14)
  98 /* sum of strlen of: temp??_input\0, temp??_max\0, temp??_crit\0,
  99    temp??_alarm\0, temp??_alarm_enable\0, temp??_beep\0, temp??_shutdown\0 */
 100 #define ABITUGURU_TEMP_NAMES_LENGTH     (13 + 11 + 12 + 13 + 20 + 12 + 16)
 101 /* sum of strlen of: fan?_input\0, fan?_min\0, fan?_alarm\0,
 102    fan?_alarm_enable\0, fan?_beep\0, fan?_shutdown\0 */
 103 #define ABITUGURU_FAN_NAMES_LENGTH      (11 + 9 + 11 + 18 + 10 + 14)
 104 /* sum of strlen of: pwm?_enable\0, pwm?_auto_channels_temp\0,
 105    pwm?_auto_point{1,2}_pwm\0, pwm?_auto_point{1,2}_temp\0 */
 106 #define ABITUGURU_PWM_NAMES_LENGTH      (12 + 24 + 2 * 21 + 2 * 22)
 107 /* IN_NAMES_LENGTH > TEMP_NAMES_LENGTH so assume all bank1 sensors are in */
 108 #define ABITUGURU_SYSFS_NAMES_LENGTH    ( \
 109         ABIT_UGURU_MAX_BANK1_SENSORS * ABITUGURU_IN_NAMES_LENGTH + \
 110         ABIT_UGURU_MAX_BANK2_SENSORS * ABITUGURU_FAN_NAMES_LENGTH + \
 111         ABIT_UGURU_MAX_PWMS * ABITUGURU_PWM_NAMES_LENGTH)
 112
 113 /* All the macros below are named identical to the oguru and oguru2 programs
 114    reverse engineered by Olle Sandberg, hence the names might not be 100%
 115    logical. I could come up with better names, but I prefer keeping the names
 116    identical so that this driver can be compared with his work more easily. */
 117 /* Two i/o-ports are used by uGuru */
 118 #define ABIT_UGURU_BASE                         0x00E0
 119 /* Used to tell uGuru what to read and to read the actual data */
 120 #define ABIT_UGURU_CMD                          0x00
 121 /* Mostly used to check if uGuru is busy */
 122 #define ABIT_UGURU_DATA                         0x04
 123 #define ABIT_UGURU_REGION_LENGTH                5
 124 /* uGuru status' */
 125 #define ABIT_UGURU_STATUS_WRITE                 0x00 /* Ready to be written */
 126 #define ABIT_UGURU_STATUS_READ                  0x01 /* Ready to be read */
 127 #define ABIT_UGURU_STATUS_INPUT                 0x08 /* More input */
 128 #define ABIT_UGURU_STATUS_READY                 0x09 /* Ready to be written */
 129
 130 /* Constants */
 131 /* in (Volt) sensors go up to 3494 mV, temp to 255000 millidegrees Celsius */
 132 static const int abituguru_bank1_max_value[2] = { 3494, 255000 };
 133 /* Min / Max allowed values for sensor2 (fan) alarm threshold, these values
 134    correspond to 300-3000 RPM */
 135 static const u8 abituguru_bank2_min_threshold = 5;
 136 static const u8 abituguru_bank2_max_threshold = 50;
 137 /* Register 0 is a bitfield, 1 and 2 are pwm settings (255 = 100%), 3 and 4
 138    are temperature trip points. */
 139 static const int abituguru_pwm_settings_multiplier[5] = { 0, 1, 1, 1000, 1000 };
 140 /* Min / Max allowed values for pwm_settings. Note: pwm1 (CPU fan) is a
 141    special case the minium allowed pwm% setting for this is 30% (77) on
 142    some MB's this special case is handled in the code! */
 143 static const u8 abituguru_pwm_min[5] = { 0, 170, 170, 25, 25 };
 144 static const u8 abituguru_pwm_max[5] = { 0, 255, 255, 75, 75 };
 145
 146
 147 /* Insmod parameters */
 148 static int force;
 149 module_param(force, bool, 0);
 150 MODULE_PARM_DESC(force, "Set to one to force detection.");
 151 static int bank1_types[ABIT_UGURU_MAX_BANK1_SENSORS] = { -1, -1, -1, -1, -1,
 152         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
 153 module_param_array(bank1_types, int, NULL, 0);
 154 MODULE_PARM_DESC(bank1_types, "Bank1 sensortype autodetection override:\n"
 155         "   -1 autodetect\n"
 156         "    0 volt sensor\n"
 157         "    1 temp sensor\n"
 158         "    2 not connected");
 159 static int fan_sensors;
 160 module_param(fan_sensors, int, 0);
 161 MODULE_PARM_DESC(fan_sensors, "Number of fan sensors on the uGuru "
 162         "(0 = autodetect)");
 163 static int pwms;
 164 module_param(pwms, int, 0);
 165 MODULE_PARM_DESC(pwms, "Number of PWMs on the uGuru "
 166         "(0 = autodetect)");
 167
 168 /* Default verbose is 2, since this driver is still in the testing phase */
 169 static int verbose = 2;
 170 module_param(verbose, int, 0644);
 171 MODULE_PARM_DESC(verbose, "How verbose should the driver be? (0-3):\n"
 172         "   0 normal output\n"
 173         "   1 + verbose error reporting\n"
 174         "   2 + sensors type probing info\n"
 175         "   3 + retryable error reporting");
 176
 177
 178 /* For the Abit uGuru, we need to keep some data in memory.
 179    The structure is dynamically allocated, at the same time when a new
 180    abituguru device is allocated. */
 181 struct abituguru_data {
 182         struct device *hwmon_dev;       /* hwmon registered device */
 183         struct mutex update_lock;       /* protect access to data and uGuru */
 184         unsigned long last_updated;     /* In jiffies */
 185         unsigned short addr;            /* uguru base address */
 186         char uguru_ready;               /* is the uguru in ready state? */
 187         unsigned char update_timeouts;  /* number of update timeouts since last
 188                                            successful update */
 189
 190         /* The sysfs attr and their names are generated automatically, for bank1
 191            we cannot use a predefined array because we don't know beforehand
 192            of a sensor is a volt or a temp sensor, for bank2 and the pwms its
 193            easier todo things the same way.  For in sensors we have 9 (temp 7)
 194            sysfs entries per sensor, for bank2 and pwms 6. */
 195         struct sensor_device_attribute_2 sysfs_attr[
 196                 ABIT_UGURU_MAX_BANK1_SENSORS * 9 +
 197                 ABIT_UGURU_MAX_BANK2_SENSORS * 6 + ABIT_UGURU_MAX_PWMS * 6];
 198         /* Buffer to store the dynamically generated sysfs names */
 199         char sysfs_names[ABITUGURU_SYSFS_NAMES_LENGTH];
 200
 201         /* Bank 1 data */
 202         /* number of and addresses of [0] in, [1] temp sensors */
 203         u8 bank1_sensors[2];
 204         u8 bank1_address[2][ABIT_UGURU_MAX_BANK1_SENSORS];
 205         u8 bank1_value[ABIT_UGURU_MAX_BANK1_SENSORS];
 206         /* This array holds 3 entries per sensor for the bank 1 sensor settings
 207            (flags, min, max for voltage / flags, warn, shutdown for temp). */
 208         u8 bank1_settings[ABIT_UGURU_MAX_BANK1_SENSORS][3];
 209         /* Maximum value for each sensor used for scaling in mV/millidegrees
 210            Celsius. */
 211         int bank1_max_value[ABIT_UGURU_MAX_BANK1_SENSORS];
 212
 213         /* Bank 2 data, ABIT_UGURU_MAX_BANK2_SENSORS entries for bank2 */
 214         u8 bank2_sensors; /* actual number of bank2 sensors found */
 215         u8 bank2_value[ABIT_UGURU_MAX_BANK2_SENSORS];
 216         u8 bank2_settings[ABIT_UGURU_MAX_BANK2_SENSORS][2]; /* flags, min */
 217
 218         /* Alarms 2 bytes for bank1, 1 byte for bank2 */
 219         u8 alarms[3];
 220
 221         /* Fan PWM (speed control) 5 bytes per PWM */
 222         u8 pwms; /* actual number of pwms found */
 223         u8 pwm_settings[ABIT_UGURU_MAX_PWMS][5];
 224 };
 225
 226 static const char *never_happen = "This should never happen.";
 227 static const char *report_this =
 228         "Please report this to the abituguru maintainer (see MAINTAINERS)";
 229
 230 /* wait till the uguru is in the specified state */
 231 static int abituguru_wait(struct abituguru_data *data, u8 state)
 232 {
 233         int timeout = ABIT_UGURU_WAIT_TIMEOUT;
 234
 235         while (inb_p(data->addr + ABIT_UGURU_DATA) != state) {
 236                 timeout--;
 237                 if (timeout == 0)
 238                         return -EBUSY;
 239                 /* sleep a bit before our last few tries, see the comment on
 240                    this where ABIT_UGURU_WAIT_TIMEOUT_SLEEP is defined. */
 241                 if (timeout <= ABIT_UGURU_WAIT_TIMEOUT_SLEEP)
 242                         msleep(0);
 243         }
 244         return 0;
 245 }
 246
 247 /* Put the uguru in ready for input state */
 248 static int abituguru_ready(struct abituguru_data *data)
 249 {
 250         int timeout = ABIT_UGURU_READY_TIMEOUT;
 251
 252         if (data->uguru_ready)
 253                 return 0;
 254
 255         /* Reset? / Prepare for next read/write cycle */
 256         outb(0x00, data->addr + ABIT_UGURU_DATA);
 257
 258         /* Wait till the uguru is ready */
 259         if (abituguru_wait(data, ABIT_UGURU_STATUS_READY)) {
 260                 ABIT_UGURU_DEBUG(1,
 261                         "timeout exceeded waiting for ready state\n");
 262                 return -EIO;
 263         }
 264
 265         /* Cmd port MUST be read now and should contain 0xAC */
 266         while (inb_p(data->addr + ABIT_UGURU_CMD) != 0xAC) {
 267                 timeout--;
 268                 if (timeout == 0) {
 269                         ABIT_UGURU_DEBUG(1,
 270                            "CMD reg does not hold 0xAC after ready command\n");
 271                         return -EIO;
 272                 }
 273                 msleep(0);
 274         }
 275
 276         /* After this the ABIT_UGURU_DATA port should contain
 277            ABIT_UGURU_STATUS_INPUT */
 278         timeout = ABIT_UGURU_READY_TIMEOUT;
 279         while (inb_p(data->addr + ABIT_UGURU_DATA) != ABIT_UGURU_STATUS_INPUT) {
 280                 timeout--;
 281                 if (timeout == 0) {
 282                         ABIT_UGURU_DEBUG(1,
 283                                 "state != more input after ready command\n");
 284                         return -EIO;
 285                 }
 286                 msleep(0);
 287         }
 288
 289         data->uguru_ready = 1;
 290         return 0;
 291 }
 292
 293 /* Send the bank and then sensor address to the uGuru for the next read/write
 294    cycle. This function gets called as the first part of a read/write by
 295    abituguru_read and abituguru_write. This function should never be
 296    called by any other function. */
 297 static int abituguru_send_address(struct abituguru_data *data,
 298         u8 bank_addr, u8 sensor_addr, int retries)
 299 {
 300         /* assume the caller does error handling itself if it has not requested
 301            any retries, and thus be quiet. */
 302         int report_errors = retries;
 303
 304         for (;;) {
 305                 /* Make sure the uguru is ready and then send the bank address,
 306                    after this the uguru is no longer "ready". */
 307                 if (abituguru_ready(data) != 0)
 308                         return -EIO;
 309                 outb(bank_addr, data->addr + ABIT_UGURU_DATA);
 310                 data->uguru_ready = 0;
 311
 312                 /* Wait till the uguru is ABIT_UGURU_STATUS_INPUT state again
 313                    and send the sensor addr */
 314                 if (abituguru_wait(data, ABIT_UGURU_STATUS_INPUT)) {
 315                         if (retries) {
 316                                 ABIT_UGURU_DEBUG(3, "timeout exceeded "
 317                                         "waiting for more input state, %d "
 318                                         "tries remaining\n", retries);
 319                                 set_current_state(TASK_UNINTERRUPTIBLE);
 320                                 schedule_timeout(ABIT_UGURU_RETRY_DELAY);
 321                                 retries--;
 322                                 continue;
 323                         }
 324                         if (report_errors)
 325                                 ABIT_UGURU_DEBUG(1, "timeout exceeded "
 326                                         "waiting for more input state "
 327                                         "(bank: %d)\n", (int)bank_addr);
 328                         return -EBUSY;
 329                 }
 330                 outb(sensor_addr, data->addr + ABIT_UGURU_CMD);
 331                 return 0;
 332         }
 333 }
 334
 335 /* Read count bytes from sensor sensor_addr in bank bank_addr and store the
 336    result in buf, retry the send address part of the read retries times. */
 337 static int abituguru_read(struct abituguru_data *data,
 338         u8 bank_addr, u8 sensor_addr, u8 *buf, int count, int retries)
 339 {
 340         int i;
 341
 342         /* Send the address */
 343         i = abituguru_send_address(data, bank_addr, sensor_addr, retries);
 344         if (i)
 345                 return i;
 346
 347         /* And read the data */
 348         for (i = 0; i < count; i++) {
 349                 if (abituguru_wait(data, ABIT_UGURU_STATUS_READ)) {
 350                         ABIT_UGURU_DEBUG(retries ? 1 : 3,
 351                                 "timeout exceeded waiting for "
 352                                 "read state (bank: %d, sensor: %d)\n",
 353                                 (int)bank_addr, (int)sensor_addr);
 354                         break;
 355                 }
 356                 buf[i] = inb(data->addr + ABIT_UGURU_CMD);
 357         }
 358
 359         /* Last put the chip back in ready state */
 360         abituguru_ready(data);
 361
 362         return i;
 363 }
 364
 365 /* Write count bytes from buf to sensor sensor_addr in bank bank_addr, the send
 366    address part of the write is always retried ABIT_UGURU_MAX_RETRIES times. */
 367 static int abituguru_write(struct abituguru_data *data,
 368         u8 bank_addr, u8 sensor_addr, u8 *buf, int count)
 369 {
 370         /* We use the ready timeout as we have to wait for 0xAC just like the
 371            ready function */
 372         int i, timeout = ABIT_UGURU_READY_TIMEOUT;
 373
 374         /* Send the address */
 375         i = abituguru_send_address(data, bank_addr, sensor_addr,
 376                 ABIT_UGURU_MAX_RETRIES);
 377         if (i)
 378                 return i;
 379
 380         /* And write the data */
 381         for (i = 0; i < count; i++) {
 382                 if (abituguru_wait(data, ABIT_UGURU_STATUS_WRITE)) {
 383                         ABIT_UGURU_DEBUG(1, "timeout exceeded waiting for "
 384                                 "write state (bank: %d, sensor: %d)\n",
 385                                 (int)bank_addr, (int)sensor_addr);
 386                         break;
 387                 }
 388                 outb(buf[i], data->addr + ABIT_UGURU_CMD);
 389         }
 390
 391         /* Now we need to wait till the chip is ready to be read again,
 392            so that we can read 0xAC as confirmation that our write has
 393            succeeded. */
 394         if (abituguru_wait(data, ABIT_UGURU_STATUS_READ)) {
 395                 ABIT_UGURU_DEBUG(1, "timeout exceeded waiting for read state "
 396                         "after write (bank: %d, sensor: %d)\n", (int)bank_addr,
 397                         (int)sensor_addr);
 398                 return -EIO;
 399         }
 400
 401         /* Cmd port MUST be read now and should contain 0xAC */
 402         while (inb_p(data->addr + ABIT_UGURU_CMD) != 0xAC) {
 403                 timeout--;
 404                 if (timeout == 0) {
 405                         ABIT_UGURU_DEBUG(1, "CMD reg does not hold 0xAC after "
 406                                 "write (bank: %d, sensor: %d)\n",
 407                                 (int)bank_addr, (int)sensor_addr);
 408                         return -EIO;
 409                 }
 410                 msleep(0);
 411         }
 412
 413         /* Last put the chip back in ready state */
 414         abituguru_ready(data);
 415
 416         return i;
 417 }
 418
 419 /* Detect sensor type. Temp and Volt sensors are enabled with
 420    different masks and will ignore enable masks not meant for them.
 421    This enables us to test what kind of sensor we're dealing with.
 422    By setting the alarm thresholds so that we will always get an
 423    alarm for sensor type X and then enabling the sensor as sensor type
 424    X, if we then get an alarm it is a sensor of type X. */
 425 static int __devinit
 426 abituguru_detect_bank1_sensor_type(struct abituguru_data *data,
 427                                    u8 sensor_addr)
 428 {
 429         u8 val, test_flag, buf[3];
 430         int i, ret = -ENODEV; /* error is the most common used retval :| */
 431
 432         /* If overriden by the user return the user selected type */
 433         if (bank1_types[sensor_addr] >= ABIT_UGURU_IN_SENSOR &&
 434                         bank1_types[sensor_addr] <= ABIT_UGURU_NC) {
 435                 ABIT_UGURU_DEBUG(2, "assuming sensor type %d for bank1 sensor "
 436                         "%d because of \"bank1_types\" module param\n",
 437                         bank1_types[sensor_addr], (int)sensor_addr);
 438                 return bank1_types[sensor_addr];
 439         }
 440
 441         /* First read the sensor and the current settings */
 442         if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1, sensor_addr, &val,
 443                         1, ABIT_UGURU_MAX_RETRIES) != 1)
 444                 return -ENODEV;
 445
 446         /* Test val is sane / usable for sensor type detection. */
 447         if ((val < 10u) || (val > 250u)) {
 448                 pr_warn("bank1-sensor: %d reading (%d) too close to limits, "
 449                         "unable to determine sensor type, skipping sensor\n",
 450                         (int)sensor_addr, (int)val);
 451                 /* assume no sensor is there for sensors for which we can't
 452                    determine the sensor type because their reading is too close
 453                    to their limits, this usually means no sensor is there. */
 454                 return ABIT_UGURU_NC;
 455         }
 456
 457         ABIT_UGURU_DEBUG(2, "testing bank1 sensor %d\n", (int)sensor_addr);
 458         /* Volt sensor test, enable volt low alarm, set min value ridicously
 459            high, or vica versa if the reading is very high. If its a volt
 460            sensor this should always give us an alarm. */
 461         if (val <= 240u) {
 462                 buf[0] = ABIT_UGURU_VOLT_LOW_ALARM_ENABLE;
 463                 buf[1] = 245;
 464                 buf[2] = 250;
 465                 test_flag = ABIT_UGURU_VOLT_LOW_ALARM_FLAG;
 466         } else {
 467                 buf[0] = ABIT_UGURU_VOLT_HIGH_ALARM_ENABLE;
 468                 buf[1] = 5;
 469                 buf[2] = 10;
 470                 test_flag = ABIT_UGURU_VOLT_HIGH_ALARM_FLAG;
 471         }
 472
 473         if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, sensor_addr,
 474                         buf, 3) != 3)
 475                 goto abituguru_detect_bank1_sensor_type_exit;
 476         /* Now we need 20 ms to give the uguru time to read the sensors
 477            and raise a voltage alarm */
 478         set_current_state(TASK_UNINTERRUPTIBLE);
 479         schedule_timeout(HZ/50);
 480         /* Check for alarm and check the alarm is a volt low alarm. */
 481         if (abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0, buf, 3,
 482                         ABIT_UGURU_MAX_RETRIES) != 3)
 483                 goto abituguru_detect_bank1_sensor_type_exit;
 484         if (buf[sensor_addr/8] & (0x01 << (sensor_addr % 8))) {
 485                 if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1 + 1,
 486                                 sensor_addr, buf, 3,
 487                                 ABIT_UGURU_MAX_RETRIES) != 3)
 488                         goto abituguru_detect_bank1_sensor_type_exit;
 489                 if (buf[0] & test_flag) {
 490                         ABIT_UGURU_DEBUG(2, "  found volt sensor\n");
 491                         ret = ABIT_UGURU_IN_SENSOR;
 492                         goto abituguru_detect_bank1_sensor_type_exit;
 493                 } else
 494                         ABIT_UGURU_DEBUG(2, "  alarm raised during volt "
 495                                 "sensor test, but volt range flag not set\n");
 496         } else
 497                 ABIT_UGURU_DEBUG(2, "  alarm not raised during volt sensor "
 498                         "test\n");
 499
 500         /* Temp sensor test, enable sensor as a temp sensor, set beep value
 501            ridicously low (but not too low, otherwise uguru ignores it).
 502            If its a temp sensor this should always give us an alarm. */
 503         buf[0] = ABIT_UGURU_TEMP_HIGH_ALARM_ENABLE;
 504         buf[1] = 5;
 505         buf[2] = 10;
 506         if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, sensor_addr,
 507                         buf, 3) != 3)
 508                 goto abituguru_detect_bank1_sensor_type_exit;
 509         /* Now we need 50 ms to give the uguru time to read the sensors
 510            and raise a temp alarm */
 511         set_current_state(TASK_UNINTERRUPTIBLE);
 512         schedule_timeout(HZ/20);
 513         /* Check for alarm and check the alarm is a temp high alarm. */
 514         if (abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0, buf, 3,
 515                         ABIT_UGURU_MAX_RETRIES) != 3)
 516                 goto abituguru_detect_bank1_sensor_type_exit;
 517         if (buf[sensor_addr/8] & (0x01 << (sensor_addr % 8))) {
 518                 if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1 + 1,
 519                                 sensor_addr, buf, 3,
 520                                 ABIT_UGURU_MAX_RETRIES) != 3)
 521                         goto abituguru_detect_bank1_sensor_type_exit;
 522                 if (buf[0] & ABIT_UGURU_TEMP_HIGH_ALARM_FLAG) {
 523                         ABIT_UGURU_DEBUG(2, "  found temp sensor\n");
 524                         ret = ABIT_UGURU_TEMP_SENSOR;
 525                         goto abituguru_detect_bank1_sensor_type_exit;
 526                 } else
 527                         ABIT_UGURU_DEBUG(2, "  alarm raised during temp "
 528                                 "sensor test, but temp high flag not set\n");
 529         } else
 530                 ABIT_UGURU_DEBUG(2, "  alarm not raised during temp sensor "
 531                         "test\n");
 532
 533         ret = ABIT_UGURU_NC;
 534 abituguru_detect_bank1_sensor_type_exit:
 535         /* Restore original settings, failing here is really BAD, it has been
 536            reported that some BIOS-es hang when entering the uGuru menu with
 537            invalid settings present in the uGuru, so we try this 3 times. */
 538         for (i = 0; i < 3; i++)
 539                 if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2,
 540                                 sensor_addr, data->bank1_settings[sensor_addr],
 541                                 3) == 3)
 542                         break;
 543         if (i == 3) {
 544                 pr_err("Fatal error could not restore original settings. %s %s\n",
 545                        never_happen, report_this);
 546                 return -ENODEV;
 547         }
 548         return ret;
 549 }
 550
 551 /* These functions try to find out how many sensors there are in bank2 and how
 552    many pwms there are. The purpose of this is to make sure that we don't give
 553    the user the possibility to change settings for non-existent sensors / pwm.
 554    The uGuru will happily read / write whatever memory happens to be after the
 555    memory storing the PWM settings when reading/writing to a PWM which is not
 556    there. Notice even if we detect a PWM which doesn't exist we normally won't
 557    write to it, unless the user tries to change the settings.
 558
 559    Although the uGuru allows reading (settings) from non existing bank2
 560    sensors, my version of the uGuru does seem to stop writing to them, the
 561    write function above aborts in this case with:
 562    "CMD reg does not hold 0xAC after write"
 563
 564    Notice these 2 tests are non destructive iow read-only tests, otherwise
 565    they would defeat their purpose. Although for the bank2_sensors detection a
 566    read/write test would be feasible because of the reaction above, I've
 567    however opted to stay on the safe side. */
 568 static void __devinit
 569 abituguru_detect_no_bank2_sensors(struct abituguru_data *data)
 570 {
 571         int i;
 572
 573         if (fan_sensors > 0 && fan_sensors <= ABIT_UGURU_MAX_BANK2_SENSORS) {
 574                 data->bank2_sensors = fan_sensors;
 575                 ABIT_UGURU_DEBUG(2, "assuming %d fan sensors because of "
 576                         "\"fan_sensors\" module param\n",
 577                         (int)data->bank2_sensors);
 578                 return;
 579         }
 580
 581         ABIT_UGURU_DEBUG(2, "detecting number of fan sensors\n");
 582         for (i = 0; i < ABIT_UGURU_MAX_BANK2_SENSORS; i++) {
 583                 /* 0x89 are the known used bits:
 584                    -0x80 enable shutdown
 585                    -0x08 enable beep
 586                    -0x01 enable alarm
 587                    All other bits should be 0, but on some motherboards
 588                    0x40 (bit 6) is also high for some of the fans?? */
 589                 if (data->bank2_settings[i][0] & ~0xC9) {
 590                         ABIT_UGURU_DEBUG(2, "  bank2 sensor %d does not seem "
 591                                 "to be a fan sensor: settings[0] = %02X\n",
 592                                 i, (unsigned int)data->bank2_settings[i][0]);
 593                         break;
 594                 }
 595
 596                 /* check if the threshold is within the allowed range */
 597                 if (data->bank2_settings[i][1] <
 598                                 abituguru_bank2_min_threshold) {
 599                         ABIT_UGURU_DEBUG(2, "  bank2 sensor %d does not seem "
 600                                 "to be a fan sensor: the threshold (%d) is "
 601                                 "below the minimum (%d)\n", i,
 602                                 (int)data->bank2_settings[i][1],
 603                                 (int)abituguru_bank2_min_threshold);
 604                         break;
 605                 }
 606                 if (data->bank2_settings[i][1] >
 607                                 abituguru_bank2_max_threshold) {
 608                         ABIT_UGURU_DEBUG(2, "  bank2 sensor %d does not seem "
 609                                 "to be a fan sensor: the threshold (%d) is "
 610                                 "above the maximum (%d)\n", i,
 611                                 (int)data->bank2_settings[i][1],
 612                                 (int)abituguru_bank2_max_threshold);
 613                         break;
 614                 }
 615         }
 616
 617         data->bank2_sensors = i;
 618         ABIT_UGURU_DEBUG(2, " found: %d fan sensors\n",
 619                 (int)data->bank2_sensors);
 620 }
 621
 622 static void __devinit
 623 abituguru_detect_no_pwms(struct abituguru_data *data)
 624 {
 625         int i, j;
 626
 627         if (pwms > 0 && pwms <= ABIT_UGURU_MAX_PWMS) {
 628                 data->pwms = pwms;
 629                 ABIT_UGURU_DEBUG(2, "assuming %d PWM outputs because of "
 630                         "\"pwms\" module param\n", (int)data->pwms);
 631                 return;
 632         }
 633
 634         ABIT_UGURU_DEBUG(2, "detecting number of PWM outputs\n");
 635         for (i = 0; i < ABIT_UGURU_MAX_PWMS; i++) {
 636                 /* 0x80 is the enable bit and the low
 637                    nibble is which temp sensor to use,
 638                    the other bits should be 0 */
 639                 if (data->pwm_settings[i][0] & ~0x8F) {
 640                         ABIT_UGURU_DEBUG(2, "  pwm channel %d does not seem "
 641                                 "to be a pwm channel: settings[0] = %02X\n",
 642                                 i, (unsigned int)data->pwm_settings[i][0]);
 643                         break;
 644                 }
 645
 646                 /* the low nibble must correspond to one of the temp sensors
 647                    we've found */
 648                 for (j = 0; j < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR];
 649                                 j++) {
 650                         if (data->bank1_address[ABIT_UGURU_TEMP_SENSOR][j] ==
 651                                         (data->pwm_settings[i][0] & 0x0F))
 652                                 break;
 653                 }
 654                 if (j == data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]) {
 655                         ABIT_UGURU_DEBUG(2, "  pwm channel %d does not seem "
 656                                 "to be a pwm channel: %d is not a valid temp "
 657                                 "sensor address\n", i,
 658                                 data->pwm_settings[i][0] & 0x0F);
 659                         break;
 660                 }
 661
 662                 /* check if all other settings are within the allowed range */
 663                 for (j = 1; j < 5; j++) {
 664                         u8 min;
 665                         /* special case pwm1 min pwm% */
 666                         if ((i == 0) && ((j == 1) || (j == 2)))
 667                                 min = 77;
 668                         else
 669                                 min = abituguru_pwm_min[j];
 670                         if (data->pwm_settings[i][j] < min) {
 671                                 ABIT_UGURU_DEBUG(2, "  pwm channel %d does "
 672                                         "not seem to be a pwm channel: "
 673                                         "setting %d (%d) is below the minimum "
 674                                         "value (%d)\n", i, j,
 675                                         (int)data->pwm_settings[i][j],
 676                                         (int)min);
 677                                 goto abituguru_detect_no_pwms_exit;
 678                         }
 679                         if (data->pwm_settings[i][j] > abituguru_pwm_max[j]) {
 680                                 ABIT_UGURU_DEBUG(2, "  pwm channel %d does "
 681                                         "not seem to be a pwm channel: "
 682                                         "setting %d (%d) is above the maximum "
 683                                         "value (%d)\n", i, j,
 684                                         (int)data->pwm_settings[i][j],
 685                                         (int)abituguru_pwm_max[j]);
 686                                 goto abituguru_detect_no_pwms_exit;
 687                         }
 688                 }
 689
 690                 /* check that min temp < max temp and min pwm < max pwm */
 691                 if (data->pwm_settings[i][1] >= data->pwm_settings[i][2]) {
 692                         ABIT_UGURU_DEBUG(2, "  pwm channel %d does not seem "
 693                                 "to be a pwm channel: min pwm (%d) >= "
 694                                 "max pwm (%d)\n", i,
 695                                 (int)data->pwm_settings[i][1],
 696                                 (int)data->pwm_settings[i][2]);
 697                         break;
 698                 }
 699                 if (data->pwm_settings[i][3] >= data->pwm_settings[i][4]) {
 700                         ABIT_UGURU_DEBUG(2, "  pwm channel %d does not seem "
 701                                 "to be a pwm channel: min temp (%d) >= "
 702                                 "max temp (%d)\n", i,
 703                                 (int)data->pwm_settings[i][3],
 704                                 (int)data->pwm_settings[i][4]);
 705                         break;
 706                 }
 707         }
 708
 709 abituguru_detect_no_pwms_exit:
 710         data->pwms = i;
 711         ABIT_UGURU_DEBUG(2, " found: %d PWM outputs\n", (int)data->pwms);
 712 }
 713
 714 /* Following are the sysfs callback functions. These functions expect:
 715    sensor_device_attribute_2->index:   sensor address/offset in the bank
 716    sensor_device_attribute_2->nr:      register offset, bitmask or NA. */
 717 static struct abituguru_data *abituguru_update_device(struct device *dev);
 718
 719 static ssize_t show_bank1_value(struct device *dev,
 720         struct device_attribute *devattr, char *buf)
 721 {
 722         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 723         struct abituguru_data *data = abituguru_update_device(dev);
 724         if (!data)
 725                 return -EIO;
 726         return sprintf(buf, "%d\n", (data->bank1_value[attr->index] *
 727                 data->bank1_max_value[attr->index] + 128) / 255);
 728 }
 729
 730 static ssize_t show_bank1_setting(struct device *dev,
 731         struct device_attribute *devattr, char *buf)
 732 {
 733         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 734         struct abituguru_data *data = dev_get_drvdata(dev);
 735         return sprintf(buf, "%d\n",
 736                 (data->bank1_settings[attr->index][attr->nr] *
 737                 data->bank1_max_value[attr->index] + 128) / 255);
 738 }
 739
 740 static ssize_t show_bank2_value(struct device *dev,
 741         struct device_attribute *devattr, char *buf)
 742 {
 743         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 744         struct abituguru_data *data = abituguru_update_device(dev);
 745         if (!data)
 746                 return -EIO;
 747         return sprintf(buf, "%d\n", (data->bank2_value[attr->index] *
 748                 ABIT_UGURU_FAN_MAX + 128) / 255);
 749 }
 750
 751 static ssize_t show_bank2_setting(struct device *dev,
 752         struct device_attribute *devattr, char *buf)
 753 {
 754         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 755         struct abituguru_data *data = dev_get_drvdata(dev);
 756         return sprintf(buf, "%d\n",
 757                 (data->bank2_settings[attr->index][attr->nr] *
 758                 ABIT_UGURU_FAN_MAX + 128) / 255);
 759 }
 760
 761 static ssize_t store_bank1_setting(struct device *dev, struct device_attribute
 762         *devattr, const char *buf, size_t count)
 763 {
 764         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 765         struct abituguru_data *data = dev_get_drvdata(dev);
 766         u8 val = (simple_strtoul(buf, NULL, 10) * 255 +
 767                 data->bank1_max_value[attr->index]/2) /
 768                 data->bank1_max_value[attr->index];
 769         ssize_t ret = count;
 770
 771         mutex_lock(&data->update_lock);
 772         if (data->bank1_settings[attr->index][attr->nr] != val) {
 773                 u8 orig_val = data->bank1_settings[attr->index][attr->nr];
 774                 data->bank1_settings[attr->index][attr->nr] = val;
 775                 if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2,
 776                                 attr->index, data->bank1_settings[attr->index],
 777                                 3) <= attr->nr) {
 778                         data->bank1_settings[attr->index][attr->nr] = orig_val;
 779                         ret = -EIO;
 780                 }
 781         }
 782         mutex_unlock(&data->update_lock);
 783         return ret;
 784 }
 785
 786 static ssize_t store_bank2_setting(struct device *dev, struct device_attribute
 787         *devattr, const char *buf, size_t count)
 788 {
 789         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 790         struct abituguru_data *data = dev_get_drvdata(dev);
 791         u8 val = (simple_strtoul(buf, NULL, 10)*255 + ABIT_UGURU_FAN_MAX/2) /
 792                 ABIT_UGURU_FAN_MAX;
 793         ssize_t ret = count;
 794
 795         /* this check can be done before taking the lock */
 796         if ((val < abituguru_bank2_min_threshold) ||
 797                         (val > abituguru_bank2_max_threshold))
 798                 return -EINVAL;
 799
 800         mutex_lock(&data->update_lock);
 801         if (data->bank2_settings[attr->index][attr->nr] != val) {
 802                 u8 orig_val = data->bank2_settings[attr->index][attr->nr];
 803                 data->bank2_settings[attr->index][attr->nr] = val;
 804                 if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK2 + 2,
 805                                 attr->index, data->bank2_settings[attr->index],
 806                                 2) <= attr->nr) {
 807                         data->bank2_settings[attr->index][attr->nr] = orig_val;
 808                         ret = -EIO;
 809                 }
 810         }
 811         mutex_unlock(&data->update_lock);
 812         return ret;
 813 }
 814
 815 static ssize_t show_bank1_alarm(struct device *dev,
 816         struct device_attribute *devattr, char *buf)
 817 {
 818         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 819         struct abituguru_data *data = abituguru_update_device(dev);
 820         if (!data)
 821                 return -EIO;
 822         /* See if the alarm bit for this sensor is set, and if the
 823            alarm matches the type of alarm we're looking for (for volt
 824            it can be either low or high). The type is stored in a few
 825            readonly bits in the settings part of the relevant sensor.
 826            The bitmask of the type is passed to us in attr->nr. */
 827         if ((data->alarms[attr->index / 8] & (0x01 << (attr->index % 8))) &&
 828                         (data->bank1_settings[attr->index][0] & attr->nr))
 829                 return sprintf(buf, "1\n");
 830         else
 831                 return sprintf(buf, "0\n");
 832 }
 833
 834 static ssize_t show_bank2_alarm(struct device *dev,
 835         struct device_attribute *devattr, char *buf)
 836 {
 837         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 838         struct abituguru_data *data = abituguru_update_device(dev);
 839         if (!data)
 840                 return -EIO;
 841         if (data->alarms[2] & (0x01 << attr->index))
 842                 return sprintf(buf, "1\n");
 843         else
 844                 return sprintf(buf, "0\n");
 845 }
 846
 847 static ssize_t show_bank1_mask(struct device *dev,
 848         struct device_attribute *devattr, char *buf)
 849 {
 850         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 851         struct abituguru_data *data = dev_get_drvdata(dev);
 852         if (data->bank1_settings[attr->index][0] & attr->nr)
 853                 return sprintf(buf, "1\n");
 854         else
 855                 return sprintf(buf, "0\n");
 856 }
 857
 858 static ssize_t show_bank2_mask(struct device *dev,
 859         struct device_attribute *devattr, char *buf)
 860 {
 861         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 862         struct abituguru_data *data = dev_get_drvdata(dev);
 863         if (data->bank2_settings[attr->index][0] & attr->nr)
 864                 return sprintf(buf, "1\n");
 865         else
 866                 return sprintf(buf, "0\n");
 867 }
 868
 869 static ssize_t store_bank1_mask(struct device *dev,
 870         struct device_attribute *devattr, const char *buf, size_t count)
 871 {
 872         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 873         struct abituguru_data *data = dev_get_drvdata(dev);
 874         int mask = simple_strtoul(buf, NULL, 10);
 875         ssize_t ret = count;
 876         u8 orig_val;
 877
 878         mutex_lock(&data->update_lock);
 879         orig_val = data->bank1_settings[attr->index][0];
 880
 881         if (mask)
 882                 data->bank1_settings[attr->index][0] |= attr->nr;
 883         else
 884                 data->bank1_settings[attr->index][0] &= ~attr->nr;
 885
 886         if ((data->bank1_settings[attr->index][0] != orig_val) &&
 887                         (abituguru_write(data,
 888                         ABIT_UGURU_SENSOR_BANK1 + 2, attr->index,
 889                         data->bank1_settings[attr->index], 3) < 1)) {
 890                 data->bank1_settings[attr->index][0] = orig_val;
 891                 ret = -EIO;
 892         }
 893         mutex_unlock(&data->update_lock);
 894         return ret;
 895 }
 896
 897 static ssize_t store_bank2_mask(struct device *dev,
 898         struct device_attribute *devattr, const char *buf, size_t count)
 899 {
 900         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 901         struct abituguru_data *data = dev_get_drvdata(dev);
 902         int mask = simple_strtoul(buf, NULL, 10);
 903         ssize_t ret = count;
 904         u8 orig_val;
 905
 906         mutex_lock(&data->update_lock);
 907         orig_val = data->bank2_settings[attr->index][0];
 908
 909         if (mask)
 910                 data->bank2_settings[attr->index][0] |= attr->nr;
 911         else
 912                 data->bank2_settings[attr->index][0] &= ~attr->nr;
 913
 914         if ((data->bank2_settings[attr->index][0] != orig_val) &&
 915                         (abituguru_write(data,
 916                         ABIT_UGURU_SENSOR_BANK2 + 2, attr->index,
 917                         data->bank2_settings[attr->index], 2) < 1)) {
 918                 data->bank2_settings[attr->index][0] = orig_val;
 919                 ret = -EIO;
 920         }
 921         mutex_unlock(&data->update_lock);
 922         return ret;
 923 }
 924
 925 /* Fan PWM (speed control) */
 926 static ssize_t show_pwm_setting(struct device *dev,
 927         struct device_attribute *devattr, char *buf)
 928 {
 929         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 930         struct abituguru_data *data = dev_get_drvdata(dev);
 931         return sprintf(buf, "%d\n", data->pwm_settings[attr->index][attr->nr] *
 932                 abituguru_pwm_settings_multiplier[attr->nr]);
 933 }
 934
 935 static ssize_t store_pwm_setting(struct device *dev, struct device_attribute
 936         *devattr, const char *buf, size_t count)
 937 {
 938         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 939         struct abituguru_data *data = dev_get_drvdata(dev);
 940         u8 min, val = (simple_strtoul(buf, NULL, 10) +
 941                 abituguru_pwm_settings_multiplier[attr->nr]/2) /
 942                 abituguru_pwm_settings_multiplier[attr->nr];
 943         ssize_t ret = count;
 944
 945         /* special case pwm1 min pwm% */
 946         if ((attr->index == 0) && ((attr->nr == 1) || (attr->nr == 2)))
 947                 min = 77;
 948         else
 949                 min = abituguru_pwm_min[attr->nr];
 950
 951         /* this check can be done before taking the lock */
 952         if ((val < min) || (val > abituguru_pwm_max[attr->nr]))
 953                 return -EINVAL;
 954
 955         mutex_lock(&data->update_lock);
 956         /* this check needs to be done after taking the lock */
 957         if ((attr->nr & 1) &&
 958                         (val >= data->pwm_settings[attr->index][attr->nr + 1]))
 959                 ret = -EINVAL;
 960         else if (!(attr->nr & 1) &&
 961                         (val <= data->pwm_settings[attr->index][attr->nr - 1]))
 962                 ret = -EINVAL;
 963         else if (data->pwm_settings[attr->index][attr->nr] != val) {
 964                 u8 orig_val = data->pwm_settings[attr->index][attr->nr];
 965                 data->pwm_settings[attr->index][attr->nr] = val;
 966                 if (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1,
 967                                 attr->index, data->pwm_settings[attr->index],
 968                                 5) <= attr->nr) {
 969                         data->pwm_settings[attr->index][attr->nr] =
 970                                 orig_val;
 971                         ret = -EIO;
 972                 }
 973         }
 974         mutex_unlock(&data->update_lock);
 975         return ret;
 976 }
 977
 978 static ssize_t show_pwm_sensor(struct device *dev,
 979         struct device_attribute *devattr, char *buf)
 980 {
 981         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 982         struct abituguru_data *data = dev_get_drvdata(dev);
 983         int i;
 984         /* We need to walk to the temp sensor addresses to find what
 985            the userspace id of the configured temp sensor is. */
 986         for (i = 0; i < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]; i++)
 987                 if (data->bank1_address[ABIT_UGURU_TEMP_SENSOR][i] ==
 988                                 (data->pwm_settings[attr->index][0] & 0x0F))
 989                         return sprintf(buf, "%d\n", i+1);
 990
 991         return -ENXIO;
 992 }
 993
 994 static ssize_t store_pwm_sensor(struct device *dev, struct device_attribute
 995         *devattr, const char *buf, size_t count)
 996 {
 997         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 998         struct abituguru_data *data = dev_get_drvdata(dev);
 999         unsigned long val = simple_strtoul(buf, NULL, 10) - 1;
1000         ssize_t ret = count;
1001
1002         mutex_lock(&data->update_lock);
1003         if (val < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]) {
1004                 u8 orig_val = data->pwm_settings[attr->index][0];
1005                 u8 address = data->bank1_address[ABIT_UGURU_TEMP_SENSOR][val];
1006                 data->pwm_settings[attr->index][0] &= 0xF0;
1007                 data->pwm_settings[attr->index][0] |= address;
1008                 if (data->pwm_settings[attr->index][0] != orig_val) {
1009                         if (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1,
1010                                         attr->index,
1011                                         data->pwm_settings[attr->index],
1012                                         5) < 1) {
1013                                 data->pwm_settings[attr->index][0] = orig_val;
1014                                 ret = -EIO;
1015                         }
1016                 }
1017         }
1018         else
1019                 ret = -EINVAL;
1020         mutex_unlock(&data->update_lock);
1021         return ret;
1022 }
1023
1024 static ssize_t show_pwm_enable(struct device *dev,
1025         struct device_attribute *devattr, char *buf)
1026 {
1027         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
1028         struct abituguru_data *data = dev_get_drvdata(dev);
1029         int res = 0;
1030         if (data->pwm_settings[attr->index][0] & ABIT_UGURU_FAN_PWM_ENABLE)
1031                 res = 2;
1032         return sprintf(buf, "%d\n", res);
1033 }
1034
1035 static ssize_t store_pwm_enable(struct device *dev, struct device_attribute
1036         *devattr, const char *buf, size_t count)
1037 {
1038         struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
1039         struct abituguru_data *data = dev_get_drvdata(dev);
1040         u8 orig_val, user_val = simple_strtoul(buf, NULL, 10);
1041         ssize_t ret = count;
1042
1043         mutex_lock(&data->update_lock);
1044         orig_val = data->pwm_settings[attr->index][0];
1045         switch (user_val) {
1046                 case 0:
1047                         data->pwm_settings[attr->index][0] &=
1048                                 ~ABIT_UGURU_FAN_PWM_ENABLE;
1049                         break;
1050                 case 2:
1051                         data->pwm_settings[attr->index][0] |=
1052                                 ABIT_UGURU_FAN_PWM_ENABLE;
1053                         break;
1054                 default:
1055                         ret = -EINVAL;
1056         }
1057         if ((data->pwm_settings[attr->index][0] != orig_val) &&
1058                         (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1,
1059                         attr->index, data->pwm_settings[attr->index],
1060                         5) < 1)) {
1061                 data->pwm_settings[attr->index][0] = orig_val;
1062                 ret = -EIO;
1063         }
1064         mutex_unlock(&data->update_lock);
1065         return ret;
1066 }
1067
1068 static ssize_t show_name(struct device *dev,
1069         struct device_attribute *devattr, char *buf)
1070 {
1071         return sprintf(buf, "%s\n", ABIT_UGURU_NAME);
1072 }
1073
1074 /* Sysfs attr templates, the real entries are generated automatically. */
1075 static const
1076 struct sensor_device_attribute_2 abituguru_sysfs_bank1_templ[2][9] = {
1077         {
1078         SENSOR_ATTR_2(in%d_input, 0444, show_bank1_value, NULL, 0, 0),
1079         SENSOR_ATTR_2(in%d_min, 0644, show_bank1_setting,
1080                 store_bank1_setting, 1, 0),
1081         SENSOR_ATTR_2(in%d_min_alarm, 0444, show_bank1_alarm, NULL,
1082                 ABIT_UGURU_VOLT_LOW_ALARM_FLAG, 0),
1083         SENSOR_ATTR_2(in%d_max, 0644, show_bank1_setting,
1084                 store_bank1_setting, 2, 0),
1085         SENSOR_ATTR_2(in%d_max_alarm, 0444, show_bank1_alarm, NULL,
1086                 ABIT_UGURU_VOLT_HIGH_ALARM_FLAG, 0),
1087         SENSOR_ATTR_2(in%d_beep, 0644, show_bank1_mask,
1088                 store_bank1_mask, ABIT_UGURU_BEEP_ENABLE, 0),
1089         SENSOR_ATTR_2(in%d_shutdown, 0644, show_bank1_mask,
1090                 store_bank1_mask, ABIT_UGURU_SHUTDOWN_ENABLE, 0),
1091         SENSOR_ATTR_2(in%d_min_alarm_enable, 0644, show_bank1_mask,
1092                 store_bank1_mask, ABIT_UGURU_VOLT_LOW_ALARM_ENABLE, 0),
1093         SENSOR_ATTR_2(in%d_max_alarm_enable, 0644, show_bank1_mask,
1094                 store_bank1_mask, ABIT_UGURU_VOLT_HIGH_ALARM_ENABLE, 0),
1095         }, {
1096         SENSOR_ATTR_2(temp%d_input, 0444, show_bank1_value, NULL, 0, 0),
1097         SENSOR_ATTR_2(temp%d_alarm, 0444, show_bank1_alarm, NULL,
1098                 ABIT_UGURU_TEMP_HIGH_ALARM_FLAG, 0),
1099         SENSOR_ATTR_2(temp%d_max, 0644, show_bank1_setting,
1100                 store_bank1_setting, 1, 0),
1101         SENSOR_ATTR_2(temp%d_crit, 0644, show_bank1_setting,
1102                 store_bank1_setting, 2, 0),
1103         SENSOR_ATTR_2(temp%d_beep, 0644, show_bank1_mask,
1104                 store_bank1_mask, ABIT_UGURU_BEEP_ENABLE, 0),
1105         SENSOR_ATTR_2(temp%d_shutdown, 0644, show_bank1_mask,
1106                 store_bank1_mask, ABIT_UGURU_SHUTDOWN_ENABLE, 0),
1107         SENSOR_ATTR_2(temp%d_alarm_enable, 0644, show_bank1_mask,
1108                 store_bank1_mask, ABIT_UGURU_TEMP_HIGH_ALARM_ENABLE, 0),
1109         }
1110 };
1111
1112 static const struct sensor_device_attribute_2 abituguru_sysfs_fan_templ[6] = {
1113         SENSOR_ATTR_2(fan%d_input, 0444, show_bank2_value, NULL, 0, 0),
1114         SENSOR_ATTR_2(fan%d_alarm, 0444, show_bank2_alarm, NULL, 0, 0),
1115         SENSOR_ATTR_2(fan%d_min, 0644, show_bank2_setting,
1116                 store_bank2_setting, 1, 0),
1117         SENSOR_ATTR_2(fan%d_beep, 0644, show_bank2_mask,
1118                 store_bank2_mask, ABIT_UGURU_BEEP_ENABLE, 0),
1119         SENSOR_ATTR_2(fan%d_shutdown, 0644, show_bank2_mask,
1120                 store_bank2_mask, ABIT_UGURU_SHUTDOWN_ENABLE, 0),
1121         SENSOR_ATTR_2(fan%d_alarm_enable, 0644, show_bank2_mask,
1122                 store_bank2_mask, ABIT_UGURU_FAN_LOW_ALARM_ENABLE, 0),
1123 };
1124
1125 static const struct sensor_device_attribute_2 abituguru_sysfs_pwm_templ[6] = {
1126         SENSOR_ATTR_2(pwm%d_enable, 0644, show_pwm_enable,
1127                 store_pwm_enable, 0, 0),
1128         SENSOR_ATTR_2(pwm%d_auto_channels_temp, 0644, show_pwm_sensor,
1129                 store_pwm_sensor, 0, 0),
1130         SENSOR_ATTR_2(pwm%d_auto_point1_pwm, 0644, show_pwm_setting,
1131                 store_pwm_setting, 1, 0),
1132         SENSOR_ATTR_2(pwm%d_auto_point2_pwm, 0644, show_pwm_setting,
1133                 store_pwm_setting, 2, 0),
1134         SENSOR_ATTR_2(pwm%d_auto_point1_temp, 0644, show_pwm_setting,
1135                 store_pwm_setting, 3, 0),
1136         SENSOR_ATTR_2(pwm%d_auto_point2_temp, 0644, show_pwm_setting,
1137                 store_pwm_setting, 4, 0),
1138 };
1139
1140 static struct sensor_device_attribute_2 abituguru_sysfs_attr[] = {
1141         SENSOR_ATTR_2(name, 0444, show_name, NULL, 0, 0),
1142 };
1143
1144 static int __devinit abituguru_probe(struct platform_device *pdev)
1145 {
1146         struct abituguru_data *data;
1147         int i, j, used, sysfs_names_free, sysfs_attr_i, res = -ENODEV;
1148         char *sysfs_filename;
1149
1150         /* El weirdo probe order, to keep the sysfs order identical to the
1151            BIOS and window-appliction listing order. */
1152         const u8 probe_order[ABIT_UGURU_MAX_BANK1_SENSORS] = {
1153                 0x00, 0x01, 0x03, 0x04, 0x0A, 0x08, 0x0E, 0x02,
1154                 0x09, 0x06, 0x05, 0x0B, 0x0F, 0x0D, 0x07, 0x0C };
1155
1156         if (!(data = kzalloc(sizeof(struct abituguru_data), GFP_KERNEL)))
1157                 return -ENOMEM;
1158
1159         data->addr = platform_get_resource(pdev, IORESOURCE_IO, 0)->start;
1160         mutex_init(&data->update_lock);
1161         platform_set_drvdata(pdev, data);
1162
1163         /* See if the uGuru is ready */
1164         if (inb_p(data->addr + ABIT_UGURU_DATA) == ABIT_UGURU_STATUS_INPUT)
1165                 data->uguru_ready = 1;
1166
1167         /* Completely read the uGuru this has 2 purposes:
1168            - testread / see if one really is there.
1169            - make an in memory copy of all the uguru settings for future use. */
1170         if (abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0,
1171                         data->alarms, 3, ABIT_UGURU_MAX_RETRIES) != 3)
1172                 goto abituguru_probe_error;
1173
1174         for (i = 0; i < ABIT_UGURU_MAX_BANK1_SENSORS; i++) {
1175                 if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1, i,
1176                                 &data->bank1_value[i], 1,
1177                                 ABIT_UGURU_MAX_RETRIES) != 1)
1178                         goto abituguru_probe_error;
1179                 if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1+1, i,
1180                                 data->bank1_settings[i], 3,
1181                                 ABIT_UGURU_MAX_RETRIES) != 3)
1182                         goto abituguru_probe_error;
1183         }
1184         /* Note: We don't know how many bank2 sensors / pwms there really are,
1185            but in order to "detect" this we need to read the maximum amount
1186            anyways. If we read sensors/pwms not there we'll just read crap
1187            this can't hurt. We need the detection because we don't want
1188            unwanted writes, which will hurt! */
1189         for (i = 0; i < ABIT_UGURU_MAX_BANK2_SENSORS; i++) {
1190                 if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK2, i,
1191                                 &data->bank2_value[i], 1,
1192                                 ABIT_UGURU_MAX_RETRIES) != 1)
1193                         goto abituguru_probe_error;
1194                 if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK2+1, i,
1195                                 data->bank2_settings[i], 2,
1196                                 ABIT_UGURU_MAX_RETRIES) != 2)
1197                         goto abituguru_probe_error;
1198         }
1199         for (i = 0; i < ABIT_UGURU_MAX_PWMS; i++) {
1200                 if (abituguru_read(data, ABIT_UGURU_FAN_PWM, i,
1201                                 data->pwm_settings[i], 5,
1202                                 ABIT_UGURU_MAX_RETRIES) != 5)
1203                         goto abituguru_probe_error;
1204         }
1205         data->last_updated = jiffies;
1206
1207         /* Detect sensor types and fill the sysfs attr for bank1 */
1208         sysfs_attr_i = 0;
1209         sysfs_filename = data->sysfs_names;
1210         sysfs_names_free = ABITUGURU_SYSFS_NAMES_LENGTH;
1211         for (i = 0; i < ABIT_UGURU_MAX_BANK1_SENSORS; i++) {
1212                 res = abituguru_detect_bank1_sensor_type(data, probe_order[i]);
1213                 if (res < 0)
1214                         goto abituguru_probe_error;
1215                 if (res == ABIT_UGURU_NC)
1216                         continue;
1217
1218                 /* res 1 (temp) sensors have 7 sysfs entries, 0 (in) 9 */
1219                 for (j = 0; j < (res ? 7 : 9); j++) {
1220                         used = snprintf(sysfs_filename, sysfs_names_free,
1221                                 abituguru_sysfs_bank1_templ[res][j].dev_attr.
1222                                 attr.name, data->bank1_sensors[res] + res)
1223                                 + 1;
1224                         data->sysfs_attr[sysfs_attr_i] =
1225                                 abituguru_sysfs_bank1_templ[res][j];
1226                         data->sysfs_attr[sysfs_attr_i].dev_attr.attr.name =
1227                                 sysfs_filename;
1228                         data->sysfs_attr[sysfs_attr_i].index = probe_order[i];
1229                         sysfs_filename += used;
1230                         sysfs_names_free -= used;
1231                         sysfs_attr_i++;
1232                 }
1233                 data->bank1_max_value[probe_order[i]] =
1234                         abituguru_bank1_max_value[res];
1235                 data->bank1_address[res][data->bank1_sensors[res]] =
1236                         probe_order[i];
1237                 data->bank1_sensors[res]++;
1238         }
1239         /* Detect number of sensors and fill the sysfs attr for bank2 (fans) */
1240         abituguru_detect_no_bank2_sensors(data);
1241         for (i = 0; i < data->bank2_sensors; i++) {
1242                 for (j = 0; j < ARRAY_SIZE(abituguru_sysfs_fan_templ); j++) {
1243                         used = snprintf(sysfs_filename, sysfs_names_free,
1244                                 abituguru_sysfs_fan_templ[j].dev_attr.attr.name,
1245                                 i + 1) + 1;
1246                         data->sysfs_attr[sysfs_attr_i] =
1247                                 abituguru_sysfs_fan_templ[j];
1248                         data->sysfs_attr[sysfs_attr_i].dev_attr.attr.name =
1249                                 sysfs_filename;
1250                         data->sysfs_attr[sysfs_attr_i].index = i;
1251                         sysfs_filename += used;
1252                         sysfs_names_free -= used;
1253                         sysfs_attr_i++;
1254                 }
1255         }
1256         /* Detect number of sensors and fill the sysfs attr for pwms */
1257         abituguru_detect_no_pwms(data);
1258         for (i = 0; i < data->pwms; i++) {
1259                 for (j = 0; j < ARRAY_SIZE(abituguru_sysfs_pwm_templ); j++) {
1260                         used = snprintf(sysfs_filename, sysfs_names_free,
1261                                 abituguru_sysfs_pwm_templ[j].dev_attr.attr.name,
1262                                 i + 1) + 1;
1263                         data->sysfs_attr[sysfs_attr_i] =
1264                                 abituguru_sysfs_pwm_templ[j];
1265                         data->sysfs_attr[sysfs_attr_i].dev_attr.attr.name =
1266                                 sysfs_filename;
1267                         data->sysfs_attr[sysfs_attr_i].index = i;
1268                         sysfs_filename += used;
1269                         sysfs_names_free -= used;
1270                         sysfs_attr_i++;
1271                 }
1272         }
1273         /* Fail safe check, this should never happen! */
1274         if (sysfs_names_free < 0) {
1275                 pr_err("Fatal error ran out of space for sysfs attr names. %s %s",
1276                        never_happen, report_this);
1277                 res = -ENAMETOOLONG;
1278                 goto abituguru_probe_error;
1279         }
1280         pr_info("found Abit uGuru\n");
1281
1282         /* Register sysfs hooks */
1283         for (i = 0; i < sysfs_attr_i; i++)
1284                 if (device_create_file(&pdev->dev,
1285                                 &data->sysfs_attr[i].dev_attr))
1286                         goto abituguru_probe_error;
1287         for (i = 0; i < ARRAY_SIZE(abituguru_sysfs_attr); i++)
1288                 if (device_create_file(&pdev->dev,
1289                                 &abituguru_sysfs_attr[i].dev_attr))
1290                         goto abituguru_probe_error;
1291
1292         data->hwmon_dev = hwmon_device_register(&pdev->dev);
1293         if (!IS_ERR(data->hwmon_dev))
1294                 return 0; /* success */
1295
1296         res = PTR_ERR(data->hwmon_dev);
1297 abituguru_probe_error:
1298         for (i = 0; data->sysfs_attr[i].dev_attr.attr.name; i++)
1299                 device_remove_file(&pdev->dev, &data->sysfs_attr[i].dev_attr);
1300         for (i = 0; i < ARRAY_SIZE(abituguru_sysfs_attr); i++)
1301                 device_remove_file(&pdev->dev,
1302                         &abituguru_sysfs_attr[i].dev_attr);
1303         platform_set_drvdata(pdev, NULL);
1304         kfree(data);
1305         return res;
1306 }
1307
1308 static int __devexit abituguru_remove(struct platform_device *pdev)
1309 {
1310         int i;
1311         struct abituguru_data *data = platform_get_drvdata(pdev);
1312
1313         hwmon_device_unregister(data->hwmon_dev);
1314         for (i = 0; data->sysfs_attr[i].dev_attr.attr.name; i++)
1315                 device_remove_file(&pdev->dev, &data->sysfs_attr[i].dev_attr);
1316         for (i = 0; i < ARRAY_SIZE(abituguru_sysfs_attr); i++)
1317                 device_remove_file(&pdev->dev,
1318                         &abituguru_sysfs_attr[i].dev_attr);
1319         platform_set_drvdata(pdev, NULL);
1320         kfree(data);
1321
1322         return 0;
1323 }
1324
1325 static struct abituguru_data *abituguru_update_device(struct device *dev)
1326 {
1327         int i, err;
1328         struct abituguru_data *data = dev_get_drvdata(dev);
1329         /* fake a complete successful read if no update necessary. */
1330         char success = 1;
1331
1332         mutex_lock(&data->update_lock);
1333         if (time_after(jiffies, data->last_updated + HZ)) {
1334                 success = 0;
1335                 if ((err = abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0,
1336                                 data->alarms, 3, 0)) != 3)
1337                         goto LEAVE_UPDATE;
1338                 for (i = 0; i < ABIT_UGURU_MAX_BANK1_SENSORS; i++) {
1339                         if ((err = abituguru_read(data,
1340                                         ABIT_UGURU_SENSOR_BANK1, i,
1341                                         &data->bank1_value[i], 1, 0)) != 1)
1342                                 goto LEAVE_UPDATE;
1343                         if ((err = abituguru_read(data,
1344                                         ABIT_UGURU_SENSOR_BANK1 + 1, i,
1345                                         data->bank1_settings[i], 3, 0)) != 3)
1346                                 goto LEAVE_UPDATE;
1347                 }
1348                 for (i = 0; i < data->bank2_sensors; i++)
1349                         if ((err = abituguru_read(data,
1350                                         ABIT_UGURU_SENSOR_BANK2, i,
1351                                         &data->bank2_value[i], 1, 0)) != 1)
1352                                 goto LEAVE_UPDATE;
1353                 /* success! */
1354                 success = 1;
1355                 data->update_timeouts = 0;
1356 LEAVE_UPDATE:
1357                 /* handle timeout condition */
1358                 if (!success && (err == -EBUSY || err >= 0)) {
1359                         /* No overflow please */
1360                         if (data->update_timeouts < 255u)
1361                                 data->update_timeouts++;
1362                         if (data->update_timeouts <= ABIT_UGURU_MAX_TIMEOUTS) {
1363                                 ABIT_UGURU_DEBUG(3, "timeout exceeded, will "
1364                                         "try again next update\n");
1365                                 /* Just a timeout, fake a successful read */
1366                                 success = 1;
1367                         } else
1368                                 ABIT_UGURU_DEBUG(1, "timeout exceeded %d "
1369                                         "times waiting for more input state\n",
1370                                         (int)data->update_timeouts);
1371                 }
1372                 /* On success set last_updated */
1373                 if (success)
1374                         data->last_updated = jiffies;
1375         }
1376         mutex_unlock(&data->update_lock);
1377
1378         if (success)
1379                 return data;
1380         else
1381                 return NULL;
1382 }
1383
1384 #ifdef CONFIG_PM
1385 static int abituguru_suspend(struct platform_device *pdev, pm_message_t state)
1386 {
1387         struct abituguru_data *data = platform_get_drvdata(pdev);
1388         /* make sure all communications with the uguru are done and no new
1389            ones are started */
1390         mutex_lock(&data->update_lock);
1391         return 0;
1392 }
1393
1394 static int abituguru_resume(struct platform_device *pdev)
1395 {
1396         struct abituguru_data *data = platform_get_drvdata(pdev);
1397         /* See if the uGuru is still ready */
1398         if (inb_p(data->addr + ABIT_UGURU_DATA) != ABIT_UGURU_STATUS_INPUT)
1399                 data->uguru_ready = 0;
1400         mutex_unlock(&data->update_lock);
1401         return 0;
1402 }
1403 #else
1404 #define abituguru_suspend       NULL
1405 #define abituguru_resume        NULL
1406 #endif /* CONFIG_PM */
1407
1408 static struct platform_driver abituguru_driver = {
1409         .driver = {
1410                 .owner  = THIS_MODULE,
1411                 .name   = ABIT_UGURU_NAME,
1412         },
1413         .probe          = abituguru_probe,
1414         .remove         = __devexit_p(abituguru_remove),
1415         .suspend        = abituguru_suspend,
1416         .resume         = abituguru_resume,
1417 };
1418
1419 static int __init abituguru_detect(void)
1420 {
1421         /* See if there is an uguru there. After a reboot uGuru will hold 0x00
1422            at DATA and 0xAC, when this driver has already been loaded once
1423            DATA will hold 0x08. For most uGuru's CMD will hold 0xAC in either
1424            scenario but some will hold 0x00.
1425            Some uGuru's initially hold 0x09 at DATA and will only hold 0x08
1426            after reading CMD first, so CMD must be read first! */
1427         u8 cmd_val = inb_p(ABIT_UGURU_BASE + ABIT_UGURU_CMD);
1428         u8 data_val = inb_p(ABIT_UGURU_BASE + ABIT_UGURU_DATA);
1429         if (((data_val == 0x00) || (data_val == 0x08)) &&
1430             ((cmd_val == 0x00) || (cmd_val == 0xAC)))
1431                 return ABIT_UGURU_BASE;
1432
1433         ABIT_UGURU_DEBUG(2, "no Abit uGuru found, data = 0x%02X, cmd = "
1434                 "0x%02X\n", (unsigned int)data_val, (unsigned int)cmd_val);
1435
1436         if (force) {
1437                 pr_info("Assuming Abit uGuru is present because of \"force\" parameter\n");
1438                 return ABIT_UGURU_BASE;
1439         }
1440
1441         /* No uGuru found */
1442         return -ENODEV;
1443 }
1444
1445 static struct platform_device *abituguru_pdev;
1446
1447 static int __init abituguru_init(void)
1448 {
1449         int address, err;
1450         struct resource res = { .flags = IORESOURCE_IO };
1451
1452 #ifdef CONFIG_DMI
1453         const char *board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
1454
1455         /* safety check, refuse to load on non Abit motherboards */
1456         if (!force && (!board_vendor ||
1457                         strcmp(board_vendor, "http://www.abit.com.tw/")))
1458                 return -ENODEV;
1459 #endif
1460
1461         address = abituguru_detect();
1462         if (address < 0)
1463                 return address;
1464
1465         err = platform_driver_register(&abituguru_driver);
1466         if (err)
1467                 goto exit;
1468
1469         abituguru_pdev = platform_device_alloc(ABIT_UGURU_NAME, address);
1470         if (!abituguru_pdev) {
1471                 pr_err("Device allocation failed\n");
1472                 err = -ENOMEM;
1473                 goto exit_driver_unregister;
1474         }
1475
1476         res.start = address;
1477         res.end = address + ABIT_UGURU_REGION_LENGTH - 1;
1478         res.name = ABIT_UGURU_NAME;
1479
1480         err = platform_device_add_resources(abituguru_pdev, &res, 1);
1481         if (err) {
1482                 pr_err("Device resource addition failed (%d)\n", err);
1483                 goto exit_device_put;
1484         }
1485
1486         err = platform_device_add(abituguru_pdev);
1487         if (err) {
1488                 pr_err("Device addition failed (%d)\n", err);
1489                 goto exit_device_put;
1490         }
1491
1492         return 0;
1493
1494 exit_device_put:
1495         platform_device_put(abituguru_pdev);
1496 exit_driver_unregister:
1497         platform_driver_unregister(&abituguru_driver);
1498 exit:
1499         return err;
1500 }
1501
1502 static void __exit abituguru_exit(void)
1503 {
1504         platform_device_unregister(abituguru_pdev);
1505         platform_driver_unregister(&abituguru_driver);
1506 }
1507
1508 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
1509 MODULE_DESCRIPTION("Abit uGuru Sensor device");
1510 MODULE_LICENSE("GPL");
1511
1512 module_init(abituguru_init);
1513 module_exit(abituguru_exit);