39 files changed, 2273 insertions, 1138 deletions
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 5ce43d8dfa98..bc196f49ec53 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -111,22 +111,6 @@ config SENSORS_AD7418
          This driver can also be built as a module. If so, the module
          will be called ad7418.
-config SENSORS_ADCXX
-        tristate "National Semiconductor ADCxxxSxxx"
-        depends on SPI_MASTER
-        help
-          If you say yes here you get support for the National Semiconductor
-          ADC<bb><c>S<sss> chip family, where
-          * bb  is the resolution in number of bits (8, 10, 12)
-          * c   is the number of channels (1, 2, 4, 8)
-          * sss is the maximum conversion speed (021 for 200 kSPS, 051 for 500
-            kSPS and 101 for 1 MSPS)
-          Examples : ADC081S101, ADC124S501, ...
-          This driver can also be built as a module.  If so, the module
-          will be called adcxx.
 config SENSORS_ADM1021
        tristate "Analog Devices ADM1021 and compatibles"
        depends on I2C
@@ -296,8 +280,8 @@ config SENSORS_K10TEMP
          If you say yes here you get support for the temperature
          sensor(s) inside your CPU. Supported are later revisions of
          the AMD Family 10h and all revisions of the AMD Family 11h,
-          12h (Llano), 14h (Brazos), 15h (Bulldozer/Trinity) and
+          12h (Llano), 14h (Brazos), 15h (Bulldozer/Trinity/Kaveri) and
-          16h (Kabini) microarchitectures.
+          16h (Kabini/Mullins) microarchitectures.
          This driver can also be built as a module.  If so, the module
          will be called k10temp.
@@ -312,6 +296,31 @@ config SENSORS_FAM15H_POWER
          This driver can also be built as a module.  If so, the module
          will be called fam15h_power.
+config SENSORS_APPLESMC
+        tristate "Apple SMC (Motion sensor, light sensor, keyboard backlight)"
+        depends on INPUT && X86
+        select NEW_LEDS
+        select LEDS_CLASS
+        select INPUT_POLLDEV
+        default n
+        help
+          This driver provides support for the Apple System Management
+          Controller, which provides an accelerometer (Apple Sudden Motion
+          Sensor), light sensors, temperature sensors, keyboard backlight
+          control and fan control.
+          Only Intel-based Apple's computers are supported (MacBook Pro,
+          MacBook, MacMini).
+          Data from the different sensors, keyboard backlight control and fan
+          control are accessible via sysfs.
+          This driver also provides an absolute input class device, allowing
+          the laptop to act as a pinball machine-esque joystick.
+          Say Y here if you have an applicable laptop and want to experience
+          the awesome power of applesmc.
 config SENSORS_ASB100
        tristate "Asus ASB100 Bach"
        depends on X86 && I2C
@@ -435,6 +444,12 @@ config SENSORS_F75375S
          This driver can also be built as a module.  If so, the module
          will be called f75375s.
+config SENSORS_MC13783_ADC
+        tristate "Freescale MC13783/MC13892 ADC"
+        depends on MFD_MC13XXX
+        help
+          Support for the A/D converter on MC13783 and MC13892 PMIC.
 config SENSORS_FSCHMD
        tristate "Fujitsu Siemens Computers sensor chips"
        depends on X86 && I2C
@@ -451,26 +466,6 @@ config SENSORS_FSCHMD
          This driver can also be built as a module.  If so, the module
          will be called fschmd.
-config SENSORS_G760A
-        tristate "GMT G760A"
-        depends on I2C
-        help
-          If you say yes here you get support for Global Mixed-mode
-          Technology Inc G760A fan speed PWM controller chips.
-          This driver can also be built as a module.  If so, the module
-          will be called g760a.
-config SENSORS_G762
-        tristate "GMT G762 and G763"
-        depends on I2C
-        help
-          If you say yes here you get support for Global Mixed-mode
-          Technology Inc G762 and G763 fan speed PWM controller chips.
-          This driver can also be built as a module.  If so, the module
-          will be called g762.
 config SENSORS_GL518SM
        tristate "Genesys Logic GL518SM"
        depends on I2C
@@ -492,6 +487,26 @@ config SENSORS_GL520SM
          This driver can also be built as a module.  If so, the module
          will be called gl520sm.
+config SENSORS_G760A
+        tristate "GMT G760A"
+        depends on I2C
+        help
+          If you say yes here you get support for Global Mixed-mode
+          Technology Inc G760A fan speed PWM controller chips.
+          This driver can also be built as a module.  If so, the module
+          will be called g760a.
+config SENSORS_G762
+        tristate "GMT G762 and G763"
+        depends on I2C
+        help
+          If you say yes here you get support for Global Mixed-mode
+          Technology Inc G762 and G763 fan speed PWM controller chips.
+          This driver can also be built as a module.  If so, the module
+          will be called g762.
 config SENSORS_GPIO_FAN
        tristate "GPIO fan"
        depends on GPIOLIB
@@ -511,24 +526,6 @@ config SENSORS_HIH6130
          This driver can also be built as a module.  If so, the module
          will be called hih6130.
-config SENSORS_HTU21
-        tristate "Measurement Specialties HTU21D humidity/temperature sensors"
-        depends on I2C
-        help
-          If you say yes here you get support for the Measurement Specialties
-          HTU21D humidity and temperature sensors.
-          This driver can also be built as a module.  If so, the module
-          will be called htu21.
-config SENSORS_CORETEMP
-        tristate "Intel Core/Core2/Atom temperature sensor"
-        depends on X86
-        help
-          If you say yes here you get support for the temperature
-          sensor inside your CPU. Most of the family 6 CPUs
-          are supported. Check Documentation/hwmon/coretemp for details.
 config SENSORS_IBMAEM
        tristate "IBM Active Energy Manager temperature/power sensors and control"
        select IPMI_SI
@@ -566,6 +563,14 @@ config SENSORS_IIO_HWMON
          for those channels specified in the map.  This map can be provided
          either via platform data or the device tree bindings.
+config SENSORS_CORETEMP
+        tristate "Intel Core/Core2/Atom temperature sensor"
+        depends on X86
+        help
+          If you say yes here you get support for the temperature
+          sensor inside your CPU. Most of the family 6 CPUs
+          are supported. Check Documentation/hwmon/coretemp for details.
 config SENSORS_IT87
        tristate "ITE IT87xx and compatibles"
        depends on !PPC
@@ -614,6 +619,219 @@ config SENSORS_LINEAGE
          This driver can also be built as a module.  If so, the module
          will be called lineage-pem.
+config SENSORS_LTC2945
+        tristate "Linear Technology LTC2945"
+        depends on I2C
+        select REGMAP_I2C
+        default n
+        help
+          If you say yes here you get support for Linear Technology LTC2945
+          I2C System Monitor.
+          This driver can also be built as a module. If so, the module will
+          be called ltc2945.
+config SENSORS_LTC4151
+        tristate "Linear Technology LTC4151"
+        depends on I2C
+        default n
+        help
+          If you say yes here you get support for Linear Technology LTC4151
+          High Voltage I2C Current and Voltage Monitor interface.
+          This driver can also be built as a module. If so, the module will
+          be called ltc4151.
+config SENSORS_LTC4215
+        tristate "Linear Technology LTC4215"
+        depends on I2C
+        default n
+        help
+          If you say yes here you get support for Linear Technology LTC4215
+          Hot Swap Controller I2C interface.
+          This driver can also be built as a module. If so, the module will
+          be called ltc4215.
+config SENSORS_LTC4222
+        tristate "Linear Technology LTC4222"
+        depends on I2C
+        select REGMAP_I2C
+        default n
+        help
+          If you say yes here you get support for Linear Technology LTC4222
+          Dual Hot Swap Controller I2C interface.
+          This driver can also be built as a module. If so, the module will
+          be called ltc4222.
+config SENSORS_LTC4245
+        tristate "Linear Technology LTC4245"
+        depends on I2C
+        default n
+        help
+          If you say yes here you get support for Linear Technology LTC4245
+          Multiple Supply Hot Swap Controller I2C interface.
+          This driver can also be built as a module. If so, the module will
+          be called ltc4245.
+config SENSORS_LTC4260
+        tristate "Linear Technology LTC4260"
+        depends on I2C
+        select REGMAP_I2C
+        default n
+        help
+          If you say yes here you get support for Linear Technology LTC4260
+          Positive Voltage Hot Swap Controller I2C interface.
+          This driver can also be built as a module. If so, the module will
+          be called ltc4260.
+config SENSORS_LTC4261
+        tristate "Linear Technology LTC4261"
+        depends on I2C
+        default n
+        help
+          If you say yes here you get support for Linear Technology LTC4261
+          Negative Voltage Hot Swap Controller I2C interface.
+          This driver can also be built as a module. If so, the module will
+          be called ltc4261.
+config SENSORS_MAX1111
+        tristate "Maxim MAX1111 Serial 8-bit ADC chip and compatibles"
+        depends on SPI_MASTER
+        help
+          Say y here to support Maxim's MAX1110, MAX1111, MAX1112, and MAX1113
+          ADC chips.
+          This driver can also be built as a module.  If so, the module
+          will be called max1111.
+config SENSORS_MAX16065
+        tristate "Maxim MAX16065 System Manager and compatibles"
+        depends on I2C
+        help
+          If you say yes here you get support for hardware monitoring
+          capabilities of the following Maxim System Manager chips.
+            MAX16065
+            MAX16066
+            MAX16067
+            MAX16068
+            MAX16070
+            MAX16071
+          This driver can also be built as a module.  If so, the module
+          will be called max16065.
+config SENSORS_MAX1619
+        tristate "Maxim MAX1619 sensor chip"
+        depends on I2C
+        help
+          If you say yes here you get support for MAX1619 sensor chip.
+          This driver can also be built as a module.  If so, the module
+          will be called max1619.
+config SENSORS_MAX1668
+        tristate "Maxim MAX1668 and compatibles"
+        depends on I2C
+        help
+          If you say yes here you get support for MAX1668, MAX1989 and
+          MAX1805 chips.
+          This driver can also be built as a module.  If so, the module
+          will be called max1668.
+config SENSORS_MAX197
+        tristate "Maxim MAX197 and compatibles"
+        help
+          Support for the Maxim MAX197 A/D converter.
+          Support will include, but not be limited to, MAX197, and MAX199.
+          This driver can also be built as a module. If so, the module
+          will be called max197.
+config SENSORS_MAX6639
+        tristate "Maxim MAX6639 sensor chip"
+        depends on I2C
+        help
+          If you say yes here you get support for the MAX6639
+          sensor chips.
+          This driver can also be built as a module.  If so, the module
+          will be called max6639.
+config SENSORS_MAX6642
+        tristate "Maxim MAX6642 sensor chip"
+        depends on I2C
+        help
+          If you say yes here you get support for MAX6642 sensor chip.
+          MAX6642 is a SMBus-Compatible Remote/Local Temperature Sensor
+          with Overtemperature Alarm from Maxim.
+          This driver can also be built as a module.  If so, the module
+          will be called max6642.
+config SENSORS_MAX6650
+        tristate "Maxim MAX6650 sensor chip"
+        depends on I2C
+        help
+          If you say yes here you get support for the MAX6650 / MAX6651
+          sensor chips.
+          This driver can also be built as a module.  If so, the module
+          will be called max6650.
+config SENSORS_MAX6697
+        tristate "Maxim MAX6697 and compatibles"
+        depends on I2C
+        help
+          If you say yes here you get support for MAX6581, MAX6602, MAX6622,
+          MAX6636, MAX6689, MAX6693, MAX6694, MAX6697, MAX6698, and MAX6699
+          temperature sensor chips.
+          This driver can also be built as a module.  If so, the module
+          will be called max6697.
+config SENSORS_HTU21
+        tristate "Measurement Specialties HTU21D humidity/temperature sensors"
+        depends on I2C
+        help
+          If you say yes here you get support for the Measurement Specialties
+          HTU21D humidity and temperature sensors.
+          This driver can also be built as a module.  If so, the module
+          will be called htu21.
+config SENSORS_MCP3021
+        tristate "Microchip MCP3021 and compatibles"
+        depends on I2C
+        help
+          If you say yes here you get support for MCP3021 and MCP3221.
+          The MCP3021 is a A/D converter (ADC) with 10-bit and the MCP3221
+          with 12-bit resolution.
+          This driver can also be built as a module.  If so, the module
+          will be called mcp3021.
+config SENSORS_ADCXX
+        tristate "National Semiconductor ADCxxxSxxx"
+        depends on SPI_MASTER
+        help
+          If you say yes here you get support for the National Semiconductor
+          ADC<bb><c>S<sss> chip family, where
+          * bb  is the resolution in number of bits (8, 10, 12)
+          * c   is the number of channels (1, 2, 4, 8)
+          * sss is the maximum conversion speed (021 for 200 kSPS, 051 for 500
+            kSPS and 101 for 1 MSPS)
+          Examples : ADC081S101, ADC124S501, ...
+          This driver can also be built as a module.  If so, the module
+          will be called adcxx.
 config SENSORS_LM63
        tristate "National Semiconductor LM63 and compatibles"
        depends on I2C
@@ -776,50 +994,6 @@ config SENSORS_LM93
          This driver can also be built as a module.  If so, the module
          will be called lm93.
-config SENSORS_LTC4151
-        tristate "Linear Technology LTC4151"
-        depends on I2C
-        default n
-        help
-          If you say yes here you get support for Linear Technology LTC4151
-          High Voltage I2C Current and Voltage Monitor interface.
-          This driver can also be built as a module. If so, the module will
-          be called ltc4151.
-config SENSORS_LTC4215
-        tristate "Linear Technology LTC4215"
-        depends on I2C
-        default n
-        help
-          If you say yes here you get support for Linear Technology LTC4215
-          Hot Swap Controller I2C interface.
-          This driver can also be built as a module. If so, the module will
-          be called ltc4215.
-config SENSORS_LTC4245
-        tristate "Linear Technology LTC4245"
-        depends on I2C
-        default n
-        help
-          If you say yes here you get support for Linear Technology LTC4245
-          Multiple Supply Hot Swap Controller I2C interface.
-          This driver can also be built as a module. If so, the module will
-          be called ltc4245.
-config SENSORS_LTC4261
-        tristate "Linear Technology LTC4261"
-        depends on I2C
-        default n
-        help
-          If you say yes here you get support for Linear Technology LTC4261
-          Negative Voltage Hot Swap Controller I2C interface.
-          This driver can also be built as a module. If so, the module will
-          be called ltc4261.
 config SENSORS_LM95234
        tristate "National Semiconductor LM95234"
        depends on I2C
@@ -849,125 +1023,33 @@ config SENSORS_LM95245
          This driver can also be built as a module.  If so, the module
          will be called lm95245.
-config SENSORS_MAX1111
+config SENSORS_PC87360
-        tristate "Maxim MAX1111 Serial 8-bit ADC chip and compatibles"
+        tristate "National Semiconductor PC87360 family"
-        depends on SPI_MASTER
+        depends on !PPC
-        help
+        select HWMON_VID
-          Say y here to support Maxim's MAX1110, MAX1111, MAX1112, and MAX1113
-          ADC chips.
-          This driver can also be built as a module.  If so, the module
-          will be called max1111.
-config SENSORS_MAX16065
-        tristate "Maxim MAX16065 System Manager and compatibles"
-        depends on I2C
-        help
-          If you say yes here you get support for hardware monitoring
-          capabilities of the following Maxim System Manager chips.
-            MAX16065
-            MAX16066
-            MAX16067
-            MAX16068
-            MAX16070
-            MAX16071
-          This driver can also be built as a module.  If so, the module
-          will be called max16065.
-config SENSORS_MAX1619
-        tristate "Maxim MAX1619 sensor chip"
-        depends on I2C
-        help
-          If you say yes here you get support for MAX1619 sensor chip.
-          This driver can also be built as a module.  If so, the module
-          will be called max1619.
-config SENSORS_MAX1668
-        tristate "Maxim MAX1668 and compatibles"
-        depends on I2C
-        help
-          If you say yes here you get support for MAX1668, MAX1989 and
-          MAX1805 chips.
-          This driver can also be built as a module.  If so, the module
-          will be called max1668.
-config SENSORS_MAX197
-        tristate "Maxim MAX197 and compatibles"
-        help
-          Support for the Maxim MAX197 A/D converter.
-          Support will include, but not be limited to, MAX197, and MAX199.
-          This driver can also be built as a module. If so, the module
-          will be called max197.
-config SENSORS_MAX6639
-        tristate "Maxim MAX6639 sensor chip"
-        depends on I2C
-        help
-          If you say yes here you get support for the MAX6639
-          sensor chips.
-          This driver can also be built as a module.  If so, the module
-          will be called max6639.
-config SENSORS_MAX6642
-        tristate "Maxim MAX6642 sensor chip"
-        depends on I2C
-        help
-          If you say yes here you get support for MAX6642 sensor chip.
-          MAX6642 is a SMBus-Compatible Remote/Local Temperature Sensor
-          with Overtemperature Alarm from Maxim.
-          This driver can also be built as a module.  If so, the module
-          will be called max6642.
-config SENSORS_MAX6650
-        tristate "Maxim MAX6650 sensor chip"
-        depends on I2C
-        help
-          If you say yes here you get support for the MAX6650 / MAX6651
-          sensor chips.
-          This driver can also be built as a module.  If so, the module
-          will be called max6650.
-config SENSORS_MAX6697
-        tristate "Maxim MAX6697 and compatibles"
-        depends on I2C
-        help
-          If you say yes here you get support for MAX6581, MAX6602, MAX6622,
-          MAX6636, MAX6689, MAX6693, MAX6694, MAX6697, MAX6698, and MAX6699
-          temperature sensor chips.
-          This driver can also be built as a module.  If so, the module
-          will be called max6697.
-config SENSORS_MCP3021
-        tristate "Microchip MCP3021 and compatibles"
-        depends on I2C
        help
-          If you say yes here you get support for MCP3021 and MCP3221.
+          If you say yes here you get access to the hardware monitoring
-          The MCP3021 is a A/D converter (ADC) with 10-bit and the MCP3221
+          functions of the National Semiconductor PC8736x Super-I/O chips.
-          with 12-bit resolution.
+          The PC87360, PC87363 and PC87364 only have fan monitoring and
+          control.  The PC87365 and PC87366 additionally have voltage and
+          temperature monitoring.
          This driver can also be built as a module.  If so, the module
-          will be called mcp3021.
+          will be called pc87360.
-config SENSORS_NCT6775
+config SENSORS_PC87427
-        tristate "Nuvoton NCT6775F and compatibles"
+        tristate "National Semiconductor PC87427"
        depends on !PPC
-        select HWMON_VID
        help
-          If you say yes here you get support for the hardware monitoring
+          If you say yes here you get access to the hardware monitoring
-          functionality of the Nuvoton NCT6775F, NCT6776F, NCT6779D
+          functions of the National Semiconductor PC87427 Super-I/O chip.
-          and compatible Super-I/O chips. This driver replaces the
+          The chip has two distinct logical devices, one for fan speed
-          w83627ehf driver for NCT6775F and NCT6776F.
+          monitoring and control, and one for voltage and temperature
+          monitoring. Fan speed monitoring and control are supported, as
+          well as temperature monitoring. Voltages aren't supported yet.
          This driver can also be built as a module.  If so, the module
-          will be called nct6775.
+          will be called pc87427.
 config SENSORS_NTC_THERMISTOR
        tristate "NTC thermistor support"
@@ -983,33 +1065,18 @@ config SENSORS_NTC_THERMISTOR
          This driver can also be built as a module.  If so, the module
          will be called ntc-thermistor.
-config SENSORS_PC87360
+config SENSORS_NCT6775
-        tristate "National Semiconductor PC87360 family"
+        tristate "Nuvoton NCT6775F and compatibles"
        depends on !PPC
        select HWMON_VID
        help
-          If you say yes here you get access to the hardware monitoring
+          If you say yes here you get support for the hardware monitoring
-          functions of the National Semiconductor PC8736x Super-I/O chips.
+          functionality of the Nuvoton NCT6775F, NCT6776F, NCT6779D
-          The PC87360, PC87363 and PC87364 only have fan monitoring and
+          and compatible Super-I/O chips. This driver replaces the
-          control.  The PC87365 and PC87366 additionally have voltage and
+          w83627ehf driver for NCT6775F and NCT6776F.
-          temperature monitoring.
-          This driver can also be built as a module.  If so, the module
-          will be called pc87360.
-config SENSORS_PC87427
-        tristate "National Semiconductor PC87427"
-        depends on !PPC
-        help
-          If you say yes here you get access to the hardware monitoring
-          functions of the National Semiconductor PC87427 Super-I/O chip.
-          The chip has two distinct logical devices, one for fan speed
-          monitoring and control, and one for voltage and temperature
-          monitoring. Fan speed monitoring and control are supported, as
-          well as temperature monitoring. Voltages aren't supported yet.
          This driver can also be built as a module.  If so, the module
-          will be called pc87427.
+          will be called nct6775.
 config SENSORS_PCF8591
        tristate "Philips PCF8591 ADC/DAC"
@@ -1074,21 +1141,6 @@ config SENSORS_SIS5595
          This driver can also be built as a module.  If so, the module
          will be called sis5595.
-config SENSORS_SMM665
-        tristate "Summit Microelectronics SMM665"
-        depends on I2C
-        default n
-        help
-          If you say yes here you get support for the hardware monitoring
-          features of the Summit Microelectronics SMM665/SMM665B Six-Channel
-          Active DC Output Controller / Monitor.
-          Other supported chips are SMM465, SMM665C, SMM764, and SMM766.
-          Support for those chips is untested.
-          This driver can also be built as a module. If so, the module will
-          be called smm665.
 config SENSORS_DME1737
        tristate "SMSC DME1737, SCH311x and compatibles"
        depends on I2C && !PPC
@@ -1210,6 +1262,31 @@ config SENSORS_SCH5636
          This driver can also be built as a module.  If so, the module
          will be called sch5636.
+config SENSORS_SMM665
+        tristate "Summit Microelectronics SMM665"
+        depends on I2C
+        default n
+        help
+          If you say yes here you get support for the hardware monitoring
+          features of the Summit Microelectronics SMM665/SMM665B Six-Channel
+          Active DC Output Controller / Monitor.
+          Other supported chips are SMM465, SMM665C, SMM764, and SMM766.
+          Support for those chips is untested.
+          This driver can also be built as a module. If so, the module will
+          be called smm665.
+config SENSORS_ADC128D818
+        tristate "Texas Instruments ADC128D818"
+        depends on I2C
+        help
+          If you say yes here you get support for the Texas Instruments
+          ADC128D818 System Monitor with Temperature Sensor chip.
+          This driver can also be built as a module. If so, the module
+          will be called adc128d818.
 config SENSORS_ADS1015
        tristate "Texas Instruments ADS1015"
        depends on I2C
@@ -1525,37 +1602,6 @@ config SENSORS_ULTRA45
          This driver provides support for the Ultra45 workstation environmental
          sensors.
-config SENSORS_APPLESMC
-        tristate "Apple SMC (Motion sensor, light sensor, keyboard backlight)"
-        depends on INPUT && X86
-        select NEW_LEDS
-        select LEDS_CLASS
-        select INPUT_POLLDEV
-        default n
-        help
-          This driver provides support for the Apple System Management
-          Controller, which provides an accelerometer (Apple Sudden Motion
-          Sensor), light sensors, temperature sensors, keyboard backlight
-          control and fan control.
-          Only Intel-based Apple's computers are supported (MacBook Pro,
-          MacBook, MacMini).
-          Data from the different sensors, keyboard backlight control and fan
-          control are accessible via sysfs.
-          This driver also provides an absolute input class device, allowing
-          the laptop to act as a pinball machine-esque joystick.
-          Say Y here if you have an applicable laptop and want to experience
-          the awesome power of applesmc.
-config SENSORS_MC13783_ADC
-        tristate "Freescale MC13783/MC13892 ADC"
-        depends on MFD_MC13XXX
-        help
-          Support for the A/D converter on MC13783 and MC13892 PMIC.
 if ACPI
 comment "ACPI drivers"
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index ec7cde06eb52..c48f9873ac73 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -25,6 +25,7 @@ obj-$(CONFIG_SENSORS_ABITUGURU3)+= abituguru3.o
 obj-$(CONFIG_SENSORS_AD7314)    += ad7314.o
 obj-$(CONFIG_SENSORS_AD7414)    += ad7414.o
 obj-$(CONFIG_SENSORS_AD7418)    += ad7418.o
