Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

* lm90.c - Part of lm_sensors, Linux kernel modules for hardware

2

* lm90.c - Part of lm_sensors, Linux kernel modules for hardware

3

* monitoring

3

* monitoring

4

5

*

5

*

6

* Based on the lm83 driver. The LM90 is a sensor chip made by National

6

* Based on the lm83 driver. The LM90 is a sensor chip made by National

7

* Semiconductor. It reports up to two temperatures (its own plus up to

7

* Semiconductor. It reports up to two temperatures (its own plus up to

8

* one external one) with a 0.125 deg resolution (1 deg for local

8

* one external one) with a 0.125 deg resolution (1 deg for local

9

* temperature) and a 3-4 deg accuracy.

9

* temperature) and a 3-4 deg accuracy.

10

*

10

*

11

* This driver also supports the LM89 and LM99, two other sensor chips

11

* This driver also supports the LM89 and LM99, two other sensor chips

12

* made by National Semiconductor. Both have an increased remote

12

* made by National Semiconductor. Both have an increased remote

13

* temperature measurement accuracy (1 degree), and the LM99

13

* temperature measurement accuracy (1 degree), and the LM99

14

* additionally shifts remote temperatures (measured and limits) by 16

14

* additionally shifts remote temperatures (measured and limits) by 16

15

* degrees, which allows for higher temperatures measurement.

15

* degrees, which allows for higher temperatures measurement.

16

* Note that there is no way to differentiate between both chips.

16

* Note that there is no way to differentiate between both chips.

17

* When device is auto-detected, the driver will assume an LM99.

17

* When device is auto-detected, the driver will assume an LM99.

18

*

18

*

19

* This driver also supports the LM86, another sensor chip made by

19

* This driver also supports the LM86, another sensor chip made by

20

* National Semiconductor. It is exactly similar to the LM90 except it

20

* National Semiconductor. It is exactly similar to the LM90 except it

21

* has a higher accuracy.

21

* has a higher accuracy.

22

*

22

*

23

* This driver also supports the ADM1032, a sensor chip made by Analog

23

* This driver also supports the ADM1032, a sensor chip made by Analog

24

* Devices. That chip is similar to the LM90, with a few differences

24

* Devices. That chip is similar to the LM90, with a few differences

25

* that are not handled by this driver. Among others, it has a higher

25

* that are not handled by this driver. Among others, it has a higher

26

* accuracy than the LM90, much like the LM86 does.

26

* accuracy than the LM90, much like the LM86 does.

27

*

27

*

28

* This driver also supports the MAX6657, MAX6658 and MAX6659 sensor

28

* This driver also supports the MAX6657, MAX6658 and MAX6659 sensor

29

* chips made by Maxim. These chips are similar to the LM86.

29

* chips made by Maxim. These chips are similar to the LM86.

30

* Note that there is no easy way to differentiate between the three

30

* Note that there is no easy way to differentiate between the three

31

* variants. We use the device address to detect MAX6659, which will result

31

* variants. We use the device address to detect MAX6659, which will result

32

* in a detection as max6657 if it is on address 0x4c. The extra address

32

* in a detection as max6657 if it is on address 0x4c. The extra address

33

* and features of the MAX6659 are only supported if the chip is configured

33

* and features of the MAX6659 are only supported if the chip is configured

34

* explicitly as max6659, or if its address is not 0x4c.

34

* explicitly as max6659, or if its address is not 0x4c.

35

* These chips lack the remote temperature offset feature.

35

* These chips lack the remote temperature offset feature.

36

*

36

*

37

* This driver also supports the MAX6646, MAX6647, MAX6648, MAX6649 and

37

* This driver also supports the MAX6646, MAX6647, MAX6648, MAX6649 and

38

* MAX6692 chips made by Maxim. These are again similar to the LM86,

38

* MAX6692 chips made by Maxim. These are again similar to the LM86,

39

* but they use unsigned temperature values and can report temperatures

39

* but they use unsigned temperature values and can report temperatures

40

* from 0 to 145 degrees.

40

* from 0 to 145 degrees.

41

*

41

*

42

* This driver also supports the MAX6680 and MAX6681, two other sensor

42

* This driver also supports the MAX6680 and MAX6681, two other sensor

43

* chips made by Maxim. These are quite similar to the other Maxim

43

* chips made by Maxim. These are quite similar to the other Maxim

44

* chips. The MAX6680 and MAX6681 only differ in the pinout so they can

44

* chips. The MAX6680 and MAX6681 only differ in the pinout so they can

45

* be treated identically.

45

* be treated identically.

46

*

46

*

47

* This driver also supports the MAX6695 and MAX6696, two other sensor

47

* This driver also supports the MAX6695 and MAX6696, two other sensor

48

* chips made by Maxim. These are also quite similar to other Maxim

48

* chips made by Maxim. These are also quite similar to other Maxim

49

* chips, but support three temperature sensors instead of two. MAX6695

49

* chips, but support three temperature sensors instead of two. MAX6695

50

* and MAX6696 only differ in the pinout so they can be treated identically.

50

* and MAX6696 only differ in the pinout so they can be treated identically.

51

*

51

*

52

* This driver also supports ADT7461 and ADT7461A from Analog Devices as well as

52

* This driver also supports ADT7461 and ADT7461A from Analog Devices as well as

53

* NCT1008 from ON Semiconductor. The chips are supported in both compatibility

53

* NCT1008 from ON Semiconductor. The chips are supported in both compatibility

54

* and extended mode. They are mostly compatible with LM90 except for a data

54

* and extended mode. They are mostly compatible with LM90 except for a data

55

* format difference for the temperature value registers.

55

* format difference for the temperature value registers.

56

*

56

*

57

* This driver also supports the SA56004 from Philips. This device is

57

* This driver also supports the SA56004 from Philips. This device is

58

* pin-compatible with the LM86, the ED/EDP parts are also address-compatible.

58

* pin-compatible with the LM86, the ED/EDP parts are also address-compatible.

59

*

59

*

60

* Since the LM90 was the first chipset supported by this driver, most

60

* Since the LM90 was the first chipset supported by this driver, most

61

* comments will refer to this chipset, but are actually general and

61

* comments will refer to this chipset, but are actually general and

62

* concern all supported chipsets, unless mentioned otherwise.

62

* concern all supported chipsets, unless mentioned otherwise.

63

*

63

*

64

* This program is free software; you can redistribute it and/or modify

64

* This program is free software; you can redistribute it and/or modify

65

* it under the terms of the GNU General Public License as published by

65

* it under the terms of the GNU General Public License as published by

66

* the Free Software Foundation; either version 2 of the License, or

66

* the Free Software Foundation; either version 2 of the License, or

67

* (at your option) any later version.

67

* (at your option) any later version.

68

*

68

*

69

* This program is distributed in the hope that it will be useful,

69

* This program is distributed in the hope that it will be useful,

70

* but WITHOUT ANY WARRANTY; without even the implied warranty of

70

* but WITHOUT ANY WARRANTY; without even the implied warranty of

71

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

71

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

72

* GNU General Public License for more details.

72

* GNU General Public License for more details.

73

*

73

*

74

* You should have received a copy of the GNU General Public License

74

* You should have received a copy of the GNU General Public License

75

* along with this program; if not, write to the Free Software

75

* along with this program; if not, write to the Free Software

76

* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

76

* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

77

*/

77

*/

78

79

#include <linux/module.h>

79

#include <linux/module.h>

80

#include <linux/init.h>

80

#include <linux/init.h>

81

#include <linux/slab.h>

81

#include <linux/slab.h>

82

#include <linux/jiffies.h>

82

#include <linux/jiffies.h>

83

#include <linux/i2c.h>

83

#include <linux/i2c.h>

84

#include <linux/hwmon-sysfs.h>

84

#include <linux/hwmon-sysfs.h>

85

#include <linux/hwmon.h>

85

#include <linux/hwmon.h>

86

#include <linux/err.h>

86

#include <linux/err.h>

87

#include <linux/mutex.h>

87

#include <linux/mutex.h>

88

#include <linux/sysfs.h>

88

#include <linux/sysfs.h>

89

90

/*

90

/*

91

* Addresses to scan

91

* Addresses to scan

92

* Address is fully defined internally and cannot be changed except for

92

* Address is fully defined internally and cannot be changed except for

93

* MAX6659, MAX6680 and MAX6681.

93

* MAX6659, MAX6680 and MAX6681.

94

* LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, ADT7461A, MAX6649,

94

* LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, ADT7461A, MAX6649,

95

* MAX6657, MAX6658, NCT1008 and W83L771 have address 0x4c.

95

* MAX6657, MAX6658, NCT1008 and W83L771 have address 0x4c.

96

* ADM1032-2, ADT7461-2, ADT7461A-2, LM89-1, LM99-1, MAX6646, and NCT1008D

96

* ADM1032-2, ADT7461-2, ADT7461A-2, LM89-1, LM99-1, MAX6646, and NCT1008D

97

* have address 0x4d.

97

* have address 0x4d.

98

* MAX6647 has address 0x4e.

98

* MAX6647 has address 0x4e.

99

* MAX6659 can have address 0x4c, 0x4d or 0x4e.

99

* MAX6659 can have address 0x4c, 0x4d or 0x4e.

100

* MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,

100

* MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,

101

* 0x4c, 0x4d or 0x4e.

101

* 0x4c, 0x4d or 0x4e.

102

* SA56004 can have address 0x48 through 0x4F.

102

* SA56004 can have address 0x48 through 0x4F.

103

*/

103

*/

104

105

static const unsigned short normal_i2c[] = {

105

static const unsigned short normal_i2c[] = {

106

0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x48, 0x49, 0x4a, 0x4b, 0x4c,

106

0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x48, 0x49, 0x4a, 0x4b, 0x4c,

107

0x4d, 0x4e, 0x4f, I2C_CLIENT_END };

107

0x4d, 0x4e, 0x4f, I2C_CLIENT_END };

108

109

enum chips { lm90, adm1032, lm99, lm86, max6657, max6659, adt7461, max6680,

109

enum chips { lm90, adm1032, lm99, lm86, max6657, max6659, adt7461, max6680,

110

max6646, w83l771, max6696, sa56004 };

110

max6646, w83l771, max6696, sa56004 };

111

112

/*

112

/*

113

* The LM90 registers

113

* The LM90 registers

114

*/

114

*/

115

116

#define LM90_REG_R_MAN_ID 0xFE

116

#define LM90_REG_R_MAN_ID 0xFE

117

#define LM90_REG_R_CHIP_ID 0xFF

117

#define LM90_REG_R_CHIP_ID 0xFF

118

#define LM90_REG_R_CONFIG1 0x03

118

#define LM90_REG_R_CONFIG1 0x03

119

#define LM90_REG_W_CONFIG1 0x09

119

#define LM90_REG_W_CONFIG1 0x09

120

#define LM90_REG_R_CONFIG2 0xBF

120

#define LM90_REG_R_CONFIG2 0xBF

121

#define LM90_REG_W_CONFIG2 0xBF

121

#define LM90_REG_W_CONFIG2 0xBF

122

#define LM90_REG_R_CONVRATE 0x04

122

#define LM90_REG_R_CONVRATE 0x04

123

#define LM90_REG_W_CONVRATE 0x0A

123

#define LM90_REG_W_CONVRATE 0x0A

124

#define LM90_REG_R_STATUS 0x02

124

#define LM90_REG_R_STATUS 0x02

125

#define LM90_REG_R_LOCAL_TEMP 0x00

125

#define LM90_REG_R_LOCAL_TEMP 0x00

126

#define LM90_REG_R_LOCAL_HIGH 0x05

126

#define LM90_REG_R_LOCAL_HIGH 0x05

127

#define LM90_REG_W_LOCAL_HIGH 0x0B

127

#define LM90_REG_W_LOCAL_HIGH 0x0B

128

#define LM90_REG_R_LOCAL_LOW 0x06

128

#define LM90_REG_R_LOCAL_LOW 0x06

129

#define LM90_REG_W_LOCAL_LOW 0x0C

129

#define LM90_REG_W_LOCAL_LOW 0x0C

130

#define LM90_REG_R_LOCAL_CRIT 0x20

130

#define LM90_REG_R_LOCAL_CRIT 0x20

131

#define LM90_REG_W_LOCAL_CRIT 0x20

131

#define LM90_REG_W_LOCAL_CRIT 0x20

132

#define LM90_REG_R_REMOTE_TEMPH 0x01

132

#define LM90_REG_R_REMOTE_TEMPH 0x01

133

#define LM90_REG_R_REMOTE_TEMPL 0x10

133

#define LM90_REG_R_REMOTE_TEMPL 0x10

134

#define LM90_REG_R_REMOTE_OFFSH 0x11

134

#define LM90_REG_R_REMOTE_OFFSH 0x11

135

#define LM90_REG_W_REMOTE_OFFSH 0x11

135

#define LM90_REG_W_REMOTE_OFFSH 0x11

136

#define LM90_REG_R_REMOTE_OFFSL 0x12

136

#define LM90_REG_R_REMOTE_OFFSL 0x12

137

#define LM90_REG_W_REMOTE_OFFSL 0x12

137

#define LM90_REG_W_REMOTE_OFFSL 0x12

138

#define LM90_REG_R_REMOTE_HIGHH 0x07

138

#define LM90_REG_R_REMOTE_HIGHH 0x07

139

#define LM90_REG_W_REMOTE_HIGHH 0x0D

139

#define LM90_REG_W_REMOTE_HIGHH 0x0D

140

#define LM90_REG_R_REMOTE_HIGHL 0x13

140

#define LM90_REG_R_REMOTE_HIGHL 0x13

141

#define LM90_REG_W_REMOTE_HIGHL 0x13

141

#define LM90_REG_W_REMOTE_HIGHL 0x13

142

#define LM90_REG_R_REMOTE_LOWH 0x08

142

#define LM90_REG_R_REMOTE_LOWH 0x08

143

