Eric Lee / smarc-fsl-linux-kernel

1

/*

1

/*

2

* A hwmon driver for the IBM PowerExecutive temperature/power sensors

2

* A hwmon driver for the IBM PowerExecutive temperature/power sensors

3

4

*

4

*

5

* Author: Darrick J. Wong <djwong@us.ibm.com>

5

* Author: Darrick J. Wong <djwong@us.ibm.com>

6

*

6

*

7

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

7

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

8

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

8

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

9

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

9

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

10

* (at your option) any later version.

10

* (at your option) any later version.

11

*

11

*

12

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

12

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

13

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

13

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

14

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

14

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

15

* GNU General Public License for more details.

15

* GNU General Public License for more details.

16

*

16

*

17

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

17

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

18

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

18

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

19

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

19

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

20

*/

20

*/

21

22

#include <linux/ipmi.h>

22

#include <linux/ipmi.h>

23

#include <linux/module.h>

23

#include <linux/module.h>

24

#include <linux/hwmon.h>

24

#include <linux/hwmon.h>

25

#include <linux/hwmon-sysfs.h>

25

#include <linux/hwmon-sysfs.h>

26

#include <linux/jiffies.h>

26

#include <linux/jiffies.h>

27

#include <linux/mutex.h>

27

#include <linux/mutex.h>

28

29

#define REFRESH_INTERVAL (2 * HZ)

29

#define REFRESH_INTERVAL (2 * HZ)

30

#define DRVNAME "ibmpex"

30

#define DRVNAME "ibmpex"

31

32

#define PEX_GET_VERSION 1

32

#define PEX_GET_VERSION 1

33

#define PEX_GET_SENSOR_COUNT 2

33

#define PEX_GET_SENSOR_COUNT 2

34

#define PEX_GET_SENSOR_NAME 3

34

#define PEX_GET_SENSOR_NAME 3

35

#define PEX_RESET_HIGH_LOW 4

35

#define PEX_RESET_HIGH_LOW 4

36

#define PEX_GET_SENSOR_DATA 6

36

#define PEX_GET_SENSOR_DATA 6

37

38

#define PEX_NET_FUNCTION 0x3A

38

#define PEX_NET_FUNCTION 0x3A

39

#define PEX_COMMAND 0x3C

39

#define PEX_COMMAND 0x3C

40

41

static inline u16 extract_value(const char *data, int offset)

41

static inline u16 extract_value(const char *data, int offset)

42

{

42

{

43

return be16_to_cpup((u16 *)&data[offset]);

43

return be16_to_cpup((__be16 *)&data[offset]);

44

}

44

}

45

46

#define TEMP_SENSOR 1

46

#define TEMP_SENSOR 1

47

#define POWER_SENSOR 2

47

#define POWER_SENSOR 2

48

49

#define PEX_SENSOR_TYPE_LEN 3

49

#define PEX_SENSOR_TYPE_LEN 3

50

static u8 const power_sensor_sig[] = {0x70, 0x77, 0x72};

50

static u8 const power_sensor_sig[] = {0x70, 0x77, 0x72};

51

static u8 const temp_sensor_sig[] = {0x74, 0x65, 0x6D};

51

static u8 const temp_sensor_sig[] = {0x74, 0x65, 0x6D};

52

53

#define PEX_MULT_LEN 2

53

#define PEX_MULT_LEN 2

54

static u8 const watt_sensor_sig[] = {0x41, 0x43};

54

static u8 const watt_sensor_sig[] = {0x41, 0x43};

55

56

#define PEX_NUM_SENSOR_FUNCS 3

56

#define PEX_NUM_SENSOR_FUNCS 3

57

static char const * const power_sensor_name_templates[] = {

57

static char const * const power_sensor_name_templates[] = {

58

"%s%d_average",

58

"%s%d_average",

59

"%s%d_average_lowest",

59

"%s%d_average_lowest",

60

"%s%d_average_highest"

60

"%s%d_average_highest"

61

};

61

};

62

static char const * const temp_sensor_name_templates[] = {

62

static char const * const temp_sensor_name_templates[] = {

63

"%s%d_input",

63

"%s%d_input",

64

"%s%d_input_lowest",

64

"%s%d_input_lowest",

65

"%s%d_input_highest"

65

"%s%d_input_highest"

66

};

66

};

67

68

static void ibmpex_msg_handler(struct ipmi_recv_msg *msg, void *user_msg_data);

68

static void ibmpex_msg_handler(struct ipmi_recv_msg *msg, void *user_msg_data);

69

static void ibmpex_register_bmc(int iface, struct device *dev);

69

static void ibmpex_register_bmc(int iface, struct device *dev);

70

static void ibmpex_bmc_gone(int iface);

70

static void ibmpex_bmc_gone(int iface);

71

72

struct ibmpex_sensor_data {

72

struct ibmpex_sensor_data {

73

int in_use;

73

int in_use;

74

s16 values[PEX_NUM_SENSOR_FUNCS];

74

s16 values[PEX_NUM_SENSOR_FUNCS];

75

int multiplier;

75

int multiplier;

76

77

struct sensor_device_attribute_2 attr[PEX_NUM_SENSOR_FUNCS];

77

struct sensor_device_attribute_2 attr[PEX_NUM_SENSOR_FUNCS];

78

};

78

};

