2 * A hwmon driver for the IBM System Director Active Energy Manager (AEM)
3 * temperature/power/energy sensors and capping functionality.
4 * Copyright (C) 2008 IBM
6 * Author: Darrick J. Wong <djwong@us.ibm.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25 #include <linux/ipmi.h>
26 #include <linux/module.h>
27 #include <linux/hwmon.h>
28 #include <linux/hwmon-sysfs.h>
29 #include <linux/jiffies.h>
30 #include <linux/mutex.h>
31 #include <linux/kdev_t.h>
32 #include <linux/spinlock.h>
33 #include <linux/idr.h>
34 #include <linux/slab.h>
35 #include <linux/sched.h>
36 #include <linux/platform_device.h>
37 #include <linux/math64.h>
38 #include <linux/time.h>
40 #define REFRESH_INTERVAL (HZ)
41 #define IPMI_TIMEOUT (30 * HZ)
44 #define AEM_NETFN 0x2E
46 #define AEM_FIND_FW_CMD 0x80
47 #define AEM_ELEMENT_CMD 0x81
48 #define AEM_FW_INSTANCE_CMD 0x82
50 #define AEM_READ_ELEMENT_CFG 0x80
51 #define AEM_READ_BUFFER 0x81
52 #define AEM_READ_REGISTER 0x82
53 #define AEM_WRITE_REGISTER 0x83
54 #define AEM_SET_REG_MASK 0x84
55 #define AEM_CLEAR_REG_MASK 0x85
56 #define AEM_READ_ELEMENT_CFG2 0x86
58 #define AEM_CONTROL_ELEMENT 0
59 #define AEM_ENERGY_ELEMENT 1
60 #define AEM_CLOCK_ELEMENT 4
61 #define AEM_POWER_CAP_ELEMENT 7
62 #define AEM_EXHAUST_ELEMENT 9
63 #define AEM_POWER_ELEMENT 10
65 #define AEM_MODULE_TYPE_ID 0x0001
67 #define AEM2_NUM_ENERGY_REGS 2
68 #define AEM2_NUM_PCAP_REGS 6
69 #define AEM2_NUM_TEMP_REGS 2
70 #define AEM2_NUM_SENSORS 14
72 #define AEM1_NUM_ENERGY_REGS 1
73 #define AEM1_NUM_SENSORS 3
75 /* AEM 2.x has more energy registers */
76 #define AEM_NUM_ENERGY_REGS AEM2_NUM_ENERGY_REGS
77 /* AEM 2.x needs more sensor files */
78 #define AEM_NUM_SENSORS AEM2_NUM_SENSORS
81 #define POWER_CAP_MAX_HOTPLUG 1
82 #define POWER_CAP_MAX 2
83 #define POWER_CAP_MIN_WARNING 3
84 #define POWER_CAP_MIN 4
87 #define AEM_DEFAULT_POWER_INTERVAL 1000
88 #define AEM_MIN_POWER_INTERVAL 200
89 #define UJ_PER_MJ 1000L
91 static DEFINE_IDA(aem_ida
);
93 static struct platform_driver aem_driver
= {
96 .bus
= &platform_bus_type
,
100 struct aem_ipmi_data
{
101 struct completion read_complete
;
102 struct ipmi_addr address
;
106 struct kernel_ipmi_msg tx_message
;
110 unsigned short rx_msg_len
;
111 unsigned char rx_result
;
114 struct device
*bmc_device
;
117 struct aem_ro_sensor_template
{
119 ssize_t (*show
)(struct device
*dev
,
120 struct device_attribute
*devattr
,
125 struct aem_rw_sensor_template
{
127 ssize_t (*show
)(struct device
*dev
,
128 struct device_attribute
*devattr
,
130 ssize_t (*set
)(struct device
*dev
,
131 struct device_attribute
*devattr
,
132 const char *buf
, size_t count
);
137 struct list_head list
;
139 struct device
*hwmon_dev
;
140 struct platform_device
*pdev
;
143 unsigned long last_updated
; /* In jiffies */
148 struct aem_ipmi_data ipmi
;
150 /* Function to update sensors */
151 void (*update
)(struct aem_data
*data
);
162 * Two temperature sensors
163 * Six power cap registers
167 struct sensor_device_attribute sensors
[AEM_NUM_SENSORS
];
169 /* energy use in mJ */
170 u64 energy
[AEM_NUM_ENERGY_REGS
];
172 /* power sampling interval in ms */
173 unsigned long power_period
[AEM_NUM_ENERGY_REGS
];
175 /* Everything past here is for AEM2 only */
177 /* power caps in dW */
178 u16 pcap
[AEM2_NUM_PCAP_REGS
];
180 /* exhaust temperature in C */
181 u8 temp
[AEM2_NUM_TEMP_REGS
];
184 /* Data structures returned by the AEM firmware */
188 static struct aem_iana_id system_x_id
= {
189 .bytes
= {0x4D, 0x4F, 0x00}
192 /* These are used to find AEM1 instances */
193 struct aem_find_firmware_req
{
194 struct aem_iana_id id
;
197 __be16 module_type_id
;
200 struct aem_find_firmware_resp
{
201 struct aem_iana_id id
;
205 /* These are used to find AEM2 instances */
206 struct aem_find_instance_req
{
207 struct aem_iana_id id
;
209 __be16 module_type_id
;
212 struct aem_find_instance_resp
{
213 struct aem_iana_id id
;
221 /* These are used to query sensors */
222 struct aem_read_sensor_req
{
223 struct aem_iana_id id
;
231 struct aem_read_sensor_resp
{
232 struct aem_iana_id id
;
236 /* Data structures to talk to the IPMI layer */
237 struct aem_driver_data
{
238 struct list_head aem_devices
;
239 struct ipmi_smi_watcher bmc_events
;
240 struct ipmi_user_hndl ipmi_hndlrs
;
243 static void aem_register_bmc(int iface
, struct device
*dev
);
244 static void aem_bmc_gone(int iface
);
245 static void aem_msg_handler(struct ipmi_recv_msg
*msg
, void *user_msg_data
);
247 static void aem_remove_sensors(struct aem_data
*data
);
248 static int aem1_find_sensors(struct aem_data
*data
);
249 static int aem2_find_sensors(struct aem_data
*data
);
250 static void update_aem1_sensors(struct aem_data
*data
);
251 static void update_aem2_sensors(struct aem_data
*data
);
253 static struct aem_driver_data driver_data
= {
254 .aem_devices
= LIST_HEAD_INIT(driver_data
.aem_devices
),
256 .owner
= THIS_MODULE
,
257 .new_smi
= aem_register_bmc
,
258 .smi_gone
= aem_bmc_gone
,
261 .ipmi_recv_hndl
= aem_msg_handler
,
265 /* Functions to talk to the IPMI layer */
267 /* Initialize IPMI address, message buffers and user data */
268 static int aem_init_ipmi_data(struct aem_ipmi_data
*data
, int iface
,
273 init_completion(&data
->read_complete
);
274 data
->bmc_device
= bmc
;
276 /* Initialize IPMI address */
277 data
->address
.addr_type
= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
;
278 data
->address
.channel
= IPMI_BMC_CHANNEL
;
279 data
->address
.data
[0] = 0;
280 data
->interface
= iface
;
282 /* Initialize message buffers */
284 data
->tx_message
.netfn
= AEM_NETFN
;
286 /* Create IPMI messaging interface user */
287 err
= ipmi_create_user(data
->interface
, &driver_data
.ipmi_hndlrs
,
290 dev_err(bmc
, "Unable to register user with IPMI "
291 "interface %d\n", data
->interface
);
298 /* Send an IPMI command */
299 static int aem_send_message(struct aem_ipmi_data
*data
)
303 err
= ipmi_validate_addr(&data
->address
, sizeof(data
->address
));
308 err
= ipmi_request_settime(data
->user
, &data
->address
, data
->tx_msgid
,
309 &data
->tx_message
, data
, 0, 0, 0);
315 dev_err(data
->bmc_device
, "request_settime=%x\n", err
);
318 dev_err(data
->bmc_device
, "validate_addr=%x\n", err
);
322 /* Dispatch IPMI messages to callers */
323 static void aem_msg_handler(struct ipmi_recv_msg
*msg
, void *user_msg_data
)
325 unsigned short rx_len
;
326 struct aem_ipmi_data
*data
= user_msg_data
;
328 if (msg
->msgid
!= data
->tx_msgid
) {
329 dev_err(data
->bmc_device
, "Mismatch between received msgid "
330 "(%02x) and transmitted msgid (%02x)!\n",
332 (int)data
->tx_msgid
);
333 ipmi_free_recv_msg(msg
);
337 data
->rx_recv_type
= msg
->recv_type
;
338 if (msg
->msg
.data_len
> 0)
339 data
->rx_result
= msg
->msg
.data
[0];
341 data
->rx_result
= IPMI_UNKNOWN_ERR_COMPLETION_CODE
;
343 if (msg
->msg
.data_len
> 1) {
344 rx_len
= msg
->msg
.data_len
- 1;
345 if (data
->rx_msg_len
< rx_len
)
346 rx_len
= data
->rx_msg_len
;
347 data
->rx_msg_len
= rx_len
;
348 memcpy(data
->rx_msg_data
, msg
->msg
.data
+ 1, data
->rx_msg_len
);
350 data
->rx_msg_len
= 0;
352 ipmi_free_recv_msg(msg
);
353 complete(&data
->read_complete
);
356 /* Sensor support functions */
358 /* Read a sensor value */
359 static int aem_read_sensor(struct aem_data
*data
, u8 elt
, u8 reg
,
360 void *buf
, size_t size
)
363 struct aem_read_sensor_req rs_req
;
364 struct aem_read_sensor_resp
*rs_resp
;
365 struct aem_ipmi_data
*ipmi
= &data
->ipmi
;
367 /* AEM registers are 1, 2, 4 or 8 bytes */
378 rs_req
.id
= system_x_id
;
379 rs_req
.module_handle
= data
->module_handle
;
380 rs_req
.element
= elt
;
381 rs_req
.subcommand
= AEM_READ_REGISTER
;
383 rs_req
.rx_buf_size
= size
;
385 ipmi
->tx_message
.cmd
= AEM_ELEMENT_CMD
;
386 ipmi
->tx_message
.data
= (char *)&rs_req
;
387 ipmi
->tx_message
.data_len
= sizeof(rs_req
);
389 rs_size
= sizeof(*rs_resp
) + size
;
390 rs_resp
= kzalloc(rs_size
, GFP_KERNEL
);
394 ipmi
->rx_msg_data
= rs_resp
;
395 ipmi
->rx_msg_len
= rs_size
;
397 aem_send_message(ipmi
);
399 res
= wait_for_completion_timeout(&ipmi
->read_complete
, IPMI_TIMEOUT
);
405 if (ipmi
->rx_result
|| ipmi
->rx_msg_len
!= rs_size
||
406 memcmp(&rs_resp
->id
, &system_x_id
, sizeof(system_x_id
))) {
414 *x
= rs_resp
->bytes
[0];
419 *x
= be16_to_cpup((__be16
*)rs_resp
->bytes
);
424 *x
= be32_to_cpup((__be32
*)rs_resp
->bytes
);
429 *x
= be64_to_cpup((__be64
*)rs_resp
->bytes
);
440 /* Update AEM energy registers */
441 static void update_aem_energy_one(struct aem_data
*data
, int which
)
443 aem_read_sensor(data
, AEM_ENERGY_ELEMENT
, which
,
444 &data
->energy
[which
], 8);
447 static void update_aem_energy(struct aem_data
*data
)
449 update_aem_energy_one(data
, 0);
450 if (data
->ver_major
< 2)
452 update_aem_energy_one(data
, 1);
455 /* Update all AEM1 sensors */
456 static void update_aem1_sensors(struct aem_data
*data
)
458 mutex_lock(&data
->lock
);
459 if (time_before(jiffies
, data
->last_updated
+ REFRESH_INTERVAL
) &&
463 update_aem_energy(data
);
465 mutex_unlock(&data
->lock
);
468 /* Update all AEM2 sensors */
469 static void update_aem2_sensors(struct aem_data
*data
)
473 mutex_lock(&data
->lock
);
474 if (time_before(jiffies
, data
->last_updated
+ REFRESH_INTERVAL
) &&
478 update_aem_energy(data
);
479 aem_read_sensor(data
, AEM_EXHAUST_ELEMENT
, 0, &data
->temp
[0], 1);
480 aem_read_sensor(data
, AEM_EXHAUST_ELEMENT
, 1, &data
->temp
[1], 1);
482 for (i
= POWER_CAP
; i
<= POWER_AUX
; i
++)
483 aem_read_sensor(data
, AEM_POWER_CAP_ELEMENT
, i
,
486 mutex_unlock(&data
->lock
);
489 /* Delete an AEM instance */
490 static void aem_delete(struct aem_data
*data
)
492 list_del(&data
->list
);
493 aem_remove_sensors(data
);
494 hwmon_device_unregister(data
->hwmon_dev
);
495 ipmi_destroy_user(data
->ipmi
.user
);
496 platform_set_drvdata(data
->pdev
, NULL
);
497 platform_device_unregister(data
->pdev
);
498 ida_simple_remove(&aem_ida
, data
->id
);
502 /* Probe functions for AEM1 devices */
504 /* Retrieve version and module handle for an AEM1 instance */
505 static int aem_find_aem1_count(struct aem_ipmi_data
*data
)
508 struct aem_find_firmware_req ff_req
;
509 struct aem_find_firmware_resp ff_resp
;
511 ff_req
.id
= system_x_id
;
513 ff_req
.module_type_id
= cpu_to_be16(AEM_MODULE_TYPE_ID
);
515 data
->tx_message
.cmd
= AEM_FIND_FW_CMD
;
516 data
->tx_message
.data
= (char *)&ff_req
;
517 data
->tx_message
.data_len
= sizeof(ff_req
);
519 data
->rx_msg_data
= &ff_resp
;
520 data
->rx_msg_len
= sizeof(ff_resp
);
522 aem_send_message(data
);
524 res
= wait_for_completion_timeout(&data
->read_complete
, IPMI_TIMEOUT
);
528 if (data
->rx_result
|| data
->rx_msg_len
!= sizeof(ff_resp
) ||
529 memcmp(&ff_resp
.id
, &system_x_id
, sizeof(system_x_id
)))
532 return ff_resp
.num_instances
;
535 /* Find and initialize one AEM1 instance */
536 static int aem_init_aem1_inst(struct aem_ipmi_data
*probe
, u8 module_handle
)
538 struct aem_data
*data
;
542 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
545 mutex_init(&data
->lock
);
547 /* Copy instance data */
550 data
->module_handle
= module_handle
;
551 for (i
= 0; i
< AEM1_NUM_ENERGY_REGS
; i
++)
552 data
->power_period
[i
] = AEM_DEFAULT_POWER_INTERVAL
;
554 /* Create sub-device for this fw instance */
555 data
->id
= ida_simple_get(&aem_ida
, 0, 0, GFP_KERNEL
);
559 data
->pdev
= platform_device_alloc(DRVNAME
, data
->id
);
562 data
->pdev
->dev
.driver
= &aem_driver
.driver
;
564 res
= platform_device_add(data
->pdev
);
568 platform_set_drvdata(data
->pdev
, data
);
570 /* Set up IPMI interface */
571 res
= aem_init_ipmi_data(&data
->ipmi
, probe
->interface
,
576 /* Register with hwmon */
577 data
->hwmon_dev
= hwmon_device_register(&data
->pdev
->dev
);
578 if (IS_ERR(data
->hwmon_dev
)) {
579 dev_err(&data
->pdev
->dev
, "Unable to register hwmon "
580 "device for IPMI interface %d\n",
582 res
= PTR_ERR(data
->hwmon_dev
);
586 data
->update
= update_aem1_sensors
;
589 res
= aem1_find_sensors(data
);
593 /* Add to our list of AEM devices */
594 list_add_tail(&data
->list
, &driver_data
.aem_devices
);
596 dev_info(data
->ipmi
.bmc_device
, "Found AEM v%d.%d at 0x%X\n",
597 data
->ver_major
, data
->ver_minor
,
598 data
->module_handle
);
602 hwmon_device_unregister(data
->hwmon_dev
);
604 ipmi_destroy_user(data
->ipmi
.user
);
606 platform_set_drvdata(data
->pdev
, NULL
);
607 platform_device_unregister(data
->pdev
);
609 ida_simple_remove(&aem_ida
, data
->id
);
616 /* Find and initialize all AEM1 instances */
617 static void aem_init_aem1(struct aem_ipmi_data
*probe
)
621 num
= aem_find_aem1_count(probe
);
622 for (i
= 0; i
< num
; i
++) {
623 err
= aem_init_aem1_inst(probe
, i
);
625 dev_err(probe
->bmc_device
,
626 "Error %d initializing AEM1 0x%X\n",
632 /* Probe functions for AEM2 devices */
634 /* Retrieve version and module handle for an AEM2 instance */
635 static int aem_find_aem2(struct aem_ipmi_data
*data
,
636 struct aem_find_instance_resp
*fi_resp
,
640 struct aem_find_instance_req fi_req
;
642 fi_req
.id
= system_x_id
;
643 fi_req
.instance_number
= instance_num
;
644 fi_req
.module_type_id
= cpu_to_be16(AEM_MODULE_TYPE_ID
);
646 data
->tx_message
.cmd
= AEM_FW_INSTANCE_CMD
;
647 data
->tx_message
.data
= (char *)&fi_req
;
648 data
->tx_message
.data_len
= sizeof(fi_req
);
650 data
->rx_msg_data
= fi_resp
;
651 data
->rx_msg_len
= sizeof(*fi_resp
);
653 aem_send_message(data
);
655 res
= wait_for_completion_timeout(&data
->read_complete
, IPMI_TIMEOUT
);
659 if (data
->rx_result
|| data
->rx_msg_len
!= sizeof(*fi_resp
) ||
660 memcmp(&fi_resp
->id
, &system_x_id
, sizeof(system_x_id
)) ||
661 fi_resp
->num_instances
<= instance_num
)
667 /* Find and initialize one AEM2 instance */
668 static int aem_init_aem2_inst(struct aem_ipmi_data
*probe
,
669 struct aem_find_instance_resp
*fi_resp
)
671 struct aem_data
*data
;
675 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
678 mutex_init(&data
->lock
);
680 /* Copy instance data */
681 data
->ver_major
= fi_resp
->major
;
682 data
->ver_minor
= fi_resp
->minor
;
683 data
->module_handle
= fi_resp
->module_handle
;
684 for (i
= 0; i
< AEM2_NUM_ENERGY_REGS
; i
++)
685 data
->power_period
[i
] = AEM_DEFAULT_POWER_INTERVAL
;
687 /* Create sub-device for this fw instance */
688 data
->id
= ida_simple_get(&aem_ida
, 0, 0, GFP_KERNEL
);
692 data
->pdev
= platform_device_alloc(DRVNAME
, data
->id
);
695 data
->pdev
->dev
.driver
= &aem_driver
.driver
;
697 res
= platform_device_add(data
->pdev
);
701 platform_set_drvdata(data
->pdev
, data
);
703 /* Set up IPMI interface */
704 res
= aem_init_ipmi_data(&data
->ipmi
, probe
->interface
,
709 /* Register with hwmon */
710 data
->hwmon_dev
= hwmon_device_register(&data
->pdev
->dev
);
711 if (IS_ERR(data
->hwmon_dev
)) {
712 dev_err(&data
->pdev
->dev
, "Unable to register hwmon "
713 "device for IPMI interface %d\n",
715 res
= PTR_ERR(data
->hwmon_dev
);
719 data
->update
= update_aem2_sensors
;
722 res
= aem2_find_sensors(data
);
726 /* Add to our list of AEM devices */
727 list_add_tail(&data
->list
, &driver_data
.aem_devices
);
729 dev_info(data
->ipmi
.bmc_device
, "Found AEM v%d.%d at 0x%X\n",
730 data
->ver_major
, data
->ver_minor
,
731 data
->module_handle
);
735 hwmon_device_unregister(data
->hwmon_dev
);
737 ipmi_destroy_user(data
->ipmi
.user
);
739 platform_set_drvdata(data
->pdev
, NULL
);
740 platform_device_unregister(data
->pdev
);
742 ida_simple_remove(&aem_ida
, data
->id
);
749 /* Find and initialize all AEM2 instances */
750 static void aem_init_aem2(struct aem_ipmi_data
*probe
)
752 struct aem_find_instance_resp fi_resp
;
756 while (!aem_find_aem2(probe
, &fi_resp
, i
)) {
757 if (fi_resp
.major
!= 2) {
758 dev_err(probe
->bmc_device
, "Unknown AEM v%d; please "
759 "report this to the maintainer.\n",
764 err
= aem_init_aem2_inst(probe
, &fi_resp
);
766 dev_err(probe
->bmc_device
,
767 "Error %d initializing AEM2 0x%X\n",
768 err
, fi_resp
.module_handle
);
774 /* Probe a BMC for AEM firmware instances */
775 static void aem_register_bmc(int iface
, struct device
*dev
)
777 struct aem_ipmi_data probe
;
779 if (aem_init_ipmi_data(&probe
, iface
, dev
))
782 /* Ignore probe errors; they won't cause problems */
783 aem_init_aem1(&probe
);
784 aem_init_aem2(&probe
);
786 ipmi_destroy_user(probe
.user
);
789 /* Handle BMC deletion */
790 static void aem_bmc_gone(int iface
)
792 struct aem_data
*p1
, *next1
;
794 list_for_each_entry_safe(p1
, next1
, &driver_data
.aem_devices
, list
)
795 if (p1
->ipmi
.interface
== iface
)
799 /* sysfs support functions */
801 /* AEM device name */
802 static ssize_t
show_name(struct device
*dev
, struct device_attribute
*devattr
,
805 struct aem_data
*data
= dev_get_drvdata(dev
);
807 return sprintf(buf
, "%s%d\n", DRVNAME
, data
->ver_major
);
809 static SENSOR_DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
, 0);
811 /* AEM device version */
812 static ssize_t
show_version(struct device
*dev
,
813 struct device_attribute
*devattr
,
816 struct aem_data
*data
= dev_get_drvdata(dev
);
818 return sprintf(buf
, "%d.%d\n", data
->ver_major
, data
->ver_minor
);
820 static SENSOR_DEVICE_ATTR(version
, S_IRUGO
, show_version
, NULL
, 0);
822 /* Display power use */
823 static ssize_t
aem_show_power(struct device
*dev
,
824 struct device_attribute
*devattr
,
827 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
828 struct aem_data
*data
= dev_get_drvdata(dev
);
829 u64 before
, after
, delta
, time
;
830 signed long leftover
;
831 struct timespec b
, a
;
833 mutex_lock(&data
->lock
);
834 update_aem_energy_one(data
, attr
->index
);
836 before
= data
->energy
[attr
->index
];
838 leftover
= schedule_timeout_interruptible(
839 msecs_to_jiffies(data
->power_period
[attr
->index
])
842 mutex_unlock(&data
->lock
);
846 update_aem_energy_one(data
, attr
->index
);
848 after
= data
->energy
[attr
->index
];
849 mutex_unlock(&data
->lock
);
851 time
= timespec_to_ns(&a
) - timespec_to_ns(&b
);
852 delta
= (after
- before
) * UJ_PER_MJ
;
854 return sprintf(buf
, "%llu\n",
855 (unsigned long long)div64_u64(delta
* NSEC_PER_SEC
, time
));
858 /* Display energy use */
859 static ssize_t
aem_show_energy(struct device
*dev
,
860 struct device_attribute
*devattr
,
863 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
864 struct aem_data
*a
= dev_get_drvdata(dev
);
865 mutex_lock(&a
->lock
);
866 update_aem_energy_one(a
, attr
->index
);
867 mutex_unlock(&a
->lock
);
869 return sprintf(buf
, "%llu\n",
870 (unsigned long long)a
->energy
[attr
->index
] * 1000);
873 /* Display power interval registers */
874 static ssize_t
aem_show_power_period(struct device
*dev
,
875 struct device_attribute
*devattr
,
878 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
879 struct aem_data
*a
= dev_get_drvdata(dev
);
882 return sprintf(buf
, "%lu\n", a
->power_period
[attr
->index
]);
885 /* Set power interval registers */
886 static ssize_t
aem_set_power_period(struct device
*dev
,
887 struct device_attribute
*devattr
,
888 const char *buf
, size_t count
)
890 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
891 struct aem_data
*a
= dev_get_drvdata(dev
);
895 res
= strict_strtoul(buf
, 10, &temp
);
899 if (temp
< AEM_MIN_POWER_INTERVAL
)
902 mutex_lock(&a
->lock
);
903 a
->power_period
[attr
->index
] = temp
;
904 mutex_unlock(&a
->lock
);
909 /* Discover sensors on an AEM device */
910 static int aem_register_sensors(struct aem_data
*data
,
911 struct aem_ro_sensor_template
*ro
,
912 struct aem_rw_sensor_template
*rw
)
914 struct device
*dev
= &data
->pdev
->dev
;
915 struct sensor_device_attribute
*sensors
= data
->sensors
;
918 /* Set up read-only sensors */
920 sysfs_attr_init(&sensors
->dev_attr
.attr
);
921 sensors
->dev_attr
.attr
.name
= ro
->label
;
922 sensors
->dev_attr
.attr
.mode
= S_IRUGO
;
923 sensors
->dev_attr
.show
= ro
->show
;
924 sensors
->index
= ro
->index
;
926 err
= device_create_file(dev
, &sensors
->dev_attr
);
928 sensors
->dev_attr
.attr
.name
= NULL
;
935 /* Set up read-write sensors */
937 sysfs_attr_init(&sensors
->dev_attr
.attr
);
938 sensors
->dev_attr
.attr
.name
= rw
->label
;
939 sensors
->dev_attr
.attr
.mode
= S_IRUGO
| S_IWUSR
;
940 sensors
->dev_attr
.show
= rw
->show
;
941 sensors
->dev_attr
.store
= rw
->set
;
942 sensors
->index
= rw
->index
;
944 err
= device_create_file(dev
, &sensors
->dev_attr
);
946 sensors
->dev_attr
.attr
.name
= NULL
;
953 err
= device_create_file(dev
, &sensor_dev_attr_name
.dev_attr
);
956 err
= device_create_file(dev
, &sensor_dev_attr_version
.dev_attr
);
960 aem_remove_sensors(data
);
964 /* sysfs support functions for AEM2 sensors */
966 /* Display temperature use */
967 static ssize_t
aem2_show_temp(struct device
*dev
,
968 struct device_attribute
*devattr
,
971 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
972 struct aem_data
*a
= dev_get_drvdata(dev
);
975 return sprintf(buf
, "%u\n", a
->temp
[attr
->index
] * 1000);
978 /* Display power-capping registers */
979 static ssize_t
aem2_show_pcap_value(struct device
*dev
,
980 struct device_attribute
*devattr
,
983 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
984 struct aem_data
*a
= dev_get_drvdata(dev
);
987 return sprintf(buf
, "%u\n", a
->pcap
[attr
->index
] * 100000);
990 /* Remove sensors attached to an AEM device */
991 static void aem_remove_sensors(struct aem_data
*data
)
995 for (i
= 0; i
< AEM_NUM_SENSORS
; i
++) {
996 if (!data
->sensors
[i
].dev_attr
.attr
.name
)
998 device_remove_file(&data
->pdev
->dev
,
999 &data
->sensors
[i
].dev_attr
);
1002 device_remove_file(&data
->pdev
->dev
,
1003 &sensor_dev_attr_name
.dev_attr
);
1004 device_remove_file(&data
->pdev
->dev
,
1005 &sensor_dev_attr_version
.dev_attr
);
1008 /* Sensor probe functions */
1010 /* Description of AEM1 sensors */
1011 static struct aem_ro_sensor_template aem1_ro_sensors
[] = {
1012 {"energy1_input", aem_show_energy
, 0},
1013 {"power1_average", aem_show_power
, 0},
1017 static struct aem_rw_sensor_template aem1_rw_sensors
[] = {
1018 {"power1_average_interval", aem_show_power_period
, aem_set_power_period
, 0},
1019 {NULL
, NULL
, NULL
, 0},
1022 /* Description of AEM2 sensors */
1023 static struct aem_ro_sensor_template aem2_ro_sensors
[] = {
1024 {"energy1_input", aem_show_energy
, 0},
1025 {"energy2_input", aem_show_energy
, 1},
1026 {"power1_average", aem_show_power
, 0},
1027 {"power2_average", aem_show_power
, 1},
1028 {"temp1_input", aem2_show_temp
, 0},
1029 {"temp2_input", aem2_show_temp
, 1},
1031 {"power4_average", aem2_show_pcap_value
, POWER_CAP_MAX_HOTPLUG
},
1032 {"power5_average", aem2_show_pcap_value
, POWER_CAP_MAX
},
1033 {"power6_average", aem2_show_pcap_value
, POWER_CAP_MIN_WARNING
},
1034 {"power7_average", aem2_show_pcap_value
, POWER_CAP_MIN
},
1036 {"power3_average", aem2_show_pcap_value
, POWER_AUX
},
1037 {"power_cap", aem2_show_pcap_value
, POWER_CAP
},
1041 static struct aem_rw_sensor_template aem2_rw_sensors
[] = {
1042 {"power1_average_interval", aem_show_power_period
, aem_set_power_period
, 0},
1043 {"power2_average_interval", aem_show_power_period
, aem_set_power_period
, 1},
1044 {NULL
, NULL
, NULL
, 0},
1047 /* Set up AEM1 sensor attrs */
1048 static int aem1_find_sensors(struct aem_data
*data
)
1050 return aem_register_sensors(data
, aem1_ro_sensors
, aem1_rw_sensors
);
1053 /* Set up AEM2 sensor attrs */
1054 static int aem2_find_sensors(struct aem_data
*data
)
1056 return aem_register_sensors(data
, aem2_ro_sensors
, aem2_rw_sensors
);
1059 /* Module init/exit routines */
1061 static int __init
aem_init(void)
1065 res
= driver_register(&aem_driver
.driver
);
1067 pr_err("Can't register aem driver\n");
1071 res
= ipmi_smi_watcher_register(&driver_data
.bmc_events
);
1077 driver_unregister(&aem_driver
.driver
);
1082 static void __exit
aem_exit(void)
1084 struct aem_data
*p1
, *next1
;
1086 ipmi_smi_watcher_unregister(&driver_data
.bmc_events
);
1087 driver_unregister(&aem_driver
.driver
);
1088 list_for_each_entry_safe(p1
, next1
, &driver_data
.aem_devices
, list
)
1092 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
1093 MODULE_DESCRIPTION("IBM AEM power/temp/energy sensor driver");
1094 MODULE_LICENSE("GPL");
1096 module_init(aem_init
);
1097 module_exit(aem_exit
);
1099 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3350-*");
1100 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3550-*");
1101 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3650-*");
1102 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3655-*");
1103 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3755-*");
1104 MODULE_ALIAS("dmi:bvnIBM:*:pnIBM3850M2/x3950M2-*");
1105 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMBladeHC10-*");