#define LM90_REG_W_REMOTE_LOWH 0x0E

143

#define LM90_REG_W_REMOTE_LOWH 0x0E

144

#define LM90_REG_R_REMOTE_LOWL 0x14

144

#define LM90_REG_R_REMOTE_LOWL 0x14

145

#define LM90_REG_W_REMOTE_LOWL 0x14

145

#define LM90_REG_W_REMOTE_LOWL 0x14

146

#define LM90_REG_R_REMOTE_CRIT 0x19

146

#define LM90_REG_R_REMOTE_CRIT 0x19

147

#define LM90_REG_W_REMOTE_CRIT 0x19

147

#define LM90_REG_W_REMOTE_CRIT 0x19

148

#define LM90_REG_R_TCRIT_HYST 0x21

148

#define LM90_REG_R_TCRIT_HYST 0x21

149

#define LM90_REG_W_TCRIT_HYST 0x21

149

#define LM90_REG_W_TCRIT_HYST 0x21

150

151

/* MAX6646/6647/6649/6657/6658/6659/6695/6696 registers */

151

/* MAX6646/6647/6649/6657/6658/6659/6695/6696 registers */

152

153

#define MAX6657_REG_R_LOCAL_TEMPL 0x11

153

#define MAX6657_REG_R_LOCAL_TEMPL 0x11

154

#define MAX6696_REG_R_STATUS2 0x12

154

#define MAX6696_REG_R_STATUS2 0x12

155

#define MAX6659_REG_R_REMOTE_EMERG 0x16

155

#define MAX6659_REG_R_REMOTE_EMERG 0x16

156

#define MAX6659_REG_W_REMOTE_EMERG 0x16

156

#define MAX6659_REG_W_REMOTE_EMERG 0x16

157

#define MAX6659_REG_R_LOCAL_EMERG 0x17

157

#define MAX6659_REG_R_LOCAL_EMERG 0x17

158

#define MAX6659_REG_W_LOCAL_EMERG 0x17

158

#define MAX6659_REG_W_LOCAL_EMERG 0x17

159

160

/* SA56004 registers */

160

/* SA56004 registers */

161

162

#define SA56004_REG_R_LOCAL_TEMPL 0x22

162

#define SA56004_REG_R_LOCAL_TEMPL 0x22

163

164

#define LM90_DEF_CONVRATE_RVAL 6 /* Def conversion rate register value */

164

#define LM90_DEF_CONVRATE_RVAL 6 /* Def conversion rate register value */

165

#define LM90_MAX_CONVRATE_MS 16000 /* Maximum conversion rate in ms */

165

#define LM90_MAX_CONVRATE_MS 16000 /* Maximum conversion rate in ms */

166

167

/*

167

/*

168

* Device flags

168

* Device flags

169

*/

169

*/

170

#define LM90_FLAG_ADT7461_EXT (1 << 0) /* ADT7461 extended mode */

170

#define LM90_FLAG_ADT7461_EXT (1 << 0) /* ADT7461 extended mode */

171

/* Device features */

171

/* Device features */

172

#define LM90_HAVE_OFFSET (1 << 1) /* temperature offset register */

172

#define LM90_HAVE_OFFSET (1 << 1) /* temperature offset register */

173

#define LM90_HAVE_REM_LIMIT_EXT (1 << 3) /* extended remote limit */

173

#define LM90_HAVE_REM_LIMIT_EXT (1 << 3) /* extended remote limit */

174

#define LM90_HAVE_EMERGENCY (1 << 4) /* 3rd upper (emergency) limit */

174

#define LM90_HAVE_EMERGENCY (1 << 4) /* 3rd upper (emergency) limit */

175

#define LM90_HAVE_EMERGENCY_ALARM (1 << 5)/* emergency alarm */

175

#define LM90_HAVE_EMERGENCY_ALARM (1 << 5)/* emergency alarm */

176

#define LM90_HAVE_TEMP3 (1 << 6) /* 3rd temperature sensor */

176

#define LM90_HAVE_TEMP3 (1 << 6) /* 3rd temperature sensor */

177

#define LM90_HAVE_BROKEN_ALERT (1 << 7) /* Broken alert */

177

#define LM90_HAVE_BROKEN_ALERT (1 << 7) /* Broken alert */

178

179

/*

179

/*

180

* Driver data (common to all clients)

180

* Driver data (common to all clients)

181

*/

181

*/

182

183

static const struct i2c_device_id lm90_id[] = {

183

static const struct i2c_device_id lm90_id[] = {

184

{ "adm1032", adm1032 },

184

{ "adm1032", adm1032 },

185

{ "adt7461", adt7461 },

185

{ "adt7461", adt7461 },

186

{ "adt7461a", adt7461 },

186

{ "adt7461a", adt7461 },

187

{ "lm90", lm90 },

187

{ "lm90", lm90 },

188

{ "lm86", lm86 },

188

{ "lm86", lm86 },

189

{ "lm89", lm86 },

189

{ "lm89", lm86 },

190

{ "lm99", lm99 },

190

{ "lm99", lm99 },

191

{ "max6646", max6646 },

191

{ "max6646", max6646 },

192

{ "max6647", max6646 },

192

{ "max6647", max6646 },

193

{ "max6649", max6646 },

193

{ "max6649", max6646 },

194

{ "max6657", max6657 },

194

{ "max6657", max6657 },

195

{ "max6658", max6657 },

195

{ "max6658", max6657 },

196

{ "max6659", max6659 },

196

{ "max6659", max6659 },

197

{ "max6680", max6680 },

197

{ "max6680", max6680 },

198

{ "max6681", max6680 },

198

{ "max6681", max6680 },

199

{ "max6695", max6696 },

199

{ "max6695", max6696 },

200

{ "max6696", max6696 },

200

{ "max6696", max6696 },

201

{ "nct1008", adt7461 },

201

{ "nct1008", adt7461 },

202

{ "w83l771", w83l771 },

202

{ "w83l771", w83l771 },

203

{ "sa56004", sa56004 },

203

{ "sa56004", sa56004 },

204

{ }

204

{ }

205

};

205

};

206

MODULE_DEVICE_TABLE(i2c, lm90_id);

206

MODULE_DEVICE_TABLE(i2c, lm90_id);

207

208

/*

208

/*

209

* chip type specific parameters

209

* chip type specific parameters

210

*/

210

*/

211

struct lm90_params {

211

struct lm90_params {

212

u32 flags; /* Capabilities */

212

u32 flags; /* Capabilities */

213

u16 alert_alarms; /* Which alarm bits trigger ALERT# */

213

u16 alert_alarms; /* Which alarm bits trigger ALERT# */

214

/* Upper 8 bits for max6695/96 */

214

/* Upper 8 bits for max6695/96 */

215

u8 max_convrate; /* Maximum conversion rate register value */

215

u8 max_convrate; /* Maximum conversion rate register value */

216

u8 reg_local_ext; /* Extended local temp register (optional) */

216

u8 reg_local_ext; /* Extended local temp register (optional) */

217

};

217

};

218

219

static const struct lm90_params lm90_params[] = {

219

static const struct lm90_params lm90_params[] = {

220

[adm1032] = {

220

[adm1032] = {

221

.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT

221

.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT

222

| LM90_HAVE_BROKEN_ALERT,

222

| LM90_HAVE_BROKEN_ALERT,

223

.alert_alarms = 0x7c,

223

.alert_alarms = 0x7c,

224

.max_convrate = 10,

224

.max_convrate = 10,

225

},

225

},

226

[adt7461] = {

226

[adt7461] = {

227

.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT

227

.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT

228

| LM90_HAVE_BROKEN_ALERT,

228

| LM90_HAVE_BROKEN_ALERT,

229

.alert_alarms = 0x7c,

229

.alert_alarms = 0x7c,

230

.max_convrate = 10,

230

.max_convrate = 10,

231

},

231

},

232

[lm86] = {

232

[lm86] = {

233

.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,

233

.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,

234

.alert_alarms = 0x7b,

234

.alert_alarms = 0x7b,

235

.max_convrate = 9,

235

.max_convrate = 9,

236

},

236

},

237

[lm90] = {

237

[lm90] = {

238

.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,

238

.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,

239

.alert_alarms = 0x7b,

239

.alert_alarms = 0x7b,

240

.max_convrate = 9,

240

.max_convrate = 9,

241

},

241

},

242

[lm99] = {

242

[lm99] = {

243

.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,

243

.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,

244

.alert_alarms = 0x7b,

244

.alert_alarms = 0x7b,

245

.max_convrate = 9,

245

.max_convrate = 9,

246

},

246

},

247

[max6646] = {

247

[max6646] = {

248

.alert_alarms = 0x7c,

248

.alert_alarms = 0x7c,

249

.max_convrate = 6,

249

.max_convrate = 6,

250

.reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,

250

.reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,

251

},

251

},

252

[max6657] = {

252

[max6657] = {

253

.alert_alarms = 0x7c,

253

.alert_alarms = 0x7c,

254

.max_convrate = 8,

254

.max_convrate = 8,

255

.reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,

255

.reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,

256

},

256

},

257

[max6659] = {

257

[max6659] = {

258

.flags = LM90_HAVE_EMERGENCY,

258

.flags = LM90_HAVE_EMERGENCY,

259

.alert_alarms = 0x7c,

259

.alert_alarms = 0x7c,

260

.max_convrate = 8,

260

.max_convrate = 8,

261

.reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,

261

.reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,

262

},

262

},

263

[max6680] = {

263

[max6680] = {

264

.flags = LM90_HAVE_OFFSET,

264

.flags = LM90_HAVE_OFFSET,

265

.alert_alarms = 0x7c,

265

.alert_alarms = 0x7c,

266

.max_convrate = 7,

266

.max_convrate = 7,

267

},

267

},

268

[max6696] = {

268

[max6696] = {

269

.flags = LM90_HAVE_EMERGENCY

269

.flags = LM90_HAVE_EMERGENCY

270

| LM90_HAVE_EMERGENCY_ALARM | LM90_HAVE_TEMP3,

270

| LM90_HAVE_EMERGENCY_ALARM | LM90_HAVE_TEMP3,

271

.alert_alarms = 0x187c,

271

.alert_alarms = 0x187c,

272

.max_convrate = 6,

272

.max_convrate = 6,

273

.reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,

273

.reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,

274

},

274

},

275

[w83l771] = {

275

[w83l771] = {

276

.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,

276

.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,

277

.alert_alarms = 0x7c,

277

.alert_alarms = 0x7c,

278

.max_convrate = 8,

278

.max_convrate = 8,

279

},

279

},

280

[sa56004] = {

280

[sa56004] = {

281

.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,

281

.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,

282

.alert_alarms = 0x7b,

282

.alert_alarms = 0x7b,

283

.max_convrate = 9,

283

.max_convrate = 9,

284

.reg_local_ext = SA56004_REG_R_LOCAL_TEMPL,

284

.reg_local_ext = SA56004_REG_R_LOCAL_TEMPL,

285

},

285

},

286

};

286

};

287

288

/*

288

/*

289

* Client data (each client gets its own)

289

* Client data (each client gets its own)

290

*/

290

*/

291

292

struct lm90_data {

292

struct lm90_data {

293

struct device *hwmon_dev;

293

struct device *hwmon_dev;

294

struct mutex update_lock;

294

struct mutex update_lock;

295

char valid; /* zero until following fields are valid */

295

char valid; /* zero until following fields are valid */

296

unsigned long last_updated; /* in jiffies */

296

unsigned long last_updated; /* in jiffies */

297

int kind;

297

int kind;

298

u32 flags;

298

u32 flags;

299

300

int update_interval; /* in milliseconds */

300

int update_interval; /* in milliseconds */

301

302

u8 config_orig; /* Original configuration register value */

302

u8 config_orig; /* Original configuration register value */

303

u8 convrate_orig; /* Original conversion rate register value */

303

u8 convrate_orig; /* Original conversion rate register value */

304

u16 alert_alarms; /* Which alarm bits trigger ALERT# */

304

u16 alert_alarms; /* Which alarm bits trigger ALERT# */

305

/* Upper 8 bits for max6695/96 */

305

/* Upper 8 bits for max6695/96 */

306

u8 max_convrate; /* Maximum conversion rate */

306

u8 max_convrate; /* Maximum conversion rate */

307

u8 reg_local_ext; /* local extension register offset */

307

u8 reg_local_ext; /* local extension register offset */

308

309

/* registers values */

309

/* registers values */

310

s8 temp8[8]; /* 0: local low limit

310

s8 temp8[8]; /* 0: local low limit

311

1: local high limit

311

1: local high limit

312

2: local critical limit

312

2: local critical limit

313

3: remote critical limit

313

3: remote critical limit

314

4: local emergency limit (max6659 and max6695/96)

314

4: local emergency limit (max6659 and max6695/96)

315

5: remote emergency limit (max6659 and max6695/96)

315

5: remote emergency limit (max6659 and max6695/96)

316

6: remote 2 critical limit (max6695/96 only)

316

6: remote 2 critical limit (max6695/96 only)

317

7: remote 2 emergency limit (max6695/96 only) */

317

7: remote 2 emergency limit (max6695/96 only) */

318

s16 temp11[8]; /* 0: remote input

318

s16 temp11[8]; /* 0: remote input

319

1: remote low limit

319

1: remote low limit

320

2: remote high limit

320

2: remote high limit

321

3: remote offset (except max6646, max6657/58/59,

321

3: remote offset (except max6646, max6657/58/59,

322

and max6695/96)

322

and max6695/96)

323

4: local input

323

4: local input

324

5: remote 2 input (max6695/96 only)

324

5: remote 2 input (max6695/96 only)

325

6: remote 2 low limit (max6695/96 only)

325

6: remote 2 low limit (max6695/96 only)

326

7: remote 2 high limit (ma6695/96 only) */

326

7: remote 2 high limit (ma6695/96 only) */

327

u8 temp_hyst;

327

u8 temp_hyst;

328

u16 alarms; /* bitvector (upper 8 bits for max6695/96) */

328

u16 alarms; /* bitvector (upper 8 bits for max6695/96) */

329

};

329

};

