1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * A hack to create a platform device from a DMI entry. This will |
4 | * allow autoloading of the IPMI drive based on SMBIOS entries. |
5 | */ |
6 | |
7 | #define pr_fmt(fmt) "%s" fmt, "ipmi:dmi: " |
8 | #define dev_fmt pr_fmt |
9 | |
10 | #include <linux/ipmi.h> |
11 | #include <linux/init.h> |
12 | #include <linux/dmi.h> |
13 | #include <linux/platform_device.h> |
14 | #include <linux/property.h> |
15 | #include "ipmi_dmi.h" |
16 | #include "ipmi_plat_data.h" |
17 | |
18 | #define IPMI_DMI_TYPE_KCS 0x01 |
19 | #define IPMI_DMI_TYPE_SMIC 0x02 |
20 | #define IPMI_DMI_TYPE_BT 0x03 |
21 | #define IPMI_DMI_TYPE_SSIF 0x04 |
22 | |
23 | struct ipmi_dmi_info { |
24 | enum si_type si_type; |
25 | unsigned int space; /* addr space for si, intf# for ssif */ |
26 | unsigned long addr; |
27 | u8 slave_addr; |
28 | struct ipmi_dmi_info *next; |
29 | }; |
30 | |
31 | static struct ipmi_dmi_info *ipmi_dmi_infos; |
32 | |
33 | static int ipmi_dmi_nr __initdata; |
34 | |
35 | static void __init dmi_add_platform_ipmi(unsigned long base_addr, |
36 | unsigned int space, |
37 | u8 slave_addr, |
38 | int irq, |
39 | int offset, |
40 | int type) |
41 | { |
42 | const char *name; |
43 | struct ipmi_dmi_info *info; |
44 | struct ipmi_plat_data p; |
45 | |
46 | memset(&p, 0, sizeof(p)); |
47 | |
48 | name = "dmi-ipmi-si" ; |
49 | p.iftype = IPMI_PLAT_IF_SI; |
50 | switch (type) { |
51 | case IPMI_DMI_TYPE_SSIF: |
52 | name = "dmi-ipmi-ssif" ; |
53 | p.iftype = IPMI_PLAT_IF_SSIF; |
54 | p.type = SI_TYPE_INVALID; |
55 | break; |
56 | case IPMI_DMI_TYPE_BT: |
57 | p.type = SI_BT; |
58 | break; |
59 | case IPMI_DMI_TYPE_KCS: |
60 | p.type = SI_KCS; |
61 | break; |
62 | case IPMI_DMI_TYPE_SMIC: |
63 | p.type = SI_SMIC; |
64 | break; |
65 | default: |
66 | pr_err("Invalid IPMI type: %d\n" , type); |
67 | return; |
68 | } |
69 | |
70 | p.addr = base_addr; |
71 | p.space = space; |
72 | p.regspacing = offset; |
73 | p.irq = irq; |
74 | p.slave_addr = slave_addr; |
75 | p.addr_source = SI_SMBIOS; |
76 | |
77 | info = kmalloc(size: sizeof(*info), GFP_KERNEL); |
78 | if (!info) { |
79 | pr_warn("Could not allocate dmi info\n" ); |
80 | } else { |
81 | info->si_type = p.type; |
82 | info->space = space; |
83 | info->addr = base_addr; |
84 | info->slave_addr = slave_addr; |
85 | info->next = ipmi_dmi_infos; |
86 | ipmi_dmi_infos = info; |
87 | } |
88 | |
89 | if (ipmi_platform_add(name, inst: ipmi_dmi_nr, p: &p)) |
90 | ipmi_dmi_nr++; |
91 | } |
92 | |
93 | /* |
94 | * Look up the slave address for a given interface. This is here |
95 | * because ACPI doesn't have a slave address while SMBIOS does, but we |
96 | * prefer using ACPI so the ACPI code can use the IPMI namespace. |
97 | * This function allows an ACPI-specified IPMI device to look up the |
98 | * slave address from the DMI table. |
99 | */ |
100 | int ipmi_dmi_get_slave_addr(enum si_type si_type, unsigned int space, |
101 | unsigned long base_addr) |
102 | { |
103 | struct ipmi_dmi_info *info = ipmi_dmi_infos; |
104 | |
105 | while (info) { |
106 | if (info->si_type == si_type && |
107 | info->space == space && |
108 | info->addr == base_addr) |
109 | return info->slave_addr; |
110 | info = info->next; |
111 | } |
112 | |
113 | return 0; |
114 | } |
115 | EXPORT_SYMBOL(ipmi_dmi_get_slave_addr); |
116 | |
117 | #define DMI_IPMI_MIN_LENGTH 0x10 |
118 | #define DMI_IPMI_VER2_LENGTH 0x12 |
119 | #define DMI_IPMI_TYPE 4 |
120 | #define DMI_IPMI_SLAVEADDR 6 |
121 | #define DMI_IPMI_ADDR 8 |
122 | #define DMI_IPMI_ACCESS 0x10 |
123 | #define DMI_IPMI_IRQ 0x11 |
124 | #define DMI_IPMI_IO_MASK 0xfffe |
125 | |
126 | static void __init dmi_decode_ipmi(const struct dmi_header *dm) |
127 | { |
128 | const u8 *data = (const u8 *) dm; |
129 | int space = IPMI_IO_ADDR_SPACE; |
130 | unsigned long base_addr; |
131 | u8 len = dm->length; |
132 | u8 slave_addr; |
133 | int irq = 0, offset = 0; |
134 | int type; |
135 | |
136 | if (len < DMI_IPMI_MIN_LENGTH) |
137 | return; |
138 | |
139 | type = data[DMI_IPMI_TYPE]; |
140 | slave_addr = data[DMI_IPMI_SLAVEADDR]; |
141 | |
142 | memcpy(&base_addr, data + DMI_IPMI_ADDR, sizeof(unsigned long)); |
143 | if (!base_addr) { |
144 | pr_err("Base address is zero, assuming no IPMI interface\n" ); |
145 | return; |
146 | } |
147 | if (len >= DMI_IPMI_VER2_LENGTH) { |
148 | if (type == IPMI_DMI_TYPE_SSIF) { |
149 | space = 0; /* Match I2C interface 0. */ |
150 | base_addr = data[DMI_IPMI_ADDR] >> 1; |
151 | if (base_addr == 0) { |
152 | /* |
153 | * Some broken systems put the I2C address in |
154 | * the slave address field. We try to |
155 | * accommodate them here. |
156 | */ |
157 | base_addr = data[DMI_IPMI_SLAVEADDR] >> 1; |
158 | slave_addr = 0; |
159 | } |
160 | } else { |
161 | if (base_addr & 1) { |
162 | /* I/O */ |
163 | base_addr &= DMI_IPMI_IO_MASK; |
164 | } else { |
165 | /* Memory */ |
166 | space = IPMI_MEM_ADDR_SPACE; |
167 | } |
168 | |
169 | /* |
170 | * If bit 4 of byte 0x10 is set, then the lsb |
171 | * for the address is odd. |
172 | */ |
173 | base_addr |= (data[DMI_IPMI_ACCESS] >> 4) & 1; |
174 | |
175 | irq = data[DMI_IPMI_IRQ]; |
176 | |
177 | /* |
178 | * The top two bits of byte 0x10 hold the |
179 | * register spacing. |
180 | */ |
181 | switch ((data[DMI_IPMI_ACCESS] >> 6) & 3) { |
182 | case 0: /* Byte boundaries */ |
183 | offset = 1; |
184 | break; |
185 | case 1: /* 32-bit boundaries */ |
186 | offset = 4; |
187 | break; |
188 | case 2: /* 16-byte boundaries */ |
189 | offset = 16; |
190 | break; |
191 | default: |
192 | pr_err("Invalid offset: 0\n" ); |
193 | return; |
194 | } |
195 | } |
196 | } else { |
197 | /* Old DMI spec. */ |
198 | /* |
199 | * Note that technically, the lower bit of the base |
200 | * address should be 1 if the address is I/O and 0 if |
201 | * the address is in memory. So many systems get that |
202 | * wrong (and all that I have seen are I/O) so we just |
203 | * ignore that bit and assume I/O. Systems that use |
204 | * memory should use the newer spec, anyway. |
205 | */ |
206 | base_addr = base_addr & DMI_IPMI_IO_MASK; |
207 | offset = 1; |
208 | } |
209 | |
210 | dmi_add_platform_ipmi(base_addr, space, slave_addr, irq, |
211 | offset, type); |
212 | } |
213 | |
214 | static int __init scan_for_dmi_ipmi(void) |
215 | { |
216 | const struct dmi_device *dev = NULL; |
217 | |
218 | while ((dev = dmi_find_device(type: DMI_DEV_TYPE_IPMI, NULL, from: dev))) |
219 | dmi_decode_ipmi(dm: (const struct dmi_header *) dev->device_data); |
220 | |
221 | return 0; |
222 | } |
223 | subsys_initcall(scan_for_dmi_ipmi); |
224 | |