pcc.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *	Copyright (C) 2014 Linaro Ltd.
  4 *	Author:	Ashwin Chaugule <ashwin.chaugule@linaro.org>
  5 *
  6 *  PCC (Platform Communication Channel) is defined in the ACPI 5.0+
  7 *  specification. It is a mailbox like mechanism to allow clients
  8 *  such as CPPC (Collaborative Processor Performance Control), RAS
  9 *  (Reliability, Availability and Serviceability) and MPST (Memory
 10 *  Node Power State Table) to talk to the platform (e.g. BMC) through
 11 *  shared memory regions as defined in the PCC table entries. The PCC
 12 *  specification supports a Doorbell mechanism for the PCC clients
 13 *  to notify the platform about new data. This Doorbell information
 14 *  is also specified in each PCC table entry.
 15 *
 16 *  Typical high level flow of operation is:
 17 *
 18 *  PCC Reads:
 19 *  * Client tries to acquire a channel lock.
 20 *  * After it is acquired it writes READ cmd in communication region cmd
 21 *		address.
 22 *  * Client issues mbox_send_message() which rings the PCC doorbell
 23 *		for its PCC channel.
 24 *  * If command completes, then client has control over channel and
 25 *		it can proceed with its reads.
 26 *  * Client releases lock.
 27 *
 28 *  PCC Writes:
 29 *  * Client tries to acquire channel lock.
 30 *  * Client writes to its communication region after it acquires a
 31 *		channel lock.
 32 *  * Client writes WRITE cmd in communication region cmd address.
 33 *  * Client issues mbox_send_message() which rings the PCC doorbell
 34 *		for its PCC channel.
 35 *  * If command completes, then writes have succeeded and it can release
 36 *		the channel lock.
 37 *
 38 *  There is a Nominal latency defined for each channel which indicates
 39 *  how long to wait until a command completes. If command is not complete
 40 *  the client needs to retry or assume failure.
 41 *
 42 *	For more details about PCC, please see the ACPI specification from
 43 *  http://www.uefi.org/ACPIv5.1 Section 14.
 44 *
 45 *  This file implements PCC as a Mailbox controller and allows for PCC
 46 *  clients to be implemented as its Mailbox Client Channels.
 47 */
 48
 49#include <linux/acpi.h>
 50#include <linux/delay.h>
 51#include <linux/io.h>
 52#include <linux/init.h>
 53#include <linux/interrupt.h>
 54#include <linux/list.h>
 55#include <linux/log2.h>
 56#include <linux/platform_device.h>
 57#include <linux/mailbox_controller.h>
 58#include <linux/mailbox_client.h>
 59#include <linux/io-64-nonatomic-lo-hi.h>
 60#include <acpi/pcc.h>
 61
 62#include "mailbox.h"
 63
 64#define MBOX_IRQ_NAME		"pcc-mbox"
 65
 66/**
 67 * struct pcc_chan_reg - PCC register bundle
 68 *
 69 * @vaddr: cached virtual address for this register
 70 * @gas: pointer to the generic address structure for this register
 71 * @preserve_mask: bitmask to preserve when writing to this register
 72 * @set_mask: bitmask to set when writing to this register
 73 * @status_mask: bitmask to determine and/or update the status for this register
 74 */
 75struct pcc_chan_reg {
 76	void __iomem *vaddr;
 77	struct acpi_generic_address *gas;
 78	u64 preserve_mask;
 79	u64 set_mask;
 80	u64 status_mask;
 81};
 82
 83/**
 84 * struct pcc_chan_info - PCC channel specific information
 85 *
 86 * @chan: PCC channel information with Shared Memory Region info
 87 * @db: PCC register bundle for the doorbell register
 88 * @plat_irq_ack: PCC register bundle for the platform interrupt acknowledge
 89 *	register
 90 * @cmd_complete: PCC register bundle for the command complete check register
 91 * @cmd_update: PCC register bundle for the command complete update register
 92 * @error: PCC register bundle for the error status register
 93 * @plat_irq: platform interrupt
 94 * @type: PCC subspace type
 95 * @plat_irq_flags: platform interrupt flags
 96 * @chan_in_use: this flag is used just to check if the interrupt needs
 97 *		handling when it is shared. Since only one transfer can occur
 98 *		at a time and mailbox takes care of locking, this flag can be
 99 *		accessed without a lock. Note: the type only support the
100 *		communication from OSPM to Platform, like type3, use it, and
101 *		other types completely ignore it.
102 */
103struct pcc_chan_info {
104	struct pcc_mbox_chan chan;
105	struct pcc_chan_reg db;
106	struct pcc_chan_reg plat_irq_ack;
107	struct pcc_chan_reg cmd_complete;
108	struct pcc_chan_reg cmd_update;
109	struct pcc_chan_reg error;
110	int plat_irq;
111	u8 type;
112	unsigned int plat_irq_flags;
113	bool chan_in_use;
114};
115
116#define to_pcc_chan_info(c) container_of(c, struct pcc_chan_info, chan)
117static struct pcc_chan_info *chan_info;
118static int pcc_chan_count;
119
120/*
121 * PCC can be used with perf critical drivers such as CPPC
122 * So it makes sense to locally cache the virtual address and
123 * use it to read/write to PCC registers such as doorbell register
124 *
125 * The below read_register and write_registers are used to read and
126 * write from perf critical registers such as PCC doorbell register
127 */
128static void read_register(void __iomem *vaddr, u64 *val, unsigned int bit_width)
129{
130	switch (bit_width) {
131	case 8:
132		*val = readb(vaddr);
133		break;
134	case 16:
135		*val = readw(vaddr);
136		break;
137	case 32:
138		*val = readl(vaddr);
139		break;
140	case 64:
141		*val = readq(vaddr);
142		break;
143	}
144}
145
146static void write_register(void __iomem *vaddr, u64 val, unsigned int bit_width)
147{
148	switch (bit_width) {
149	case 8:
150		writeb(val, vaddr);
151		break;
152	case 16:
153		writew(val, vaddr);
154		break;
155	case 32:
156		writel(val, vaddr);
157		break;
158	case 64:
159		writeq(val, vaddr);
160		break;
161	}
162}
163
164static int pcc_chan_reg_read(struct pcc_chan_reg *reg, u64 *val)
165{
166	int ret = 0;
167
168	if (!reg->gas) {
169		*val = 0;
170		return 0;
171	}
172
173	if (reg->vaddr)
174		read_register(reg->vaddr, val, reg->gas->bit_width);
175	else
176		ret = acpi_read(val, reg->gas);
177
178	return ret;
179}
180
181static int pcc_chan_reg_write(struct pcc_chan_reg *reg, u64 val)
182{
183	int ret = 0;
184
185	if (!reg->gas)
186		return 0;
187
188	if (reg->vaddr)
189		write_register(reg->vaddr, val, reg->gas->bit_width);
190	else
191		ret = acpi_write(val, reg->gas);
192
193	return ret;
194}
195
196static int pcc_chan_reg_read_modify_write(struct pcc_chan_reg *reg)
197{
198	int ret = 0;
199	u64 val;
200
201	ret = pcc_chan_reg_read(reg, &val);
202	if (ret)
203		return ret;
204
205	val &= reg->preserve_mask;
206	val |= reg->set_mask;
207
208	return pcc_chan_reg_write(reg, val);
209}
210
211/**
212 * pcc_map_interrupt - Map a PCC subspace GSI to a linux IRQ number
213 * @interrupt: GSI number.
214 * @flags: interrupt flags
215 *
216 * Returns: a valid linux IRQ number on success
217 *		0 or -EINVAL on failure
218 */
219static int pcc_map_interrupt(u32 interrupt, u32 flags)
220{
221	int trigger, polarity;
222
223	if (!interrupt)
224		return 0;
225
226	trigger = (flags & ACPI_PCCT_INTERRUPT_MODE) ? ACPI_EDGE_SENSITIVE
227			: ACPI_LEVEL_SENSITIVE;
228
229	polarity = (flags & ACPI_PCCT_INTERRUPT_POLARITY) ? ACPI_ACTIVE_LOW
230			: ACPI_ACTIVE_HIGH;
231
232	return acpi_register_gsi(NULL, interrupt, trigger, polarity);
233}
234
235static bool pcc_chan_plat_irq_can_be_shared(struct pcc_chan_info *pchan)
236{
237	return (pchan->plat_irq_flags & ACPI_PCCT_INTERRUPT_MODE) ==
238		ACPI_LEVEL_SENSITIVE;
239}
240
241static bool pcc_mbox_cmd_complete_check(struct pcc_chan_info *pchan)
242{
243	u64 val;
244	int ret;
245
246	if (!pchan->cmd_complete.gas)
247		return true;
248
249	ret = pcc_chan_reg_read(&pchan->cmd_complete, &val);
250	if (ret)
251		return false;
252
253	/*
254	 * Judge if the channel respond the interrupt based on the value of
255	 * command complete.
256	 */
257	val &= pchan->cmd_complete.status_mask;
258
259	/*
260	 * If this is PCC slave subspace channel, and the command complete
261	 * bit 0 indicates that Platform is sending a notification and OSPM
262	 * needs to respond this interrupt to process this command.
263	 */
264	if (pchan->type == ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE)
265		return !val;
266
267	return !!val;
268}
269
270static int pcc_mbox_error_check_and_clear(struct pcc_chan_info *pchan)
271{
272	u64 val;
273	int ret;
274
275	ret = pcc_chan_reg_read(&pchan->error, &val);
276	if (ret)
277		return ret;
278
279	if (val & pchan->error.status_mask) {
280		val &= pchan->error.preserve_mask;
281		pcc_chan_reg_write(&pchan->error, val);
282		return -EIO;
283	}
284
285	return 0;
286}
287
288static void pcc_chan_acknowledge(struct pcc_chan_info *pchan)
289{
290	struct acpi_pcct_ext_pcc_shared_memory __iomem *pcc_hdr;
291
292	if (pchan->type != ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE)
293		return;
294
295	pcc_chan_reg_read_modify_write(&pchan->cmd_update);
296
297	pcc_hdr = pchan->chan.shmem;
298
299	/*
300	 * The PCC slave subspace channel needs to set the command
301	 * complete bit after processing message. If the PCC_ACK_FLAG
302	 * is set, it should also ring the doorbell.
303	 */
304	if (ioread32(&pcc_hdr->flags) & PCC_CMD_COMPLETION_NOTIFY)
305		pcc_chan_reg_read_modify_write(&pchan->db);
306}
307
308/**
309 * pcc_mbox_irq - PCC mailbox interrupt handler
310 * @irq:	interrupt number
311 * @p: data/cookie passed from the caller to identify the channel
312 *
313 * Returns: IRQ_HANDLED if interrupt is handled or IRQ_NONE if not
314 */
315static irqreturn_t pcc_mbox_irq(int irq, void *p)
316{
317	struct pcc_chan_info *pchan;
318	struct mbox_chan *chan = p;
319
320	pchan = chan->con_priv;
321
322	if (pcc_chan_reg_read_modify_write(&pchan->plat_irq_ack))
323		return IRQ_NONE;
324
325	if (pchan->type == ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE &&
326	    !pchan->chan_in_use)
327		return IRQ_NONE;
328
329	if (!pcc_mbox_cmd_complete_check(pchan))
330		return IRQ_NONE;
331
332	if (pcc_mbox_error_check_and_clear(pchan))
333		return IRQ_NONE;
334
335	/*
336	 * Clear this flag after updating interrupt ack register and just
337	 * before mbox_chan_received_data() which might call pcc_send_data()
338	 * where the flag is set again to start new transfer. This is
339	 * required to avoid any possible race in updatation of this flag.
340	 */
341	pchan->chan_in_use = false;
342	mbox_chan_received_data(chan, NULL);
343
344	pcc_chan_acknowledge(pchan);
345
346	return IRQ_HANDLED;
347}
348
349/**
350 * pcc_mbox_request_channel - PCC clients call this function to
351 *		request a pointer to their PCC subspace, from which they
352 *		can get the details of communicating with the remote.
353 * @cl: Pointer to Mailbox client, so we know where to bind the
354 *		Channel.
355 * @subspace_id: The PCC Subspace index as parsed in the PCC client
356 *		ACPI package. This is used to lookup the array of PCC
357 *		subspaces as parsed by the PCC Mailbox controller.
358 *
359 * Return: Pointer to the PCC Mailbox Channel if successful or ERR_PTR.
360 */
361struct pcc_mbox_chan *
362pcc_mbox_request_channel(struct mbox_client *cl, int subspace_id)
363{
364	struct pcc_mbox_chan *pcc_mchan;
365	struct pcc_chan_info *pchan;
366	struct mbox_chan *chan;
367	int rc;
368
369	if (subspace_id < 0 || subspace_id >= pcc_chan_count)
370		return ERR_PTR(-ENOENT);
371
372	pchan = chan_info + subspace_id;
373	chan = pchan->chan.mchan;
374	if (IS_ERR(chan) || chan->cl) {
375		pr_err("Channel not found for idx: %d\n", subspace_id);
376		return ERR_PTR(-EBUSY);
377	}
378
379	rc = mbox_bind_client(chan, cl);
380	if (rc)
381		return ERR_PTR(rc);
382
383	pcc_mchan = &pchan->chan;
384	pcc_mchan->shmem = acpi_os_ioremap(pcc_mchan->shmem_base_addr,
385					   pcc_mchan->shmem_size);
386	if (pcc_mchan->shmem)
387		return pcc_mchan;
388
389	mbox_free_channel(chan);
390	return ERR_PTR(-ENXIO);
391}
392EXPORT_SYMBOL_GPL(pcc_mbox_request_channel);
393
394/**
395 * pcc_mbox_free_channel - Clients call this to free their Channel.
396 *
397 * @pchan: Pointer to the PCC mailbox channel as returned by
398 *	   pcc_mbox_request_channel()
399 */
400void pcc_mbox_free_channel(struct pcc_mbox_chan *pchan)
401{
402	struct mbox_chan *chan = pchan->mchan;
403	struct pcc_chan_info *pchan_info;
404	struct pcc_mbox_chan *pcc_mbox_chan;
405
406	if (!chan || !chan->cl)
407		return;
408	pchan_info = chan->con_priv;
409	pcc_mbox_chan = &pchan_info->chan;
410	if (pcc_mbox_chan->shmem) {
411		iounmap(pcc_mbox_chan->shmem);
412		pcc_mbox_chan->shmem = NULL;
413	}
414
415	mbox_free_channel(chan);
416}
417EXPORT_SYMBOL_GPL(pcc_mbox_free_channel);
418
419/**
420 * pcc_send_data - Called from Mailbox Controller code. Used
421 *		here only to ring the channel doorbell. The PCC client
422 *		specific read/write is done in the client driver in
423 *		order to maintain atomicity over PCC channel once
424 *		OS has control over it. See above for flow of operations.
425 * @chan: Pointer to Mailbox channel over which to send data.
426 * @data: Client specific data written over channel. Used here
427 *		only for debug after PCC transaction completes.
428 *
429 * Return: Err if something failed else 0 for success.
430 */
431static int pcc_send_data(struct mbox_chan *chan, void *data)
432{
433	int ret;
434	struct pcc_chan_info *pchan = chan->con_priv;
435
436	ret = pcc_chan_reg_read_modify_write(&pchan->cmd_update);
437	if (ret)
438		return ret;
439
440	ret = pcc_chan_reg_read_modify_write(&pchan->db);
441	if (!ret && pchan->plat_irq > 0)
442		pchan->chan_in_use = true;
443
444	return ret;
445}
446
447/**
448 * pcc_startup - Called from Mailbox Controller code. Used here
449 *		to request the interrupt.
450 * @chan: Pointer to Mailbox channel to startup.
451 *
452 * Return: Err if something failed else 0 for success.
453 */
454static int pcc_startup(struct mbox_chan *chan)
455{
456	struct pcc_chan_info *pchan = chan->con_priv;
457	unsigned long irqflags;
458	int rc;
459
460	if (pchan->plat_irq > 0) {
461		irqflags = pcc_chan_plat_irq_can_be_shared(pchan) ?
462						IRQF_SHARED : 0;
463		rc = devm_request_irq(chan->mbox->dev, pchan->plat_irq, pcc_mbox_irq,
464				      irqflags, MBOX_IRQ_NAME, chan);
465		if (unlikely(rc)) {
466			dev_err(chan->mbox->dev, "failed to register PCC interrupt %d\n",
467				pchan->plat_irq);
468			return rc;
469		}
470	}
471
472	return 0;
473}
474
475/**
476 * pcc_shutdown - Called from Mailbox Controller code. Used here
477 *		to free the interrupt.
478 * @chan: Pointer to Mailbox channel to shutdown.
479 */
480static void pcc_shutdown(struct mbox_chan *chan)
481{
482	struct pcc_chan_info *pchan = chan->con_priv;
483
484	if (pchan->plat_irq > 0)
485		devm_free_irq(chan->mbox->dev, pchan->plat_irq, chan);
486}
487
488static const struct mbox_chan_ops pcc_chan_ops = {
489	.send_data = pcc_send_data,
490	.startup = pcc_startup,
491	.shutdown = pcc_shutdown,
492};
493
494/**
495 * parse_pcc_subspace - Count PCC subspaces defined
496 * @header: Pointer to the ACPI subtable header under the PCCT.
497 * @end: End of subtable entry.
498 *
499 * Return: If we find a PCC subspace entry of a valid type, return 0.
500 *	Otherwise, return -EINVAL.
501 *
502 * This gets called for each entry in the PCC table.
503 */
504static int parse_pcc_subspace(union acpi_subtable_headers *header,
505		const unsigned long end)
506{
507	struct acpi_pcct_subspace *ss = (struct acpi_pcct_subspace *) header;
508
509	if (ss->header.type < ACPI_PCCT_TYPE_RESERVED)
510		return 0;
511
512	return -EINVAL;
513}
514
515static int
516pcc_chan_reg_init(struct pcc_chan_reg *reg, struct acpi_generic_address *gas,
517		  u64 preserve_mask, u64 set_mask, u64 status_mask, char *name)
518{
519	if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
520		if (!(gas->bit_width >= 8 && gas->bit_width <= 64 &&
521		      is_power_of_2(gas->bit_width))) {
522			pr_err("Error: Cannot access register of %u bit width",
523			       gas->bit_width);
524			return -EFAULT;
525		}
526
527		reg->vaddr = acpi_os_ioremap(gas->address, gas->bit_width / 8);
528		if (!reg->vaddr) {
529			pr_err("Failed to ioremap PCC %s register\n", name);
530			return -ENOMEM;
531		}
532	}
533	reg->gas = gas;
534	reg->preserve_mask = preserve_mask;
535	reg->set_mask = set_mask;
536	reg->status_mask = status_mask;
537	return 0;
538}
539
540/**
541 * pcc_parse_subspace_irq - Parse the PCC IRQ and PCC ACK register
542 *
543 * @pchan: Pointer to the PCC channel info structure.
544 * @pcct_entry: Pointer to the ACPI subtable header.
545 *
546 * Return: 0 for Success, else errno.
547 *
548 * There should be one entry per PCC channel. This gets called for each
549 * entry in the PCC table. This uses PCCY Type1 structure for all applicable
550 * types(Type 1-4) to fetch irq
551 */
552static int pcc_parse_subspace_irq(struct pcc_chan_info *pchan,
553				  struct acpi_subtable_header *pcct_entry)
554{
555	int ret = 0;
556	struct acpi_pcct_hw_reduced *pcct_ss;
557
558	if (pcct_entry->type < ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE ||
559	    pcct_entry->type > ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE)
560		return 0;
561
562	pcct_ss = (struct acpi_pcct_hw_reduced *)pcct_entry;
563	pchan->plat_irq = pcc_map_interrupt(pcct_ss->platform_interrupt,
564					    (u32)pcct_ss->flags);
565	if (pchan->plat_irq <= 0) {
566		pr_err("PCC GSI %d not registered\n",
567		       pcct_ss->platform_interrupt);
568		return -EINVAL;
569	}
570	pchan->plat_irq_flags = pcct_ss->flags;
571
572	if (pcct_ss->header.type == ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2) {
573		struct acpi_pcct_hw_reduced_type2 *pcct2_ss = (void *)pcct_ss;
574
575		ret = pcc_chan_reg_init(&pchan->plat_irq_ack,
576					&pcct2_ss->platform_ack_register,
577					pcct2_ss->ack_preserve_mask,
578					pcct2_ss->ack_write_mask, 0,
579					"PLAT IRQ ACK");
580
581	} else if (pcct_ss->header.type == ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE ||
582		   pcct_ss->header.type == ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE) {
583		struct acpi_pcct_ext_pcc_master *pcct_ext = (void *)pcct_ss;
584
585		ret = pcc_chan_reg_init(&pchan->plat_irq_ack,
586					&pcct_ext->platform_ack_register,
587					pcct_ext->ack_preserve_mask,
588					pcct_ext->ack_set_mask, 0,
589					"PLAT IRQ ACK");
590	}
591
592	if (pcc_chan_plat_irq_can_be_shared(pchan) &&
593	    !pchan->plat_irq_ack.gas) {
594		pr_err("PCC subspace has level IRQ with no ACK register\n");
595		return -EINVAL;
596	}
597
598	return ret;
599}
600
601/**
602 * pcc_parse_subspace_db_reg - Parse the PCC doorbell register
603 *
604 * @pchan: Pointer to the PCC channel info structure.
605 * @pcct_entry: Pointer to the ACPI subtable header.
606 *
607 * Return: 0 for Success, else errno.
608 */
609static int pcc_parse_subspace_db_reg(struct pcc_chan_info *pchan,
610				     struct acpi_subtable_header *pcct_entry)
611{
612	int ret = 0;
613
614	if (pcct_entry->type <= ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2) {
615		struct acpi_pcct_subspace *pcct_ss;
616
617		pcct_ss = (struct acpi_pcct_subspace *)pcct_entry;
618
619		ret = pcc_chan_reg_init(&pchan->db,
620					&pcct_ss->doorbell_register,
621					pcct_ss->preserve_mask,
622					pcct_ss->write_mask, 0,	"Doorbell");
623
624	} else {
625		struct acpi_pcct_ext_pcc_master *pcct_ext;
626
627		pcct_ext = (struct acpi_pcct_ext_pcc_master *)pcct_entry;
628
629		ret = pcc_chan_reg_init(&pchan->db,
630					&pcct_ext->doorbell_register,
631					pcct_ext->preserve_mask,
632					pcct_ext->write_mask, 0, "Doorbell");
633		if (ret)
634			return ret;
635
636		ret = pcc_chan_reg_init(&pchan->cmd_complete,
637					&pcct_ext->cmd_complete_register,
638					0, 0, pcct_ext->cmd_complete_mask,
639					"Command Complete Check");
640		if (ret)
641			return ret;
642
643		ret = pcc_chan_reg_init(&pchan->cmd_update,
644					&pcct_ext->cmd_update_register,
645					pcct_ext->cmd_update_preserve_mask,
646					pcct_ext->cmd_update_set_mask, 0,
647					"Command Complete Update");
648		if (ret)
649			return ret;
650
651		ret = pcc_chan_reg_init(&pchan->error,
652					&pcct_ext->error_status_register,
653					~pcct_ext->error_status_mask, 0,
654					pcct_ext->error_status_mask,
655					"Error Status");
656	}
657	return ret;
658}
659
660/**
661 * pcc_parse_subspace_shmem - Parse the PCC Shared Memory Region information
662 *
663 * @pchan: Pointer to the PCC channel info structure.
664 * @pcct_entry: Pointer to the ACPI subtable header.
665 *
666 */
667static void pcc_parse_subspace_shmem(struct pcc_chan_info *pchan,
668				     struct acpi_subtable_header *pcct_entry)
669{
670	if (pcct_entry->type <= ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2) {
671		struct acpi_pcct_subspace *pcct_ss =
672			(struct acpi_pcct_subspace *)pcct_entry;
673
674		pchan->chan.shmem_base_addr = pcct_ss->base_address;
675		pchan->chan.shmem_size = pcct_ss->length;
676		pchan->chan.latency = pcct_ss->latency;
677		pchan->chan.max_access_rate = pcct_ss->max_access_rate;
678		pchan->chan.min_turnaround_time = pcct_ss->min_turnaround_time;
679	} else {
680		struct acpi_pcct_ext_pcc_master *pcct_ext =
681			(struct acpi_pcct_ext_pcc_master *)pcct_entry;
682
683		pchan->chan.shmem_base_addr = pcct_ext->base_address;
684		pchan->chan.shmem_size = pcct_ext->length;
685		pchan->chan.latency = pcct_ext->latency;
686		pchan->chan.max_access_rate = pcct_ext->max_access_rate;
687		pchan->chan.min_turnaround_time = pcct_ext->min_turnaround_time;
688	}
689}
690
691/**
692 * acpi_pcc_probe - Parse the ACPI tree for the PCCT.
693 *
694 * Return: 0 for Success, else errno.
695 */
696static int __init acpi_pcc_probe(void)
697{
698	int count, i, rc = 0;
699	acpi_status status;
700	struct acpi_table_header *pcct_tbl;
701	struct acpi_subtable_proc proc[ACPI_PCCT_TYPE_RESERVED];
702
703	status = acpi_get_table(ACPI_SIG_PCCT, 0, &pcct_tbl);
704	if (ACPI_FAILURE(status) || !pcct_tbl)
705		return -ENODEV;
706
707	/* Set up the subtable handlers */
708	for (i = ACPI_PCCT_TYPE_GENERIC_SUBSPACE;
709	     i < ACPI_PCCT_TYPE_RESERVED; i++) {
710		proc[i].id = i;
711		proc[i].count = 0;
712		proc[i].handler = parse_pcc_subspace;
713	}
714
715	count = acpi_table_parse_entries_array(ACPI_SIG_PCCT,
716			sizeof(struct acpi_table_pcct), proc,
717			ACPI_PCCT_TYPE_RESERVED, MAX_PCC_SUBSPACES);
718	if (count <= 0 || count > MAX_PCC_SUBSPACES) {
719		if (count < 0)
720			pr_warn("Error parsing PCC subspaces from PCCT\n");
721		else
722			pr_warn("Invalid PCCT: %d PCC subspaces\n", count);
723
724		rc = -EINVAL;
725	} else {
726		pcc_chan_count = count;
727	}
728
729	acpi_put_table(pcct_tbl);
730
731	return rc;
732}
733
734/**
735 * pcc_mbox_probe - Called when we find a match for the
736 *	PCCT platform device. This is purely used to represent
737 *	the PCCT as a virtual device for registering with the
738 *	generic Mailbox framework.
739 *
740 * @pdev: Pointer to platform device returned when a match
741 *	is found.
742 *
743 *	Return: 0 for Success, else errno.
744 */
745static int pcc_mbox_probe(struct platform_device *pdev)
746{
747	struct device *dev = &pdev->dev;
748	struct mbox_controller *pcc_mbox_ctrl;
749	struct mbox_chan *pcc_mbox_channels;
750	struct acpi_table_header *pcct_tbl;
751	struct acpi_subtable_header *pcct_entry;
752	struct acpi_table_pcct *acpi_pcct_tbl;
753	acpi_status status = AE_OK;
754	int i, rc, count = pcc_chan_count;
755
756	/* Search for PCCT */
757	status = acpi_get_table(ACPI_SIG_PCCT, 0, &pcct_tbl);
758
759	if (ACPI_FAILURE(status) || !pcct_tbl)
760		return -ENODEV;
761
762	pcc_mbox_channels = devm_kcalloc(dev, count, sizeof(*pcc_mbox_channels),
763					 GFP_KERNEL);
764	if (!pcc_mbox_channels) {
765		rc = -ENOMEM;
766		goto err;
767	}
768
769	chan_info = devm_kcalloc(dev, count, sizeof(*chan_info), GFP_KERNEL);
770	if (!chan_info) {
771		rc = -ENOMEM;
772		goto err;
773	}
774
775	pcc_mbox_ctrl = devm_kzalloc(dev, sizeof(*pcc_mbox_ctrl), GFP_KERNEL);
776	if (!pcc_mbox_ctrl) {
777		rc = -ENOMEM;
778		goto err;
779	}
780
781	/* Point to the first PCC subspace entry */
782	pcct_entry = (struct acpi_subtable_header *) (
783		(unsigned long) pcct_tbl + sizeof(struct acpi_table_pcct));
784
785	acpi_pcct_tbl = (struct acpi_table_pcct *) pcct_tbl;
786	if (acpi_pcct_tbl->flags & ACPI_PCCT_DOORBELL)
787		pcc_mbox_ctrl->txdone_irq = true;
788
789	for (i = 0; i < count; i++) {
790		struct pcc_chan_info *pchan = chan_info + i;
791
792		pcc_mbox_channels[i].con_priv = pchan;
793		pchan->chan.mchan = &pcc_mbox_channels[i];
794
795		if (pcct_entry->type == ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE &&
796		    !pcc_mbox_ctrl->txdone_irq) {
797			pr_err("Platform Interrupt flag must be set to 1");
798			rc = -EINVAL;
799			goto err;
800		}
801
802		if (pcc_mbox_ctrl->txdone_irq) {
803			rc = pcc_parse_subspace_irq(pchan, pcct_entry);
804			if (rc < 0)
805				goto err;
806		}
807		rc = pcc_parse_subspace_db_reg(pchan, pcct_entry);
808		if (rc < 0)
809			goto err;
810
811		pcc_parse_subspace_shmem(pchan, pcct_entry);
812
813		pchan->type = pcct_entry->type;
814		pcct_entry = (struct acpi_subtable_header *)
815			((unsigned long) pcct_entry + pcct_entry->length);
816	}
817
818	pcc_mbox_ctrl->num_chans = count;
819
820	pr_info("Detected %d PCC Subspaces\n", pcc_mbox_ctrl->num_chans);
821
822	pcc_mbox_ctrl->chans = pcc_mbox_channels;
823	pcc_mbox_ctrl->ops = &pcc_chan_ops;
824	pcc_mbox_ctrl->dev = dev;
825
826	pr_info("Registering PCC driver as Mailbox controller\n");
827	rc = mbox_controller_register(pcc_mbox_ctrl);
828	if (rc)
829		pr_err("Err registering PCC as Mailbox controller: %d\n", rc);
830	else
831		return 0;
832err:
833	acpi_put_table(pcct_tbl);
834	return rc;
835}
836
837static struct platform_driver pcc_mbox_driver = {
838	.probe = pcc_mbox_probe,
839	.driver = {
840		.name = "PCCT",
841	},
842};
843
844static int __init pcc_init(void)
845{
846	int ret;
847	struct platform_device *pcc_pdev;
848
849	if (acpi_disabled)
850		return -ENODEV;
851
852	/* Check if PCC support is available. */
853	ret = acpi_pcc_probe();
854
855	if (ret) {
856		pr_debug("ACPI PCC probe failed.\n");
857		return -ENODEV;
858	}
859
860	pcc_pdev = platform_create_bundle(&pcc_mbox_driver,
861			pcc_mbox_probe, NULL, 0, NULL, 0);
862
863	if (IS_ERR(pcc_pdev)) {
864		pr_debug("Err creating PCC platform bundle\n");
865		pcc_chan_count = 0;
866		return PTR_ERR(pcc_pdev);
867	}
868
869	return 0;
870}
871
872/*
873 * Make PCC init postcore so that users of this mailbox
874 * such as the ACPI Processor driver have it available
875 * at their init.
876 */
877postcore_initcall(pcc_init);