79

80

struct ibmpex_bmc_data {

80

struct ibmpex_bmc_data {

81

struct list_head list;

81

struct list_head list;

82

struct device *hwmon_dev;

82

struct device *hwmon_dev;

83

struct device *bmc_device;

83

struct device *bmc_device;

84

struct mutex lock;

84

struct mutex lock;

85

char valid;

85

char valid;

86

unsigned long last_updated; /* In jiffies */

86

unsigned long last_updated; /* In jiffies */

87

88

struct ipmi_addr address;

88

struct ipmi_addr address;

89

struct completion read_complete;

89

struct completion read_complete;

90

ipmi_user_t user;

90

ipmi_user_t user;

91

int interface;

91

int interface;

92

93

struct kernel_ipmi_msg tx_message;

93

struct kernel_ipmi_msg tx_message;

94

unsigned char tx_msg_data[IPMI_MAX_MSG_LENGTH];

94

unsigned char tx_msg_data[IPMI_MAX_MSG_LENGTH];

95

long tx_msgid;

95

long tx_msgid;

96

97

unsigned char rx_msg_data[IPMI_MAX_MSG_LENGTH];

97

unsigned char rx_msg_data[IPMI_MAX_MSG_LENGTH];

98

unsigned long rx_msg_len;

98

unsigned long rx_msg_len;

99

unsigned char rx_result;

99

unsigned char rx_result;

100

int rx_recv_type;

100

int rx_recv_type;

101

102

unsigned char sensor_major;

102

unsigned char sensor_major;

103

unsigned char sensor_minor;

103

unsigned char sensor_minor;

104

105

unsigned char num_sensors;

105

unsigned char num_sensors;

106

struct ibmpex_sensor_data *sensors;

106

struct ibmpex_sensor_data *sensors;

107

};

107

};

108

109

struct ibmpex_driver_data {

109

struct ibmpex_driver_data {

110

struct list_head bmc_data;

110

struct list_head bmc_data;

111

struct ipmi_smi_watcher bmc_events;

111

struct ipmi_smi_watcher bmc_events;

112

struct ipmi_user_hndl ipmi_hndlrs;

112

struct ipmi_user_hndl ipmi_hndlrs;

113

};

113

};

114

115

static struct ibmpex_driver_data driver_data = {

115

static struct ibmpex_driver_data driver_data = {

116

.bmc_data = LIST_HEAD_INIT(driver_data.bmc_data),

116

.bmc_data = LIST_HEAD_INIT(driver_data.bmc_data),

117

.bmc_events = {

117

.bmc_events = {

118

.owner = THIS_MODULE,

118

.owner = THIS_MODULE,

119

.new_smi = ibmpex_register_bmc,

119

.new_smi = ibmpex_register_bmc,

120

.smi_gone = ibmpex_bmc_gone,

120

.smi_gone = ibmpex_bmc_gone,

121

},

121

},

122

.ipmi_hndlrs = {

122

.ipmi_hndlrs = {

123

.ipmi_recv_hndl = ibmpex_msg_handler,

123

.ipmi_recv_hndl = ibmpex_msg_handler,

124

},

124

},

125

};

125

};

126

127

static int ibmpex_send_message(struct ibmpex_bmc_data *data)

127

static int ibmpex_send_message(struct ibmpex_bmc_data *data)

128

{

128

{

129

int err;

129

int err;

130

131

err = ipmi_validate_addr(&data->address, sizeof(data->address));

131

err = ipmi_validate_addr(&data->address, sizeof(data->address));

132

if (err)

132

if (err)

133

goto out;

133

goto out;

134

135

data->tx_msgid++;

135

data->tx_msgid++;

136

err = ipmi_request_settime(data->user, &data->address, data->tx_msgid,

136

err = ipmi_request_settime(data->user, &data->address, data->tx_msgid,

137

&data->tx_message, data, 0, 0, 0);

137

&data->tx_message, data, 0, 0, 0);

138

if (err)

138

if (err)

139

goto out1;

139

goto out1;

140

141

return 0;

141

return 0;

142

out1:

142

out1:

143

dev_err(data->bmc_device, "request_settime=%x\n", err);

143

dev_err(data->bmc_device, "request_settime=%x\n", err);

144

return err;

144

return err;

145

out:

145

out:

146

dev_err(data->bmc_device, "validate_addr=%x\n", err);

146

dev_err(data->bmc_device, "validate_addr=%x\n", err);

147

return err;

147

return err;

148

}

148

}

149

150

static int ibmpex_ver_check(struct ibmpex_bmc_data *data)

150

static int ibmpex_ver_check(struct ibmpex_bmc_data *data)

151