330

331

/*

331

/*

332

* Support functions

332

* Support functions

333

*/

333

*/

334

335

/*

335

/*

336

* The ADM1032 supports PEC but not on write byte transactions, so we need

336

* The ADM1032 supports PEC but not on write byte transactions, so we need

337

* to explicitly ask for a transaction without PEC.

337

* to explicitly ask for a transaction without PEC.

338

*/

338

*/

339

static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)

339

static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)

340

{

340

{

341

return i2c_smbus_xfer(client->adapter, client->addr,

341

return i2c_smbus_xfer(client->adapter, client->addr,

342

client->flags & ~I2C_CLIENT_PEC,

342

client->flags & ~I2C_CLIENT_PEC,

343

I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);

343

I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);

344

}

344

}

345

346

/*

346

/*

347

* It is assumed that client->update_lock is held (unless we are in

347

* It is assumed that client->update_lock is held (unless we are in

348

* detection or initialization steps). This matters when PEC is enabled,

348

* detection or initialization steps). This matters when PEC is enabled,

349

* because we don't want the address pointer to change between the write

349

* because we don't want the address pointer to change between the write

350

* byte and the read byte transactions.

350

* byte and the read byte transactions.

351

*/

351

*/

352

static int lm90_read_reg(struct i2c_client *client, u8 reg, u8 *value)

352

static int lm90_read_reg(struct i2c_client *client, u8 reg, u8 *value)

353

{

353

{

354

int err;

354

int err;

355

356

if (client->flags & I2C_CLIENT_PEC) {

356

if (client->flags & I2C_CLIENT_PEC) {

357

err = adm1032_write_byte(client, reg);

357

err = adm1032_write_byte(client, reg);

358

if (err >= 0)

358

if (err >= 0)

359

err = i2c_smbus_read_byte(client);

359

err = i2c_smbus_read_byte(client);

360

} else

360

} else

361

err = i2c_smbus_read_byte_data(client, reg);

361

err = i2c_smbus_read_byte_data(client, reg);

362

363

if (err < 0) {

363

if (err < 0) {

364

dev_warn(&client->dev, "Register %#02x read failed (%d)\n",

364

dev_warn(&client->dev, "Register %#02x read failed (%d)\n",

365

reg, err);

365

reg, err);

366

return err;

366

return err;

367

}

367

}

368

*value = err;

368

*value = err;

369

370

return 0;

370

return 0;

371

}

371

}

372

373

static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl, u16 *value)

373

static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl, u16 *value)

374

{

374

{

375

int err;

375

int err;

376

u8 oldh, newh, l;

376

u8 oldh, newh, l;

377

378

/*

378

/*

379

* There is a trick here. We have to read two registers to have the

379

* There is a trick here. We have to read two registers to have the

380

* sensor temperature, but we have to beware a conversion could occur

380

* sensor temperature, but we have to beware a conversion could occur

381

* between the readings. The datasheet says we should either use

381

* between the readings. The datasheet says we should either use

382

* the one-shot conversion register, which we don't want to do

382

* the one-shot conversion register, which we don't want to do

383

* (disables hardware monitoring) or monitor the busy bit, which is

383

* (disables hardware monitoring) or monitor the busy bit, which is

384

* impossible (we can't read the values and monitor that bit at the

384

* impossible (we can't read the values and monitor that bit at the

385

* exact same time). So the solution used here is to read the high

385

* exact same time). So the solution used here is to read the high

386

* byte once, then the low byte, then the high byte again. If the new

386

* byte once, then the low byte, then the high byte again. If the new

387

* high byte matches the old one, then we have a valid reading. Else

387

* high byte matches the old one, then we have a valid reading. Else

388

* we have to read the low byte again, and now we believe we have a

388

* we have to read the low byte again, and now we believe we have a

389

* correct reading.

389

* correct reading.

390

*/

390

*/

391

if ((err = lm90_read_reg(client, regh, &oldh))

391

if ((err = lm90_read_reg(client, regh, &oldh))

392

|| (err = lm90_read_reg(client, regl, &l))

392

|| (err = lm90_read_reg(client, regl, &l))

393

|| (err = lm90_read_reg(client, regh, &newh)))

393

|| (err = lm90_read_reg(client, regh, &newh)))

394

return err;

394

return err;

395

if (oldh != newh) {

395

if (oldh != newh) {

396

err = lm90_read_reg(client, regl, &l);

396

err = lm90_read_reg(client, regl, &l);

397

if (err)

397

if (err)

398

return err;

398

return err;

399

}

399

}

400

*value = (newh << 8) | l;

400

*value = (newh << 8) | l;

401

402

return 0;

402

return 0;

403

}

403

}

404

405

/*

405

/*

406

* client->update_lock must be held when calling this function (unless we are

406

* client->update_lock must be held when calling this function (unless we are

407

* in detection or initialization steps), and while a remote channel other

407

* in detection or initialization steps), and while a remote channel other

408

* than channel 0 is selected. Also, calling code must make sure to re-select

408

* than channel 0 is selected. Also, calling code must make sure to re-select

409

* external channel 0 before releasing the lock. This is necessary because

409

* external channel 0 before releasing the lock. This is necessary because

410

* various registers have different meanings as a result of selecting a

410

* various registers have different meanings as a result of selecting a

411

* non-default remote channel.

411

* non-default remote channel.

412

*/

412

*/

413

static inline void lm90_select_remote_channel(struct i2c_client *client,

413

static inline void lm90_select_remote_channel(struct i2c_client *client,

414

struct lm90_data *data,

414

struct lm90_data *data,

415

int channel)

415

int channel)

416

{

416

{

417

u8 config;

417

u8 config;

418

419

if (data->kind == max6696) {

419

if (data->kind == max6696) {

420

lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);

420

lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);

421

config &= ~0x08;

421

config &= ~0x08;

422

if (channel)

422

if (channel)

423

config |= 0x08;

423

config |= 0x08;

424

i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,

424

i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,

425

config);

425

config);

426

}

426

}

427

}

427

}

428

429

/*

429

/*

430

* Set conversion rate.

430

* Set conversion rate.

431

* client->update_lock must be held when calling this function (unless we are

431

* client->update_lock must be held when calling this function (unless we are

432

* in detection or initialization steps).

432

* in detection or initialization steps).

433

*/

433

*/

434

static void lm90_set_convrate(struct i2c_client *client, struct lm90_data *data,

434

static void lm90_set_convrate(struct i2c_client *client, struct lm90_data *data,

435

unsigned int interval)

435

unsigned int interval)

436

{

436

{

437

int i;

437

int i;

438

unsigned int update_interval;

438

unsigned int update_interval;

439

440

/* Shift calculations to avoid rounding errors */

440

/* Shift calculations to avoid rounding errors */

441

interval <<= 6;

441

interval <<= 6;

442

443

/* find the nearest update rate */

443

/* find the nearest update rate */

444

for (i = 0, update_interval = LM90_MAX_CONVRATE_MS << 6;

444

for (i = 0, update_interval = LM90_MAX_CONVRATE_MS << 6;

445

i < data->max_convrate; i++, update_interval >>= 1)

445

i < data->max_convrate; i++, update_interval >>= 1)

446

if (interval >= update_interval * 3 / 4)

446

if (interval >= update_interval * 3 / 4)

447

break;

447

break;

448

449

i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE, i);

449

i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE, i);

450

data->update_interval = DIV_ROUND_CLOSEST(update_interval, 64);

450

data->update_interval = DIV_ROUND_CLOSEST(update_interval, 64);

451

}

451

}

452

453

static struct lm90_data *lm90_update_device(struct device *dev)

453

static struct lm90_data *lm90_update_device(struct device *dev)

454

{

454

{

455

struct i2c_client *client = to_i2c_client(dev);

455

struct i2c_client *client = to_i2c_client(dev);

456

struct lm90_data *data = i2c_get_clientdata(client);

456

struct lm90_data *data = i2c_get_clientdata(client);

457

unsigned long next_update;

457

unsigned long next_update;

458

459

mutex_lock(&data->update_lock);

459

mutex_lock(&data->update_lock);

460

461

next_update = data->last_updated

461

next_update = data->last_updated

462

+ msecs_to_jiffies(data->update_interval) + 1;

462

+ msecs_to_jiffies(data->update_interval) + 1;

463

if (time_after(jiffies, next_update) || !data->valid) {

463

if (time_after(jiffies, next_update) || !data->valid) {

464

u8 h, l;

464

u8 h, l;

465

u8 alarms;

465

u8 alarms;

466

467

dev_dbg(&client->dev, "Updating lm90 data.\n");

467

dev_dbg(&client->dev, "Updating lm90 data.\n");

468

lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[0]);

468

lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[0]);

469

lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[1]);

469

lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[1]);

470

lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[2]);

470

lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[2]);

471

lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);

471

lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);

472

lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);

472

lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);

473

474

if (data->reg_local_ext) {

474

if (data->reg_local_ext) {

475

lm90_read16(client, LM90_REG_R_LOCAL_TEMP,

475

lm90_read16(client, LM90_REG_R_LOCAL_TEMP,

476

data->reg_local_ext,

476

data->reg_local_ext,

477

&data->temp11[4]);

477

&data->temp11[4]);

478

} else {

478

} else {

479

if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,

479

if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,

480

&h) == 0)

480

&h) == 0)

481

data->temp11[4] = h << 8;

481

data->temp11[4] = h << 8;

482

}

482

}

483

lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,

483

lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,

484

LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);

484

LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);

485

486

if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) {

486

if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) {

487

data->temp11[1] = h << 8;

487

data->temp11[1] = h << 8;

488

if ((data->flags & LM90_HAVE_REM_LIMIT_EXT)

488

if ((data->flags & LM90_HAVE_REM_LIMIT_EXT)

489

&& lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL,

489

&& lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL,

490

&l) == 0)

490

&l) == 0)

491

data->temp11[1] |= l;

491

data->temp11[1] |= l;

492

}

492

}

493

if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0) {

493

if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0) {

494

data->temp11[2] = h << 8;

494

data->temp11[2] = h << 8;

495

if ((data->flags & LM90_HAVE_REM_LIMIT_EXT)

495

if ((data->flags & LM90_HAVE_REM_LIMIT_EXT)

496

&& lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL,

496

&& lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL,

497

&l) == 0)

497

&l) == 0)

498

data->temp11[2] |= l;

498

data->temp11[2] |= l;

499

}

499

}

500

501

if (data->flags & LM90_HAVE_OFFSET) {

501

if (data->flags & LM90_HAVE_OFFSET) {

502

if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,

502

if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,

503

&h) == 0

503

&h) == 0

504

&& lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,

504

&& lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,

505

&l) == 0)

505

&l) == 0)

506

data->temp11[3] = (h << 8) | l;

506

data->temp11[3] = (h << 8) | l;

507

}

507

}

508

if (data->flags & LM90_HAVE_EMERGENCY) {

508

if (data->flags & LM90_HAVE_EMERGENCY) {

509

lm90_read_reg(client, MAX6659_REG_R_LOCAL_EMERG,

509

lm90_read_reg(client, MAX6659_REG_R_LOCAL_EMERG,

510

&data->temp8[4]);

510

&data->temp8[4]);

511

lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG,

511

lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG,

512

&data->temp8[5]);

512

&data->temp8[5]);

513

}

513

}

514

lm90_read_reg(client, LM90_REG_R_STATUS, &alarms);

514

lm90_read_reg(client, LM90_REG_R_STATUS, &alarms);

515

data->alarms = alarms; /* save as 16 bit value */

515

data->alarms = alarms; /* save as 16 bit value */

516

517

if (data->kind == max6696) {

517

if (data->kind == max6696) {

518

lm90_select_remote_channel(client, data, 1);

518

lm90_select_remote_channel(client, data, 1);

519

lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT,

519

lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT,

520

&data->temp8[6]);

520

&data->temp8[6]);

521

lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG,

521

lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG,

522

&data->temp8[7]);

522

&data->temp8[7]);

523

lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,

523

lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,

524

LM90_REG_R_REMOTE_TEMPL, &data->temp11[5]);

524

LM90_REG_R_REMOTE_TEMPL, &data->temp11[5]);

525

if (!lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h))

525

if (!lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h))

526

data->temp11[6] = h << 8;

526

data->temp11[6] = h << 8;

527

if (!lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h))

527

if (!lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h))

528

data->temp11[7] = h << 8;

528

data->temp11[7] = h << 8;

529

lm90_select_remote_channel(client, data, 0);

529

lm90_select_remote_channel(client, data, 0);

530

531

if (!lm90_read_reg(client, MAX6696_REG_R_STATUS2,

531

if (!lm90_read_reg(client, MAX6696_REG_R_STATUS2,

532

&alarms))

532

&alarms))

533

data->alarms |= alarms << 8;

533

data->alarms |= alarms << 8;

534

}

534

}

535

536

/* Re-enable ALERT# output if it was originally enabled and

536

/* Re-enable ALERT# output if it was originally enabled and

537

* relevant alarms are all clear */

537

* relevant alarms are all clear */

538

if ((data->config_orig & 0x80) == 0

538

if ((data->config_orig & 0x80) == 0

539

&& (data->alarms & data->alert_alarms) == 0) {

539

&& (data->alarms & data->alert_alarms) == 0) {

540

u8 config;

540

u8 config;

541

542

lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);

542

lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);

543

if (config & 0x80) {

543

if (config & 0x80) {

544

dev_dbg(&client->dev, "Re-enabling ALERT#\n");

544

dev_dbg(&client->dev, "Re-enabling ALERT#\n");

545

i2c_smbus_write_byte_data(client,

545

i2c_smbus_write_byte_data(client,

546

LM90_REG_W_CONFIG1,

546

LM90_REG_W_CONFIG1,

547

config & ~0x80);

547

config & ~0x80);

548

}

548

}

549

}