+obj-$(CONFIG_SENSORS_ADC128D818) += adc128d818.o
 obj-$(CONFIG_SENSORS_ADCXX)     += adcxx.o
 obj-$(CONFIG_SENSORS_ADM1021)   += adm1021.o
 obj-$(CONFIG_SENSORS_ADM1025)   += adm1025.o
@@ -95,9 +96,12 @@ obj-$(CONFIG_SENSORS_LM93)	+= lm93.o
 obj-$(CONFIG_SENSORS_LM95234)   += lm95234.o
 obj-$(CONFIG_SENSORS_LM95241)   += lm95241.o
 obj-$(CONFIG_SENSORS_LM95245)   += lm95245.o
+obj-$(CONFIG_SENSORS_LTC2945)   += ltc2945.o
 obj-$(CONFIG_SENSORS_LTC4151)   += ltc4151.o
 obj-$(CONFIG_SENSORS_LTC4215)   += ltc4215.o
+obj-$(CONFIG_SENSORS_LTC4222)   += ltc4222.o
 obj-$(CONFIG_SENSORS_LTC4245)   += ltc4245.o
+obj-$(CONFIG_SENSORS_LTC4260)   += ltc4260.o
 obj-$(CONFIG_SENSORS_LTC4261)   += ltc4261.o
 obj-$(CONFIG_SENSORS_MAX1111)   += max1111.o
 obj-$(CONFIG_SENSORS_MAX16065)  += max16065.o
