1
2
3
4
5
6
7
8
9#define pr_fmt(fmt) "ipmi_platform: " fmt
10#define dev_fmt pr_fmt
11
12#include <linux/types.h>
13#include <linux/module.h>
14#include <linux/of_device.h>
15#include <linux/of_platform.h>
16#include <linux/of_address.h>
17#include <linux/of_irq.h>
18#include <linux/acpi.h>
19#include "ipmi_si.h"
20#include "ipmi_dmi.h"
21
22static bool platform_registered;
23static bool si_tryplatform = true;
24#ifdef CONFIG_ACPI
25static bool si_tryacpi = true;
26#endif
27#ifdef CONFIG_OF
28static bool si_tryopenfirmware = true;
29#endif
30#ifdef CONFIG_DMI
31static bool si_trydmi = true;
32#else
33static bool si_trydmi = false;
34#endif
35
36module_param_named(tryplatform, si_tryplatform, bool, 0);
37MODULE_PARM_DESC(tryplatform,
38 "Setting this to zero will disable the default scan of the interfaces identified via platform interfaces besides ACPI, OpenFirmware, and DMI");
39#ifdef CONFIG_ACPI
40module_param_named(tryacpi, si_tryacpi, bool, 0);
41MODULE_PARM_DESC(tryacpi,
42 "Setting this to zero will disable the default scan of the interfaces identified via ACPI");
43#endif
44#ifdef CONFIG_OF
45module_param_named(tryopenfirmware, si_tryopenfirmware, bool, 0);
46MODULE_PARM_DESC(tryopenfirmware,
47 "Setting this to zero will disable the default scan of the interfaces identified via OpenFirmware");
48#endif
49#ifdef CONFIG_DMI
50module_param_named(trydmi, si_trydmi, bool, 0);
51MODULE_PARM_DESC(trydmi,
52 "Setting this to zero will disable the default scan of the interfaces identified via DMI");
53#endif
54
55#ifdef CONFIG_ACPI
56
57static u32 ipmi_acpi_gpe(acpi_handle gpe_device,
58 u32 gpe_number, void *context)
59{
60 struct si_sm_io *io = context;
61
62 ipmi_si_irq_handler(io->irq, io->irq_handler_data);
63 return ACPI_INTERRUPT_HANDLED;
64}
65
66static void acpi_gpe_irq_cleanup(struct si_sm_io *io)
67{
68 if (!io->irq)
69 return;
70
71 ipmi_irq_start_cleanup(io);
72 acpi_remove_gpe_handler(NULL, io->irq, &ipmi_acpi_gpe);
73}
74
75static int acpi_gpe_irq_setup(struct si_sm_io *io)
76{
77 acpi_status status;
78
79 if (!io->irq)
80 return 0;
81
82 status = acpi_install_gpe_handler(NULL,
83 io->irq,
84 ACPI_GPE_LEVEL_TRIGGERED,
85 &ipmi_acpi_gpe,
86 io);
87 if (ACPI_FAILURE(status)) {
88 dev_warn(io->dev,
89 "Unable to claim ACPI GPE %d, running polled\n",
90 io->irq);
91 io->irq = 0;
92 return -EINVAL;
93 }
94
95 io->irq_cleanup = acpi_gpe_irq_cleanup;
96 ipmi_irq_finish_setup(io);
97 dev_info(io->dev, "Using ACPI GPE %d\n", io->irq);
98 return 0;
99}
100#endif
101
102static void ipmi_set_addr_data_and_space(struct resource *r, struct si_sm_io *io)
103{
104 if (resource_type(r) == IORESOURCE_IO)
105 io->addr_space = IPMI_IO_ADDR_SPACE;
106 else
107 io->addr_space = IPMI_MEM_ADDR_SPACE;
108 io->addr_data = r->start;
109}
110
111static struct resource *
112ipmi_get_info_from_resources(struct platform_device *pdev,
113 struct si_sm_io *io)
114{
115 struct resource *res, *res_second;
116
117 res = platform_get_mem_or_io(pdev, 0);
118 if (!res) {
119 dev_err(&pdev->dev, "no I/O or memory address\n");
120 return NULL;
121 }
122 ipmi_set_addr_data_and_space(res, io);
123
124 io->regspacing = DEFAULT_REGSPACING;
125 res_second = platform_get_mem_or_io(pdev, 1);
126 if (res_second && resource_type(res_second) == resource_type(res)) {
127 if (res_second->start > io->addr_data)
128 io->regspacing = res_second->start - io->addr_data;
129 }
130
131 return res;
132}
133
134static int platform_ipmi_probe(struct platform_device *pdev)
135{
136 struct si_sm_io io;
137 u8 type, slave_addr, addr_source, regsize, regshift;
138 int rv;
139
140 rv = device_property_read_u8(&pdev->dev, "addr-source", &addr_source);
141 if (rv)
142 addr_source = SI_PLATFORM;
143 if (addr_source >= SI_LAST)
144 return -EINVAL;
145
146 if (addr_source == SI_SMBIOS) {
147 if (!si_trydmi)
148 return -ENODEV;
149 } else if (addr_source != SI_HARDCODED) {
150 if (!si_tryplatform)
151 return -ENODEV;
152 }
153
154 rv = device_property_read_u8(&pdev->dev, "ipmi-type", &type);
155 if (rv)
156 return -ENODEV;
157
158 memset(&io, 0, sizeof(io));
159 io.addr_source = addr_source;
160 dev_info(&pdev->dev, "probing via %s\n",
161 ipmi_addr_src_to_str(addr_source));
162
163 switch (type) {
164 case SI_KCS:
165 case SI_SMIC:
166 case SI_BT:
167 io.si_type = type;
168 break;
169 case SI_TYPE_INVALID:
170 return -ENODEV;
171 default:
172 dev_err(&pdev->dev, "ipmi-type property is invalid\n");
173 return -EINVAL;
174 }
175
176 io.regsize = DEFAULT_REGSIZE;
177 rv = device_property_read_u8(&pdev->dev, "reg-size", ®size);
178 if (!rv)
179 io.regsize = regsize;
180
181 io.regshift = 0;
182 rv = device_property_read_u8(&pdev->dev, "reg-shift", ®shift);
183 if (!rv)
184 io.regshift = regshift;
185
186 if (!ipmi_get_info_from_resources(pdev, &io))
187 return -EINVAL;
188
189 rv = device_property_read_u8(&pdev->dev, "slave-addr", &slave_addr);
190 if (rv)
191 io.slave_addr = 0x20;
192 else
193 io.slave_addr = slave_addr;
194
195 io.irq = platform_get_irq_optional(pdev, 0);
196 if (io.irq > 0)
197 io.irq_setup = ipmi_std_irq_setup;
198 else
199 io.irq = 0;
200
201 io.dev = &pdev->dev;
202
203 pr_info("ipmi_si: %s: %s %#lx regsize %d spacing %d irq %d\n",
204 ipmi_addr_src_to_str(addr_source),
205 (io.addr_space == IPMI_IO_ADDR_SPACE) ? "io" : "mem",
206 io.addr_data, io.regsize, io.regspacing, io.irq);
207
208 ipmi_si_add_smi(&io);
209
210 return 0;
211}
212
213#ifdef CONFIG_OF
214static const struct of_device_id of_ipmi_match[] = {
215 { .type = "ipmi", .compatible = "ipmi-kcs",
216 .data = (void *)(unsigned long) SI_KCS },
217 { .type = "ipmi", .compatible = "ipmi-smic",
218 .data = (void *)(unsigned long) SI_SMIC },
219 { .type = "ipmi", .compatible = "ipmi-bt",
220 .data = (void *)(unsigned long) SI_BT },
221 {},
222};
223MODULE_DEVICE_TABLE(of, of_ipmi_match);
224
225static int of_ipmi_probe(struct platform_device *pdev)
226{
227 const struct of_device_id *match;
228 struct si_sm_io io;
229 struct resource resource;
230 const __be32 *regsize, *regspacing, *regshift;
231 struct device_node *np = pdev->dev.of_node;
232 int ret;
233 int proplen;
234
235 if (!si_tryopenfirmware)
236 return -ENODEV;
237
238 dev_info(&pdev->dev, "probing via device tree\n");
239
240 match = of_match_device(of_ipmi_match, &pdev->dev);
241 if (!match)
242 return -ENODEV;
243
244 if (!of_device_is_available(np))
245 return -EINVAL;
246
247 ret = of_address_to_resource(np, 0, &resource);
248 if (ret) {
249 dev_warn(&pdev->dev, "invalid address from OF\n");
250 return ret;
251 }
252
253 regsize = of_get_property(np, "reg-size", &proplen);
254 if (regsize && proplen != 4) {
255 dev_warn(&pdev->dev, "invalid regsize from OF\n");
256 return -EINVAL;
257 }
258
259 regspacing = of_get_property(np, "reg-spacing", &proplen);
260 if (regspacing && proplen != 4) {
261 dev_warn(&pdev->dev, "invalid regspacing from OF\n");
262 return -EINVAL;
263 }
264
265 regshift = of_get_property(np, "reg-shift", &proplen);
266 if (regshift && proplen != 4) {
267 dev_warn(&pdev->dev, "invalid regshift from OF\n");
268 return -EINVAL;
269 }
270
271 memset(&io, 0, sizeof(io));
272 io.si_type = (enum si_type) match->data;
273 io.addr_source = SI_DEVICETREE;
274 io.irq_setup = ipmi_std_irq_setup;
275
276 ipmi_set_addr_data_and_space(&resource, &io);
277
278 io.regsize = regsize ? be32_to_cpup(regsize) : DEFAULT_REGSIZE;
279 io.regspacing = regspacing ? be32_to_cpup(regspacing) : DEFAULT_REGSPACING;
280 io.regshift = regshift ? be32_to_cpup(regshift) : 0;
281
282 io.irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
283 io.dev = &pdev->dev;
284
285 dev_dbg(&pdev->dev, "addr 0x%lx regsize %d spacing %d irq %d\n",
286 io.addr_data, io.regsize, io.regspacing, io.irq);
287
288 return ipmi_si_add_smi(&io);
289}
290#else
291#define of_ipmi_match NULL
292static int of_ipmi_probe(struct platform_device *dev)
293{
294 return -ENODEV;
295}
296#endif
297
298#ifdef CONFIG_ACPI
299static int find_slave_address(struct si_sm_io *io, int slave_addr)
300{
301#ifdef CONFIG_IPMI_DMI_DECODE
302 if (!slave_addr)
303 slave_addr = ipmi_dmi_get_slave_addr(io->si_type,
304 io->addr_space,
305 io->addr_data);
306#endif
307
308 return slave_addr;
309}
310
311static int acpi_ipmi_probe(struct platform_device *pdev)
312{
313 struct device *dev = &pdev->dev;
314 struct si_sm_io io;
315 acpi_handle handle;
316 acpi_status status;
317 unsigned long long tmp;
318 struct resource *res;
319
320 if (!si_tryacpi)
321 return -ENODEV;
322
323 handle = ACPI_HANDLE(dev);
324 if (!handle)
325 return -ENODEV;
326
327 memset(&io, 0, sizeof(io));
328 io.addr_source = SI_ACPI;
329 dev_info(dev, "probing via ACPI\n");
330
331 io.addr_info.acpi_info.acpi_handle = handle;
332
333
334 status = acpi_evaluate_integer(handle, "_IFT", NULL, &tmp);
335 if (ACPI_FAILURE(status)) {
336 dev_err(dev, "Could not find ACPI IPMI interface type\n");
337 return -EINVAL;
338 }
339
340 switch (tmp) {
341 case 1:
342 io.si_type = SI_KCS;
343 break;
344 case 2:
345 io.si_type = SI_SMIC;
346 break;
347 case 3:
348 io.si_type = SI_BT;
349 break;
350 case 4:
351 return -ENODEV;
352 default:
353 dev_info(dev, "unknown IPMI type %lld\n", tmp);
354 return -EINVAL;
355 }
356
357 io.dev = dev;
358 io.regsize = DEFAULT_REGSIZE;
359 io.regshift = 0;
360
361 res = ipmi_get_info_from_resources(pdev, &io);
362 if (!res)
363 return -EINVAL;
364
365
366 status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
367 if (ACPI_SUCCESS(status)) {
368 io.irq = tmp;
369 io.irq_setup = acpi_gpe_irq_setup;
370 } else {
371 int irq = platform_get_irq_optional(pdev, 0);
372
373 if (irq > 0) {
374 io.irq = irq;
375 io.irq_setup = ipmi_std_irq_setup;
376 }
377 }
378
379 io.slave_addr = find_slave_address(&io, io.slave_addr);
380
381 dev_info(dev, "%pR regsize %d spacing %d irq %d\n",
382 res, io.regsize, io.regspacing, io.irq);
383
384 request_module("acpi_ipmi");
385
386 return ipmi_si_add_smi(&io);
387}
388
389static const struct acpi_device_id acpi_ipmi_match[] = {
390 { "IPI0001", 0 },
391 { },
392};
393MODULE_DEVICE_TABLE(acpi, acpi_ipmi_match);
394#else
395static int acpi_ipmi_probe(struct platform_device *dev)
396{
397 return -ENODEV;
398}
399#endif
400
401static int ipmi_probe(struct platform_device *pdev)
402{
403 if (pdev->dev.of_node && of_ipmi_probe(pdev) == 0)
404 return 0;
405
406 if (acpi_ipmi_probe(pdev) == 0)
407 return 0;
408
409 return platform_ipmi_probe(pdev);
410}
411
412static int ipmi_remove(struct platform_device *pdev)
413{
414 ipmi_si_remove_by_dev(&pdev->dev);
415
416 return 0;
417}
418
419static int pdev_match_name(struct device *dev, const void *data)
420{
421 struct platform_device *pdev = to_platform_device(dev);
422 const char *name = data;
423
424 return strcmp(pdev->name, name) == 0;
425}
426
427void ipmi_remove_platform_device_by_name(char *name)
428{
429 struct device *dev;
430
431 while ((dev = bus_find_device(&platform_bus_type, NULL, name,
432 pdev_match_name))) {
433 struct platform_device *pdev = to_platform_device(dev);
434
435 platform_device_unregister(pdev);
436 put_device(dev);
437 }
438}
439
440static const struct platform_device_id si_plat_ids[] = {
441 { "dmi-ipmi-si", 0 },
442 { "hardcode-ipmi-si", 0 },
443 { "hotmod-ipmi-si", 0 },
444 { }
445};
446
447struct platform_driver ipmi_platform_driver = {
448 .driver = {
449 .name = SI_DEVICE_NAME,
450 .of_match_table = of_ipmi_match,
451 .acpi_match_table = ACPI_PTR(acpi_ipmi_match),
452 },
453 .probe = ipmi_probe,
454 .remove = ipmi_remove,
455 .id_table = si_plat_ids
456};
457
458void ipmi_si_platform_init(void)
459{
460 int rv = platform_driver_register(&ipmi_platform_driver);
461 if (rv)
462 pr_err("Unable to register driver: %d\n", rv);
463 else
464 platform_registered = true;
465}
466
467void ipmi_si_platform_shutdown(void)
468{
469 if (platform_registered)
470 platform_driver_unregister(&ipmi_platform_driver);
471}
472
