* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-06 22:25 ` [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI Denis Pauk
@ 2021-10-06 23:32 ` Eugene Shalygin
2021-10-07 15:46 ` Denis Pauk
2021-10-07 16:41 ` Guenter Roeck
` (2 subsequent siblings)
3 siblings, 1 reply; 23+ messages in thread
From: Eugene Shalygin @ 2021-10-06 23:32 UTC (permalink / raw)
To: Denis Pauk
Cc: andy.shevchenko, Jean Delvare, Guenter Roeck, linux-kernel, linux-hwmon
On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com> wrote:
>
> Supported motherboards:
> * ROG CROSSHAIR VIII HERO
> * ROG CROSSHAIR VIII DARK HERO
> * ROG CROSSHAIR VIII FORMULA
> * ROG STRIX X570-E GAMING
> * ROG STRIX B550-E GAMING
Pro WS X570-ACE is missing from this list.
> + * EC provided:
provides
> + * Chipset temperature,
> + * CPU temperature,
> + * Motherboard temperature,
> + * T_Sensor temperature,
> + * VRM temperature,
> + * Water In temperature,
> + * Water Out temperature,
> + * CPU Optional Fan,
Hereinafter "CPU Optional Fan RPM"?
> +static const enum known_ec_sensor known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> + [BOARD_PW_X570_A] = {
> + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> + SENSOR_FAN_CHIPSET,
I missed SENSOR_CURR_CPU for a few boards, and unfortunately the
mistake made it here too. Sorry for that.
> +/**
> + * struct asus_wmi_ec_info - sensor info.
> + * @sensors: list of sensors.
> + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> + * @read_buffer: WMI function output.
This seems to be a bit misleading to me in a sense that the variable
holds decoded output (array of numbers as opposed to array of
characters in the WMI output buffer.
> +struct asus_wmi_data {
> + int ec_board;
> +};
A leftover?
> +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> +{
> + unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] / 4);
> + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> + const char *pos = buffer;
> + const u8 *data = inp + 2;
> + unsigned int i;
> +
> + utf16s_to_utf8s((wchar_t *)data, len * 2, UTF16_LITTLE_ENDIAN, buffer, len * 2);
Errr... Why is it here? You need the same loop afterwards, just with a
smaller stride.
> +
> + for (i = 0; i < len; i++, pos += 2)
> + out[i] = (hex_to_bin(pos[0]) << 4) + hex_to_bin(pos[1]);
> +}
> +
> +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len, char *out)
> +{
> + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> + char *pos = buffer;
> + unsigned int i;
> + u8 byte;
> +
> + *out++ = len * 8;
> + *out++ = 0;
> +
> + for (i = 0; i < len; i++) {
> + byte = registers[i] >> 8;
> + *pos = hex_asc_hi(byte);
> + pos++;
> + *pos = hex_asc_lo(byte);
> + pos++;
> + byte = registers[i];
> + *pos = hex_asc_hi(byte);
> + pos++;
> + *pos = hex_asc_lo(byte);
> + pos++;
> + }
> +
> + utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN, (wchar_t *)out, len * 4);
Same here. Just for the sake of calling utf8s_to_utf16s() you need the
same loop plus an additional buffer. I don't get it.
> +}
> +
> +static void asus_wmi_ec_make_block_read_query(struct asus_wmi_ec_info *ec)
> +{
> + u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> + const struct ec_sensor_info *si;
> + long i, j, register_idx = 0;
long? maybe a simple unsigned or int?
> +
> +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info *ec)
> +{
> + const struct ec_sensor_info *si;
> + struct ec_sensor *s;
> +
> + u32 value;
This variable is now redundant.
> + if (si->addr.size == 1)
Maybe switch(si->addr.size)?
> + value = ec->read_buffer[read_reg_ct];
> + else if (si->addr.size == 2)
> + value = get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> + else if (si->addr.size == 4)
> + value = get_unaligned_le32(&ec->read_buffer[read_reg_ct]);
> +
> + read_reg_ct += si->addr.size;
> + s->cached_value = value;
> + }
> + return 0;
> +}
> + mutex_lock(&sensor_data->lock);
The mutex locking/unlocking should be moved inside the
update_ec_sensors(), I guess.
I re-read your answer to my question as to why don't you add module
aliases to the driver, and I have to admit I don't really understand
it. Could you, please, elaborate?
Thank you,
Eugene
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-06 23:32 ` Eugene Shalygin
@ 2021-10-07 15:46 ` Denis Pauk
2021-10-07 17:55 ` Eugene Shalygin
0 siblings, 1 reply; 23+ messages in thread
From: Denis Pauk @ 2021-10-07 15:46 UTC (permalink / raw)
To: Eugene Shalygin
Cc: andy.shevchenko, Jean Delvare, Guenter Roeck, linux-kernel, linux-hwmon
Hi Eugene,
On Thu, 7 Oct 2021 01:32:14 +0200
Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
> On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com> wrote:
> >
>
> > Supported motherboards:
> > * ROG CROSSHAIR VIII HERO
> > * ROG CROSSHAIR VIII DARK HERO
> > * ROG CROSSHAIR VIII FORMULA
> > * ROG STRIX X570-E GAMING
> > * ROG STRIX B550-E GAMING
>
> Pro WS X570-ACE is missing from this list.
Thanks, I will check.
>
> > + * EC provided:
> provides
Thanks, I will check.
>
> > + * Chipset temperature,
> > + * CPU temperature,
> > + * Motherboard temperature,
> > + * T_Sensor temperature,
> > + * VRM temperature,
> > + * Water In temperature,
> > + * Water Out temperature,
> > + * CPU Optional Fan,
> Hereinafter "CPU Optional Fan RPM"?
>
Thanks, I will check.
> > +static const enum known_ec_sensor
> > known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> > + [BOARD_PW_X570_A] = {
> > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> > + SENSOR_FAN_CHIPSET,
>
> I missed SENSOR_CURR_CPU for a few boards, and unfortunately the
> mistake made it here too. Sorry for that.
>
Do you have such fix in your repository?
> > +/**
> > + * struct asus_wmi_ec_info - sensor info.
> > + * @sensors: list of sensors.
> > + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> > + * @read_buffer: WMI function output.
>
> This seems to be a bit misleading to me in a sense that the variable
> holds decoded output (array of numbers as opposed to array of
> characters in the WMI output buffer.
>
> > +struct asus_wmi_data {
> > + int ec_board;
> > +};
>
> A leftover?
>
Its platform data and used to share board_id with probe.
> > +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> > +{
> > + unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] /
> > 4);
> > + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > + const char *pos = buffer;
> > + const u8 *data = inp + 2;
> > + unsigned int i;
> > +
> > + utf16s_to_utf8s((wchar_t *)data, len * 2,
> > UTF16_LITTLE_ENDIAN, buffer, len * 2);
> Errr... Why is it here? You need the same loop afterwards, just with a
> smaller stride.
I have tried to apply Andy's idea. And it looks it does not
provide benefits. Andy, what do you think? Maybe I understand it in
wrong way.
> > +
> > + for (i = 0; i < len; i++, pos += 2)
> > + out[i] = (hex_to_bin(pos[0]) << 4) +
> > hex_to_bin(pos[1]); +}
> > +
> > +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len,
> > char *out) +{
> > + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > + char *pos = buffer;
> > + unsigned int i;
> > + u8 byte;
> > +
> > + *out++ = len * 8;
> > + *out++ = 0;
> > +
> > + for (i = 0; i < len; i++) {
> > + byte = registers[i] >> 8;
> > + *pos = hex_asc_hi(byte);
> > + pos++;
> > + *pos = hex_asc_lo(byte);
> > + pos++;
> > + byte = registers[i];
> > + *pos = hex_asc_hi(byte);
> > + pos++;
> > + *pos = hex_asc_lo(byte);
> > + pos++;
> > + }
> > +
> > + utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN,
> > (wchar_t *)out, len * 4);
> Same here. Just for the sake of calling utf8s_to_utf16s() you need the
> same loop plus an additional buffer. I don't get it.
>
I have tried to apply Andy's idea. And it looks it does not
provide benefits. Andy, what do you think? Maybe I understand it in
wrong way.
> > +}
> > +
> > +static void asus_wmi_ec_make_block_read_query(struct
> > asus_wmi_ec_info *ec) +{
> > + u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > + const struct ec_sensor_info *si;
> > + long i, j, register_idx = 0;
> long? maybe a simple unsigned or int?
>
Looks as it was in original patch, I will look.
> > +
> > +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info
> > *ec) +{
> > + const struct ec_sensor_info *si;
> > + struct ec_sensor *s;
> > +
> > + u32 value;
> This variable is now redundant.
>
Thank you, I will look.
> > + if (si->addr.size == 1)
> Maybe switch(si->addr.size)?
>
Thank you, I will check.
> > + value = ec->read_buffer[read_reg_ct];
> > + else if (si->addr.size == 2)
> > + value =
> > get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> > + else if (si->addr.size == 4)
> > + value =
> > get_unaligned_le32(&ec->read_buffer[read_reg_ct]); +
> > + read_reg_ct += si->addr.size;
> > + s->cached_value = value;
> > + }
> > + return 0;
> > +}
>
>
> > + mutex_lock(&sensor_data->lock);
> The mutex locking/unlocking should be moved inside the
> update_ec_sensors(), I guess.
>
> I re-read your answer to my question as to why don't you add module
> aliases to the driver, and I have to admit I don't really understand
> it. Could you, please, elaborate?
>
It looked complicated to support two kind of WMI interfaces with UUID.
As we split big support module to two separate - I will look to such
change also.
> Thank you,
> Eugene
Best regards,
Denis.
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-07 15:46 ` Denis Pauk
@ 2021-10-07 17:55 ` Eugene Shalygin
2021-10-07 18:11 ` Eugene Shalygin
0 siblings, 1 reply; 23+ messages in thread
From: Eugene Shalygin @ 2021-10-07 17:55 UTC (permalink / raw)
To: Denis Pauk
Cc: andy.shevchenko, Jean Delvare, Guenter Roeck, linux-kernel, linux-hwmon
Hi Denis,
yes, the GH repo contains the fix and a few code cleanups, which I
would like to propose for mainlining too. Also, please find below a
draft of the documentation:
Kernel driver asus-wmi-ec-sensors
=================================
Authors:
<eugene.shalygin@gmail.com>
Description:
------------
ASUS mainboards publish hardware monitoring information via Super I/O
chip and the ACPI embedded controller (EC) registers. Some of the sensors
are only available via the EC.
ASUS WMI interface provides a method (BREC) to read data from EC registers,
which is utilized by this driver to publish those sensor readings to the
HWMON system. The driver is aware of and reads the following sensors:
1. Chipset (PCH) temperature
2. CPU package temperature
3. Motherboard temperature
4. Readings from the T_Sensor header
5. VRM temperature
6. CPU_Opt fan RPM
7. Chipset fan RPM
8. Readings from the "Water flow meter" header (RPM)
9. Readings from the "Water In" and "Water Out" temperature headers
10. CPU current
Best regards,
Eugene
On Thu, 7 Oct 2021 at 17:46, Denis Pauk <pauk.denis@gmail.com> wrote:
>
> Hi Eugene,
>
> On Thu, 7 Oct 2021 01:32:14 +0200
> Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
>
> > On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com> wrote:
> > >
> >
> > > Supported motherboards:
> > > * ROG CROSSHAIR VIII HERO
> > > * ROG CROSSHAIR VIII DARK HERO
> > > * ROG CROSSHAIR VIII FORMULA
> > > * ROG STRIX X570-E GAMING
> > > * ROG STRIX B550-E GAMING
> >
> > Pro WS X570-ACE is missing from this list.
> Thanks, I will check.
> >
> > > + * EC provided:
> > provides
> Thanks, I will check.
> >
> > > + * Chipset temperature,
> > > + * CPU temperature,
> > > + * Motherboard temperature,
> > > + * T_Sensor temperature,
> > > + * VRM temperature,
> > > + * Water In temperature,
> > > + * Water Out temperature,
> > > + * CPU Optional Fan,
> > Hereinafter "CPU Optional Fan RPM"?
> >
> Thanks, I will check.
> > > +static const enum known_ec_sensor
> > > known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> > > + [BOARD_PW_X570_A] = {
> > > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > > SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> > > + SENSOR_FAN_CHIPSET,
> >
> > I missed SENSOR_CURR_CPU for a few boards, and unfortunately the
> > mistake made it here too. Sorry for that.
> >
> Do you have such fix in your repository?
> > > +/**
> > > + * struct asus_wmi_ec_info - sensor info.
> > > + * @sensors: list of sensors.
> > > + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> > > + * @read_buffer: WMI function output.
> >
> > This seems to be a bit misleading to me in a sense that the variable
> > holds decoded output (array of numbers as opposed to array of
> > characters in the WMI output buffer.
> >
> > > +struct asus_wmi_data {
> > > + int ec_board;
> > > +};
> >
> > A leftover?
> >
> Its platform data and used to share board_id with probe.
>
> > > +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> > > +{
> > > + unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] /
> > > 4);
> > > + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > + const char *pos = buffer;
> > > + const u8 *data = inp + 2;
> > > + unsigned int i;
> > > +
> > > + utf16s_to_utf8s((wchar_t *)data, len * 2,
> > > UTF16_LITTLE_ENDIAN, buffer, len * 2);
> > Errr... Why is it here? You need the same loop afterwards, just with a
> > smaller stride.
> I have tried to apply Andy's idea. And it looks it does not
> provide benefits. Andy, what do you think? Maybe I understand it in
> wrong way.
> > > +
> > > + for (i = 0; i < len; i++, pos += 2)
> > > + out[i] = (hex_to_bin(pos[0]) << 4) +
> > > hex_to_bin(pos[1]); +}
> > > +
> > > +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len,
> > > char *out) +{
> > > + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > + char *pos = buffer;
> > > + unsigned int i;
> > > + u8 byte;
> > > +
> > > + *out++ = len * 8;
> > > + *out++ = 0;
> > > +
> > > + for (i = 0; i < len; i++) {
> > > + byte = registers[i] >> 8;
> > > + *pos = hex_asc_hi(byte);
> > > + pos++;
> > > + *pos = hex_asc_lo(byte);
> > > + pos++;
> > > + byte = registers[i];
> > > + *pos = hex_asc_hi(byte);
> > > + pos++;
> > > + *pos = hex_asc_lo(byte);
> > > + pos++;
> > > + }
> > > +
> > > + utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN,
> > > (wchar_t *)out, len * 4);
> > Same here. Just for the sake of calling utf8s_to_utf16s() you need the
> > same loop plus an additional buffer. I don't get it.
> >
> I have tried to apply Andy's idea. And it looks it does not
> provide benefits. Andy, what do you think? Maybe I understand it in
> wrong way.
> > > +}
> > > +
> > > +static void asus_wmi_ec_make_block_read_query(struct
> > > asus_wmi_ec_info *ec) +{
> > > + u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > > + const struct ec_sensor_info *si;
> > > + long i, j, register_idx = 0;
> > long? maybe a simple unsigned or int?
> >
> Looks as it was in original patch, I will look.
> > > +
> > > +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info
> > > *ec) +{
> > > + const struct ec_sensor_info *si;
> > > + struct ec_sensor *s;
> > > +
> > > + u32 value;
> > This variable is now redundant.
> >
> Thank you, I will look.
>
> > > + if (si->addr.size == 1)
> > Maybe switch(si->addr.size)?
> >
> Thank you, I will check.
> > > + value = ec->read_buffer[read_reg_ct];
> > > + else if (si->addr.size == 2)
> > > + value =
> > > get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> > > + else if (si->addr.size == 4)
> > > + value =
> > > get_unaligned_le32(&ec->read_buffer[read_reg_ct]); +
> > > + read_reg_ct += si->addr.size;
> > > + s->cached_value = value;
> > > + }
> > > + return 0;
> > > +}
> >
> >
> > > + mutex_lock(&sensor_data->lock);
> > The mutex locking/unlocking should be moved inside the
> > update_ec_sensors(), I guess.
> >
> > I re-read your answer to my question as to why don't you add module
> > aliases to the driver, and I have to admit I don't really understand
> > it. Could you, please, elaborate?
> >
> It looked complicated to support two kind of WMI interfaces with UUID.
> As we split big support module to two separate - I will look to such
> change also.
>
> > Thank you,
> > Eugene
>
> Best regards,
> Denis.
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-07 17:55 ` Eugene Shalygin
@ 2021-10-07 18:11 ` Eugene Shalygin
2021-10-09 15:44 ` Eugene Shalygin
2021-10-10 10:39 ` Denis Pauk
0 siblings, 2 replies; 23+ messages in thread
From: Eugene Shalygin @ 2021-10-07 18:11 UTC (permalink / raw)
To: Denis Pauk
Cc: andy.shevchenko, Jean Delvare, Guenter Roeck, linux-kernel, linux-hwmon
Denis and All,
regarding the asus-wmi-ec-sensors driver: it uses a WMI method to read
EC registers, and this method is slow (requires almost a full second
for a single call). Maybe I'm doing something wrong, but my impression
is that the WMI calls themselves are that slow. I will try to
reimplement this driver using direct EC operations and the global ACPI
lock with a hope to make it read sensors quicker. If that works out,
perhaps the nct6775 may go the same way, as it suffers too from the
slow WMI calls. I know next to nothing about the ACPI system and learn
from the beginning, so I'm not sure about the result. I know the naive
reading from the ACPI EC registers leads to problems (fans get stuck,
etc.), and if someone with knowledge can assure me that the idea with
the ACPI global lock (as far as I understand it is even implemented in
the ec kernel driver already) is correct, I would even request to stop
accepting the EC WMI sensors driver, as it is so slow (albeit dead
simple and small).
Best regards,
Eugen
On Thu, 7 Oct 2021 at 19:55, Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
>
> Hi Denis,
>
> yes, the GH repo contains the fix and a few code cleanups, which I
> would like to propose for mainlining too. Also, please find below a
> draft of the documentation:
>
> Kernel driver asus-wmi-ec-sensors
> =================================
>
> Authors:
> <eugene.shalygin@gmail.com>
>
> Description:
> ------------
> ASUS mainboards publish hardware monitoring information via Super I/O
> chip and the ACPI embedded controller (EC) registers. Some of the sensors
> are only available via the EC.
>
> ASUS WMI interface provides a method (BREC) to read data from EC registers,
> which is utilized by this driver to publish those sensor readings to the
> HWMON system. The driver is aware of and reads the following sensors:
>
> 1. Chipset (PCH) temperature
> 2. CPU package temperature
> 3. Motherboard temperature
> 4. Readings from the T_Sensor header
> 5. VRM temperature
> 6. CPU_Opt fan RPM
> 7. Chipset fan RPM
> 8. Readings from the "Water flow meter" header (RPM)
> 9. Readings from the "Water In" and "Water Out" temperature headers
> 10. CPU current
>
> Best regards,
> Eugene
>
> On Thu, 7 Oct 2021 at 17:46, Denis Pauk <pauk.denis@gmail.com> wrote:
> >
> > Hi Eugene,
> >
> > On Thu, 7 Oct 2021 01:32:14 +0200
> > Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
> >
> > > On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com> wrote:
> > > >
> > >
> > > > Supported motherboards:
> > > > * ROG CROSSHAIR VIII HERO
> > > > * ROG CROSSHAIR VIII DARK HERO
> > > > * ROG CROSSHAIR VIII FORMULA
> > > > * ROG STRIX X570-E GAMING
> > > > * ROG STRIX B550-E GAMING
> > >
> > > Pro WS X570-ACE is missing from this list.
> > Thanks, I will check.
> > >
> > > > + * EC provided:
> > > provides
> > Thanks, I will check.
> > >
> > > > + * Chipset temperature,
> > > > + * CPU temperature,
> > > > + * Motherboard temperature,
> > > > + * T_Sensor temperature,
> > > > + * VRM temperature,
> > > > + * Water In temperature,
> > > > + * Water Out temperature,
> > > > + * CPU Optional Fan,
> > > Hereinafter "CPU Optional Fan RPM"?
> > >
> > Thanks, I will check.
> > > > +static const enum known_ec_sensor
> > > > known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> > > > + [BOARD_PW_X570_A] = {
> > > > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > > > SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> > > > + SENSOR_FAN_CHIPSET,
> > >
> > > I missed SENSOR_CURR_CPU for a few boards, and unfortunately the
> > > mistake made it here too. Sorry for that.
> > >
> > Do you have such fix in your repository?
> > > > +/**
> > > > + * struct asus_wmi_ec_info - sensor info.
> > > > + * @sensors: list of sensors.
> > > > + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> > > > + * @read_buffer: WMI function output.
> > >
> > > This seems to be a bit misleading to me in a sense that the variable
> > > holds decoded output (array of numbers as opposed to array of
> > > characters in the WMI output buffer.
> > >
> > > > +struct asus_wmi_data {
> > > > + int ec_board;
> > > > +};
> > >
> > > A leftover?
> > >
> > Its platform data and used to share board_id with probe.
> >
> > > > +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> > > > +{
> > > > + unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] /
> > > > 4);
> > > > + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > > + const char *pos = buffer;
> > > > + const u8 *data = inp + 2;
> > > > + unsigned int i;
> > > > +
> > > > + utf16s_to_utf8s((wchar_t *)data, len * 2,
> > > > UTF16_LITTLE_ENDIAN, buffer, len * 2);
> > > Errr... Why is it here? You need the same loop afterwards, just with a
> > > smaller stride.
> > I have tried to apply Andy's idea. And it looks it does not
> > provide benefits. Andy, what do you think? Maybe I understand it in
> > wrong way.
> > > > +
> > > > + for (i = 0; i < len; i++, pos += 2)
> > > > + out[i] = (hex_to_bin(pos[0]) << 4) +
> > > > hex_to_bin(pos[1]); +}
> > > > +
> > > > +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len,
> > > > char *out) +{
> > > > + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > > + char *pos = buffer;
> > > > + unsigned int i;
> > > > + u8 byte;
> > > > +
> > > > + *out++ = len * 8;
> > > > + *out++ = 0;
> > > > +
> > > > + for (i = 0; i < len; i++) {
> > > > + byte = registers[i] >> 8;
> > > > + *pos = hex_asc_hi(byte);
> > > > + pos++;
> > > > + *pos = hex_asc_lo(byte);
> > > > + pos++;
> > > > + byte = registers[i];
> > > > + *pos = hex_asc_hi(byte);
> > > > + pos++;
> > > > + *pos = hex_asc_lo(byte);
> > > > + pos++;
> > > > + }
> > > > +
> > > > + utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN,
> > > > (wchar_t *)out, len * 4);
> > > Same here. Just for the sake of calling utf8s_to_utf16s() you need the
> > > same loop plus an additional buffer. I don't get it.
> > >
> > I have tried to apply Andy's idea. And it looks it does not
> > provide benefits. Andy, what do you think? Maybe I understand it in
> > wrong way.
> > > > +}
> > > > +
> > > > +static void asus_wmi_ec_make_block_read_query(struct
> > > > asus_wmi_ec_info *ec) +{
> > > > + u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > > > + const struct ec_sensor_info *si;
> > > > + long i, j, register_idx = 0;
> > > long? maybe a simple unsigned or int?
> > >
> > Looks as it was in original patch, I will look.
> > > > +
> > > > +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info
> > > > *ec) +{
> > > > + const struct ec_sensor_info *si;
> > > > + struct ec_sensor *s;
> > > > +
> > > > + u32 value;
> > > This variable is now redundant.
> > >
> > Thank you, I will look.
> >
> > > > + if (si->addr.size == 1)
> > > Maybe switch(si->addr.size)?
> > >
> > Thank you, I will check.
> > > > + value = ec->read_buffer[read_reg_ct];
> > > > + else if (si->addr.size == 2)
> > > > + value =
> > > > get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> > > > + else if (si->addr.size == 4)
> > > > + value =
> > > > get_unaligned_le32(&ec->read_buffer[read_reg_ct]); +
> > > > + read_reg_ct += si->addr.size;
> > > > + s->cached_value = value;
> > > > + }
> > > > + return 0;
> > > > +}
> > >
> > >
> > > > + mutex_lock(&sensor_data->lock);
> > > The mutex locking/unlocking should be moved inside the
> > > update_ec_sensors(), I guess.
> > >
> > > I re-read your answer to my question as to why don't you add module
> > > aliases to the driver, and I have to admit I don't really understand
> > > it. Could you, please, elaborate?
> > >
> > It looked complicated to support two kind of WMI interfaces with UUID.
> > As we split big support module to two separate - I will look to such
> > change also.
> >
> > > Thank you,
> > > Eugene
> >
> > Best regards,
> > Denis.
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-07 18:11 ` Eugene Shalygin
@ 2021-10-09 15:44 ` Eugene Shalygin
2021-10-10 10:39 ` Denis Pauk
1 sibling, 0 replies; 23+ messages in thread
From: Eugene Shalygin @ 2021-10-09 15:44 UTC (permalink / raw)
To: Denis Pauk
Cc: andy.shevchenko, Jean Delvare, Guenter Roeck, linux-kernel, linux-hwmon
Dear Denis and all,
Let me propose for your consideration a better approach, as I believe,
to the problem with ASUS hardware sensors for the boards with SIO and
EC resources marked as used by the ACPI code. It evolved from the
discussion and patches in the kernel bug 204807, work by Denis, and my
attempts to implement sensor reading from the ACPI EC registers.
Thanks to the users who submitted ACPI dumps for many ASUS boards in
bug 204807 and discussion in the Libre Hardware Monitor project we
learned the names for methods to read SIO and EC registers. Now we
have drivers that implement reading via the ACPI (WMI, to be precise)
methods sensor values. However, this slows down reading by a great
margin (for example, reading from EC takes almost a full second). But
do we need to use ACPI functions to read data?
If one checks out AML code for all the boards, it can be noted that
all the WMI hardware access functions are guarded by a mutex, which
has the same name for all the ASUS boards ("\AMW0.ASMX"). Thus, we do
not need to use WMI functions, but can simply lock the same mutex and
access hardware registers directly.
For the EC case this reduced reading delay from 0.99 seconds down to
0.01 -- 0.3 seconds. So, I propose to change the nct6775 code and
instead of using the SIO read function from board WMI, just grab that
mutex and read directly. For the EC sensors I've done that in a GH
repo [1].
Best regards,
Eugene
[1] https://github.com/zeule/asus-ec-sensors
On Thu, 7 Oct 2021 at 20:11, Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
>
> Denis and All,
>
> regarding the asus-wmi-ec-sensors driver: it uses a WMI method to read
> EC registers, and this method is slow (requires almost a full second
> for a single call). Maybe I'm doing something wrong, but my impression
> is that the WMI calls themselves are that slow. I will try to
> reimplement this driver using direct EC operations and the global ACPI
> lock with a hope to make it read sensors quicker. If that works out,
> perhaps the nct6775 may go the same way, as it suffers too from the
> slow WMI calls. I know next to nothing about the ACPI system and learn
> from the beginning, so I'm not sure about the result. I know the naive
> reading from the ACPI EC registers leads to problems (fans get stuck,
> etc.), and if someone with knowledge can assure me that the idea with
> the ACPI global lock (as far as I understand it is even implemented in
> the ec kernel driver already) is correct, I would even request to stop
> accepting the EC WMI sensors driver, as it is so slow (albeit dead
> simple and small).
>
> Best regards,
> Eugen
>
> On Thu, 7 Oct 2021 at 19:55, Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
> >
> > Hi Denis,
> >
> > yes, the GH repo contains the fix and a few code cleanups, which I
> > would like to propose for mainlining too. Also, please find below a
> > draft of the documentation:
> >
> > Kernel driver asus-wmi-ec-sensors
> > =================================
> >
> > Authors:
> > <eugene.shalygin@gmail.com>
> >
> > Description:
> > ------------
> > ASUS mainboards publish hardware monitoring information via Super I/O
> > chip and the ACPI embedded controller (EC) registers. Some of the sensors
> > are only available via the EC.
> >
> > ASUS WMI interface provides a method (BREC) to read data from EC registers,
> > which is utilized by this driver to publish those sensor readings to the
> > HWMON system. The driver is aware of and reads the following sensors:
> >
> > 1. Chipset (PCH) temperature
> > 2. CPU package temperature
> > 3. Motherboard temperature
> > 4. Readings from the T_Sensor header
> > 5. VRM temperature
> > 6. CPU_Opt fan RPM
> > 7. Chipset fan RPM
> > 8. Readings from the "Water flow meter" header (RPM)
> > 9. Readings from the "Water In" and "Water Out" temperature headers
> > 10. CPU current
> >
> > Best regards,
> > Eugene
> >
> > On Thu, 7 Oct 2021 at 17:46, Denis Pauk <pauk.denis@gmail.com> wrote:
> > >
> > > Hi Eugene,
> > >
> > > On Thu, 7 Oct 2021 01:32:14 +0200
> > > Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
> > >
> > > > On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com> wrote:
> > > > >
> > > >
> > > > > Supported motherboards:
> > > > > * ROG CROSSHAIR VIII HERO
> > > > > * ROG CROSSHAIR VIII DARK HERO
> > > > > * ROG CROSSHAIR VIII FORMULA
> > > > > * ROG STRIX X570-E GAMING
> > > > > * ROG STRIX B550-E GAMING
> > > >
> > > > Pro WS X570-ACE is missing from this list.
> > > Thanks, I will check.
> > > >
> > > > > + * EC provided:
> > > > provides
> > > Thanks, I will check.
> > > >
> > > > > + * Chipset temperature,
> > > > > + * CPU temperature,
> > > > > + * Motherboard temperature,
> > > > > + * T_Sensor temperature,
> > > > > + * VRM temperature,
> > > > > + * Water In temperature,
> > > > > + * Water Out temperature,
> > > > > + * CPU Optional Fan,
> > > > Hereinafter "CPU Optional Fan RPM"?
> > > >
> > > Thanks, I will check.
> > > > > +static const enum known_ec_sensor
> > > > > known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> > > > > + [BOARD_PW_X570_A] = {
> > > > > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > > > > SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> > > > > + SENSOR_FAN_CHIPSET,
> > > >
> > > > I missed SENSOR_CURR_CPU for a few boards, and unfortunately the
> > > > mistake made it here too. Sorry for that.
> > > >
> > > Do you have such fix in your repository?
> > > > > +/**
> > > > > + * struct asus_wmi_ec_info - sensor info.
> > > > > + * @sensors: list of sensors.
> > > > > + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> > > > > + * @read_buffer: WMI function output.
> > > >
> > > > This seems to be a bit misleading to me in a sense that the variable
> > > > holds decoded output (array of numbers as opposed to array of
> > > > characters in the WMI output buffer.
> > > >
> > > > > +struct asus_wmi_data {
> > > > > + int ec_board;
> > > > > +};
> > > >
> > > > A leftover?
> > > >
> > > Its platform data and used to share board_id with probe.
> > >
> > > > > +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> > > > > +{
> > > > > + unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] /
> > > > > 4);
> > > > > + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > > > + const char *pos = buffer;
> > > > > + const u8 *data = inp + 2;
> > > > > + unsigned int i;
> > > > > +
> > > > > + utf16s_to_utf8s((wchar_t *)data, len * 2,
> > > > > UTF16_LITTLE_ENDIAN, buffer, len * 2);
> > > > Errr... Why is it here? You need the same loop afterwards, just with a
> > > > smaller stride.
> > > I have tried to apply Andy's idea. And it looks it does not
> > > provide benefits. Andy, what do you think? Maybe I understand it in
> > > wrong way.
> > > > > +
> > > > > + for (i = 0; i < len; i++, pos += 2)
> > > > > + out[i] = (hex_to_bin(pos[0]) << 4) +
> > > > > hex_to_bin(pos[1]); +}
> > > > > +
> > > > > +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len,
> > > > > char *out) +{
> > > > > + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > > > + char *pos = buffer;
> > > > > + unsigned int i;
> > > > > + u8 byte;
> > > > > +
> > > > > + *out++ = len * 8;
> > > > > + *out++ = 0;
> > > > > +
> > > > > + for (i = 0; i < len; i++) {
> > > > > + byte = registers[i] >> 8;
> > > > > + *pos = hex_asc_hi(byte);
> > > > > + pos++;
> > > > > + *pos = hex_asc_lo(byte);
> > > > > + pos++;
> > > > > + byte = registers[i];
> > > > > + *pos = hex_asc_hi(byte);
> > > > > + pos++;
> > > > > + *pos = hex_asc_lo(byte);
> > > > > + pos++;
> > > > > + }
> > > > > +
> > > > > + utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN,
> > > > > (wchar_t *)out, len * 4);
> > > > Same here. Just for the sake of calling utf8s_to_utf16s() you need the
> > > > same loop plus an additional buffer. I don't get it.
> > > >
> > > I have tried to apply Andy's idea. And it looks it does not
> > > provide benefits. Andy, what do you think? Maybe I understand it in
> > > wrong way.
> > > > > +}
> > > > > +
> > > > > +static void asus_wmi_ec_make_block_read_query(struct
> > > > > asus_wmi_ec_info *ec) +{
> > > > > + u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > > > > + const struct ec_sensor_info *si;
> > > > > + long i, j, register_idx = 0;
> > > > long? maybe a simple unsigned or int?
> > > >
> > > Looks as it was in original patch, I will look.
> > > > > +
> > > > > +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info
> > > > > *ec) +{
> > > > > + const struct ec_sensor_info *si;
> > > > > + struct ec_sensor *s;
> > > > > +
> > > > > + u32 value;
> > > > This variable is now redundant.
> > > >
> > > Thank you, I will look.
> > >
> > > > > + if (si->addr.size == 1)
> > > > Maybe switch(si->addr.size)?
> > > >
> > > Thank you, I will check.
> > > > > + value = ec->read_buffer[read_reg_ct];
> > > > > + else if (si->addr.size == 2)
> > > > > + value =
> > > > > get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> > > > > + else if (si->addr.size == 4)
> > > > > + value =
> > > > > get_unaligned_le32(&ec->read_buffer[read_reg_ct]); +
> > > > > + read_reg_ct += si->addr.size;
> > > > > + s->cached_value = value;
> > > > > + }
> > > > > + return 0;
> > > > > +}
> > > >
> > > >
> > > > > + mutex_lock(&sensor_data->lock);
> > > > The mutex locking/unlocking should be moved inside the
> > > > update_ec_sensors(), I guess.
> > > >
> > > > I re-read your answer to my question as to why don't you add module
> > > > aliases to the driver, and I have to admit I don't really understand
> > > > it. Could you, please, elaborate?
> > > >
> > > It looked complicated to support two kind of WMI interfaces with UUID.
> > > As we split big support module to two separate - I will look to such
> > > change also.
> > >
> > > > Thank you,
> > > > Eugene
> > >
> > > Best regards,
> > > Denis.
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-07 18:11 ` Eugene Shalygin
2021-10-09 15:44 ` Eugene Shalygin
@ 2021-10-10 10:39 ` Denis Pauk
2021-10-10 13:46 ` Eugene Shalygin
1 sibling, 1 reply; 23+ messages in thread
From: Denis Pauk @ 2021-10-10 10:39 UTC (permalink / raw)
To: Eugene Shalygin
Cc: andy.shevchenko, Jean Delvare, Guenter Roeck, linux-kernel, linux-hwmon
Hi Eugene,
As for me, use WMI methods will be more reliable and cover more
motherboards.
Best regards,
Denis.
On Thu, 7 Oct 2021 20:11:33 +0200
Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
> Denis and All,
>
> regarding the asus-wmi-ec-sensors driver: it uses a WMI method to read
> EC registers, and this method is slow (requires almost a full second
> for a single call). Maybe I'm doing something wrong, but my impression
> is that the WMI calls themselves are that slow. I will try to
> reimplement this driver using direct EC operations and the global ACPI
> lock with a hope to make it read sensors quicker. If that works out,
> perhaps the nct6775 may go the same way, as it suffers too from the
> slow WMI calls. I know next to nothing about the ACPI system and learn
> from the beginning, so I'm not sure about the result. I know the naive
> reading from the ACPI EC registers leads to problems (fans get stuck,
> etc.), and if someone with knowledge can assure me that the idea with
> the ACPI global lock (as far as I understand it is even implemented in
> the ec kernel driver already) is correct, I would even request to stop
> accepting the EC WMI sensors driver, as it is so slow (albeit dead
> simple and small).
>
> Best regards,
> Eugen
>
> On Thu, 7 Oct 2021 at 19:55, Eugene Shalygin
> <eugene.shalygin@gmail.com> wrote:
> >
> > Hi Denis,
> >
> > yes, the GH repo contains the fix and a few code cleanups, which I
> > would like to propose for mainlining too. Also, please find below a
> > draft of the documentation:
> >
> > Kernel driver asus-wmi-ec-sensors
> > =================================
> >
> > Authors:
> > <eugene.shalygin@gmail.com>
> >
> > Description:
> > ------------
> > ASUS mainboards publish hardware monitoring information via Super
> > I/O chip and the ACPI embedded controller (EC) registers. Some of
> > the sensors are only available via the EC.
> >
> > ASUS WMI interface provides a method (BREC) to read data from EC
> > registers, which is utilized by this driver to publish those sensor
> > readings to the HWMON system. The driver is aware of and reads the
> > following sensors:
> >
> > 1. Chipset (PCH) temperature
> > 2. CPU package temperature
> > 3. Motherboard temperature
> > 4. Readings from the T_Sensor header
> > 5. VRM temperature
> > 6. CPU_Opt fan RPM
> > 7. Chipset fan RPM
> > 8. Readings from the "Water flow meter" header (RPM)
> > 9. Readings from the "Water In" and "Water Out" temperature headers
> > 10. CPU current
> >
> > Best regards,
> > Eugene
> >
> > On Thu, 7 Oct 2021 at 17:46, Denis Pauk <pauk.denis@gmail.com>
> > wrote:
> > >
> > > Hi Eugene,
> > >
> > > On Thu, 7 Oct 2021 01:32:14 +0200
> > > Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
> > >
> > > > On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com>
> > > > wrote:
> > > > >
> > > >
> > > > > Supported motherboards:
> > > > > * ROG CROSSHAIR VIII HERO
> > > > > * ROG CROSSHAIR VIII DARK HERO
> > > > > * ROG CROSSHAIR VIII FORMULA
> > > > > * ROG STRIX X570-E GAMING
> > > > > * ROG STRIX B550-E GAMING
> > > >
> > > > Pro WS X570-ACE is missing from this list.
> > > Thanks, I will check.
> > > >
> > > > > + * EC provided:
> > > > provides
> > > Thanks, I will check.
> > > >
> > > > > + * Chipset temperature,
> > > > > + * CPU temperature,
> > > > > + * Motherboard temperature,
> > > > > + * T_Sensor temperature,
> > > > > + * VRM temperature,
> > > > > + * Water In temperature,
> > > > > + * Water Out temperature,
> > > > > + * CPU Optional Fan,
> > > > Hereinafter "CPU Optional Fan RPM"?
> > > >
> > > Thanks, I will check.
> > > > > +static const enum known_ec_sensor
> > > > > known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> > > > > + [BOARD_PW_X570_A] = {
> > > > > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > > > > SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> > > > > + SENSOR_FAN_CHIPSET,
> > > >
> > > > I missed SENSOR_CURR_CPU for a few boards, and unfortunately the
> > > > mistake made it here too. Sorry for that.
> > > >
> > > Do you have such fix in your repository?
> > > > > +/**
> > > > > + * struct asus_wmi_ec_info - sensor info.
> > > > > + * @sensors: list of sensors.
> > > > > + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> > > > > + * @read_buffer: WMI function output.
> > > >
> > > > This seems to be a bit misleading to me in a sense that the
> > > > variable holds decoded output (array of numbers as opposed to
> > > > array of characters in the WMI output buffer.
> > > >
> > > > > +struct asus_wmi_data {
> > > > > + int ec_board;
> > > > > +};
> > > >
> > > > A leftover?
> > > >
> > > Its platform data and used to share board_id with probe.
> > >
> > > > > +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp,
> > > > > u8 *out) +{
> > > > > + unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN,
> > > > > inp[0] / 4);
> > > > > + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > > > + const char *pos = buffer;
> > > > > + const u8 *data = inp + 2;
> > > > > + unsigned int i;
> > > > > +
> > > > > + utf16s_to_utf8s((wchar_t *)data, len * 2,
> > > > > UTF16_LITTLE_ENDIAN, buffer, len * 2);
> > > > Errr... Why is it here? You need the same loop afterwards, just
> > > > with a smaller stride.
> > > I have tried to apply Andy's idea. And it looks it does not
> > > provide benefits. Andy, what do you think? Maybe I understand it
> > > in wrong way.
> > > > > +
> > > > > + for (i = 0; i < len; i++, pos += 2)
> > > > > + out[i] = (hex_to_bin(pos[0]) << 4) +
> > > > > hex_to_bin(pos[1]); +}
> > > > > +
> > > > > +static void asus_wmi_ec_encode_registers(u16 *registers, u8
> > > > > len, char *out) +{
> > > > > + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > > > + char *pos = buffer;
> > > > > + unsigned int i;
> > > > > + u8 byte;
> > > > > +
> > > > > + *out++ = len * 8;
> > > > > + *out++ = 0;
> > > > > +
> > > > > + for (i = 0; i < len; i++) {
> > > > > + byte = registers[i] >> 8;
> > > > > + *pos = hex_asc_hi(byte);
> > > > > + pos++;
> > > > > + *pos = hex_asc_lo(byte);
> > > > > + pos++;
> > > > > + byte = registers[i];
> > > > > + *pos = hex_asc_hi(byte);
> > > > > + pos++;
> > > > > + *pos = hex_asc_lo(byte);
> > > > > + pos++;
> > > > > + }
> > > > > +
> > > > > + utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN,
> > > > > (wchar_t *)out, len * 4);
> > > > Same here. Just for the sake of calling utf8s_to_utf16s() you
> > > > need the same loop plus an additional buffer. I don't get it.
> > > >
> > > I have tried to apply Andy's idea. And it looks it does not
> > > provide benefits. Andy, what do you think? Maybe I understand it
> > > in wrong way.
> > > > > +}
> > > > > +
> > > > > +static void asus_wmi_ec_make_block_read_query(struct
> > > > > asus_wmi_ec_info *ec) +{
> > > > > + u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > > > > + const struct ec_sensor_info *si;
> > > > > + long i, j, register_idx = 0;
> > > > long? maybe a simple unsigned or int?
> > > >
> > > Looks as it was in original patch, I will look.
> > > > > +
> > > > > +static int asus_wmi_ec_update_ec_sensors(struct
> > > > > asus_wmi_ec_info *ec) +{
> > > > > + const struct ec_sensor_info *si;
> > > > > + struct ec_sensor *s;
> > > > > +
> > > > > + u32 value;
> > > > This variable is now redundant.
> > > >
> > > Thank you, I will look.
> > >
> > > > > + if (si->addr.size == 1)
> > > > Maybe switch(si->addr.size)?
> > > >
> > > Thank you, I will check.
> > > > > + value = ec->read_buffer[read_reg_ct];
> > > > > + else if (si->addr.size == 2)
> > > > > + value =
> > > > > get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> > > > > + else if (si->addr.size == 4)
> > > > > + value =
> > > > > get_unaligned_le32(&ec->read_buffer[read_reg_ct]); +
> > > > > + read_reg_ct += si->addr.size;
> > > > > + s->cached_value = value;
> > > > > + }
> > > > > + return 0;
> > > > > +}
> > > >
> > > >
> > > > > + mutex_lock(&sensor_data->lock);
> > > > The mutex locking/unlocking should be moved inside the
> > > > update_ec_sensors(), I guess.
> > > >
> > > > I re-read your answer to my question as to why don't you add
> > > > module aliases to the driver, and I have to admit I don't
> > > > really understand it. Could you, please, elaborate?
> > > >
> > > It looked complicated to support two kind of WMI interfaces with
> > > UUID. As we split big support module to two separate - I will
> > > look to such change also.
> > >
> > > > Thank you,
> > > > Eugene
> > >
> > > Best regards,
> > > Denis.
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-10 10:39 ` Denis Pauk
@ 2021-10-10 13:46 ` Eugene Shalygin
2021-10-10 14:33 ` Guenter Roeck
0 siblings, 1 reply; 23+ messages in thread
From: Eugene Shalygin @ 2021-10-10 13:46 UTC (permalink / raw)
To: Denis Pauk
Cc: andy.shevchenko, Jean Delvare, Guenter Roeck, linux-kernel, linux-hwmon
Hi Denis,
On Sun, 10 Oct 2021 at 12:39, Denis Pauk <pauk.denis@gmail.com> wrote:
>
> Hi Eugene,
>
> As for me, use WMI methods will be more reliable and cover more
> motherboards.
Why do you believe they are more reliable? How does it cover more motherboards?
Thanks,
Eugene
>
> Best regards,
> Denis.
>
> On Thu, 7 Oct 2021 20:11:33 +0200
> Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
>
> > Denis and All,
> >
> > regarding the asus-wmi-ec-sensors driver: it uses a WMI method to read
> > EC registers, and this method is slow (requires almost a full second
> > for a single call). Maybe I'm doing something wrong, but my impression
> > is that the WMI calls themselves are that slow. I will try to
> > reimplement this driver using direct EC operations and the global ACPI
> > lock with a hope to make it read sensors quicker. If that works out,
> > perhaps the nct6775 may go the same way, as it suffers too from the
> > slow WMI calls. I know next to nothing about the ACPI system and learn
> > from the beginning, so I'm not sure about the result. I know the naive
> > reading from the ACPI EC registers leads to problems (fans get stuck,
> > etc.), and if someone with knowledge can assure me that the idea with
> > the ACPI global lock (as far as I understand it is even implemented in
> > the ec kernel driver already) is correct, I would even request to stop
> > accepting the EC WMI sensors driver, as it is so slow (albeit dead
> > simple and small).
> >
> > Best regards,
> > Eugen
> >
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-10 13:46 ` Eugene Shalygin
@ 2021-10-10 14:33 ` Guenter Roeck
2021-10-10 18:45 ` Eugene Shalygin
0 siblings, 1 reply; 23+ messages in thread
From: Guenter Roeck @ 2021-10-10 14:33 UTC (permalink / raw)
To: Eugene Shalygin, Denis Pauk
Cc: andy.shevchenko, Jean Delvare, linux-kernel, linux-hwmon
On 10/10/21 6:46 AM, Eugene Shalygin wrote:
> Hi Denis,
>
> On Sun, 10 Oct 2021 at 12:39, Denis Pauk <pauk.denis@gmail.com> wrote:
>>
>> Hi Eugene,
>>
>> As for me, use WMI methods will be more reliable and cover more
>> motherboards.
>
> Why do you believe they are more reliable? How does it cover more motherboards?
>
You said yourself below: "I know the naive reading from the ACPI EC registers
leads to problems (fans get stuck, etc.)".
Something in the WMI code is obviously broken and, ultimately, will need
to get fixed. I don't know if that something is on the ASUS side or on the
kernel side, or on the interface between the two. A single WMI call taking
1 second is way too long and strongly suggests that some timeout is involved.
Not using WMI because of that just seems wrong.
Guenter
> Thanks,
> Eugene
>
>>
>> Best regards,
>> Denis.
>>
>> On Thu, 7 Oct 2021 20:11:33 +0200
>> Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
>>
>>> Denis and All,
>>>
>>> regarding the asus-wmi-ec-sensors driver: it uses a WMI method to read
>>> EC registers, and this method is slow (requires almost a full second
>>> for a single call). Maybe I'm doing something wrong, but my impression
>>> is that the WMI calls themselves are that slow. I will try to
>>> reimplement this driver using direct EC operations and the global ACPI
>>> lock with a hope to make it read sensors quicker. If that works out,
>>> perhaps the nct6775 may go the same way, as it suffers too from the
>>> slow WMI calls. I know next to nothing about the ACPI system and learn
>>> from the beginning, so I'm not sure about the result. I know the naive
>>> reading from the ACPI EC registers leads to problems (fans get stuck,
>>> etc.), and if someone with knowledge can assure me that the idea with
>>> the ACPI global lock (as far as I understand it is even implemented in
>>> the ec kernel driver already) is correct, I would even request to stop
>>> accepting the EC WMI sensors driver, as it is so slow (albeit dead
>>> simple and small).
>>>
>>> Best regards,
>>> Eugen
>>>
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-10 14:33 ` Guenter Roeck
@ 2021-10-10 18:45 ` Eugene Shalygin
2021-10-25 13:10 ` Eugene Shalygin
0 siblings, 1 reply; 23+ messages in thread
From: Eugene Shalygin @ 2021-10-10 18:45 UTC (permalink / raw)
To: Guenter Roeck
Cc: Denis Pauk, andy.shevchenko, Jean Delvare, linux-kernel, linux-hwmon
Günter,
On Sun, 10 Oct 2021 at 16:33, Guenter Roeck <linux@roeck-us.net> wrote:
> > Why do you believe they are more reliable? How does it cover more motherboards?
> >
>
> You said yourself below: "I know the naive reading from the ACPI EC registers
> leads to problems (fans get stuck, etc.)".
I also know what the WMI functions (BREC, RSIO, WSIO, RHWM, ) do, as I
see their source. They lock the mutex (\AMW0.ASMX) and through
multi-level mapping access EC or Super I/O chip registers. I know all
the hardware access WMI functions begin with acquiring the same mutex,
and those accessing the SIO acquire one more mutex
(\_SB.PCI0.SBRG.SIO1.MUT0). Thus locking the same mutex and accessing
the hardware directly is safe.
By naive I meant reading EC registers without acquiring the ACPI mutex.
> Something in the WMI code is obviously broken and, ultimately, will need
> to get fixed. I don't know if that something is on the ASUS side or on the
> kernel side, or on the interface between the two. A single WMI call taking
> 1 second is way too long and strongly suggests that some timeout is involved.
> Not using WMI because of that just seems wrong.
On that machine a single reading of the EC register (i.e. a call to
ec_read()) takes approx. 14 ms. The timeout is probably right here.
From that the 990 ms delay of BREC is understandable, because for each
register it performs 4 EC transactions: read current bank,
unconditionally switch current bank, read register, switch to the old
bank. When I ask it to read 14 registers, it needs 42 ec_transaction()
calls which would sum up to 600 ms alone. In the new approach I switch
EC banks only when needed (currently only 2 times including rollback
to the previous bank) and save a lot of ec_transaction() calls. It
would help, however, to extend the EC interface in the acpi/ec.c to
allow for block reads in a single transaction.
I don't know why ec_transaction() takes so long, but in any case the
API of the WMI BREC function dictates it to perform slowly because it
needs to do a bank switch for each item in the input array, while the
direct reading allows us to avoid that bloating.
Regards,
Eugene
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-10 18:45 ` Eugene Shalygin
@ 2021-10-25 13:10 ` Eugene Shalygin
0 siblings, 0 replies; 23+ messages in thread
From: Eugene Shalygin @ 2021-10-25 13:10 UTC (permalink / raw)
To: Guenter Roeck
Cc: Denis Pauk, Andy Shevchenko, Jean Delvare,
Linux Kernel Mailing List, linux-hwmon
Hi All,
> On that machine a single reading of the EC register (i.e. a call to
> ec_read()) takes approx. 14 ms. The timeout is probably right here.
I migrated that ASUS machine to another distribution (Arch -> Gentoo,
kernel versions 5.14.8 -> 5.14.14) and surprisingly reading EC
registers became faster. I accumulated data from 14133 read operations
and the times are distributed as follows: 84 % at 4 ms, 10 % at 5 ms,
5.0 % at 6 ms and the rest is between 3 and 9 ms (but concentrating
around multiples of 0.5 ms).
In the meantime the only other user who provided EC read timeouts
showed 14 ms per EC read too.
Regards,
Eugene
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-06 22:25 ` [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI Denis Pauk
2021-10-06 23:32 ` Eugene Shalygin
@ 2021-10-07 16:41 ` Guenter Roeck
2021-10-07 17:17 ` Denis Pauk
2021-10-07 16:47 ` Guenter Roeck
2021-10-08 14:42 ` Eugene Shalygin
3 siblings, 1 reply; 23+ messages in thread
From: Guenter Roeck @ 2021-10-07 16:41 UTC (permalink / raw)
To: Denis Pauk
Cc: andy.shevchenko, Eugene Shalygin, Jean Delvare, linux-kernel,
linux-hwmon
On 10/6/21 3:25 PM, Denis Pauk wrote:
> Linux HWMON sensors driver for ASUS motherboards to read
> sensors from the embedded controller.
>
> Many ASUS motherboards do not publish all the available
> sensors via the Super I/O chip but the missing ones are
> available through the embedded controller (EC) registers.
>
> This driver implements reading those sensor data via the
> WMI method BREC, which is known to be present in all ASUS
> motherboards based on the AMD 500 series chipsets (and
> probably is available in other models too). The driver
> needs to know exact register addresses for the sensors and
> thus support for each motherboard has to be added explicitly.
>
> The EC registers do not provide critical values for the
> sensors and as such they are not published to the HWMON.
>
> Supported motherboards:
> * ROG CROSSHAIR VIII HERO
> * ROG CROSSHAIR VIII DARK HERO
> * ROG CROSSHAIR VIII FORMULA
> * ROG STRIX X570-E GAMING
> * ROG STRIX B550-E GAMING
>
> BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
> Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
> Co-developed-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
>
> ---
> Changes in v2:
> - Use utf8s_to_utf16s/utf16s_to_utf8s instead handmade fuctions.
> - Use post increment.
> - Use get_unaligned* for convert values.
> - Use PTR_ERR_OR_ZERO.
> - Specify per-board sensors in a declarative way (by Eugene Shalygin).
> ---
> MAINTAINERS | 7 +
> drivers/hwmon/Kconfig | 13 +-
> drivers/hwmon/Makefile | 1 +
> drivers/hwmon/asus_wmi_ec_sensors.c | 631 ++++++++++++++++++++++++++++
> 4 files changed, 651 insertions(+), 1 deletion(-)
> create mode 100644 drivers/hwmon/asus_wmi_ec_sensors.c
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index bae3f62f548f..bc2e981a54e2 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -2937,6 +2937,13 @@ W: http://acpi4asus.sf.net
> F: drivers/platform/x86/asus*.c
> F: drivers/platform/x86/eeepc*.c
>
> +ASUS WMI HARDWARE MONITOR DRIVER
> +M: Eugene Shalygin <eugene.shalygin@gmail.com>
> +M: Denis Pauk <pauk.denis@gmail.com>
> +L: linux-hwmon@vger.kernel.org
> +S: Maintained
> +F: drivers/hwmon/asus_wmi_ec_sensors.c
> +
> ASUS WIRELESS RADIO CONTROL DRIVER
> M: João Paulo Rechi Vita <jprvita@gmail.com>
> L: platform-driver-x86@vger.kernel.org
> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> index 7fde4c6e1e7f..b7107721a401 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -1840,7 +1840,7 @@ config SENSORS_ADS7871
>
> config SENSORS_AMC6821
> tristate "Texas Instruments AMC6821"
> - depends on I2C
> + depends on I2C
Completely unrelated and unacceptable change.
> help
> If you say yes here you get support for the Texas Instruments
> AMC6821 hardware monitoring chips.
> @@ -2215,6 +2215,17 @@ config SENSORS_ATK0110
> This driver can also be built as a module. If so, the module
> will be called asus_atk0110.
>
> +config SENSORS_ASUS_WMI_EC
> + tristate "ASUS WMI B550/X570"
> + help
> + If you say yes here you get support for the ACPI embedded controller
> + hardware monitoring interface found in B550/X570 ASUS motherboards.
> + This driver will provide readings of fans, voltages and temperatures
> + through the system firmware.
> +
> + This driver can also be built as a module. If so, the module
> + will be called asus_wmi_sensors_ec.
> +
> endif # ACPI
>
> endif # HWMON
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index baee6a8d4dd1..aae2ff5c7335 100644
> --- a/drivers/hwmon/Makefile
> +++ b/drivers/hwmon/Makefile
> @@ -9,6 +9,7 @@ obj-$(CONFIG_HWMON_VID) += hwmon-vid.o
> # APCI drivers
> obj-$(CONFIG_SENSORS_ACPI_POWER) += acpi_power_meter.o
> obj-$(CONFIG_SENSORS_ATK0110) += asus_atk0110.o
> +obj-$(CONFIG_SENSORS_ASUS_WMI_EC) += asus_wmi_ec_sensors.o
>
> # Native drivers
> # asb100, then w83781d go first, as they can override other drivers' addresses.
> diff --git a/drivers/hwmon/asus_wmi_ec_sensors.c b/drivers/hwmon/asus_wmi_ec_sensors.c
> new file mode 100644
> index 000000000000..553d9ee8656d
> --- /dev/null
> +++ b/drivers/hwmon/asus_wmi_ec_sensors.c
> @@ -0,0 +1,631 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * HWMON driver for ASUS B550/X570 motherboards that publish sensor
> + * values via the embedded controller registers.
> + *
> + * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com>
> + * Copyright (C) 2018-2019 Ed Brindley <kernel@maidavale.org>
> + *
> + * EC provided:
> + * Chipset temperature,
> + * CPU temperature,
> + * Motherboard temperature,
> + * T_Sensor temperature,
> + * VRM temperature,
> + * Water In temperature,
> + * Water Out temperature,
> + * CPU Optional Fan,
> + * Chipset fan,
> + * Water Flow fan,
> + * CPU current.
> + *
> + */
> +#include <asm/unaligned.h>
> +#include <linux/acpi.h>
> +#include <linux/dmi.h>
> +#include <linux/hwmon.h>
> +#include <linux/hwmon-sysfs.h>
> +#include <linux/init.h>
> +#include <linux/jiffies.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/mutex.h>
> +#include <linux/nls.h>
> +#include <linux/platform_device.h>
> +#include <linux/units.h>
> +#include <linux/wmi.h>
> +
> +#define ASUSWMI_MONITORING_GUID "466747A0-70EC-11DE-8A39-0800200C9A66"
> +#define ASUSWMI_METHODID_BLOCK_READ_EC 0x42524543 /* BREC */
> +
> +#define ASUS_WMI_BLOCK_READ_REGISTERS_MAX 0x10 /* from the ASUS DSDT source */
> +/* from the ASUS_WMI_BLOCK_READ_REGISTERS_MAX value */
> +#define ASUS_WMI_MAX_BUF_LEN 0x80
> +#define MAX_SENSOR_LABEL_LENGTH 0x10
> +
> +enum asus_wmi_ec_board {
> + BOARD_PW_X570_A, /* Pro WS X570-ACE */
> + BOARD_R_C8H, /* ROG Crosshair VIII Hero */
> + BOARD_R_C8DH, /* ROG Crosshair VIII Dark Hero */
> + BOARD_R_C8F, /* ROG Crosshair VIII Formula */
> + BOARD_RS_B550_E_G, /* ROG STRIX B550-E GAMING */
> + BOARD_RS_X570_E_G, /* ROG STRIX X570-E GAMING */
> + BOARD_MAX
> +};
> +
> +/* boards with EC support */
> +static const char *const asus_wmi_ec_boards_names[] = {
> + [BOARD_PW_X570_A] = "Pro WS X570-ACE",
> + [BOARD_R_C8H] = "ROG CROSSHAIR VIII HERO",
> + [BOARD_R_C8DH] = "ROG CROSSHAIR VIII DARK HERO",
> + [BOARD_R_C8F] = "ROG CROSSHAIR VIII FORMULA",
> + [BOARD_RS_B550_E_G] = "ROG STRIX B550-E GAMING",
> + [BOARD_RS_X570_E_G] = "ROG STRIX X570-E GAMING",
> +};
> +
> +static u32 hwmon_attributes[] = {
> + [hwmon_chip] = HWMON_C_REGISTER_TZ,
> + [hwmon_temp] = HWMON_T_INPUT | HWMON_T_LABEL,
> + [hwmon_in] = HWMON_I_INPUT | HWMON_I_LABEL,
> + [hwmon_curr] = HWMON_C_INPUT | HWMON_C_LABEL,
> + [hwmon_fan] = HWMON_F_INPUT | HWMON_F_LABEL,
> +};
> +
> +struct asus_wmi_ec_sensor_address {
> + u8 index;
> + u8 bank;
> + u8 size;
> +};
> +
> +#define MAKE_SENSOR_ADDRESS(size_i, bank_i, index_i) \
> + { .size = size_i,\
> + .bank = bank_i,\
> + .index = index_i}
> +
> +struct ec_sensor_info {
> + char label[MAX_SENSOR_LABEL_LENGTH];
> + enum hwmon_sensor_types type;
> + struct asus_wmi_ec_sensor_address addr;
> +};
> +
> +#define EC_SENSOR(sensor_label, sensor_type, size, bank, index) \
> + { .label = sensor_label,\
> + .type = sensor_type, \
> + .addr = MAKE_SENSOR_ADDRESS(size, bank, index) \
> + }
> +
> +enum known_ec_sensor {
> + SENSOR_TEMP_CHIPSET,
> + SENSOR_TEMP_CPU,
> + SENSOR_TEMP_MB,
> + SENSOR_TEMP_T_SENSOR,
> + SENSOR_TEMP_VRM,
> + SENSOR_FAN_CPU_OPT,
> + SENSOR_FAN_CHIPSET,
> + SENSOR_FAN_WATER_FLOW,
> + SENSOR_CURR_CPU,
> + SENSOR_TEMP_WATER_IN,
> + SENSOR_TEMP_WATER_OUT,
> + SENSOR_MAX
> +};
> +
> +/*
> + * Array of the all known sensors for ASUS EC controllers
> + */
> +static const struct ec_sensor_info known_ec_sensors[] = {
> + [SENSOR_TEMP_CHIPSET] = EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a),
> + [SENSOR_TEMP_CPU] = EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b),
> + [SENSOR_TEMP_MB] = EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c),
> + [SENSOR_TEMP_T_SENSOR] = EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d),
> + [SENSOR_TEMP_VRM] = EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e),
> + [SENSOR_FAN_CPU_OPT] = EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0),
> + [SENSOR_FAN_CHIPSET] = EC_SENSOR("Chipset", hwmon_fan, 2, 0x00, 0xb4),
> + [SENSOR_FAN_WATER_FLOW] = EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc),
> + [SENSOR_CURR_CPU] = EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4),
> + [SENSOR_TEMP_WATER_IN] = EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00),
> + [SENSOR_TEMP_WATER_OUT] = EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01),
> +};
> +
> +static const enum known_ec_sensor known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> + [BOARD_PW_X570_A] = {
> + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> + SENSOR_FAN_CHIPSET,
> + SENSOR_MAX
> + },
> + [BOARD_R_C8H] = {
> + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
> + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> + SENSOR_TEMP_WATER_IN, SENSOR_TEMP_WATER_OUT,
> + SENSOR_FAN_CPU_OPT, SENSOR_FAN_CHIPSET, SENSOR_FAN_WATER_FLOW,
> + SENSOR_CURR_CPU,
> + SENSOR_MAX
> + },
> + [BOARD_R_C8DH] = { /* Same as Hero but without chipset fan */
> + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
> + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> + SENSOR_TEMP_WATER_IN, SENSOR_TEMP_WATER_OUT,
> + SENSOR_FAN_CPU_OPT, SENSOR_FAN_WATER_FLOW,
> + SENSOR_CURR_CPU,
> + SENSOR_MAX
> + },
> + [BOARD_R_C8F] = { /* Same as Hero but without water */
> + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
> + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> + SENSOR_FAN_CPU_OPT, SENSOR_FAN_CHIPSET,
> + SENSOR_CURR_CPU,
> + SENSOR_MAX
> + },
> + [BOARD_RS_B550_E_G] = {
> + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
> + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> + SENSOR_FAN_CPU_OPT,
> + SENSOR_CURR_CPU,
> + SENSOR_MAX
> + },
> + [BOARD_RS_X570_E_G] = {
> + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
> + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> + SENSOR_FAN_CHIPSET,
> + SENSOR_MAX
> + },
> +};
> +
> +struct ec_sensor {
> + enum known_ec_sensor info_index;
> + u32 cached_value;
> +};
> +
> +/**
> + * struct asus_wmi_ec_info - sensor info.
> + * @sensors: list of sensors.
> + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> + * @read_buffer: WMI function output.
> + * @nr_sensors: number of board EC sensors.
> + * @nr_registers: number of EC registers to read (sensor might span more than
> + * 1 register).
> + * @last_updated: in jiffies.
> + */
> +struct asus_wmi_ec_info {
> + struct ec_sensor sensors[SENSOR_MAX];
> + char read_arg[((ASUS_WMI_BLOCK_READ_REGISTERS_MAX * 4) + 1) * 2];
> + u8 read_buffer[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> + unsigned int nr_sensors;
> + unsigned int nr_registers;
> + unsigned long last_updated;
> +};
> +
> +struct asus_wmi_sensors {
> + /* lock access to instrnal cache */
> + struct mutex lock;
> + struct asus_wmi_ec_info ec;
> +
> + int ec_board;
> +};
> +
> +struct asus_wmi_data {
> + int ec_board;
> +};
> +
> +static void asus_wmi_ec_fill_board_sensors(struct asus_wmi_ec_info *ec, int board)
> +{
> + const enum known_ec_sensor *bsi = known_board_sensors[board];
> + struct ec_sensor *s = ec->sensors;
> + int i;
> +
> + ec->nr_sensors = 0;
> + ec->nr_registers = 0;
> +
> + for (i = 0; i < SENSOR_MAX && bsi[i] != SENSOR_MAX; i++) {
> + s[i].info_index = bsi[i];
> + s[i].cached_value = 0;
> + ec->nr_sensors++;
> + ec->nr_registers += known_ec_sensors[bsi[i]].addr.size;
> + }
> +}
> +
> +/*
> + * The next four functions converts to/from BRxx string argument format
> + * The format of the string is as follows:
> + * The string consists of two-byte UTF-16 characters
> + * The value of the very first byte int the string is equal to the total length
> + * of the next string in bytes, thus excluding the first two-byte character
> + * The rest of the string encodes pairs of (bank, index) pairs, where both
> + * values are byte-long (0x00 to 0xFF)
> + * Numbers are encoded as UTF-16 hex values
> + */
> +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> +{
> + unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] / 4);
> + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> + const char *pos = buffer;
> + const u8 *data = inp + 2;
> + unsigned int i;
> +
> + utf16s_to_utf8s((wchar_t *)data, len * 2, UTF16_LITTLE_ENDIAN, buffer, len * 2);
> +
> + for (i = 0; i < len; i++, pos += 2)
> + out[i] = (hex_to_bin(pos[0]) << 4) + hex_to_bin(pos[1]);
> +}
> +
> +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len, char *out)
> +{
> + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> + char *pos = buffer;
> + unsigned int i;
> + u8 byte;
> +
> + *out++ = len * 8;
> + *out++ = 0;
> +
> + for (i = 0; i < len; i++) {
> + byte = registers[i] >> 8;
> + *pos = hex_asc_hi(byte);
> + pos++;
> + *pos = hex_asc_lo(byte);
> + pos++;
> + byte = registers[i];
> + *pos = hex_asc_hi(byte);
> + pos++;
> + *pos = hex_asc_lo(byte);
> + pos++;
> + }
> +
> + utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN, (wchar_t *)out, len * 4);
> +}
> +
> +static void asus_wmi_ec_make_block_read_query(struct asus_wmi_ec_info *ec)
> +{
> + u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> + const struct ec_sensor_info *si;
> + long i, j, register_idx = 0;
> +
> + /*
> + * if we can get values for all the registers in a single query,
> + * the query will not change from call to call
> + */
> + if (ec->nr_registers <= ASUS_WMI_BLOCK_READ_REGISTERS_MAX &&
> + ec->read_arg[0] > 0) {
> + /* no need to update */
> + return;
> + }
> +
> + for (i = 0; i < ec->nr_sensors; i++) {
> + si = &known_ec_sensors[ec->sensors[i].info_index];
> + for (j = 0; j < si->addr.size;
> + j++, register_idx++) {
> + registers[register_idx] = (si->addr.bank << 8) + si->addr.index + j;
> + }
> + }
> +
> + asus_wmi_ec_encode_registers(registers, ec->nr_registers, ec->read_arg);
> +}
> +
> +static int asus_wmi_ec_block_read(u32 method_id, char *query, u8 *out)
> +{
> + struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER,
> + NULL };
> + struct acpi_buffer input;
> + union acpi_object *obj;
> + acpi_status status;
> +
> + /* the first byte of the BRxx() argument string has to be the string size */
> + input.length = (acpi_size)query[0] + 2;
> + input.pointer = query;
> + status = wmi_evaluate_method(ASUSWMI_MONITORING_GUID, 0, method_id, &input,
> + &output);
> + if (ACPI_FAILURE(status))
> + return -EIO;
> +
> + obj = output.pointer;
> + if (!obj || obj->type != ACPI_TYPE_BUFFER) {
> + if (!obj)
> + acpi_os_free(output.pointer);
> +
> + return -EIO;
> + }
> + asus_wmi_ec_decode_reply_buffer(obj->buffer.pointer, out);
> + acpi_os_free(output.pointer);
> + return 0;
> +}
> +
> +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info *ec)
> +{
> + const struct ec_sensor_info *si;
> + struct ec_sensor *s;
> +
> + u32 value;
> + int status;
> + u8 i_sensor, read_reg_ct;
> +
> + asus_wmi_ec_make_block_read_query(ec);
> + status = asus_wmi_ec_block_read(ASUSWMI_METHODID_BLOCK_READ_EC,
> + ec->read_arg,
> + ec->read_buffer);
> + if (status)
> + return status;
> +
> + read_reg_ct = 0;
> + for (i_sensor = 0; i_sensor < ec->nr_sensors; i_sensor++) {
> + s = &ec->sensors[i_sensor];
> + si = &known_ec_sensors[s->info_index];
> +
> + if (si->addr.size == 1)
> + value = ec->read_buffer[read_reg_ct];
> + else if (si->addr.size == 2)
> + value = get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> + else if (si->addr.size == 4)
> + value = get_unaligned_le32(&ec->read_buffer[read_reg_ct]);
> +
> + read_reg_ct += si->addr.size;
> + s->cached_value = value;
> + }
> + return 0;
> +}
> +
> +static int asus_wmi_ec_scale_sensor_value(u32 value, int data_type)
> +{
> + switch (data_type) {
> + case hwmon_curr:
> + case hwmon_temp:
> + case hwmon_in:
> + return value * KILO;
> + default:
> + return value;
> + }
> +}
> +
> +static int asus_wmi_ec_find_sensor_index(const struct asus_wmi_ec_info *ec,
> + enum hwmon_sensor_types type, int channel)
> +{
> + int i;
> +
> + for (i = 0; i < ec->nr_sensors; i++) {
> + if (known_ec_sensors[ec->sensors[i].info_index].type == type) {
> + if (channel == 0)
> + return i;
> +
> + channel--;
> + }
> + }
> + return -EINVAL;
> +}
> +
> +static int asus_wmi_ec_get_cached_value_or_update(int sensor_index,
> + struct asus_wmi_sensors *state,
> + u32 *value)
> +{
> + int ret;
> +
> + if (time_after(jiffies, state->ec.last_updated + HZ)) {
> + ret = asus_wmi_ec_update_ec_sensors(&state->ec);
> + if (ret)
> + return ret;
> +
> + state->ec.last_updated = jiffies;
> + }
> +
> + *value = state->ec.sensors[sensor_index].cached_value;
> + return 0;
> +}
> +
> +/*
> + * Now follow the functions that implement the hwmon interface
> + */
> +
> +static int asus_wmi_ec_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
> + u32 attr, int channel, long *val)
> +{
> + struct asus_wmi_sensors *sensor_data = dev_get_drvdata(dev);
> + int ret, sidx, info_index;
> + u32 value = 0;
> +
> + sidx = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> + if (sidx < 0)
> + return sidx;
> +
> + mutex_lock(&sensor_data->lock);
> + ret = asus_wmi_ec_get_cached_value_or_update(sidx, sensor_data, &value);
> + mutex_unlock(&sensor_data->lock);
> + if (ret)
> + return ret;
> +
> + info_index = sensor_data->ec.sensors[sidx].info_index;
> + *val = asus_wmi_ec_scale_sensor_value(value,
> + known_ec_sensors[info_index].type);
> +
> + return ret;
> +}
> +
> +static int asus_wmi_ec_hwmon_read_string(struct device *dev,
> + enum hwmon_sensor_types type, u32 attr,
> + int channel, const char **str)
> +{
> + struct asus_wmi_sensors *sensor_data = dev_get_drvdata(dev);
> + int sensor_index;
> +
> + sensor_index = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> + *str = known_ec_sensors[sensor_data->ec.sensors[sensor_index].info_index].label;
> +
> + return 0;
> +}
> +
> +static umode_t asus_wmi_ec_hwmon_is_visible(const void *drvdata,
> + enum hwmon_sensor_types type, u32 attr,
> + int channel)
> +{
> + int index;
> + const struct asus_wmi_sensors *sensor_data = drvdata;
> +
> + index = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> +
> + return index == 0xff ? 0 : 0444;
> +}
> +
> +static int asus_wmi_hwmon_add_chan_info(struct hwmon_channel_info *asus_wmi_hwmon_chan,
> + struct device *dev, int num,
> + enum hwmon_sensor_types type, u32 config)
> +{
> + u32 *cfg;
> +
> + cfg = devm_kcalloc(dev, num + 1, sizeof(*cfg), GFP_KERNEL);
> + if (!cfg)
> + return -ENOMEM;
> +
> + asus_wmi_hwmon_chan->type = type;
> + asus_wmi_hwmon_chan->config = cfg;
> + memset32(cfg, config, num);
> +
> + return 0;
> +}
> +
> +static const struct hwmon_ops asus_wmi_ec_hwmon_ops = {
> + .is_visible = asus_wmi_ec_hwmon_is_visible,
> + .read = asus_wmi_ec_hwmon_read,
> + .read_string = asus_wmi_ec_hwmon_read_string,
> +};
> +
> +static struct hwmon_chip_info asus_wmi_ec_chip_info = {
> + .ops = &asus_wmi_ec_hwmon_ops,
> +};
> +
> +static int asus_wmi_ec_configure_sensor_setup(struct platform_device *pdev,
> + struct asus_wmi_sensors *sensor_data)
> +{
> + struct hwmon_channel_info *asus_wmi_hwmon_chan;
> + const struct hwmon_channel_info **ptr_asus_wmi_ci;
> + int nr_count[hwmon_max] = { 0 }, nr_types = 0;
> + const struct hwmon_chip_info *chip_info;
> + struct device *dev = &pdev->dev;
> + const struct ec_sensor_info *si;
> + enum hwmon_sensor_types type;
> + struct device *hwdev;
> + int i;
> +
> + asus_wmi_ec_fill_board_sensors(&sensor_data->ec, sensor_data->ec_board);
> +
> + if (!sensor_data->ec.nr_sensors)
> + return -ENODEV;
> +
> + for (i = 0; i < sensor_data->ec.nr_sensors; i++) {
> + si = &known_ec_sensors[sensor_data->ec.sensors[i].info_index];
> + if (!nr_count[si->type])
> + nr_types++;
> + nr_count[si->type]++;
> + }
> +
> + if (nr_count[hwmon_temp]) {
> + nr_count[hwmon_chip]++;
> + nr_types++;
> + }
> +
> + asus_wmi_hwmon_chan = devm_kcalloc(dev, nr_types,
> + sizeof(*asus_wmi_hwmon_chan),
> + GFP_KERNEL);
> + if (!asus_wmi_hwmon_chan)
> + return -ENOMEM;
> +
> + ptr_asus_wmi_ci = devm_kcalloc(dev, nr_types + 1,
> + sizeof(*ptr_asus_wmi_ci), GFP_KERNEL);
> + if (!ptr_asus_wmi_ci)
> + return -ENOMEM;
> +
> + asus_wmi_ec_chip_info.info = ptr_asus_wmi_ci;
> + chip_info = &asus_wmi_ec_chip_info;
> +
> + for (type = 0; type < hwmon_max; type++) {
> + if (!nr_count[type])
> + continue;
> +
> + asus_wmi_hwmon_add_chan_info(asus_wmi_hwmon_chan, dev,
> + nr_count[type], type,
> + hwmon_attributes[type]);
> + *ptr_asus_wmi_ci++ = asus_wmi_hwmon_chan++;
> + }
> +
> + dev_dbg(&pdev->dev, "%s board has %d EC sensors that span %d registers",
> + asus_wmi_ec_boards_names[sensor_data->ec_board],
> + sensor_data->ec.nr_sensors,
> + sensor_data->ec.nr_registers);
> +
> + hwdev = devm_hwmon_device_register_with_info(dev, KBUILD_MODNAME,
> + sensor_data, chip_info, NULL);
> +
> + return PTR_ERR_OR_ZERO(hwdev);
> +}
> +
> +static int asus_wmi_probe(struct platform_device *pdev)
> +{
> + struct asus_wmi_sensors *sensor_data;
> + struct device *dev = &pdev->dev;
> + struct asus_wmi_data *data;
> +
> + data = dev_get_platdata(dev);
> +
> + sensor_data = devm_kzalloc(dev, sizeof(struct asus_wmi_sensors),
> + GFP_KERNEL);
> + if (!sensor_data)
> + return -ENOMEM;
> +
> + mutex_init(&sensor_data->lock);
> + sensor_data->ec_board = data->ec_board;
> +
> + platform_set_drvdata(pdev, sensor_data);
> +
> + /* ec init */
> + return asus_wmi_ec_configure_sensor_setup(pdev,
> + sensor_data);
> +}
> +
> +static struct platform_driver asus_wmi_sensors_platform_driver = {
> + .driver = {
> + .name = "asus-wmi-sensors",
> + },
> + .probe = asus_wmi_probe,
> +};
> +
> +static struct platform_device *sensors_pdev;
> +
> +static int __init asus_wmi_init(void)
> +{
> + const char *board_vendor, *board_name;
> + struct asus_wmi_data data;
> +
> + data.ec_board = -1;
> +
> + board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
> + board_name = dmi_get_system_info(DMI_BOARD_NAME);
> +
> + if (board_vendor && board_name &&
> + !strcmp(board_vendor, "ASUSTeK COMPUTER INC.")) {
> + if (!wmi_has_guid(ASUSWMI_MONITORING_GUID))
> + return -ENODEV;
> +
> + data.ec_board = match_string(asus_wmi_ec_boards_names,
> + ARRAY_SIZE(asus_wmi_ec_boards_names),
> + board_name);
> + }
> +
> + /* Nothing to support */
> + if (data.ec_board < 0)
> + return -ENODEV;
> +
> + sensors_pdev = platform_create_bundle(&asus_wmi_sensors_platform_driver,
> + asus_wmi_probe,
> + NULL, 0,
> + &data, sizeof(struct asus_wmi_data));
> +
> + return PTR_ERR_OR_ZERO(sensors_pdev);
> +}
> +module_init(asus_wmi_init);
> +
> +static void __exit asus_wmi_exit(void)
> +{
> + platform_device_unregister(sensors_pdev);
> + platform_driver_unregister(&asus_wmi_sensors_platform_driver);
> +}
> +module_exit(asus_wmi_exit);
> +
> +MODULE_AUTHOR("Ed Brindley <kernel@maidavale.org>");
> +MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
> +MODULE_DESCRIPTION("Asus WMI Sensors Driver");
> +MODULE_LICENSE("GPL");
>
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-07 16:41 ` Guenter Roeck
@ 2021-10-07 17:17 ` Denis Pauk
0 siblings, 0 replies; 23+ messages in thread
From: Denis Pauk @ 2021-10-07 17:17 UTC (permalink / raw)
To: Guenter Roeck
Cc: andy.shevchenko, Eugene Shalygin, Jean Delvare, linux-kernel,
linux-hwmon
On Thu, 7 Oct 2021 09:41:30 -0700
Guenter Roeck <linux@roeck-us.net> wrote:
> On 10/6/21 3:25 PM, Denis Pauk wrote:
> > Linux HWMON sensors driver for ASUS motherboards to read
> > sensors from the embedded controller.
> >
> > Many ASUS motherboards do not publish all the available
> > sensors via the Super I/O chip but the missing ones are
> > available through the embedded controller (EC) registers.
> >
> > This driver implements reading those sensor data via the
> > WMI method BREC, which is known to be present in all ASUS
> > motherboards based on the AMD 500 series chipsets (and
> > probably is available in other models too). The driver
> > needs to know exact register addresses for the sensors and
> > thus support for each motherboard has to be added explicitly.
> >
> > The EC registers do not provide critical values for the
> > sensors and as such they are not published to the HWMON.
> >
> > Supported motherboards:
> > * ROG CROSSHAIR VIII HERO
> > * ROG CROSSHAIR VIII DARK HERO
> > * ROG CROSSHAIR VIII FORMULA
> > * ROG STRIX X570-E GAMING
> > * ROG STRIX B550-E GAMING
> >
> > BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
> > Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
> > Co-developed-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> > Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> >
> > ---
> > Changes in v2:
> > - Use utf8s_to_utf16s/utf16s_to_utf8s instead handmade fuctions.
> > - Use post increment.
> > - Use get_unaligned* for convert values.
> > - Use PTR_ERR_OR_ZERO.
> > - Specify per-board sensors in a declarative way (by Eugene
> > Shalygin). ---
> > MAINTAINERS | 7 +
> > drivers/hwmon/Kconfig | 13 +-
> > drivers/hwmon/Makefile | 1 +
> > drivers/hwmon/asus_wmi_ec_sensors.c | 631
> > ++++++++++++++++++++++++++++ 4 files changed, 651 insertions(+), 1
> > deletion(-) create mode 100644 drivers/hwmon/asus_wmi_ec_sensors.c
> >
> > diff --git a/MAINTAINERS b/MAINTAINERS
> > index bae3f62f548f..bc2e981a54e2 100644
> > --- a/MAINTAINERS
> > +++ b/MAINTAINERS
> > @@ -2937,6 +2937,13 @@ W: http://acpi4asus.sf.net
> > F: drivers/platform/x86/asus*.c
> > F: drivers/platform/x86/eeepc*.c
> >
> > +ASUS WMI HARDWARE MONITOR DRIVER
> > +M: Eugene Shalygin <eugene.shalygin@gmail.com>
> > +M: Denis Pauk <pauk.denis@gmail.com>
> > +L: linux-hwmon@vger.kernel.org
> > +S: Maintained
> > +F: drivers/hwmon/asus_wmi_ec_sensors.c
> > +
> > ASUS WIRELESS RADIO CONTROL DRIVER
> > M: João Paulo Rechi Vita <jprvita@gmail.com>
> > L: platform-driver-x86@vger.kernel.org
> > diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> > index 7fde4c6e1e7f..b7107721a401 100644
> > --- a/drivers/hwmon/Kconfig
> > +++ b/drivers/hwmon/Kconfig
> > @@ -1840,7 +1840,7 @@ config SENSORS_ADS7871
> >
> > config SENSORS_AMC6821
> > tristate "Texas Instruments AMC6821"
> > - depends on I2C
> > + depends on I2C
>
> Completely unrelated and unacceptable change.
>
Yes, I will remove it.
Thank you.
> > help
> > If you say yes here you get support for the Texas
> > Instruments AMC6821 hardware monitoring chips.
> > @@ -2215,6 +2215,17 @@ config SENSORS_ATK0110
> > This driver can also be built as a module. If so, the
> > module will be called asus_atk0110.
> >
> > +config SENSORS_ASUS_WMI_EC
> > + tristate "ASUS WMI B550/X570"
> > + help
> > + If you say yes here you get support for the ACPI
> > embedded controller
> > + hardware monitoring interface found in B550/X570 ASUS
> > motherboards.
> > + This driver will provide readings of fans, voltages and
> > temperatures
> > + through the system firmware.
> > +
> > + This driver can also be built as a module. If so, the
> > module
> > + will be called asus_wmi_sensors_ec.
> > +
> > endif # ACPI
> >
> > endif # HWMON
> > diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> > index baee6a8d4dd1..aae2ff5c7335 100644
> > --- a/drivers/hwmon/Makefile
> > +++ b/drivers/hwmon/Makefile
> > @@ -9,6 +9,7 @@ obj-$(CONFIG_HWMON_VID) +=
> > hwmon-vid.o # APCI drivers
> > obj-$(CONFIG_SENSORS_ACPI_POWER) += acpi_power_meter.o
> > obj-$(CONFIG_SENSORS_ATK0110) += asus_atk0110.o
> > +obj-$(CONFIG_SENSORS_ASUS_WMI_EC) += asus_wmi_ec_sensors.o
> >
> > # Native drivers
> > # asb100, then w83781d go first, as they can override other
> > drivers' addresses. diff --git
> > a/drivers/hwmon/asus_wmi_ec_sensors.c
> > b/drivers/hwmon/asus_wmi_ec_sensors.c new file mode 100644 index
> > 000000000000..553d9ee8656d --- /dev/null
> > +++ b/drivers/hwmon/asus_wmi_ec_sensors.c
> > @@ -0,0 +1,631 @@
> > +// SPDX-License-Identifier: GPL-2.0+
> > +/*
> > + * HWMON driver for ASUS B550/X570 motherboards that publish sensor
> > + * values via the embedded controller registers.
> > + *
> > + * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com>
> > + * Copyright (C) 2018-2019 Ed Brindley <kernel@maidavale.org>
> > + *
> > + * EC provided:
> > + * Chipset temperature,
> > + * CPU temperature,
> > + * Motherboard temperature,
> > + * T_Sensor temperature,
> > + * VRM temperature,
> > + * Water In temperature,
> > + * Water Out temperature,
> > + * CPU Optional Fan,
> > + * Chipset fan,
> > + * Water Flow fan,
> > + * CPU current.
> > + *
> > + */
> > +#include <asm/unaligned.h>
> > +#include <linux/acpi.h>
> > +#include <linux/dmi.h>
> > +#include <linux/hwmon.h>
> > +#include <linux/hwmon-sysfs.h>
> > +#include <linux/init.h>
> > +#include <linux/jiffies.h>
> > +#include <linux/kernel.h>
> > +#include <linux/module.h>
> > +#include <linux/mutex.h>
> > +#include <linux/nls.h>
> > +#include <linux/platform_device.h>
> > +#include <linux/units.h>
> > +#include <linux/wmi.h>
> > +
> > +#define ASUSWMI_MONITORING_GUID
> > "466747A0-70EC-11DE-8A39-0800200C9A66" +#define
> > ASUSWMI_METHODID_BLOCK_READ_EC 0x42524543 /* BREC */
> > + +#define ASUS_WMI_BLOCK_READ_REGISTERS_MAX 0x10 /* from the ASUS
> > DSDT source */ +/* from the ASUS_WMI_BLOCK_READ_REGISTERS_MAX value
> > */ +#define ASUS_WMI_MAX_BUF_LEN 0x80
> > +#define MAX_SENSOR_LABEL_LENGTH 0x10
> > +
> > +enum asus_wmi_ec_board {
> > + BOARD_PW_X570_A, /* Pro WS X570-ACE */
> > + BOARD_R_C8H, /* ROG Crosshair VIII Hero */
> > + BOARD_R_C8DH, /* ROG Crosshair VIII Dark Hero */
> > + BOARD_R_C8F, /* ROG Crosshair VIII Formula */
> > + BOARD_RS_B550_E_G, /* ROG STRIX B550-E GAMING */
> > + BOARD_RS_X570_E_G, /* ROG STRIX X570-E GAMING */
> > + BOARD_MAX
> > +};
> > +
> > +/* boards with EC support */
> > +static const char *const asus_wmi_ec_boards_names[] = {
> > + [BOARD_PW_X570_A] = "Pro WS X570-ACE",
> > + [BOARD_R_C8H] = "ROG CROSSHAIR VIII HERO",
> > + [BOARD_R_C8DH] = "ROG CROSSHAIR VIII DARK HERO",
> > + [BOARD_R_C8F] = "ROG CROSSHAIR VIII FORMULA",
> > + [BOARD_RS_B550_E_G] = "ROG STRIX B550-E GAMING",
> > + [BOARD_RS_X570_E_G] = "ROG STRIX X570-E GAMING",
> > +};
> > +
> > +static u32 hwmon_attributes[] = {
> > + [hwmon_chip] = HWMON_C_REGISTER_TZ,
> > + [hwmon_temp] = HWMON_T_INPUT | HWMON_T_LABEL,
> > + [hwmon_in] = HWMON_I_INPUT | HWMON_I_LABEL,
> > + [hwmon_curr] = HWMON_C_INPUT | HWMON_C_LABEL,
> > + [hwmon_fan] = HWMON_F_INPUT | HWMON_F_LABEL,
> > +};
> > +
> > +struct asus_wmi_ec_sensor_address {
> > + u8 index;
> > + u8 bank;
> > + u8 size;
> > +};
> > +
> > +#define MAKE_SENSOR_ADDRESS(size_i, bank_i, index_i) \
> > + { .size = size_i,\
> > + .bank = bank_i,\
> > + .index = index_i}
> > +
> > +struct ec_sensor_info {
> > + char label[MAX_SENSOR_LABEL_LENGTH];
> > + enum hwmon_sensor_types type;
> > + struct asus_wmi_ec_sensor_address addr;
> > +};
> > +
> > +#define EC_SENSOR(sensor_label, sensor_type, size, bank, index) \
> > + { .label = sensor_label,\
> > + .type = sensor_type, \
> > + .addr = MAKE_SENSOR_ADDRESS(size, bank, index) \
> > + }
> > +
> > +enum known_ec_sensor {
> > + SENSOR_TEMP_CHIPSET,
> > + SENSOR_TEMP_CPU,
> > + SENSOR_TEMP_MB,
> > + SENSOR_TEMP_T_SENSOR,
> > + SENSOR_TEMP_VRM,
> > + SENSOR_FAN_CPU_OPT,
> > + SENSOR_FAN_CHIPSET,
> > + SENSOR_FAN_WATER_FLOW,
> > + SENSOR_CURR_CPU,
> > + SENSOR_TEMP_WATER_IN,
> > + SENSOR_TEMP_WATER_OUT,
> > + SENSOR_MAX
> > +};
> > +
> > +/*
> > + * Array of the all known sensors for ASUS EC controllers
> > + */
> > +static const struct ec_sensor_info known_ec_sensors[] = {
> > + [SENSOR_TEMP_CHIPSET] = EC_SENSOR("Chipset", hwmon_temp,
> > 1, 0x00, 0x3a),
> > + [SENSOR_TEMP_CPU] = EC_SENSOR("CPU", hwmon_temp, 1, 0x00,
> > 0x3b),
> > + [SENSOR_TEMP_MB] = EC_SENSOR("Motherboard", hwmon_temp, 1,
> > 0x00, 0x3c),
> > + [SENSOR_TEMP_T_SENSOR] = EC_SENSOR("T_Sensor", hwmon_temp,
> > 1, 0x00, 0x3d),
> > + [SENSOR_TEMP_VRM] = EC_SENSOR("VRM", hwmon_temp, 1, 0x00,
> > 0x3e),
> > + [SENSOR_FAN_CPU_OPT] = EC_SENSOR("CPU_Opt", hwmon_fan, 2,
> > 0x00, 0xb0),
> > + [SENSOR_FAN_CHIPSET] = EC_SENSOR("Chipset", hwmon_fan, 2,
> > 0x00, 0xb4),
> > + [SENSOR_FAN_WATER_FLOW] = EC_SENSOR("Water_Flow",
> > hwmon_fan, 2, 0x00, 0xbc),
> > + [SENSOR_CURR_CPU] = EC_SENSOR("CPU", hwmon_curr, 1, 0x00,
> > 0xf4),
> > + [SENSOR_TEMP_WATER_IN] = EC_SENSOR("Water_In", hwmon_temp,
> > 1, 0x01, 0x00),
> > + [SENSOR_TEMP_WATER_OUT] = EC_SENSOR("Water_Out",
> > hwmon_temp, 1, 0x01, 0x01), +};
> > +
> > +static const enum known_ec_sensor
> > known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> > + [BOARD_PW_X570_A] = {
> > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> > + SENSOR_FAN_CHIPSET,
> > + SENSOR_MAX
> > + },
> > + [BOARD_R_C8H] = {
> > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB,
> > + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> > + SENSOR_TEMP_WATER_IN, SENSOR_TEMP_WATER_OUT,
> > + SENSOR_FAN_CPU_OPT, SENSOR_FAN_CHIPSET,
> > SENSOR_FAN_WATER_FLOW,
> > + SENSOR_CURR_CPU,
> > + SENSOR_MAX
> > + },
> > + [BOARD_R_C8DH] = { /* Same as Hero but without chipset fan
> > */
> > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB,
> > + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> > + SENSOR_TEMP_WATER_IN, SENSOR_TEMP_WATER_OUT,
> > + SENSOR_FAN_CPU_OPT, SENSOR_FAN_WATER_FLOW,
> > + SENSOR_CURR_CPU,
> > + SENSOR_MAX
> > + },
> > + [BOARD_R_C8F] = { /* Same as Hero but without water */
> > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB,
> > + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> > + SENSOR_FAN_CPU_OPT, SENSOR_FAN_CHIPSET,
> > + SENSOR_CURR_CPU,
> > + SENSOR_MAX
> > + },
> > + [BOARD_RS_B550_E_G] = {
> > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB,
> > + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> > + SENSOR_FAN_CPU_OPT,
> > + SENSOR_CURR_CPU,
> > + SENSOR_MAX
> > + },
> > + [BOARD_RS_X570_E_G] = {
> > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB,
> > + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> > + SENSOR_FAN_CHIPSET,
> > + SENSOR_MAX
> > + },
> > +};
> > +
> > +struct ec_sensor {
> > + enum known_ec_sensor info_index;
> > + u32 cached_value;
> > +};
> > +
> > +/**
> > + * struct asus_wmi_ec_info - sensor info.
> > + * @sensors: list of sensors.
> > + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> > + * @read_buffer: WMI function output.
> > + * @nr_sensors: number of board EC sensors.
> > + * @nr_registers: number of EC registers to read (sensor might
> > span more than
> > + * 1 register).
> > + * @last_updated: in jiffies.
> > + */
> > +struct asus_wmi_ec_info {
> > + struct ec_sensor sensors[SENSOR_MAX];
> > + char read_arg[((ASUS_WMI_BLOCK_READ_REGISTERS_MAX * 4) +
> > 1) * 2];
> > + u8 read_buffer[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > + unsigned int nr_sensors;
> > + unsigned int nr_registers;
> > + unsigned long last_updated;
> > +};
> > +
> > +struct asus_wmi_sensors {
> > + /* lock access to instrnal cache */
> > + struct mutex lock;
> > + struct asus_wmi_ec_info ec;
> > +
> > + int ec_board;
> > +};
> > +
> > +struct asus_wmi_data {
> > + int ec_board;
> > +};
> > +
> > +static void asus_wmi_ec_fill_board_sensors(struct asus_wmi_ec_info
> > *ec, int board) +{
> > + const enum known_ec_sensor *bsi =
> > known_board_sensors[board];
> > + struct ec_sensor *s = ec->sensors;
> > + int i;
> > +
> > + ec->nr_sensors = 0;
> > + ec->nr_registers = 0;
> > +
> > + for (i = 0; i < SENSOR_MAX && bsi[i] != SENSOR_MAX; i++) {
> > + s[i].info_index = bsi[i];
> > + s[i].cached_value = 0;
> > + ec->nr_sensors++;
> > + ec->nr_registers +=
> > known_ec_sensors[bsi[i]].addr.size;
> > + }
> > +}
> > +
> > +/*
> > + * The next four functions converts to/from BRxx string argument
> > format
> > + * The format of the string is as follows:
> > + * The string consists of two-byte UTF-16 characters
> > + * The value of the very first byte int the string is equal to the
> > total length
> > + * of the next string in bytes, thus excluding the first two-byte
> > character
> > + * The rest of the string encodes pairs of (bank, index) pairs,
> > where both
> > + * values are byte-long (0x00 to 0xFF)
> > + * Numbers are encoded as UTF-16 hex values
> > + */
> > +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> > +{
> > + unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] /
> > 4);
> > + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > + const char *pos = buffer;
> > + const u8 *data = inp + 2;
> > + unsigned int i;
> > +
> > + utf16s_to_utf8s((wchar_t *)data, len * 2,
> > UTF16_LITTLE_ENDIAN, buffer, len * 2); +
> > + for (i = 0; i < len; i++, pos += 2)
> > + out[i] = (hex_to_bin(pos[0]) << 4) +
> > hex_to_bin(pos[1]); +}
> > +
> > +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len,
> > char *out) +{
> > + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > + char *pos = buffer;
> > + unsigned int i;
> > + u8 byte;
> > +
> > + *out++ = len * 8;
> > + *out++ = 0;
> > +
> > + for (i = 0; i < len; i++) {
> > + byte = registers[i] >> 8;
> > + *pos = hex_asc_hi(byte);
> > + pos++;
> > + *pos = hex_asc_lo(byte);
> > + pos++;
> > + byte = registers[i];
> > + *pos = hex_asc_hi(byte);
> > + pos++;
> > + *pos = hex_asc_lo(byte);
> > + pos++;
> > + }
> > +
> > + utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN,
> > (wchar_t *)out, len * 4); +}
> > +
> > +static void asus_wmi_ec_make_block_read_query(struct
> > asus_wmi_ec_info *ec) +{
> > + u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > + const struct ec_sensor_info *si;
> > + long i, j, register_idx = 0;
> > +
> > + /*
> > + * if we can get values for all the registers in a single
> > query,
> > + * the query will not change from call to call
> > + */
> > + if (ec->nr_registers <= ASUS_WMI_BLOCK_READ_REGISTERS_MAX
> > &&
> > + ec->read_arg[0] > 0) {
> > + /* no need to update */
> > + return;
> > + }
> > +
> > + for (i = 0; i < ec->nr_sensors; i++) {
> > + si = &known_ec_sensors[ec->sensors[i].info_index];
> > + for (j = 0; j < si->addr.size;
> > + j++, register_idx++) {
> > + registers[register_idx] = (si->addr.bank
> > << 8) + si->addr.index + j;
> > + }
> > + }
> > +
> > + asus_wmi_ec_encode_registers(registers, ec->nr_registers,
> > ec->read_arg); +}
> > +
> > +static int asus_wmi_ec_block_read(u32 method_id, char *query, u8
> > *out) +{
> > + struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER,
> > + NULL };
> > + struct acpi_buffer input;
> > + union acpi_object *obj;
> > + acpi_status status;
> > +
> > + /* the first byte of the BRxx() argument string has to be
> > the string size */
> > + input.length = (acpi_size)query[0] + 2;
> > + input.pointer = query;
> > + status = wmi_evaluate_method(ASUSWMI_MONITORING_GUID, 0,
> > method_id, &input,
> > + &output);
> > + if (ACPI_FAILURE(status))
> > + return -EIO;
> > +
> > + obj = output.pointer;
> > + if (!obj || obj->type != ACPI_TYPE_BUFFER) {
> > + if (!obj)
> > + acpi_os_free(output.pointer);
> > +
> > + return -EIO;
> > + }
> > + asus_wmi_ec_decode_reply_buffer(obj->buffer.pointer, out);
> > + acpi_os_free(output.pointer);
> > + return 0;
> > +}
> > +
> > +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info
> > *ec) +{
> > + const struct ec_sensor_info *si;
> > + struct ec_sensor *s;
> > +
> > + u32 value;
> > + int status;
> > + u8 i_sensor, read_reg_ct;
> > +
> > + asus_wmi_ec_make_block_read_query(ec);
> > + status =
> > asus_wmi_ec_block_read(ASUSWMI_METHODID_BLOCK_READ_EC,
> > + ec->read_arg,
> > + ec->read_buffer);
> > + if (status)
> > + return status;
> > +
> > + read_reg_ct = 0;
> > + for (i_sensor = 0; i_sensor < ec->nr_sensors; i_sensor++) {
> > + s = &ec->sensors[i_sensor];
> > + si = &known_ec_sensors[s->info_index];
> > +
> > + if (si->addr.size == 1)
> > + value = ec->read_buffer[read_reg_ct];
> > + else if (si->addr.size == 2)
> > + value =
> > get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> > + else if (si->addr.size == 4)
> > + value =
> > get_unaligned_le32(&ec->read_buffer[read_reg_ct]); +
> > + read_reg_ct += si->addr.size;
> > + s->cached_value = value;
> > + }
> > + return 0;
> > +}
> > +
> > +static int asus_wmi_ec_scale_sensor_value(u32 value, int data_type)
> > +{
> > + switch (data_type) {
> > + case hwmon_curr:
> > + case hwmon_temp:
> > + case hwmon_in:
> > + return value * KILO;
> > + default:
> > + return value;
> > + }
> > +}
> > +
> > +static int asus_wmi_ec_find_sensor_index(const struct
> > asus_wmi_ec_info *ec,
> > + enum hwmon_sensor_types
> > type, int channel) +{
> > + int i;
> > +
> > + for (i = 0; i < ec->nr_sensors; i++) {
> > + if
> > (known_ec_sensors[ec->sensors[i].info_index].type == type) {
> > + if (channel == 0)
> > + return i;
> > +
> > + channel--;
> > + }
> > + }
> > + return -EINVAL;
> > +}
> > +
> > +static int asus_wmi_ec_get_cached_value_or_update(int sensor_index,
> > + struct
> > asus_wmi_sensors *state,
> > + u32 *value)
> > +{
> > + int ret;
> > +
> > + if (time_after(jiffies, state->ec.last_updated + HZ)) {
> > + ret = asus_wmi_ec_update_ec_sensors(&state->ec);
> > + if (ret)
> > + return ret;
> > +
> > + state->ec.last_updated = jiffies;
> > + }
> > +
> > + *value = state->ec.sensors[sensor_index].cached_value;
> > + return 0;
> > +}
> > +
> > +/*
> > + * Now follow the functions that implement the hwmon interface
> > + */
> > +
> > +static int asus_wmi_ec_hwmon_read(struct device *dev, enum
> > hwmon_sensor_types type,
> > + u32 attr, int channel, long *val)
> > +{
> > + struct asus_wmi_sensors *sensor_data =
> > dev_get_drvdata(dev);
> > + int ret, sidx, info_index;
> > + u32 value = 0;
> > +
> > + sidx = asus_wmi_ec_find_sensor_index(&sensor_data->ec,
> > type, channel);
> > + if (sidx < 0)
> > + return sidx;
> > +
> > + mutex_lock(&sensor_data->lock);
> > + ret = asus_wmi_ec_get_cached_value_or_update(sidx,
> > sensor_data, &value);
> > + mutex_unlock(&sensor_data->lock);
> > + if (ret)
> > + return ret;
> > +
> > + info_index = sensor_data->ec.sensors[sidx].info_index;
> > + *val = asus_wmi_ec_scale_sensor_value(value,
> > +
> > known_ec_sensors[info_index].type); +
> > + return ret;
> > +}
> > +
> > +static int asus_wmi_ec_hwmon_read_string(struct device *dev,
> > + enum hwmon_sensor_types
> > type, u32 attr,
> > + int channel, const char
> > **str) +{
> > + struct asus_wmi_sensors *sensor_data =
> > dev_get_drvdata(dev);
> > + int sensor_index;
> > +
> > + sensor_index =
> > asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> > + *str =
> > known_ec_sensors[sensor_data->ec.sensors[sensor_index].info_index].label;
> > +
> > + return 0;
> > +}
> > +
> > +static umode_t asus_wmi_ec_hwmon_is_visible(const void *drvdata,
> > + enum
> > hwmon_sensor_types type, u32 attr,
> > + int channel)
> > +{
> > + int index;
> > + const struct asus_wmi_sensors *sensor_data = drvdata;
> > +
> > + index = asus_wmi_ec_find_sensor_index(&sensor_data->ec,
> > type, channel); +
> > + return index == 0xff ? 0 : 0444;
> > +}
> > +
> > +static int asus_wmi_hwmon_add_chan_info(struct hwmon_channel_info
> > *asus_wmi_hwmon_chan,
> > + struct device *dev, int
> > num,
> > + enum hwmon_sensor_types
> > type, u32 config) +{
> > + u32 *cfg;
> > +
> > + cfg = devm_kcalloc(dev, num + 1, sizeof(*cfg), GFP_KERNEL);
> > + if (!cfg)
> > + return -ENOMEM;
> > +
> > + asus_wmi_hwmon_chan->type = type;
> > + asus_wmi_hwmon_chan->config = cfg;
> > + memset32(cfg, config, num);
> > +
> > + return 0;
> > +}
> > +
> > +static const struct hwmon_ops asus_wmi_ec_hwmon_ops = {
> > + .is_visible = asus_wmi_ec_hwmon_is_visible,
> > + .read = asus_wmi_ec_hwmon_read,
> > + .read_string = asus_wmi_ec_hwmon_read_string,
> > +};
> > +
> > +static struct hwmon_chip_info asus_wmi_ec_chip_info = {
> > + .ops = &asus_wmi_ec_hwmon_ops,
> > +};
> > +
> > +static int asus_wmi_ec_configure_sensor_setup(struct
> > platform_device *pdev,
> > + struct
> > asus_wmi_sensors *sensor_data) +{
> > + struct hwmon_channel_info *asus_wmi_hwmon_chan;
> > + const struct hwmon_channel_info **ptr_asus_wmi_ci;
> > + int nr_count[hwmon_max] = { 0 }, nr_types = 0;
> > + const struct hwmon_chip_info *chip_info;
> > + struct device *dev = &pdev->dev;
> > + const struct ec_sensor_info *si;
> > + enum hwmon_sensor_types type;
> > + struct device *hwdev;
> > + int i;
> > +
> > + asus_wmi_ec_fill_board_sensors(&sensor_data->ec,
> > sensor_data->ec_board); +
> > + if (!sensor_data->ec.nr_sensors)
> > + return -ENODEV;
> > +
> > + for (i = 0; i < sensor_data->ec.nr_sensors; i++) {
> > + si =
> > &known_ec_sensors[sensor_data->ec.sensors[i].info_index];
> > + if (!nr_count[si->type])
> > + nr_types++;
> > + nr_count[si->type]++;
> > + }
> > +
> > + if (nr_count[hwmon_temp]) {
> > + nr_count[hwmon_chip]++;
> > + nr_types++;
> > + }
> > +
> > + asus_wmi_hwmon_chan = devm_kcalloc(dev, nr_types,
> > +
> > sizeof(*asus_wmi_hwmon_chan),
> > + GFP_KERNEL);
> > + if (!asus_wmi_hwmon_chan)
> > + return -ENOMEM;
> > +
> > + ptr_asus_wmi_ci = devm_kcalloc(dev, nr_types + 1,
> > + sizeof(*ptr_asus_wmi_ci),
> > GFP_KERNEL);
> > + if (!ptr_asus_wmi_ci)
> > + return -ENOMEM;
> > +
> > + asus_wmi_ec_chip_info.info = ptr_asus_wmi_ci;
> > + chip_info = &asus_wmi_ec_chip_info;
> > +
> > + for (type = 0; type < hwmon_max; type++) {
> > + if (!nr_count[type])
> > + continue;
> > +
> > + asus_wmi_hwmon_add_chan_info(asus_wmi_hwmon_chan,
> > dev,
> > + nr_count[type], type,
> > +
> > hwmon_attributes[type]);
> > + *ptr_asus_wmi_ci++ = asus_wmi_hwmon_chan++;
> > + }
> > +
> > + dev_dbg(&pdev->dev, "%s board has %d EC sensors that span
> > %d registers",
> > + asus_wmi_ec_boards_names[sensor_data->ec_board],
> > + sensor_data->ec.nr_sensors,
> > + sensor_data->ec.nr_registers);
> > +
> > + hwdev = devm_hwmon_device_register_with_info(dev,
> > KBUILD_MODNAME,
> > + sensor_data,
> > chip_info, NULL); +
> > + return PTR_ERR_OR_ZERO(hwdev);
> > +}
> > +
> > +static int asus_wmi_probe(struct platform_device *pdev)
> > +{
> > + struct asus_wmi_sensors *sensor_data;
> > + struct device *dev = &pdev->dev;
> > + struct asus_wmi_data *data;
> > +
> > + data = dev_get_platdata(dev);
> > +
> > + sensor_data = devm_kzalloc(dev, sizeof(struct
> > asus_wmi_sensors),
> > + GFP_KERNEL);
> > + if (!sensor_data)
> > + return -ENOMEM;
> > +
> > + mutex_init(&sensor_data->lock);
> > + sensor_data->ec_board = data->ec_board;
> > +
> > + platform_set_drvdata(pdev, sensor_data);
> > +
> > + /* ec init */
> > + return asus_wmi_ec_configure_sensor_setup(pdev,
> > + sensor_data);
> > +}
> > +
> > +static struct platform_driver asus_wmi_sensors_platform_driver = {
> > + .driver = {
> > + .name = "asus-wmi-sensors",
> > + },
> > + .probe = asus_wmi_probe,
> > +};
> > +
> > +static struct platform_device *sensors_pdev;
> > +
> > +static int __init asus_wmi_init(void)
> > +{
> > + const char *board_vendor, *board_name;
> > + struct asus_wmi_data data;
> > +
> > + data.ec_board = -1;
> > +
> > + board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
> > + board_name = dmi_get_system_info(DMI_BOARD_NAME);
> > +
> > + if (board_vendor && board_name &&
> > + !strcmp(board_vendor, "ASUSTeK COMPUTER INC.")) {
> > + if (!wmi_has_guid(ASUSWMI_MONITORING_GUID))
> > + return -ENODEV;
> > +
> > + data.ec_board =
> > match_string(asus_wmi_ec_boards_names,
> > +
> > ARRAY_SIZE(asus_wmi_ec_boards_names),
> > + board_name);
> > + }
> > +
> > + /* Nothing to support */
> > + if (data.ec_board < 0)
> > + return -ENODEV;
> > +
> > + sensors_pdev =
> > platform_create_bundle(&asus_wmi_sensors_platform_driver,
> > + asus_wmi_probe,
> > + NULL, 0,
> > + &data, sizeof(struct
> > asus_wmi_data)); +
> > + return PTR_ERR_OR_ZERO(sensors_pdev);
> > +}
> > +module_init(asus_wmi_init);
> > +
> > +static void __exit asus_wmi_exit(void)
> > +{
> > + platform_device_unregister(sensors_pdev);
> > +
> > platform_driver_unregister(&asus_wmi_sensors_platform_driver); +}
> > +module_exit(asus_wmi_exit);
> > +
> > +MODULE_AUTHOR("Ed Brindley <kernel@maidavale.org>");
> > +MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
> > +MODULE_DESCRIPTION("Asus WMI Sensors Driver");
> > +MODULE_LICENSE("GPL");
> >
>
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-06 22:25 ` [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI Denis Pauk
2021-10-06 23:32 ` Eugene Shalygin
2021-10-07 16:41 ` Guenter Roeck
@ 2021-10-07 16:47 ` Guenter Roeck
2021-10-07 17:14 ` Denis Pauk
2021-10-08 14:42 ` Eugene Shalygin
3 siblings, 1 reply; 23+ messages in thread
From: Guenter Roeck @ 2021-10-07 16:47 UTC (permalink / raw)
To: Denis Pauk
Cc: andy.shevchenko, Eugene Shalygin, Jean Delvare, linux-kernel,
linux-hwmon
On 10/6/21 3:25 PM, Denis Pauk wrote:
> Linux HWMON sensors driver for ASUS motherboards to read
> sensors from the embedded controller.
>
> Many ASUS motherboards do not publish all the available
> sensors via the Super I/O chip but the missing ones are
> available through the embedded controller (EC) registers.
>
> This driver implements reading those sensor data via the
> WMI method BREC, which is known to be present in all ASUS
> motherboards based on the AMD 500 series chipsets (and
> probably is available in other models too). The driver
> needs to know exact register addresses for the sensors and
> thus support for each motherboard has to be added explicitly.
>
> The EC registers do not provide critical values for the
> sensors and as such they are not published to the HWMON.
>
> Supported motherboards:
> * ROG CROSSHAIR VIII HERO
> * ROG CROSSHAIR VIII DARK HERO
> * ROG CROSSHAIR VIII FORMULA
> * ROG STRIX X570-E GAMING
> * ROG STRIX B550-E GAMING
>
> BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
> Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
> Co-developed-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
>
> ---
> Changes in v2:
> - Use utf8s_to_utf16s/utf16s_to_utf8s instead handmade fuctions.
> - Use post increment.
> - Use get_unaligned* for convert values.
> - Use PTR_ERR_OR_ZERO.
> - Specify per-board sensors in a declarative way (by Eugene Shalygin).
> ---
> MAINTAINERS | 7 +
> drivers/hwmon/Kconfig | 13 +-
> drivers/hwmon/Makefile | 1 +
> drivers/hwmon/asus_wmi_ec_sensors.c | 631 ++++++++++++++++++++++++++++
Documentation needed. Also,what is the difference to the hwmon device
instantiated from drivers/platform/x86/asus-wmi.c, and how is it guaranteed
that there is no overlap ?
Guenter
> 4 files changed, 651 insertions(+), 1 deletion(-)
> create mode 100644 drivers/hwmon/asus_wmi_ec_sensors.c
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index bae3f62f548f..bc2e981a54e2 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -2937,6 +2937,13 @@ W: http://acpi4asus.sf.net
> F: drivers/platform/x86/asus*.c
> F: drivers/platform/x86/eeepc*.c
>
> +ASUS WMI HARDWARE MONITOR DRIVER
> +M: Eugene Shalygin <eugene.shalygin@gmail.com>
> +M: Denis Pauk <pauk.denis@gmail.com>
> +L: linux-hwmon@vger.kernel.org
> +S: Maintained
> +F: drivers/hwmon/asus_wmi_ec_sensors.c
> +
> ASUS WIRELESS RADIO CONTROL DRIVER
> M: João Paulo Rechi Vita <jprvita@gmail.com>
> L: platform-driver-x86@vger.kernel.org
> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> index 7fde4c6e1e7f..b7107721a401 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -1840,7 +1840,7 @@ config SENSORS_ADS7871
>
> config SENSORS_AMC6821
> tristate "Texas Instruments AMC6821"
> - depends on I2C
> + depends on I2C
> help
> If you say yes here you get support for the Texas Instruments
> AMC6821 hardware monitoring chips.
> @@ -2215,6 +2215,17 @@ config SENSORS_ATK0110
> This driver can also be built as a module. If so, the module
> will be called asus_atk0110.
>
> +config SENSORS_ASUS_WMI_EC
> + tristate "ASUS WMI B550/X570"
> + help
> + If you say yes here you get support for the ACPI embedded controller
> + hardware monitoring interface found in B550/X570 ASUS motherboards.
> + This driver will provide readings of fans, voltages and temperatures
> + through the system firmware.
> +
> + This driver can also be built as a module. If so, the module
> + will be called asus_wmi_sensors_ec.
> +
> endif # ACPI
>
> endif # HWMON
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index baee6a8d4dd1..aae2ff5c7335 100644
> --- a/drivers/hwmon/Makefile
> +++ b/drivers/hwmon/Makefile
> @@ -9,6 +9,7 @@ obj-$(CONFIG_HWMON_VID) += hwmon-vid.o
> # APCI drivers
> obj-$(CONFIG_SENSORS_ACPI_POWER) += acpi_power_meter.o
> obj-$(CONFIG_SENSORS_ATK0110) += asus_atk0110.o
> +obj-$(CONFIG_SENSORS_ASUS_WMI_EC) += asus_wmi_ec_sensors.o
>
> # Native drivers
> # asb100, then w83781d go first, as they can override other drivers' addresses.
> diff --git a/drivers/hwmon/asus_wmi_ec_sensors.c b/drivers/hwmon/asus_wmi_ec_sensors.c
> new file mode 100644
> index 000000000000..553d9ee8656d
> --- /dev/null
> +++ b/drivers/hwmon/asus_wmi_ec_sensors.c
> @@ -0,0 +1,631 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * HWMON driver for ASUS B550/X570 motherboards that publish sensor
> + * values via the embedded controller registers.
> + *
> + * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com>
> + * Copyright (C) 2018-2019 Ed Brindley <kernel@maidavale.org>
> + *
> + * EC provided:
> + * Chipset temperature,
> + * CPU temperature,
> + * Motherboard temperature,
> + * T_Sensor temperature,
> + * VRM temperature,
> + * Water In temperature,
> + * Water Out temperature,
> + * CPU Optional Fan,
> + * Chipset fan,
> + * Water Flow fan,
> + * CPU current.
> + *
> + */
> +#include <asm/unaligned.h>
> +#include <linux/acpi.h>
> +#include <linux/dmi.h>
> +#include <linux/hwmon.h>
> +#include <linux/hwmon-sysfs.h>
> +#include <linux/init.h>
> +#include <linux/jiffies.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/mutex.h>
> +#include <linux/nls.h>
> +#include <linux/platform_device.h>
> +#include <linux/units.h>
> +#include <linux/wmi.h>
> +
> +#define ASUSWMI_MONITORING_GUID "466747A0-70EC-11DE-8A39-0800200C9A66"
> +#define ASUSWMI_METHODID_BLOCK_READ_EC 0x42524543 /* BREC */
> +
> +#define ASUS_WMI_BLOCK_READ_REGISTERS_MAX 0x10 /* from the ASUS DSDT source */
> +/* from the ASUS_WMI_BLOCK_READ_REGISTERS_MAX value */
> +#define ASUS_WMI_MAX_BUF_LEN 0x80
> +#define MAX_SENSOR_LABEL_LENGTH 0x10
> +
> +enum asus_wmi_ec_board {
> + BOARD_PW_X570_A, /* Pro WS X570-ACE */
> + BOARD_R_C8H, /* ROG Crosshair VIII Hero */
> + BOARD_R_C8DH, /* ROG Crosshair VIII Dark Hero */
> + BOARD_R_C8F, /* ROG Crosshair VIII Formula */
> + BOARD_RS_B550_E_G, /* ROG STRIX B550-E GAMING */
> + BOARD_RS_X570_E_G, /* ROG STRIX X570-E GAMING */
> + BOARD_MAX
> +};
> +
> +/* boards with EC support */
> +static const char *const asus_wmi_ec_boards_names[] = {
> + [BOARD_PW_X570_A] = "Pro WS X570-ACE",
> + [BOARD_R_C8H] = "ROG CROSSHAIR VIII HERO",
> + [BOARD_R_C8DH] = "ROG CROSSHAIR VIII DARK HERO",
> + [BOARD_R_C8F] = "ROG CROSSHAIR VIII FORMULA",
> + [BOARD_RS_B550_E_G] = "ROG STRIX B550-E GAMING",
> + [BOARD_RS_X570_E_G] = "ROG STRIX X570-E GAMING",
> +};
> +
> +static u32 hwmon_attributes[] = {
> + [hwmon_chip] = HWMON_C_REGISTER_TZ,
> + [hwmon_temp] = HWMON_T_INPUT | HWMON_T_LABEL,
> + [hwmon_in] = HWMON_I_INPUT | HWMON_I_LABEL,
> + [hwmon_curr] = HWMON_C_INPUT | HWMON_C_LABEL,
> + [hwmon_fan] = HWMON_F_INPUT | HWMON_F_LABEL,
> +};
> +
> +struct asus_wmi_ec_sensor_address {
> + u8 index;
> + u8 bank;
> + u8 size;
> +};
> +
> +#define MAKE_SENSOR_ADDRESS(size_i, bank_i, index_i) \
> + { .size = size_i,\
> + .bank = bank_i,\
> + .index = index_i}
> +
> +struct ec_sensor_info {
> + char label[MAX_SENSOR_LABEL_LENGTH];
> + enum hwmon_sensor_types type;
> + struct asus_wmi_ec_sensor_address addr;
> +};
> +
> +#define EC_SENSOR(sensor_label, sensor_type, size, bank, index) \
> + { .label = sensor_label,\
> + .type = sensor_type, \
> + .addr = MAKE_SENSOR_ADDRESS(size, bank, index) \
> + }
> +
> +enum known_ec_sensor {
> + SENSOR_TEMP_CHIPSET,
> + SENSOR_TEMP_CPU,
> + SENSOR_TEMP_MB,
> + SENSOR_TEMP_T_SENSOR,
> + SENSOR_TEMP_VRM,
> + SENSOR_FAN_CPU_OPT,
> + SENSOR_FAN_CHIPSET,
> + SENSOR_FAN_WATER_FLOW,
> + SENSOR_CURR_CPU,
> + SENSOR_TEMP_WATER_IN,
> + SENSOR_TEMP_WATER_OUT,
> + SENSOR_MAX
> +};
> +
> +/*
> + * Array of the all known sensors for ASUS EC controllers
> + */
> +static const struct ec_sensor_info known_ec_sensors[] = {
> + [SENSOR_TEMP_CHIPSET] = EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a),
> + [SENSOR_TEMP_CPU] = EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b),
> + [SENSOR_TEMP_MB] = EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c),
> + [SENSOR_TEMP_T_SENSOR] = EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d),
> + [SENSOR_TEMP_VRM] = EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e),
> + [SENSOR_FAN_CPU_OPT] = EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0),
> + [SENSOR_FAN_CHIPSET] = EC_SENSOR("Chipset", hwmon_fan, 2, 0x00, 0xb4),
> + [SENSOR_FAN_WATER_FLOW] = EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc),
> + [SENSOR_CURR_CPU] = EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4),
> + [SENSOR_TEMP_WATER_IN] = EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00),
> + [SENSOR_TEMP_WATER_OUT] = EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01),
> +};
> +
> +static const enum known_ec_sensor known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> + [BOARD_PW_X570_A] = {
> + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> + SENSOR_FAN_CHIPSET,
> + SENSOR_MAX
> + },
> + [BOARD_R_C8H] = {
> + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
> + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> + SENSOR_TEMP_WATER_IN, SENSOR_TEMP_WATER_OUT,
> + SENSOR_FAN_CPU_OPT, SENSOR_FAN_CHIPSET, SENSOR_FAN_WATER_FLOW,
> + SENSOR_CURR_CPU,
> + SENSOR_MAX
> + },
> + [BOARD_R_C8DH] = { /* Same as Hero but without chipset fan */
> + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
> + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> + SENSOR_TEMP_WATER_IN, SENSOR_TEMP_WATER_OUT,
> + SENSOR_FAN_CPU_OPT, SENSOR_FAN_WATER_FLOW,
> + SENSOR_CURR_CPU,
> + SENSOR_MAX
> + },
> + [BOARD_R_C8F] = { /* Same as Hero but without water */
> + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
> + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> + SENSOR_FAN_CPU_OPT, SENSOR_FAN_CHIPSET,
> + SENSOR_CURR_CPU,
> + SENSOR_MAX
> + },
> + [BOARD_RS_B550_E_G] = {
> + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
> + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> + SENSOR_FAN_CPU_OPT,
> + SENSOR_CURR_CPU,
> + SENSOR_MAX
> + },
> + [BOARD_RS_X570_E_G] = {
> + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
> + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> + SENSOR_FAN_CHIPSET,
> + SENSOR_MAX
> + },
> +};
> +
> +struct ec_sensor {
> + enum known_ec_sensor info_index;
> + u32 cached_value;
> +};
> +
> +/**
> + * struct asus_wmi_ec_info - sensor info.
> + * @sensors: list of sensors.
> + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> + * @read_buffer: WMI function output.
> + * @nr_sensors: number of board EC sensors.
> + * @nr_registers: number of EC registers to read (sensor might span more than
> + * 1 register).
> + * @last_updated: in jiffies.
> + */
> +struct asus_wmi_ec_info {
> + struct ec_sensor sensors[SENSOR_MAX];
> + char read_arg[((ASUS_WMI_BLOCK_READ_REGISTERS_MAX * 4) + 1) * 2];
> + u8 read_buffer[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> + unsigned int nr_sensors;
> + unsigned int nr_registers;
> + unsigned long last_updated;
> +};
> +
> +struct asus_wmi_sensors {
> + /* lock access to instrnal cache */
> + struct mutex lock;
> + struct asus_wmi_ec_info ec;
> +
> + int ec_board;
> +};
> +
> +struct asus_wmi_data {
> + int ec_board;
> +};
> +
> +static void asus_wmi_ec_fill_board_sensors(struct asus_wmi_ec_info *ec, int board)
> +{
> + const enum known_ec_sensor *bsi = known_board_sensors[board];
> + struct ec_sensor *s = ec->sensors;
> + int i;
> +
> + ec->nr_sensors = 0;
> + ec->nr_registers = 0;
> +
> + for (i = 0; i < SENSOR_MAX && bsi[i] != SENSOR_MAX; i++) {
> + s[i].info_index = bsi[i];
> + s[i].cached_value = 0;
> + ec->nr_sensors++;
> + ec->nr_registers += known_ec_sensors[bsi[i]].addr.size;
> + }
> +}
> +
> +/*
> + * The next four functions converts to/from BRxx string argument format
> + * The format of the string is as follows:
> + * The string consists of two-byte UTF-16 characters
> + * The value of the very first byte int the string is equal to the total length
> + * of the next string in bytes, thus excluding the first two-byte character
> + * The rest of the string encodes pairs of (bank, index) pairs, where both
> + * values are byte-long (0x00 to 0xFF)
> + * Numbers are encoded as UTF-16 hex values
> + */
> +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> +{
> + unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] / 4);
> + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> + const char *pos = buffer;
> + const u8 *data = inp + 2;
> + unsigned int i;
> +
> + utf16s_to_utf8s((wchar_t *)data, len * 2, UTF16_LITTLE_ENDIAN, buffer, len * 2);
> +
> + for (i = 0; i < len; i++, pos += 2)
> + out[i] = (hex_to_bin(pos[0]) << 4) + hex_to_bin(pos[1]);
> +}
> +
> +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len, char *out)
> +{
> + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> + char *pos = buffer;
> + unsigned int i;
> + u8 byte;
> +
> + *out++ = len * 8;
> + *out++ = 0;
> +
> + for (i = 0; i < len; i++) {
> + byte = registers[i] >> 8;
> + *pos = hex_asc_hi(byte);
> + pos++;
> + *pos = hex_asc_lo(byte);
> + pos++;
> + byte = registers[i];
> + *pos = hex_asc_hi(byte);
> + pos++;
> + *pos = hex_asc_lo(byte);
> + pos++;
> + }
> +
> + utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN, (wchar_t *)out, len * 4);
> +}
> +
> +static void asus_wmi_ec_make_block_read_query(struct asus_wmi_ec_info *ec)
> +{
> + u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> + const struct ec_sensor_info *si;
> + long i, j, register_idx = 0;
> +
> + /*
> + * if we can get values for all the registers in a single query,
> + * the query will not change from call to call
> + */
> + if (ec->nr_registers <= ASUS_WMI_BLOCK_READ_REGISTERS_MAX &&
> + ec->read_arg[0] > 0) {
> + /* no need to update */
> + return;
> + }
> +
> + for (i = 0; i < ec->nr_sensors; i++) {
> + si = &known_ec_sensors[ec->sensors[i].info_index];
> + for (j = 0; j < si->addr.size;
> + j++, register_idx++) {
> + registers[register_idx] = (si->addr.bank << 8) + si->addr.index + j;
> + }
> + }
> +
> + asus_wmi_ec_encode_registers(registers, ec->nr_registers, ec->read_arg);
> +}
> +
> +static int asus_wmi_ec_block_read(u32 method_id, char *query, u8 *out)
> +{
> + struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER,
> + NULL };
> + struct acpi_buffer input;
> + union acpi_object *obj;
> + acpi_status status;
> +
> + /* the first byte of the BRxx() argument string has to be the string size */
> + input.length = (acpi_size)query[0] + 2;
> + input.pointer = query;
> + status = wmi_evaluate_method(ASUSWMI_MONITORING_GUID, 0, method_id, &input,
> + &output);
> + if (ACPI_FAILURE(status))
> + return -EIO;
> +
> + obj = output.pointer;
> + if (!obj || obj->type != ACPI_TYPE_BUFFER) {
> + if (!obj)
> + acpi_os_free(output.pointer);
> +
> + return -EIO;
> + }
> + asus_wmi_ec_decode_reply_buffer(obj->buffer.pointer, out);
> + acpi_os_free(output.pointer);
> + return 0;
> +}
> +
> +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info *ec)
> +{
> + const struct ec_sensor_info *si;
> + struct ec_sensor *s;
> +
> + u32 value;
> + int status;
> + u8 i_sensor, read_reg_ct;
> +
> + asus_wmi_ec_make_block_read_query(ec);
> + status = asus_wmi_ec_block_read(ASUSWMI_METHODID_BLOCK_READ_EC,
> + ec->read_arg,
> + ec->read_buffer);
> + if (status)
> + return status;
> +
> + read_reg_ct = 0;
> + for (i_sensor = 0; i_sensor < ec->nr_sensors; i_sensor++) {
> + s = &ec->sensors[i_sensor];
> + si = &known_ec_sensors[s->info_index];
> +
> + if (si->addr.size == 1)
> + value = ec->read_buffer[read_reg_ct];
> + else if (si->addr.size == 2)
> + value = get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> + else if (si->addr.size == 4)
> + value = get_unaligned_le32(&ec->read_buffer[read_reg_ct]);
> +
> + read_reg_ct += si->addr.size;
> + s->cached_value = value;
> + }
> + return 0;
> +}
> +
> +static int asus_wmi_ec_scale_sensor_value(u32 value, int data_type)
> +{
> + switch (data_type) {
> + case hwmon_curr:
> + case hwmon_temp:
> + case hwmon_in:
> + return value * KILO;
> + default:
> + return value;
> + }
> +}
> +
> +static int asus_wmi_ec_find_sensor_index(const struct asus_wmi_ec_info *ec,
> + enum hwmon_sensor_types type, int channel)
> +{
> + int i;
> +
> + for (i = 0; i < ec->nr_sensors; i++) {
> + if (known_ec_sensors[ec->sensors[i].info_index].type == type) {
> + if (channel == 0)
> + return i;
> +
> + channel--;
> + }
> + }
> + return -EINVAL;
> +}
> +
> +static int asus_wmi_ec_get_cached_value_or_update(int sensor_index,
> + struct asus_wmi_sensors *state,
> + u32 *value)
> +{
> + int ret;
> +
> + if (time_after(jiffies, state->ec.last_updated + HZ)) {
> + ret = asus_wmi_ec_update_ec_sensors(&state->ec);
> + if (ret)
> + return ret;
> +
> + state->ec.last_updated = jiffies;
> + }
> +
> + *value = state->ec.sensors[sensor_index].cached_value;
> + return 0;
> +}
> +
> +/*
> + * Now follow the functions that implement the hwmon interface
> + */
> +
> +static int asus_wmi_ec_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
> + u32 attr, int channel, long *val)
> +{
> + struct asus_wmi_sensors *sensor_data = dev_get_drvdata(dev);
> + int ret, sidx, info_index;
> + u32 value = 0;
> +
> + sidx = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> + if (sidx < 0)
> + return sidx;
> +
> + mutex_lock(&sensor_data->lock);
> + ret = asus_wmi_ec_get_cached_value_or_update(sidx, sensor_data, &value);
> + mutex_unlock(&sensor_data->lock);
> + if (ret)
> + return ret;
> +
> + info_index = sensor_data->ec.sensors[sidx].info_index;
> + *val = asus_wmi_ec_scale_sensor_value(value,
> + known_ec_sensors[info_index].type);
> +
> + return ret;
> +}
> +
> +static int asus_wmi_ec_hwmon_read_string(struct device *dev,
> + enum hwmon_sensor_types type, u32 attr,
> + int channel, const char **str)
> +{
> + struct asus_wmi_sensors *sensor_data = dev_get_drvdata(dev);
> + int sensor_index;
> +
> + sensor_index = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> + *str = known_ec_sensors[sensor_data->ec.sensors[sensor_index].info_index].label;
> +
> + return 0;
> +}
> +
> +static umode_t asus_wmi_ec_hwmon_is_visible(const void *drvdata,
> + enum hwmon_sensor_types type, u32 attr,
> + int channel)
> +{
> + int index;
> + const struct asus_wmi_sensors *sensor_data = drvdata;
> +
> + index = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> +
> + return index == 0xff ? 0 : 0444;
> +}
> +
> +static int asus_wmi_hwmon_add_chan_info(struct hwmon_channel_info *asus_wmi_hwmon_chan,
> + struct device *dev, int num,
> + enum hwmon_sensor_types type, u32 config)
> +{
> + u32 *cfg;
> +
> + cfg = devm_kcalloc(dev, num + 1, sizeof(*cfg), GFP_KERNEL);
> + if (!cfg)
> + return -ENOMEM;
> +
> + asus_wmi_hwmon_chan->type = type;
> + asus_wmi_hwmon_chan->config = cfg;
> + memset32(cfg, config, num);
> +
> + return 0;
> +}
> +
> +static const struct hwmon_ops asus_wmi_ec_hwmon_ops = {
> + .is_visible = asus_wmi_ec_hwmon_is_visible,
> + .read = asus_wmi_ec_hwmon_read,
> + .read_string = asus_wmi_ec_hwmon_read_string,
> +};
> +
> +static struct hwmon_chip_info asus_wmi_ec_chip_info = {
> + .ops = &asus_wmi_ec_hwmon_ops,
> +};
> +
> +static int asus_wmi_ec_configure_sensor_setup(struct platform_device *pdev,
> + struct asus_wmi_sensors *sensor_data)
> +{
> + struct hwmon_channel_info *asus_wmi_hwmon_chan;
> + const struct hwmon_channel_info **ptr_asus_wmi_ci;
> + int nr_count[hwmon_max] = { 0 }, nr_types = 0;
> + const struct hwmon_chip_info *chip_info;
> + struct device *dev = &pdev->dev;
> + const struct ec_sensor_info *si;
> + enum hwmon_sensor_types type;
> + struct device *hwdev;
> + int i;
> +
> + asus_wmi_ec_fill_board_sensors(&sensor_data->ec, sensor_data->ec_board);
> +
> + if (!sensor_data->ec.nr_sensors)
> + return -ENODEV;
> +
> + for (i = 0; i < sensor_data->ec.nr_sensors; i++) {
> + si = &known_ec_sensors[sensor_data->ec.sensors[i].info_index];
> + if (!nr_count[si->type])
> + nr_types++;
> + nr_count[si->type]++;
> + }
> +
> + if (nr_count[hwmon_temp]) {
> + nr_count[hwmon_chip]++;
> + nr_types++;
> + }
> +
> + asus_wmi_hwmon_chan = devm_kcalloc(dev, nr_types,
> + sizeof(*asus_wmi_hwmon_chan),
> + GFP_KERNEL);
> + if (!asus_wmi_hwmon_chan)
> + return -ENOMEM;
> +
> + ptr_asus_wmi_ci = devm_kcalloc(dev, nr_types + 1,
> + sizeof(*ptr_asus_wmi_ci), GFP_KERNEL);
> + if (!ptr_asus_wmi_ci)
> + return -ENOMEM;
> +
> + asus_wmi_ec_chip_info.info = ptr_asus_wmi_ci;
> + chip_info = &asus_wmi_ec_chip_info;
> +
> + for (type = 0; type < hwmon_max; type++) {
> + if (!nr_count[type])
> + continue;
> +
> + asus_wmi_hwmon_add_chan_info(asus_wmi_hwmon_chan, dev,
> + nr_count[type], type,
> + hwmon_attributes[type]);
> + *ptr_asus_wmi_ci++ = asus_wmi_hwmon_chan++;
> + }
> +
> + dev_dbg(&pdev->dev, "%s board has %d EC sensors that span %d registers",
> + asus_wmi_ec_boards_names[sensor_data->ec_board],
> + sensor_data->ec.nr_sensors,
> + sensor_data->ec.nr_registers);
> +
> + hwdev = devm_hwmon_device_register_with_info(dev, KBUILD_MODNAME,
> + sensor_data, chip_info, NULL);
> +
> + return PTR_ERR_OR_ZERO(hwdev);
> +}
> +
> +static int asus_wmi_probe(struct platform_device *pdev)
> +{
> + struct asus_wmi_sensors *sensor_data;
> + struct device *dev = &pdev->dev;
> + struct asus_wmi_data *data;
> +
> + data = dev_get_platdata(dev);
> +
> + sensor_data = devm_kzalloc(dev, sizeof(struct asus_wmi_sensors),
> + GFP_KERNEL);
> + if (!sensor_data)
> + return -ENOMEM;
> +
> + mutex_init(&sensor_data->lock);
> + sensor_data->ec_board = data->ec_board;
> +
> + platform_set_drvdata(pdev, sensor_data);
> +
> + /* ec init */
> + return asus_wmi_ec_configure_sensor_setup(pdev,
> + sensor_data);
> +}
> +
> +static struct platform_driver asus_wmi_sensors_platform_driver = {
> + .driver = {
> + .name = "asus-wmi-sensors",
> + },
> + .probe = asus_wmi_probe,
> +};
> +
> +static struct platform_device *sensors_pdev;
> +
> +static int __init asus_wmi_init(void)
> +{
> + const char *board_vendor, *board_name;
> + struct asus_wmi_data data;
> +
> + data.ec_board = -1;
> +
> + board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
> + board_name = dmi_get_system_info(DMI_BOARD_NAME);
> +
> + if (board_vendor && board_name &&
> + !strcmp(board_vendor, "ASUSTeK COMPUTER INC.")) {
> + if (!wmi_has_guid(ASUSWMI_MONITORING_GUID))
> + return -ENODEV;
> +
> + data.ec_board = match_string(asus_wmi_ec_boards_names,
> + ARRAY_SIZE(asus_wmi_ec_boards_names),
> + board_name);
> + }
> +
> + /* Nothing to support */
> + if (data.ec_board < 0)
> + return -ENODEV;
> +
> + sensors_pdev = platform_create_bundle(&asus_wmi_sensors_platform_driver,
> + asus_wmi_probe,
> + NULL, 0,
> + &data, sizeof(struct asus_wmi_data));
> +
> + return PTR_ERR_OR_ZERO(sensors_pdev);
> +}
> +module_init(asus_wmi_init);
> +
> +static void __exit asus_wmi_exit(void)
> +{
> + platform_device_unregister(sensors_pdev);
> + platform_driver_unregister(&asus_wmi_sensors_platform_driver);
> +}
> +module_exit(asus_wmi_exit);
> +
> +MODULE_AUTHOR("Ed Brindley <kernel@maidavale.org>");
> +MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
> +MODULE_DESCRIPTION("Asus WMI Sensors Driver");
> +MODULE_LICENSE("GPL");
>
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-07 16:47 ` Guenter Roeck
@ 2021-10-07 17:14 ` Denis Pauk
0 siblings, 0 replies; 23+ messages in thread
From: Denis Pauk @ 2021-10-07 17:14 UTC (permalink / raw)
To: Guenter Roeck
Cc: andy.shevchenko, Eugene Shalygin, Jean Delvare, linux-kernel,
linux-hwmon
On Thu, 7 Oct 2021 09:47:27 -0700
Guenter Roeck <linux@roeck-us.net> wrote:
> On 10/6/21 3:25 PM, Denis Pauk wrote:
> > Linux HWMON sensors driver for ASUS motherboards to read
> > sensors from the embedded controller.
> >
> > Many ASUS motherboards do not publish all the available
> > sensors via the Super I/O chip but the missing ones are
> > available through the embedded controller (EC) registers.
> >
> > This driver implements reading those sensor data via the
> > WMI method BREC, which is known to be present in all ASUS
> > motherboards based on the AMD 500 series chipsets (and
> > probably is available in other models too). The driver
> > needs to know exact register addresses for the sensors and
> > thus support for each motherboard has to be added explicitly.
> >
> > The EC registers do not provide critical values for the
> > sensors and as such they are not published to the HWMON.
> >
> > Supported motherboards:
> > * ROG CROSSHAIR VIII HERO
> > * ROG CROSSHAIR VIII DARK HERO
> > * ROG CROSSHAIR VIII FORMULA
> > * ROG STRIX X570-E GAMING
> > * ROG STRIX B550-E GAMING
> >
> > BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
> > Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
> > Co-developed-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> > Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> >
> > ---
> > Changes in v2:
> > - Use utf8s_to_utf16s/utf16s_to_utf8s instead handmade fuctions.
> > - Use post increment.
> > - Use get_unaligned* for convert values.
> > - Use PTR_ERR_OR_ZERO.
> > - Specify per-board sensors in a declarative way (by Eugene
> > Shalygin). ---
> > MAINTAINERS | 7 +
> > drivers/hwmon/Kconfig | 13 +-
> > drivers/hwmon/Makefile | 1 +
> > drivers/hwmon/asus_wmi_ec_sensors.c | 631
> > ++++++++++++++++++++++++++++
>
> Documentation needed. Also,what is the difference to the hwmon device
> instantiated from drivers/platform/x86/asus-wmi.c, and how is it
> guaranteed that there is no overlap ?
>
> Guenter
>
Both modules in patch series use "466747A0-70EC-11DE-8A39-0800200C9A66"
when asus-wmi uses "97845ED0-4E6D-11DE-8A39-0800200C9A66".
I will create documentation.
Thank you.
> > 4 files changed, 651 insertions(+), 1 deletion(-)
> > create mode 100644 drivers/hwmon/asus_wmi_ec_sensors.c
> >
> > diff --git a/MAINTAINERS b/MAINTAINERS
> > index bae3f62f548f..bc2e981a54e2 100644
> > --- a/MAINTAINERS
> > +++ b/MAINTAINERS
> > @@ -2937,6 +2937,13 @@ W: http://acpi4asus.sf.net
> > F: drivers/platform/x86/asus*.c
> > F: drivers/platform/x86/eeepc*.c
> >
> > +ASUS WMI HARDWARE MONITOR DRIVER
> > +M: Eugene Shalygin <eugene.shalygin@gmail.com>
> > +M: Denis Pauk <pauk.denis@gmail.com>
> > +L: linux-hwmon@vger.kernel.org
> > +S: Maintained
> > +F: drivers/hwmon/asus_wmi_ec_sensors.c
> > +
> > ASUS WIRELESS RADIO CONTROL DRIVER
> > M: João Paulo Rechi Vita <jprvita@gmail.com>
> > L: platform-driver-x86@vger.kernel.org
> > diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> > index 7fde4c6e1e7f..b7107721a401 100644
> > --- a/drivers/hwmon/Kconfig
> > +++ b/drivers/hwmon/Kconfig
> > @@ -1840,7 +1840,7 @@ config SENSORS_ADS7871
> >
> > config SENSORS_AMC6821
> > tristate "Texas Instruments AMC6821"
> > - depends on I2C
> > + depends on I2C
> > help
> > If you say yes here you get support for the Texas
> > Instruments AMC6821 hardware monitoring chips.
> > @@ -2215,6 +2215,17 @@ config SENSORS_ATK0110
> > This driver can also be built as a module. If so, the
> > module will be called asus_atk0110.
> >
> > +config SENSORS_ASUS_WMI_EC
> > + tristate "ASUS WMI B550/X570"
> > + help
> > + If you say yes here you get support for the ACPI
> > embedded controller
> > + hardware monitoring interface found in B550/X570 ASUS
> > motherboards.
> > + This driver will provide readings of fans, voltages and
> > temperatures
> > + through the system firmware.
> > +
> > + This driver can also be built as a module. If so, the
> > module
> > + will be called asus_wmi_sensors_ec.
> > +
> > endif # ACPI
> >
> > endif # HWMON
> > diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> > index baee6a8d4dd1..aae2ff5c7335 100644
> > --- a/drivers/hwmon/Makefile
> > +++ b/drivers/hwmon/Makefile
> > @@ -9,6 +9,7 @@ obj-$(CONFIG_HWMON_VID) +=
> > hwmon-vid.o # APCI drivers
> > obj-$(CONFIG_SENSORS_ACPI_POWER) += acpi_power_meter.o
> > obj-$(CONFIG_SENSORS_ATK0110) += asus_atk0110.o
> > +obj-$(CONFIG_SENSORS_ASUS_WMI_EC) += asus_wmi_ec_sensors.o
> >
> > # Native drivers
> > # asb100, then w83781d go first, as they can override other
> > drivers' addresses. diff --git
> > a/drivers/hwmon/asus_wmi_ec_sensors.c
> > b/drivers/hwmon/asus_wmi_ec_sensors.c new file mode 100644 index
> > 000000000000..553d9ee8656d --- /dev/null
> > +++ b/drivers/hwmon/asus_wmi_ec_sensors.c
> > @@ -0,0 +1,631 @@
> > +// SPDX-License-Identifier: GPL-2.0+
> > +/*
> > + * HWMON driver for ASUS B550/X570 motherboards that publish sensor
> > + * values via the embedded controller registers.
> > + *
> > + * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com>
> > + * Copyright (C) 2018-2019 Ed Brindley <kernel@maidavale.org>
> > + *
> > + * EC provided:
> > + * Chipset temperature,
> > + * CPU temperature,
> > + * Motherboard temperature,
> > + * T_Sensor temperature,
> > + * VRM temperature,
> > + * Water In temperature,
> > + * Water Out temperature,
> > + * CPU Optional Fan,
> > + * Chipset fan,
> > + * Water Flow fan,
> > + * CPU current.
> > + *
> > + */
> > +#include <asm/unaligned.h>
> > +#include <linux/acpi.h>
> > +#include <linux/dmi.h>
> > +#include <linux/hwmon.h>
> > +#include <linux/hwmon-sysfs.h>
> > +#include <linux/init.h>
> > +#include <linux/jiffies.h>
> > +#include <linux/kernel.h>
> > +#include <linux/module.h>
> > +#include <linux/mutex.h>
> > +#include <linux/nls.h>
> > +#include <linux/platform_device.h>
> > +#include <linux/units.h>
> > +#include <linux/wmi.h>
> > +
> > +#define ASUSWMI_MONITORING_GUID
> > "466747A0-70EC-11DE-8A39-0800200C9A66" +#define
> > ASUSWMI_METHODID_BLOCK_READ_EC 0x42524543 /* BREC */
> > + +#define ASUS_WMI_BLOCK_READ_REGISTERS_MAX 0x10 /* from the ASUS
> > DSDT source */ +/* from the ASUS_WMI_BLOCK_READ_REGISTERS_MAX value
> > */ +#define ASUS_WMI_MAX_BUF_LEN 0x80
> > +#define MAX_SENSOR_LABEL_LENGTH 0x10
> > +
> > +enum asus_wmi_ec_board {
> > + BOARD_PW_X570_A, /* Pro WS X570-ACE */
> > + BOARD_R_C8H, /* ROG Crosshair VIII Hero */
> > + BOARD_R_C8DH, /* ROG Crosshair VIII Dark Hero */
> > + BOARD_R_C8F, /* ROG Crosshair VIII Formula */
> > + BOARD_RS_B550_E_G, /* ROG STRIX B550-E GAMING */
> > + BOARD_RS_X570_E_G, /* ROG STRIX X570-E GAMING */
> > + BOARD_MAX
> > +};
> > +
> > +/* boards with EC support */
> > +static const char *const asus_wmi_ec_boards_names[] = {
> > + [BOARD_PW_X570_A] = "Pro WS X570-ACE",
> > + [BOARD_R_C8H] = "ROG CROSSHAIR VIII HERO",
> > + [BOARD_R_C8DH] = "ROG CROSSHAIR VIII DARK HERO",
> > + [BOARD_R_C8F] = "ROG CROSSHAIR VIII FORMULA",
> > + [BOARD_RS_B550_E_G] = "ROG STRIX B550-E GAMING",
> > + [BOARD_RS_X570_E_G] = "ROG STRIX X570-E GAMING",
> > +};
> > +
> > +static u32 hwmon_attributes[] = {
> > + [hwmon_chip] = HWMON_C_REGISTER_TZ,
> > + [hwmon_temp] = HWMON_T_INPUT | HWMON_T_LABEL,
> > + [hwmon_in] = HWMON_I_INPUT | HWMON_I_LABEL,
> > + [hwmon_curr] = HWMON_C_INPUT | HWMON_C_LABEL,
> > + [hwmon_fan] = HWMON_F_INPUT | HWMON_F_LABEL,
> > +};
> > +
> > +struct asus_wmi_ec_sensor_address {
> > + u8 index;
> > + u8 bank;
> > + u8 size;
> > +};
> > +
> > +#define MAKE_SENSOR_ADDRESS(size_i, bank_i, index_i) \
> > + { .size = size_i,\
> > + .bank = bank_i,\
> > + .index = index_i}
> > +
> > +struct ec_sensor_info {
> > + char label[MAX_SENSOR_LABEL_LENGTH];
> > + enum hwmon_sensor_types type;
> > + struct asus_wmi_ec_sensor_address addr;
> > +};
> > +
> > +#define EC_SENSOR(sensor_label, sensor_type, size, bank, index) \
> > + { .label = sensor_label,\
> > + .type = sensor_type, \
> > + .addr = MAKE_SENSOR_ADDRESS(size, bank, index) \
> > + }
> > +
> > +enum known_ec_sensor {
> > + SENSOR_TEMP_CHIPSET,
> > + SENSOR_TEMP_CPU,
> > + SENSOR_TEMP_MB,
> > + SENSOR_TEMP_T_SENSOR,
> > + SENSOR_TEMP_VRM,
> > + SENSOR_FAN_CPU_OPT,
> > + SENSOR_FAN_CHIPSET,
> > + SENSOR_FAN_WATER_FLOW,
> > + SENSOR_CURR_CPU,
> > + SENSOR_TEMP_WATER_IN,
> > + SENSOR_TEMP_WATER_OUT,
> > + SENSOR_MAX
> > +};
> > +
> > +/*
> > + * Array of the all known sensors for ASUS EC controllers
> > + */
> > +static const struct ec_sensor_info known_ec_sensors[] = {
> > + [SENSOR_TEMP_CHIPSET] = EC_SENSOR("Chipset", hwmon_temp,
> > 1, 0x00, 0x3a),
> > + [SENSOR_TEMP_CPU] = EC_SENSOR("CPU", hwmon_temp, 1, 0x00,
> > 0x3b),
> > + [SENSOR_TEMP_MB] = EC_SENSOR("Motherboard", hwmon_temp, 1,
> > 0x00, 0x3c),
> > + [SENSOR_TEMP_T_SENSOR] = EC_SENSOR("T_Sensor", hwmon_temp,
> > 1, 0x00, 0x3d),
> > + [SENSOR_TEMP_VRM] = EC_SENSOR("VRM", hwmon_temp, 1, 0x00,
> > 0x3e),
> > + [SENSOR_FAN_CPU_OPT] = EC_SENSOR("CPU_Opt", hwmon_fan, 2,
> > 0x00, 0xb0),
> > + [SENSOR_FAN_CHIPSET] = EC_SENSOR("Chipset", hwmon_fan, 2,
> > 0x00, 0xb4),
> > + [SENSOR_FAN_WATER_FLOW] = EC_SENSOR("Water_Flow",
> > hwmon_fan, 2, 0x00, 0xbc),
> > + [SENSOR_CURR_CPU] = EC_SENSOR("CPU", hwmon_curr, 1, 0x00,
> > 0xf4),
> > + [SENSOR_TEMP_WATER_IN] = EC_SENSOR("Water_In", hwmon_temp,
> > 1, 0x01, 0x00),
> > + [SENSOR_TEMP_WATER_OUT] = EC_SENSOR("Water_Out",
> > hwmon_temp, 1, 0x01, 0x01), +};
> > +
> > +static const enum known_ec_sensor
> > known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> > + [BOARD_PW_X570_A] = {
> > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> > + SENSOR_FAN_CHIPSET,
> > + SENSOR_MAX
> > + },
> > + [BOARD_R_C8H] = {
> > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB,
> > + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> > + SENSOR_TEMP_WATER_IN, SENSOR_TEMP_WATER_OUT,
> > + SENSOR_FAN_CPU_OPT, SENSOR_FAN_CHIPSET,
> > SENSOR_FAN_WATER_FLOW,
> > + SENSOR_CURR_CPU,
> > + SENSOR_MAX
> > + },
> > + [BOARD_R_C8DH] = { /* Same as Hero but without chipset fan
> > */
> > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB,
> > + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> > + SENSOR_TEMP_WATER_IN, SENSOR_TEMP_WATER_OUT,
> > + SENSOR_FAN_CPU_OPT, SENSOR_FAN_WATER_FLOW,
> > + SENSOR_CURR_CPU,
> > + SENSOR_MAX
> > + },
> > + [BOARD_R_C8F] = { /* Same as Hero but without water */
> > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB,
> > + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> > + SENSOR_FAN_CPU_OPT, SENSOR_FAN_CHIPSET,
> > + SENSOR_CURR_CPU,
> > + SENSOR_MAX
> > + },
> > + [BOARD_RS_B550_E_G] = {
> > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB,
> > + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> > + SENSOR_FAN_CPU_OPT,
> > + SENSOR_CURR_CPU,
> > + SENSOR_MAX
> > + },
> > + [BOARD_RS_X570_E_G] = {
> > + SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB,
> > + SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> > + SENSOR_FAN_CHIPSET,
> > + SENSOR_MAX
> > + },
> > +};
> > +
> > +struct ec_sensor {
> > + enum known_ec_sensor info_index;
> > + u32 cached_value;
> > +};
> > +
> > +/**
> > + * struct asus_wmi_ec_info - sensor info.
> > + * @sensors: list of sensors.
> > + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> > + * @read_buffer: WMI function output.
> > + * @nr_sensors: number of board EC sensors.
> > + * @nr_registers: number of EC registers to read (sensor might
> > span more than
> > + * 1 register).
> > + * @last_updated: in jiffies.
> > + */
> > +struct asus_wmi_ec_info {
> > + struct ec_sensor sensors[SENSOR_MAX];
> > + char read_arg[((ASUS_WMI_BLOCK_READ_REGISTERS_MAX * 4) +
> > 1) * 2];
> > + u8 read_buffer[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > + unsigned int nr_sensors;
> > + unsigned int nr_registers;
> > + unsigned long last_updated;
> > +};
> > +
> > +struct asus_wmi_sensors {
> > + /* lock access to instrnal cache */
> > + struct mutex lock;
> > + struct asus_wmi_ec_info ec;
> > +
> > + int ec_board;
> > +};
> > +
> > +struct asus_wmi_data {
> > + int ec_board;
> > +};
> > +
> > +static void asus_wmi_ec_fill_board_sensors(struct asus_wmi_ec_info
> > *ec, int board) +{
> > + const enum known_ec_sensor *bsi =
> > known_board_sensors[board];
> > + struct ec_sensor *s = ec->sensors;
> > + int i;
> > +
> > + ec->nr_sensors = 0;
> > + ec->nr_registers = 0;
> > +
> > + for (i = 0; i < SENSOR_MAX && bsi[i] != SENSOR_MAX; i++) {
> > + s[i].info_index = bsi[i];
> > + s[i].cached_value = 0;
> > + ec->nr_sensors++;
> > + ec->nr_registers +=
> > known_ec_sensors[bsi[i]].addr.size;
> > + }
> > +}
> > +
> > +/*
> > + * The next four functions converts to/from BRxx string argument
> > format
> > + * The format of the string is as follows:
> > + * The string consists of two-byte UTF-16 characters
> > + * The value of the very first byte int the string is equal to the
> > total length
> > + * of the next string in bytes, thus excluding the first two-byte
> > character
> > + * The rest of the string encodes pairs of (bank, index) pairs,
> > where both
> > + * values are byte-long (0x00 to 0xFF)
> > + * Numbers are encoded as UTF-16 hex values
> > + */
> > +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> > +{
> > + unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] /
> > 4);
> > + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > + const char *pos = buffer;
> > + const u8 *data = inp + 2;
> > + unsigned int i;
> > +
> > + utf16s_to_utf8s((wchar_t *)data, len * 2,
> > UTF16_LITTLE_ENDIAN, buffer, len * 2); +
> > + for (i = 0; i < len; i++, pos += 2)
> > + out[i] = (hex_to_bin(pos[0]) << 4) +
> > hex_to_bin(pos[1]); +}
> > +
> > +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len,
> > char *out) +{
> > + char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > + char *pos = buffer;
> > + unsigned int i;
> > + u8 byte;
> > +
> > + *out++ = len * 8;
> > + *out++ = 0;
> > +
> > + for (i = 0; i < len; i++) {
> > + byte = registers[i] >> 8;
> > + *pos = hex_asc_hi(byte);
> > + pos++;
> > + *pos = hex_asc_lo(byte);
> > + pos++;
> > + byte = registers[i];
> > + *pos = hex_asc_hi(byte);
> > + pos++;
> > + *pos = hex_asc_lo(byte);
> > + pos++;
> > + }
> > +
> > + utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN,
> > (wchar_t *)out, len * 4); +}
> > +
> > +static void asus_wmi_ec_make_block_read_query(struct
> > asus_wmi_ec_info *ec) +{
> > + u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > + const struct ec_sensor_info *si;
> > + long i, j, register_idx = 0;
> > +
> > + /*
> > + * if we can get values for all the registers in a single
> > query,
> > + * the query will not change from call to call
> > + */
> > + if (ec->nr_registers <= ASUS_WMI_BLOCK_READ_REGISTERS_MAX
> > &&
> > + ec->read_arg[0] > 0) {
> > + /* no need to update */
> > + return;
> > + }
> > +
> > + for (i = 0; i < ec->nr_sensors; i++) {
> > + si = &known_ec_sensors[ec->sensors[i].info_index];
> > + for (j = 0; j < si->addr.size;
> > + j++, register_idx++) {
> > + registers[register_idx] = (si->addr.bank
> > << 8) + si->addr.index + j;
> > + }
> > + }
> > +
> > + asus_wmi_ec_encode_registers(registers, ec->nr_registers,
> > ec->read_arg); +}
> > +
> > +static int asus_wmi_ec_block_read(u32 method_id, char *query, u8
> > *out) +{
> > + struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER,
> > + NULL };
> > + struct acpi_buffer input;
> > + union acpi_object *obj;
> > + acpi_status status;
> > +
> > + /* the first byte of the BRxx() argument string has to be
> > the string size */
> > + input.length = (acpi_size)query[0] + 2;
> > + input.pointer = query;
> > + status = wmi_evaluate_method(ASUSWMI_MONITORING_GUID, 0,
> > method_id, &input,
> > + &output);
> > + if (ACPI_FAILURE(status))
> > + return -EIO;
> > +
> > + obj = output.pointer;
> > + if (!obj || obj->type != ACPI_TYPE_BUFFER) {
> > + if (!obj)
> > + acpi_os_free(output.pointer);
> > +
> > + return -EIO;
> > + }
> > + asus_wmi_ec_decode_reply_buffer(obj->buffer.pointer, out);
> > + acpi_os_free(output.pointer);
> > + return 0;
> > +}
> > +
> > +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info
> > *ec) +{
> > + const struct ec_sensor_info *si;
> > + struct ec_sensor *s;
> > +
> > + u32 value;
> > + int status;
> > + u8 i_sensor, read_reg_ct;
> > +
> > + asus_wmi_ec_make_block_read_query(ec);
> > + status =
> > asus_wmi_ec_block_read(ASUSWMI_METHODID_BLOCK_READ_EC,
> > + ec->read_arg,
> > + ec->read_buffer);
> > + if (status)
> > + return status;
> > +
> > + read_reg_ct = 0;
> > + for (i_sensor = 0; i_sensor < ec->nr_sensors; i_sensor++) {
> > + s = &ec->sensors[i_sensor];
> > + si = &known_ec_sensors[s->info_index];
> > +
> > + if (si->addr.size == 1)
> > + value = ec->read_buffer[read_reg_ct];
> > + else if (si->addr.size == 2)
> > + value =
> > get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> > + else if (si->addr.size == 4)
> > + value =
> > get_unaligned_le32(&ec->read_buffer[read_reg_ct]); +
> > + read_reg_ct += si->addr.size;
> > + s->cached_value = value;
> > + }
> > + return 0;
> > +}
> > +
> > +static int asus_wmi_ec_scale_sensor_value(u32 value, int data_type)
> > +{
> > + switch (data_type) {
> > + case hwmon_curr:
> > + case hwmon_temp:
> > + case hwmon_in:
> > + return value * KILO;
> > + default:
> > + return value;
> > + }
> > +}
> > +
> > +static int asus_wmi_ec_find_sensor_index(const struct
> > asus_wmi_ec_info *ec,
> > + enum hwmon_sensor_types
> > type, int channel) +{
> > + int i;
> > +
> > + for (i = 0; i < ec->nr_sensors; i++) {
> > + if
> > (known_ec_sensors[ec->sensors[i].info_index].type == type) {
> > + if (channel == 0)
> > + return i;
> > +
> > + channel--;
> > + }
> > + }
> > + return -EINVAL;
> > +}
> > +
> > +static int asus_wmi_ec_get_cached_value_or_update(int sensor_index,
> > + struct
> > asus_wmi_sensors *state,
> > + u32 *value)
> > +{
> > + int ret;
> > +
> > + if (time_after(jiffies, state->ec.last_updated + HZ)) {
> > + ret = asus_wmi_ec_update_ec_sensors(&state->ec);
> > + if (ret)
> > + return ret;
> > +
> > + state->ec.last_updated = jiffies;
> > + }
> > +
> > + *value = state->ec.sensors[sensor_index].cached_value;
> > + return 0;
> > +}
> > +
> > +/*
> > + * Now follow the functions that implement the hwmon interface
> > + */
> > +
> > +static int asus_wmi_ec_hwmon_read(struct device *dev, enum
> > hwmon_sensor_types type,
> > + u32 attr, int channel, long *val)
> > +{
> > + struct asus_wmi_sensors *sensor_data =
> > dev_get_drvdata(dev);
> > + int ret, sidx, info_index;
> > + u32 value = 0;
> > +
> > + sidx = asus_wmi_ec_find_sensor_index(&sensor_data->ec,
> > type, channel);
> > + if (sidx < 0)
> > + return sidx;
> > +
> > + mutex_lock(&sensor_data->lock);
> > + ret = asus_wmi_ec_get_cached_value_or_update(sidx,
> > sensor_data, &value);
> > + mutex_unlock(&sensor_data->lock);
> > + if (ret)
> > + return ret;
> > +
> > + info_index = sensor_data->ec.sensors[sidx].info_index;
> > + *val = asus_wmi_ec_scale_sensor_value(value,
> > +
> > known_ec_sensors[info_index].type); +
> > + return ret;
> > +}
> > +
> > +static int asus_wmi_ec_hwmon_read_string(struct device *dev,
> > + enum hwmon_sensor_types
> > type, u32 attr,
> > + int channel, const char
> > **str) +{
> > + struct asus_wmi_sensors *sensor_data =
> > dev_get_drvdata(dev);
> > + int sensor_index;
> > +
> > + sensor_index =
> > asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> > + *str =
> > known_ec_sensors[sensor_data->ec.sensors[sensor_index].info_index].label;
> > +
> > + return 0;
> > +}
> > +
> > +static umode_t asus_wmi_ec_hwmon_is_visible(const void *drvdata,
> > + enum
> > hwmon_sensor_types type, u32 attr,
> > + int channel)
> > +{
> > + int index;
> > + const struct asus_wmi_sensors *sensor_data = drvdata;
> > +
> > + index = asus_wmi_ec_find_sensor_index(&sensor_data->ec,
> > type, channel); +
> > + return index == 0xff ? 0 : 0444;
> > +}
> > +
> > +static int asus_wmi_hwmon_add_chan_info(struct hwmon_channel_info
> > *asus_wmi_hwmon_chan,
> > + struct device *dev, int
> > num,
> > + enum hwmon_sensor_types
> > type, u32 config) +{
> > + u32 *cfg;
> > +
> > + cfg = devm_kcalloc(dev, num + 1, sizeof(*cfg), GFP_KERNEL);
> > + if (!cfg)
> > + return -ENOMEM;
> > +
> > + asus_wmi_hwmon_chan->type = type;
> > + asus_wmi_hwmon_chan->config = cfg;
> > + memset32(cfg, config, num);
> > +
> > + return 0;
> > +}
> > +
> > +static const struct hwmon_ops asus_wmi_ec_hwmon_ops = {
> > + .is_visible = asus_wmi_ec_hwmon_is_visible,
> > + .read = asus_wmi_ec_hwmon_read,
> > + .read_string = asus_wmi_ec_hwmon_read_string,
> > +};
> > +
> > +static struct hwmon_chip_info asus_wmi_ec_chip_info = {
> > + .ops = &asus_wmi_ec_hwmon_ops,
> > +};
> > +
> > +static int asus_wmi_ec_configure_sensor_setup(struct
> > platform_device *pdev,
> > + struct
> > asus_wmi_sensors *sensor_data) +{
> > + struct hwmon_channel_info *asus_wmi_hwmon_chan;
> > + const struct hwmon_channel_info **ptr_asus_wmi_ci;
> > + int nr_count[hwmon_max] = { 0 }, nr_types = 0;
> > + const struct hwmon_chip_info *chip_info;
> > + struct device *dev = &pdev->dev;
> > + const struct ec_sensor_info *si;
> > + enum hwmon_sensor_types type;
> > + struct device *hwdev;
> > + int i;
> > +
> > + asus_wmi_ec_fill_board_sensors(&sensor_data->ec,
> > sensor_data->ec_board); +
> > + if (!sensor_data->ec.nr_sensors)
> > + return -ENODEV;
> > +
> > + for (i = 0; i < sensor_data->ec.nr_sensors; i++) {
> > + si =
> > &known_ec_sensors[sensor_data->ec.sensors[i].info_index];
> > + if (!nr_count[si->type])
> > + nr_types++;
> > + nr_count[si->type]++;
> > + }
> > +
> > + if (nr_count[hwmon_temp]) {
> > + nr_count[hwmon_chip]++;
> > + nr_types++;
> > + }
> > +
> > + asus_wmi_hwmon_chan = devm_kcalloc(dev, nr_types,
> > +
> > sizeof(*asus_wmi_hwmon_chan),
> > + GFP_KERNEL);
> > + if (!asus_wmi_hwmon_chan)
> > + return -ENOMEM;
> > +
> > + ptr_asus_wmi_ci = devm_kcalloc(dev, nr_types + 1,
> > + sizeof(*ptr_asus_wmi_ci),
> > GFP_KERNEL);
> > + if (!ptr_asus_wmi_ci)
> > + return -ENOMEM;
> > +
> > + asus_wmi_ec_chip_info.info = ptr_asus_wmi_ci;
> > + chip_info = &asus_wmi_ec_chip_info;
> > +
> > + for (type = 0; type < hwmon_max; type++) {
> > + if (!nr_count[type])
> > + continue;
> > +
> > + asus_wmi_hwmon_add_chan_info(asus_wmi_hwmon_chan,
> > dev,
> > + nr_count[type], type,
> > +
> > hwmon_attributes[type]);
> > + *ptr_asus_wmi_ci++ = asus_wmi_hwmon_chan++;
> > + }
> > +
> > + dev_dbg(&pdev->dev, "%s board has %d EC sensors that span
> > %d registers",
> > + asus_wmi_ec_boards_names[sensor_data->ec_board],
> > + sensor_data->ec.nr_sensors,
> > + sensor_data->ec.nr_registers);
> > +
> > + hwdev = devm_hwmon_device_register_with_info(dev,
> > KBUILD_MODNAME,
> > + sensor_data,
> > chip_info, NULL); +
> > + return PTR_ERR_OR_ZERO(hwdev);
> > +}
> > +
> > +static int asus_wmi_probe(struct platform_device *pdev)
> > +{
> > + struct asus_wmi_sensors *sensor_data;
> > + struct device *dev = &pdev->dev;
> > + struct asus_wmi_data *data;
> > +
> > + data = dev_get_platdata(dev);
> > +
> > + sensor_data = devm_kzalloc(dev, sizeof(struct
> > asus_wmi_sensors),
> > + GFP_KERNEL);
> > + if (!sensor_data)
> > + return -ENOMEM;
> > +
> > + mutex_init(&sensor_data->lock);
> > + sensor_data->ec_board = data->ec_board;
> > +
> > + platform_set_drvdata(pdev, sensor_data);
> > +
> > + /* ec init */
> > + return asus_wmi_ec_configure_sensor_setup(pdev,
> > + sensor_data);
> > +}
> > +
> > +static struct platform_driver asus_wmi_sensors_platform_driver = {
> > + .driver = {
> > + .name = "asus-wmi-sensors",
> > + },
> > + .probe = asus_wmi_probe,
> > +};
> > +
> > +static struct platform_device *sensors_pdev;
> > +
> > +static int __init asus_wmi_init(void)
> > +{
> > + const char *board_vendor, *board_name;
> > + struct asus_wmi_data data;
> > +
> > + data.ec_board = -1;
> > +
> > + board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
> > + board_name = dmi_get_system_info(DMI_BOARD_NAME);
> > +
> > + if (board_vendor && board_name &&
> > + !strcmp(board_vendor, "ASUSTeK COMPUTER INC.")) {
> > + if (!wmi_has_guid(ASUSWMI_MONITORING_GUID))
> > + return -ENODEV;
> > +
> > + data.ec_board =
> > match_string(asus_wmi_ec_boards_names,
> > +
> > ARRAY_SIZE(asus_wmi_ec_boards_names),
> > + board_name);
> > + }
> > +
> > + /* Nothing to support */
> > + if (data.ec_board < 0)
> > + return -ENODEV;
> > +
> > + sensors_pdev =
> > platform_create_bundle(&asus_wmi_sensors_platform_driver,
> > + asus_wmi_probe,
> > + NULL, 0,
> > + &data, sizeof(struct
> > asus_wmi_data)); +
> > + return PTR_ERR_OR_ZERO(sensors_pdev);
> > +}
> > +module_init(asus_wmi_init);
> > +
> > +static void __exit asus_wmi_exit(void)
> > +{
> > + platform_device_unregister(sensors_pdev);
> > +
> > platform_driver_unregister(&asus_wmi_sensors_platform_driver); +}
> > +module_exit(asus_wmi_exit);
> > +
> > +MODULE_AUTHOR("Ed Brindley <kernel@maidavale.org>");
> > +MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
> > +MODULE_DESCRIPTION("Asus WMI Sensors Driver");
> > +MODULE_LICENSE("GPL");
> >
>
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
2021-10-06 22:25 ` [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI Denis Pauk
` (2 preceding siblings ...)
2021-10-07 16:47 ` Guenter Roeck
@ 2021-10-08 14:42 ` Eugene Shalygin
3 siblings, 0 replies; 23+ messages in thread
From: Eugene Shalygin @ 2021-10-08 14:42 UTC (permalink / raw)
To: Denis Pauk
Cc: andy.shevchenko, Jean Delvare, Guenter Roeck, linux-kernel, linux-hwmon
Hi Denis,
On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com> wrote:
> + if (si->addr.size == 1)
> + value = ec->read_buffer[read_reg_ct];
> + else if (si->addr.size == 2)
> + value = get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> + else if (si->addr.size == 4)
> + value = get_unaligned_le32(&ec->read_buffer[read_reg_ct]);
If you did not invert the encoding scheme the data in the buffer are
in BE order.
Best regards,
Eugene
^ permalink raw reply [flat|nested] 23+ messages in thread