{

151

{

152

data->tx_msg_data[0] = PEX_GET_VERSION;

152

data->tx_msg_data[0] = PEX_GET_VERSION;

153

data->tx_message.data_len = 1;

153

data->tx_message.data_len = 1;

154

ibmpex_send_message(data);

154

ibmpex_send_message(data);

155

156

wait_for_completion(&data->read_complete);

156

wait_for_completion(&data->read_complete);

157

158

if (data->rx_result || data->rx_msg_len != 6)

158

if (data->rx_result || data->rx_msg_len != 6)

159

return -ENOENT;

159

return -ENOENT;

160

161

data->sensor_major = data->rx_msg_data[0];

161

data->sensor_major = data->rx_msg_data[0];

162

data->sensor_minor = data->rx_msg_data[1];

162

data->sensor_minor = data->rx_msg_data[1];

163

164

dev_info(data->bmc_device, "Found BMC with sensor interface "

164

dev_info(data->bmc_device, "Found BMC with sensor interface "

165

"v%d.%d %d-%02d-%02d on interface %d\n",

165

"v%d.%d %d-%02d-%02d on interface %d\n",

166

data->sensor_major,

166

data->sensor_major,

167

data->sensor_minor,

167

data->sensor_minor,

168

extract_value(data->rx_msg_data, 2),

168

extract_value(data->rx_msg_data, 2),

169

data->rx_msg_data[4],

169

data->rx_msg_data[4],

170

data->rx_msg_data[5],

170

data->rx_msg_data[5],

171

data->interface);

171

data->interface);

172

173

return 0;

173

return 0;

174

}

174

}

175

176

static int ibmpex_query_sensor_count(struct ibmpex_bmc_data *data)

176

static int ibmpex_query_sensor_count(struct ibmpex_bmc_data *data)

177

{

177

{

178

data->tx_msg_data[0] = PEX_GET_SENSOR_COUNT;

178

data->tx_msg_data[0] = PEX_GET_SENSOR_COUNT;

179

data->tx_message.data_len = 1;

179

data->tx_message.data_len = 1;

180

ibmpex_send_message(data);

180

ibmpex_send_message(data);

181

182

wait_for_completion(&data->read_complete);

182

wait_for_completion(&data->read_complete);

183

184

if (data->rx_result || data->rx_msg_len != 1)

184

if (data->rx_result || data->rx_msg_len != 1)

185

return -ENOENT;

185

return -ENOENT;

186

187

return data->rx_msg_data[0];

187

return data->rx_msg_data[0];

188

}

188

}

189

190

static int ibmpex_query_sensor_name(struct ibmpex_bmc_data *data, int sensor)

190

static int ibmpex_query_sensor_name(struct ibmpex_bmc_data *data, int sensor)

191

{

191

{

192

data->tx_msg_data[0] = PEX_GET_SENSOR_NAME;

192

data->tx_msg_data[0] = PEX_GET_SENSOR_NAME;

193

data->tx_msg_data[1] = sensor;

193

data->tx_msg_data[1] = sensor;

194

data->tx_message.data_len = 2;

194

data->tx_message.data_len = 2;

195

ibmpex_send_message(data);

195

ibmpex_send_message(data);

196

197

wait_for_completion(&data->read_complete);

197

wait_for_completion(&data->read_complete);

198

199

if (data->rx_result || data->rx_msg_len < 1)

199

if (data->rx_result || data->rx_msg_len < 1)

200

return -ENOENT;

200

return -ENOENT;

201

202

return 0;

202

return 0;

203

}

203

}

204

205

static int ibmpex_query_sensor_data(struct ibmpex_bmc_data *data, int sensor)

205

static int ibmpex_query_sensor_data(struct ibmpex_bmc_data *data, int sensor)

206

{

206

{

207

data->tx_msg_data[0] = PEX_GET_SENSOR_DATA;

207

data->tx_msg_data[0] = PEX_GET_SENSOR_DATA;

208

data->tx_msg_data[1] = sensor;

208

data->tx_msg_data[1] = sensor;

209

data->tx_message.data_len = 2;

209

data->tx_message.data_len = 2;

210

ibmpex_send_message(data);

210

ibmpex_send_message(data);

211

212

wait_for_completion(&data->read_complete);

212

wait_for_completion(&data->read_complete);

213

214

if (data->rx_result || data->rx_msg_len < 26) {

214

if (data->rx_result || data->rx_msg_len < 26) {

215

dev_err(data->bmc_device, "Error reading sensor %d.\n",

215

dev_err(data->bmc_device, "Error reading sensor %d.\n",

216

sensor);

216

sensor);

217

return -ENOENT;

217

return -ENOENT;

218

}

218

}

219

220

return 0;

220

return 0;

221

}

221

}

222

223

static int ibmpex_reset_high_low_data(struct ibmpex_bmc_data *data)

223

static int ibmpex_reset_high_low_data(struct ibmpex_bmc_data *data)

224

{

224

{

225

data->tx_msg_data[0] = PEX_RESET_HIGH_LOW;

225

data->tx_msg_data[0] = PEX_RESET_HIGH_LOW;

226

data->tx_message.data_len = 1;

226

data->tx_message.data_len = 1;

227

ibmpex_send_message(data);

227

ibmpex_send_message(data);

228

229

wait_for_completion(&data->read_complete);

229

wait_for_completion(&data->read_complete);

230

231

return 0;

231

return 0;

232

}

232

}

