Blame view
drivers/mailbox/pcc.c
16.1 KB
c942fddf8
|
1 |
// SPDX-License-Identifier: GPL-2.0-or-later |
86c22f8c9
|
2 3 4 5 |
/* * Copyright (C) 2014 Linaro Ltd. * Author: Ashwin Chaugule <ashwin.chaugule@linaro.org> * |
86c22f8c9
|
6 7 8 9 10 11 12 13 |
* PCC (Platform Communication Channel) is defined in the ACPI 5.0+ * specification. It is a mailbox like mechanism to allow clients * such as CPPC (Collaborative Processor Performance Control), RAS * (Reliability, Availability and Serviceability) and MPST (Memory * Node Power State Table) to talk to the platform (e.g. BMC) through * shared memory regions as defined in the PCC table entries. The PCC * specification supports a Doorbell mechanism for the PCC clients * to notify the platform about new data. This Doorbell information |
33350e6b1
|
14 |
* is also specified in each PCC table entry. |
86c22f8c9
|
15 |
* |
33350e6b1
|
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 |
* Typical high level flow of operation is: * * PCC Reads: * * Client tries to acquire a channel lock. * * After it is acquired it writes READ cmd in communication region cmd * address. * * Client issues mbox_send_message() which rings the PCC doorbell * for its PCC channel. * * If command completes, then client has control over channel and * it can proceed with its reads. * * Client releases lock. * * PCC Writes: * * Client tries to acquire channel lock. * * Client writes to its communication region after it acquires a * channel lock. * * Client writes WRITE cmd in communication region cmd address. * * Client issues mbox_send_message() which rings the PCC doorbell * for its PCC channel. * * If command completes, then writes have succeded and it can release * the channel lock. * * There is a Nominal latency defined for each channel which indicates * how long to wait until a command completes. If command is not complete * the client needs to retry or assume failure. * * For more details about PCC, please see the ACPI specification from |
86c22f8c9
|
43 44 45 46 47 48 49 50 51 52 |
* http://www.uefi.org/ACPIv5.1 Section 14. * * This file implements PCC as a Mailbox controller and allows for PCC * clients to be implemented as its Mailbox Client Channels. */ #include <linux/acpi.h> #include <linux/delay.h> #include <linux/io.h> #include <linux/init.h> |
aca314efb
|
53 |
#include <linux/interrupt.h> |
86c22f8c9
|
54 55 56 57 |
#include <linux/list.h> #include <linux/platform_device.h> #include <linux/mailbox_controller.h> #include <linux/mailbox_client.h> |
8b0f57889
|
58 |
#include <linux/io-64-nonatomic-lo-hi.h> |
6ca595a70
|
59 |
#include <acpi/pcc.h> |
86c22f8c9
|
60 61 |
#include "mailbox.h" |
aca314efb
|
62 |
#define MBOX_IRQ_NAME "pcc-mbox" |
86c22f8c9
|
63 64 |
static struct mbox_chan *pcc_mbox_channels; |
8b0f57889
|
65 66 |
/* Array of cached virtual address for doorbell registers */ static void __iomem **pcc_doorbell_vaddr; |
aca314efb
|
67 68 69 70 |
/* Array of cached virtual address for doorbell ack registers */ static void __iomem **pcc_doorbell_ack_vaddr; /* Array of doorbell interrupts */ static int *pcc_doorbell_irq; |
8b0f57889
|
71 |
|
86c22f8c9
|
72 73 74 75 76 77 78 79 80 81 82 |
static struct mbox_controller pcc_mbox_ctrl = {}; /** * get_pcc_channel - Given a PCC subspace idx, get * the respective mbox_channel. * @id: PCC subspace index. * * Return: ERR_PTR(errno) if error, else pointer * to mbox channel. */ static struct mbox_chan *get_pcc_channel(int id) { |
ecfc1599e
|
83 |
if (id < 0 || id >= pcc_mbox_ctrl.num_chans) |
86c22f8c9
|
84 |
return ERR_PTR(-ENOENT); |
e9c8dc8ba
|
85 |
return &pcc_mbox_channels[id]; |
86c22f8c9
|
86 |
} |
aca314efb
|
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 |
/* * PCC can be used with perf critical drivers such as CPPC * So it makes sense to locally cache the virtual address and * use it to read/write to PCC registers such as doorbell register * * The below read_register and write_registers are used to read and * write from perf critical registers such as PCC doorbell register */ static int read_register(void __iomem *vaddr, u64 *val, unsigned int bit_width) { int ret_val = 0; switch (bit_width) { case 8: *val = readb(vaddr); break; case 16: *val = readw(vaddr); break; case 32: *val = readl(vaddr); break; case 64: *val = readq(vaddr); break; default: pr_debug("Error: Cannot read register of %u bit width", bit_width); ret_val = -EFAULT; break; } return ret_val; } static int write_register(void __iomem *vaddr, u64 val, unsigned int bit_width) { int ret_val = 0; switch (bit_width) { case 8: writeb(val, vaddr); break; case 16: writew(val, vaddr); break; case 32: writel(val, vaddr); break; case 64: writeq(val, vaddr); break; default: pr_debug("Error: Cannot write register of %u bit width", bit_width); ret_val = -EFAULT; break; } return ret_val; } /** * pcc_map_interrupt - Map a PCC subspace GSI to a linux IRQ number * @interrupt: GSI number. * @flags: interrupt flags * * Returns: a valid linux IRQ number on success * 0 or -EINVAL on failure */ static int pcc_map_interrupt(u32 interrupt, u32 flags) { int trigger, polarity; if (!interrupt) return 0; trigger = (flags & ACPI_PCCT_INTERRUPT_MODE) ? ACPI_EDGE_SENSITIVE : ACPI_LEVEL_SENSITIVE; polarity = (flags & ACPI_PCCT_INTERRUPT_POLARITY) ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH; return acpi_register_gsi(NULL, interrupt, trigger, polarity); } /** * pcc_mbox_irq - PCC mailbox interrupt handler */ static irqreturn_t pcc_mbox_irq(int irq, void *p) { struct acpi_generic_address *doorbell_ack; struct acpi_pcct_hw_reduced *pcct_ss; struct mbox_chan *chan = p; u64 doorbell_ack_preserve; u64 doorbell_ack_write; u64 doorbell_ack_val; int ret; pcct_ss = chan->con_priv; mbox_chan_received_data(chan, NULL); if (pcct_ss->header.type == ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2) { struct acpi_pcct_hw_reduced_type2 *pcct2_ss = chan->con_priv; u32 id = chan - pcc_mbox_channels; |
c7a1dfb95
|
191 |
doorbell_ack = &pcct2_ss->platform_ack_register; |
aca314efb
|
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 |
doorbell_ack_preserve = pcct2_ss->ack_preserve_mask; doorbell_ack_write = pcct2_ss->ack_write_mask; ret = read_register(pcc_doorbell_ack_vaddr[id], &doorbell_ack_val, doorbell_ack->bit_width); if (ret) return IRQ_NONE; ret = write_register(pcc_doorbell_ack_vaddr[id], (doorbell_ack_val & doorbell_ack_preserve) | doorbell_ack_write, doorbell_ack->bit_width); if (ret) return IRQ_NONE; } return IRQ_HANDLED; } |
86c22f8c9
|
211 |
/** |
86c22f8c9
|
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 |
* pcc_mbox_request_channel - PCC clients call this function to * request a pointer to their PCC subspace, from which they * can get the details of communicating with the remote. * @cl: Pointer to Mailbox client, so we know where to bind the * Channel. * @subspace_id: The PCC Subspace index as parsed in the PCC client * ACPI package. This is used to lookup the array of PCC * subspaces as parsed by the PCC Mailbox controller. * * Return: Pointer to the Mailbox Channel if successful or * ERR_PTR. */ struct mbox_chan *pcc_mbox_request_channel(struct mbox_client *cl, int subspace_id) { struct device *dev = pcc_mbox_ctrl.dev; struct mbox_chan *chan; unsigned long flags; /* * Each PCC Subspace is a Mailbox Channel. * The PCC Clients get their PCC Subspace ID * from their own tables and pass it here. * This returns a pointer to the PCC subspace * for the Client to operate on. */ chan = get_pcc_channel(subspace_id); |
d311a28a5
|
239 |
if (IS_ERR(chan) || chan->cl) { |
33350e6b1
|
240 241 |
dev_err(dev, "Channel not found for idx: %d ", subspace_id); |
86c22f8c9
|
242 243 244 245 246 247 248 249 250 251 252 |
return ERR_PTR(-EBUSY); } spin_lock_irqsave(&chan->lock, flags); chan->msg_free = 0; chan->msg_count = 0; chan->active_req = NULL; chan->cl = cl; init_completion(&chan->tx_complete); if (chan->txdone_method == TXDONE_BY_POLL && cl->knows_txdone) |
33cd7123a
|
253 |
chan->txdone_method = TXDONE_BY_ACK; |
86c22f8c9
|
254 |
|
6ca595a70
|
255 |
spin_unlock_irqrestore(&chan->lock, flags); |
aca314efb
|
256 257 258 259 260 261 262 263 264 |
if (pcc_doorbell_irq[subspace_id] > 0) { int rc; rc = devm_request_irq(dev, pcc_doorbell_irq[subspace_id], pcc_mbox_irq, 0, MBOX_IRQ_NAME, chan); if (unlikely(rc)) { dev_err(dev, "failed to register PCC interrupt %d ", pcc_doorbell_irq[subspace_id]); |
6ca595a70
|
265 |
pcc_mbox_free_channel(chan); |
aca314efb
|
266 267 268 |
chan = ERR_PTR(rc); } } |
86c22f8c9
|
269 270 271 272 273 274 275 276 277 278 279 280 |
return chan; } EXPORT_SYMBOL_GPL(pcc_mbox_request_channel); /** * pcc_mbox_free_channel - Clients call this to free their Channel. * * @chan: Pointer to the mailbox channel as returned by * pcc_mbox_request_channel() */ void pcc_mbox_free_channel(struct mbox_chan *chan) { |
aca314efb
|
281 |
u32 id = chan - pcc_mbox_channels; |
86c22f8c9
|
282 283 284 285 |
unsigned long flags; if (!chan || !chan->cl) return; |
aca314efb
|
286 287 288 289 290 |
if (id >= pcc_mbox_ctrl.num_chans) { pr_debug("pcc_mbox_free_channel: Invalid mbox_chan passed "); return; } |
6ca595a70
|
291 292 |
if (pcc_doorbell_irq[id] > 0) devm_free_irq(chan->mbox->dev, pcc_doorbell_irq[id], chan); |
86c22f8c9
|
293 294 295 |
spin_lock_irqsave(&chan->lock, flags); chan->cl = NULL; chan->active_req = NULL; |
33cd7123a
|
296 |
if (chan->txdone_method == TXDONE_BY_ACK) |
86c22f8c9
|
297 298 299 300 301 302 303 |
chan->txdone_method = TXDONE_BY_POLL; spin_unlock_irqrestore(&chan->lock, flags); } EXPORT_SYMBOL_GPL(pcc_mbox_free_channel); /** |
33350e6b1
|
304 305 306 307 308 |
* pcc_send_data - Called from Mailbox Controller code. Used * here only to ring the channel doorbell. The PCC client * specific read/write is done in the client driver in * order to maintain atomicity over PCC channel once * OS has control over it. See above for flow of operations. |
86c22f8c9
|
309 |
* @chan: Pointer to Mailbox channel over which to send data. |
33350e6b1
|
310 311 |
* @data: Client specific data written over channel. Used here * only for debug after PCC transaction completes. |
86c22f8c9
|
312 313 314 315 316 317 |
* * Return: Err if something failed else 0 for success. */ static int pcc_send_data(struct mbox_chan *chan, void *data) { struct acpi_pcct_hw_reduced *pcct_ss = chan->con_priv; |
8b0f57889
|
318 |
struct acpi_generic_address *doorbell; |
86c22f8c9
|
319 320 321 |
u64 doorbell_preserve; u64 doorbell_val; u64 doorbell_write; |
8b0f57889
|
322 323 324 325 326 327 328 329 |
u32 id = chan - pcc_mbox_channels; int ret = 0; if (id >= pcc_mbox_ctrl.num_chans) { pr_debug("pcc_send_data: Invalid mbox_chan passed "); return -ENOENT; } |
86c22f8c9
|
330 |
|
8b0f57889
|
331 |
doorbell = &pcct_ss->doorbell_register; |
86c22f8c9
|
332 333 |
doorbell_preserve = pcct_ss->preserve_mask; doorbell_write = pcct_ss->write_mask; |
33350e6b1
|
334 |
/* Sync notification from OS to Platform. */ |
8b0f57889
|
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 |
if (pcc_doorbell_vaddr[id]) { ret = read_register(pcc_doorbell_vaddr[id], &doorbell_val, doorbell->bit_width); if (ret) return ret; ret = write_register(pcc_doorbell_vaddr[id], (doorbell_val & doorbell_preserve) | doorbell_write, doorbell->bit_width); } else { ret = acpi_read(&doorbell_val, doorbell); if (ret) return ret; ret = acpi_write((doorbell_val & doorbell_preserve) | doorbell_write, doorbell); } return ret; |
86c22f8c9
|
351 |
} |
05ae79756
|
352 |
static const struct mbox_chan_ops pcc_chan_ops = { |
86c22f8c9
|
353 |
.send_data = pcc_send_data, |
86c22f8c9
|
354 355 356 |
}; /** |
8f8027c5f
|
357 |
* parse_pcc_subspaces -- Count PCC subspaces defined |
86c22f8c9
|
358 359 360 |
* @header: Pointer to the ACPI subtable header under the PCCT. * @end: End of subtable entry. * |
8f8027c5f
|
361 362 |
* Return: If we find a PCC subspace entry of a valid type, return 0. * Otherwise, return -EINVAL. |
86c22f8c9
|
363 364 365 |
* * This gets called for each entry in the PCC table. */ |
60574d1e0
|
366 |
static int parse_pcc_subspace(union acpi_subtable_headers *header, |
86c22f8c9
|
367 368 |
const unsigned long end) { |
8f8027c5f
|
369 |
struct acpi_pcct_subspace *ss = (struct acpi_pcct_subspace *) header; |
86c22f8c9
|
370 |
|
8f8027c5f
|
371 372 |
if (ss->header.type < ACPI_PCCT_TYPE_RESERVED) return 0; |
86c22f8c9
|
373 |
|
8f8027c5f
|
374 |
return -EINVAL; |
86c22f8c9
|
375 376 377 |
} /** |
aca314efb
|
378 379 380 381 382 383 384 385 386 387 388 389 |
* pcc_parse_subspace_irq - Parse the PCC IRQ and PCC ACK register * There should be one entry per PCC client. * @id: PCC subspace index. * @pcct_ss: Pointer to the ACPI subtable header under the PCCT. * * Return: 0 for Success, else errno. * * This gets called for each entry in the PCC table. */ static int pcc_parse_subspace_irq(int id, struct acpi_pcct_hw_reduced *pcct_ss) { |
c7a1dfb95
|
390 |
pcc_doorbell_irq[id] = pcc_map_interrupt(pcct_ss->platform_interrupt, |
aca314efb
|
391 392 393 394 |
(u32)pcct_ss->flags); if (pcc_doorbell_irq[id] <= 0) { pr_err("PCC GSI %d not registered ", |
c7a1dfb95
|
395 |
pcct_ss->platform_interrupt); |
aca314efb
|
396 397 398 399 400 401 402 403 |
return -EINVAL; } if (pcct_ss->header.type == ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2) { struct acpi_pcct_hw_reduced_type2 *pcct2_ss = (void *)pcct_ss; pcc_doorbell_ack_vaddr[id] = acpi_os_ioremap( |
c7a1dfb95
|
404 405 |
pcct2_ss->platform_ack_register.address, pcct2_ss->platform_ack_register.bit_width / 8); |
aca314efb
|
406 407 408 409 410 411 412 413 414 415 416 |
if (!pcc_doorbell_ack_vaddr[id]) { pr_err("Failed to ioremap PCC ACK register "); return -ENOMEM; } } return 0; } /** |
86c22f8c9
|
417 418 419 420 421 422 |
* acpi_pcc_probe - Parse the ACPI tree for the PCCT. * * Return: 0 for Success, else errno. */ static int __init acpi_pcc_probe(void) { |
86c22f8c9
|
423 424 |
struct acpi_table_header *pcct_tbl; struct acpi_subtable_header *pcct_entry; |
aca314efb
|
425 |
struct acpi_table_pcct *acpi_pcct_tbl; |
8f8027c5f
|
426 |
struct acpi_subtable_proc proc[ACPI_PCCT_TYPE_RESERVED]; |
aca314efb
|
427 |
int count, i, rc; |
86c22f8c9
|
428 429 430 |
acpi_status status = AE_OK; /* Search for PCCT */ |
6b11d1d67
|
431 |
status = acpi_get_table(ACPI_SIG_PCCT, 0, &pcct_tbl); |
86c22f8c9
|
432 |
|
66ed4cac6
|
433 |
if (ACPI_FAILURE(status) || !pcct_tbl) |
86c22f8c9
|
434 |
return -ENODEV; |
86c22f8c9
|
435 |
|
8f8027c5f
|
436 437 438 439 440 441 442 |
/* Set up the subtable handlers */ for (i = ACPI_PCCT_TYPE_GENERIC_SUBSPACE; i < ACPI_PCCT_TYPE_RESERVED; i++) { proc[i].id = i; proc[i].count = 0; proc[i].handler = parse_pcc_subspace; } |
86c22f8c9
|
443 |
|
8f8027c5f
|
444 445 446 |
count = acpi_table_parse_entries_array(ACPI_SIG_PCCT, sizeof(struct acpi_table_pcct), proc, ACPI_PCCT_TYPE_RESERVED, MAX_PCC_SUBSPACES); |
afd0b1fb2
|
447 448 449 450 451 452 453 |
if (count <= 0 || count > MAX_PCC_SUBSPACES) { if (count < 0) pr_warn("Error parsing PCC subspaces from PCCT "); else pr_warn("Invalid PCCT: %d PCC subspaces ", count); |
86c22f8c9
|
454 455 |
return -EINVAL; } |
6396bb221
|
456 457 |
pcc_mbox_channels = kcalloc(count, sizeof(struct mbox_chan), GFP_KERNEL); |
86c22f8c9
|
458 459 460 461 462 |
if (!pcc_mbox_channels) { pr_err("Could not allocate space for PCC mbox channels "); return -ENOMEM; } |
8f8027c5f
|
463 |
pcc_doorbell_vaddr = kcalloc(count, sizeof(void *), GFP_KERNEL); |
8b0f57889
|
464 |
if (!pcc_doorbell_vaddr) { |
aca314efb
|
465 466 467 |
rc = -ENOMEM; goto err_free_mbox; } |
8f8027c5f
|
468 |
pcc_doorbell_ack_vaddr = kcalloc(count, sizeof(void *), GFP_KERNEL); |
aca314efb
|
469 470 471 472 |
if (!pcc_doorbell_ack_vaddr) { rc = -ENOMEM; goto err_free_db_vaddr; } |
8f8027c5f
|
473 |
pcc_doorbell_irq = kcalloc(count, sizeof(int), GFP_KERNEL); |
aca314efb
|
474 475 476 |
if (!pcc_doorbell_irq) { rc = -ENOMEM; goto err_free_db_ack_vaddr; |
8b0f57889
|
477 |
} |
86c22f8c9
|
478 479 480 |
/* Point to the first PCC subspace entry */ pcct_entry = (struct acpi_subtable_header *) ( (unsigned long) pcct_tbl + sizeof(struct acpi_table_pcct)); |
aca314efb
|
481 482 483 |
acpi_pcct_tbl = (struct acpi_table_pcct *) pcct_tbl; if (acpi_pcct_tbl->flags & ACPI_PCCT_DOORBELL) pcc_mbox_ctrl.txdone_irq = true; |
8f8027c5f
|
484 |
for (i = 0; i < count; i++) { |
8b0f57889
|
485 |
struct acpi_generic_address *db_reg; |
8f8027c5f
|
486 |
struct acpi_pcct_subspace *pcct_ss; |
86c22f8c9
|
487 |
pcc_mbox_channels[i].con_priv = pcct_entry; |
8b0f57889
|
488 |
|
8f8027c5f
|
489 490 491 492 493 |
if (pcct_entry->type == ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE || pcct_entry->type == ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2) { struct acpi_pcct_hw_reduced *pcct_hrss; pcct_hrss = (struct acpi_pcct_hw_reduced *) pcct_entry; |
aca314efb
|
494 |
|
8f8027c5f
|
495 496 497 498 499 |
if (pcc_mbox_ctrl.txdone_irq) { rc = pcc_parse_subspace_irq(i, pcct_hrss); if (rc < 0) goto err; } |
aca314efb
|
500 |
} |
8f8027c5f
|
501 |
pcct_ss = (struct acpi_pcct_subspace *) pcct_entry; |
aca314efb
|
502 |
|
8b0f57889
|
503 |
/* If doorbell is in system memory cache the virt address */ |
8b0f57889
|
504 505 506 507 |
db_reg = &pcct_ss->doorbell_register; if (db_reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) pcc_doorbell_vaddr[i] = acpi_os_ioremap(db_reg->address, db_reg->bit_width/8); |
86c22f8c9
|
508 509 510 |
pcct_entry = (struct acpi_subtable_header *) ((unsigned long) pcct_entry + pcct_entry->length); } |
8f8027c5f
|
511 |
pcc_mbox_ctrl.num_chans = count; |
86c22f8c9
|
512 513 514 515 516 |
pr_info("Detected %d PCC Subspaces ", pcc_mbox_ctrl.num_chans); return 0; |
aca314efb
|
517 518 519 520 521 522 523 524 525 526 |
err: kfree(pcc_doorbell_irq); err_free_db_ack_vaddr: kfree(pcc_doorbell_ack_vaddr); err_free_db_vaddr: kfree(pcc_doorbell_vaddr); err_free_mbox: kfree(pcc_mbox_channels); return rc; |
86c22f8c9
|
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 |
} /** * pcc_mbox_probe - Called when we find a match for the * PCCT platform device. This is purely used to represent * the PCCT as a virtual device for registering with the * generic Mailbox framework. * * @pdev: Pointer to platform device returned when a match * is found. * * Return: 0 for Success, else errno. */ static int pcc_mbox_probe(struct platform_device *pdev) { int ret = 0; pcc_mbox_ctrl.chans = pcc_mbox_channels; pcc_mbox_ctrl.ops = &pcc_chan_ops; |
86c22f8c9
|
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 |
pcc_mbox_ctrl.dev = &pdev->dev; pr_info("Registering PCC driver as Mailbox controller "); ret = mbox_controller_register(&pcc_mbox_ctrl); if (ret) { pr_err("Err registering PCC as Mailbox controller: %d ", ret); ret = -ENODEV; } return ret; } struct platform_driver pcc_mbox_driver = { .probe = pcc_mbox_probe, .driver = { .name = "PCCT", .owner = THIS_MODULE, }, }; static int __init pcc_init(void) { int ret; struct platform_device *pcc_pdev; if (acpi_disabled) return -ENODEV; /* Check if PCC support is available. */ ret = acpi_pcc_probe(); if (ret) { |
efd756daf
|
581 582 |
pr_debug("ACPI PCC probe failed. "); |
86c22f8c9
|
583 584 585 586 587 |
return -ENODEV; } pcc_pdev = platform_create_bundle(&pcc_mbox_driver, pcc_mbox_probe, NULL, 0, NULL, 0); |
356d5d28f
|
588 |
if (IS_ERR(pcc_pdev)) { |
efd756daf
|
589 590 |
pr_debug("Err creating PCC platform bundle "); |
356d5d28f
|
591 |
return PTR_ERR(pcc_pdev); |
86c22f8c9
|
592 593 594 595 |
} return 0; } |
d3c68f218
|
596 597 598 599 600 601 602 |
/* * Make PCC init postcore so that users of this mailbox * such as the ACPI Processor driver have it available * at their init. */ postcore_initcall(pcc_init); |