549

}

550

551

data->last_updated = jiffies;

551

data->last_updated = jiffies;

552

data->valid = 1;

552

data->valid = 1;

553

}

553

}

554

555

mutex_unlock(&data->update_lock);

555

mutex_unlock(&data->update_lock);

556

557

return data;

557

return data;

558

}

558

}

559

560

/*

560

/*

561

* Conversions

561

* Conversions

562

* For local temperatures and limits, critical limits and the hysteresis

562

* For local temperatures and limits, critical limits and the hysteresis

563

* value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.

563

* value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.

564

* For remote temperatures and limits, it uses signed 11-bit values with

564

* For remote temperatures and limits, it uses signed 11-bit values with

565

* LSB = 0.125 degree Celsius, left-justified in 16-bit registers. Some

565

* LSB = 0.125 degree Celsius, left-justified in 16-bit registers. Some

566

* Maxim chips use unsigned values.

566

* Maxim chips use unsigned values.

567

*/

567

*/

568

569

static inline int temp_from_s8(s8 val)

569

static inline int temp_from_s8(s8 val)

570

{

570

{

571

return val * 1000;

571

return val * 1000;

572

}

572

}

573

574

static inline int temp_from_u8(u8 val)

574

static inline int temp_from_u8(u8 val)

575

{

575

{

576

return val * 1000;

576

return val * 1000;

577

}

577

}

578

579

static inline int temp_from_s16(s16 val)

579

static inline int temp_from_s16(s16 val)

580

{

580

{

581

return val / 32 * 125;

581

return val / 32 * 125;

582

}

582

}

583

584

static inline int temp_from_u16(u16 val)

584

static inline int temp_from_u16(u16 val)

585

{

585

{

586

return val / 32 * 125;

586

return val / 32 * 125;

587

}

587

}

588

589

static s8 temp_to_s8(long val)

589

static s8 temp_to_s8(long val)

590

{

590

{

591

if (val <= -128000)

591

if (val <= -128000)

592

return -128;

592

return -128;

593

if (val >= 127000)

593

if (val >= 127000)

594

return 127;

594

return 127;

595

if (val < 0)

595

if (val < 0)

596

return (val - 500) / 1000;

596

return (val - 500) / 1000;

597

return (val + 500) / 1000;

597

return (val + 500) / 1000;

598

}

598

}

599

600

static u8 temp_to_u8(long val)

600

static u8 temp_to_u8(long val)

601

{

601

{

602

if (val <= 0)

602

if (val <= 0)

603

return 0;

603

return 0;

604

if (val >= 255000)

604

if (val >= 255000)

605

return 255;

605

return 255;

606

return (val + 500) / 1000;

606

return (val + 500) / 1000;

607

}

607

}

608

609

static s16 temp_to_s16(long val)

609

static s16 temp_to_s16(long val)

610

{

610

{

611

if (val <= -128000)

611

if (val <= -128000)

612

return 0x8000;

612

return 0x8000;

613

if (val >= 127875)

613

if (val >= 127875)

614

return 0x7FE0;

614

return 0x7FE0;

615

if (val < 0)

615

if (val < 0)

616

return (val - 62) / 125 * 32;

616

return (val - 62) / 125 * 32;

617

return (val + 62) / 125 * 32;

617

return (val + 62) / 125 * 32;

618

}

618

}

619

620

static u8 hyst_to_reg(long val)

620

static u8 hyst_to_reg(long val)

621

{

621

{

622

if (val <= 0)

622

if (val <= 0)

623

return 0;

623

return 0;

624

if (val >= 30500)

624

if (val >= 30500)

625

return 31;

625

return 31;

626

return (val + 500) / 1000;

626

return (val + 500) / 1000;

627

}

627

}

628

629

/*

629

/*

630

* ADT7461 in compatibility mode is almost identical to LM90 except that

630

* ADT7461 in compatibility mode is almost identical to LM90 except that

631

* attempts to write values that are outside the range 0 < temp < 127 are

631

* attempts to write values that are outside the range 0 < temp < 127 are

632

* treated as the boundary value.

632

* treated as the boundary value.

633

*

633

*

634

* ADT7461 in "extended mode" operation uses unsigned integers offset by

634

* ADT7461 in "extended mode" operation uses unsigned integers offset by

635

* 64 (e.g., 0 -> -64 degC). The range is restricted to -64..191 degC.

635

* 64 (e.g., 0 -> -64 degC). The range is restricted to -64..191 degC.

636

*/

636

*/

637

static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val)

637

static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val)

638

{

638

{

639

if (data->flags & LM90_FLAG_ADT7461_EXT)

639

if (data->flags & LM90_FLAG_ADT7461_EXT)

640

return (val - 64) * 1000;

640

return (val - 64) * 1000;

641

else

641

else

642

return temp_from_s8(val);

642

return temp_from_s8(val);

643

}

643

}

644

645

static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val)

645

static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val)

646

{

646

{

647

if (data->flags & LM90_FLAG_ADT7461_EXT)

647

if (data->flags & LM90_FLAG_ADT7461_EXT)

648

return (val - 0x4000) / 64 * 250;

648

return (val - 0x4000) / 64 * 250;

649

else

649

else

650

return temp_from_s16(val);

650

return temp_from_s16(val);

651

}

651

}

652

653

static u8 temp_to_u8_adt7461(struct lm90_data *data, long val)

653

static u8 temp_to_u8_adt7461(struct lm90_data *data, long val)

654

{

654

{

655

if (data->flags & LM90_FLAG_ADT7461_EXT) {

655

if (data->flags & LM90_FLAG_ADT7461_EXT) {

656

if (val <= -64000)

656

if (val <= -64000)

657

return 0;

657

return 0;

658

if (val >= 191000)

658

if (val >= 191000)

659

return 0xFF;

659

return 0xFF;

660

return (val + 500 + 64000) / 1000;

660

return (val + 500 + 64000) / 1000;

661

} else {

661

} else {

662

if (val <= 0)

662

if (val <= 0)

663

return 0;

663

return 0;

664

if (val >= 127000)

664

if (val >= 127000)

665

return 127;

665

return 127;

666

return (val + 500) / 1000;

666

return (val + 500) / 1000;

667

}

667

}

668

}

668

}

669

670

static u16 temp_to_u16_adt7461(struct lm90_data *data, long val)

670

static u16 temp_to_u16_adt7461(struct lm90_data *data, long val)

671

{

671

{

672

if (data->flags & LM90_FLAG_ADT7461_EXT) {

672

if (data->flags & LM90_FLAG_ADT7461_EXT) {

673

if (val <= -64000)

673

if (val <= -64000)

674

return 0;

674

return 0;

675

if (val >= 191750)

675

if (val >= 191750)

676

return 0xFFC0;

676

return 0xFFC0;

677

return (val + 64000 + 125) / 250 * 64;

677

return (val + 64000 + 125) / 250 * 64;

678

} else {

678

} else {

679

if (val <= 0)

679

if (val <= 0)

680

return 0;

680

return 0;

681

if (val >= 127750)

681

if (val >= 127750)

682

return 0x7FC0;

682

return 0x7FC0;

683

return (val + 125) / 250 * 64;

683

return (val + 125) / 250 * 64;

684

}

684

}

685

}

685

}

686

687

/*

687

/*

688

* Sysfs stuff

688

* Sysfs stuff

689

*/

689

*/

690

691

static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,

691

static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,

692

char *buf)

692

char *buf)

693

{

693

{

694

struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

694

struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

695

struct lm90_data *data = lm90_update_device(dev);

695

struct lm90_data *data = lm90_update_device(dev);

696

int temp;

696

int temp;

697

698

if (data->kind == adt7461)

698

if (data->kind == adt7461)

699

temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);

699

temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);

700

else if (data->kind == max6646)

700

else if (data->kind == max6646)

701

temp = temp_from_u8(data->temp8[attr->index]);

701

temp = temp_from_u8(data->temp8[attr->index]);

702

else

702

else

703

temp = temp_from_s8(data->temp8[attr->index]);

703

temp = temp_from_s8(data->temp8[attr->index]);

704

705

/* +16 degrees offset for temp2 for the LM99 */

705

/* +16 degrees offset for temp2 for the LM99 */

706

if (data->kind == lm99 && attr->index == 3)

706

if (data->kind == lm99 && attr->index == 3)

707

temp += 16000;

707

temp += 16000;

708

709

return sprintf(buf, "%d\n", temp);

709

return sprintf(buf, "%d\n", temp);

710

}

710

}

711

712

static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,

712

static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,

713

const char *buf, size_t count)

713

const char *buf, size_t count)

714

{

714

{

715

static const u8 reg[8] = {

715

static const u8 reg[8] = {

716

LM90_REG_W_LOCAL_LOW,

716

LM90_REG_W_LOCAL_LOW,

717

LM90_REG_W_LOCAL_HIGH,

717

LM90_REG_W_LOCAL_HIGH,

718

LM90_REG_W_LOCAL_CRIT,

718

LM90_REG_W_LOCAL_CRIT,

719

LM90_REG_W_REMOTE_CRIT,

719

LM90_REG_W_REMOTE_CRIT,

720

MAX6659_REG_W_LOCAL_EMERG,

720

MAX6659_REG_W_LOCAL_EMERG,

721

MAX6659_REG_W_REMOTE_EMERG,

721

MAX6659_REG_W_REMOTE_EMERG,

722

LM90_REG_W_REMOTE_CRIT,

722

LM90_REG_W_REMOTE_CRIT,

723

MAX6659_REG_W_REMOTE_EMERG,

723

MAX6659_REG_W_REMOTE_EMERG,

724

};

724

};

725

726

struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

726

struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

727

struct i2c_client *client = to_i2c_client(dev);

727

struct i2c_client *client = to_i2c_client(dev);

728

struct lm90_data *data = i2c_get_clientdata(client);

728

struct lm90_data *data = i2c_get_clientdata(client);

729

int nr = attr->index;

729

int nr = attr->index;

730

long val;

730

long val;

731

int err;

731

int err;

732

733

err = kstrtol(buf, 10, &val);

733

err = kstrtol(buf, 10, &val);

734

if (err < 0)

734

if (err < 0)

735

return err;

735

return err;

736

737

/* +16 degrees offset for temp2 for the LM99 */

737

/* +16 degrees offset for temp2 for the LM99 */

738

if (data->kind == lm99 && attr->index == 3)

738

if (data->kind == lm99 && attr->index == 3)

739

val -= 16000;

739

val -= 16000;

740

741

mutex_lock(&data->update_lock);

741

mutex_lock(&data->update_lock);

742

if (data->kind == adt7461)

742

if (data->kind == adt7461)

743

data->temp8[nr] = temp_to_u8_adt7461(data, val);

743

data->temp8[nr] = temp_to_u8_adt7461(data, val);

744

else if (data->kind == max6646)

744

else if (data->kind == max6646)

745

data->temp8[nr] = temp_to_u8(val);

745

data->temp8[nr] = temp_to_u8(val);

746

else

746

else

747

data->temp8[nr] = temp_to_s8(val);

747

data->temp8[nr] = temp_to_s8(val);

748

749

lm90_select_remote_channel(client, data, nr >= 6);

749

lm90_select_remote_channel(client, data, nr >= 6);

750

i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]);

750

i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]);

751

lm90_select_remote_channel(client, data, 0);

751

lm90_select_remote_channel(client, data, 0);

752

753

mutex_unlock(&data->update_lock);

753

mutex_unlock(&data->update_lock);

754

return count;

754

return count;

755

}

755

}

756

757

static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,

757

static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,

758

char *buf)

758

char *buf)

759

{

759

{

760

struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);

760

struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);

761

struct lm90_data *data = lm90_update_device(dev);

761

struct lm90_data *data = lm90_update_device(dev);

762

int temp;

762

int temp;

763

764

if (data->kind == adt7461)

764

if (data->kind == adt7461)

765

temp = temp_from_u16_adt7461(data, data->temp11[attr->index]);

765

temp = temp_from_u16_adt7461(data, data->temp11[attr->index]);

766

else if (data->kind == max6646)

766

else if (data->kind == max6646)

767

temp = temp_from_u16(data->temp11[attr->index]);

767

temp = temp_from_u16(data->temp11[attr->index]);

768

else

768

else

769

temp = temp_from_s16(data->temp11[attr->index]);

769

temp = temp_from_s16(data->temp11[attr->index]);

770

771

/* +16 degrees offset for temp2 for the LM99 */

771

/* +16 degrees offset for temp2 for the LM99 */

772

if (data->kind == lm99 && attr->index <= 2)

772

if (data->kind == lm99 && attr->index <= 2)

773

temp += 16000;

773

temp += 16000;

774

775

return sprintf(buf, "%d\n", temp);

775

return sprintf(buf, "%d\n", temp);

776

}

776

}

777

778

static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,

778

static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,

779

const char *buf, size_t count)

779

const char *buf, size_t count)

780

{

780

{

781

struct {

781

struct {

782

u8 high;

782

u8 high;

783

u8 low;

783

u8 low;

784

int channel;

784

int channel;

785

} reg[5] = {

785

} reg[5] = {

786

{ LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL, 0 },

786

{ LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL, 0 },

787

{ LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL, 0 },

787

{ LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL, 0 },

788

{ LM90_REG_W_REMOTE_OFFSH, LM90_REG_W_REMOTE_OFFSL, 0 },

788

{ LM90_REG_W_REMOTE_OFFSH, LM90_REG_W_REMOTE_OFFSL, 0 },

789

{ LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL, 1 },

789

{ LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL, 1 },

790

{ LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL, 1 }

790

{ LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL, 1 }

791

};

791

};

792

793

struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);

793

struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);

794

struct i2c_client *client = to_i2c_client(dev);

794

struct i2c_client *client = to_i2c_client(dev);

795

struct lm90_data *data = i2c_get_clientdata(client);

795

struct lm90_data *data = i2c_get_clientdata(client);

796

int nr = attr->nr;

