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 #include <linux/ipmi.h>
24 #include <linux/module.h>
25 #include <linux/hwmon.h>
26 #include <linux/hwmon-sysfs.h>
27 #include <linux/jiffies.h>
28 #include <linux/mutex.h>
29 #include <linux/kdev_t.h>
30 #include <linux/spinlock.h>
31 #include <linux/idr.h>
32 #include <linux/sched.h>
33 #include <linux/platform_device.h>
34 #include <linux/math64.h>
35 #include <linux/time.h>
37 #define REFRESH_INTERVAL (HZ)
38 #define IPMI_TIMEOUT (30 * HZ)
41 #define AEM_NETFN 0x2E
43 #define AEM_FIND_FW_CMD 0x80
44 #define AEM_ELEMENT_CMD 0x81
45 #define AEM_FW_INSTANCE_CMD 0x82
47 #define AEM_READ_ELEMENT_CFG 0x80
48 #define AEM_READ_BUFFER 0x81
49 #define AEM_READ_REGISTER 0x82
50 #define AEM_WRITE_REGISTER 0x83
51 #define AEM_SET_REG_MASK 0x84
52 #define AEM_CLEAR_REG_MASK 0x85
53 #define AEM_READ_ELEMENT_CFG2 0x86
55 #define AEM_CONTROL_ELEMENT 0
56 #define AEM_ENERGY_ELEMENT 1
57 #define AEM_CLOCK_ELEMENT 4
58 #define AEM_POWER_CAP_ELEMENT 7
59 #define AEM_EXHAUST_ELEMENT 9
60 #define AEM_POWER_ELEMENT 10
62 #define AEM_MODULE_TYPE_ID 0x0001
64 #define AEM2_NUM_ENERGY_REGS 2
65 #define AEM2_NUM_PCAP_REGS 6
66 #define AEM2_NUM_TEMP_REGS 2
67 #define AEM2_NUM_SENSORS 14
69 #define AEM1_NUM_ENERGY_REGS 1
70 #define AEM1_NUM_SENSORS 3
72 /* AEM 2.x has more energy registers */
73 #define AEM_NUM_ENERGY_REGS AEM2_NUM_ENERGY_REGS
74 /* AEM 2.x needs more sensor files */
75 #define AEM_NUM_SENSORS AEM2_NUM_SENSORS
78 #define POWER_CAP_MAX_HOTPLUG 1
79 #define POWER_CAP_MAX 2
80 #define POWER_CAP_MIN_WARNING 3
81 #define POWER_CAP_MIN 4
84 #define AEM_DEFAULT_POWER_INTERVAL 1000
85 #define AEM_MIN_POWER_INTERVAL 200
86 #define UJ_PER_MJ 1000L
88 static DEFINE_IDR(aem_idr
);
89 static DEFINE_SPINLOCK(aem_idr_lock
);
91 static struct platform_driver aem_driver
= {
94 .bus
= &platform_bus_type
,
98 struct aem_ipmi_data
{
99 struct completion read_complete
;
100 struct ipmi_addr address
;
104 struct kernel_ipmi_msg tx_message
;
108 unsigned short rx_msg_len
;
109 unsigned char rx_result
;
112 struct device
*bmc_device
;
115 struct aem_ro_sensor_template
{
117 ssize_t (*show
)(struct device
*dev
,
118 struct device_attribute
*devattr
,
123 struct aem_rw_sensor_template
{
125 ssize_t (*show
)(struct device
*dev
,
126 struct device_attribute
*devattr
,
128 ssize_t (*set
)(struct device
*dev
,
129 struct device_attribute
*devattr
,
130 const char *buf
, size_t count
);
135 struct list_head list
;
137 struct device
*hwmon_dev
;
138 struct platform_device
*pdev
;
141 unsigned long last_updated
; /* In jiffies */
146 struct aem_ipmi_data ipmi
;
148 /* Function to update sensors */
149 void (*update
)(struct aem_data
*data
);
160 * Two temperature sensors
161 * Six power cap registers
165 struct sensor_device_attribute sensors
[AEM_NUM_SENSORS
];
167 /* energy use in mJ */
168 u64 energy
[AEM_NUM_ENERGY_REGS
];
170 /* power sampling interval in ms */
171 unsigned long power_period
[AEM_NUM_ENERGY_REGS
];
173 /* Everything past here is for AEM2 only */
175 /* power caps in dW */
176 u16 pcap
[AEM2_NUM_PCAP_REGS
];
178 /* exhaust temperature in C */
179 u8 temp
[AEM2_NUM_TEMP_REGS
];
182 /* Data structures returned by the AEM firmware */
186 static struct aem_iana_id system_x_id
= {
187 .bytes
= {0x4D, 0x4F, 0x00}
190 /* These are used to find AEM1 instances */
191 struct aem_find_firmware_req
{
192 struct aem_iana_id id
;
195 __be16 module_type_id
;
198 struct aem_find_firmware_resp
{
199 struct aem_iana_id id
;
203 /* These are used to find AEM2 instances */
204 struct aem_find_instance_req
{
205 struct aem_iana_id id
;
207 __be16 module_type_id
;
210 struct aem_find_instance_resp
{
211 struct aem_iana_id id
;
219 /* These are used to query sensors */
220 struct aem_read_sensor_req
{
221 struct aem_iana_id id
;
229 struct aem_read_sensor_resp
{
230 struct aem_iana_id id
;
234 /* Data structures to talk to the IPMI layer */
235 struct aem_driver_data
{
236 struct list_head aem_devices
;
237 struct ipmi_smi_watcher bmc_events
;
238 struct ipmi_user_hndl ipmi_hndlrs
;
241 static void aem_register_bmc(int iface
, struct device
*dev
);
242 static void aem_bmc_gone(int iface
);
243 static void aem_msg_handler(struct ipmi_recv_msg
*msg
, void *user_msg_data
);
245 static void aem_remove_sensors(struct aem_data
*data
);
246 static int aem_init_aem1(struct aem_ipmi_data
*probe
);
247 static int aem_init_aem2(struct aem_ipmi_data
*probe
);
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
);
359 static int aem_idr_get(int *id
)
364 if (unlikely(!idr_pre_get(&aem_idr
, GFP_KERNEL
)))
367 spin_lock(&aem_idr_lock
);
368 err
= idr_get_new(&aem_idr
, NULL
, &i
);
369 spin_unlock(&aem_idr_lock
);
371 if (unlikely(err
== -EAGAIN
))
373 else if (unlikely(err
))
376 *id
= i
& MAX_ID_MASK
;
380 /* Release an object ID */
381 static void aem_idr_put(int id
)
383 spin_lock(&aem_idr_lock
);
384 idr_remove(&aem_idr
, id
);
385 spin_unlock(&aem_idr_lock
);
388 /* Sensor support functions */
390 /* Read a sensor value */
391 static int aem_read_sensor(struct aem_data
*data
, u8 elt
, u8 reg
,
392 void *buf
, size_t size
)
395 struct aem_read_sensor_req rs_req
;
396 struct aem_read_sensor_resp
*rs_resp
;
397 struct aem_ipmi_data
*ipmi
= &data
->ipmi
;
399 /* AEM registers are 1, 2, 4 or 8 bytes */
410 rs_req
.id
= system_x_id
;
411 rs_req
.module_handle
= data
->module_handle
;
412 rs_req
.element
= elt
;
413 rs_req
.subcommand
= AEM_READ_REGISTER
;
415 rs_req
.rx_buf_size
= size
;
417 ipmi
->tx_message
.cmd
= AEM_ELEMENT_CMD
;
418 ipmi
->tx_message
.data
= (char *)&rs_req
;
419 ipmi
->tx_message
.data_len
= sizeof(rs_req
);
421 rs_size
= sizeof(*rs_resp
) + size
;
422 rs_resp
= kzalloc(rs_size
, GFP_KERNEL
);
426 ipmi
->rx_msg_data
= rs_resp
;
427 ipmi
->rx_msg_len
= rs_size
;
429 aem_send_message(ipmi
);
431 res
= wait_for_completion_timeout(&ipmi
->read_complete
, IPMI_TIMEOUT
);
437 if (ipmi
->rx_result
|| ipmi
->rx_msg_len
!= rs_size
||
438 memcmp(&rs_resp
->id
, &system_x_id
, sizeof(system_x_id
))) {
446 *x
= rs_resp
->bytes
[0];
451 *x
= be16_to_cpup((__be16
*)rs_resp
->bytes
);
456 *x
= be32_to_cpup((__be32
*)rs_resp
->bytes
);
461 *x
= be64_to_cpup((__be64
*)rs_resp
->bytes
);
472 /* Update AEM energy registers */
473 static void update_aem_energy_one(struct aem_data
*data
, int which
)
475 aem_read_sensor(data
, AEM_ENERGY_ELEMENT
, which
,
476 &data
->energy
[which
], 8);
479 static void update_aem_energy(struct aem_data
*data
)
481 update_aem_energy_one(data
, 0);
482 if (data
->ver_major
< 2)
484 update_aem_energy_one(data
, 1);
487 /* Update all AEM1 sensors */
488 static void update_aem1_sensors(struct aem_data
*data
)
490 mutex_lock(&data
->lock
);
491 if (time_before(jiffies
, data
->last_updated
+ REFRESH_INTERVAL
) &&
495 update_aem_energy(data
);
497 mutex_unlock(&data
->lock
);
500 /* Update all AEM2 sensors */
501 static void update_aem2_sensors(struct aem_data
*data
)
505 mutex_lock(&data
->lock
);
506 if (time_before(jiffies
, data
->last_updated
+ REFRESH_INTERVAL
) &&
510 update_aem_energy(data
);
511 aem_read_sensor(data
, AEM_EXHAUST_ELEMENT
, 0, &data
->temp
[0], 1);
512 aem_read_sensor(data
, AEM_EXHAUST_ELEMENT
, 1, &data
->temp
[1], 1);
514 for (i
= POWER_CAP
; i
<= POWER_AUX
; i
++)
515 aem_read_sensor(data
, AEM_POWER_CAP_ELEMENT
, i
,
518 mutex_unlock(&data
->lock
);
521 /* Delete an AEM instance */
522 static void aem_delete(struct aem_data
*data
)
524 list_del(&data
->list
);
525 aem_remove_sensors(data
);
526 hwmon_device_unregister(data
->hwmon_dev
);
527 ipmi_destroy_user(data
->ipmi
.user
);
528 dev_set_drvdata(&data
->pdev
->dev
, NULL
);
529 platform_device_unregister(data
->pdev
);
530 aem_idr_put(data
->id
);
534 /* Probe functions for AEM1 devices */
536 /* Retrieve version and module handle for an AEM1 instance */
537 static int aem_find_aem1_count(struct aem_ipmi_data
*data
)
540 struct aem_find_firmware_req ff_req
;
541 struct aem_find_firmware_resp ff_resp
;
543 ff_req
.id
= system_x_id
;
545 ff_req
.module_type_id
= cpu_to_be16(AEM_MODULE_TYPE_ID
);
547 data
->tx_message
.cmd
= AEM_FIND_FW_CMD
;
548 data
->tx_message
.data
= (char *)&ff_req
;
549 data
->tx_message
.data_len
= sizeof(ff_req
);
551 data
->rx_msg_data
= &ff_resp
;
552 data
->rx_msg_len
= sizeof(ff_resp
);
554 aem_send_message(data
);
556 res
= wait_for_completion_timeout(&data
->read_complete
, IPMI_TIMEOUT
);
560 if (data
->rx_result
|| data
->rx_msg_len
!= sizeof(ff_resp
) ||
561 memcmp(&ff_resp
.id
, &system_x_id
, sizeof(system_x_id
)))
564 return ff_resp
.num_instances
;
567 /* Find and initialize one AEM1 instance */
568 static int aem_init_aem1_inst(struct aem_ipmi_data
*probe
, u8 module_handle
)
570 struct aem_data
*data
;
574 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
577 mutex_init(&data
->lock
);
579 /* Copy instance data */
582 data
->module_handle
= module_handle
;
583 for (i
= 0; i
< AEM1_NUM_ENERGY_REGS
; i
++)
584 data
->power_period
[i
] = AEM_DEFAULT_POWER_INTERVAL
;
586 /* Create sub-device for this fw instance */
587 if (aem_idr_get(&data
->id
))
590 data
->pdev
= platform_device_alloc(DRVNAME
, data
->id
);
593 data
->pdev
->dev
.driver
= &aem_driver
.driver
;
595 res
= platform_device_add(data
->pdev
);
599 dev_set_drvdata(&data
->pdev
->dev
, data
);
601 /* Set up IPMI interface */
602 if (aem_init_ipmi_data(&data
->ipmi
, probe
->interface
,
606 /* Register with hwmon */
607 data
->hwmon_dev
= hwmon_device_register(&data
->pdev
->dev
);
609 if (IS_ERR(data
->hwmon_dev
)) {
610 dev_err(&data
->pdev
->dev
, "Unable to register hwmon "
611 "device for IPMI interface %d\n",
616 data
->update
= update_aem1_sensors
;
619 if (aem1_find_sensors(data
))
622 /* Add to our list of AEM devices */
623 list_add_tail(&data
->list
, &driver_data
.aem_devices
);
625 dev_info(data
->ipmi
.bmc_device
, "Found AEM v%d.%d at 0x%X\n",
626 data
->ver_major
, data
->ver_minor
,
627 data
->module_handle
);
631 hwmon_device_unregister(data
->hwmon_dev
);
633 ipmi_destroy_user(data
->ipmi
.user
);
635 dev_set_drvdata(&data
->pdev
->dev
, NULL
);
636 platform_device_unregister(data
->pdev
);
638 aem_idr_put(data
->id
);
645 /* Find and initialize all AEM1 instances */
646 static int aem_init_aem1(struct aem_ipmi_data
*probe
)
650 num
= aem_find_aem1_count(probe
);
651 for (i
= 0; i
< num
; i
++) {
652 err
= aem_init_aem1_inst(probe
, i
);
654 dev_err(probe
->bmc_device
,
655 "Error %d initializing AEM1 0x%X\n",
664 /* Probe functions for AEM2 devices */
666 /* Retrieve version and module handle for an AEM2 instance */
667 static int aem_find_aem2(struct aem_ipmi_data
*data
,
668 struct aem_find_instance_resp
*fi_resp
,
672 struct aem_find_instance_req fi_req
;
674 fi_req
.id
= system_x_id
;
675 fi_req
.instance_number
= instance_num
;
676 fi_req
.module_type_id
= cpu_to_be16(AEM_MODULE_TYPE_ID
);
678 data
->tx_message
.cmd
= AEM_FW_INSTANCE_CMD
;
679 data
->tx_message
.data
= (char *)&fi_req
;
680 data
->tx_message
.data_len
= sizeof(fi_req
);
682 data
->rx_msg_data
= fi_resp
;
683 data
->rx_msg_len
= sizeof(*fi_resp
);
685 aem_send_message(data
);
687 res
= wait_for_completion_timeout(&data
->read_complete
, IPMI_TIMEOUT
);
691 if (data
->rx_result
|| data
->rx_msg_len
!= sizeof(*fi_resp
) ||
692 memcmp(&fi_resp
->id
, &system_x_id
, sizeof(system_x_id
)) ||
693 fi_resp
->num_instances
<= instance_num
)
699 /* Find and initialize one AEM2 instance */
700 static int aem_init_aem2_inst(struct aem_ipmi_data
*probe
,
701 struct aem_find_instance_resp
*fi_resp
)
703 struct aem_data
*data
;
707 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
710 mutex_init(&data
->lock
);
712 /* Copy instance data */
713 data
->ver_major
= fi_resp
->major
;
714 data
->ver_minor
= fi_resp
->minor
;
715 data
->module_handle
= fi_resp
->module_handle
;
716 for (i
= 0; i
< AEM2_NUM_ENERGY_REGS
; i
++)
717 data
->power_period
[i
] = AEM_DEFAULT_POWER_INTERVAL
;
719 /* Create sub-device for this fw instance */
720 if (aem_idr_get(&data
->id
))
723 data
->pdev
= platform_device_alloc(DRVNAME
, data
->id
);
726 data
->pdev
->dev
.driver
= &aem_driver
.driver
;
728 res
= platform_device_add(data
->pdev
);
732 dev_set_drvdata(&data
->pdev
->dev
, data
);
734 /* Set up IPMI interface */
735 if (aem_init_ipmi_data(&data
->ipmi
, probe
->interface
,
739 /* Register with hwmon */
740 data
->hwmon_dev
= hwmon_device_register(&data
->pdev
->dev
);
742 if (IS_ERR(data
->hwmon_dev
)) {
743 dev_err(&data
->pdev
->dev
, "Unable to register hwmon "
744 "device for IPMI interface %d\n",
749 data
->update
= update_aem2_sensors
;
752 if (aem2_find_sensors(data
))
755 /* Add to our list of AEM devices */
756 list_add_tail(&data
->list
, &driver_data
.aem_devices
);
758 dev_info(data
->ipmi
.bmc_device
, "Found AEM v%d.%d at 0x%X\n",
759 data
->ver_major
, data
->ver_minor
,
760 data
->module_handle
);
764 hwmon_device_unregister(data
->hwmon_dev
);
766 ipmi_destroy_user(data
->ipmi
.user
);
768 dev_set_drvdata(&data
->pdev
->dev
, NULL
);
769 platform_device_unregister(data
->pdev
);
771 aem_idr_put(data
->id
);
778 /* Find and initialize all AEM2 instances */
779 static int aem_init_aem2(struct aem_ipmi_data
*probe
)
781 struct aem_find_instance_resp fi_resp
;
785 while (!aem_find_aem2(probe
, &fi_resp
, i
)) {
786 if (fi_resp
.major
!= 2) {
787 dev_err(probe
->bmc_device
, "Unknown AEM v%d; please "
788 "report this to the maintainer.\n",
793 err
= aem_init_aem2_inst(probe
, &fi_resp
);
795 dev_err(probe
->bmc_device
,
796 "Error %d initializing AEM2 0x%X\n",
797 err
, fi_resp
.module_handle
);
806 /* Probe a BMC for AEM firmware instances */
807 static void aem_register_bmc(int iface
, struct device
*dev
)
809 struct aem_ipmi_data probe
;
811 if (aem_init_ipmi_data(&probe
, iface
, dev
))
814 /* Ignore probe errors; they won't cause problems */
815 aem_init_aem1(&probe
);
816 aem_init_aem2(&probe
);
818 ipmi_destroy_user(probe
.user
);
821 /* Handle BMC deletion */
822 static void aem_bmc_gone(int iface
)
824 struct aem_data
*p1
, *next1
;
826 list_for_each_entry_safe(p1
, next1
, &driver_data
.aem_devices
, list
)
827 if (p1
->ipmi
.interface
== iface
)
831 /* sysfs support functions */
833 /* AEM device name */
834 static ssize_t
show_name(struct device
*dev
, struct device_attribute
*devattr
,
837 struct aem_data
*data
= dev_get_drvdata(dev
);
839 return sprintf(buf
, "%s%d\n", DRVNAME
, data
->ver_major
);
841 static SENSOR_DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
, 0);
843 /* AEM device version */
844 static ssize_t
show_version(struct device
*dev
,
845 struct device_attribute
*devattr
,
848 struct aem_data
*data
= dev_get_drvdata(dev
);
850 return sprintf(buf
, "%d.%d\n", data
->ver_major
, data
->ver_minor
);
852 static SENSOR_DEVICE_ATTR(version
, S_IRUGO
, show_version
, NULL
, 0);
854 /* Display power use */
855 static ssize_t
aem_show_power(struct device
*dev
,
856 struct device_attribute
*devattr
,
859 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
860 struct aem_data
*data
= dev_get_drvdata(dev
);
861 u64 before
, after
, delta
, time
;
862 signed long leftover
;
863 struct timespec b
, a
;
865 mutex_lock(&data
->lock
);
866 update_aem_energy_one(data
, attr
->index
);
868 before
= data
->energy
[attr
->index
];
870 leftover
= schedule_timeout_interruptible(
871 msecs_to_jiffies(data
->power_period
[attr
->index
])
874 mutex_unlock(&data
->lock
);
878 update_aem_energy_one(data
, attr
->index
);
880 after
= data
->energy
[attr
->index
];
881 mutex_unlock(&data
->lock
);
883 time
= timespec_to_ns(&a
) - timespec_to_ns(&b
);
884 delta
= (after
- before
) * UJ_PER_MJ
;
886 return sprintf(buf
, "%llu\n",
887 (unsigned long long)div64_u64(delta
* NSEC_PER_SEC
, time
));
890 /* Display energy use */
891 static ssize_t
aem_show_energy(struct device
*dev
,
892 struct device_attribute
*devattr
,
895 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
896 struct aem_data
*a
= dev_get_drvdata(dev
);
897 mutex_lock(&a
->lock
);
898 update_aem_energy_one(a
, attr
->index
);
899 mutex_unlock(&a
->lock
);
901 return sprintf(buf
, "%llu\n",
902 (unsigned long long)a
->energy
[attr
->index
] * 1000);
905 /* Display power interval registers */
906 static ssize_t
aem_show_power_period(struct device
*dev
,
907 struct device_attribute
*devattr
,
910 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
911 struct aem_data
*a
= dev_get_drvdata(dev
);
914 return sprintf(buf
, "%lu\n", a
->power_period
[attr
->index
]);
917 /* Set power interval registers */
918 static ssize_t
aem_set_power_period(struct device
*dev
,
919 struct device_attribute
*devattr
,
920 const char *buf
, size_t count
)
922 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
923 struct aem_data
*a
= dev_get_drvdata(dev
);
927 res
= strict_strtoul(buf
, 10, &temp
);
931 if (temp
< AEM_MIN_POWER_INTERVAL
)
934 mutex_lock(&a
->lock
);
935 a
->power_period
[attr
->index
] = temp
;
936 mutex_unlock(&a
->lock
);
941 /* Discover sensors on an AEM device */
942 static int aem_register_sensors(struct aem_data
*data
,
943 struct aem_ro_sensor_template
*ro
,
944 struct aem_rw_sensor_template
*rw
)
946 struct device
*dev
= &data
->pdev
->dev
;
947 struct sensor_device_attribute
*sensors
= data
->sensors
;
950 /* Set up read-only sensors */
952 sensors
->dev_attr
.attr
.name
= ro
->label
;
953 sensors
->dev_attr
.attr
.mode
= S_IRUGO
;
954 sensors
->dev_attr
.show
= ro
->show
;
955 sensors
->index
= ro
->index
;
957 err
= device_create_file(dev
, &sensors
->dev_attr
);
959 sensors
->dev_attr
.attr
.name
= NULL
;
966 /* Set up read-write sensors */
968 sensors
->dev_attr
.attr
.name
= rw
->label
;
969 sensors
->dev_attr
.attr
.mode
= S_IRUGO
| S_IWUSR
;
970 sensors
->dev_attr
.show
= rw
->show
;
971 sensors
->dev_attr
.store
= rw
->set
;
972 sensors
->index
= rw
->index
;
974 err
= device_create_file(dev
, &sensors
->dev_attr
);
976 sensors
->dev_attr
.attr
.name
= NULL
;
983 err
= device_create_file(dev
, &sensor_dev_attr_name
.dev_attr
);
986 err
= device_create_file(dev
, &sensor_dev_attr_version
.dev_attr
);
990 aem_remove_sensors(data
);
994 /* sysfs support functions for AEM2 sensors */
996 /* Display temperature use */
997 static ssize_t
aem2_show_temp(struct device
*dev
,
998 struct device_attribute
*devattr
,
1001 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
1002 struct aem_data
*a
= dev_get_drvdata(dev
);
1005 return sprintf(buf
, "%u\n", a
->temp
[attr
->index
] * 1000);
1008 /* Display power-capping registers */
1009 static ssize_t
aem2_show_pcap_value(struct device
*dev
,
1010 struct device_attribute
*devattr
,
1013 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
1014 struct aem_data
*a
= dev_get_drvdata(dev
);
1017 return sprintf(buf
, "%u\n", a
->pcap
[attr
->index
] * 100000);
1020 /* Remove sensors attached to an AEM device */
1021 static void aem_remove_sensors(struct aem_data
*data
)
1025 for (i
= 0; i
< AEM_NUM_SENSORS
; i
++) {
1026 if (!data
->sensors
[i
].dev_attr
.attr
.name
)
1028 device_remove_file(&data
->pdev
->dev
,
1029 &data
->sensors
[i
].dev_attr
);
1032 device_remove_file(&data
->pdev
->dev
,
1033 &sensor_dev_attr_name
.dev_attr
);
1034 device_remove_file(&data
->pdev
->dev
,
1035 &sensor_dev_attr_version
.dev_attr
);
1038 /* Sensor probe functions */
1040 /* Description of AEM1 sensors */
1041 static struct aem_ro_sensor_template aem1_ro_sensors
[] = {
1042 {"energy1_input", aem_show_energy
, 0},
1043 {"power1_average", aem_show_power
, 0},
1047 static struct aem_rw_sensor_template aem1_rw_sensors
[] = {
1048 {"power1_average_interval", aem_show_power_period
, aem_set_power_period
, 0},
1049 {NULL
, NULL
, NULL
, 0},
1052 /* Description of AEM2 sensors */
1053 static struct aem_ro_sensor_template aem2_ro_sensors
[] = {
1054 {"energy1_input", aem_show_energy
, 0},
1055 {"energy2_input", aem_show_energy
, 1},
1056 {"power1_average", aem_show_power
, 0},
1057 {"power2_average", aem_show_power
, 1},
1058 {"temp1_input", aem2_show_temp
, 0},
1059 {"temp2_input", aem2_show_temp
, 1},
1061 {"power4_average", aem2_show_pcap_value
, POWER_CAP_MAX_HOTPLUG
},
1062 {"power5_average", aem2_show_pcap_value
, POWER_CAP_MAX
},
1063 {"power6_average", aem2_show_pcap_value
, POWER_CAP_MIN_WARNING
},
1064 {"power7_average", aem2_show_pcap_value
, POWER_CAP_MIN
},
1066 {"power3_average", aem2_show_pcap_value
, POWER_AUX
},
1067 {"power_cap", aem2_show_pcap_value
, POWER_CAP
},
1071 static struct aem_rw_sensor_template aem2_rw_sensors
[] = {
1072 {"power1_average_interval", aem_show_power_period
, aem_set_power_period
, 0},
1073 {"power2_average_interval", aem_show_power_period
, aem_set_power_period
, 1},
1074 {NULL
, NULL
, NULL
, 0},
1077 /* Set up AEM1 sensor attrs */
1078 static int aem1_find_sensors(struct aem_data
*data
)
1080 return aem_register_sensors(data
, aem1_ro_sensors
, aem1_rw_sensors
);
1083 /* Set up AEM2 sensor attrs */
1084 static int aem2_find_sensors(struct aem_data
*data
)
1086 return aem_register_sensors(data
, aem2_ro_sensors
, aem2_rw_sensors
);
1089 /* Module init/exit routines */
1091 static int __init
aem_init(void)
1095 res
= driver_register(&aem_driver
.driver
);
1097 printk(KERN_ERR
"Can't register aem driver\n");
1101 res
= ipmi_smi_watcher_register(&driver_data
.bmc_events
);
1107 driver_unregister(&aem_driver
.driver
);
1112 static void __exit
aem_exit(void)
1114 struct aem_data
*p1
, *next1
;
1116 ipmi_smi_watcher_unregister(&driver_data
.bmc_events
);
1117 driver_unregister(&aem_driver
.driver
);
1118 list_for_each_entry_safe(p1
, next1
, &driver_data
.aem_devices
, list
)
1122 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
1123 MODULE_DESCRIPTION("IBM AEM power/temp/energy sensor driver");
1124 MODULE_LICENSE("GPL");
1126 module_init(aem_init
);
1127 module_exit(aem_exit
);
1129 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3350-*");
1130 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3550-*");
1131 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3650-*");
1132 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3655-*");
1133 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3755-*");
1134 MODULE_ALIAS("dmi:bvnIBM:*:pnIBM3850M2/x3950M2-*");
1135 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMBladeHC10-*");