233

234

static void ibmpex_update_device(struct ibmpex_bmc_data *data)

234

static void ibmpex_update_device(struct ibmpex_bmc_data *data)

235

{

235

{

236

int i, err;

236

int i, err;

237

238

mutex_lock(&data->lock);

238

mutex_lock(&data->lock);

239

if (time_before(jiffies, data->last_updated + REFRESH_INTERVAL) &&

239

if (time_before(jiffies, data->last_updated + REFRESH_INTERVAL) &&

240

data->valid)

240

data->valid)

241

goto out;

241

goto out;

242

243

for (i = 0; i < data->num_sensors; i++) {

243

for (i = 0; i < data->num_sensors; i++) {

244

if (!data->sensors[i].in_use)

244

if (!data->sensors[i].in_use)

245

continue;

245

continue;

246

err = ibmpex_query_sensor_data(data, i);

246

err = ibmpex_query_sensor_data(data, i);

247

if (err)

247

if (err)

248

continue;

248

continue;

249

data->sensors[i].values[0] =

249

data->sensors[i].values[0] =

250

extract_value(data->rx_msg_data, 16);

250

extract_value(data->rx_msg_data, 16);

251

data->sensors[i].values[1] =

251

data->sensors[i].values[1] =

252

extract_value(data->rx_msg_data, 18);

252

extract_value(data->rx_msg_data, 18);

253

data->sensors[i].values[2] =

253

data->sensors[i].values[2] =

254

extract_value(data->rx_msg_data, 20);

254

extract_value(data->rx_msg_data, 20);

255

}

255

}

256

257

data->last_updated = jiffies;

257

data->last_updated = jiffies;

258

data->valid = 1;

258

data->valid = 1;

259

260

out:

260

out:

261

mutex_unlock(&data->lock);

261

mutex_unlock(&data->lock);

262

}

262

}

263

264

static struct ibmpex_bmc_data *get_bmc_data(int iface)

264

static struct ibmpex_bmc_data *get_bmc_data(int iface)

265

{

265

{

266

struct ibmpex_bmc_data *p, *next;

266

struct ibmpex_bmc_data *p, *next;

267

268

list_for_each_entry_safe(p, next, &driver_data.bmc_data, list)

268

list_for_each_entry_safe(p, next, &driver_data.bmc_data, list)

269

if (p->interface == iface)

269

if (p->interface == iface)

270

return p;

270

return p;

271

272

return NULL;

272

return NULL;

273

}

273

}

274

275

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

275

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

276

char *buf)

276

char *buf)

277

{

277

{

278

return sprintf(buf, "%s\n", DRVNAME);

278

return sprintf(buf, "%s\n", DRVNAME);

279

}

279

}

280

static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);

280

static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);

281

282

static ssize_t ibmpex_show_sensor(struct device *dev,

282

static ssize_t ibmpex_show_sensor(struct device *dev,

283

struct device_attribute *devattr,

283

struct device_attribute *devattr,

284

char *buf)

284

char *buf)

285

{

285

{

286

struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);

286

struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);

287

struct ibmpex_bmc_data *data = dev_get_drvdata(dev);

287

struct ibmpex_bmc_data *data = dev_get_drvdata(dev);

288

int mult = data->sensors[attr->index].multiplier;

288

int mult = data->sensors[attr->index].multiplier;

289

ibmpex_update_device(data);

289

ibmpex_update_device(data);

290

291

return sprintf(buf, "%d\n",

291

return sprintf(buf, "%d\n",

292

data->sensors[attr->index].values[attr->nr] * mult);

292

data->sensors[attr->index].values[attr->nr] * mult);

293

}

293

}

294

295

static ssize_t ibmpex_reset_high_low(struct device *dev,

295

static ssize_t ibmpex_reset_high_low(struct device *dev,

296

struct device_attribute *devattr,

296

struct device_attribute *devattr,

297

const char *buf,

297

const char *buf,

298

size_t count)

298

size_t count)

299

{

299

{

300

struct ibmpex_bmc_data *data = dev_get_drvdata(dev);

300

struct ibmpex_bmc_data *data = dev_get_drvdata(dev);

301

302

ibmpex_reset_high_low_data(data);

302

ibmpex_reset_high_low_data(data);

303

304

return count;

304

return count;

305

}

305

}

306

307

static SENSOR_DEVICE_ATTR(reset_high_low, S_IWUSR, NULL,

307

static SENSOR_DEVICE_ATTR(reset_high_low, S_IWUSR, NULL,

308

ibmpex_reset_high_low, 0);

308

ibmpex_reset_high_low, 0);

309

310

static int is_power_sensor(const char *sensor_id, int len)

310

static int is_power_sensor(const char *sensor_id, int len)

311

{

311

{

312

if (len < PEX_SENSOR_TYPE_LEN)

312

if (len < PEX_SENSOR_TYPE_LEN)

313

return 0;

313

return 0;

314

315

if (!memcmp(sensor_id, power_sensor_sig, PEX_SENSOR_TYPE_LEN))

315

if (!memcmp(sensor_id, power_sensor_sig, PEX_SENSOR_TYPE_LEN))

316

return 1;

316

return 1;

317

return 0;

317

return 0;

318

}

318

}