796

int nr = attr->nr;

797

int index = attr->index;

797

int index = attr->index;

798

long val;

798

long val;

799

int err;

799

int err;

800

801

err = kstrtol(buf, 10, &val);

801

err = kstrtol(buf, 10, &val);

802

if (err < 0)

802

if (err < 0)

803

return err;

803

return err;

804

805

/* +16 degrees offset for temp2 for the LM99 */

805

/* +16 degrees offset for temp2 for the LM99 */

806

if (data->kind == lm99 && index <= 2)

806

if (data->kind == lm99 && index <= 2)

807

val -= 16000;

807

val -= 16000;

808

809

mutex_lock(&data->update_lock);

809

mutex_lock(&data->update_lock);

810

if (data->kind == adt7461)

810

if (data->kind == adt7461)

811

data->temp11[index] = temp_to_u16_adt7461(data, val);

811

data->temp11[index] = temp_to_u16_adt7461(data, val);

812

else if (data->kind == max6646)

812

else if (data->kind == max6646)

813

data->temp11[index] = temp_to_u8(val) << 8;

813

data->temp11[index] = temp_to_u8(val) << 8;

814

else if (data->flags & LM90_HAVE_REM_LIMIT_EXT)

814

else if (data->flags & LM90_HAVE_REM_LIMIT_EXT)

815

data->temp11[index] = temp_to_s16(val);

815

data->temp11[index] = temp_to_s16(val);

816

else

816

else

817

data->temp11[index] = temp_to_s8(val) << 8;

817

data->temp11[index] = temp_to_s8(val) << 8;

818

819

lm90_select_remote_channel(client, data, reg[nr].channel);

819

lm90_select_remote_channel(client, data, reg[nr].channel);

820

i2c_smbus_write_byte_data(client, reg[nr].high,

820

i2c_smbus_write_byte_data(client, reg[nr].high,

821

data->temp11[index] >> 8);

821

data->temp11[index] >> 8);

822

if (data->flags & LM90_HAVE_REM_LIMIT_EXT)

822

if (data->flags & LM90_HAVE_REM_LIMIT_EXT)

823

i2c_smbus_write_byte_data(client, reg[nr].low,

823

i2c_smbus_write_byte_data(client, reg[nr].low,

824

data->temp11[index] & 0xff);

824

data->temp11[index] & 0xff);

825

lm90_select_remote_channel(client, data, 0);

825

lm90_select_remote_channel(client, data, 0);

826

827

mutex_unlock(&data->update_lock);

827

mutex_unlock(&data->update_lock);

828

return count;

828

return count;

829

}

829

}

830

831

static ssize_t show_temphyst(struct device *dev,

831

static ssize_t show_temphyst(struct device *dev,

832

struct device_attribute *devattr,

832

struct device_attribute *devattr,

833

char *buf)

833

char *buf)

834

{

834

{

835

struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

835

struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

836

struct lm90_data *data = lm90_update_device(dev);

836

struct lm90_data *data = lm90_update_device(dev);

837

int temp;

837

int temp;

838

839

if (data->kind == adt7461)

839

if (data->kind == adt7461)

840

temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);

840

temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);

841

else if (data->kind == max6646)

841

else if (data->kind == max6646)

842

temp = temp_from_u8(data->temp8[attr->index]);

842

temp = temp_from_u8(data->temp8[attr->index]);

843

else

843

else

844

temp = temp_from_s8(data->temp8[attr->index]);

844

temp = temp_from_s8(data->temp8[attr->index]);

845

846

/* +16 degrees offset for temp2 for the LM99 */

846

/* +16 degrees offset for temp2 for the LM99 */

847

if (data->kind == lm99 && attr->index == 3)

847

if (data->kind == lm99 && attr->index == 3)

848

temp += 16000;

848

temp += 16000;

849

850

return sprintf(buf, "%d\n", temp - temp_from_s8(data->temp_hyst));

850

return sprintf(buf, "%d\n", temp - temp_from_s8(data->temp_hyst));

851

}

851

}

852

853

static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,

853

static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,

854

const char *buf, size_t count)

854

const char *buf, size_t count)

855

{

855

{

856

struct i2c_client *client = to_i2c_client(dev);

856

struct i2c_client *client = to_i2c_client(dev);

857

struct lm90_data *data = i2c_get_clientdata(client);

857

struct lm90_data *data = i2c_get_clientdata(client);

858

long val;

858

long val;

859

int err;

859

int err;

860

int temp;

860

int temp;

861

862

err = kstrtol(buf, 10, &val);

862

err = kstrtol(buf, 10, &val);

863

if (err < 0)

863

if (err < 0)

864

return err;

864

return err;

865

866

mutex_lock(&data->update_lock);

866

mutex_lock(&data->update_lock);

867

if (data->kind == adt7461)

867

if (data->kind == adt7461)

868

temp = temp_from_u8_adt7461(data, data->temp8[2]);

868

temp = temp_from_u8_adt7461(data, data->temp8[2]);

869

else if (data->kind == max6646)

869

else if (data->kind == max6646)

870

temp = temp_from_u8(data->temp8[2]);

870

temp = temp_from_u8(data->temp8[2]);

871

else

871

else

872

temp = temp_from_s8(data->temp8[2]);

872

temp = temp_from_s8(data->temp8[2]);

873

874

data->temp_hyst = hyst_to_reg(temp - val);

874

data->temp_hyst = hyst_to_reg(temp - val);

875

i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,

875

i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,

876

data->temp_hyst);

876

data->temp_hyst);

877

mutex_unlock(&data->update_lock);

877

mutex_unlock(&data->update_lock);

878

return count;

878

return count;

879

}

879

}

880

881

static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,

881

static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,

882

char *buf)

882

char *buf)

883

{

883

{

884

struct lm90_data *data = lm90_update_device(dev);

884

struct lm90_data *data = lm90_update_device(dev);

885

return sprintf(buf, "%d\n", data->alarms);

885

return sprintf(buf, "%d\n", data->alarms);

886

}

886

}

887

888

static ssize_t show_alarm(struct device *dev, struct device_attribute

888

static ssize_t show_alarm(struct device *dev, struct device_attribute

889

*devattr, char *buf)

889

*devattr, char *buf)

890

{

890

{

891

struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

891

struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

892

struct lm90_data *data = lm90_update_device(dev);

892

struct lm90_data *data = lm90_update_device(dev);

893

int bitnr = attr->index;

893

int bitnr = attr->index;

894

895

return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);

895

return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);

896

}

896

}

897

898

static ssize_t show_update_interval(struct device *dev,

898

static ssize_t show_update_interval(struct device *dev,

899

struct device_attribute *attr, char *buf)

899

struct device_attribute *attr, char *buf)

900

{

900

{

901

struct lm90_data *data = dev_get_drvdata(dev);

901

struct lm90_data *data = dev_get_drvdata(dev);

902

903

return sprintf(buf, "%u\n", data->update_interval);

903

return sprintf(buf, "%u\n", data->update_interval);

904

}

904

}

905

906

static ssize_t set_update_interval(struct device *dev,

906

static ssize_t set_update_interval(struct device *dev,

907

struct device_attribute *attr,

907

struct device_attribute *attr,

908

const char *buf, size_t count)

908

const char *buf, size_t count)

909

{

909

{

910

struct i2c_client *client = to_i2c_client(dev);

910

struct i2c_client *client = to_i2c_client(dev);

911

struct lm90_data *data = i2c_get_clientdata(client);

911

struct lm90_data *data = i2c_get_clientdata(client);

912

unsigned long val;

912

unsigned long val;

913

int err;

913

int err;

914

915

err = kstrtoul(buf, 10, &val);

915

err = kstrtoul(buf, 10, &val);

916

if (err)

916

if (err)

917

return err;

917

return err;

918

919

mutex_lock(&data->update_lock);

919

mutex_lock(&data->update_lock);

920

lm90_set_convrate(client, data, val);

920

lm90_set_convrate(client, data, SENSORS_LIMIT(val, 0, 100000));

921

mutex_unlock(&data->update_lock);

921

mutex_unlock(&data->update_lock);

922

923

return count;

923

return count;

924

}

924

}

925

926

static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp11, NULL, 0, 4);

926

static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp11, NULL, 0, 4);

927

static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp11, NULL, 0, 0);

927

static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp11, NULL, 0, 0);

928

static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,

928

static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,

929

set_temp8, 0);

929

set_temp8, 0);

930

static SENSOR_DEVICE_ATTR_2(temp2_min, S_IWUSR | S_IRUGO, show_temp11,

930

static SENSOR_DEVICE_ATTR_2(temp2_min, S_IWUSR | S_IRUGO, show_temp11,

931

set_temp11, 0, 1);

931

set_temp11, 0, 1);

932

static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,

932

static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,

933

set_temp8, 1);

933

set_temp8, 1);

934

static SENSOR_DEVICE_ATTR_2(temp2_max, S_IWUSR | S_IRUGO, show_temp11,

934

static SENSOR_DEVICE_ATTR_2(temp2_max, S_IWUSR | S_IRUGO, show_temp11,

935

set_temp11, 1, 2);

935

set_temp11, 1, 2);

936

static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,

936

static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,

937

set_temp8, 2);

937

set_temp8, 2);

938

static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,

938

static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,

939

set_temp8, 3);

939

set_temp8, 3);

940

static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,

940

static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,

941

set_temphyst, 2);

941

set_temphyst, 2);

942

static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);

942

static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);

943

static SENSOR_DEVICE_ATTR_2(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,

943

static SENSOR_DEVICE_ATTR_2(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,

944

set_temp11, 2, 3);

944

set_temp11, 2, 3);

945

946

/* Individual alarm files */

946

/* Individual alarm files */

947

static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);

947

static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);

948

static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);

948

static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);

949

static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);

949

static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);

950

static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);

950

static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);

951

static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);

951

static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);

952

static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);

952

static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);

953

static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);

953

static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);

954

/* Raw alarm file for compatibility */

954

/* Raw alarm file for compatibility */

955

static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);

955

static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);

956

957

static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,

957

static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,

958

set_update_interval);

958

set_update_interval);

959

960

static struct attribute *lm90_attributes[] = {

960

static struct attribute *lm90_attributes[] = {

961

&sensor_dev_attr_temp1_input.dev_attr.attr,

961

&sensor_dev_attr_temp1_input.dev_attr.attr,

962

&sensor_dev_attr_temp2_input.dev_attr.attr,

962

&sensor_dev_attr_temp2_input.dev_attr.attr,

963

&sensor_dev_attr_temp1_min.dev_attr.attr,

963

&sensor_dev_attr_temp1_min.dev_attr.attr,

964

&sensor_dev_attr_temp2_min.dev_attr.attr,

964

&sensor_dev_attr_temp2_min.dev_attr.attr,

965

&sensor_dev_attr_temp1_max.dev_attr.attr,

965

&sensor_dev_attr_temp1_max.dev_attr.attr,

966

&sensor_dev_attr_temp2_max.dev_attr.attr,

966

&sensor_dev_attr_temp2_max.dev_attr.attr,

967

&sensor_dev_attr_temp1_crit.dev_attr.attr,

967

&sensor_dev_attr_temp1_crit.dev_attr.attr,

968

&sensor_dev_attr_temp2_crit.dev_attr.attr,

968

&sensor_dev_attr_temp2_crit.dev_attr.attr,

969

&sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,

969

&sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,

970

&sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,

970

&sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,

971

972

&sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,

972

&sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,

973

&sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,

973

&sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,

974

&sensor_dev_attr_temp2_fault.dev_attr.attr,

974

&sensor_dev_attr_temp2_fault.dev_attr.attr,

975

&sensor_dev_attr_temp2_min_alarm.dev_attr.attr,

975

&sensor_dev_attr_temp2_min_alarm.dev_attr.attr,

976

&sensor_dev_attr_temp2_max_alarm.dev_attr.attr,

976

&sensor_dev_attr_temp2_max_alarm.dev_attr.attr,

977

&sensor_dev_attr_temp1_min_alarm.dev_attr.attr,

977

&sensor_dev_attr_temp1_min_alarm.dev_attr.attr,

978

&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,

978

&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,

979

&dev_attr_alarms.attr,

979

&dev_attr_alarms.attr,

980

&dev_attr_update_interval.attr,

980

&dev_attr_update_interval.attr,

981

NULL

981

NULL

982

};

982

};

983

984

static const struct attribute_group lm90_group = {

984

static const struct attribute_group lm90_group = {

985

.attrs = lm90_attributes,

985

.attrs = lm90_attributes,

986

};

986

};

987

988

/*

988

/*

989

* Additional attributes for devices with emergency sensors

989

* Additional attributes for devices with emergency sensors

990

*/

990

*/

991

static SENSOR_DEVICE_ATTR(temp1_emergency, S_IWUSR | S_IRUGO, show_temp8,

991

static SENSOR_DEVICE_ATTR(temp1_emergency, S_IWUSR | S_IRUGO, show_temp8,

992

set_temp8, 4);

992

set_temp8, 4);

993

static SENSOR_DEVICE_ATTR(temp2_emergency, S_IWUSR | S_IRUGO, show_temp8,

993

static SENSOR_DEVICE_ATTR(temp2_emergency, S_IWUSR | S_IRUGO, show_temp8,

994

set_temp8, 5);

994

set_temp8, 5);

995

static SENSOR_DEVICE_ATTR(temp1_emergency_hyst, S_IRUGO, show_temphyst,

995

static SENSOR_DEVICE_ATTR(temp1_emergency_hyst, S_IRUGO, show_temphyst,

996

NULL, 4);

996

NULL, 4);

997

static SENSOR_DEVICE_ATTR(temp2_emergency_hyst, S_IRUGO, show_temphyst,

997

static SENSOR_DEVICE_ATTR(temp2_emergency_hyst, S_IRUGO, show_temphyst,

998

NULL, 5);

998

NULL, 5);

999

1000

