hc
2023-12-06 d38611ca164021d018c1b23eee65bbebc09c63e0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
/* Copyright (C) 2017 Netronome Systems, Inc. */
 
#include <linux/kernel.h>
#include <linux/slab.h>
 
#include "nfp.h"
#include "nfp_nsp.h"
 
struct nsp_identify {
   u8 version[40];
   u8 flags;
   u8 br_primary;
   u8 br_secondary;
   u8 br_nsp;
   __le16 primary;
   __le16 secondary;
   __le16 nsp;
   u8 reserved[6];
   __le64 sensor_mask;
};
 
struct nfp_nsp_identify *__nfp_nsp_identify(struct nfp_nsp *nsp)
{
   struct nfp_nsp_identify *nspi = NULL;
   struct nsp_identify *ni;
   int ret;
 
   if (nfp_nsp_get_abi_ver_minor(nsp) < 15)
       return NULL;
 
   ni = kzalloc(sizeof(*ni), GFP_KERNEL);
   if (!ni)
       return NULL;
 
   ret = nfp_nsp_read_identify(nsp, ni, sizeof(*ni));
   if (ret < 0) {
       nfp_err(nfp_nsp_cpp(nsp), "reading bsp version failed %d\n",
           ret);
       goto exit_free;
   }
 
   nspi = kzalloc(sizeof(*nspi), GFP_KERNEL);
   if (!nspi)
       goto exit_free;
 
   memcpy(nspi->version, ni->version, sizeof(nspi->version));
   nspi->version[sizeof(nspi->version) - 1] = '\0';
   nspi->flags = ni->flags;
   nspi->br_primary = ni->br_primary;
   nspi->br_secondary = ni->br_secondary;
   nspi->br_nsp = ni->br_nsp;
   nspi->primary = le16_to_cpu(ni->primary);
   nspi->secondary = le16_to_cpu(ni->secondary);
   nspi->nsp = le16_to_cpu(ni->nsp);
   nspi->sensor_mask = le64_to_cpu(ni->sensor_mask);
 
exit_free:
   kfree(ni);
   return nspi;
}
 
struct nfp_sensors {
   __le32 chip_temp;
   __le32 assembly_power;
   __le32 assembly_12v_power;
   __le32 assembly_3v3_power;
};
 
int nfp_hwmon_read_sensor(struct nfp_cpp *cpp, enum nfp_nsp_sensor_id id,
             long *val)
{
   struct nfp_sensors s;
   struct nfp_nsp *nsp;
   int ret;
 
   nsp = nfp_nsp_open(cpp);
   if (IS_ERR(nsp))
       return PTR_ERR(nsp);
 
   ret = nfp_nsp_read_sensors(nsp, BIT(id), &s, sizeof(s));
   nfp_nsp_close(nsp);
 
   if (ret < 0)
       return ret;
 
   switch (id) {
   case NFP_SENSOR_CHIP_TEMPERATURE:
       *val = le32_to_cpu(s.chip_temp);
       break;
   case NFP_SENSOR_ASSEMBLY_POWER:
       *val = le32_to_cpu(s.assembly_power);
       break;
   case NFP_SENSOR_ASSEMBLY_12V_POWER:
       *val = le32_to_cpu(s.assembly_12v_power);
       break;
   case NFP_SENSOR_ASSEMBLY_3V3_POWER:
       *val = le32_to_cpu(s.assembly_3v3_power);
       break;
   default:
       return -EINVAL;
   }
   return 0;
}