319

320

static int is_temp_sensor(const char *sensor_id, int len)

320

static int is_temp_sensor(const char *sensor_id, int len)

321

{

321

{

322

if (len < PEX_SENSOR_TYPE_LEN)

322

if (len < PEX_SENSOR_TYPE_LEN)

323

return 0;

323

return 0;

324

325

if (!memcmp(sensor_id, temp_sensor_sig, PEX_SENSOR_TYPE_LEN))

325

if (!memcmp(sensor_id, temp_sensor_sig, PEX_SENSOR_TYPE_LEN))

326

return 1;

326

return 1;

327

return 0;

327

return 0;

328

}

328

}

329

330

static int power_sensor_multiplier(struct ibmpex_bmc_data *data,

330

static int power_sensor_multiplier(struct ibmpex_bmc_data *data,

331

const char *sensor_id, int len)

331

const char *sensor_id, int len)

332

{

332

{

333

int i;

333

int i;

334

335

if (data->sensor_major == 2)

335

if (data->sensor_major == 2)

336

return 1000000;

336

return 1000000;

337

338

for (i = PEX_SENSOR_TYPE_LEN; i < len - 1; i++)

338

for (i = PEX_SENSOR_TYPE_LEN; i < len - 1; i++)

339

if (!memcmp(&sensor_id[i], watt_sensor_sig, PEX_MULT_LEN))

339

if (!memcmp(&sensor_id[i], watt_sensor_sig, PEX_MULT_LEN))

340

return 1000000;

340

return 1000000;

341

342

return 100000;

342

return 100000;

343

}

343

}

344

345

static int create_sensor(struct ibmpex_bmc_data *data, int type,

345

static int create_sensor(struct ibmpex_bmc_data *data, int type,

346

int counter, int sensor, int func)

346

int counter, int sensor, int func)

347

{

347

{

348

int err;

348

int err;

349

char *n;

349

char *n;

350

351

n = kmalloc(32, GFP_KERNEL);

351

n = kmalloc(32, GFP_KERNEL);

352

if (!n)

352

if (!n)

353

return -ENOMEM;

353

return -ENOMEM;

354

355

if (type == TEMP_SENSOR)

355

if (type == TEMP_SENSOR)

356

sprintf(n, temp_sensor_name_templates[func], "temp", counter);

356

sprintf(n, temp_sensor_name_templates[func], "temp", counter);

357

else if (type == POWER_SENSOR)

357

else if (type == POWER_SENSOR)

358

sprintf(n, power_sensor_name_templates[func], "power", counter);

358

sprintf(n, power_sensor_name_templates[func], "power", counter);

359

360

data->sensors[sensor].attr[func].dev_attr.attr.name = n;

360

data->sensors[sensor].attr[func].dev_attr.attr.name = n;

361

data->sensors[sensor].attr[func].dev_attr.attr.mode = S_IRUGO;

361

data->sensors[sensor].attr[func].dev_attr.attr.mode = S_IRUGO;

362

data->sensors[sensor].attr[func].dev_attr.show = ibmpex_show_sensor;

362

data->sensors[sensor].attr[func].dev_attr.show = ibmpex_show_sensor;

363

data->sensors[sensor].attr[func].index = sensor;

363

data->sensors[sensor].attr[func].index = sensor;

364

data->sensors[sensor].attr[func].nr = func;

364

data->sensors[sensor].attr[func].nr = func;

365

366

err = device_create_file(data->bmc_device,

366

err = device_create_file(data->bmc_device,

367

&data->sensors[sensor].attr[func].dev_attr);

367

&data->sensors[sensor].attr[func].dev_attr);

368

if (err) {

368

if (err) {

369

data->sensors[sensor].attr[func].dev_attr.attr.name = NULL;

369

data->sensors[sensor].attr[func].dev_attr.attr.name = NULL;

370

kfree(n);

370

kfree(n);

371

return err;

371

return err;

372

}

372

}

373

374

return 0;

374

return 0;

375

}

375

}

376

377

static int ibmpex_find_sensors(struct ibmpex_bmc_data *data)

377

static int ibmpex_find_sensors(struct ibmpex_bmc_data *data)

378

