/*
   * ACPI support for platform bus type.
   *
   * Copyright (C) 2012, Intel Corporation
   * Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
   *          Mathias Nyman <mathias.nyman@linux.intel.com>
   *          Rafael J. Wysocki <rafael.j.wysocki@intel.com>
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License version 2 as
   * published by the Free Software Foundation.
   */
  
  #include <linux/acpi.h>
  #include <linux/device.h>

  #include <linux/err.h>

  #include <linux/kernel.h>
  #include <linux/module.h>

  #include <linux/dma-mapping.h>

  #include <linux/pci.h>

  #include <linux/platform_device.h>

  #include "internal.h"

  ACPI_MODULE_NAME("platform");

  static const struct acpi_device_id forbidden_id_list[] = {

  	{"PNP0000",  0},	/* PIC */
  	{"PNP0100",  0},	/* Timer */
  	{"PNP0200",  0},	/* AT DMA Controller */
  	{"ACPI0009", 0},	/* IOxAPIC */
  	{"ACPI000A", 0},	/* IOAPIC */

  	{"SMB0001",  0},	/* ACPI SMBUS virtual device */

  	{"", 0},

  };

  static void acpi_platform_fill_resource(struct acpi_device *adev,
  	const struct resource *src, struct resource *dest)
  {
  	struct device *parent;
  
  	*dest = *src;
  
  	/*
  	 * If the device has parent we need to take its resources into
  	 * account as well because this device might consume part of those.
  	 */
  	parent = acpi_get_first_physical_node(adev->parent);
  	if (parent && dev_is_pci(parent))
  		dest->parent = pci_find_resource(to_pci_dev(parent), dest);
  }

  /**
   * acpi_create_platform_device - Create platform device for ACPI device node
   * @adev: ACPI device node to create a platform device for.

   * @properties: Optional collection of build-in properties.

   *
   * Check if the given @adev can be represented as a platform device and, if
   * that's the case, create and register a platform device, populate its common
   * resources and returns a pointer to it.  Otherwise, return %NULL.
   *

   * Name of the platform device will be the same as @adev's.

   */

  struct platform_device *acpi_create_platform_device(struct acpi_device *adev,
  					struct property_entry *properties)

  {
  	struct platform_device *pdev = NULL;

  	struct platform_device_info pdevinfo;

  	struct resource_entry *rentry;

  	struct list_head resource_list;

  	struct resource *resources = NULL;

  	int count;

  
  	/* If the ACPI node already has a physical device attached, skip it. */
  	if (adev->physical_node_count)

  		return NULL;

  	if (!acpi_match_device_ids(adev, forbidden_id_list))
  		return ERR_PTR(-EINVAL);

  	INIT_LIST_HEAD(&resource_list);
  	count = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);

  	if (count < 0) {

  		return NULL;

  	} else if (count > 0) {

  		resources = kzalloc(count * sizeof(struct resource),

  				    GFP_KERNEL);
  		if (!resources) {
  			dev_err(&adev->dev, "No memory for resources
  ");
  			acpi_dev_free_resource_list(&resource_list);

  			return ERR_PTR(-ENOMEM);

  		}
  		count = 0;
  		list_for_each_entry(rentry, &resource_list, node)

  			acpi_platform_fill_resource(adev, rentry->res,
  						    &resources[count++]);

  		acpi_dev_free_resource_list(&resource_list);

  	}

  	memset(&pdevinfo, 0, sizeof(pdevinfo));

  	/*
  	 * If the ACPI node has a parent and that parent has a physical device
  	 * attached to it, that physical device should be the parent of the
  	 * platform device we are about to create.
  	 */

  	pdevinfo.parent = adev->parent ?
  		acpi_get_first_physical_node(adev->parent) : NULL;

  	pdevinfo.name = dev_name(&adev->dev);
  	pdevinfo.id = -1;
  	pdevinfo.res = resources;
  	pdevinfo.num_res = count;

  	pdevinfo.fwnode = acpi_fwnode_handle(adev);

  	pdevinfo.properties = properties;

  
  	if (acpi_dma_supported(adev))
  		pdevinfo.dma_mask = DMA_BIT_MASK(32);
  	else
  		pdevinfo.dma_mask = 0;

  	pdev = platform_device_register_full(&pdevinfo);

  	if (IS_ERR(pdev))

  		dev_err(&adev->dev, "platform device creation failed: %ld
  ",
  			PTR_ERR(pdev));

  	else {
  		set_dev_node(&pdev->dev, acpi_get_node(adev->handle));

  		dev_dbg(&adev->dev, "created platform device %s
  ",
  			dev_name(&pdev->dev));

  	}

  	kfree(resources);

  	return pdev;
  }

  EXPORT_SYMBOL_GPL(acpi_create_platform_device);