diff --git a/drivers/hwmon/adc128d818.c b/drivers/hwmon/adc128d818.c
new file mode 100644
index 000000000000..5ffd81f19d01
--- /dev/null
+++ b/drivers/hwmon/adc128d818.c
@@ -0,0 +1,491 @@
+/*
+ * Driver for TI ADC128D818 System Monitor with Temperature Sensor
+ *
+ * Copyright (c) 2014 Guenter Roeck
+ *
+ * Derived from lm80.c
+ * Copyright (C) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
+ *                           and Philip Edelbrock <phil@netroedge.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+#include <linux/regulator/consumer.h>
+#include <linux/mutex.h>
+/* Addresses to scan
+ * The chip also supports addresses 0x35..0x37. Don't scan those addresses
+ * since they are also used by some EEPROMs, which may result in false
+ * positives.
+ */
+static const unsigned short normal_i2c[] = {
+        0x1d, 0x1e, 0x1f, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
+/* registers */
+#define ADC128_REG_IN_MAX(nr)           (0x2a + (nr) * 2)
+#define ADC128_REG_IN_MIN(nr)           (0x2b + (nr) * 2)
+#define ADC128_REG_IN(nr)               (0x20 + (nr))
+#define ADC128_REG_TEMP                 0x27
+#define ADC128_REG_TEMP_MAX             0x38
+#define ADC128_REG_TEMP_HYST            0x39
+#define ADC128_REG_CONFIG               0x00
+#define ADC128_REG_ALARM                0x01
+#define ADC128_REG_MASK                 0x03
+#define ADC128_REG_CONV_RATE            0x07
+#define ADC128_REG_ONESHOT              0x09
+#define ADC128_REG_SHUTDOWN             0x0a
+#define ADC128_REG_CONFIG_ADV           0x0b
+#define ADC128_REG_BUSY_STATUS          0x0c
+#define ADC128_REG_MAN_ID               0x3e
+#define ADC128_REG_DEV_ID               0x3f
+struct adc128_data {
+        struct i2c_client *client;
+        struct regulator *regulator;
+        int vref;               /* Reference voltage in mV */
+        struct mutex update_lock;
+        bool valid;             /* true if following fields are valid */
+        unsigned long last_updated;     /* In jiffies */
+        u16 in[3][7];           /* Register value, normalized to 12 bit
+                                 * 0: input voltage
+                                 * 1: min limit
+                                 * 2: max limit
+                                 */
+        s16 temp[3];            /* Register value, normalized to 9 bit
+                                 * 0: sensor 1: limit 2: hyst
+                                 */
+        u8 alarms;              /* alarm register value */
+};
+static struct adc128_data *adc128_update_device(struct device *dev)
+{
+        struct adc128_data *data = dev_get_drvdata(dev);
+        struct i2c_client *client = data->client;
+        struct adc128_data *ret = data;
+        int i, rv;
+        mutex_lock(&data->update_lock);
+        if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
+                for (i = 0; i < 7; i++) {
+                        rv = i2c_smbus_read_word_swapped(client,
+                                                         ADC128_REG_IN(i));
+                        if (rv < 0)
+                                goto abort;
+                        data->in[0][i] = rv >> 4;
+                        rv = i2c_smbus_read_byte_data(client,
+                                                      ADC128_REG_IN_MIN(i));
+                        if (rv < 0)
+                                goto abort;
+                        data->in[1][i] = rv << 4;
+                        rv = i2c_smbus_read_byte_data(client,
+                                                      ADC128_REG_IN_MAX(i));
+                        if (rv < 0)
+                                goto abort;
+                        data->in[2][i] = rv << 4;
+                }
+                rv = i2c_smbus_read_word_swapped(client, ADC128_REG_TEMP);
+                if (rv < 0)
+                        goto abort;
+                data->temp[0] = rv >> 7;
+                rv = i2c_smbus_read_byte_data(client, ADC128_REG_TEMP_MAX);
+                if (rv < 0)
+                        goto abort;
+                data->temp[1] = rv << 1;
+                rv = i2c_smbus_read_byte_data(client, ADC128_REG_TEMP_HYST);
+                if (rv < 0)
+                        goto abort;
+                data->temp[2] = rv << 1;
+                rv = i2c_smbus_read_byte_data(client, ADC128_REG_ALARM);
+                if (rv < 0)
+                        goto abort;
+                data->alarms |= rv;
+                data->last_updated = jiffies;
+                data->valid = true;
+        }
+        goto done;
+abort:
+        ret = ERR_PTR(rv);
+        data->valid = false;
+done:
+        mutex_unlock(&data->update_lock);
+        return ret;
+}
+static ssize_t adc128_show_in(struct device *dev, struct device_attribute *attr,
+                              char *buf)
+{
+        struct adc128_data *data = adc128_update_device(dev);
+        int index = to_sensor_dev_attr_2(attr)->index;
+        int nr = to_sensor_dev_attr_2(attr)->nr;
+        int val;
+        if (IS_ERR(data))
+                return PTR_ERR(data);
+        val = DIV_ROUND_CLOSEST(data->in[index][nr] * data->vref, 4095);
+        return sprintf(buf, "%d\n", val);
+}
+static ssize_t adc128_set_in(struct device *dev, struct device_attribute *attr,
+                             const char *buf, size_t count)
+{
+        struct adc128_data *data = dev_get_drvdata(dev);
+        int index = to_sensor_dev_attr_2(attr)->index;
+        int nr = to_sensor_dev_attr_2(attr)->nr;
+        u8 reg, regval;
+        long val;
+        int err;
+        err = kstrtol(buf, 10, &val);
+        if (err < 0)
+                return err;
+        mutex_lock(&data->update_lock);
+        /* 10 mV LSB on limit registers */
+        regval = clamp_val(DIV_ROUND_CLOSEST(val, 10), 0, 255);
+        data->in[index][nr] = regval << 4;
+        reg = index == 1 ? ADC128_REG_IN_MIN(nr) : ADC128_REG_IN_MAX(nr);
+        i2c_smbus_write_byte_data(data->client, reg, regval);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+static ssize_t adc128_show_temp(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct adc128_data *data = adc128_update_device(dev);
+        int index = to_sensor_dev_attr(attr)->index;
+        int temp;
+        if (IS_ERR(data))
+                return PTR_ERR(data);
+        temp = (data->temp[index] << 7) >> 7;   /* sign extend */
+        return sprintf(buf, "%d\n", temp * 500);/* 0.5 degrees C resolution */
+}
+static ssize_t adc128_set_temp(struct device *dev,
+                               struct device_attribute *attr,
+                               const char *buf, size_t count)
+{
+        struct adc128_data *data = dev_get_drvdata(dev);
+        int index = to_sensor_dev_attr(attr)->index;
+        long val;
+        int err;
+        s8 regval;
+        err = kstrtol(buf, 10, &val);
+        if (err < 0)
+                return err;
+        mutex_lock(&data->update_lock);
+        regval = clamp_val(DIV_ROUND_CLOSEST(val, 1000), -128, 127);
+        data->temp[index] = regval << 1;
+        i2c_smbus_write_byte_data(data->client,
+                                  index == 1 ? ADC128_REG_TEMP_MAX
+                                             : ADC128_REG_TEMP_HYST,
+                                  regval);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+static ssize_t adc128_show_alarm(struct device *dev,
+                                 struct device_attribute *attr, char *buf)
+{
+        struct adc128_data *data = adc128_update_device(dev);
+        int mask = 1 << to_sensor_dev_attr(attr)->index;
+        u8 alarms;
+        if (IS_ERR(data))
+                return PTR_ERR(data);
+        /*
+         * Clear an alarm after reporting it to user space. If it is still
+         * active, the next update sequence will set the alarm bit again.
+         */
+        alarms = data->alarms;
+        data->alarms &= ~mask;
+        return sprintf(buf, "%u\n", !!(alarms & mask));
+}
+static SENSOR_DEVICE_ATTR_2(in0_input, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 0, 0);
+static SENSOR_DEVICE_ATTR_2(in0_min, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 0, 1);
+static SENSOR_DEVICE_ATTR_2(in0_max, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 0, 2);
+static SENSOR_DEVICE_ATTR_2(in1_input, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 1, 0);
+static SENSOR_DEVICE_ATTR_2(in1_min, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 1, 1);
+static SENSOR_DEVICE_ATTR_2(in1_max, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 1, 2);
+static SENSOR_DEVICE_ATTR_2(in2_input, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 2, 0);
+static SENSOR_DEVICE_ATTR_2(in2_min, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 2, 1);
+static SENSOR_DEVICE_ATTR_2(in2_max, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 2, 2);
+static SENSOR_DEVICE_ATTR_2(in3_input, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 3, 0);
+static SENSOR_DEVICE_ATTR_2(in3_min, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 3, 1);
+static SENSOR_DEVICE_ATTR_2(in3_max, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 3, 2);
+static SENSOR_DEVICE_ATTR_2(in4_input, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 4, 0);
+static SENSOR_DEVICE_ATTR_2(in4_min, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 4, 1);
+static SENSOR_DEVICE_ATTR_2(in4_max, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 4, 2);
+static SENSOR_DEVICE_ATTR_2(in5_input, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 5, 0);
+static SENSOR_DEVICE_ATTR_2(in5_min, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 5, 1);
+static SENSOR_DEVICE_ATTR_2(in5_max, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 5, 2);
+static SENSOR_DEVICE_ATTR_2(in6_input, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 6, 0);
+static SENSOR_DEVICE_ATTR_2(in6_min, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 6, 1);
+static SENSOR_DEVICE_ATTR_2(in6_max, S_IWUSR | S_IRUGO,
+                            adc128_show_in, adc128_set_in, 6, 2);
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, adc128_show_temp, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
+                          adc128_show_temp, adc128_set_temp, 1);
+static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
+                          adc128_show_temp, adc128_set_temp, 2);
+static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, adc128_show_alarm, NULL, 0);
+static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, adc128_show_alarm, NULL, 1);
+static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, adc128_show_alarm, NULL, 2);
+static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, adc128_show_alarm, NULL, 3);
+static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, adc128_show_alarm, NULL, 4);
+static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, adc128_show_alarm, NULL, 5);
+static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, adc128_show_alarm, NULL, 6);
+static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, adc128_show_alarm, NULL, 7);
+static struct attribute *adc128_attrs[] = {
+        &sensor_dev_attr_in0_min.dev_attr.attr,
+        &sensor_dev_attr_in1_min.dev_attr.attr,
+        &sensor_dev_attr_in2_min.dev_attr.attr,
+        &sensor_dev_attr_in3_min.dev_attr.attr,
+        &sensor_dev_attr_in4_min.dev_attr.attr,
+        &sensor_dev_attr_in5_min.dev_attr.attr,
+        &sensor_dev_attr_in6_min.dev_attr.attr,
+        &sensor_dev_attr_in0_max.dev_attr.attr,
+        &sensor_dev_attr_in1_max.dev_attr.attr,
+        &sensor_dev_attr_in2_max.dev_attr.attr,
+        &sensor_dev_attr_in3_max.dev_attr.attr,
+        &sensor_dev_attr_in4_max.dev_attr.attr,
+        &sensor_dev_attr_in5_max.dev_attr.attr,
+        &sensor_dev_attr_in6_max.dev_attr.attr,
+        &sensor_dev_attr_in0_input.dev_attr.attr,
+        &sensor_dev_attr_in1_input.dev_attr.attr,
+        &sensor_dev_attr_in2_input.dev_attr.attr,
+        &sensor_dev_attr_in3_input.dev_attr.attr,
+        &sensor_dev_attr_in4_input.dev_attr.attr,
+        &sensor_dev_attr_in5_input.dev_attr.attr,
+        &sensor_dev_attr_in6_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_max.dev_attr.attr,
+        &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
+        &sensor_dev_attr_in0_alarm.dev_attr.attr,
+        &sensor_dev_attr_in1_alarm.dev_attr.attr,
+        &sensor_dev_attr_in2_alarm.dev_attr.attr,
+        &sensor_dev_attr_in3_alarm.dev_attr.attr,
+        &sensor_dev_attr_in4_alarm.dev_attr.attr,
+        &sensor_dev_attr_in5_alarm.dev_attr.attr,
+        &sensor_dev_attr_in6_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
+        NULL
+};
+ATTRIBUTE_GROUPS(adc128);
+static int adc128_detect(struct i2c_client *client, struct i2c_board_info *info)
+{
+        int man_id, dev_id;
+        if (!i2c_check_functionality(client->adapter,
+                                     I2C_FUNC_SMBUS_BYTE_DATA |
+                                     I2C_FUNC_SMBUS_WORD_DATA))
+                return -ENODEV;
+        man_id = i2c_smbus_read_byte_data(client, ADC128_REG_MAN_ID);
+        dev_id = i2c_smbus_read_byte_data(client, ADC128_REG_DEV_ID);
+        if (man_id != 0x01 || dev_id != 0x09)
+                return -ENODEV;
+        /* Check unused bits for confirmation */
+        if (i2c_smbus_read_byte_data(client, ADC128_REG_CONFIG) & 0xf4)
+                return -ENODEV;
+        if (i2c_smbus_read_byte_data(client, ADC128_REG_CONV_RATE) & 0xfe)
+                return -ENODEV;
+        if (i2c_smbus_read_byte_data(client, ADC128_REG_ONESHOT) & 0xfe)
+                return -ENODEV;
+        if (i2c_smbus_read_byte_data(client, ADC128_REG_SHUTDOWN) & 0xfe)
+                return -ENODEV;
+        if (i2c_smbus_read_byte_data(client, ADC128_REG_CONFIG_ADV) & 0xf8)
+                return -ENODEV;
+        if (i2c_smbus_read_byte_data(client, ADC128_REG_BUSY_STATUS) & 0xfc)
+                return -ENODEV;
+        strlcpy(info->type, "adc128d818", I2C_NAME_SIZE);
+        return 0;
+}
+static int adc128_init_client(struct adc128_data *data)
+{
+        struct i2c_client *client = data->client;
+        int err;
+        /*
+         * Reset chip to defaults.
+         * This makes most other initializations unnecessary.
+         */
+        err = i2c_smbus_write_byte_data(client, ADC128_REG_CONFIG, 0x80);
+        if (err)
+                return err;
+        /* Start monitoring */
+        err = i2c_smbus_write_byte_data(client, ADC128_REG_CONFIG, 0x01);
+        if (err)
+                return err;
+        /* If external vref is selected, configure the chip to use it */
+        if (data->regulator) {
+                err = i2c_smbus_write_byte_data(client,
+                                                ADC128_REG_CONFIG_ADV, 0x01);
+                if (err)
+                        return err;
+        }
+        return 0;
+}
+static int adc128_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+        struct device *dev = &client->dev;
+        struct regulator *regulator;
+        struct device *hwmon_dev;
+        struct adc128_data *data;
+        int err, vref;
+        data = devm_kzalloc(dev, sizeof(struct adc128_data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+        /* vref is optional. If specified, is used as chip reference voltage */
+        regulator = devm_regulator_get_optional(dev, "vref");
+        if (!IS_ERR(regulator)) {
+                data->regulator = regulator;
+                err = regulator_enable(regulator);
+                if (err < 0)
+                        return err;
+                vref = regulator_get_voltage(regulator);
+                if (vref < 0) {
+                        err = vref;
+                        goto error;
+                }
+                data->vref = DIV_ROUND_CLOSEST(vref, 1000);
+        } else {
+                data->vref = 2560;      /* 2.56V, in mV */
+        }
+        data->client = client;
+        i2c_set_clientdata(client, data);
+        mutex_init(&data->update_lock);
+        /* Initialize the chip */
+        err = adc128_init_client(data);
+        if (err < 0)
+                goto error;
+        hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
+                                                           data, adc128_groups);
+        if (IS_ERR(hwmon_dev)) {
+                err = PTR_ERR(hwmon_dev);
+                goto error;
+        }
+        return 0;
+error:
+        if (data->regulator)
+                regulator_disable(data->regulator);
+        return err;
+}
+static int adc128_remove(struct i2c_client *client)
+{
+        struct adc128_data *data = i2c_get_clientdata(client);
+        if (data->regulator)
+                regulator_disable(data->regulator);
+        return 0;
+}
+static const struct i2c_device_id adc128_id[] = {
+        { "adc128d818", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, adc128_id);
+static struct i2c_driver adc128_driver = {
+        .class          = I2C_CLASS_HWMON,
+        .driver = {
+                .name   = "adc128d818",
+        },
+        .probe          = adc128_probe,
+        .remove         = adc128_remove,
+        .id_table       = adc128_id,
+        .detect         = adc128_detect,
+        .address_list   = normal_i2c,
+};
+module_i2c_driver(adc128_driver);
+MODULE_AUTHOR("Guenter Roeck");
+MODULE_DESCRIPTION("Driver for ADC128D818");
+MODULE_LICENSE("GPL");
diff --git a/drivers/hwmon/adm1021.c b/drivers/hwmon/adm1021.c
index 29dd9f746dfa..3eb4281689b5 100644
--- a/drivers/hwmon/adm1021.c
+++ b/drivers/hwmon/adm1021.c
@@ -79,9 +79,11 @@ enum chips {
 /* Each client has this additional data */
 struct adm1021_data {
-        struct device *hwmon_dev;
+        struct i2c_client *client;
        enum chips type;
+        const struct attribute_group *groups[3];
        struct mutex update_lock;
        char valid;             /* !=0 if following fields are valid */
        char low_power;         /* !=0 if device in low power mode */
@@ -101,7 +103,6 @@ static int adm1021_probe(struct i2c_client *client,
 static int adm1021_detect(struct i2c_client *client,
                          struct i2c_board_info *info);
 static void adm1021_init_client(struct i2c_client *client);
-static int adm1021_remove(struct i2c_client *client);
 static struct adm1021_data *adm1021_update_device(struct device *dev);
 /* (amalysh) read only mode, otherwise any limit's writing confuse BIOS */
@@ -128,7 +129,6 @@ static struct i2c_driver adm1021_driver = {
                .name   = "adm1021",
        },
        .probe          = adm1021_probe,
-        .remove         = adm1021_remove,
        .id_table       = adm1021_id,
        .detect         = adm1021_detect,
        .address_list   = normal_i2c,
@@ -182,8 +182,8 @@ static ssize_t set_temp_max(struct device *dev,
                            const char *buf, size_t count)
 {
        int index = to_sensor_dev_attr(devattr)->index;
-        struct i2c_client *client = to_i2c_client(dev);
+        struct adm1021_data *data = dev_get_drvdata(dev);
-        struct adm1021_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        long temp;
        int err;
@@ -207,8 +207,8 @@ static ssize_t set_temp_min(struct device *dev,
                            const char *buf, size_t count)
 {
        int index = to_sensor_dev_attr(devattr)->index;
-        struct i2c_client *client = to_i2c_client(dev);
+        struct adm1021_data *data = dev_get_drvdata(dev);
-        struct adm1021_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        long temp;
        int err;
@@ -238,8 +238,8 @@ static ssize_t set_low_power(struct device *dev,
                             struct device_attribute *devattr,
                             const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct adm1021_data *data = dev_get_drvdata(dev);
-        struct adm1021_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        char low_power;
        unsigned long val;
        int err;
@@ -412,15 +412,15 @@ static int adm1021_detect(struct i2c_client *client,
 static int adm1021_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
+        struct device *dev = &client->dev;
        struct adm1021_data *data;
-        int err;
+        struct device *hwmon_dev;
-        data = devm_kzalloc(&client->dev, sizeof(struct adm1021_data),
+        data = devm_kzalloc(dev, sizeof(struct adm1021_data), GFP_KERNEL);
-                            GFP_KERNEL);
        if (!data)
                return -ENOMEM;
-        i2c_set_clientdata(client, data);
+        data->client = client;
        data->type = id->driver_data;
        mutex_init(&data->update_lock);
@@ -428,29 +428,14 @@ static int adm1021_probe(struct i2c_client *client,
        if (data->type != lm84 && !read_only)
                adm1021_init_client(client);
-        /* Register sysfs hooks */
+        data->groups[0] = &adm1021_group;
-        err = sysfs_create_group(&client->dev.kobj, &adm1021_group);
+        if (data->type != lm84)
-        if (err)
+                data->groups[1] = &adm1021_min_group;
-                return err;
-        if (data->type != lm84) {
-                err = sysfs_create_group(&client->dev.kobj, &adm1021_min_group);
-                if (err)
-                        goto error;
-        }
-        data->hwmon_dev = hwmon_device_register(&client->dev);
+        hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
-        if (IS_ERR(data->hwmon_dev)) {
+                                                           data, data->groups);
-                err = PTR_ERR(data->hwmon_dev);
-                goto error;
-        }
-        return 0;
+        return PTR_ERR_OR_ZERO(hwmon_dev);
-error:
-        sysfs_remove_group(&client->dev.kobj, &adm1021_min_group);
-        sysfs_remove_group(&client->dev.kobj, &adm1021_group);
-        return err;
 }
 static void adm1021_init_client(struct i2c_client *client)
@@ -462,21 +447,10 @@ static void adm1021_init_client(struct i2c_client *client)
        i2c_smbus_write_byte_data(client, ADM1021_REG_CONV_RATE_W, 0x04);
 }
-static int adm1021_remove(struct i2c_client *client)
-{
-        struct adm1021_data *data = i2c_get_clientdata(client);
-        hwmon_device_unregister(data->hwmon_dev);
-        sysfs_remove_group(&client->dev.kobj, &adm1021_min_group);
-        sysfs_remove_group(&client->dev.kobj, &adm1021_group);
-        return 0;
-}
 static struct adm1021_data *adm1021_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct adm1021_data *data = dev_get_drvdata(dev);
-        struct adm1021_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        mutex_lock(&data->update_lock);
@@ -484,7 +458,7 @@ static struct adm1021_data *adm1021_update_device(struct device *dev)
            || !data->valid) {
                int i;
-                dev_dbg(&client->dev, "Starting adm1021 update\n");
+                dev_dbg(dev, "Starting adm1021 update\n");
                for (i = 0; i < 2; i++) {
                        data->temp[i] = 1000 *
diff --git a/drivers/hwmon/asc7621.c b/drivers/hwmon/asc7621.c
index 8d9f2a0e8efe..71463689d163 100644
--- a/drivers/hwmon/asc7621.c
+++ b/drivers/hwmon/asc7621.c
@@ -1115,7 +1115,6 @@ asc7621_probe(struct i2c_client *client, const struct i2c_device_id *id)
                return -ENOMEM;
        i2c_set_clientdata(client, data);
-        data->valid = 0;
        mutex_init(&data->update_lock);
        /* Initialize the asc7621 chip */
diff --git a/drivers/hwmon/atxp1.c b/drivers/hwmon/atxp1.c
index ddff02e3e66f..6edce42c61d5 100644
--- a/drivers/hwmon/atxp1.c
+++ b/drivers/hwmon/atxp1.c
@@ -353,8 +353,6 @@ static int atxp1_probe(struct i2c_client *new_client,
        data->vrm = vid_which_vrm();
        i2c_set_clientdata(new_client, data);
-        data->valid = 0;
        mutex_init(&data->update_lock);
        /* Register sysfs hooks */
diff --git a/drivers/hwmon/coretemp.c b/drivers/hwmon/coretemp.c
index bbb0b0d463f7..6d02e3b06375 100644
--- a/drivers/hwmon/coretemp.c
+++ b/drivers/hwmon/coretemp.c
@@ -94,6 +94,8 @@ struct temp_data {
        bool valid;
        struct sensor_device_attribute sd_attrs[TOTAL_ATTRS];
        char attr_name[TOTAL_ATTRS][CORETEMP_NAME_LENGTH];
+        struct attribute *attrs[TOTAL_ATTRS + 1];
+        struct attribute_group attr_group;
        struct mutex update_lock;
 };
@@ -114,12 +116,6 @@ struct pdev_entry {
 static LIST_HEAD(pdev_list);
 static DEFINE_MUTEX(pdev_list_mutex);
-static ssize_t show_name(struct device *dev,
-                        struct device_attribute *devattr, char *buf)
-{
-        return sprintf(buf, "%s\n", DRVNAME);
-}
 static ssize_t show_label(struct device *dev,
                                struct device_attribute *devattr, char *buf)
 {
@@ -393,20 +389,10 @@ static int get_tjmax(struct cpuinfo_x86 *c, u32 id, struct device *dev)
        return adjust_tjmax(c, id, dev);
 }
-static int create_name_attr(struct platform_data *pdata,
-                                      struct device *dev)
-{
-        sysfs_attr_init(&pdata->name_attr.attr);
-        pdata->name_attr.attr.name = "name";
-        pdata->name_attr.attr.mode = S_IRUGO;
-        pdata->name_attr.show = show_name;
-        return device_create_file(dev, &pdata->name_attr);
-}
 static int create_core_attrs(struct temp_data *tdata, struct device *dev,
                             int attr_no)
 {
-        int err, i;
+        int i;
        static ssize_t (*const rd_ptr[TOTAL_ATTRS]) (struct device *dev,
                        struct device_attribute *devattr, char *buf) = {
                        show_label, show_crit_alarm, show_temp, show_tjmax,
@@ -424,16 +410,10 @@ static int create_core_attrs(struct temp_data *tdata, struct device *dev,
                tdata->sd_attrs[i].dev_attr.attr.mode = S_IRUGO;
                tdata->sd_attrs[i].dev_attr.show = rd_ptr[i];
                tdata->sd_attrs[i].index = attr_no;
-                err = device_create_file(dev, &tdata->sd_attrs[i].dev_attr);
+                tdata->attrs[i] = &tdata->sd_attrs[i].dev_attr.attr;
-                if (err)
-                        goto exit_free;
        }
-        return 0;
+        tdata->attr_group.attrs = tdata->attrs;
+        return sysfs_create_group(&dev->kobj, &tdata->attr_group);
-exit_free:
-        while (--i >= 0)
-                device_remove_file(dev, &tdata->sd_attrs[i].dev_attr);
-        return err;
 }
@@ -548,7 +528,7 @@ static int create_core_data(struct platform_device *pdev, unsigned int cpu,
        pdata->core_data[attr_no] = tdata;
        /* Create sysfs interfaces */
-        err = create_core_attrs(tdata, &pdev->dev, attr_no);
+        err = create_core_attrs(tdata, pdata->hwmon_dev, attr_no);
        if (err)
                goto exit_free;
@@ -573,14 +553,12 @@ static void coretemp_add_core(unsigned int cpu, int pkg_flag)
 }
 static void coretemp_remove_core(struct platform_data *pdata,
-                                struct device *dev, int indx)
+                                 int indx)
 {
-        int i;
        struct temp_data *tdata = pdata->core_data[indx];
        /* Remove the sysfs attributes */
-        for (i = 0; i < tdata->attr_size; i++)
+        sysfs_remove_group(&pdata->hwmon_dev->kobj, &tdata->attr_group);
-                device_remove_file(dev, &tdata->sd_attrs[i].dev_attr);
        kfree(pdata->core_data[indx]);
        pdata->core_data[indx] = NULL;
@@ -588,34 +566,20 @@ static void coretemp_remove_core(struct platform_data *pdata,
 static int coretemp_probe(struct platform_device *pdev)
 {
+        struct device *dev = &pdev->dev;
        struct platform_data *pdata;
-        int err;
        /* Initialize the per-package data structures */
-        pdata = kzalloc(sizeof(struct platform_data), GFP_KERNEL);
+        pdata = devm_kzalloc(dev, sizeof(struct platform_data), GFP_KERNEL);
        if (!pdata)
                return -ENOMEM;
-        err = create_name_attr(pdata, &pdev->dev);
-        if (err)
-                goto exit_free;
        pdata->phys_proc_id = pdev->id;
        platform_set_drvdata(pdev, pdata);
-        pdata->hwmon_dev = hwmon_device_register(&pdev->dev);
+        pdata->hwmon_dev = devm_hwmon_device_register_with_groups(dev, DRVNAME,
-        if (IS_ERR(pdata->hwmon_dev)) {
+                                                                  pdata, NULL);
-                err = PTR_ERR(pdata->hwmon_dev);
+        return PTR_ERR_OR_ZERO(pdata->hwmon_dev);
-                dev_err(&pdev->dev, "Class registration failed (%d)\n", err);
-                goto exit_name;
-        }
-        return 0;
-exit_name:
-        device_remove_file(&pdev->dev, &pdata->name_attr);
-exit_free:
-        kfree(pdata);
-        return err;
 }
 static int coretemp_remove(struct platform_device *pdev)
@@ -625,11 +589,8 @@ static int coretemp_remove(struct platform_device *pdev)
        for (i = MAX_CORE_DATA - 1; i >= 0; --i)
                if (pdata->core_data[i])
-                        coretemp_remove_core(pdata, &pdev->dev, i);
+                        coretemp_remove_core(pdata, i);
-        device_remove_file(&pdev->dev, &pdata->name_attr);
-        hwmon_device_unregister(pdata->hwmon_dev);
-        kfree(pdata);
        return 0;
 }
@@ -777,7 +738,7 @@ static void put_core_offline(unsigned int cpu)
                return;
        if (pdata->core_data[indx] && pdata->core_data[indx]->cpu == cpu)
-                coretemp_remove_core(pdata, &pdev->dev, indx);
+                coretemp_remove_core(pdata, indx);
        /*
         * If a HT sibling of a core is taken offline, but another HT sibling
@@ -849,20 +810,20 @@ static int __init coretemp_init(void)
        if (err)
                goto exit;
-        get_online_cpus();
+        cpu_notifier_register_begin();
        for_each_online_cpu(i)
                get_core_online(i);
 #ifndef CONFIG_HOTPLUG_CPU
        if (list_empty(&pdev_list)) {
-                put_online_cpus();
+                cpu_notifier_register_done();
                err = -ENODEV;
                goto exit_driver_unreg;
        }
 #endif
-        register_hotcpu_notifier(&coretemp_cpu_notifier);
+        __register_hotcpu_notifier(&coretemp_cpu_notifier);
-        put_online_cpus();
+        cpu_notifier_register_done();
        return 0;
 #ifndef CONFIG_HOTPLUG_CPU
@@ -877,8 +838,8 @@ static void __exit coretemp_exit(void)
 {
        struct pdev_entry *p, *n;
-        get_online_cpus();
+        cpu_notifier_register_begin();
-        unregister_hotcpu_notifier(&coretemp_cpu_notifier);
+        __unregister_hotcpu_notifier(&coretemp_cpu_notifier);
        mutex_lock(&pdev_list_mutex);
        list_for_each_entry_safe(p, n, &pdev_list, list) {
                platform_device_unregister(p->pdev);
@@ -886,7 +847,7 @@ static void __exit coretemp_exit(void)
                kfree(p);
        }
        mutex_unlock(&pdev_list_mutex);
-        put_online_cpus();
+        cpu_notifier_register_done();
        platform_driver_unregister(&coretemp_driver);
 }
diff --git a/drivers/hwmon/emc2103.c b/drivers/hwmon/emc2103.c
index 2c137b26acb4..fd892dd48e4c 100644
--- a/drivers/hwmon/emc2103.c
+++ b/drivers/hwmon/emc2103.c
@@ -349,7 +349,7 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
                dev_dbg(&client->dev, "reg 0x%02x, err %d\n",
                        REG_FAN_CONF1, status);
                mutex_unlock(&data->update_lock);
-                return -EIO;
+                return status;
        }
        status &= 0x9F;
        status |= (new_range_bits << 5);
diff --git a/drivers/hwmon/f71805f.c b/drivers/hwmon/f71805f.c
index 1a8aa1265262..32f5132c4652 100644
--- a/drivers/hwmon/f71805f.c
+++ b/drivers/hwmon/f71805f.c
@@ -1648,7 +1648,7 @@ static void __exit f71805f_exit(void)
        platform_driver_unregister(&f71805f_driver);
 }
-MODULE_AUTHOR("Jean Delvare <khali@linux-fr>");
+MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("F71805F/F71872F hardware monitoring driver");
diff --git a/drivers/hwmon/hwmon.c b/drivers/hwmon/hwmon.c
index e176a43af63d..a26c385a435b 100644
--- a/drivers/hwmon/hwmon.c
+++ b/drivers/hwmon/hwmon.c
@@ -22,6 +22,7 @@
 #include <linux/gfp.h>
 #include <linux/spinlock.h>
 #include <linux/pci.h>
+#include <linux/string.h>
 #define HWMON_ID_PREFIX "hwmon"
 #define HWMON_ID_FORMAT HWMON_ID_PREFIX "%d"
@@ -99,6 +100,10 @@ hwmon_device_register_with_groups(struct device *dev, const char *name,
        struct hwmon_device *hwdev;
        int err, id;
+        /* Do not accept invalid characters in hwmon name attribute */
+        if (name && (!strlen(name) || strpbrk(name, "-* \t\n")))
+                return ERR_PTR(-EINVAL);
        id = ida_simple_get(&hwmon_ida, 0, 0, GFP_KERNEL);
        if (id < 0)
                return ERR_PTR(id);
diff --git a/drivers/hwmon/iio_hwmon.c b/drivers/hwmon/iio_hwmon.c
index 708081b68c6f..9fbb1b1fdff3 100644
--- a/drivers/hwmon/iio_hwmon.c
+++ b/drivers/hwmon/iio_hwmon.c
@@ -31,6 +31,7 @@ struct iio_hwmon_state {
        int num_channels;
        struct device *hwmon_dev;
        struct attribute_group attr_group;
+        const struct attribute_group *groups[2];
        struct attribute **attrs;
 };
@@ -56,19 +57,6 @@ static ssize_t iio_hwmon_read_val(struct device *dev,
        return sprintf(buf, "%d\n", result);
 }
-static ssize_t show_name(struct device *dev, struct device_attribute *attr,
-                         char *buf)
-{
-        const char *name = "iio_hwmon";
-        if (dev->of_node && dev->of_node->name)
-                name = dev->of_node->name;
-        return sprintf(buf, "%s\n", name);
-}
-static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 static int iio_hwmon_probe(struct platform_device *pdev)
 {
        struct device *dev = &pdev->dev;
@@ -78,6 +66,10 @@ static int iio_hwmon_probe(struct platform_device *pdev)
        int in_i = 1, temp_i = 1, curr_i = 1;
        enum iio_chan_type type;
        struct iio_channel *channels;
+        const char *name = "iio_hwmon";
+        if (dev->of_node && dev->of_node->name)
+                name = dev->of_node->name;
        channels = iio_channel_get_all(dev);
        if (IS_ERR(channels))
@@ -96,7 +88,7 @@ static int iio_hwmon_probe(struct platform_device *pdev)
                st->num_channels++;
        st->attrs = devm_kzalloc(dev,
-                                 sizeof(*st->attrs) * (st->num_channels + 2),
+                                 sizeof(*st->attrs) * (st->num_channels + 1),
                                 GFP_KERNEL);
        if (st->attrs == NULL) {
                ret = -ENOMEM;
@@ -144,22 +136,18 @@ static int iio_hwmon_probe(struct platform_device *pdev)
                a->index = i;
                st->attrs[i] = &a->dev_attr.attr;
        }
-        st->attrs[st->num_channels] = &dev_attr_name.attr;
-        st->attr_group.attrs = st->attrs;
-        platform_set_drvdata(pdev, st);
-        ret = sysfs_create_group(&dev->kobj, &st->attr_group);
-        if (ret < 0)
-                goto error_release_channels;
-        st->hwmon_dev = hwmon_device_register(dev);
+        st->attr_group.attrs = st->attrs;
+        st->groups[0] = &st->attr_group;
+        st->hwmon_dev = hwmon_device_register_with_groups(dev, name, st,
+                                                          st->groups);
        if (IS_ERR(st->hwmon_dev)) {
                ret = PTR_ERR(st->hwmon_dev);
-                goto error_remove_group;
+                goto error_release_channels;
        }
+        platform_set_drvdata(pdev, st);
        return 0;
-error_remove_group:
-        sysfs_remove_group(&dev->kobj, &st->attr_group);
 error_release_channels:
        iio_channel_release_all(channels);
        return ret;
@@ -170,7 +158,6 @@ static int iio_hwmon_remove(struct platform_device *pdev)
        struct iio_hwmon_state *st = platform_get_drvdata(pdev);
        hwmon_device_unregister(st->hwmon_dev);
-        sysfs_remove_group(&pdev->dev.kobj, &st->attr_group);
        iio_channel_release_all(st->channels);
        return 0;
diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
index 70749fc15a4f..a327fd3402a7 100644
--- a/drivers/hwmon/it87.c
+++ b/drivers/hwmon/it87.c
@@ -11,6 +11,7 @@
 *  similar parts.  The other devices are supported by different drivers.
 *
 *  Supports: IT8603E  Super I/O chip w/LPC interface
+ *            IT8623E  Super I/O chip w/LPC interface
 *            IT8705F  Super I/O chip w/LPC interface
 *            IT8712F  Super I/O chip w/LPC interface
 *            IT8716F  Super I/O chip w/LPC interface
@@ -147,7 +148,8 @@ static inline void superio_exit(void)
 #define IT8772E_DEVID 0x8772
 #define IT8782F_DEVID 0x8782
 #define IT8783E_DEVID 0x8783
-#define IT8306E_DEVID 0x8603
+#define IT8603E_DEVID 0x8603
+#define IT8623E_DEVID 0x8623
 #define IT87_ACT_REG  0x30
 #define IT87_BASE_REG 0x60
@@ -1431,7 +1433,7 @@ static ssize_t show_label(struct device *dev, struct device_attribute *attr,
 static SENSOR_DEVICE_ATTR(in3_label, S_IRUGO, show_label, NULL, 0);
 static SENSOR_DEVICE_ATTR(in7_label, S_IRUGO, show_label, NULL, 1);
 static SENSOR_DEVICE_ATTR(in8_label, S_IRUGO, show_label, NULL, 2);
-/* special AVCC3 IT8306E in9 */
+/* special AVCC3 IT8603E in9 */
 static SENSOR_DEVICE_ATTR(in9_label, S_IRUGO, show_label, NULL, 0);
 static ssize_t show_name(struct device *dev, struct device_attribute
@@ -1766,7 +1768,8 @@ static int __init it87_find(unsigned short *address,
        case IT8783E_DEVID:
                sio_data->type = it8783;
                break;
-        case IT8306E_DEVID:
+        case IT8603E_DEVID:
+        case IT8623E_DEVID:
                sio_data->type = it8603;
                break;
        case 0xffff:    /* No device at all */
diff --git a/drivers/hwmon/jz4740-hwmon.c b/drivers/hwmon/jz4740-hwmon.c
index a183e488db78..7488e36809c8 100644
--- a/drivers/hwmon/jz4740-hwmon.c
+++ b/drivers/hwmon/jz4740-hwmon.c
@@ -28,7 +28,6 @@
 #include <linux/hwmon.h>
 struct jz4740_hwmon {
-        struct resource *mem;
        void __iomem *base;
        int irq;
@@ -106,6 +105,7 @@ static int jz4740_hwmon_probe(struct platform_device *pdev)
 {
        int ret;
        struct jz4740_hwmon *hwmon;
+        struct resource *mem;
        hwmon = devm_kzalloc(&pdev->dev, sizeof(*hwmon), GFP_KERNEL);
        if (!hwmon)
@@ -120,25 +120,10 @@ static int jz4740_hwmon_probe(struct platform_device *pdev)
                return hwmon->irq;
        }
-        hwmon->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!hwmon->mem) {
+        hwmon->base = devm_ioremap_resource(&pdev->dev, mem);
-                dev_err(&pdev->dev, "Failed to get platform mmio resource\n");
+        if (IS_ERR(hwmon->base))
-                return -ENOENT;
+                return PTR_ERR(hwmon->base);
-        }
-        hwmon->mem = devm_request_mem_region(&pdev->dev, hwmon->mem->start,
-                        resource_size(hwmon->mem), pdev->name);
-        if (!hwmon->mem) {
-                dev_err(&pdev->dev, "Failed to request mmio memory region\n");
-                return -EBUSY;
-        }
-        hwmon->base = devm_ioremap_nocache(&pdev->dev, hwmon->mem->start,
-                                           resource_size(hwmon->mem));
-        if (!hwmon->base) {
-                dev_err(&pdev->dev, "Failed to ioremap mmio memory\n");
-                return -EBUSY;
-        }
        init_completion(&hwmon->read_completion);
        mutex_init(&hwmon->lock);
diff --git a/drivers/hwmon/k10temp.c b/drivers/hwmon/k10temp.c
index baf375b5ab0d..f7b46f68ef43 100644
--- a/drivers/hwmon/k10temp.c
+++ b/drivers/hwmon/k10temp.c
@@ -212,6 +212,7 @@ static const struct pci_device_id k10temp_id_table[] = {
        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_15H_M10H_F3) },
        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_15H_M30H_NB_F3) },
        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_16H_NB_F3) },
+        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_16H_M30H_NB_F3) },
        {}
 };
 MODULE_DEVICE_TABLE(pci, k10temp_id_table);
diff --git a/drivers/hwmon/lm63.c b/drivers/hwmon/lm63.c
index b4ad598feb6c..848b9611151f 100644
--- a/drivers/hwmon/lm63.c
+++ b/drivers/hwmon/lm63.c
@@ -155,8 +155,9 @@ enum chips { lm63, lm64, lm96163 };
 */
 struct lm63_data {
-        struct device *hwmon_dev;
+        struct i2c_client *client;
        struct mutex update_lock;
+        const struct attribute_group *groups[5];
        char valid; /* zero until following fields are valid */
        char lut_valid; /* zero until lut fields are valid */
        unsigned long last_updated; /* in jiffies */
@@ -218,9 +219,9 @@ static inline int lut_temp_to_reg(struct lm63_data *data, long val)
 * Update the lookup table register cache.
 * client->update_lock must be held when calling this function.
 */
-static void lm63_update_lut(struct i2c_client *client)
+static void lm63_update_lut(struct lm63_data *data)
 {
-        struct lm63_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        int i;
        if (time_after(jiffies, data->lut_last_updated + 5 * HZ) ||
@@ -241,8 +242,8 @@ static void lm63_update_lut(struct i2c_client *client)
 static struct lm63_data *lm63_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm63_data *data = dev_get_drvdata(dev);
-        struct lm63_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        unsigned long next_update;
        mutex_lock(&data->update_lock);
@@ -310,7 +311,7 @@ static struct lm63_data *lm63_update_device(struct device *dev)
                data->valid = 1;
        }
-        lm63_update_lut(client);
+        lm63_update_lut(data);
        mutex_unlock(&data->update_lock);
@@ -321,18 +322,17 @@ static struct lm63_data *lm63_update_device(struct device *dev)
 * Trip points in the lookup table should be in ascending order for both
 * temperatures and PWM output values.
 */
-static int lm63_lut_looks_bad(struct i2c_client *client)
+static int lm63_lut_looks_bad(struct device *dev, struct lm63_data *data)
 {
-        struct lm63_data *data = i2c_get_clientdata(client);
        int i;
        mutex_lock(&data->update_lock);
-        lm63_update_lut(client);
+        lm63_update_lut(data);
        for (i = 1; i < data->lut_size; i++) {
                if (data->pwm1[1 + i - 1] > data->pwm1[1 + i]
                 || data->temp8[3 + i - 1] > data->temp8[3 + i]) {
-                        dev_warn(&client->dev,
+                        dev_warn(dev,
                                 "Lookup table doesn't look sane (check entries %d and %d)\n",
                                 i, i + 1);
                        break;
@@ -358,8 +358,8 @@ static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
 static ssize_t set_fan(struct device *dev, struct device_attribute *dummy,
                       const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm63_data *data = dev_get_drvdata(dev);
-        struct lm63_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        unsigned long val;
        int err;
@@ -399,8 +399,8 @@ static ssize_t set_pwm1(struct device *dev, struct device_attribute *devattr,
                        const char *buf, size_t count)
 {
        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm63_data *data = dev_get_drvdata(dev);
-        struct lm63_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        int nr = attr->index;
        unsigned long val;
        int err;
@@ -435,8 +435,8 @@ static ssize_t set_pwm1_enable(struct device *dev,
                               struct device_attribute *dummy,
                               const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm63_data *data = dev_get_drvdata(dev);
-        struct lm63_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        unsigned long val;
        int err;
@@ -450,7 +450,7 @@ static ssize_t set_pwm1_enable(struct device *dev,
         * Only let the user switch to automatic mode if the lookup table
         * looks sane.
         */
-        if (val == 2 && lm63_lut_looks_bad(client))
+        if (val == 2 && lm63_lut_looks_bad(dev, data))
                return -EPERM;
        mutex_lock(&data->update_lock);
@@ -461,7 +461,7 @@ static ssize_t set_pwm1_enable(struct device *dev,
        else
                data->config_fan &= ~0x20;
        i2c_smbus_write_byte_data(client, LM63_REG_CONFIG_FAN,
-        data->config_fan);
+                                  data->config_fan);
        mutex_unlock(&data->update_lock);
        return count;
 }
@@ -505,8 +505,8 @@ static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
                         const char *buf, size_t count)
 {
        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm63_data *data = dev_get_drvdata(dev);
-        struct lm63_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        int nr = attr->index;
        long val;
        int err;
@@ -579,8 +579,8 @@ static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
        };
        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm63_data *data = dev_get_drvdata(dev);
-        struct lm63_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        long val;
        int err;
        int nr = attr->index;
@@ -635,8 +635,8 @@ static ssize_t set_temp2_crit_hyst(struct device *dev,
                                   struct device_attribute *dummy,
                                   const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm63_data *data = dev_get_drvdata(dev);
-        struct lm63_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        long val;
        int err;
        long hyst;
@@ -657,11 +657,11 @@ static ssize_t set_temp2_crit_hyst(struct device *dev,
 * Set conversion rate.
 * client->update_lock must be held when calling this function.
 */
-static void lm63_set_convrate(struct i2c_client *client, struct lm63_data *data,
+static void lm63_set_convrate(struct lm63_data *data, unsigned int interval)
-                              unsigned int interval)
 {
-        int i;
+        struct i2c_client *client = data->client;
        unsigned int update_interval;
+        int i;
        /* Shift calculations to avoid rounding errors */
        interval <<= 6;
@@ -689,8 +689,7 @@ static ssize_t set_update_interval(struct device *dev,
                                   struct device_attribute *attr,
                                   const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm63_data *data = dev_get_drvdata(dev);
-        struct lm63_data *data = i2c_get_clientdata(client);
        unsigned long val;
        int err;
@@ -699,7 +698,7 @@ static ssize_t set_update_interval(struct device *dev,
                return err;
        mutex_lock(&data->update_lock);
-        lm63_set_convrate(client, data, clamp_val(val, 0, 100000));
+        lm63_set_convrate(data, clamp_val(val, 0, 100000));
        mutex_unlock(&data->update_lock);
        return count;
@@ -708,8 +707,7 @@ static ssize_t set_update_interval(struct device *dev,
 static ssize_t show_type(struct device *dev, struct device_attribute *attr,
                         char *buf)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm63_data *data = dev_get_drvdata(dev);
-        struct lm63_data *data = i2c_get_clientdata(client);
        return sprintf(buf, data->trutherm ? "1\n" : "2\n");
 }
@@ -717,8 +715,8 @@ static ssize_t show_type(struct device *dev, struct device_attribute *attr,
 static ssize_t set_type(struct device *dev, struct device_attribute *attr,
                        const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm63_data *data = dev_get_drvdata(dev);
-        struct lm63_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        unsigned long val;
        int ret;
        u8 reg;
@@ -915,6 +913,15 @@ static struct attribute *lm63_attributes[] = {
        NULL
 };
+static struct attribute *lm63_attributes_temp2_type[] = {
+        &dev_attr_temp2_type.attr,
+        NULL
+};
+static const struct attribute_group lm63_group_temp2_type = {
+        .attrs = lm63_attributes_temp2_type,
+};
 static struct attribute *lm63_attributes_extra_lut[] = {
        &sensor_dev_attr_pwm1_auto_point9_pwm.dev_attr.attr,
        &sensor_dev_attr_pwm1_auto_point9_temp.dev_attr.attr,
@@ -946,8 +953,7 @@ static umode_t lm63_attribute_mode(struct kobject *kobj,
                                   struct attribute *attr, int index)
 {
        struct device *dev = container_of(kobj, struct device, kobj);
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm63_data *data = dev_get_drvdata(dev);
-        struct lm63_data *data = i2c_get_clientdata(client);
        if (attr == &sensor_dev_attr_temp2_crit.dev_attr.attr
            && (data->kind == lm64 ||
@@ -1026,9 +1032,10 @@ static int lm63_detect(struct i2c_client *client,
 * Ideally we shouldn't have to initialize anything, since the BIOS
 * should have taken care of everything
 */
-static void lm63_init_client(struct i2c_client *client)
+static void lm63_init_client(struct lm63_data *data)
 {
-        struct lm63_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
+        struct device *dev = &client->dev;
        u8 convrate;
        data->config = i2c_smbus_read_byte_data(client, LM63_REG_CONFIG1);
@@ -1037,7 +1044,7 @@ static void lm63_init_client(struct i2c_client *client)
        /* Start converting if needed */
        if (data->config & 0x40) { /* standby */
-                dev_dbg(&client->dev, "Switching to operational mode\n");
+                dev_dbg(dev, "Switching to operational mode\n");
                data->config &= 0xA7;
                i2c_smbus_write_byte_data(client, LM63_REG_CONFIG1,
                                          data->config);
@@ -1090,13 +1097,13 @@ static void lm63_init_client(struct i2c_client *client)
        /* Show some debug info about the LM63 configuration */
        if (data->kind == lm63)
-                dev_dbg(&client->dev, "Alert/tach pin configured for %s\n",
+                dev_dbg(dev, "Alert/tach pin configured for %s\n",
                        (data->config & 0x04) ? "tachometer input" :
                        "alert output");
-        dev_dbg(&client->dev, "PWM clock %s kHz, output frequency %u Hz\n",
+        dev_dbg(dev, "PWM clock %s kHz, output frequency %u Hz\n",
                (data->config_fan & 0x08) ? "1.4" : "360",
                ((data->config_fan & 0x08) ? 700 : 180000) / data->pwm1_freq);
-        dev_dbg(&client->dev, "PWM output active %s, %s mode\n",
+        dev_dbg(dev, "PWM output active %s, %s mode\n",
                (data->config_fan & 0x10) ? "low" : "high",
                (data->config_fan & 0x20) ? "manual" : "auto");
 }
@@ -1104,15 +1111,16 @@ static void lm63_init_client(struct i2c_client *client)
 static int lm63_probe(struct i2c_client *client,
                      const struct i2c_device_id *id)
 {
+        struct device *dev = &client->dev;
+        struct device *hwmon_dev;
        struct lm63_data *data;
-        int err;
+        int groups = 0;
-        data = devm_kzalloc(&client->dev, sizeof(struct lm63_data), GFP_KERNEL);
+        data = devm_kzalloc(dev, sizeof(struct lm63_data), GFP_KERNEL);
        if (!data)
                return -ENOMEM;
-        i2c_set_clientdata(client, data);
+        data->client = client;
-        data->valid = 0;
        mutex_init(&data->update_lock);
        /* Set the device type */
@@ -1121,59 +1129,21 @@ static int lm63_probe(struct i2c_client *client,
                data->temp2_offset = 16000;
        /* Initialize chip */
-        lm63_init_client(client);
+        lm63_init_client(data);
        /* Register sysfs hooks */
-        err = sysfs_create_group(&client->dev.kobj, &lm63_group);
+        data->groups[groups++] = &lm63_group;
-        if (err)
+        if (data->config & 0x04)        /* tachometer enabled */
-                return err;
+                data->groups[groups++] = &lm63_group_fan1;
-        if (data->config & 0x04) { /* tachometer enabled */
-                err = sysfs_create_group(&client->dev.kobj, &lm63_group_fan1);
-                if (err)
-                        goto exit_remove_files;
-        }
-        if (data->kind == lm96163) {
-                err = device_create_file(&client->dev, &dev_attr_temp2_type);
-                if (err)
-                        goto exit_remove_files;
-                err = sysfs_create_group(&client->dev.kobj,
-                                         &lm63_group_extra_lut);
-                if (err)
-                        goto exit_remove_files;
-        }
-        data->hwmon_dev = hwmon_device_register(&client->dev);
-        if (IS_ERR(data->hwmon_dev)) {
-                err = PTR_ERR(data->hwmon_dev);
-                goto exit_remove_files;
-        }
-        return 0;
-exit_remove_files:
-        sysfs_remove_group(&client->dev.kobj, &lm63_group);
-        sysfs_remove_group(&client->dev.kobj, &lm63_group_fan1);
        if (data->kind == lm96163) {
-                device_remove_file(&client->dev, &dev_attr_temp2_type);
+                data->groups[groups++] = &lm63_group_temp2_type;
-                sysfs_remove_group(&client->dev.kobj, &lm63_group_extra_lut);
+                data->groups[groups++] = &lm63_group_extra_lut;
        }
-        return err;
-}
-static int lm63_remove(struct i2c_client *client)
-{
-        struct lm63_data *data = i2c_get_clientdata(client);
-        hwmon_device_unregister(data->hwmon_dev);
+        hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
-        sysfs_remove_group(&client->dev.kobj, &lm63_group);
+                                                           data, data->groups);
-        sysfs_remove_group(&client->dev.kobj, &lm63_group_fan1);
+        return PTR_ERR_OR_ZERO(hwmon_dev);
-        if (data->kind == lm96163) {
-                device_remove_file(&client->dev, &dev_attr_temp2_type);
-                sysfs_remove_group(&client->dev.kobj, &lm63_group_extra_lut);
-        }
-        return 0;
 }
 /*
@@ -1194,7 +1164,6 @@ static struct i2c_driver lm63_driver = {
                .name   = "lm63",
        },
        .probe          = lm63_probe,
-        .remove         = lm63_remove,
        .id_table       = lm63_id,
        .detect         = lm63_detect,
        .address_list   = normal_i2c,
diff --git a/drivers/hwmon/lm77.c b/drivers/hwmon/lm77.c
index f17beb5e6dd6..502771c06fd9 100644
--- a/drivers/hwmon/lm77.c
+++ b/drivers/hwmon/lm77.c
@@ -348,7 +348,6 @@ static int lm77_probe(struct i2c_client *client, const struct i2c_device_id *id)
                return -ENOMEM;
        i2c_set_clientdata(client, data);
-        data->valid = 0;
        mutex_init(&data->update_lock);
        /* Initialize the LM77 chip */
diff --git a/drivers/hwmon/lm80.c b/drivers/hwmon/lm80.c
index eba89aac3ece..bd0a1ebbf867 100644
--- a/drivers/hwmon/lm80.c
+++ b/drivers/hwmon/lm80.c
@@ -112,7 +112,7 @@ static inline long TEMP_FROM_REG(u16 temp)
 */
 struct lm80_data {
-        struct device *hwmon_dev;
+        struct i2c_client *client;
        struct mutex update_lock;
        char error;             /* !=0 if error occurred during last update */
        char valid;             /* !=0 if following fields are valid */
@@ -140,7 +140,6 @@ static int lm80_probe(struct i2c_client *client,
                      const struct i2c_device_id *id);
 static int lm80_detect(struct i2c_client *client, struct i2c_board_info *info);
 static void lm80_init_client(struct i2c_client *client);
-static int lm80_remove(struct i2c_client *client);
 static struct lm80_data *lm80_update_device(struct device *dev);
 static int lm80_read_value(struct i2c_client *client, u8 reg);
 static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value);
@@ -162,7 +161,6 @@ static struct i2c_driver lm80_driver = {
                .name   = "lm80",
        },
        .probe          = lm80_probe,
-        .remove         = lm80_remove,
        .id_table       = lm80_id,
        .detect         = lm80_detect,
        .address_list   = normal_i2c,
@@ -191,8 +189,8 @@ static ssize_t set_in_##suffix(struct device *dev, \
        struct device_attribute *attr, const char *buf, size_t count) \
 { \
        int nr = to_sensor_dev_attr(attr)->index; \
-        struct i2c_client *client = to_i2c_client(dev); \
+        struct lm80_data *data = dev_get_drvdata(dev); \
-        struct lm80_data *data = i2c_get_clientdata(client); \
+        struct i2c_client *client = data->client; \
        long val; \
        int err = kstrtol(buf, 10, &val); \
        if (err < 0) \
@@ -235,8 +233,8 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
        const char *buf, size_t count)
 {
        int nr = to_sensor_dev_attr(attr)->index;
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm80_data *data = dev_get_drvdata(dev);
-        struct lm80_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        unsigned long val;
        int err = kstrtoul(buf, 10, &val);
        if (err < 0)
@@ -259,8 +257,8 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
        const char *buf, size_t count)
 {
        int nr = to_sensor_dev_attr(attr)->index;
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm80_data *data = dev_get_drvdata(dev);
-        struct lm80_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        unsigned long min, val;
        u8 reg;
        int err = kstrtoul(buf, 10, &val);
@@ -286,7 +284,7 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
                data->fan_div[nr] = 3;
                break;
        default:
-                dev_err(&client->dev,
+                dev_err(dev,
                        "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n",
                        val);
                mutex_unlock(&data->update_lock);
@@ -332,8 +330,8 @@ show_temp(os_hyst, temp_os_hyst);
 static ssize_t set_temp_##suffix(struct device *dev, \
        struct device_attribute *attr, const char *buf, size_t count) \
 { \
-        struct i2c_client *client = to_i2c_client(dev); \
+        struct lm80_data *data = dev_get_drvdata(dev); \
-        struct lm80_data *data = i2c_get_clientdata(client); \
+        struct i2c_client *client = data->client; \
        long val; \
        int err = kstrtol(buf, 10, &val); \
        if (err < 0) \
@@ -440,7 +438,7 @@ static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 13);
 * Real code
 */
-static struct attribute *lm80_attributes[] = {
+static struct attribute *lm80_attrs[] = {
        &sensor_dev_attr_in0_min.dev_attr.attr,
        &sensor_dev_attr_in1_min.dev_attr.attr,
        &sensor_dev_attr_in2_min.dev_attr.attr,
@@ -487,10 +485,7 @@ static struct attribute *lm80_attributes[] = {
        &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
        NULL
 };
+ATTRIBUTE_GROUPS(lm80);
-static const struct attribute_group lm80_group = {
-        .attrs = lm80_attributes,
-};
 /* Return 0 if detection is successful, -ENODEV otherwise */
 static int lm80_detect(struct i2c_client *client, struct i2c_board_info *info)
@@ -541,14 +536,15 @@ static int lm80_detect(struct i2c_client *client, struct i2c_board_info *info)
 static int lm80_probe(struct i2c_client *client,
                      const struct i2c_device_id *id)
 {
+        struct device *dev = &client->dev;
+        struct device *hwmon_dev;
        struct lm80_data *data;
-        int err;
-        data = devm_kzalloc(&client->dev, sizeof(struct lm80_data), GFP_KERNEL);
+        data = devm_kzalloc(dev, sizeof(struct lm80_data), GFP_KERNEL);
        if (!data)
                return -ENOMEM;
-        i2c_set_clientdata(client, data);
+        data->client = client;
        mutex_init(&data->update_lock);
        /* Initialize the LM80 chip */
@@ -558,32 +554,10 @@ static int lm80_probe(struct i2c_client *client,
        data->fan_min[0] = lm80_read_value(client, LM80_REG_FAN_MIN(1));
        data->fan_min[1] = lm80_read_value(client, LM80_REG_FAN_MIN(2));
-        /* Register sysfs hooks */
+        hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
-        err = sysfs_create_group(&client->dev.kobj, &lm80_group);
+                                                           data, lm80_groups);
-        if (err)
-                return err;
-        data->hwmon_dev = hwmon_device_register(&client->dev);
-        if (IS_ERR(data->hwmon_dev)) {
-                err = PTR_ERR(data->hwmon_dev);
-                goto error_remove;
-        }
-        return 0;
+        return PTR_ERR_OR_ZERO(hwmon_dev);
-error_remove:
-        sysfs_remove_group(&client->dev.kobj, &lm80_group);
-        return err;
-}
-static int lm80_remove(struct i2c_client *client)
-{
-        struct lm80_data *data = i2c_get_clientdata(client);
-        hwmon_device_unregister(data->hwmon_dev);
-        sysfs_remove_group(&client->dev.kobj, &lm80_group);
-        return 0;
 }
 static int lm80_read_value(struct i2c_client *client, u8 reg)
@@ -614,8 +588,8 @@ static void lm80_init_client(struct i2c_client *client)
 static struct lm80_data *lm80_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm80_data *data = dev_get_drvdata(dev);
-        struct lm80_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        int i;
        int rv;
        int prev_rv;
@@ -627,7 +601,7 @@ static struct lm80_data *lm80_update_device(struct device *dev)
                lm80_init_client(client);
        if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
-                dev_dbg(&client->dev, "Starting lm80 update\n");
+                dev_dbg(dev, "Starting lm80 update\n");
                for (i = 0; i <= 6; i++) {
                        rv = lm80_read_value(client, LM80_REG_IN(i));
                        if (rv < 0)
diff --git a/drivers/hwmon/lm83.c b/drivers/hwmon/lm83.c
index abd270243ba7..be02155788c3 100644
--- a/drivers/hwmon/lm83.c
+++ b/drivers/hwmon/lm83.c
@@ -349,7 +349,6 @@ static int lm83_probe(struct i2c_client *new_client,
                return -ENOMEM;
        i2c_set_clientdata(new_client, data);
-        data->valid = 0;
        mutex_init(&data->update_lock);
        /*
diff --git a/drivers/hwmon/lm87.c b/drivers/hwmon/lm87.c
index 4c5f20231c1a..ba1d83d48056 100644
--- a/drivers/hwmon/lm87.c
+++ b/drivers/hwmon/lm87.c
@@ -903,7 +903,6 @@ static int lm87_probe(struct i2c_client *client, const struct i2c_device_id *id)
                return -ENOMEM;
        i2c_set_clientdata(client, data);
-        data->valid = 0;
        mutex_init(&data->update_lock);
        /* Initialize the LM87 chip */
diff --git a/drivers/hwmon/lm90.c b/drivers/hwmon/lm90.c
index 701e952ae523..c9ff08dbe10c 100644
--- a/drivers/hwmon/lm90.c
+++ b/drivers/hwmon/lm90.c
@@ -365,7 +365,9 @@ enum lm90_temp11_reg_index {
 */
 struct lm90_data {
+        struct i2c_client *client;
        struct device *hwmon_dev;
+        const struct attribute_group *groups[6];
        struct mutex update_lock;
        struct regulator *regulator;
        char valid; /* zero until following fields are valid */
@@ -513,8 +515,8 @@ static void lm90_set_convrate(struct i2c_client *client, struct lm90_data *data,
 static struct lm90_data *lm90_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm90_data *data = dev_get_drvdata(dev);
-        struct lm90_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        unsigned long next_update;
        mutex_lock(&data->update_lock);
@@ -793,8 +795,8 @@ static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
        };
        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm90_data *data = dev_get_drvdata(dev);
-        struct lm90_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        int nr = attr->index;
        long val;
        int err;
@@ -860,8 +862,8 @@ static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
        };
        struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm90_data *data = dev_get_drvdata(dev);
-        struct lm90_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        int nr = attr->nr;
        int index = attr->index;
        long val;
@@ -922,8 +924,8 @@ static ssize_t show_temphyst(struct device *dev,
 static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
                            const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm90_data *data = dev_get_drvdata(dev);
-        struct lm90_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        long val;
        int err;
        int temp;
@@ -976,8 +978,8 @@ static ssize_t set_update_interval(struct device *dev,
                                   struct device_attribute *attr,
                                   const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm90_data *data = dev_get_drvdata(dev);
-        struct lm90_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        unsigned long val;
        int err;
@@ -1057,6 +1059,15 @@ static const struct attribute_group lm90_group = {
        .attrs = lm90_attributes,
 };
+static struct attribute *lm90_temp2_offset_attributes[] = {
+        &sensor_dev_attr_temp2_offset.dev_attr.attr,
+        NULL
+};
+static const struct attribute_group lm90_temp2_offset_group = {
+        .attrs = lm90_temp2_offset_attributes,
+};
 /*
 * Additional attributes for devices with emergency sensors
 */
@@ -1393,22 +1404,6 @@ static int lm90_detect(struct i2c_client *client,
        return 0;
 }
-static void lm90_remove_files(struct i2c_client *client, struct lm90_data *data)
-{
-        struct device *dev = &client->dev;
-        if (data->flags & LM90_HAVE_TEMP3)
-                sysfs_remove_group(&dev->kobj, &lm90_temp3_group);
-        if (data->flags & LM90_HAVE_EMERGENCY_ALARM)
-                sysfs_remove_group(&dev->kobj, &lm90_emergency_alarm_group);
-        if (data->flags & LM90_HAVE_EMERGENCY)
-                sysfs_remove_group(&dev->kobj, &lm90_emergency_group);
-        if (data->flags & LM90_HAVE_OFFSET)
-                device_remove_file(dev, &sensor_dev_attr_temp2_offset.dev_attr);
-        device_remove_file(dev, &dev_attr_pec);
-        sysfs_remove_group(&dev->kobj, &lm90_group);
-}
 static void lm90_restore_conf(struct i2c_client *client, struct lm90_data *data)
 {
        /* Restore initial configuration */
@@ -1418,10 +1413,9 @@ static void lm90_restore_conf(struct i2c_client *client, struct lm90_data *data)
                                  data->config_orig);
 }
-static void lm90_init_client(struct i2c_client *client)
+static void lm90_init_client(struct i2c_client *client, struct lm90_data *data)
 {
        u8 config, convrate;
-        struct lm90_data *data = i2c_get_clientdata(client);
        if (lm90_read_reg(client, LM90_REG_R_CONVRATE, &convrate) < 0) {
                dev_warn(&client->dev, "Failed to read convrate register!\n");
@@ -1519,6 +1513,7 @@ static int lm90_probe(struct i2c_client *client,
        struct i2c_adapter *adapter = to_i2c_adapter(dev->parent);
        struct lm90_data *data;
        struct regulator *regulator;
+        int groups = 0;
        int err;
        regulator = devm_regulator_get(dev, "vcc");
@@ -1527,15 +1522,15 @@ static int lm90_probe(struct i2c_client *client,
        err = regulator_enable(regulator);
        if (err < 0) {
-                dev_err(&client->dev,
+                dev_err(dev, "Failed to enable regulator: %d\n", err);
-                        "Failed to enable regulator: %d\n", err);
                return err;
        }
-        data = devm_kzalloc(&client->dev, sizeof(struct lm90_data), GFP_KERNEL);
+        data = devm_kzalloc(dev, sizeof(struct lm90_data), GFP_KERNEL);
        if (!data)
                return -ENOMEM;
+        data->client = client;
        i2c_set_clientdata(client, data);
        mutex_init(&data->update_lock);
@@ -1562,44 +1557,34 @@ static int lm90_probe(struct i2c_client *client,
        data->max_convrate = lm90_params[data->kind].max_convrate;
        /* Initialize the LM90 chip */
-        lm90_init_client(client);
+        lm90_init_client(client, data);
        /* Register sysfs hooks */
-        err = sysfs_create_group(&dev->kobj, &lm90_group);
+        data->groups[groups++] = &lm90_group;
-        if (err)
-                goto exit_restore;
+        if (data->flags & LM90_HAVE_OFFSET)
+                data->groups[groups++] = &lm90_temp2_offset_group;
+        if (data->flags & LM90_HAVE_EMERGENCY)
+                data->groups[groups++] = &lm90_emergency_group;
+        if (data->flags & LM90_HAVE_EMERGENCY_ALARM)
+                data->groups[groups++] = &lm90_emergency_alarm_group;
+        if (data->flags & LM90_HAVE_TEMP3)
+                data->groups[groups++] = &lm90_temp3_group;
        if (client->flags & I2C_CLIENT_PEC) {
                err = device_create_file(dev, &dev_attr_pec);
                if (err)
-                        goto exit_remove_files;
+                        goto exit_restore;
-        }
-        if (data->flags & LM90_HAVE_OFFSET) {
-                err = device_create_file(dev,
-                                        &sensor_dev_attr_temp2_offset.dev_attr);
-                if (err)
-                        goto exit_remove_files;
-        }
-        if (data->flags & LM90_HAVE_EMERGENCY) {
-                err = sysfs_create_group(&dev->kobj, &lm90_emergency_group);
-                if (err)
-                        goto exit_remove_files;
-        }
-        if (data->flags & LM90_HAVE_EMERGENCY_ALARM) {
-                err = sysfs_create_group(&dev->kobj,
-                                         &lm90_emergency_alarm_group);
-                if (err)
-                        goto exit_remove_files;
-        }
-        if (data->flags & LM90_HAVE_TEMP3) {
-                err = sysfs_create_group(&dev->kobj, &lm90_temp3_group);
-                if (err)
-                        goto exit_remove_files;
        }
-        data->hwmon_dev = hwmon_device_register(dev);
+        data->hwmon_dev = hwmon_device_register_with_groups(dev, client->name,
+                                                            data, data->groups);
        if (IS_ERR(data->hwmon_dev)) {
                err = PTR_ERR(data->hwmon_dev);
-                goto exit_remove_files;
+                goto exit_remove_pec;
        }
        if (client->irq) {
@@ -1618,8 +1603,8 @@ static int lm90_probe(struct i2c_client *client,
 exit_unregister:
        hwmon_device_unregister(data->hwmon_dev);
-exit_remove_files:
+exit_remove_pec:
-        lm90_remove_files(client, data);
+        device_remove_file(dev, &dev_attr_pec);
 exit_restore:
        lm90_restore_conf(client, data);
        regulator_disable(data->regulator);
@@ -1632,7 +1617,7 @@ static int lm90_remove(struct i2c_client *client)
        struct lm90_data *data = i2c_get_clientdata(client);
        hwmon_device_unregister(data->hwmon_dev);
-        lm90_remove_files(client, data);
+        device_remove_file(&client->dev, &dev_attr_pec);
        lm90_restore_conf(client, data);
        regulator_disable(data->regulator);
diff --git a/drivers/hwmon/lm92.c b/drivers/hwmon/lm92.c
index 9d0e87a4f0cb..b9022db6511a 100644
--- a/drivers/hwmon/lm92.c
+++ b/drivers/hwmon/lm92.c
@@ -380,7 +380,6 @@ static int lm92_probe(struct i2c_client *new_client,
                return -ENOMEM;
        i2c_set_clientdata(new_client, data);
-        data->valid = 0;
        mutex_init(&data->update_lock);
        /* Initialize the chipset */
diff --git a/drivers/hwmon/lm93.c b/drivers/hwmon/lm93.c
index 6f1c6c0dbaf5..adf23165a6a7 100644
--- a/drivers/hwmon/lm93.c
+++ b/drivers/hwmon/lm93.c
@@ -2754,7 +2754,6 @@ static int lm93_probe(struct i2c_client *client,
        i2c_set_clientdata(client, data);
        /* housekeeping */
-        data->valid = 0;
        data->update = update;
        mutex_init(&data->update_lock);
diff --git a/drivers/hwmon/lm95241.c b/drivers/hwmon/lm95241.c
index 4b68fb2a31d7..cdf19adaec79 100644
--- a/drivers/hwmon/lm95241.c
+++ b/drivers/hwmon/lm95241.c
@@ -89,7 +89,7 @@ static const u8 lm95241_reg_address[] = {
 /* Client data (each client gets its own) */
 struct lm95241_data {
-        struct device *hwmon_dev;
+        struct i2c_client *client;
        struct mutex update_lock;
        unsigned long last_updated, interval;   /* in jiffies */
        char valid;             /* zero until following fields are valid */
@@ -113,8 +113,8 @@ static int temp_from_reg_unsigned(u8 val_h, u8 val_l)
 static struct lm95241_data *lm95241_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95241_data *data = dev_get_drvdata(dev);
-        struct lm95241_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        mutex_lock(&data->update_lock);
@@ -122,7 +122,7 @@ static struct lm95241_data *lm95241_update_device(struct device *dev)
            !data->valid) {
                int i;
-                dev_dbg(&client->dev, "Updating lm95241 data.\n");
+                dev_dbg(dev, "Updating lm95241 data.\n");
                for (i = 0; i < ARRAY_SIZE(lm95241_reg_address); i++)
                        data->temp[i]
                          = i2c_smbus_read_byte_data(client,
@@ -153,8 +153,7 @@ static ssize_t show_input(struct device *dev, struct device_attribute *attr,
 static ssize_t show_type(struct device *dev, struct device_attribute *attr,
                         char *buf)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95241_data *data = dev_get_drvdata(dev);
-        struct lm95241_data *data = i2c_get_clientdata(client);
        return snprintf(buf, PAGE_SIZE - 1,
                data->model & to_sensor_dev_attr(attr)->index ? "1\n" : "2\n");
@@ -163,8 +162,8 @@ static ssize_t show_type(struct device *dev, struct device_attribute *attr,
 static ssize_t set_type(struct device *dev, struct device_attribute *attr,
                        const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95241_data *data = dev_get_drvdata(dev);
-        struct lm95241_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        unsigned long val;
        int shift;
        u8 mask = to_sensor_dev_attr(attr)->index;
@@ -201,8 +200,7 @@ static ssize_t set_type(struct device *dev, struct device_attribute *attr,
 static ssize_t show_min(struct device *dev, struct device_attribute *attr,
                        char *buf)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95241_data *data = dev_get_drvdata(dev);
-        struct lm95241_data *data = i2c_get_clientdata(client);
        return snprintf(buf, PAGE_SIZE - 1,
                        data->config & to_sensor_dev_attr(attr)->index ?
@@ -212,8 +210,7 @@ static ssize_t show_min(struct device *dev, struct device_attribute *attr,
 static ssize_t set_min(struct device *dev, struct device_attribute *attr,
                       const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95241_data *data = dev_get_drvdata(dev);
-        struct lm95241_data *data = i2c_get_clientdata(client);
        long val;
        if (kstrtol(buf, 10, &val) < 0)
@@ -229,7 +226,8 @@ static ssize_t set_min(struct device *dev, struct device_attribute *attr,
                data->config &= ~to_sensor_dev_attr(attr)->index;
        data->valid = 0;
-        i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config);
+        i2c_smbus_write_byte_data(data->client, LM95241_REG_RW_CONFIG,
+                                  data->config);
        mutex_unlock(&data->update_lock);
@@ -239,8 +237,7 @@ static ssize_t set_min(struct device *dev, struct device_attribute *attr,
 static ssize_t show_max(struct device *dev, struct device_attribute *attr,
                        char *buf)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95241_data *data = dev_get_drvdata(dev);
-        struct lm95241_data *data = i2c_get_clientdata(client);
        return snprintf(buf, PAGE_SIZE - 1,
                        data->config & to_sensor_dev_attr(attr)->index ?
@@ -250,8 +247,7 @@ static ssize_t show_max(struct device *dev, struct device_attribute *attr,
 static ssize_t set_max(struct device *dev, struct device_attribute *attr,
                       const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95241_data *data = dev_get_drvdata(dev);
-        struct lm95241_data *data = i2c_get_clientdata(client);
        long val;
        if (kstrtol(buf, 10, &val) < 0)
@@ -267,7 +263,8 @@ static ssize_t set_max(struct device *dev, struct device_attribute *attr,
                data->config &= ~to_sensor_dev_attr(attr)->index;
        data->valid = 0;
-        i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config);
+        i2c_smbus_write_byte_data(data->client, LM95241_REG_RW_CONFIG,
+                                  data->config);
        mutex_unlock(&data->update_lock);
@@ -286,8 +283,7 @@ static ssize_t show_interval(struct device *dev, struct device_attribute *attr,
 static ssize_t set_interval(struct device *dev, struct device_attribute *attr,
                            const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95241_data *data = dev_get_drvdata(dev);
-        struct lm95241_data *data = i2c_get_clientdata(client);
        unsigned long val;
        if (kstrtoul(buf, 10, &val) < 0)
@@ -316,7 +312,7 @@ static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_max, set_max,
 static DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO, show_interval,
                   set_interval);
-static struct attribute *lm95241_attributes[] = {
+static struct attribute *lm95241_attrs[] = {
        &sensor_dev_attr_temp1_input.dev_attr.attr,
        &sensor_dev_attr_temp2_input.dev_attr.attr,
        &sensor_dev_attr_temp3_input.dev_attr.attr,
@@ -329,10 +325,7 @@ static struct attribute *lm95241_attributes[] = {
        &dev_attr_update_interval.attr,
        NULL
 };
+ATTRIBUTE_GROUPS(lm95241);
-static const struct attribute_group lm95241_group = {
-        .attrs = lm95241_attributes,
-};
 /* Return 0 if detection is successful, -ENODEV otherwise */
 static int lm95241_detect(struct i2c_client *new_client,
@@ -366,14 +359,11 @@ static int lm95241_detect(struct i2c_client *new_client,
        return 0;
 }
-static void lm95241_init_client(struct i2c_client *client)
+static void lm95241_init_client(struct i2c_client *client,
+                                struct lm95241_data *data)
 {
-        struct lm95241_data *data = i2c_get_clientdata(client);
        data->interval = HZ;    /* 1 sec default */
-        data->valid = 0;
        data->config = CFG_CR0076;
-        data->model = 0;
        data->trutherm = (TT_OFF << TT1_SHIFT) | (TT_OFF << TT2_SHIFT);
        i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config);
@@ -385,49 +375,27 @@ static void lm95241_init_client(struct i2c_client *client)
                                  data->model);
 }
-static int lm95241_probe(struct i2c_client *new_client,
+static int lm95241_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
+        struct device *dev = &client->dev;
        struct lm95241_data *data;
-        int err;
+        struct device *hwmon_dev;
-        data = devm_kzalloc(&new_client->dev, sizeof(struct lm95241_data),
+        data = devm_kzalloc(dev, sizeof(struct lm95241_data), GFP_KERNEL);
-                            GFP_KERNEL);
        if (!data)
                return -ENOMEM;
-        i2c_set_clientdata(new_client, data);
+        data->client = client;
        mutex_init(&data->update_lock);
        /* Initialize the LM95241 chip */
-        lm95241_init_client(new_client);
+        lm95241_init_client(client, data);
-        /* Register sysfs hooks */
+        hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
-        err = sysfs_create_group(&new_client->dev.kobj, &lm95241_group);
+                                                           data,
-        if (err)
+                                                           lm95241_groups);
-                return err;
+        return PTR_ERR_OR_ZERO(hwmon_dev);
-        data->hwmon_dev = hwmon_device_register(&new_client->dev);
-        if (IS_ERR(data->hwmon_dev)) {
-                err = PTR_ERR(data->hwmon_dev);
-                goto exit_remove_files;
-        }
-        return 0;
-exit_remove_files:
-        sysfs_remove_group(&new_client->dev.kobj, &lm95241_group);
-        return err;
-}
-static int lm95241_remove(struct i2c_client *client)
-{
-        struct lm95241_data *data = i2c_get_clientdata(client);
-        hwmon_device_unregister(data->hwmon_dev);
-        sysfs_remove_group(&client->dev.kobj, &lm95241_group);
-        return 0;
 }
 /* Driver data (common to all clients) */
@@ -444,7 +412,6 @@ static struct i2c_driver lm95241_driver = {
                .name   = DEVNAME,
        },
        .probe          = lm95241_probe,
-        .remove         = lm95241_remove,
        .id_table       = lm95241_id,
        .detect         = lm95241_detect,
        .address_list   = normal_i2c,
diff --git a/drivers/hwmon/lm95245.c b/drivers/hwmon/lm95245.c
index a6c85f0ff8f3..0ae0dfdafdff 100644
--- a/drivers/hwmon/lm95245.c
+++ b/drivers/hwmon/lm95245.c
@@ -115,7 +115,7 @@ static const u8 lm95245_reg_address[] = {
 /* Client data (each client gets its own) */
 struct lm95245_data {
-        struct device *hwmon_dev;
+        struct i2c_client *client;
        struct mutex update_lock;
        unsigned long last_updated;     /* in jiffies */
        unsigned long interval; /* in msecs */
@@ -140,8 +140,8 @@ static int temp_from_reg_signed(u8 val_h, u8 val_l)
 static struct lm95245_data *lm95245_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95245_data *data = dev_get_drvdata(dev);
-        struct lm95245_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        mutex_lock(&data->update_lock);
@@ -149,7 +149,6 @@ static struct lm95245_data *lm95245_update_device(struct device *dev)
                + msecs_to_jiffies(data->interval)) || !data->valid) {
                int i;
-                dev_dbg(&client->dev, "Updating lm95245 data.\n");
                for (i = 0; i < ARRAY_SIZE(lm95245_reg_address); i++)
                        data->regs[i]
                          = i2c_smbus_read_byte_data(client,
@@ -249,9 +248,9 @@ static ssize_t show_limit(struct device *dev, struct device_attribute *attr,
 static ssize_t set_limit(struct device *dev, struct device_attribute *attr,
                        const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95245_data *data = dev_get_drvdata(dev);
-        struct lm95245_data *data = i2c_get_clientdata(client);
        int index = to_sensor_dev_attr(attr)->index;
+        struct i2c_client *client = data->client;
        unsigned long val;
        if (kstrtoul(buf, 10, &val) < 0)
@@ -272,27 +271,38 @@ static ssize_t set_limit(struct device *dev, struct device_attribute *attr,
        return count;
 }
+static ssize_t show_crit_hyst(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        struct lm95245_data *data = lm95245_update_device(dev);
+        int index = to_sensor_dev_attr(attr)->index;
+        int hyst = data->regs[index] - data->regs[8];
+        return snprintf(buf, PAGE_SIZE - 1, "%d\n", hyst * 1000);
+}
 static ssize_t set_crit_hyst(struct device *dev, struct device_attribute *attr,
                        const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95245_data *data = dev_get_drvdata(dev);
-        struct lm95245_data *data = i2c_get_clientdata(client);
+        int index = to_sensor_dev_attr(attr)->index;
+        struct i2c_client *client = data->client;
        unsigned long val;
+        int hyst, limit;
        if (kstrtoul(buf, 10, &val) < 0)
                return -EINVAL;
-        val /= 1000;
-        val = clamp_val(val, 0, 31);
        mutex_lock(&data->update_lock);
-        data->valid = 0;
+        limit = i2c_smbus_read_byte_data(client, lm95245_reg_address[index]);
+        hyst = limit - val / 1000;
+        hyst = clamp_val(hyst, 0, 31);
+        data->regs[8] = hyst;
        /* shared crit hysteresis */
        i2c_smbus_write_byte_data(client, LM95245_REG_RW_COMMON_HYSTERESIS,
-                val);
+                hyst);
        mutex_unlock(&data->update_lock);
@@ -302,8 +312,7 @@ static ssize_t set_crit_hyst(struct device *dev, struct device_attribute *attr,
 static ssize_t show_type(struct device *dev, struct device_attribute *attr,
                         char *buf)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95245_data *data = dev_get_drvdata(dev);
-        struct lm95245_data *data = i2c_get_clientdata(client);
        return snprintf(buf, PAGE_SIZE - 1,
                data->config2 & CFG2_REMOTE_TT ? "1\n" : "2\n");
@@ -312,8 +321,8 @@ static ssize_t show_type(struct device *dev, struct device_attribute *attr,
 static ssize_t set_type(struct device *dev, struct device_attribute *attr,
                        const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95245_data *data = dev_get_drvdata(dev);
-        struct lm95245_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        unsigned long val;
        if (kstrtoul(buf, 10, &val) < 0)
@@ -359,8 +368,8 @@ static ssize_t show_interval(struct device *dev, struct device_attribute *attr,
 static ssize_t set_interval(struct device *dev, struct device_attribute *attr,
                            const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95245_data *data = dev_get_drvdata(dev);
-        struct lm95245_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        unsigned long val;
        if (kstrtoul(buf, 10, &val) < 0)
@@ -378,16 +387,15 @@ static ssize_t set_interval(struct device *dev, struct device_attribute *attr,
 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_input, NULL, 0);
 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_limit,
                set_limit, 6);
-static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_limit,
+static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_crit_hyst,
-                set_crit_hyst, 8);
+                set_crit_hyst, 6);
 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL,
                STATUS1_LOC);
 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_input, NULL, 2);
 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_limit,
                set_limit, 7);
-static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IWUSR | S_IRUGO, show_limit,
+static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_crit_hyst, NULL, 7);
-                set_crit_hyst, 8);
 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL,
                STATUS1_RTCRIT);
 static SENSOR_DEVICE_ATTR(temp2_type, S_IWUSR | S_IRUGO, show_type,
@@ -398,7 +406,7 @@ static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL,
 static DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO, show_interval,
                set_interval);
-static struct attribute *lm95245_attributes[] = {
+static struct attribute *lm95245_attrs[] = {
        &sensor_dev_attr_temp1_input.dev_attr.attr,
        &sensor_dev_attr_temp1_crit.dev_attr.attr,
        &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
@@ -412,10 +420,7 @@ static struct attribute *lm95245_attributes[] = {
        &dev_attr_update_interval.attr,
        NULL
 };
+ATTRIBUTE_GROUPS(lm95245);
-static const struct attribute_group lm95245_group = {
-        .attrs = lm95245_attributes,
-};
 /* Return 0 if detection is successful, -ENODEV otherwise */
 static int lm95245_detect(struct i2c_client *new_client,
@@ -436,11 +441,9 @@ static int lm95245_detect(struct i2c_client *new_client,
        return 0;
 }
-static void lm95245_init_client(struct i2c_client *client)
+static void lm95245_init_client(struct i2c_client *client,
+                                struct lm95245_data *data)
 {
-        struct lm95245_data *data = i2c_get_clientdata(client);
-        data->valid = 0;
        data->interval = lm95245_read_conversion_rate(client);
        data->config1 = i2c_smbus_read_byte_data(client,
@@ -456,49 +459,27 @@ static void lm95245_init_client(struct i2c_client *client)
        }
 }
-static int lm95245_probe(struct i2c_client *new_client,
+static int lm95245_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
+        struct device *dev = &client->dev;
        struct lm95245_data *data;
-        int err;
+        struct device *hwmon_dev;
-        data = devm_kzalloc(&new_client->dev, sizeof(struct lm95245_data),
+        data = devm_kzalloc(dev, sizeof(struct lm95245_data), GFP_KERNEL);
-                            GFP_KERNEL);
        if (!data)
                return -ENOMEM;
-        i2c_set_clientdata(new_client, data);
+        data->client = client;
        mutex_init(&data->update_lock);
        /* Initialize the LM95245 chip */
-        lm95245_init_client(new_client);
+        lm95245_init_client(client, data);
-        /* Register sysfs hooks */
-        err = sysfs_create_group(&new_client->dev.kobj, &lm95245_group);
-        if (err)
-                return err;
-        data->hwmon_dev = hwmon_device_register(&new_client->dev);
-        if (IS_ERR(data->hwmon_dev)) {
-                err = PTR_ERR(data->hwmon_dev);
-                goto exit_remove_files;
-        }
-        return 0;
-exit_remove_files:
-        sysfs_remove_group(&new_client->dev.kobj, &lm95245_group);
-        return err;
-}
-static int lm95245_remove(struct i2c_client *client)
+        hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
-{
+                                                           data,
-        struct lm95245_data *data = i2c_get_clientdata(client);
+                                                           lm95245_groups);
+        return PTR_ERR_OR_ZERO(hwmon_dev);
-        hwmon_device_unregister(data->hwmon_dev);
-        sysfs_remove_group(&client->dev.kobj, &lm95245_group);
-        return 0;
 }
 /* Driver data (common to all clients) */
@@ -514,7 +495,6 @@ static struct i2c_driver lm95245_driver = {
                .name   = DEVNAME,
        },
        .probe          = lm95245_probe,
-        .remove         = lm95245_remove,
        .id_table       = lm95245_id,
        .detect         = lm95245_detect,
        .address_list   = normal_i2c,
diff --git a/drivers/hwmon/ltc2945.c b/drivers/hwmon/ltc2945.c
new file mode 100644
index 000000000000..c104cc32989d
--- /dev/null
+++ b/drivers/hwmon/ltc2945.c
@@ -0,0 +1,519 @@
+/*
+ * Driver for Linear Technology LTC2945 I2C Power Monitor
+ *
+ * Copyright (c) 2014 Guenter Roeck
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/jiffies.h>
+#include <linux/regmap.h>
+/* chip registers */
+#define LTC2945_CONTROL                 0x00
+#define LTC2945_ALERT                   0x01
+#define LTC2945_STATUS                  0x02
+#define LTC2945_FAULT                   0x03
+#define LTC2945_POWER_H                 0x05
+#define LTC2945_MAX_POWER_H             0x08
+#define LTC2945_MIN_POWER_H             0x0b
+#define LTC2945_MAX_POWER_THRES_H       0x0e
+#define LTC2945_MIN_POWER_THRES_H       0x11
+#define LTC2945_SENSE_H                 0x14
+#define LTC2945_MAX_SENSE_H             0x16
+#define LTC2945_MIN_SENSE_H             0x18
+#define LTC2945_MAX_SENSE_THRES_H       0x1a
+#define LTC2945_MIN_SENSE_THRES_H       0x1c
+#define LTC2945_VIN_H                   0x1e
+#define LTC2945_MAX_VIN_H               0x20
+#define LTC2945_MIN_VIN_H               0x22
+#define LTC2945_MAX_VIN_THRES_H         0x24
+#define LTC2945_MIN_VIN_THRES_H         0x26
+#define LTC2945_ADIN_H                  0x28
+#define LTC2945_MAX_ADIN_H              0x2a
+#define LTC2945_MIN_ADIN_H              0x2c
+#define LTC2945_MAX_ADIN_THRES_H        0x2e
+#define LTC2945_MIN_ADIN_THRES_H        0x30
+#define LTC2945_MIN_ADIN_THRES_L        0x31
+/* Fault register bits */
+#define FAULT_ADIN_UV           (1 << 0)
+#define FAULT_ADIN_OV           (1 << 1)
+#define FAULT_VIN_UV            (1 << 2)
+#define FAULT_VIN_OV            (1 << 3)
+#define FAULT_SENSE_UV          (1 << 4)
+#define FAULT_SENSE_OV          (1 << 5)
+#define FAULT_POWER_UV          (1 << 6)
+#define FAULT_POWER_OV          (1 << 7)
+/* Control register bits */
+#define CONTROL_MULT_SELECT     (1 << 0)
+#define CONTROL_TEST_MODE       (1 << 4)
+static inline bool is_power_reg(u8 reg)
+{
+        return reg < LTC2945_SENSE_H;
+}
+/* Return the value from the given register in uW, mV, or mA */
+static long long ltc2945_reg_to_val(struct device *dev, u8 reg)
+{
+        struct regmap *regmap = dev_get_drvdata(dev);
+        unsigned int control;
+        u8 buf[3];
+        long long val;
+        int ret;
+        ret = regmap_bulk_read(regmap, reg, buf,
+                               is_power_reg(reg) ? 3 : 2);
+        if (ret < 0)
+                return ret;
+        if (is_power_reg(reg)) {
+                /* power */
+                val = (buf[0] << 16) + (buf[1] << 8) + buf[2];
+        } else {
+                /* current, voltage */
+                val = (buf[0] << 4) + (buf[1] >> 4);
+        }
+        switch (reg) {
+        case LTC2945_POWER_H:
+        case LTC2945_MAX_POWER_H:
+        case LTC2945_MIN_POWER_H:
+        case LTC2945_MAX_POWER_THRES_H:
+        case LTC2945_MIN_POWER_THRES_H:
+                /*
+                 * Convert to uW by assuming current is measured with
+                 * an 1mOhm sense resistor, similar to current
+                 * measurements.
+                 * Control register bit 0 selects if voltage at SENSE+/VDD
+                 * or voltage at ADIN is used to measure power.
+                 */
+                ret = regmap_read(regmap, LTC2945_CONTROL, &control);
+                if (ret < 0)
+                        return ret;
+                if (control & CONTROL_MULT_SELECT) {
+                        /* 25 mV * 25 uV = 0.625 uV resolution. */
+                        val *= 625LL;
+                } else {
+                        /* 0.5 mV * 25 uV = 0.0125 uV resolution. */
+                        val = (val * 25LL) >> 1;
+                }
+                break;
+        case LTC2945_VIN_H:
+        case LTC2945_MAX_VIN_H:
+        case LTC2945_MIN_VIN_H:
+        case LTC2945_MAX_VIN_THRES_H:
+        case LTC2945_MIN_VIN_THRES_H:
+                /* 25 mV resolution. Convert to mV. */
+                val *= 25;
+                break;
+        case LTC2945_ADIN_H:
+        case LTC2945_MAX_ADIN_H:
+        case LTC2945_MIN_ADIN_THRES_H:
+        case LTC2945_MAX_ADIN_THRES_H:
+        case LTC2945_MIN_ADIN_H:
+                /* 0.5mV resolution. Convert to mV. */
+                val = val >> 1;
+                break;
+        case LTC2945_SENSE_H:
+        case LTC2945_MAX_SENSE_H:
+        case LTC2945_MIN_SENSE_H:
+        case LTC2945_MAX_SENSE_THRES_H:
+        case LTC2945_MIN_SENSE_THRES_H:
+                /*
+                 * 25 uV resolution. Convert to current as measured with
+                 * an 1 mOhm sense resistor, in mA. If a different sense
+                 * resistor is installed, calculate the actual current by
+                 * dividing the reported current by the sense resistor value
+                 * in mOhm.
+                 */
+                val *= 25;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return val;
+}
+static int ltc2945_val_to_reg(struct device *dev, u8 reg,
+                              unsigned long val)
+{
+        struct regmap *regmap = dev_get_drvdata(dev);
+        unsigned int control;
+        int ret;
+        switch (reg) {
+        case LTC2945_POWER_H:
+        case LTC2945_MAX_POWER_H:
+        case LTC2945_MIN_POWER_H:
+        case LTC2945_MAX_POWER_THRES_H:
+        case LTC2945_MIN_POWER_THRES_H:
+                /*
+                 * Convert to register value by assuming current is measured
+                 * with an 1mOhm sense resistor, similar to current
+                 * measurements.
+                 * Control register bit 0 selects if voltage at SENSE+/VDD
+                 * or voltage at ADIN is used to measure power, which in turn
+                 * determines register calculations.
+                 */
+                ret = regmap_read(regmap, LTC2945_CONTROL, &control);
+                if (ret < 0)
+                        return ret;
+                if (control & CONTROL_MULT_SELECT) {
+                        /* 25 mV * 25 uV = 0.625 uV resolution. */
+                        val = DIV_ROUND_CLOSEST(val, 625);
+                } else {
+                        /*
+                         * 0.5 mV * 25 uV = 0.0125 uV resolution.
+                         * Divide first to avoid overflow;
+                         * accept loss of accuracy.
+                         */
+                        val = DIV_ROUND_CLOSEST(val, 25) * 2;
+                }
+                break;
+        case LTC2945_VIN_H:
+        case LTC2945_MAX_VIN_H:
+        case LTC2945_MIN_VIN_H:
+        case LTC2945_MAX_VIN_THRES_H:
+        case LTC2945_MIN_VIN_THRES_H:
+                /* 25 mV resolution. */
+                val /= 25;
+                break;
+        case LTC2945_ADIN_H:
+        case LTC2945_MAX_ADIN_H:
+        case LTC2945_MIN_ADIN_THRES_H:
+        case LTC2945_MAX_ADIN_THRES_H:
+        case LTC2945_MIN_ADIN_H:
+                /* 0.5mV resolution. */
+                val *= 2;
+                break;
+        case LTC2945_SENSE_H:
+        case LTC2945_MAX_SENSE_H:
+        case LTC2945_MIN_SENSE_H:
+        case LTC2945_MAX_SENSE_THRES_H:
+        case LTC2945_MIN_SENSE_THRES_H:
+                /*
+                 * 25 uV resolution. Convert to current as measured with
+                 * an 1 mOhm sense resistor, in mA. If a different sense
+                 * resistor is installed, calculate the actual current by
+                 * dividing the reported current by the sense resistor value
+                 * in mOhm.
+                 */
+                val = DIV_ROUND_CLOSEST(val, 25);
+                break;
+        default:
+                return -EINVAL;
+        }
+        return val;
+}
+static ssize_t ltc2945_show_value(struct device *dev,
+                                  struct device_attribute *da, char *buf)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        long long value;
+        value = ltc2945_reg_to_val(dev, attr->index);
+        if (value < 0)
+                return value;
+        return snprintf(buf, PAGE_SIZE, "%lld\n", value);
+}
+static ssize_t ltc2945_set_value(struct device *dev,
+                                     struct device_attribute *da,
+                                     const char *buf, size_t count)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        struct regmap *regmap = dev_get_drvdata(dev);
+        u8 reg = attr->index;
+        unsigned long val;
+        u8 regbuf[3];
+        int num_regs;
+        int regval;
+        int ret;
+        ret = kstrtoul(buf, 10, &val);
+        if (ret)
+                return ret;
+        /* convert to register value, then clamp and write result */
+        regval = ltc2945_val_to_reg(dev, reg, val);
+        if (is_power_reg(reg)) {
+                regval = clamp_val(regval, 0, 0xffffff);
+                regbuf[0] = regval >> 16;
+                regbuf[1] = (regval >> 8) & 0xff;
+                regbuf[2] = regval;
+                num_regs = 3;
+        } else {
+                regval = clamp_val(regval, 0, 0xfff) << 4;
+                regbuf[0] = regval >> 8;
+                regbuf[1] = regval & 0xff;
+                num_regs = 2;
+        }
+        ret = regmap_bulk_write(regmap, reg, regbuf, num_regs);
+        return ret < 0 ? ret : count;
+}
+static ssize_t ltc2945_reset_history(struct device *dev,
+                                     struct device_attribute *da,
+                                     const char *buf, size_t count)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        struct regmap *regmap = dev_get_drvdata(dev);
+        u8 reg = attr->index;
+        int num_regs = is_power_reg(reg) ? 3 : 2;
+        u8 buf_min[3] = { 0xff, 0xff, 0xff };
+        u8 buf_max[3] = { 0, 0, 0 };
+        unsigned long val;
+        int ret;
+        ret = kstrtoul(buf, 10, &val);
+        if (ret)
+                return ret;
+        if (val != 1)
+                return -EINVAL;
+        ret = regmap_update_bits(regmap, LTC2945_CONTROL, CONTROL_TEST_MODE,
+                                 CONTROL_TEST_MODE);
+        /* Reset minimum */
+        ret = regmap_bulk_write(regmap, reg, buf_min, num_regs);
+        if (ret)
+                return ret;
+        switch (reg) {
+        case LTC2945_MIN_POWER_H:
+                reg = LTC2945_MAX_POWER_H;
+                break;
+        case LTC2945_MIN_SENSE_H:
+                reg = LTC2945_MAX_SENSE_H;
+                break;
+        case LTC2945_MIN_VIN_H:
+                reg = LTC2945_MAX_VIN_H;
+                break;
+        case LTC2945_MIN_ADIN_H:
+                reg = LTC2945_MAX_ADIN_H;
+                break;
+        default:
+                BUG();
+                break;
+        }
+        /* Reset maximum */
+        ret = regmap_bulk_write(regmap, reg, buf_max, num_regs);
+        /* Try resetting test mode even if there was an error */
+        regmap_update_bits(regmap, LTC2945_CONTROL, CONTROL_TEST_MODE, 0);
+        return ret ? : count;
+}
+static ssize_t ltc2945_show_bool(struct device *dev,
+                                 struct device_attribute *da, char *buf)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        struct regmap *regmap = dev_get_drvdata(dev);
+        unsigned int fault;
+        int ret;
+        ret = regmap_read(regmap, LTC2945_FAULT, &fault);
+        if (ret < 0)
+                return ret;
+        fault &= attr->index;
+        if (fault)              /* Clear reported faults in chip register */
+                regmap_update_bits(regmap, LTC2945_FAULT, attr->index, 0);
+        return snprintf(buf, PAGE_SIZE, "%d\n", !!fault);
+}
+/* Input voltages */
+static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ltc2945_show_value, NULL,
+                          LTC2945_VIN_H);
+static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO | S_IWUSR, ltc2945_show_value,
+                          ltc2945_set_value, LTC2945_MIN_VIN_THRES_H);
+static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO | S_IWUSR, ltc2945_show_value,
+                          ltc2945_set_value, LTC2945_MAX_VIN_THRES_H);
+static SENSOR_DEVICE_ATTR(in1_lowest, S_IRUGO, ltc2945_show_value, NULL,
+                          LTC2945_MIN_VIN_H);
+static SENSOR_DEVICE_ATTR(in1_highest, S_IRUGO, ltc2945_show_value, NULL,
+                          LTC2945_MAX_VIN_H);
+static SENSOR_DEVICE_ATTR(in1_reset_history, S_IWUSR, NULL,
+                          ltc2945_reset_history, LTC2945_MIN_VIN_H);
+static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, ltc2945_show_value, NULL,
+                          LTC2945_ADIN_H);
+static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO | S_IWUSR, ltc2945_show_value,
+                          ltc2945_set_value, LTC2945_MIN_ADIN_THRES_H);
+static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO | S_IWUSR, ltc2945_show_value,
+                          ltc2945_set_value, LTC2945_MAX_ADIN_THRES_H);
+static SENSOR_DEVICE_ATTR(in2_lowest, S_IRUGO, ltc2945_show_value, NULL,
+                          LTC2945_MIN_ADIN_H);
+static SENSOR_DEVICE_ATTR(in2_highest, S_IRUGO, ltc2945_show_value, NULL,
+                          LTC2945_MAX_ADIN_H);
+static SENSOR_DEVICE_ATTR(in2_reset_history, S_IWUSR, NULL,
+                          ltc2945_reset_history, LTC2945_MIN_ADIN_H);
+/* Voltage alarms */
+static SENSOR_DEVICE_ATTR(in1_min_alarm, S_IRUGO, ltc2945_show_bool, NULL,
+                          FAULT_VIN_UV);
+static SENSOR_DEVICE_ATTR(in1_max_alarm, S_IRUGO, ltc2945_show_bool, NULL,
+                          FAULT_VIN_OV);
+static SENSOR_DEVICE_ATTR(in2_min_alarm, S_IRUGO, ltc2945_show_bool, NULL,
+                          FAULT_ADIN_UV);
+static SENSOR_DEVICE_ATTR(in2_max_alarm, S_IRUGO, ltc2945_show_bool, NULL,
+                          FAULT_ADIN_OV);
+/* Currents (via sense resistor) */
+static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ltc2945_show_value, NULL,
+                          LTC2945_SENSE_H);
+static SENSOR_DEVICE_ATTR(curr1_min, S_IRUGO | S_IWUSR, ltc2945_show_value,
+                          ltc2945_set_value, LTC2945_MIN_SENSE_THRES_H);
+static SENSOR_DEVICE_ATTR(curr1_max, S_IRUGO | S_IWUSR, ltc2945_show_value,
+                          ltc2945_set_value, LTC2945_MAX_SENSE_THRES_H);
+static SENSOR_DEVICE_ATTR(curr1_lowest, S_IRUGO, ltc2945_show_value, NULL,
+                          LTC2945_MIN_SENSE_H);
+static SENSOR_DEVICE_ATTR(curr1_highest, S_IRUGO, ltc2945_show_value, NULL,
+                          LTC2945_MAX_SENSE_H);
+static SENSOR_DEVICE_ATTR(curr1_reset_history, S_IWUSR, NULL,
+                          ltc2945_reset_history, LTC2945_MIN_SENSE_H);
+/* Current alarms */
+static SENSOR_DEVICE_ATTR(curr1_min_alarm, S_IRUGO, ltc2945_show_bool, NULL,
+                          FAULT_SENSE_UV);
+static SENSOR_DEVICE_ATTR(curr1_max_alarm, S_IRUGO, ltc2945_show_bool, NULL,
+                          FAULT_SENSE_OV);
+/* Power */
+static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO, ltc2945_show_value, NULL,
+                          LTC2945_POWER_H);
+static SENSOR_DEVICE_ATTR(power1_min, S_IRUGO | S_IWUSR, ltc2945_show_value,
+                          ltc2945_set_value, LTC2945_MIN_POWER_THRES_H);
+static SENSOR_DEVICE_ATTR(power1_max, S_IRUGO | S_IWUSR, ltc2945_show_value,
+                          ltc2945_set_value, LTC2945_MAX_POWER_THRES_H);
+static SENSOR_DEVICE_ATTR(power1_input_lowest, S_IRUGO, ltc2945_show_value,
+                          NULL, LTC2945_MIN_POWER_H);
+static SENSOR_DEVICE_ATTR(power1_input_highest, S_IRUGO, ltc2945_show_value,
+                          NULL, LTC2945_MAX_POWER_H);
+static SENSOR_DEVICE_ATTR(power1_reset_history, S_IWUSR, NULL,
+                          ltc2945_reset_history, LTC2945_MIN_POWER_H);
+/* Power alarms */
+static SENSOR_DEVICE_ATTR(power1_min_alarm, S_IRUGO, ltc2945_show_bool, NULL,
+                          FAULT_POWER_UV);
+static SENSOR_DEVICE_ATTR(power1_max_alarm, S_IRUGO, ltc2945_show_bool, NULL,
+                          FAULT_POWER_OV);
+static struct attribute *ltc2945_attrs[] = {
+        &sensor_dev_attr_in1_input.dev_attr.attr,
+        &sensor_dev_attr_in1_min.dev_attr.attr,
+        &sensor_dev_attr_in1_max.dev_attr.attr,
+        &sensor_dev_attr_in1_lowest.dev_attr.attr,
+        &sensor_dev_attr_in1_highest.dev_attr.attr,
+        &sensor_dev_attr_in1_reset_history.dev_attr.attr,
+        &sensor_dev_attr_in1_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_in1_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_in2_input.dev_attr.attr,
+        &sensor_dev_attr_in2_min.dev_attr.attr,
+        &sensor_dev_attr_in2_max.dev_attr.attr,
+        &sensor_dev_attr_in2_lowest.dev_attr.attr,
+        &sensor_dev_attr_in2_highest.dev_attr.attr,
+        &sensor_dev_attr_in2_reset_history.dev_attr.attr,
+        &sensor_dev_attr_in2_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_in2_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_curr1_input.dev_attr.attr,
+        &sensor_dev_attr_curr1_min.dev_attr.attr,
+        &sensor_dev_attr_curr1_max.dev_attr.attr,
+        &sensor_dev_attr_curr1_lowest.dev_attr.attr,
+        &sensor_dev_attr_curr1_highest.dev_attr.attr,
+        &sensor_dev_attr_curr1_reset_history.dev_attr.attr,
+        &sensor_dev_attr_curr1_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_curr1_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_power1_input.dev_attr.attr,
+        &sensor_dev_attr_power1_min.dev_attr.attr,
+        &sensor_dev_attr_power1_max.dev_attr.attr,
+        &sensor_dev_attr_power1_input_lowest.dev_attr.attr,
+        &sensor_dev_attr_power1_input_highest.dev_attr.attr,
+        &sensor_dev_attr_power1_reset_history.dev_attr.attr,
+        &sensor_dev_attr_power1_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_power1_max_alarm.dev_attr.attr,
+        NULL,
+};
+ATTRIBUTE_GROUPS(ltc2945);
+static struct regmap_config ltc2945_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+        .max_register = LTC2945_MIN_ADIN_THRES_L,
+};
+static int ltc2945_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        struct device *dev = &client->dev;
+        struct device *hwmon_dev;
+        struct regmap *regmap;
+        regmap = devm_regmap_init_i2c(client, &ltc2945_regmap_config);
+        if (IS_ERR(regmap)) {
+                dev_err(dev, "failed to allocate register map\n");
+                return PTR_ERR(regmap);
+        }
+        /* Clear faults */
+        regmap_write(regmap, LTC2945_FAULT, 0x00);
+        hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
+                                                           regmap,
+                                                           ltc2945_groups);
+        return PTR_ERR_OR_ZERO(hwmon_dev);
+}
+static const struct i2c_device_id ltc2945_id[] = {
+        {"ltc2945", 0},
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, ltc2945_id);
+static struct i2c_driver ltc2945_driver = {
+        .driver = {
+                   .name = "ltc2945",
+                   },
+        .probe = ltc2945_probe,
+        .id_table = ltc2945_id,
+};
+module_i2c_driver(ltc2945_driver);
+MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
+MODULE_DESCRIPTION("LTC2945 driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/hwmon/ltc4215.c b/drivers/hwmon/ltc4215.c
index 8a142960d69e..c8a9bd9b050f 100644
--- a/drivers/hwmon/ltc4215.c
+++ b/drivers/hwmon/ltc4215.c
@@ -33,7 +33,7 @@ enum ltc4215_cmd {
 };
 struct ltc4215_data {
-        struct device *hwmon_dev;
+        struct i2c_client *client;
        struct mutex update_lock;
        bool valid;
@@ -45,8 +45,8 @@ struct ltc4215_data {
 static struct ltc4215_data *ltc4215_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct ltc4215_data *data = dev_get_drvdata(dev);
-        struct ltc4215_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        s32 val;
        int i;
@@ -214,7 +214,7 @@ static SENSOR_DEVICE_ATTR(in2_min_alarm, S_IRUGO, ltc4215_show_alarm, NULL,
 * Finally, construct an array of pointers to members of the above objects,
 * as required for sysfs_create_group()
 */
-static struct attribute *ltc4215_attributes[] = {
+static struct attribute *ltc4215_attrs[] = {
        &sensor_dev_attr_curr1_input.dev_attr.attr,
        &sensor_dev_attr_curr1_max_alarm.dev_attr.attr,
@@ -229,57 +229,33 @@ static struct attribute *ltc4215_attributes[] = {
        NULL,
 };
+ATTRIBUTE_GROUPS(ltc4215);
-static const struct attribute_group ltc4215_group = {
-        .attrs = ltc4215_attributes,
-};
 static int ltc4215_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
        struct i2c_adapter *adapter = client->adapter;
+        struct device *dev = &client->dev;
        struct ltc4215_data *data;
-        int ret;
+        struct device *hwmon_dev;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
+        data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
        if (!data)
                return -ENOMEM;
-        i2c_set_clientdata(client, data);
+        data->client = client;
        mutex_init(&data->update_lock);
        /* Initialize the LTC4215 chip */
        i2c_smbus_write_byte_data(client, LTC4215_FAULT, 0x00);
-        /* Register sysfs hooks */
+        hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
-        ret = sysfs_create_group(&client->dev.kobj, &ltc4215_group);
+                                                           data,
-        if (ret)
+                                                           ltc4215_groups);
-                return ret;
+        return PTR_ERR_OR_ZERO(hwmon_dev);
-        data->hwmon_dev = hwmon_device_register(&client->dev);
-        if (IS_ERR(data->hwmon_dev)) {
-                ret = PTR_ERR(data->hwmon_dev);
-                goto out_hwmon_device_register;
-        }
-        return 0;
-out_hwmon_device_register:
-        sysfs_remove_group(&client->dev.kobj, &ltc4215_group);
-        return ret;
-}
-static int ltc4215_remove(struct i2c_client *client)
-{
-        struct ltc4215_data *data = i2c_get_clientdata(client);
-        hwmon_device_unregister(data->hwmon_dev);
-        sysfs_remove_group(&client->dev.kobj, &ltc4215_group);
-        return 0;
 }
 static const struct i2c_device_id ltc4215_id[] = {
@@ -294,7 +270,6 @@ static struct i2c_driver ltc4215_driver = {
                .name   = "ltc4215",
        },
        .probe          = ltc4215_probe,
-        .remove         = ltc4215_remove,
        .id_table       = ltc4215_id,
 };
diff --git a/drivers/hwmon/ltc4222.c b/drivers/hwmon/ltc4222.c
new file mode 100644
index 000000000000..07c25653659f
--- /dev/null
+++ b/drivers/hwmon/ltc4222.c
@@ -0,0 +1,237 @@
+/*
+ * Driver for Linear Technology LTC4222 Dual Hot Swap controller
+ *
+ * Copyright (c) 2014 Guenter Roeck
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/bitops.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/jiffies.h>
+#include <linux/regmap.h>
+/* chip registers */
+#define LTC4222_CONTROL1        0xd0
+#define LTC4222_ALERT1          0xd1
+#define LTC4222_STATUS1         0xd2
+#define LTC4222_FAULT1          0xd3
+#define LTC4222_CONTROL2        0xd4
+#define LTC4222_ALERT2          0xd5
+#define LTC4222_STATUS2         0xd6
+#define LTC4222_FAULT2          0xd7
+#define LTC4222_SOURCE1         0xd8
+#define LTC4222_SOURCE2         0xda
+#define LTC4222_ADIN1           0xdc
+#define LTC4222_ADIN2           0xde
+#define LTC4222_SENSE1          0xe0
+#define LTC4222_SENSE2          0xe2
+#define LTC4222_ADC_CONTROL     0xe4
+/*
+ * Fault register bits
+ */
+#define FAULT_OV        BIT(0)
+#define FAULT_UV        BIT(1)
+#define FAULT_OC        BIT(2)
+#define FAULT_POWER_BAD BIT(3)
+#define FAULT_FET_BAD   BIT(5)
+/* Return the voltage from the given register in mV or mA */
+static int ltc4222_get_value(struct device *dev, u8 reg)
+{
+        struct regmap *regmap = dev_get_drvdata(dev);
+        unsigned int val;
+        u8 buf[2];
+        int ret;
+        ret = regmap_bulk_read(regmap, reg, buf, 2);
+        if (ret < 0)
+                return ret;
+        val = ((buf[0] << 8) + buf[1]) >> 6;
+        switch (reg) {
+        case LTC4222_ADIN1:
+        case LTC4222_ADIN2:
+                /* 1.25 mV resolution. Convert to mV. */
+                val = DIV_ROUND_CLOSEST(val * 5, 4);
+                break;
+        case LTC4222_SOURCE1:
+        case LTC4222_SOURCE2:
+                /* 31.25 mV resolution. Convert to mV. */
+                val = DIV_ROUND_CLOSEST(val * 125, 4);
+                break;
+        case LTC4222_SENSE1:
+        case LTC4222_SENSE2:
+                /*
+                 * 62.5 uV resolution. Convert to current as measured with
+                 * an 1 mOhm sense resistor, in mA. If a different sense
+                 * resistor is installed, calculate the actual current by
+                 * dividing the reported current by the sense resistor value
+                 * in mOhm.
+                 */
+                val = DIV_ROUND_CLOSEST(val * 125, 2);
+                break;
+        default:
+                return -EINVAL;
+        }
+        return val;
+}
+static ssize_t ltc4222_show_value(struct device *dev,
+                                  struct device_attribute *da, char *buf)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int value;
+        value = ltc4222_get_value(dev, attr->index);
+        if (value < 0)
+                return value;
+        return snprintf(buf, PAGE_SIZE, "%d\n", value);
+}
+static ssize_t ltc4222_show_bool(struct device *dev,
+                                 struct device_attribute *da, char *buf)
+{
+        struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(da);
+        struct regmap *regmap = dev_get_drvdata(dev);
+        unsigned int fault;
+        int ret;
+        ret = regmap_read(regmap, attr->nr, &fault);
+        if (ret < 0)
+                return ret;
+        fault &= attr->index;
+        if (fault)              /* Clear reported faults in chip register */
+                regmap_update_bits(regmap, attr->nr, attr->index, 0);
+        return snprintf(buf, PAGE_SIZE, "%d\n", !!fault);
+}
+/* Voltages */
+static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ltc4222_show_value, NULL,
+                          LTC4222_SOURCE1);
+static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, ltc4222_show_value, NULL,
+                          LTC4222_ADIN1);
+static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, ltc4222_show_value, NULL,
+                          LTC4222_SOURCE2);
+static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, ltc4222_show_value, NULL,
+                          LTC4222_ADIN2);
+/*
+ * Voltage alarms
+ * UV/OV faults are associated with the input voltage, and power bad and fet
+ * faults are associated with the output voltage.
+ */
+static SENSOR_DEVICE_ATTR_2(in1_min_alarm, S_IRUGO, ltc4222_show_bool, NULL,
+                            LTC4222_FAULT1, FAULT_UV);
+static SENSOR_DEVICE_ATTR_2(in1_max_alarm, S_IRUGO, ltc4222_show_bool, NULL,
+                            LTC4222_FAULT1, FAULT_OV);
+static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, ltc4222_show_bool, NULL,
+                            LTC4222_FAULT1, FAULT_POWER_BAD | FAULT_FET_BAD);
+static SENSOR_DEVICE_ATTR_2(in3_min_alarm, S_IRUGO, ltc4222_show_bool, NULL,
+                            LTC4222_FAULT2, FAULT_UV);
+static SENSOR_DEVICE_ATTR_2(in3_max_alarm, S_IRUGO, ltc4222_show_bool, NULL,
+                            LTC4222_FAULT2, FAULT_OV);
+static SENSOR_DEVICE_ATTR_2(in4_alarm, S_IRUGO, ltc4222_show_bool, NULL,
+                            LTC4222_FAULT2, FAULT_POWER_BAD | FAULT_FET_BAD);
+/* Current (via sense resistor) */
+static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ltc4222_show_value, NULL,
+                          LTC4222_SENSE1);
+static SENSOR_DEVICE_ATTR(curr2_input, S_IRUGO, ltc4222_show_value, NULL,
+                          LTC4222_SENSE2);
+/* Overcurrent alarm */
+static SENSOR_DEVICE_ATTR_2(curr1_max_alarm, S_IRUGO, ltc4222_show_bool, NULL,
+                            LTC4222_FAULT1, FAULT_OC);
+static SENSOR_DEVICE_ATTR_2(curr2_max_alarm, S_IRUGO, ltc4222_show_bool, NULL,
+                            LTC4222_FAULT2, FAULT_OC);
+static struct attribute *ltc4222_attrs[] = {
+        &sensor_dev_attr_in1_input.dev_attr.attr,
+        &sensor_dev_attr_in1_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_in1_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_in2_input.dev_attr.attr,
+        &sensor_dev_attr_in2_alarm.dev_attr.attr,
+        &sensor_dev_attr_in3_input.dev_attr.attr,
+        &sensor_dev_attr_in3_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_in3_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_in4_input.dev_attr.attr,
+        &sensor_dev_attr_in4_alarm.dev_attr.attr,
+        &sensor_dev_attr_curr1_input.dev_attr.attr,
+        &sensor_dev_attr_curr1_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_curr2_input.dev_attr.attr,
+        &sensor_dev_attr_curr2_max_alarm.dev_attr.attr,
+        NULL,
+};
+ATTRIBUTE_GROUPS(ltc4222);
+static struct regmap_config ltc4222_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+        .max_register = LTC4222_ADC_CONTROL,
+};
+static int ltc4222_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        struct device *dev = &client->dev;
+        struct device *hwmon_dev;
+        struct regmap *regmap;
+        regmap = devm_regmap_init_i2c(client, &ltc4222_regmap_config);
+        if (IS_ERR(regmap)) {
+                dev_err(dev, "failed to allocate register map\n");
+                return PTR_ERR(regmap);
+        }
+        /* Clear faults */
+        regmap_write(regmap, LTC4222_FAULT1, 0x00);
+        regmap_write(regmap, LTC4222_FAULT2, 0x00);
+        hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
+                                                           regmap,
+                                                           ltc4222_groups);
+        return PTR_ERR_OR_ZERO(hwmon_dev);
+}
+static const struct i2c_device_id ltc4222_id[] = {
+        {"ltc4222", 0},
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, ltc4222_id);
+static struct i2c_driver ltc4222_driver = {
+        .driver = {
+                   .name = "ltc4222",
+                   },
+        .probe = ltc4222_probe,
+        .id_table = ltc4222_id,
+};
+module_i2c_driver(ltc4222_driver);
+MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
+MODULE_DESCRIPTION("LTC4222 driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/hwmon/ltc4245.c b/drivers/hwmon/ltc4245.c
index d4172933ce4f..681b5b7b3c3b 100644
--- a/drivers/hwmon/ltc4245.c
+++ b/drivers/hwmon/ltc4245.c
@@ -95,7 +95,6 @@ static void ltc4245_update_gpios(struct device *dev)
         * readings as stale by setting them to -EAGAIN
         */
        if (time_after(jiffies, data->last_updated + 5 * HZ)) {
-                dev_dbg(&client->dev, "Marking GPIOs invalid\n");
                for (i = 0; i < ARRAY_SIZE(data->gpios); i++)
                        data->gpios[i] = -EAGAIN;
        }
@@ -141,8 +140,6 @@ static struct ltc4245_data *ltc4245_update_device(struct device *dev)
        if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
-                dev_dbg(&client->dev, "Starting ltc4245 update\n");
                /* Read control registers -- 0x00 to 0x07 */
                for (i = 0; i < ARRAY_SIZE(data->cregs); i++) {
                        val = i2c_smbus_read_byte_data(client, i);
@@ -470,19 +467,15 @@ static void ltc4245_sysfs_add_groups(struct ltc4245_data *data)
 static bool ltc4245_use_extra_gpios(struct i2c_client *client)
 {
        struct ltc4245_platform_data *pdata = dev_get_platdata(&client->dev);
-#ifdef CONFIG_OF
        struct device_node *np = client->dev.of_node;
-#endif
        /* prefer platform data */
        if (pdata)
                return pdata->use_extra_gpios;
-#ifdef CONFIG_OF
        /* fallback on OF */
        if (of_find_property(np, "ltc4245,use-extra-gpios", NULL))
                return true;
-#endif
        return false;
 }
@@ -512,24 +505,10 @@ static int ltc4245_probe(struct i2c_client *client,
        /* Add sysfs hooks */
        ltc4245_sysfs_add_groups(data);
-        hwmon_dev = hwmon_device_register_with_groups(&client->dev,
+        hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
-                                                      client->name, data,
+                                                           client->name, data,
-                                                      data->groups);
+                                                           data->groups);
-        if (IS_ERR(hwmon_dev))
+        return PTR_ERR_OR_ZERO(hwmon_dev);
-                return PTR_ERR(hwmon_dev);
-        i2c_set_clientdata(client, hwmon_dev);
-        return 0;
-}
-static int ltc4245_remove(struct i2c_client *client)
-{
-        struct device *hwmon_dev = i2c_get_clientdata(client);
-        hwmon_device_unregister(hwmon_dev);
-        return 0;
 }
 static const struct i2c_device_id ltc4245_id[] = {
@@ -544,7 +523,6 @@ static struct i2c_driver ltc4245_driver = {
                .name   = "ltc4245",
        },
        .probe          = ltc4245_probe,
-        .remove         = ltc4245_remove,
        .id_table       = ltc4245_id,
 };
diff --git a/drivers/hwmon/ltc4260.c b/drivers/hwmon/ltc4260.c
new file mode 100644
index 000000000000..453a250d9df5
--- /dev/null
+++ b/drivers/hwmon/ltc4260.c
@@ -0,0 +1,200 @@
+/*
+ * Driver for Linear Technology LTC4260 I2C Positive Voltage Hot Swap Controller
+ *
+ * Copyright (c) 2014 Guenter Roeck
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/jiffies.h>
+#include <linux/regmap.h>
+/* chip registers */
+#define LTC4260_CONTROL 0x00
+#define LTC4260_ALERT   0x01
+#define LTC4260_STATUS  0x02
+#define LTC4260_FAULT   0x03
+#define LTC4260_SENSE   0x04
+#define LTC4260_SOURCE  0x05
+#define LTC4260_ADIN    0x06
+/*
+ * Fault register bits
+ */
+#define FAULT_OV        (1 << 0)
+#define FAULT_UV        (1 << 1)
+#define FAULT_OC        (1 << 2)
+#define FAULT_POWER_BAD (1 << 3)
+#define FAULT_FET_SHORT (1 << 5)
+/* Return the voltage from the given register in mV or mA */
+static int ltc4260_get_value(struct device *dev, u8 reg)
+{
+        struct regmap *regmap = dev_get_drvdata(dev);
+        unsigned int val;
+        int ret;
+        ret = regmap_read(regmap, reg, &val);
+        if (ret < 0)
+                return ret;
+        switch (reg) {
+        case LTC4260_ADIN:
+                /* 10 mV resolution. Convert to mV. */
+                val = val * 10;
+                break;
+        case LTC4260_SOURCE:
+                /* 400 mV resolution. Convert to mV. */
+                val = val * 400;
+                break;
+        case LTC4260_SENSE:
+                /*
+                 * 300 uV resolution. Convert to current as measured with
+                 * an 1 mOhm sense resistor, in mA. If a different sense
+                 * resistor is installed, calculate the actual current by
+                 * dividing the reported current by the sense resistor value
+                 * in mOhm.
+                 */
+                val = val * 300;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return val;
+}
+static ssize_t ltc4260_show_value(struct device *dev,
+                                  struct device_attribute *da, char *buf)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int value;
+        value = ltc4260_get_value(dev, attr->index);
+        if (value < 0)
+                return value;
+        return snprintf(buf, PAGE_SIZE, "%d\n", value);
+}
+static ssize_t ltc4260_show_bool(struct device *dev,
+                                 struct device_attribute *da, char *buf)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        struct regmap *regmap = dev_get_drvdata(dev);
+        unsigned int fault;
+        int ret;
+        ret = regmap_read(regmap, LTC4260_FAULT, &fault);
+        if (ret < 0)
+                return ret;
+        fault &= attr->index;
+        if (fault)              /* Clear reported faults in chip register */
+                regmap_update_bits(regmap, LTC4260_FAULT, attr->index, 0);
+        return snprintf(buf, PAGE_SIZE, "%d\n", !!fault);
+}
+/* Voltages */
+static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ltc4260_show_value, NULL,
+                          LTC4260_SOURCE);
+static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, ltc4260_show_value, NULL,
+                          LTC4260_ADIN);
+/*
+ * Voltage alarms
+ * UV/OV faults are associated with the input voltage, and the POWER BAD and
+ * FET SHORT faults are associated with the output voltage.
+ */
+static SENSOR_DEVICE_ATTR(in1_min_alarm, S_IRUGO, ltc4260_show_bool, NULL,
+                          FAULT_UV);
+static SENSOR_DEVICE_ATTR(in1_max_alarm, S_IRUGO, ltc4260_show_bool, NULL,
+                          FAULT_OV);
+static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, ltc4260_show_bool, NULL,
+                          FAULT_POWER_BAD | FAULT_FET_SHORT);
+/* Current (via sense resistor) */
+static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ltc4260_show_value, NULL,
+                          LTC4260_SENSE);
+/* Overcurrent alarm */
+static SENSOR_DEVICE_ATTR(curr1_max_alarm, S_IRUGO, ltc4260_show_bool, NULL,
+                          FAULT_OC);
+static struct attribute *ltc4260_attrs[] = {
+        &sensor_dev_attr_in1_input.dev_attr.attr,
+        &sensor_dev_attr_in1_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_in1_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_in2_input.dev_attr.attr,
+        &sensor_dev_attr_in2_alarm.dev_attr.attr,
+        &sensor_dev_attr_curr1_input.dev_attr.attr,
+        &sensor_dev_attr_curr1_max_alarm.dev_attr.attr,
+        NULL,
+};
+ATTRIBUTE_GROUPS(ltc4260);
+static struct regmap_config ltc4260_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+        .max_register = LTC4260_ADIN,
+};
+static int ltc4260_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        struct device *dev = &client->dev;
+        struct device *hwmon_dev;
+        struct regmap *regmap;
+        regmap = devm_regmap_init_i2c(client, &ltc4260_regmap_config);
+        if (IS_ERR(regmap)) {
+                dev_err(dev, "failed to allocate register map\n");
+                return PTR_ERR(regmap);
+        }
+        /* Clear faults */
+        regmap_write(regmap, LTC4260_FAULT, 0x00);
+        hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
+                                                           regmap,
+                                                           ltc4260_groups);
+        return PTR_ERR_OR_ZERO(hwmon_dev);
+}
+static const struct i2c_device_id ltc4260_id[] = {
+        {"ltc4260", 0},
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, ltc4260_id);
+static struct i2c_driver ltc4260_driver = {
+        .driver = {
+                   .name = "ltc4260",
+                   },
+        .probe = ltc4260_probe,
+        .id_table = ltc4260_id,
+};
+module_i2c_driver(ltc4260_driver);
+MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
+MODULE_DESCRIPTION("LTC4260 driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/hwmon/max1619.c b/drivers/hwmon/max1619.c
index 6638e997f83f..4c23afe113e2 100644
--- a/drivers/hwmon/max1619.c
+++ b/drivers/hwmon/max1619.c
@@ -273,7 +273,6 @@ static int max1619_probe(struct i2c_client *new_client,
                return -ENOMEM;
        i2c_set_clientdata(new_client, data);
-        data->valid = 0;
        mutex_init(&data->update_lock);
        /* Initialize the MAX1619 chip */
diff --git a/drivers/hwmon/max1668.c b/drivers/hwmon/max1668.c
index 029b65e6c589..e3ed0a5b6d94 100644
--- a/drivers/hwmon/max1668.c
+++ b/drivers/hwmon/max1668.c
@@ -66,7 +66,8 @@ MODULE_PARM_DESC(read_only, "Don't set any values, read only mode");
 enum chips { max1668, max1805, max1989 };
 struct max1668_data {
-        struct device *hwmon_dev;
+        struct i2c_client *client;
+        const struct attribute_group *groups[3];
        enum chips type;
        struct mutex update_lock;
@@ -82,8 +83,8 @@ struct max1668_data {
 static struct max1668_data *max1668_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct max1668_data *data = dev_get_drvdata(dev);
-        struct max1668_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        struct max1668_data *ret = data;
        s32 val;
        int i;
@@ -205,8 +206,8 @@ static ssize_t set_temp_max(struct device *dev,
                            const char *buf, size_t count)
 {
        int index = to_sensor_dev_attr(devattr)->index;
-        struct i2c_client *client = to_i2c_client(dev);
+        struct max1668_data *data = dev_get_drvdata(dev);
-        struct max1668_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        long temp;
        int ret;
@@ -216,10 +217,11 @@ static ssize_t set_temp_max(struct device *dev,
        mutex_lock(&data->update_lock);
        data->temp_max[index] = clamp_val(temp/1000, -128, 127);
-        if (i2c_smbus_write_byte_data(client,
+        ret = i2c_smbus_write_byte_data(client,
                                        MAX1668_REG_LIMH_WR(index),
-                                        data->temp_max[index]))
+                                        data->temp_max[index]);
-                count = -EIO;
+        if (ret < 0)
+                count = ret;
        mutex_unlock(&data->update_lock);
        return count;
@@ -230,8 +232,8 @@ static ssize_t set_temp_min(struct device *dev,
                            const char *buf, size_t count)
 {
        int index = to_sensor_dev_attr(devattr)->index;
-        struct i2c_client *client = to_i2c_client(dev);
+        struct max1668_data *data = dev_get_drvdata(dev);
-        struct max1668_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        long temp;
        int ret;
@@ -241,10 +243,11 @@ static ssize_t set_temp_min(struct device *dev,
        mutex_lock(&data->update_lock);
        data->temp_min[index] = clamp_val(temp/1000, -128, 127);
-        if (i2c_smbus_write_byte_data(client,
+        ret = i2c_smbus_write_byte_data(client,
                                        MAX1668_REG_LIML_WR(index),
-                                        data->temp_min[index]))
+                                        data->temp_min[index]);
-                count = -EIO;
+        if (ret < 0)
+                count = ret;
        mutex_unlock(&data->update_lock);
        return count;
@@ -405,60 +408,29 @@ static int max1668_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
        struct i2c_adapter *adapter = client->adapter;
+        struct device *dev = &client->dev;
+        struct device *hwmon_dev;
        struct max1668_data *data;
-        int err;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        data = devm_kzalloc(&client->dev, sizeof(struct max1668_data),
+        data = devm_kzalloc(dev, sizeof(struct max1668_data), GFP_KERNEL);
-                            GFP_KERNEL);
        if (!data)
                return -ENOMEM;
-        i2c_set_clientdata(client, data);
+        data->client = client;
        data->type = id->driver_data;
        mutex_init(&data->update_lock);
-        /* Register sysfs hooks */
+        /* sysfs hooks */
-        err = sysfs_create_group(&client->dev.kobj, &max1668_group_common);
+        data->groups[0] = &max1668_group_common;
-        if (err)
-                return err;
-        if (data->type == max1668 || data->type == max1989) {
-                err = sysfs_create_group(&client->dev.kobj,
-                                         &max1668_group_unique);
-                if (err)
-                        goto error_sysrem0;
-        }
-        data->hwmon_dev = hwmon_device_register(&client->dev);
-        if (IS_ERR(data->hwmon_dev)) {
-                err = PTR_ERR(data->hwmon_dev);
-                goto error_sysrem1;
-        }
-        return 0;
-error_sysrem1:
        if (data->type == max1668 || data->type == max1989)
-                sysfs_remove_group(&client->dev.kobj, &max1668_group_unique);
+                data->groups[1] = &max1668_group_unique;
-error_sysrem0:
-        sysfs_remove_group(&client->dev.kobj, &max1668_group_common);
-        return err;
-}
-static int max1668_remove(struct i2c_client *client)
-{
-        struct max1668_data *data = i2c_get_clientdata(client);
-        hwmon_device_unregister(data->hwmon_dev);
+        hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
-        if (data->type == max1668 || data->type == max1989)
+                                                           data, data->groups);
-                sysfs_remove_group(&client->dev.kobj, &max1668_group_unique);
+        return PTR_ERR_OR_ZERO(hwmon_dev);
-        sysfs_remove_group(&client->dev.kobj, &max1668_group_common);
-        return 0;
 }
 static const struct i2c_device_id max1668_id[] = {
@@ -476,7 +448,6 @@ static struct i2c_driver max1668_driver = {
                  .name = "max1668",
                  },
        .probe = max1668_probe,
-        .remove = max1668_remove,
        .id_table = max1668_id,
        .detect = max1668_detect,
        .address_list = max1668_addr_list,
diff --git a/drivers/hwmon/max6639.c b/drivers/hwmon/max6639.c
index 066e587a18a5..70650de2cbd1 100644
--- a/drivers/hwmon/max6639.c
+++ b/drivers/hwmon/max6639.c
@@ -80,7 +80,7 @@ static const int rpm_ranges[] = { 2000, 4000, 8000, 16000 };
 * Client data (each client gets its own)
 */
 struct max6639_data {
-        struct device *hwmon_dev;
+        struct i2c_client *client;
        struct mutex update_lock;
        char valid;             /* !=0 if following fields are valid */
        unsigned long last_updated;     /* In jiffies */
@@ -104,8 +104,8 @@ struct max6639_data {
 static struct max6639_data *max6639_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct max6639_data *data = dev_get_drvdata(dev);
-        struct max6639_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        struct max6639_data *ret = data;
        int i;
        int status_reg;
@@ -191,9 +191,8 @@ static ssize_t show_temp_fault(struct device *dev,
 static ssize_t show_temp_max(struct device *dev,
                             struct device_attribute *dev_attr, char *buf)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct max6639_data *data = i2c_get_clientdata(client);
        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+        struct max6639_data *data = dev_get_drvdata(dev);
        return sprintf(buf, "%d\n", (data->temp_therm[attr->index] * 1000));
 }
@@ -202,9 +201,9 @@ static ssize_t set_temp_max(struct device *dev,
                            struct device_attribute *dev_attr,
                            const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct max6639_data *data = i2c_get_clientdata(client);
        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+        struct max6639_data *data = dev_get_drvdata(dev);
+        struct i2c_client *client = data->client;
        unsigned long val;
        int res;
@@ -224,9 +223,8 @@ static ssize_t set_temp_max(struct device *dev,
 static ssize_t show_temp_crit(struct device *dev,
                              struct device_attribute *dev_attr, char *buf)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct max6639_data *data = i2c_get_clientdata(client);
        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+        struct max6639_data *data = dev_get_drvdata(dev);
        return sprintf(buf, "%d\n", (data->temp_alert[attr->index] * 1000));
 }
@@ -235,9 +233,9 @@ static ssize_t set_temp_crit(struct device *dev,
                             struct device_attribute *dev_attr,
                             const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct max6639_data *data = i2c_get_clientdata(client);
        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+        struct max6639_data *data = dev_get_drvdata(dev);
+        struct i2c_client *client = data->client;
        unsigned long val;
        int res;
@@ -258,9 +256,8 @@ static ssize_t show_temp_emergency(struct device *dev,
                                   struct device_attribute *dev_attr,
                                   char *buf)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct max6639_data *data = i2c_get_clientdata(client);
        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+        struct max6639_data *data = dev_get_drvdata(dev);
        return sprintf(buf, "%d\n", (data->temp_ot[attr->index] * 1000));
 }
@@ -269,9 +266,9 @@ static ssize_t set_temp_emergency(struct device *dev,
                                  struct device_attribute *dev_attr,
                                  const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct max6639_data *data = i2c_get_clientdata(client);
        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+        struct max6639_data *data = dev_get_drvdata(dev);
+        struct i2c_client *client = data->client;
        unsigned long val;
        int res;
@@ -291,9 +288,8 @@ static ssize_t set_temp_emergency(struct device *dev,
 static ssize_t show_pwm(struct device *dev,
                        struct device_attribute *dev_attr, char *buf)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct max6639_data *data = i2c_get_clientdata(client);
        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+        struct max6639_data *data = dev_get_drvdata(dev);
        return sprintf(buf, "%d\n", data->pwm[attr->index] * 255 / 120);
 }
@@ -302,9 +298,9 @@ static ssize_t set_pwm(struct device *dev,
                       struct device_attribute *dev_attr,
                       const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct max6639_data *data = i2c_get_clientdata(client);
        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+        struct max6639_data *data = dev_get_drvdata(dev);
+        struct i2c_client *client = data->client;
        unsigned long val;
        int res;
@@ -378,7 +374,7 @@ static SENSOR_DEVICE_ATTR(temp1_emergency_alarm, S_IRUGO, show_alarm, NULL, 5);
 static SENSOR_DEVICE_ATTR(temp2_emergency_alarm, S_IRUGO, show_alarm, NULL, 4);
-static struct attribute *max6639_attributes[] = {
+static struct attribute *max6639_attrs[] = {
        &sensor_dev_attr_temp1_input.dev_attr.attr,
        &sensor_dev_attr_temp2_input.dev_attr.attr,
        &sensor_dev_attr_temp1_fault.dev_attr.attr,
@@ -403,10 +399,7 @@ static struct attribute *max6639_attributes[] = {
        &sensor_dev_attr_temp2_emergency_alarm.dev_attr.attr,
        NULL
 };
+ATTRIBUTE_GROUPS(max6639);
-static const struct attribute_group max6639_group = {
-        .attrs = max6639_attributes,
-};
 /*
 *  returns respective index in rpm_ranges table
@@ -424,9 +417,9 @@ static int rpm_range_to_reg(int range)
        return 1; /* default: 4000 RPM */
 }
-static int max6639_init_client(struct i2c_client *client)
+static int max6639_init_client(struct i2c_client *client,
+                               struct max6639_data *data)
 {
-        struct max6639_data *data = i2c_get_clientdata(client);
        struct max6639_platform_data *max6639_info =
                dev_get_platdata(&client->dev);
        int i;
@@ -545,50 +538,27 @@ static int max6639_detect(struct i2c_client *client,
 static int max6639_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
+        struct device *dev = &client->dev;
        struct max6639_data *data;
+        struct device *hwmon_dev;
        int err;
-        data = devm_kzalloc(&client->dev, sizeof(struct max6639_data),
+        data = devm_kzalloc(dev, sizeof(struct max6639_data), GFP_KERNEL);
-                            GFP_KERNEL);
        if (!data)
                return -ENOMEM;
-        i2c_set_clientdata(client, data);
+        data->client = client;
        mutex_init(&data->update_lock);
        /* Initialize the max6639 chip */
-        err = max6639_init_client(client);
+        err = max6639_init_client(client, data);
        if (err < 0)
                return err;
-        /* Register sysfs hooks */
+        hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
-        err = sysfs_create_group(&client->dev.kobj, &max6639_group);
+                                                           data,
-        if (err)
+                                                           max6639_groups);
-                return err;
+        return PTR_ERR_OR_ZERO(hwmon_dev);
-        data->hwmon_dev = hwmon_device_register(&client->dev);
-        if (IS_ERR(data->hwmon_dev)) {
-                err = PTR_ERR(data->hwmon_dev);
-                goto error_remove;
-        }
-        dev_info(&client->dev, "temperature sensor and fan control found\n");
-        return 0;
-error_remove:
-        sysfs_remove_group(&client->dev.kobj, &max6639_group);
-        return err;
-}
-static int max6639_remove(struct i2c_client *client)
-{
-        struct max6639_data *data = i2c_get_clientdata(client);
-        hwmon_device_unregister(data->hwmon_dev);
-        sysfs_remove_group(&client->dev.kobj, &max6639_group);
-        return 0;
 }
 #ifdef CONFIG_PM_SLEEP
@@ -622,9 +592,7 @@ static const struct i2c_device_id max6639_id[] = {
 MODULE_DEVICE_TABLE(i2c, max6639_id);
-static const struct dev_pm_ops max6639_pm_ops = {
+static SIMPLE_DEV_PM_OPS(max6639_pm_ops, max6639_suspend, max6639_resume);
-        SET_SYSTEM_SLEEP_PM_OPS(max6639_suspend, max6639_resume)
-};
 static struct i2c_driver max6639_driver = {
        .class = I2C_CLASS_HWMON,
@@ -633,7 +601,6 @@ static struct i2c_driver max6639_driver = {
                   .pm = &max6639_pm_ops,
                   },
        .probe = max6639_probe,
-        .remove = max6639_remove,
        .id_table = max6639_id,
        .detect = max6639_detect,
        .address_list = normal_i2c,
diff --git a/drivers/hwmon/max6650.c b/drivers/hwmon/max6650.c
index 0cafc390db4d..162a520f4bd6 100644
--- a/drivers/hwmon/max6650.c
+++ b/drivers/hwmon/max6650.c
@@ -105,38 +105,13 @@ module_param(clock, int, S_IRUGO);
 #define DIV_FROM_REG(reg) (1 << (reg & 7))
-static int max6650_probe(struct i2c_client *client,
-                         const struct i2c_device_id *id);
-static int max6650_init_client(struct i2c_client *client);
-static int max6650_remove(struct i2c_client *client);
-static struct max6650_data *max6650_update_device(struct device *dev);
-/*
- * Driver data (common to all clients)
- */
-static const struct i2c_device_id max6650_id[] = {
-        { "max6650", 1 },
-        { "max6651", 4 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, max6650_id);
-static struct i2c_driver max6650_driver = {
-        .driver = {
-                .name   = "max6650",
-        },
-        .probe          = max6650_probe,
-        .remove         = max6650_remove,
-        .id_table       = max6650_id,
-};
 /*
 * Client data (each client gets its own)
 */
 struct max6650_data {
-        struct device *hwmon_dev;
+        struct i2c_client *client;
+        const struct attribute_group *groups[3];
        struct mutex update_lock;
        int nr_fans;
        char valid; /* zero until following fields are valid */
@@ -151,6 +126,51 @@ struct max6650_data {
        u8 alarm;
 };
+static const u8 tach_reg[] = {
+        MAX6650_REG_TACH0,
+        MAX6650_REG_TACH1,
+        MAX6650_REG_TACH2,
+        MAX6650_REG_TACH3,
+};
+static struct max6650_data *max6650_update_device(struct device *dev)
+{
+        struct max6650_data *data = dev_get_drvdata(dev);
+        struct i2c_client *client = data->client;
+        int i;
+        mutex_lock(&data->update_lock);
+        if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
+                data->speed = i2c_smbus_read_byte_data(client,
+                                                       MAX6650_REG_SPEED);
+                data->config = i2c_smbus_read_byte_data(client,
+                                                        MAX6650_REG_CONFIG);
+                for (i = 0; i < data->nr_fans; i++) {
+                        data->tach[i] = i2c_smbus_read_byte_data(client,
+                                                                 tach_reg[i]);
+                }
+                data->count = i2c_smbus_read_byte_data(client,
+                                                        MAX6650_REG_COUNT);
+                data->dac = i2c_smbus_read_byte_data(client, MAX6650_REG_DAC);
+                /*
+                 * Alarms are cleared on read in case the condition that
+                 * caused the alarm is removed. Keep the value latched here
+                 * for providing the register through different alarm files.
+                 */
+                data->alarm |= i2c_smbus_read_byte_data(client,
+                                                        MAX6650_REG_ALARM);
+                data->last_updated = jiffies;
+                data->valid = 1;
+        }
+        mutex_unlock(&data->update_lock);
+        return data;
+}
 static ssize_t get_fan(struct device *dev, struct device_attribute *devattr,
                       char *buf)
 {
@@ -235,8 +255,8 @@ static ssize_t get_target(struct device *dev, struct device_attribute *devattr,
 static ssize_t set_target(struct device *dev, struct device_attribute *devattr,
                         const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct max6650_data *data = dev_get_drvdata(dev);
-        struct max6650_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        int kscale, ktach;
        unsigned long rpm;
        int err;
@@ -304,8 +324,8 @@ static ssize_t get_pwm(struct device *dev, struct device_attribute *devattr,
 static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
                        const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct max6650_data *data = dev_get_drvdata(dev);
-        struct max6650_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        unsigned long pwm;
        int err;
@@ -350,8 +370,8 @@ static ssize_t get_enable(struct device *dev, struct device_attribute *devattr,
 static ssize_t set_enable(struct device *dev, struct device_attribute *devattr,
                          const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct max6650_data *data = dev_get_drvdata(dev);
-        struct max6650_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        int max6650_modes[3] = {0, 3, 2};
        unsigned long mode;
        int err;
@@ -400,8 +420,8 @@ static ssize_t get_div(struct device *dev, struct device_attribute *devattr,
 static ssize_t set_div(struct device *dev, struct device_attribute *devattr,
                       const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
+        struct max6650_data *data = dev_get_drvdata(dev);
-        struct max6650_data *data = i2c_get_clientdata(client);
+        struct i2c_client *client = data->client;
        unsigned long div;
        int err;
@@ -446,7 +466,7 @@ static ssize_t get_alarm(struct device *dev, struct device_attribute *devattr,
 {
        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
        struct max6650_data *data = max6650_update_device(dev);
-        struct i2c_client *client = to_i2c_client(dev);
+        struct i2c_client *client = data->client;
        int alarm = 0;
        if (data->alarm & attr->index) {
@@ -484,7 +504,8 @@ static umode_t max6650_attrs_visible(struct kobject *kobj, struct attribute *a,
                                    int n)
 {
        struct device *dev = container_of(kobj, struct device, kobj);
-        struct i2c_client *client = to_i2c_client(dev);
+        struct max6650_data *data = dev_get_drvdata(dev);
+        struct i2c_client *client = data->client;
        u8 alarm_en = i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM_EN);
        struct device_attribute *devattr;
@@ -519,7 +540,7 @@ static struct attribute *max6650_attrs[] = {
        NULL
 };
-static struct attribute_group max6650_attr_grp = {
+static const struct attribute_group max6650_group = {
        .attrs = max6650_attrs,
        .is_visible = max6650_attrs_visible,
 };
@@ -531,7 +552,7 @@ static struct attribute *max6651_attrs[] = {
        NULL
 };
-static const struct attribute_group max6651_attr_grp = {
+static const struct attribute_group max6651_group = {
        .attrs = max6651_attrs,
 };
@@ -539,74 +560,17 @@ static const struct attribute_group max6651_attr_grp = {
 * Real code
 */
-static int max6650_probe(struct i2c_client *client,
+static int max6650_init_client(struct max6650_data *data,
-                         const struct i2c_device_id *id)
+                               struct i2c_client *client)
-{
-        struct max6650_data *data;
-        int err;
-        data = devm_kzalloc(&client->dev, sizeof(struct max6650_data),
-                            GFP_KERNEL);
-        if (!data) {
-                dev_err(&client->dev, "out of memory.\n");
-                return -ENOMEM;
-        }
-        i2c_set_clientdata(client, data);
-        mutex_init(&data->update_lock);
-        data->nr_fans = id->driver_data;
-        /*
-         * Initialize the max6650 chip
-         */
-        err = max6650_init_client(client);
-        if (err)
-                return err;
-        err = sysfs_create_group(&client->dev.kobj, &max6650_attr_grp);
-        if (err)
-                return err;
-        /* 3 additional fan inputs for the MAX6651 */
-        if (data->nr_fans == 4) {
-                err = sysfs_create_group(&client->dev.kobj, &max6651_attr_grp);
-                if (err)
-                        goto err_remove;
-        }
-        data->hwmon_dev = hwmon_device_register(&client->dev);
-        if (!IS_ERR(data->hwmon_dev))
-                return 0;
-        err = PTR_ERR(data->hwmon_dev);
-        dev_err(&client->dev, "error registering hwmon device.\n");
-        if (data->nr_fans == 4)
-                sysfs_remove_group(&client->dev.kobj, &max6651_attr_grp);
-err_remove:
-        sysfs_remove_group(&client->dev.kobj, &max6650_attr_grp);
-        return err;
-}
-static int max6650_remove(struct i2c_client *client)
 {
-        struct max6650_data *data = i2c_get_clientdata(client);
+        struct device *dev = &client->dev;
-        hwmon_device_unregister(data->hwmon_dev);
-        if (data->nr_fans == 4)
-                sysfs_remove_group(&client->dev.kobj, &max6651_attr_grp);
-        sysfs_remove_group(&client->dev.kobj, &max6650_attr_grp);
-        return 0;
-}
-static int max6650_init_client(struct i2c_client *client)
-{
-        struct max6650_data *data = i2c_get_clientdata(client);
        int config;
        int err = -EIO;
        config = i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG);
        if (config < 0) {
-                dev_err(&client->dev, "Error reading config, aborting.\n");
+                dev_err(dev, "Error reading config, aborting.\n");
                return err;
        }
@@ -620,11 +584,11 @@ static int max6650_init_client(struct i2c_client *client)
                config |= MAX6650_CFG_V12;
                break;
        default:
-                dev_err(&client->dev, "illegal value for fan_voltage (%d)\n",
+                dev_err(dev, "illegal value for fan_voltage (%d)\n",
                        fan_voltage);
        }
-        dev_info(&client->dev, "Fan voltage is set to %dV.\n",
+        dev_info(dev, "Fan voltage is set to %dV.\n",
                 (config & MAX6650_CFG_V12) ? 12 : 5);
        switch (prescaler) {
@@ -650,11 +614,10 @@ static int max6650_init_client(struct i2c_client *client)
                         | MAX6650_CFG_PRESCALER_16;
                break;
        default:
-                dev_err(&client->dev, "illegal value for prescaler (%d)\n",
+                dev_err(dev, "illegal value for prescaler (%d)\n", prescaler);
-                        prescaler);
        }
-        dev_info(&client->dev, "Prescaler is set to %d.\n",
+        dev_info(dev, "Prescaler is set to %d.\n",
                 1 << (config & MAX6650_CFG_PRESCALER_MASK));
        /*
@@ -664,17 +627,17 @@ static int max6650_init_client(struct i2c_client *client)
         */
        if ((config & MAX6650_CFG_MODE_MASK) == MAX6650_CFG_MODE_OFF) {
-                dev_dbg(&client->dev, "Change mode to open loop, full off.\n");
+                dev_dbg(dev, "Change mode to open loop, full off.\n");
                config = (config & ~MAX6650_CFG_MODE_MASK)
                         | MAX6650_CFG_MODE_OPEN_LOOP;
                if (i2c_smbus_write_byte_data(client, MAX6650_REG_DAC, 255)) {
-                        dev_err(&client->dev, "DAC write error, aborting.\n");
+                        dev_err(dev, "DAC write error, aborting.\n");
                        return err;
                }
        }
        if (i2c_smbus_write_byte_data(client, MAX6650_REG_CONFIG, config)) {
-                dev_err(&client->dev, "Config write error, aborting.\n");
+                dev_err(dev, "Config write error, aborting.\n");
                return err;
        }
@@ -684,51 +647,55 @@ static int max6650_init_client(struct i2c_client *client)
        return 0;
 }
-static const u8 tach_reg[] = {
+static int max6650_probe(struct i2c_client *client,
-        MAX6650_REG_TACH0,
+                         const struct i2c_device_id *id)
-        MAX6650_REG_TACH1,
-        MAX6650_REG_TACH2,
-        MAX6650_REG_TACH3,
-};
-static struct max6650_data *max6650_update_device(struct device *dev)
 {
-        int i;
+        struct device *dev = &client->dev;
-        struct i2c_client *client = to_i2c_client(dev);
+        struct max6650_data *data;
-        struct max6650_data *data = i2c_get_clientdata(client);
+        struct device *hwmon_dev;
+        int err;
-        mutex_lock(&data->update_lock);
-        if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
+        data = devm_kzalloc(dev, sizeof(struct max6650_data), GFP_KERNEL);
-                data->speed = i2c_smbus_read_byte_data(client,
+        if (!data)
-                                                       MAX6650_REG_SPEED);
+                return -ENOMEM;
-                data->config = i2c_smbus_read_byte_data(client,
-                                                        MAX6650_REG_CONFIG);
-                for (i = 0; i < data->nr_fans; i++) {
-                        data->tach[i] = i2c_smbus_read_byte_data(client,
-                                                                 tach_reg[i]);
-                }
-                data->count = i2c_smbus_read_byte_data(client,
-                                                        MAX6650_REG_COUNT);
-                data->dac = i2c_smbus_read_byte_data(client, MAX6650_REG_DAC);
-                /*
+        data->client = client;
-                 * Alarms are cleared on read in case the condition that
+        mutex_init(&data->update_lock);
-                 * caused the alarm is removed. Keep the value latched here
+        data->nr_fans = id->driver_data;
-                 * for providing the register through different alarm files.
-                 */
-                data->alarm |= i2c_smbus_read_byte_data(client,
-                                                        MAX6650_REG_ALARM);
-                data->last_updated = jiffies;
+        /*
-                data->valid = 1;
+         * Initialize the max6650 chip
-        }
+         */
+        err = max6650_init_client(data, client);
+        if (err)
+                return err;
-        mutex_unlock(&data->update_lock);
+        data->groups[0] = &max6650_group;
+        /* 3 additional fan inputs for the MAX6651 */
+        if (data->nr_fans == 4)
+                data->groups[1] = &max6651_group;
-        return data;
+        hwmon_dev = devm_hwmon_device_register_with_groups(dev,
+                                                           client->name, data,
+                                                           data->groups);
+        return PTR_ERR_OR_ZERO(hwmon_dev);
 }
+static const struct i2c_device_id max6650_id[] = {
+        { "max6650", 1 },
+        { "max6651", 4 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, max6650_id);
+static struct i2c_driver max6650_driver = {
+        .driver = {
+                .name   = "max6650",
+        },
+        .probe          = max6650_probe,
+        .id_table       = max6650_id,
+};
 module_i2c_driver(max6650_driver);
 MODULE_AUTHOR("Hans J. Koch");
diff --git a/drivers/hwmon/pc87360.c b/drivers/hwmon/pc87360.c
index 330fe117e219..988181e4cfcd 100644
--- a/drivers/hwmon/pc87360.c
+++ b/drivers/hwmon/pc87360.c
@@ -1225,7 +1225,7 @@ static int pc87360_probe(struct platform_device *pdev)
        int i;
        struct pc87360_data *data;
        int err = 0;
-        const char *name = "pc87360";
+        const char *name;
        int use_thermistors = 0;
        struct device *dev = &pdev->dev;
@@ -1233,13 +1233,14 @@ static int pc87360_probe(struct platform_device *pdev)
        if (!data)
                return -ENOMEM;
-        data->fannr = 2;
-        data->innr = 0;
-        data->tempnr = 0;
        switch (devid) {
+        default:
+                name = "pc87360";
+                data->fannr = 2;
+                break;
        case 0xe8:
                name = "pc87363";
+                data->fannr = 2;
                break;
        case 0xe4:
                name = "pc87364";
@@ -1260,7 +1261,6 @@ static int pc87360_probe(struct platform_device *pdev)
        }
        data->name = name;
-        data->valid = 0;
        mutex_init(&data->lock);
        mutex_init(&data->update_lock);
        platform_set_drvdata(pdev, data);
diff --git a/drivers/hwmon/pmbus/ltc2978.c b/drivers/hwmon/pmbus/ltc2978.c
index de3c152a1d9a..e24ed521051a 100644
--- a/drivers/hwmon/pmbus/ltc2978.c
+++ b/drivers/hwmon/pmbus/ltc2978.c
@@ -1,9 +1,9 @@
 /*
 * Hardware monitoring driver for LTC2974, LTC2977, LTC2978, LTC3880,
- * and LTC3883
+ * LTC3883, and LTM4676
 *
 * Copyright (c) 2011 Ericsson AB.
- * Copyright (c) 2013 Guenter Roeck
+ * Copyright (c) 2013, 2014 Guenter Roeck
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -14,10 +14,6 @@
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 #include <linux/kernel.h>
@@ -28,7 +24,7 @@
 #include <linux/i2c.h>
 #include "pmbus.h"
-enum chips { ltc2974, ltc2977, ltc2978, ltc3880, ltc3883 };
+enum chips { ltc2974, ltc2977, ltc2978, ltc3880, ltc3883, ltm4676 };
 /* Common for all chips */
 #define LTC2978_MFR_VOUT_PEAK           0xdd
@@ -45,7 +41,7 @@ enum chips { ltc2974, ltc2977, ltc2978, ltc3880, ltc3883 };
 #define LTC2974_MFR_IOUT_PEAK           0xd7
 #define LTC2974_MFR_IOUT_MIN            0xd8
-/* LTC3880 and LTC3883 */
+/* LTC3880, LTC3883, and LTM4676 */
 #define LTC3880_MFR_IOUT_PEAK           0xd7
 #define LTC3880_MFR_CLEAR_PEAKS         0xe3
 #define LTC3880_MFR_TEMPERATURE2_PEAK   0xf4
@@ -53,7 +49,8 @@ enum chips { ltc2974, ltc2977, ltc2978, ltc3880, ltc3883 };
 /* LTC3883 only */
 #define LTC3883_MFR_IIN_PEAK            0xe1
-#define LTC2974_ID                      0x0212
+#define LTC2974_ID_REV1                 0x0212
+#define LTC2974_ID_REV2                 0x0213
 #define LTC2977_ID                      0x0130
 #define LTC2978_ID_REV1                 0x0121
 #define LTC2978_ID_REV2                 0x0122
@@ -62,6 +59,8 @@ enum chips { ltc2974, ltc2977, ltc2978, ltc3880, ltc3883 };
 #define LTC3880_ID_MASK                 0xff00
 #define LTC3883_ID                      0x4300
 #define LTC3883_ID_MASK                 0xff00
+#define LTM4676_ID                      0x4480  /* datasheet claims 0x440X */
+#define LTM4676_ID_MASK                 0xfff0
 #define LTC2974_NUM_PAGES               4
 #define LTC2978_NUM_PAGES               8
@@ -370,6 +369,7 @@ static const struct i2c_device_id ltc2978_id[] = {
        {"ltc2978", ltc2978},
        {"ltc3880", ltc3880},
        {"ltc3883", ltc3883},
+        {"ltm4676", ltm4676},
        {}
 };
 MODULE_DEVICE_TABLE(i2c, ltc2978_id);
@@ -394,7 +394,7 @@ static int ltc2978_probe(struct i2c_client *client,
        if (chip_id < 0)
                return chip_id;
-        if (chip_id == LTC2974_ID) {
+        if (chip_id == LTC2974_ID_REV1 || chip_id == LTC2974_ID_REV2) {
                data->id = ltc2974;
        } else if (chip_id == LTC2977_ID) {
                data->id = ltc2977;
@@ -405,6 +405,8 @@ static int ltc2978_probe(struct i2c_client *client,
                data->id = ltc3880;
        } else if ((chip_id & LTC3883_ID_MASK) == LTC3883_ID) {
                data->id = ltc3883;
+        } else if ((chip_id & LTM4676_ID_MASK) == LTM4676_ID) {
+                data->id = ltm4676;
        } else {
                dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
                return -ENODEV;
@@ -458,6 +460,7 @@ static int ltc2978_probe(struct i2c_client *client,
                }
                break;
        case ltc3880:
+        case ltm4676:
                info->read_word_data = ltc3880_read_word_data;
                info->pages = LTC3880_NUM_PAGES;
                info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
@@ -500,5 +503,5 @@ static struct i2c_driver ltc2978_driver = {
 module_i2c_driver(ltc2978_driver);
 MODULE_AUTHOR("Guenter Roeck");
-MODULE_DESCRIPTION("PMBus driver for LTC2974, LTC2978, LTC3880, and LTC3883");
+MODULE_DESCRIPTION("PMBus driver for LTC2974, LTC2978, LTC3880, LTC3883, and LTM4676");
 MODULE_LICENSE("GPL");
diff --git a/drivers/hwmon/smm665.c b/drivers/hwmon/smm665.c
index d9e1b7de78da..4ef5802df6d8 100644
--- a/drivers/hwmon/smm665.c
+++ b/drivers/hwmon/smm665.c
@@ -222,7 +222,7 @@ static int smm665_read_adc(struct smm665_data *data, int adc)
        rv = i2c_smbus_read_word_swapped(client, 0);
        if (rv < 0) {
                dev_dbg(&client->dev, "Failed to read ADC value: error %d", rv);
-                return -1;
+                return rv;
        }
        /*
         * Validate/verify readback adc channel (in bit 11..14).
diff --git a/drivers/hwmon/via-cputemp.c b/drivers/hwmon/via-cputemp.c
index 38944e94f65f..8df43c51de2c 100644
--- a/drivers/hwmon/via-cputemp.c
+++ b/drivers/hwmon/via-cputemp.c
@@ -319,7 +319,7 @@ static int __init via_cputemp_init(void)
        if (err)
                goto exit;
-        get_online_cpus();
+        cpu_notifier_register_begin();
        for_each_online_cpu(i) {
                struct cpuinfo_x86 *c = &cpu_data(i);
@@ -339,14 +339,14 @@ static int __init via_cputemp_init(void)
 #ifndef CONFIG_HOTPLUG_CPU
        if (list_empty(&pdev_list)) {
-                put_online_cpus();
+                cpu_notifier_register_done();
                err = -ENODEV;
                goto exit_driver_unreg;
        }
 #endif
-        register_hotcpu_notifier(&via_cputemp_cpu_notifier);
+        __register_hotcpu_notifier(&via_cputemp_cpu_notifier);
-        put_online_cpus();
+        cpu_notifier_register_done();
        return 0;
 #ifndef CONFIG_HOTPLUG_CPU
@@ -361,8 +361,8 @@ static void __exit via_cputemp_exit(void)
 {
        struct pdev_entry *p, *n;
-        get_online_cpus();
+        cpu_notifier_register_begin();
-        unregister_hotcpu_notifier(&via_cputemp_cpu_notifier);
+        __unregister_hotcpu_notifier(&via_cputemp_cpu_notifier);
        mutex_lock(&pdev_list_mutex);
        list_for_each_entry_safe(p, n, &pdev_list, list) {
                platform_device_unregister(p->pdev);
@@ -370,7 +370,7 @@ static void __exit via_cputemp_exit(void)
                kfree(p);
        }
        mutex_unlock(&pdev_list_mutex);
-        put_online_cpus();
+        cpu_notifier_register_done();
        platform_driver_unregister(&via_cputemp_driver);
 }
diff --git a/drivers/hwmon/w83792d.c b/drivers/hwmon/w83792d.c
index df585808adb6..4068db4d9580 100644
--- a/drivers/hwmon/w83792d.c
+++ b/drivers/hwmon/w83792d.c
@@ -1376,7 +1376,6 @@ w83792d_probe(struct i2c_client *client, const struct i2c_device_id *id)
                return -ENOMEM;
        i2c_set_clientdata(client, data);
-        data->valid = 0;
        mutex_init(&data->update_lock);
        err = w83792d_detect_subclients(client);
diff --git a/drivers/hwmon/w83l785ts.c b/drivers/hwmon/w83l785ts.c
index 6384b268f590..ac3043122011 100644
--- a/drivers/hwmon/w83l785ts.c
+++ b/drivers/hwmon/w83l785ts.c
@@ -188,12 +188,8 @@ static int w83l785ts_probe(struct i2c_client *client,
                return -ENOMEM;
        i2c_set_clientdata(client, data);
-        data->valid = 0;
        mutex_init(&data->update_lock);
-        /* Default values in case the first read fails (unlikely). */
-        data->temp[1] = data->temp[0] = 0;
        /*
         * Initialize the W83L785TS chip
         * Nothing yet, assume it is already started.