{

378

{

379

int i, j, err;

379

int i, j, err;

380

int sensor_type;

380

int sensor_type;

381

int sensor_counter;

381

int sensor_counter;

382

int num_power = 0;

382

int num_power = 0;

383

int num_temp = 0;

383

int num_temp = 0;

384

385

err = ibmpex_query_sensor_count(data);

385

err = ibmpex_query_sensor_count(data);

386

if (err <= 0)

386

if (err <= 0)

387

return -ENOENT;

387

return -ENOENT;

388

data->num_sensors = err;

388

data->num_sensors = err;

389

390

data->sensors = kzalloc(data->num_sensors * sizeof(*data->sensors),

390

data->sensors = kzalloc(data->num_sensors * sizeof(*data->sensors),

391

GFP_KERNEL);

391

GFP_KERNEL);

392

if (!data->sensors)

392

if (!data->sensors)

393

return -ENOMEM;

393

return -ENOMEM;

394

395

for (i = 0; i < data->num_sensors; i++) {

395

for (i = 0; i < data->num_sensors; i++) {

396

err = ibmpex_query_sensor_name(data, i);

396

err = ibmpex_query_sensor_name(data, i);

397

if (err)

397

if (err)

398

continue;

398

continue;

399

400

if (is_power_sensor(data->rx_msg_data, data->rx_msg_len)) {

400

if (is_power_sensor(data->rx_msg_data, data->rx_msg_len)) {

401

sensor_type = POWER_SENSOR;

401

sensor_type = POWER_SENSOR;

402

num_power++;

402

num_power++;

403

sensor_counter = num_power;

403

sensor_counter = num_power;

404

data->sensors[i].multiplier =

404

data->sensors[i].multiplier =

405

power_sensor_multiplier(data,

405

power_sensor_multiplier(data,

406

data->rx_msg_data,

406

data->rx_msg_data,

407

data->rx_msg_len);

407

data->rx_msg_len);

408

} else if (is_temp_sensor(data->rx_msg_data,

408

} else if (is_temp_sensor(data->rx_msg_data,

409

data->rx_msg_len)) {

409

data->rx_msg_len)) {

410

sensor_type = TEMP_SENSOR;

410

sensor_type = TEMP_SENSOR;

411

num_temp++;

411

num_temp++;

412

sensor_counter = num_temp;

412

sensor_counter = num_temp;

413

data->sensors[i].multiplier = 1000;

413

data->sensors[i].multiplier = 1000;

414

} else

414

} else

415

continue;

415

continue;

416

417

data->sensors[i].in_use = 1;

417

data->sensors[i].in_use = 1;

418

419

/* Create attributes */

419

/* Create attributes */

420

for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) {

420

for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) {

421

err = create_sensor(data, sensor_type, sensor_counter,

421

err = create_sensor(data, sensor_type, sensor_counter,

422

i, j);

422

i, j);

423

if (err)

423

if (err)

424

goto exit_remove;

424

goto exit_remove;

425

}

425

}

426

}

426

}

427

428

err = device_create_file(data->bmc_device,

428

err = device_create_file(data->bmc_device,

429

&sensor_dev_attr_reset_high_low.dev_attr);

429

&sensor_dev_attr_reset_high_low.dev_attr);

430

if (err)

430

if (err)

431

goto exit_remove;

431

goto exit_remove;

432

433

err = device_create_file(data->bmc_device,

433

err = device_create_file(data->bmc_device,

434

&sensor_dev_attr_name.dev_attr);

434

&sensor_dev_attr_name.dev_attr);

435

if (err)

435

if (err)

436

goto exit_remove;

436

goto exit_remove;

437

438

return 0;

438

return 0;

439

440

exit_remove:

440

exit_remove:

441

device_remove_file(data->bmc_device,

441

device_remove_file(data->bmc_device,

442

&sensor_dev_attr_reset_high_low.dev_attr);

442

&sensor_dev_attr_reset_high_low.dev_attr);

443

device_remove_file(data->bmc_device, &sensor_dev_attr_name.dev_attr);

443

device_remove_file(data->bmc_device, &sensor_dev_attr_name.dev_attr);

444

for (i = 0; i < data->num_sensors; i++)

444

for (i = 0; i < data->num_sensors; i++)

445

for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) {

445

for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) {

446

if (!data->sensors[i].attr[j].dev_attr.attr.name)

446

if (!data->sensors[i].attr[j].dev_attr.attr.name)

447

continue;

447

continue;

448

device_remove_file(data->bmc_device,

448

device_remove_file(data->bmc_device,

449

&data->sensors[i].attr[j].dev_attr);

449

&data->sensors[i].attr[j].dev_attr);

450

kfree(data->sensors[i].attr[j].dev_attr.attr.name);

450

kfree(data->sensors[i].attr[j].dev_attr.attr.name);

451

}

451

}

452

453

kfree(data->sensors);

453

kfree(data->sensors);

454

return err;

454

return err;

455

}

455

}

456

457

static void ibmpex_register_bmc(int iface, struct device *dev)

457

static void ibmpex_register_bmc(int iface, struct device *dev)

458

