Commit | Line | Data |
---|---|---|
adf38bb0 ZY |
1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* | |
3 | * Copyright (C) 2017 Hisilicon Limited, All Rights Reserved. | |
4 | * Author: Zhichang Yuan <yuanzhichang@hisilicon.com> | |
5 | * Author: Zou Rongrong <zourongrong@huawei.com> | |
6 | * Author: John Garry <john.garry@huawei.com> | |
7 | */ | |
8 | ||
9 | #include <linux/acpi.h> | |
10 | #include <linux/console.h> | |
11 | #include <linux/delay.h> | |
12 | #include <linux/io.h> | |
13 | #include <linux/logic_pio.h> | |
14 | #include <linux/module.h> | |
15 | #include <linux/of.h> | |
16 | #include <linux/of_address.h> | |
17 | #include <linux/of_platform.h> | |
18 | #include <linux/pci.h> | |
adf3457b | 19 | #include <linux/serial_8250.h> |
adf38bb0 ZY |
20 | #include <linux/slab.h> |
21 | ||
22 | #define DRV_NAME "hisi-lpc" | |
23 | ||
24 | /* | |
25 | * Setting this bit means each IO operation will target a different port | |
26 | * address; 0 means repeated IO operations will use the same port, | |
27 | * such as BT. | |
28 | */ | |
29 | #define FG_INCRADDR_LPC 0x02 | |
30 | ||
31 | struct lpc_cycle_para { | |
32 | unsigned int opflags; | |
33 | unsigned int csize; /* data length of each operation */ | |
34 | }; | |
35 | ||
36 | struct hisi_lpc_dev { | |
37 | spinlock_t cycle_lock; | |
38 | void __iomem *membase; | |
39 | struct logic_pio_hwaddr *io_host; | |
40 | }; | |
41 | ||
42 | /* The max IO cycle counts supported is four per operation at maximum */ | |
43 | #define LPC_MAX_DWIDTH 4 | |
44 | ||
45 | #define LPC_REG_STARTUP_SIGNAL 0x00 | |
46 | #define LPC_REG_STARTUP_SIGNAL_START BIT(0) | |
47 | #define LPC_REG_OP_STATUS 0x04 | |
48 | #define LPC_REG_OP_STATUS_IDLE BIT(0) | |
49 | #define LPC_REG_OP_STATUS_FINISHED BIT(1) | |
50 | #define LPC_REG_OP_LEN 0x10 /* LPC cycles count per start */ | |
51 | #define LPC_REG_CMD 0x14 | |
52 | #define LPC_REG_CMD_OP BIT(0) /* 0: read, 1: write */ | |
53 | #define LPC_REG_CMD_SAMEADDR BIT(3) | |
54 | #define LPC_REG_ADDR 0x20 /* target address */ | |
55 | #define LPC_REG_WDATA 0x24 /* write FIFO */ | |
56 | #define LPC_REG_RDATA 0x28 /* read FIFO */ | |
57 | ||
58 | /* The minimal nanosecond interval for each query on LPC cycle status */ | |
59 | #define LPC_NSEC_PERWAIT 100 | |
60 | ||
61 | /* | |
62 | * The maximum waiting time is about 128us. It is specific for stream I/O, | |
63 | * such as ins. | |
64 | * | |
65 | * The fastest IO cycle time is about 390ns, but the worst case will wait | |
66 | * for extra 256 lpc clocks, so (256 + 13) * 30ns = 8 us. The maximum burst | |
67 | * cycles is 16. So, the maximum waiting time is about 128us under worst | |
68 | * case. | |
69 | * | |
70 | * Choose 1300 as the maximum. | |
71 | */ | |
72 | #define LPC_MAX_WAITCNT 1300 | |
73 | ||
74 | /* About 10us. This is specific for single IO operations, such as inb */ | |
75 | #define LPC_PEROP_WAITCNT 100 | |
76 | ||
663accf1 | 77 | static int wait_lpc_idle(void __iomem *mbase, unsigned int waitcnt) |
adf38bb0 ZY |
78 | { |
79 | u32 status; | |
80 | ||
81 | do { | |
82 | status = readl(mbase + LPC_REG_OP_STATUS); | |
83 | if (status & LPC_REG_OP_STATUS_IDLE) | |
84 | return (status & LPC_REG_OP_STATUS_FINISHED) ? 0 : -EIO; | |
85 | ndelay(LPC_NSEC_PERWAIT); | |
86 | } while (--waitcnt); | |
87 | ||
88 | return -ETIME; | |
89 | } | |
90 | ||
91 | /* | |
92 | * hisi_lpc_target_in - trigger a series of LPC cycles for read operation | |
93 | * @lpcdev: pointer to hisi lpc device | |
94 | * @para: some parameters used to control the lpc I/O operations | |
95 | * @addr: the lpc I/O target port address | |
96 | * @buf: where the read back data is stored | |
97 | * @opcnt: how many I/O operations required, i.e. data width | |
98 | * | |
99 | * Returns 0 on success, non-zero on fail. | |
100 | */ | |
101 | static int hisi_lpc_target_in(struct hisi_lpc_dev *lpcdev, | |
102 | struct lpc_cycle_para *para, unsigned long addr, | |
103 | unsigned char *buf, unsigned long opcnt) | |
104 | { | |
105 | unsigned int cmd_word; | |
106 | unsigned int waitcnt; | |
107 | unsigned long flags; | |
108 | int ret; | |
109 | ||
110 | if (!buf || !opcnt || !para || !para->csize || !lpcdev) | |
111 | return -EINVAL; | |
112 | ||
113 | cmd_word = 0; /* IO mode, Read */ | |
114 | waitcnt = LPC_PEROP_WAITCNT; | |
115 | if (!(para->opflags & FG_INCRADDR_LPC)) { | |
116 | cmd_word |= LPC_REG_CMD_SAMEADDR; | |
117 | waitcnt = LPC_MAX_WAITCNT; | |
118 | } | |
119 | ||
120 | /* whole operation must be atomic */ | |
121 | spin_lock_irqsave(&lpcdev->cycle_lock, flags); | |
122 | ||
123 | writel_relaxed(opcnt, lpcdev->membase + LPC_REG_OP_LEN); | |
124 | writel_relaxed(cmd_word, lpcdev->membase + LPC_REG_CMD); | |
125 | writel_relaxed(addr, lpcdev->membase + LPC_REG_ADDR); | |
126 | ||
127 | writel(LPC_REG_STARTUP_SIGNAL_START, | |
128 | lpcdev->membase + LPC_REG_STARTUP_SIGNAL); | |
129 | ||
130 | /* whether the operation is finished */ | |
131 | ret = wait_lpc_idle(lpcdev->membase, waitcnt); | |
132 | if (ret) { | |
133 | spin_unlock_irqrestore(&lpcdev->cycle_lock, flags); | |
134 | return ret; | |
135 | } | |
136 | ||
137 | readsb(lpcdev->membase + LPC_REG_RDATA, buf, opcnt); | |
138 | ||
139 | spin_unlock_irqrestore(&lpcdev->cycle_lock, flags); | |
140 | ||
141 | return 0; | |
142 | } | |
143 | ||
144 | /* | |
145 | * hisi_lpc_target_out - trigger a series of LPC cycles for write operation | |
146 | * @lpcdev: pointer to hisi lpc device | |
147 | * @para: some parameters used to control the lpc I/O operations | |
148 | * @addr: the lpc I/O target port address | |
149 | * @buf: where the data to be written is stored | |
150 | * @opcnt: how many I/O operations required, i.e. data width | |
151 | * | |
152 | * Returns 0 on success, non-zero on fail. | |
153 | */ | |
154 | static int hisi_lpc_target_out(struct hisi_lpc_dev *lpcdev, | |
155 | struct lpc_cycle_para *para, unsigned long addr, | |
156 | const unsigned char *buf, unsigned long opcnt) | |
157 | { | |
158 | unsigned int waitcnt; | |
159 | unsigned long flags; | |
160 | u32 cmd_word; | |
161 | int ret; | |
162 | ||
163 | if (!buf || !opcnt || !para || !lpcdev) | |
164 | return -EINVAL; | |
165 | ||
166 | /* default is increasing address */ | |
167 | cmd_word = LPC_REG_CMD_OP; /* IO mode, write */ | |
168 | waitcnt = LPC_PEROP_WAITCNT; | |
169 | if (!(para->opflags & FG_INCRADDR_LPC)) { | |
170 | cmd_word |= LPC_REG_CMD_SAMEADDR; | |
171 | waitcnt = LPC_MAX_WAITCNT; | |
172 | } | |
173 | ||
174 | spin_lock_irqsave(&lpcdev->cycle_lock, flags); | |
175 | ||
176 | writel_relaxed(opcnt, lpcdev->membase + LPC_REG_OP_LEN); | |
177 | writel_relaxed(cmd_word, lpcdev->membase + LPC_REG_CMD); | |
178 | writel_relaxed(addr, lpcdev->membase + LPC_REG_ADDR); | |
179 | ||
180 | writesb(lpcdev->membase + LPC_REG_WDATA, buf, opcnt); | |
181 | ||
182 | writel(LPC_REG_STARTUP_SIGNAL_START, | |
183 | lpcdev->membase + LPC_REG_STARTUP_SIGNAL); | |
184 | ||
185 | /* whether the operation is finished */ | |
186 | ret = wait_lpc_idle(lpcdev->membase, waitcnt); | |
187 | ||
188 | spin_unlock_irqrestore(&lpcdev->cycle_lock, flags); | |
189 | ||
190 | return ret; | |
191 | } | |
192 | ||
193 | static unsigned long hisi_lpc_pio_to_addr(struct hisi_lpc_dev *lpcdev, | |
194 | unsigned long pio) | |
195 | { | |
196 | return pio - lpcdev->io_host->io_start + lpcdev->io_host->hw_start; | |
197 | } | |
198 | ||
199 | /* | |
200 | * hisi_lpc_comm_in - input the data in a single operation | |
201 | * @hostdata: pointer to the device information relevant to LPC controller | |
202 | * @pio: the target I/O port address | |
203 | * @dwidth: the data length required to read from the target I/O port | |
204 | * | |
205 | * When success, data is returned. Otherwise, ~0 is returned. | |
206 | */ | |
207 | static u32 hisi_lpc_comm_in(void *hostdata, unsigned long pio, size_t dwidth) | |
208 | { | |
209 | struct hisi_lpc_dev *lpcdev = hostdata; | |
210 | struct lpc_cycle_para iopara; | |
211 | unsigned long addr; | |
663accf1 | 212 | __le32 rd_data = 0; |
adf38bb0 ZY |
213 | int ret; |
214 | ||
215 | if (!lpcdev || !dwidth || dwidth > LPC_MAX_DWIDTH) | |
216 | return ~0; | |
217 | ||
218 | addr = hisi_lpc_pio_to_addr(lpcdev, pio); | |
219 | ||
220 | iopara.opflags = FG_INCRADDR_LPC; | |
221 | iopara.csize = dwidth; | |
222 | ||
223 | ret = hisi_lpc_target_in(lpcdev, &iopara, addr, | |
224 | (unsigned char *)&rd_data, dwidth); | |
225 | if (ret) | |
226 | return ~0; | |
227 | ||
228 | return le32_to_cpu(rd_data); | |
229 | } | |
230 | ||
231 | /* | |
232 | * hisi_lpc_comm_out - output the data in a single operation | |
233 | * @hostdata: pointer to the device information relevant to LPC controller | |
234 | * @pio: the target I/O port address | |
235 | * @val: a value to be output from caller, maximum is four bytes | |
236 | * @dwidth: the data width required writing to the target I/O port | |
237 | * | |
238 | * This function corresponds to out(b,w,l) only. | |
239 | */ | |
240 | static void hisi_lpc_comm_out(void *hostdata, unsigned long pio, | |
241 | u32 val, size_t dwidth) | |
242 | { | |
243 | struct hisi_lpc_dev *lpcdev = hostdata; | |
244 | struct lpc_cycle_para iopara; | |
245 | const unsigned char *buf; | |
246 | unsigned long addr; | |
663accf1 | 247 | __le32 _val = cpu_to_le32(val); |
adf38bb0 ZY |
248 | |
249 | if (!lpcdev || !dwidth || dwidth > LPC_MAX_DWIDTH) | |
250 | return; | |
251 | ||
663accf1 | 252 | buf = (const unsigned char *)&_val; |
adf38bb0 ZY |
253 | addr = hisi_lpc_pio_to_addr(lpcdev, pio); |
254 | ||
255 | iopara.opflags = FG_INCRADDR_LPC; | |
256 | iopara.csize = dwidth; | |
257 | ||
258 | hisi_lpc_target_out(lpcdev, &iopara, addr, buf, dwidth); | |
259 | } | |
260 | ||
261 | /* | |
262 | * hisi_lpc_comm_ins - input the data in the buffer in multiple operations | |
263 | * @hostdata: pointer to the device information relevant to LPC controller | |
264 | * @pio: the target I/O port address | |
265 | * @buffer: a buffer where read/input data bytes are stored | |
266 | * @dwidth: the data width required writing to the target I/O port | |
267 | * @count: how many data units whose length is dwidth will be read | |
268 | * | |
269 | * When success, the data read back is stored in buffer pointed by buffer. | |
270 | * Returns 0 on success, -errno otherwise. | |
271 | */ | |
272 | static u32 hisi_lpc_comm_ins(void *hostdata, unsigned long pio, void *buffer, | |
273 | size_t dwidth, unsigned int count) | |
274 | { | |
275 | struct hisi_lpc_dev *lpcdev = hostdata; | |
276 | unsigned char *buf = buffer; | |
277 | struct lpc_cycle_para iopara; | |
278 | unsigned long addr; | |
279 | ||
280 | if (!lpcdev || !buf || !count || !dwidth || dwidth > LPC_MAX_DWIDTH) | |
281 | return -EINVAL; | |
282 | ||
283 | iopara.opflags = 0; | |
284 | if (dwidth > 1) | |
285 | iopara.opflags |= FG_INCRADDR_LPC; | |
286 | iopara.csize = dwidth; | |
287 | ||
288 | addr = hisi_lpc_pio_to_addr(lpcdev, pio); | |
289 | ||
290 | do { | |
291 | int ret; | |
292 | ||
293 | ret = hisi_lpc_target_in(lpcdev, &iopara, addr, buf, dwidth); | |
294 | if (ret) | |
295 | return ret; | |
296 | buf += dwidth; | |
297 | } while (--count); | |
298 | ||
299 | return 0; | |
300 | } | |
301 | ||
302 | /* | |
303 | * hisi_lpc_comm_outs - output the data in the buffer in multiple operations | |
304 | * @hostdata: pointer to the device information relevant to LPC controller | |
305 | * @pio: the target I/O port address | |
306 | * @buffer: a buffer where write/output data bytes are stored | |
307 | * @dwidth: the data width required writing to the target I/O port | |
308 | * @count: how many data units whose length is dwidth will be written | |
309 | */ | |
310 | static void hisi_lpc_comm_outs(void *hostdata, unsigned long pio, | |
311 | const void *buffer, size_t dwidth, | |
312 | unsigned int count) | |
313 | { | |
314 | struct hisi_lpc_dev *lpcdev = hostdata; | |
315 | struct lpc_cycle_para iopara; | |
316 | const unsigned char *buf = buffer; | |
317 | unsigned long addr; | |
318 | ||
319 | if (!lpcdev || !buf || !count || !dwidth || dwidth > LPC_MAX_DWIDTH) | |
320 | return; | |
321 | ||
322 | iopara.opflags = 0; | |
323 | if (dwidth > 1) | |
324 | iopara.opflags |= FG_INCRADDR_LPC; | |
325 | iopara.csize = dwidth; | |
326 | ||
327 | addr = hisi_lpc_pio_to_addr(lpcdev, pio); | |
328 | do { | |
329 | if (hisi_lpc_target_out(lpcdev, &iopara, addr, buf, dwidth)) | |
330 | break; | |
331 | buf += dwidth; | |
332 | } while (--count); | |
333 | } | |
334 | ||
335 | static const struct logic_pio_host_ops hisi_lpc_ops = { | |
336 | .in = hisi_lpc_comm_in, | |
337 | .out = hisi_lpc_comm_out, | |
338 | .ins = hisi_lpc_comm_ins, | |
339 | .outs = hisi_lpc_comm_outs, | |
340 | }; | |
341 | ||
e0aa1563 | 342 | #ifdef CONFIG_ACPI |
e0aa1563 JG |
343 | static int hisi_lpc_acpi_xlat_io_res(struct acpi_device *adev, |
344 | struct acpi_device *host, | |
345 | struct resource *res) | |
346 | { | |
347 | unsigned long sys_port; | |
348 | resource_size_t len = resource_size(res); | |
349 | ||
350 | sys_port = logic_pio_trans_hwaddr(&host->fwnode, res->start, len); | |
351 | if (sys_port == ~0UL) | |
352 | return -EFAULT; | |
353 | ||
354 | res->start = sys_port; | |
355 | res->end = sys_port + len; | |
356 | ||
357 | return 0; | |
358 | } | |
359 | ||
a6dd255b JG |
360 | /* |
361 | * Released firmware describes the IO port max address as 0x3fff, which is | |
362 | * the max host bus address. Fixup to a proper range. This will probably | |
363 | * never be fixed in firmware. | |
364 | */ | |
365 | static void hisi_lpc_acpi_fixup_child_resource(struct device *hostdev, | |
366 | struct resource *r) | |
367 | { | |
368 | if (r->end != 0x3fff) | |
369 | return; | |
370 | ||
371 | if (r->start == 0xe4) | |
372 | r->end = 0xe4 + 0x04 - 1; | |
373 | else if (r->start == 0x2f8) | |
374 | r->end = 0x2f8 + 0x08 - 1; | |
375 | else | |
376 | dev_warn(hostdev, "unrecognised resource %pR to fixup, ignoring\n", | |
377 | r); | |
378 | } | |
379 | ||
e0aa1563 | 380 | /* |
332f632e | 381 | * hisi_lpc_acpi_set_io_res - set the resources for a child |
e0aa1563 JG |
382 | * @child: the device node to be updated the I/O resource |
383 | * @hostdev: the device node associated with host controller | |
384 | * @res: double pointer to be set to the address of translated resources | |
385 | * @num_res: pointer to variable to hold the number of translated resources | |
386 | * | |
387 | * Returns 0 when successful, and a negative value for failure. | |
388 | * | |
389 | * For a given host controller, each child device will have an associated | |
390 | * host-relative address resource. This function will return the translated | |
391 | * logical PIO addresses for each child devices resources. | |
392 | */ | |
393 | static int hisi_lpc_acpi_set_io_res(struct device *child, | |
394 | struct device *hostdev, | |
395 | const struct resource **res, int *num_res) | |
396 | { | |
397 | struct acpi_device *adev; | |
398 | struct acpi_device *host; | |
399 | struct resource_entry *rentry; | |
400 | LIST_HEAD(resource_list); | |
401 | struct resource *resources; | |
402 | int count; | |
403 | int i; | |
404 | ||
405 | if (!child || !hostdev) | |
406 | return -EINVAL; | |
407 | ||
408 | host = to_acpi_device(hostdev); | |
409 | adev = to_acpi_device(child); | |
410 | ||
411 | if (!adev->status.present) { | |
412 | dev_dbg(child, "device is not present\n"); | |
413 | return -EIO; | |
414 | } | |
415 | ||
416 | if (acpi_device_enumerated(adev)) { | |
417 | dev_dbg(child, "has been enumerated\n"); | |
418 | return -EIO; | |
419 | } | |
420 | ||
421 | /* | |
422 | * The following code segment to retrieve the resources is common to | |
423 | * acpi_create_platform_device(), so consider a common helper function | |
424 | * in future. | |
425 | */ | |
426 | count = acpi_dev_get_resources(adev, &resource_list, NULL, NULL); | |
427 | if (count <= 0) { | |
428 | dev_dbg(child, "failed to get resources\n"); | |
429 | return count ? count : -EIO; | |
430 | } | |
431 | ||
432 | resources = devm_kcalloc(hostdev, count, sizeof(*resources), | |
433 | GFP_KERNEL); | |
434 | if (!resources) { | |
435 | dev_warn(hostdev, "could not allocate memory for %d resources\n", | |
436 | count); | |
437 | acpi_dev_free_resource_list(&resource_list); | |
438 | return -ENOMEM; | |
439 | } | |
440 | count = 0; | |
a6dd255b JG |
441 | list_for_each_entry(rentry, &resource_list, node) { |
442 | resources[count] = *rentry->res; | |
443 | hisi_lpc_acpi_fixup_child_resource(hostdev, &resources[count]); | |
444 | count++; | |
445 | } | |
e0aa1563 JG |
446 | |
447 | acpi_dev_free_resource_list(&resource_list); | |
448 | ||
449 | /* translate the I/O resources */ | |
450 | for (i = 0; i < count; i++) { | |
451 | int ret; | |
452 | ||
453 | if (!(resources[i].flags & IORESOURCE_IO)) | |
454 | continue; | |
455 | ret = hisi_lpc_acpi_xlat_io_res(adev, host, &resources[i]); | |
456 | if (ret) { | |
457 | dev_err(child, "translate IO range %pR failed (%d)\n", | |
458 | &resources[i], ret); | |
459 | return ret; | |
460 | } | |
461 | } | |
462 | *res = resources; | |
463 | *num_res = count; | |
464 | ||
465 | return 0; | |
466 | } | |
467 | ||
99c0228d JG |
468 | static int hisi_lpc_acpi_remove_subdev(struct device *dev, void *unused) |
469 | { | |
470 | platform_device_unregister(to_platform_device(dev)); | |
471 | return 0; | |
472 | } | |
473 | ||
474 | struct hisi_lpc_acpi_cell { | |
475 | const char *hid; | |
476 | const char *name; | |
477 | void *pdata; | |
478 | size_t pdata_size; | |
479 | }; | |
480 | ||
10e62b47 JG |
481 | static void hisi_lpc_acpi_remove(struct device *hostdev) |
482 | { | |
483 | struct acpi_device *adev = ACPI_COMPANION(hostdev); | |
484 | struct acpi_device *child; | |
485 | ||
486 | device_for_each_child(hostdev, NULL, hisi_lpc_acpi_remove_subdev); | |
487 | ||
488 | list_for_each_entry(child, &adev->children, node) | |
489 | acpi_device_clear_enumerated(child); | |
490 | } | |
491 | ||
e0aa1563 JG |
492 | /* |
493 | * hisi_lpc_acpi_probe - probe children for ACPI FW | |
494 | * @hostdev: LPC host device pointer | |
495 | * | |
496 | * Returns 0 when successful, and a negative value for failure. | |
497 | * | |
99c0228d JG |
498 | * Create a platform device per child, fixing up the resources |
499 | * from bus addresses to Logical PIO addresses. | |
500 | * | |
e0aa1563 JG |
501 | */ |
502 | static int hisi_lpc_acpi_probe(struct device *hostdev) | |
503 | { | |
504 | struct acpi_device *adev = ACPI_COMPANION(hostdev); | |
e0aa1563 | 505 | struct acpi_device *child; |
332f632e | 506 | int ret; |
e0aa1563 | 507 | |
e0aa1563 JG |
508 | /* Only consider the children of the host */ |
509 | list_for_each_entry(child, &adev->children, node) { | |
99c0228d JG |
510 | const char *hid = acpi_device_hid(child); |
511 | const struct hisi_lpc_acpi_cell *cell; | |
512 | struct platform_device *pdev; | |
332f632e | 513 | const struct resource *res; |
99c0228d | 514 | bool found = false; |
332f632e JG |
515 | int num_res; |
516 | ||
517 | ret = hisi_lpc_acpi_set_io_res(&child->dev, &adev->dev, &res, | |
518 | &num_res); | |
e0aa1563 | 519 | if (ret) { |
332f632e | 520 | dev_warn(hostdev, "set resource fail (%d)\n", ret); |
99c0228d JG |
521 | goto fail; |
522 | } | |
523 | ||
524 | cell = (struct hisi_lpc_acpi_cell []){ | |
525 | /* ipmi */ | |
526 | { | |
527 | .hid = "IPI0001", | |
528 | .name = "hisi-lpc-ipmi", | |
529 | }, | |
adf3457b JG |
530 | /* 8250-compatible uart */ |
531 | { | |
532 | .hid = "HISI1031", | |
533 | .name = "serial8250", | |
534 | .pdata = (struct plat_serial8250_port []) { | |
535 | { | |
536 | .iobase = res->start, | |
537 | .uartclk = 1843200, | |
538 | .iotype = UPIO_PORT, | |
539 | .flags = UPF_BOOT_AUTOCONF, | |
540 | }, | |
541 | {} | |
542 | }, | |
543 | .pdata_size = 2 * | |
544 | sizeof(struct plat_serial8250_port), | |
545 | }, | |
99c0228d JG |
546 | {} |
547 | }; | |
548 | ||
549 | for (; cell && cell->name; cell++) { | |
550 | if (!strcmp(cell->hid, hid)) { | |
551 | found = true; | |
552 | break; | |
553 | } | |
e0aa1563 | 554 | } |
99c0228d JG |
555 | |
556 | if (!found) { | |
557 | dev_warn(hostdev, | |
705c0ee8 | 558 | "could not find cell for child device (%s), discarding\n", |
99c0228d | 559 | hid); |
705c0ee8 | 560 | continue; |
99c0228d JG |
561 | } |
562 | ||
563 | pdev = platform_device_alloc(cell->name, PLATFORM_DEVID_AUTO); | |
564 | if (!pdev) { | |
565 | ret = -ENOMEM; | |
566 | goto fail; | |
567 | } | |
568 | ||
569 | pdev->dev.parent = hostdev; | |
570 | ACPI_COMPANION_SET(&pdev->dev, child); | |
571 | ||
572 | ret = platform_device_add_resources(pdev, res, num_res); | |
573 | if (ret) | |
574 | goto fail; | |
575 | ||
576 | ret = platform_device_add_data(pdev, cell->pdata, | |
577 | cell->pdata_size); | |
578 | if (ret) | |
579 | goto fail; | |
580 | ||
581 | ret = platform_device_add(pdev); | |
582 | if (ret) | |
583 | goto fail; | |
584 | ||
585 | acpi_device_set_enumerated(child); | |
e0aa1563 JG |
586 | } |
587 | ||
588 | return 0; | |
99c0228d JG |
589 | |
590 | fail: | |
10e62b47 | 591 | hisi_lpc_acpi_remove(hostdev); |
99c0228d | 592 | return ret; |
e0aa1563 JG |
593 | } |
594 | ||
595 | static const struct acpi_device_id hisi_lpc_acpi_match[] = { | |
596 | {"HISI0191"}, | |
597 | {} | |
598 | }; | |
599 | #else | |
600 | static int hisi_lpc_acpi_probe(struct device *dev) | |
601 | { | |
602 | return -ENODEV; | |
603 | } | |
10e62b47 JG |
604 | |
605 | static void hisi_lpc_acpi_remove(struct device *hostdev) | |
606 | { | |
607 | } | |
e0aa1563 JG |
608 | #endif // CONFIG_ACPI |
609 | ||
adf38bb0 ZY |
610 | /* |
611 | * hisi_lpc_probe - the probe callback function for hisi lpc host, | |
612 | * will finish all the initialization. | |
613 | * @pdev: the platform device corresponding to hisi lpc host | |
614 | * | |
615 | * Returns 0 on success, non-zero on fail. | |
616 | */ | |
617 | static int hisi_lpc_probe(struct platform_device *pdev) | |
618 | { | |
619 | struct device *dev = &pdev->dev; | |
620 | struct acpi_device *acpi_device = ACPI_COMPANION(dev); | |
621 | struct logic_pio_hwaddr *range; | |
622 | struct hisi_lpc_dev *lpcdev; | |
623 | resource_size_t io_end; | |
624 | struct resource *res; | |
625 | int ret; | |
626 | ||
627 | lpcdev = devm_kzalloc(dev, sizeof(*lpcdev), GFP_KERNEL); | |
628 | if (!lpcdev) | |
629 | return -ENOMEM; | |
630 | ||
631 | spin_lock_init(&lpcdev->cycle_lock); | |
632 | ||
633 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
634 | lpcdev->membase = devm_ioremap_resource(dev, res); | |
635 | if (IS_ERR(lpcdev->membase)) | |
636 | return PTR_ERR(lpcdev->membase); | |
637 | ||
638 | range = devm_kzalloc(dev, sizeof(*range), GFP_KERNEL); | |
639 | if (!range) | |
640 | return -ENOMEM; | |
641 | ||
642 | range->fwnode = dev->fwnode; | |
643 | range->flags = LOGIC_PIO_INDIRECT; | |
644 | range->size = PIO_INDIRECT_SIZE; | |
1b15a563 JG |
645 | range->hostdata = lpcdev; |
646 | range->ops = &hisi_lpc_ops; | |
647 | lpcdev->io_host = range; | |
adf38bb0 ZY |
648 | |
649 | ret = logic_pio_register_range(range); | |
650 | if (ret) { | |
651 | dev_err(dev, "register IO range failed (%d)!\n", ret); | |
652 | return ret; | |
653 | } | |
adf38bb0 ZY |
654 | |
655 | /* register the LPC host PIO resources */ | |
e0aa1563 JG |
656 | if (acpi_device) |
657 | ret = hisi_lpc_acpi_probe(dev); | |
658 | else | |
adf38bb0 | 659 | ret = of_platform_populate(dev->of_node, NULL, NULL, dev); |
1b15a563 JG |
660 | if (ret) { |
661 | logic_pio_unregister_range(range); | |
e0aa1563 | 662 | return ret; |
1b15a563 | 663 | } |
adf38bb0 | 664 | |
10e62b47 JG |
665 | dev_set_drvdata(dev, lpcdev); |
666 | ||
adf38bb0 ZY |
667 | io_end = lpcdev->io_host->io_start + lpcdev->io_host->size; |
668 | dev_info(dev, "registered range [%pa - %pa]\n", | |
669 | &lpcdev->io_host->io_start, &io_end); | |
670 | ||
671 | return ret; | |
672 | } | |
673 | ||
10e62b47 JG |
674 | static int hisi_lpc_remove(struct platform_device *pdev) |
675 | { | |
676 | struct device *dev = &pdev->dev; | |
677 | struct acpi_device *acpi_device = ACPI_COMPANION(dev); | |
678 | struct hisi_lpc_dev *lpcdev = dev_get_drvdata(dev); | |
679 | struct logic_pio_hwaddr *range = lpcdev->io_host; | |
680 | ||
681 | if (acpi_device) | |
682 | hisi_lpc_acpi_remove(dev); | |
683 | else | |
684 | of_platform_depopulate(dev); | |
685 | ||
686 | logic_pio_unregister_range(range); | |
687 | ||
688 | return 0; | |
689 | } | |
690 | ||
adf38bb0 ZY |
691 | static const struct of_device_id hisi_lpc_of_match[] = { |
692 | { .compatible = "hisilicon,hip06-lpc", }, | |
693 | { .compatible = "hisilicon,hip07-lpc", }, | |
694 | {} | |
695 | }; | |
696 | ||
697 | static struct platform_driver hisi_lpc_driver = { | |
698 | .driver = { | |
699 | .name = DRV_NAME, | |
700 | .of_match_table = hisi_lpc_of_match, | |
e0aa1563 | 701 | .acpi_match_table = ACPI_PTR(hisi_lpc_acpi_match), |
adf38bb0 ZY |
702 | }, |
703 | .probe = hisi_lpc_probe, | |
10e62b47 | 704 | .remove = hisi_lpc_remove, |
adf38bb0 ZY |
705 | }; |
706 | builtin_platform_driver(hisi_lpc_driver); |