static struct attribute *lm90_emergency_attributes[] = {

1000

static struct attribute *lm90_emergency_attributes[] = {

1001

&sensor_dev_attr_temp1_emergency.dev_attr.attr,

1001

&sensor_dev_attr_temp1_emergency.dev_attr.attr,

1002

&sensor_dev_attr_temp2_emergency.dev_attr.attr,

1002

&sensor_dev_attr_temp2_emergency.dev_attr.attr,

1003

&sensor_dev_attr_temp1_emergency_hyst.dev_attr.attr,

1003

&sensor_dev_attr_temp1_emergency_hyst.dev_attr.attr,

1004

&sensor_dev_attr_temp2_emergency_hyst.dev_attr.attr,

1004

&sensor_dev_attr_temp2_emergency_hyst.dev_attr.attr,

1005

NULL

1005

NULL

1006

};

1006

};

1007

1008

static const struct attribute_group lm90_emergency_group = {

1008

static const struct attribute_group lm90_emergency_group = {

1009

.attrs = lm90_emergency_attributes,

1009

.attrs = lm90_emergency_attributes,

1010

};

1010

};

1011

1012

static SENSOR_DEVICE_ATTR(temp1_emergency_alarm, S_IRUGO, show_alarm, NULL, 15);

1012

static SENSOR_DEVICE_ATTR(temp1_emergency_alarm, S_IRUGO, show_alarm, NULL, 15);

1013

static SENSOR_DEVICE_ATTR(temp2_emergency_alarm, S_IRUGO, show_alarm, NULL, 13);

1013

static SENSOR_DEVICE_ATTR(temp2_emergency_alarm, S_IRUGO, show_alarm, NULL, 13);

1014

1015

static struct attribute *lm90_emergency_alarm_attributes[] = {

1015

static struct attribute *lm90_emergency_alarm_attributes[] = {

1016

&sensor_dev_attr_temp1_emergency_alarm.dev_attr.attr,

1016

&sensor_dev_attr_temp1_emergency_alarm.dev_attr.attr,

1017

&sensor_dev_attr_temp2_emergency_alarm.dev_attr.attr,

1017

&sensor_dev_attr_temp2_emergency_alarm.dev_attr.attr,

1018

NULL

1018

NULL

1019

};

1019

};

1020

1021

static const struct attribute_group lm90_emergency_alarm_group = {

1021

static const struct attribute_group lm90_emergency_alarm_group = {

1022

.attrs = lm90_emergency_alarm_attributes,

1022

.attrs = lm90_emergency_alarm_attributes,

1023

};

1023

};

1024

1025

/*

1025

/*

1026

* Additional attributes for devices with 3 temperature sensors

1026

* Additional attributes for devices with 3 temperature sensors

1027

*/

1027

*/

1028

static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp11, NULL, 0, 5);

1028

static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp11, NULL, 0, 5);

1029

static SENSOR_DEVICE_ATTR_2(temp3_min, S_IWUSR | S_IRUGO, show_temp11,

1029

static SENSOR_DEVICE_ATTR_2(temp3_min, S_IWUSR | S_IRUGO, show_temp11,

1030

set_temp11, 3, 6);

1030

set_temp11, 3, 6);

1031

static SENSOR_DEVICE_ATTR_2(temp3_max, S_IWUSR | S_IRUGO, show_temp11,

1031

static SENSOR_DEVICE_ATTR_2(temp3_max, S_IWUSR | S_IRUGO, show_temp11,

1032

set_temp11, 4, 7);

1032

set_temp11, 4, 7);

1033

static SENSOR_DEVICE_ATTR(temp3_crit, S_IWUSR | S_IRUGO, show_temp8,

1033

static SENSOR_DEVICE_ATTR(temp3_crit, S_IWUSR | S_IRUGO, show_temp8,

1034

set_temp8, 6);

1034

set_temp8, 6);

1035

static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO, show_temphyst, NULL, 6);

1035

static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO, show_temphyst, NULL, 6);

1036

static SENSOR_DEVICE_ATTR(temp3_emergency, S_IWUSR | S_IRUGO, show_temp8,

1036

static SENSOR_DEVICE_ATTR(temp3_emergency, S_IWUSR | S_IRUGO, show_temp8,

1037

set_temp8, 7);

1037

set_temp8, 7);

1038

static SENSOR_DEVICE_ATTR(temp3_emergency_hyst, S_IRUGO, show_temphyst,

1038

static SENSOR_DEVICE_ATTR(temp3_emergency_hyst, S_IRUGO, show_temphyst,

1039

NULL, 7);

1039

NULL, 7);

1040

1041

static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 9);

1041

static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 9);

1042

static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 10);

1042

static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 10);

1043

static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11);

1043

static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11);

1044

static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 12);

1044

static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 12);

1045

static SENSOR_DEVICE_ATTR(temp3_emergency_alarm, S_IRUGO, show_alarm, NULL, 14);

1045

static SENSOR_DEVICE_ATTR(temp3_emergency_alarm, S_IRUGO, show_alarm, NULL, 14);

1046

1047

static struct attribute *lm90_temp3_attributes[] = {

1047

static struct attribute *lm90_temp3_attributes[] = {

1048

&sensor_dev_attr_temp3_input.dev_attr.attr,

1048

&sensor_dev_attr_temp3_input.dev_attr.attr,

1049

&sensor_dev_attr_temp3_min.dev_attr.attr,

1049

&sensor_dev_attr_temp3_min.dev_attr.attr,

1050

&sensor_dev_attr_temp3_max.dev_attr.attr,

1050

&sensor_dev_attr_temp3_max.dev_attr.attr,

1051

&sensor_dev_attr_temp3_crit.dev_attr.attr,

1051

&sensor_dev_attr_temp3_crit.dev_attr.attr,

1052

&sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,

1052

&sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,

1053

&sensor_dev_attr_temp3_emergency.dev_attr.attr,

1053

&sensor_dev_attr_temp3_emergency.dev_attr.attr,

1054

&sensor_dev_attr_temp3_emergency_hyst.dev_attr.attr,

1054

&sensor_dev_attr_temp3_emergency_hyst.dev_attr.attr,

1055

1056

&sensor_dev_attr_temp3_fault.dev_attr.attr,

1056

&sensor_dev_attr_temp3_fault.dev_attr.attr,

1057

&sensor_dev_attr_temp3_min_alarm.dev_attr.attr,

1057

&sensor_dev_attr_temp3_min_alarm.dev_attr.attr,

1058

&sensor_dev_attr_temp3_max_alarm.dev_attr.attr,

1058

&sensor_dev_attr_temp3_max_alarm.dev_attr.attr,

1059

&sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,

1059

&sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,

1060

&sensor_dev_attr_temp3_emergency_alarm.dev_attr.attr,

1060

&sensor_dev_attr_temp3_emergency_alarm.dev_attr.attr,

1061

NULL

1061

NULL

1062

};

1062

};

1063

1064

static const struct attribute_group lm90_temp3_group = {

1064

static const struct attribute_group lm90_temp3_group = {

1065

.attrs = lm90_temp3_attributes,

1065

.attrs = lm90_temp3_attributes,

1066

};

1066

};

1067

1068

/* pec used for ADM1032 only */

1068

/* pec used for ADM1032 only */

1069

static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,

1069

static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,

1070

char *buf)

1070

char *buf)

1071

{

1071

{

1072

struct i2c_client *client = to_i2c_client(dev);

1072

struct i2c_client *client = to_i2c_client(dev);

1073

return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));

1073

return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));

1074

}

1074

}

1075

1076

static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,

1076

static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,

1077

const char *buf, size_t count)

1077

const char *buf, size_t count)

1078

{

1078

{

1079

struct i2c_client *client = to_i2c_client(dev);

1079

struct i2c_client *client = to_i2c_client(dev);

1080

long val;

1080

long val;

1081

int err;

1081

int err;

1082

1083

err = kstrtol(buf, 10, &val);

1083

err = kstrtol(buf, 10, &val);

1084

if (err < 0)

1084

if (err < 0)

1085

return err;

1085

return err;

1086

1087

switch (val) {

1087

switch (val) {

1088

case 0:

1088

case 0:

1089

client->flags &= ~I2C_CLIENT_PEC;

1089

client->flags &= ~I2C_CLIENT_PEC;

1090

break;

1090

break;

1091

case 1:

1091

case 1:

1092

client->flags |= I2C_CLIENT_PEC;

1092

client->flags |= I2C_CLIENT_PEC;

1093

break;

1093

break;

1094

default:

1094

default:

1095

return -EINVAL;

1095

return -EINVAL;

1096

}

1096

}

1097

1098

return count;

1098

return count;

1099

}

1099

}

1100

1101

static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);

1101

static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);

1102

1103

/*

1103

/*

1104

* Real code

1104

* Real code

1105

*/

1105

*/

1106

1107

/* Return 0 if detection is successful, -ENODEV otherwise */

1107

/* Return 0 if detection is successful, -ENODEV otherwise */

1108

static int lm90_detect(struct i2c_client *client,

1108

static int lm90_detect(struct i2c_client *client,

1109

struct i2c_board_info *info)

1109

struct i2c_board_info *info)

1110

{

1110

{

1111

struct i2c_adapter *adapter = client->adapter;

1111

struct i2c_adapter *adapter = client->adapter;

1112

int address = client->addr;

1112

int address = client->addr;

1113

const char *name = NULL;

1113

const char *name = NULL;

1114

int man_id, chip_id, config1, config2, convrate;

1114

int man_id, chip_id, config1, config2, convrate;

1115

1116

if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))

1116

if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))

1117

return -ENODEV;

1117

return -ENODEV;

1118

1119

/* detection and identification */

1119

/* detection and identification */

1120

man_id = i2c_smbus_read_byte_data(client, LM90_REG_R_MAN_ID);

1120

man_id = i2c_smbus_read_byte_data(client, LM90_REG_R_MAN_ID);

1121

chip_id = i2c_smbus_read_byte_data(client, LM90_REG_R_CHIP_ID);

1121

chip_id = i2c_smbus_read_byte_data(client, LM90_REG_R_CHIP_ID);

1122

config1 = i2c_smbus_read_byte_data(client, LM90_REG_R_CONFIG1);

1122

config1 = i2c_smbus_read_byte_data(client, LM90_REG_R_CONFIG1);

1123

convrate = i2c_smbus_read_byte_data(client, LM90_REG_R_CONVRATE);

1123

convrate = i2c_smbus_read_byte_data(client, LM90_REG_R_CONVRATE);

1124

if (man_id < 0 || chip_id < 0 || config1 < 0 || convrate < 0)

1124

if (man_id < 0 || chip_id < 0 || config1 < 0 || convrate < 0)

1125

return -ENODEV;

1125

return -ENODEV;

1126

1127

if (man_id == 0x01 || man_id == 0x5C || man_id == 0x41) {

1127

if (man_id == 0x01 || man_id == 0x5C || man_id == 0x41) {

1128

config2 = i2c_smbus_read_byte_data(client, LM90_REG_R_CONFIG2);

1128

config2 = i2c_smbus_read_byte_data(client, LM90_REG_R_CONFIG2);

1129

if (config2 < 0)

1129

if (config2 < 0)

1130

return -ENODEV;

1130

return -ENODEV;

1131

} else

1131

} else

1132

config2 = 0; /* Make compiler happy */

1132

config2 = 0; /* Make compiler happy */

1133

1134

if ((address == 0x4C || address == 0x4D)

1134

if ((address == 0x4C || address == 0x4D)

1135

&& man_id == 0x01) { /* National Semiconductor */

1135

&& man_id == 0x01) { /* National Semiconductor */

1136

if ((config1 & 0x2A) == 0x00

1136

if ((config1 & 0x2A) == 0x00

1137

&& (config2 & 0xF8) == 0x00

1137

&& (config2 & 0xF8) == 0x00

1138

&& convrate <= 0x09) {

1138

&& convrate <= 0x09) {

1139

if (address == 0x4C

1139

if (address == 0x4C

1140

&& (chip_id & 0xF0) == 0x20) { /* LM90 */

1140

&& (chip_id & 0xF0) == 0x20) { /* LM90 */

1141

name = "lm90";

1141

name = "lm90";

1142

} else

1142

} else

1143

if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */

1143

if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */

1144

name = "lm99";

1144

name = "lm99";

1145

dev_info(&adapter->dev,

1145

dev_info(&adapter->dev,

1146

"Assuming LM99 chip at 0x%02x\n",

1146

"Assuming LM99 chip at 0x%02x\n",

1147

address);

1147

address);

1148

dev_info(&adapter->dev,

1148

dev_info(&adapter->dev,

1149

"If it is an LM89, instantiate it "

1149

"If it is an LM89, instantiate it "

1150

"with the new_device sysfs "

1150

"with the new_device sysfs "

1151

"interface\n");

1151

"interface\n");

1152

} else

1152

} else

1153

if (address == 0x4C

1153

if (address == 0x4C

1154

&& (chip_id & 0xF0) == 0x10) { /* LM86 */

1154

&& (chip_id & 0xF0) == 0x10) { /* LM86 */

1155

name = "lm86";

1155

name = "lm86";

1156

}

1156

}

1157

}

1157

}

1158

} else

1158

} else

1159