{

458

{

459

struct ibmpex_bmc_data *data;

459

struct ibmpex_bmc_data *data;

460

int err;

460

int err;

461

462

data = kzalloc(sizeof(*data), GFP_KERNEL);

462

data = kzalloc(sizeof(*data), GFP_KERNEL);

463

if (!data) {

463

if (!data) {

464

dev_err(dev, "Insufficient memory for BMC interface.\n");

464

dev_err(dev, "Insufficient memory for BMC interface.\n");

465

return;

465

return;

466

}

466

}

467

468

data->address.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;

468

data->address.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;

469

data->address.channel = IPMI_BMC_CHANNEL;

469

data->address.channel = IPMI_BMC_CHANNEL;

470

data->address.data[0] = 0;

470

data->address.data[0] = 0;

471

data->interface = iface;

471

data->interface = iface;

472

data->bmc_device = dev;

472

data->bmc_device = dev;

473

474

/* Create IPMI messaging interface user */

474

/* Create IPMI messaging interface user */

475

err = ipmi_create_user(data->interface, &driver_data.ipmi_hndlrs,

475

err = ipmi_create_user(data->interface, &driver_data.ipmi_hndlrs,

476

data, &data->user);

476

data, &data->user);

477

if (err < 0) {

477

if (err < 0) {

478

dev_err(dev, "Unable to register user with IPMI "

478

dev_err(dev, "Unable to register user with IPMI "

479

"interface %d\n", data->interface);

479

"interface %d\n", data->interface);

480

goto out;

480

goto out;

481

}

481

}

482

483

mutex_init(&data->lock);

483

mutex_init(&data->lock);

484

485

/* Initialize message */

485

/* Initialize message */

486

data->tx_msgid = 0;

486

data->tx_msgid = 0;

487

init_completion(&data->read_complete);

487

init_completion(&data->read_complete);

488

data->tx_message.netfn = PEX_NET_FUNCTION;

488

data->tx_message.netfn = PEX_NET_FUNCTION;

489

data->tx_message.cmd = PEX_COMMAND;

489

data->tx_message.cmd = PEX_COMMAND;

490

data->tx_message.data = data->tx_msg_data;

490

data->tx_message.data = data->tx_msg_data;

491

492

/* Does this BMC support PowerExecutive? */

492

/* Does this BMC support PowerExecutive? */

493

err = ibmpex_ver_check(data);

493

err = ibmpex_ver_check(data);

494

if (err)

494

if (err)

495

goto out_user;

495

goto out_user;

496

497

/* Register the BMC as a HWMON class device */

497

/* Register the BMC as a HWMON class device */

498

data->hwmon_dev = hwmon_device_register(data->bmc_device);

498

data->hwmon_dev = hwmon_device_register(data->bmc_device);

499

500

if (IS_ERR(data->hwmon_dev)) {

500

if (IS_ERR(data->hwmon_dev)) {

501

dev_err(data->bmc_device, "Unable to register hwmon "

501

dev_err(data->bmc_device, "Unable to register hwmon "

502

"device for IPMI interface %d\n",

502

"device for IPMI interface %d\n",

503

data->interface);

503

data->interface);

504

goto out_user;

504

goto out_user;

505

}

505

}

506

507

/* finally add the new bmc data to the bmc data list */

507

/* finally add the new bmc data to the bmc data list */

508

dev_set_drvdata(dev, data);

508

dev_set_drvdata(dev, data);

509

list_add_tail(&data->list, &driver_data.bmc_data);

509

list_add_tail(&data->list, &driver_data.bmc_data);

510

511

/* Now go find all the sensors */

511

/* Now go find all the sensors */

512

err = ibmpex_find_sensors(data);

512

err = ibmpex_find_sensors(data);

513

if (err) {

513

if (err) {

514

dev_err(data->bmc_device, "Error %d finding sensors\n", err);

514

dev_err(data->bmc_device, "Error %d finding sensors\n", err);

515

goto out_register;

515

goto out_register;

516

}

516

}

517

518

return;

518

return;

519

520

out_register:

520

out_register:

521

hwmon_device_unregister(data->hwmon_dev);

521

hwmon_device_unregister(data->hwmon_dev);

522

out_user:

522

out_user:

523

ipmi_destroy_user(data->user);

523

ipmi_destroy_user(data->user);

524

out:

524

out:

525

kfree(data);

525

kfree(data);

526

}

526

}

527

528

static void ibmpex_bmc_delete(struct ibmpex_bmc_data *data)

528

static void ibmpex_bmc_delete(struct ibmpex_bmc_data *data)

529

{

529

{

530

int i, j;

530

int i, j;

531

532

device_remove_file(data->bmc_device,

532

device_remove_file(data->bmc_device,

533

&sensor_dev_attr_reset_high_low.dev_attr);

533

&sensor_dev_attr_reset_high_low.dev_attr);

534

device_remove_file(data->bmc_device, &sensor_dev_attr_name.dev_attr);

534

device_remove_file(data->bmc_device, &sensor_dev_attr_name.dev_attr);

535

for (i = 0; i < data->num_sensors; i++)

535

for (i = 0; i < data->num_sensors; i++)

536

for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) {

536

for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) {

537

if (!data->sensors[i].attr[j].dev_attr.attr.name)

537

if (!data->sensors[i].attr[j].dev_attr.attr.name)

538

continue;

538

continue;

539

device_remove_file(data->bmc_device,

539

device_remove_file(data->bmc_device,

540

&data->sensors[i].attr[j].dev_attr);

540

&data->sensors[i].attr[j].dev_attr);

541

kfree(data->sensors[i].attr[j].dev_attr.attr.name);

541

kfree(data->sensors[i].attr[j].dev_attr.attr.name);

542

}

542

}

543

544

list_del(&data->list);

544

list_del(&data->list);

545

