// SPDX-License-Identifier: GPL-2.0-only
/*
 * inv_mpu_acpi: ACPI processing for creating client devices
 * Copyright (c) 2015, Intel Corporation.
 */

#ifdef CONFIG_ACPI

#include <linux/kernel.h>
#include <linux/i2c.h>
#include <linux/dmi.h>
#include <linux/acpi.h>
#include <linux/wordpart.h>

#include "inv_mpu_iio.h"

enum inv_mpu_product_name {
 INV_MPU_NOT_MATCHED,
 INV_MPU_ASUS_T100TA,
};

static enum inv_mpu_product_name matched_product_name;

static int __init asus_t100_matched(const struct dmi_system_id *d)
{
 matched_product_name = INV_MPU_ASUS_T100TA;

 return 0;
}

static const struct dmi_system_id inv_mpu_dev_list[] = {
 {
 .callback = asus_t100_matched,
 .ident = "Asus Transformer Book T100",
  .matches = {
   DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC"),
   DMI_MATCH(DMI_PRODUCT_NAME, "T100TA"),
   DMI_MATCH(DMI_PRODUCT_VERSION, "1.0"),
  },
 },
 /* Add more matching tables here..*/
 { }
};

static int asus_acpi_get_sensor_info(struct acpi_device *adev,
         struct i2c_client *client,
         struct i2c_board_info *info)
{
 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
 int i;
 acpi_status status;
 union acpi_object *cpm;
 int ret;

 status = acpi_evaluate_object(adev->handle, "CNF0", NULL, &buffer);
 if (ACPI_FAILURE(status))
  return -ENODEV;

 cpm = buffer.pointer;
 for (i = 0; i < cpm->package.count; ++i) {
  union acpi_object *elem;
  int j;

  elem = &cpm->package.elements[i];
  for (j = 0; j < elem->package.count; ++j) {
   union acpi_object *sub_elem;

   sub_elem = &elem->package.elements[j];
   if (sub_elem->type == ACPI_TYPE_STRING)
    strscpy(info->type, sub_elem->string.pointer,
     sizeof(info->type));
   else if (sub_elem->type == ACPI_TYPE_INTEGER) {
    if (sub_elem->integer.value != client->addr) {
     info->addr = sub_elem->integer.value;
     break; /* Not a MPU6500 primary */
    }
   }
  }
 }
 ret = cpm->package.count;
 kfree(buffer.pointer);

 return ret;
}

static int acpi_i2c_check_resource(struct acpi_resource *ares, void *data)
{
 struct acpi_resource_i2c_serialbus *sb;
 u32 *addr = data;

 if (i2c_acpi_get_i2c_resource(ares, &sb)) {
  if (*addr)
   *addr |= (sb->slave_address << 16);
  else
   *addr = sb->slave_address;
 }

 /* Tell the ACPI core that we already copied this address */
 return 1;
}

static int inv_mpu_process_acpi_config(struct i2c_client *client,
           unsigned short *primary_addr,
           unsigned short *secondary_addr)
{
 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
 u32 i2c_addr = 0;
 LIST_HEAD(resources);
 int ret;

 if (!is_acpi_device_node(dev_fwnode(&client->dev)))
  return -ENODEV;

 ret = acpi_dev_get_resources(adev, &resources,
         acpi_i2c_check_resource, &i2c_addr);
 if (ret < 0)
  return ret;

 acpi_dev_free_resource_list(&resources);
 *primary_addr = lower_16_bits(i2c_addr);
 *secondary_addr = upper_16_bits(i2c_addr);

 return 0;
}

int inv_mpu_acpi_create_mux_client(struct i2c_client *client)
{
 struct inv_mpu6050_state *st = iio_priv(dev_get_drvdata(&client->dev));
 struct acpi_device *adev = ACPI_COMPANION(&client->dev);

 st->mux_client = NULL;
 if (adev) {
  struct i2c_board_info info = { };
  struct i2c_client *mux_client;
  int ret = -1;

  dmi_check_system(inv_mpu_dev_list);
  switch (matched_product_name) {
  case INV_MPU_ASUS_T100TA:
   ret = asus_acpi_get_sensor_info(adev, client,
       &info);
   break;
  /* Add more matched product processing here */
  default:
   break;
  }

  if (ret < 0) {
   /* No matching DMI, so create device on INV6XX type */
   unsigned short primary, secondary;

   ret = inv_mpu_process_acpi_config(client, &primary,
         &secondary);
   if (!ret && secondary) {
    char *name;

    info.addr = secondary;
    strscpy(info.type, dev_name(&adev->dev),
     sizeof(info.type));
    name = strchr(info.type, ':');
    if (name)
     *name = '\0';
    strlcat(info.type, "-client",
     sizeof(info.type));
   } else
    return 0; /* no secondary addr, which is OK */
  }
  mux_client = i2c_new_client_device(st->muxc->adapter[0], &info);
  if (IS_ERR(mux_client))
   return PTR_ERR(mux_client);
  st->mux_client = mux_client;
 }

 return 0;
}

void inv_mpu_acpi_delete_mux_client(struct i2c_client *client)
{
 struct inv_mpu6050_state *st = iio_priv(dev_get_drvdata(&client->dev));

 i2c_unregister_device(st->mux_client);
}
#else

#include "inv_mpu_iio.h"

int inv_mpu_acpi_create_mux_client(struct i2c_client *client)
{
 return 0;
}

void inv_mpu_acpi_delete_mux_client(struct i2c_client *client)
{
}
#endif