if ((address == 0x4C || address == 0x4D)

1159

if ((address == 0x4C || address == 0x4D)

1160

&& man_id == 0x41) { /* Analog Devices */

1160

&& man_id == 0x41) { /* Analog Devices */

1161

if ((chip_id & 0xF0) == 0x40 /* ADM1032 */

1161

if ((chip_id & 0xF0) == 0x40 /* ADM1032 */

1162

&& (config1 & 0x3F) == 0x00

1162

&& (config1 & 0x3F) == 0x00

1163

&& convrate <= 0x0A) {

1163

&& convrate <= 0x0A) {

1164

name = "adm1032";

1164

name = "adm1032";

1165

/* The ADM1032 supports PEC, but only if combined

1165

/* The ADM1032 supports PEC, but only if combined

1166

transactions are not used. */

1166

transactions are not used. */

1167

if (i2c_check_functionality(adapter,

1167

if (i2c_check_functionality(adapter,

1168

I2C_FUNC_SMBUS_BYTE))

1168

I2C_FUNC_SMBUS_BYTE))

1169

info->flags |= I2C_CLIENT_PEC;

1169

info->flags |= I2C_CLIENT_PEC;

1170

} else

1170

} else

1171

if (chip_id == 0x51 /* ADT7461 */

1171

if (chip_id == 0x51 /* ADT7461 */

1172

&& (config1 & 0x1B) == 0x00

1172

&& (config1 & 0x1B) == 0x00

1173

&& convrate <= 0x0A) {

1173

&& convrate <= 0x0A) {

1174

name = "adt7461";

1174

name = "adt7461";

1175

} else

1175

} else

1176

if (chip_id == 0x57 /* ADT7461A, NCT1008 */

1176

if (chip_id == 0x57 /* ADT7461A, NCT1008 */

1177

&& (config1 & 0x1B) == 0x00

1177

&& (config1 & 0x1B) == 0x00

1178

&& convrate <= 0x0A) {

1178

&& convrate <= 0x0A) {

1179

name = "adt7461a";

1179

name = "adt7461a";

1180

}

1180

}

1181

} else

1181

} else

1182

if (man_id == 0x4D) { /* Maxim */

1182

if (man_id == 0x4D) { /* Maxim */

1183

int emerg, emerg2, status2;

1183

int emerg, emerg2, status2;

1184

1185

/*

1185

/*

1186

* We read MAX6659_REG_R_REMOTE_EMERG twice, and re-read

1186

* We read MAX6659_REG_R_REMOTE_EMERG twice, and re-read

1187

* LM90_REG_R_MAN_ID in between. If MAX6659_REG_R_REMOTE_EMERG

1187

* LM90_REG_R_MAN_ID in between. If MAX6659_REG_R_REMOTE_EMERG

1188

* exists, both readings will reflect the same value. Otherwise,

1188

* exists, both readings will reflect the same value. Otherwise,

1189

* the readings will be different.

1189

* the readings will be different.

1190

*/

1190

*/

1191

emerg = i2c_smbus_read_byte_data(client,

1191

emerg = i2c_smbus_read_byte_data(client,

1192

MAX6659_REG_R_REMOTE_EMERG);

1192

MAX6659_REG_R_REMOTE_EMERG);

1193

man_id = i2c_smbus_read_byte_data(client,

1193

man_id = i2c_smbus_read_byte_data(client,

1194

LM90_REG_R_MAN_ID);

1194

LM90_REG_R_MAN_ID);

1195

emerg2 = i2c_smbus_read_byte_data(client,

1195

emerg2 = i2c_smbus_read_byte_data(client,

1196

MAX6659_REG_R_REMOTE_EMERG);

1196

MAX6659_REG_R_REMOTE_EMERG);

1197

status2 = i2c_smbus_read_byte_data(client,

1197

status2 = i2c_smbus_read_byte_data(client,

1198

MAX6696_REG_R_STATUS2);

1198

MAX6696_REG_R_STATUS2);

1199

if (emerg < 0 || man_id < 0 || emerg2 < 0 || status2 < 0)

1199

if (emerg < 0 || man_id < 0 || emerg2 < 0 || status2 < 0)

1200

return -ENODEV;

1200

return -ENODEV;

1201

1202

/*

1202

/*

1203

* The MAX6657, MAX6658 and MAX6659 do NOT have a chip_id

1203

* The MAX6657, MAX6658 and MAX6659 do NOT have a chip_id

1204

* register. Reading from that address will return the last

1204

* register. Reading from that address will return the last

1205

* read value, which in our case is those of the man_id

1205

* read value, which in our case is those of the man_id

1206

* register. Likewise, the config1 register seems to lack a

1206

* register. Likewise, the config1 register seems to lack a

1207

* low nibble, so the value will be those of the previous

1207

* low nibble, so the value will be those of the previous

1208

* read, so in our case those of the man_id register.

1208

* read, so in our case those of the man_id register.

1209

* MAX6659 has a third set of upper temperature limit registers.

1209

* MAX6659 has a third set of upper temperature limit registers.

1210

* Those registers also return values on MAX6657 and MAX6658,

1210

* Those registers also return values on MAX6657 and MAX6658,

1211

* thus the only way to detect MAX6659 is by its address.

1211

* thus the only way to detect MAX6659 is by its address.

1212

* For this reason it will be mis-detected as MAX6657 if its

1212

* For this reason it will be mis-detected as MAX6657 if its

1213

* address is 0x4C.

1213

* address is 0x4C.

1214

*/

1214

*/

1215

if (chip_id == man_id

1215

if (chip_id == man_id

1216

&& (address == 0x4C || address == 0x4D || address == 0x4E)

1216

&& (address == 0x4C || address == 0x4D || address == 0x4E)

1217

&& (config1 & 0x1F) == (man_id & 0x0F)

1217

&& (config1 & 0x1F) == (man_id & 0x0F)

1218

&& convrate <= 0x09) {

1218

&& convrate <= 0x09) {

1219

if (address == 0x4C)

1219

if (address == 0x4C)

1220

name = "max6657";

1220

name = "max6657";

1221

else

1221

else

1222

name = "max6659";

1222

name = "max6659";

1223

} else

1223

} else

1224

/*

1224

/*

1225

* Even though MAX6695 and MAX6696 do not have a chip ID

1225

* Even though MAX6695 and MAX6696 do not have a chip ID

1226

* register, reading it returns 0x01. Bit 4 of the config1

1226

* register, reading it returns 0x01. Bit 4 of the config1

1227

* register is unused and should return zero when read. Bit 0 of

1227

* register is unused and should return zero when read. Bit 0 of

1228

* the status2 register is unused and should return zero when

1228

* the status2 register is unused and should return zero when

1229

* read.

1229

* read.

1230

*

1230

*

1231

* MAX6695 and MAX6696 have an additional set of temperature

1231

* MAX6695 and MAX6696 have an additional set of temperature

1232

* limit registers. We can detect those chips by checking if

1232

* limit registers. We can detect those chips by checking if

1233

* one of those registers exists.

1233

* one of those registers exists.

1234

*/

1234

*/

1235

if (chip_id == 0x01

1235

if (chip_id == 0x01

1236

&& (config1 & 0x10) == 0x00

1236

&& (config1 & 0x10) == 0x00

1237

&& (status2 & 0x01) == 0x00

1237

&& (status2 & 0x01) == 0x00

1238

&& emerg == emerg2

1238

&& emerg == emerg2

1239

&& convrate <= 0x07) {

1239

&& convrate <= 0x07) {

1240

name = "max6696";

1240

name = "max6696";

1241

} else

1241

} else

1242

/*

1242

/*

1243

* The chip_id register of the MAX6680 and MAX6681 holds the

1243

* The chip_id register of the MAX6680 and MAX6681 holds the

1244

* revision of the chip. The lowest bit of the config1 register

1244

* revision of the chip. The lowest bit of the config1 register

1245

* is unused and should return zero when read, so should the

1245

* is unused and should return zero when read, so should the

1246

* second to last bit of config1 (software reset).

1246

* second to last bit of config1 (software reset).

1247

*/

1247

*/

1248

if (chip_id == 0x01

1248

if (chip_id == 0x01

1249

&& (config1 & 0x03) == 0x00

1249

&& (config1 & 0x03) == 0x00

1250

&& convrate <= 0x07) {

1250

&& convrate <= 0x07) {

1251

name = "max6680";

1251

name = "max6680";

1252

} else

1252

} else

1253

/*

1253

/*

1254

* The chip_id register of the MAX6646/6647/6649 holds the

1254

* The chip_id register of the MAX6646/6647/6649 holds the

1255

* revision of the chip. The lowest 6 bits of the config1

1255

* revision of the chip. The lowest 6 bits of the config1

1256

* register are unused and should return zero when read.

1256

* register are unused and should return zero when read.

1257

*/

1257

*/

1258

if (chip_id == 0x59

1258

if (chip_id == 0x59

1259

&& (config1 & 0x3f) == 0x00

1259

&& (config1 & 0x3f) == 0x00

1260

&& convrate <= 0x07) {

1260

&& convrate <= 0x07) {

1261

name = "max6646";

1261

name = "max6646";

1262

}

1262

}

1263

} else

1263

} else

1264

if (address == 0x4C

1264

if (address == 0x4C

1265

&& man_id == 0x5C) { /* Winbond/Nuvoton */

1265

&& man_id == 0x5C) { /* Winbond/Nuvoton */

1266

if ((config1 & 0x2A) == 0x00

1266

if ((config1 & 0x2A) == 0x00

1267

&& (config2 & 0xF8) == 0x00) {

1267

&& (config2 & 0xF8) == 0x00) {

1268

if (chip_id == 0x01 /* W83L771W/G */

1268

if (chip_id == 0x01 /* W83L771W/G */

1269

&& convrate <= 0x09) {

1269

&& convrate <= 0x09) {

1270

name = "w83l771";

1270

name = "w83l771";

1271

} else

1271

} else

1272

if ((chip_id & 0xFE) == 0x10 /* W83L771AWG/ASG */

1272

if ((chip_id & 0xFE) == 0x10 /* W83L771AWG/ASG */

1273

&& convrate <= 0x08) {

1273

&& convrate <= 0x08) {

1274

name = "w83l771";

1274

name = "w83l771";

1275

}

1275

}

1276

}

1276

}

1277

} else

1277

} else

1278

if (address >= 0x48 && address <= 0x4F

1278

if (address >= 0x48 && address <= 0x4F

1279

&& man_id == 0xA1) { /* NXP Semiconductor/Philips */

1279

&& man_id == 0xA1) { /* NXP Semiconductor/Philips */

1280

if (chip_id == 0x00

1280

if (chip_id == 0x00

1281

&& (config1 & 0x2A) == 0x00

1281

&& (config1 & 0x2A) == 0x00

1282

&& (config2 & 0xFE) == 0x00

1282

&& (config2 & 0xFE) == 0x00

1283

&& convrate <= 0x09) {

1283

&& convrate <= 0x09) {

1284

name = "sa56004";

1284

name = "sa56004";

1285

}

1285

}

1286

}

1286

}

1287

1288

if (!name) { /* identification failed */

1288

if (!name) { /* identification failed */

1289

dev_dbg(&adapter->dev,

1289

dev_dbg(&adapter->dev,

1290

"Unsupported chip at 0x%02x (man_id=0x%02X, "

1290

"Unsupported chip at 0x%02x (man_id=0x%02X, "

1291

"chip_id=0x%02X)\n", address, man_id, chip_id);

1291

"chip_id=0x%02X)\n", address, man_id, chip_id);

1292

return -ENODEV;

1292

return -ENODEV;

1293

}

1293

}

1294

1295

strlcpy(info->type, name, I2C_NAME_SIZE);

1295

strlcpy(info->type, name, I2C_NAME_SIZE);

1296

1297

return 0;

1297

return 0;

1298

}

1298

}

1299

1300

static void lm90_remove_files(struct i2c_client *client, struct lm90_data *data)

1300

static void lm90_remove_files(struct i2c_client *client, struct lm90_data *data)

1301

{

1301

{

1302

struct device *dev = &client->dev;

1302

struct device *dev = &client->dev;

1303

1304

if (data->flags & LM90_HAVE_TEMP3)

1304

if (data->flags & LM90_HAVE_TEMP3)

1305

sysfs_remove_group(&dev->kobj, &lm90_temp3_group);

1305

sysfs_remove_group(&dev->kobj, &lm90_temp3_group);

1306

if (data->flags & LM90_HAVE_EMERGENCY_ALARM)

1306

if (data->flags & LM90_HAVE_EMERGENCY_ALARM)

1307

sysfs_remove_group(&dev->kobj, &lm90_emergency_alarm_group);

1307

sysfs_remove_group(&dev->kobj, &lm90_emergency_alarm_group);

1308

if (data->flags & LM90_HAVE_EMERGENCY)

1308

if (data->flags & LM90_HAVE_EMERGENCY)

1309

sysfs_remove_group(&dev->kobj, &lm90_emergency_group);

1309

sysfs_remove_group(&dev->kobj, &lm90_emergency_group);

1310

if (data->flags & LM90_HAVE_OFFSET)

1310

if (data->flags & LM90_HAVE_OFFSET)

1311

device_remove_file(dev, &sensor_dev_attr_temp2_offset.dev_attr);

1311

device_remove_file(dev, &sensor_dev_attr_temp2_offset.dev_attr);

1312

device_remove_file(dev, &dev_attr_pec);

1312

device_remove_file(dev, &dev_attr_pec);

1313

sysfs_remove_group(&dev->kobj, &lm90_group);

1313

sysfs_remove_group(&dev->kobj, &lm90_group);

1314

}

1314

}

1315

1316

static void lm90_init_client(struct i2c_client *client)

1316

static void lm90_init_client(struct i2c_client *client)

1317