dev_set_drvdata(data->bmc_device, NULL);

545

dev_set_drvdata(data->bmc_device, NULL);

546

hwmon_device_unregister(data->hwmon_dev);

546

hwmon_device_unregister(data->hwmon_dev);

547

ipmi_destroy_user(data->user);

547

ipmi_destroy_user(data->user);

548

kfree(data->sensors);

548

kfree(data->sensors);

549

kfree(data);

549

kfree(data);

550

}

550

}

551

552

static void ibmpex_bmc_gone(int iface)

552

static void ibmpex_bmc_gone(int iface)

553

{

553

{

554

struct ibmpex_bmc_data *data = get_bmc_data(iface);

554

struct ibmpex_bmc_data *data = get_bmc_data(iface);

555

556

if (!data)

556

if (!data)

557

return;

557

return;

558

559

ibmpex_bmc_delete(data);

559

ibmpex_bmc_delete(data);

560

}

560

}

561

562

static void ibmpex_msg_handler(struct ipmi_recv_msg *msg, void *user_msg_data)

562

static void ibmpex_msg_handler(struct ipmi_recv_msg *msg, void *user_msg_data)

563

{

563

{

564

struct ibmpex_bmc_data *data = (struct ibmpex_bmc_data *)user_msg_data;

564

struct ibmpex_bmc_data *data = (struct ibmpex_bmc_data *)user_msg_data;

565

566

if (msg->msgid != data->tx_msgid) {

566

if (msg->msgid != data->tx_msgid) {

567

dev_err(data->bmc_device, "Mismatch between received msgid "

567

dev_err(data->bmc_device, "Mismatch between received msgid "

568

"(%02x) and transmitted msgid (%02x)!\n",

568

"(%02x) and transmitted msgid (%02x)!\n",

569

(int)msg->msgid,

569

(int)msg->msgid,

570

(int)data->tx_msgid);

570

(int)data->tx_msgid);

571

ipmi_free_recv_msg(msg);

571

ipmi_free_recv_msg(msg);

572

return;

572

return;

573

}

573

}

574

575

data->rx_recv_type = msg->recv_type;

575

data->rx_recv_type = msg->recv_type;

576

if (msg->msg.data_len > 0)

576

if (msg->msg.data_len > 0)

577

data->rx_result = msg->msg.data[0];

577

data->rx_result = msg->msg.data[0];

578

else

578

else

579

data->rx_result = IPMI_UNKNOWN_ERR_COMPLETION_CODE;

579

data->rx_result = IPMI_UNKNOWN_ERR_COMPLETION_CODE;

580

581

if (msg->msg.data_len > 1) {

581

if (msg->msg.data_len > 1) {

582

data->rx_msg_len = msg->msg.data_len - 1;

582

data->rx_msg_len = msg->msg.data_len - 1;

583

memcpy(data->rx_msg_data, msg->msg.data + 1, data->rx_msg_len);

583

memcpy(data->rx_msg_data, msg->msg.data + 1, data->rx_msg_len);

584

} else

584

} else

585

data->rx_msg_len = 0;

585

data->rx_msg_len = 0;

586

587

ipmi_free_recv_msg(msg);

587

ipmi_free_recv_msg(msg);

588

complete(&data->read_complete);

588

complete(&data->read_complete);

589

}

589

}

590

591

static int __init ibmpex_init(void)

591

static int __init ibmpex_init(void)

592

{

592

{

593

return ipmi_smi_watcher_register(&driver_data.bmc_events);

593

return ipmi_smi_watcher_register(&driver_data.bmc_events);

594

}

594

}

595

596

static void __exit ibmpex_exit(void)

596

static void __exit ibmpex_exit(void)

597

{

597

{

598

struct ibmpex_bmc_data *p, *next;

598

struct ibmpex_bmc_data *p, *next;

599

600

ipmi_smi_watcher_unregister(&driver_data.bmc_events);

600

ipmi_smi_watcher_unregister(&driver_data.bmc_events);

601

list_for_each_entry_safe(p, next, &driver_data.bmc_data, list)

601

list_for_each_entry_safe(p, next, &driver_data.bmc_data, list)

602

ibmpex_bmc_delete(p);

602

ibmpex_bmc_delete(p);

603

}

603

}

604

605

MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");

605

MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");

606

MODULE_DESCRIPTION("IBM PowerExecutive power/temperature sensor driver");

606

MODULE_DESCRIPTION("IBM PowerExecutive power/temperature sensor driver");

607

MODULE_LICENSE("GPL");

607

MODULE_LICENSE("GPL");

608

609

module_init(ibmpex_init);

609

module_init(ibmpex_init);

610

module_exit(ibmpex_exit);

610

module_exit(ibmpex_exit);

611

612

MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3350-*");

612

MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3350-*");

613

MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3550-*");

613

MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3550-*");

614

MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3650-*");

614

MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3650-*");

615

MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3655-*");

615

MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3655-*");

616

MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3755-*");

616

MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3755-*");

617

GITLAB

Eric Lee / smarc-fsl-linux-kernel

ibmpex: add endian annotation to extract_data() helper