{

1317

{

1318

u8 config, convrate;

1318

u8 config, convrate;

1319

struct lm90_data *data = i2c_get_clientdata(client);

1319

struct lm90_data *data = i2c_get_clientdata(client);

1320

1321

if (lm90_read_reg(client, LM90_REG_R_CONVRATE, &convrate) < 0) {

1321

if (lm90_read_reg(client, LM90_REG_R_CONVRATE, &convrate) < 0) {

1322

dev_warn(&client->dev, "Failed to read convrate register!\n");

1322

dev_warn(&client->dev, "Failed to read convrate register!\n");

1323

convrate = LM90_DEF_CONVRATE_RVAL;

1323

convrate = LM90_DEF_CONVRATE_RVAL;

1324

}

1324

}

1325

data->convrate_orig = convrate;

1325

data->convrate_orig = convrate;

1326

1327

/*

1327

/*

1328

* Start the conversions.

1328

* Start the conversions.

1329

*/

1329

*/

1330

lm90_set_convrate(client, data, 500); /* 500ms; 2Hz conversion rate */

1330

lm90_set_convrate(client, data, 500); /* 500ms; 2Hz conversion rate */

1331

if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {

1331

if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {

1332

dev_warn(&client->dev, "Initialization failed!\n");

1332

dev_warn(&client->dev, "Initialization failed!\n");

1333

return;

1333

return;

1334

}

1334

}

1335

data->config_orig = config;

1335

data->config_orig = config;

1336

1337

/* Check Temperature Range Select */

1337

/* Check Temperature Range Select */

1338

if (data->kind == adt7461) {

1338

if (data->kind == adt7461) {

1339

if (config & 0x04)

1339

if (config & 0x04)

1340

data->flags |= LM90_FLAG_ADT7461_EXT;

1340

data->flags |= LM90_FLAG_ADT7461_EXT;

1341

}

1341

}

1342

1343

/*

1343

/*

1344

* Put MAX6680/MAX8881 into extended resolution (bit 0x10,

1344

* Put MAX6680/MAX8881 into extended resolution (bit 0x10,

1345

* 0.125 degree resolution) and range (0x08, extend range

1345

* 0.125 degree resolution) and range (0x08, extend range

1346

* to -64 degree) mode for the remote temperature sensor.

1346

* to -64 degree) mode for the remote temperature sensor.

1347

*/

1347

*/

1348

if (data->kind == max6680)

1348

if (data->kind == max6680)

1349

config |= 0x18;

1349

config |= 0x18;

1350

1351

/*

1351

/*

1352

* Select external channel 0 for max6695/96

1352

* Select external channel 0 for max6695/96

1353

*/

1353

*/

1354

if (data->kind == max6696)

1354

if (data->kind == max6696)

1355

config &= ~0x08;

1355

config &= ~0x08;

1356

1357

config &= 0xBF; /* run */

1357

config &= 0xBF; /* run */

1358

if (config != data->config_orig) /* Only write if changed */

1358

if (config != data->config_orig) /* Only write if changed */

1359

i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);

1359

i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);

1360

}

1360

}

1361

1362

static int lm90_probe(struct i2c_client *client,

1362

static int lm90_probe(struct i2c_client *client,

1363

const struct i2c_device_id *id)

1363

const struct i2c_device_id *id)

1364

{

1364

{

1365

struct device *dev = &client->dev;

1365

struct device *dev = &client->dev;

1366

struct i2c_adapter *adapter = to_i2c_adapter(dev->parent);

1366

struct i2c_adapter *adapter = to_i2c_adapter(dev->parent);

1367

struct lm90_data *data;

1367

struct lm90_data *data;

1368

int err;

1368

int err;

1369

1370

data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL);

1370

data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL);

1371

if (!data) {

1371

if (!data) {

1372

err = -ENOMEM;

1372

err = -ENOMEM;

1373

goto exit;

1373

goto exit;

1374

}

1374

}

1375

i2c_set_clientdata(client, data);

1375

i2c_set_clientdata(client, data);

1376

mutex_init(&data->update_lock);

1376

mutex_init(&data->update_lock);

1377

1378

/* Set the device type */

1378

/* Set the device type */

1379

data->kind = id->driver_data;

1379

data->kind = id->driver_data;

1380

if (data->kind == adm1032) {

1380

if (data->kind == adm1032) {

1381

if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))

1381

if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))

1382

client->flags &= ~I2C_CLIENT_PEC;

1382

client->flags &= ~I2C_CLIENT_PEC;

1383

}

1383

}

1384

1385

/* Different devices have different alarm bits triggering the

1385

/* Different devices have different alarm bits triggering the

1386

* ALERT# output */

1386

* ALERT# output */

1387

data->alert_alarms = lm90_params[data->kind].alert_alarms;

1387

data->alert_alarms = lm90_params[data->kind].alert_alarms;

1388

1389

/* Set chip capabilities */

1389

/* Set chip capabilities */

1390

data->flags = lm90_params[data->kind].flags;

1390

data->flags = lm90_params[data->kind].flags;

1391

data->reg_local_ext = lm90_params[data->kind].reg_local_ext;

1391

data->reg_local_ext = lm90_params[data->kind].reg_local_ext;

1392

1393

/* Set maximum conversion rate */

1393

/* Set maximum conversion rate */

1394

data->max_convrate = lm90_params[data->kind].max_convrate;

1394

data->max_convrate = lm90_params[data->kind].max_convrate;

1395

1396

/* Initialize the LM90 chip */

1396

/* Initialize the LM90 chip */

1397

lm90_init_client(client);

1397

lm90_init_client(client);

1398

1399

/* Register sysfs hooks */

1399

/* Register sysfs hooks */

1400

err = sysfs_create_group(&dev->kobj, &lm90_group);

1400

err = sysfs_create_group(&dev->kobj, &lm90_group);

1401

if (err)

1401

if (err)

1402

goto exit_free;

1402

goto exit_free;

1403

if (client->flags & I2C_CLIENT_PEC) {

1403

if (client->flags & I2C_CLIENT_PEC) {

1404

err = device_create_file(dev, &dev_attr_pec);

1404

err = device_create_file(dev, &dev_attr_pec);

1405

if (err)

1405

if (err)

1406

goto exit_remove_files;

1406

goto exit_remove_files;

1407

}

1407

}

1408

if (data->flags & LM90_HAVE_OFFSET) {

1408

if (data->flags & LM90_HAVE_OFFSET) {

1409

err = device_create_file(dev,

1409

err = device_create_file(dev,

1410

&sensor_dev_attr_temp2_offset.dev_attr);

1410

&sensor_dev_attr_temp2_offset.dev_attr);

1411

if (err)

1411

if (err)

1412

goto exit_remove_files;

1412

goto exit_remove_files;

1413

}

1413

}

1414

if (data->flags & LM90_HAVE_EMERGENCY) {

1414

if (data->flags & LM90_HAVE_EMERGENCY) {

1415

err = sysfs_create_group(&dev->kobj, &lm90_emergency_group);

1415

err = sysfs_create_group(&dev->kobj, &lm90_emergency_group);

1416

if (err)

1416

if (err)

1417

goto exit_remove_files;

1417

goto exit_remove_files;

1418

}

1418

}

1419

if (data->flags & LM90_HAVE_EMERGENCY_ALARM) {

1419

if (data->flags & LM90_HAVE_EMERGENCY_ALARM) {

1420

err = sysfs_create_group(&dev->kobj,

1420

err = sysfs_create_group(&dev->kobj,

1421

&lm90_emergency_alarm_group);

1421

&lm90_emergency_alarm_group);

1422

if (err)

1422

if (err)

1423

goto exit_remove_files;

1423

goto exit_remove_files;

1424

}

1424

}

1425

if (data->flags & LM90_HAVE_TEMP3) {

1425

if (data->flags & LM90_HAVE_TEMP3) {

1426

err = sysfs_create_group(&dev->kobj, &lm90_temp3_group);

1426

err = sysfs_create_group(&dev->kobj, &lm90_temp3_group);

1427

if (err)

1427

if (err)

1428

goto exit_remove_files;

1428

goto exit_remove_files;

1429

}

1429

}

1430

1431

data->hwmon_dev = hwmon_device_register(dev);

1431

data->hwmon_dev = hwmon_device_register(dev);

1432

if (IS_ERR(data->hwmon_dev)) {

1432

if (IS_ERR(data->hwmon_dev)) {

1433

err = PTR_ERR(data->hwmon_dev);

1433

err = PTR_ERR(data->hwmon_dev);

1434

goto exit_remove_files;

1434

goto exit_remove_files;

1435

}

1435

}

1436

1437

return 0;

1437

return 0;

1438

1439

exit_remove_files:

1439

exit_remove_files:

1440

lm90_remove_files(client, data);

1440

lm90_remove_files(client, data);

1441

exit_free:

1441

exit_free:

1442

kfree(data);

1442

kfree(data);

1443

exit:

1443

exit:

1444

return err;

1444

return err;

1445

}

1445

}

1446

1447

static int lm90_remove(struct i2c_client *client)

1447

static int lm90_remove(struct i2c_client *client)

1448

{

1448

{

1449

struct lm90_data *data = i2c_get_clientdata(client);

1449

struct lm90_data *data = i2c_get_clientdata(client);

1450

1451

hwmon_device_unregister(data->hwmon_dev);

1451

hwmon_device_unregister(data->hwmon_dev);

1452

lm90_remove_files(client, data);

1452

lm90_remove_files(client, data);

1453

1454

/* Restore initial configuration */

1454

/* Restore initial configuration */

1455

i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,

1455

i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,

1456

data->convrate_orig);

1456

data->convrate_orig);

1457

i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,

1457

i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,

1458

data->config_orig);

1458

data->config_orig);

1459

1460

kfree(data);

1460

kfree(data);

1461

return 0;

1461

return 0;

1462

}

1462

}

1463

1464

static void lm90_alert(struct i2c_client *client, unsigned int flag)

1464

static void lm90_alert(struct i2c_client *client, unsigned int flag)

1465

{

1465

{

1466

struct lm90_data *data = i2c_get_clientdata(client);

1466

struct lm90_data *data = i2c_get_clientdata(client);

1467

u8 config, alarms, alarms2 = 0;

1467

u8 config, alarms, alarms2 = 0;

1468

1469

lm90_read_reg(client, LM90_REG_R_STATUS, &alarms);

1469

lm90_read_reg(client, LM90_REG_R_STATUS, &alarms);

1470

1471

if (data->kind == max6696)

1471

if (data->kind == max6696)

1472

lm90_read_reg(client, MAX6696_REG_R_STATUS2, &alarms2);

1472

lm90_read_reg(client, MAX6696_REG_R_STATUS2, &alarms2);

1473

1474

if ((alarms & 0x7f) == 0 && (alarms2 & 0xfe) == 0) {

1474

if ((alarms & 0x7f) == 0 && (alarms2 & 0xfe) == 0) {

1475

dev_info(&client->dev, "Everything OK\n");

1475

dev_info(&client->dev, "Everything OK\n");

1476

} else {

1476

} else {

1477

if (alarms & 0x61)

1477

if (alarms & 0x61)

1478

dev_warn(&client->dev,

1478

dev_warn(&client->dev,

1479

"temp%d out of range, please check!\n", 1);

1479

"temp%d out of range, please check!\n", 1);

1480

if (alarms & 0x1a)

1480

if (alarms & 0x1a)

1481

dev_warn(&client->dev,

1481

dev_warn(&client->dev,

1482

"temp%d out of range, please check!\n", 2);

1482

"temp%d out of range, please check!\n", 2);

1483

if (alarms & 0x04)

1483

if (alarms & 0x04)

1484

dev_warn(&client->dev,

1484

dev_warn(&client->dev,

1485

"temp%d diode open, please check!\n", 2);

1485

"temp%d diode open, please check!\n", 2);

1486

1487

if (alarms2 & 0x18)

1487

if (alarms2 & 0x18)

1488

dev_warn(&client->dev,

1488

dev_warn(&client->dev,

1489

"temp%d out of range, please check!\n", 3);

1489

"temp%d out of range, please check!\n", 3);

1490

1491

/* Disable ALERT# output, because these chips don't implement

1491

/* Disable ALERT# output, because these chips don't implement

1492

SMBus alert correctly; they should only hold the alert line

1492

SMBus alert correctly; they should only hold the alert line

1493

low briefly. */

1493

low briefly. */

1494

if ((data->flags & LM90_HAVE_BROKEN_ALERT)

1494

if ((data->flags & LM90_HAVE_BROKEN_ALERT)

1495

&& (alarms & data->alert_alarms)) {

1495

&& (alarms & data->alert_alarms)) {

1496

dev_dbg(&client->dev, "Disabling ALERT#\n");

1496

dev_dbg(&client->dev, "Disabling ALERT#\n");

1497

lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);

1497

lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);

1498

i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,

1498

i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,

1499

config | 0x80);

1499

config | 0x80);

1500

}

1500

}

1501

}

1501

}

1502

}

1502

}

1503

1504

static struct i2c_driver lm90_driver = {

1504

static struct i2c_driver lm90_driver = {

1505

.class = I2C_CLASS_HWMON,

1505

.class = I2C_CLASS_HWMON,

1506

.driver = {

1506

.driver = {

1507

.name = "lm90",

1507

.name = "lm90",

1508

},

1508

},

1509

.probe = lm90_probe,

1509

.probe = lm90_probe,

1510

.remove = lm90_remove,

1510

.remove = lm90_remove,

1511

.alert = lm90_alert,

1511

.alert = lm90_alert,

1512

.id_table = lm90_id,

1512

.id_table = lm90_id,

1513

.detect = lm90_detect,

1513

.detect = lm90_detect,

1514

.address_list = normal_i2c,

1514

.address_list = normal_i2c,

1515

};

1515

};

1516

1517

static int __init sensors_lm90_init(void)

1517

static int __init sensors_lm90_init(void)

1518

{

1518

{

1519

return i2c_add_driver(&lm90_driver);

1519

return i2c_add_driver(&lm90_driver);

1520

}

1520

}

1521

1522

static void __exit sensors_lm90_exit(void)

1522

static void __exit sensors_lm90_exit(void)

1523

{

1523

{

1524

i2c_del_driver(&lm90_driver);

1524

i2c_del_driver(&lm90_driver);

1525

}

1525

}

1526

1527

MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");

1527

MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");

1528

MODULE_DESCRIPTION("LM90/ADM1032 driver");

1528

MODULE_DESCRIPTION("LM90/ADM1032 driver");

1529

MODULE_LICENSE("GPL");

1529

MODULE_LICENSE("GPL");

1530

1531

module_init(sensors_lm90_init);

1531

module_init(sensors_lm90_init);

1532

module_exit(sensors_lm90_exit);

1532

module_exit(sensors_lm90_exit);

1533

GITLAB

hwmon: (lm90) Add range check to set_update_interval