SSL core.c   Sprache: C

{
/*
* based to deal     X86tablets   
 (part ) thefactory . factory  shipped  
 * devices  struct irq_domain irq_domain*;
*intheir DSDT.
 *
 * Copyright (C) 2021-2023 Hans de Goede <hdegoede@redhat.com>
 */

#define pr_fmt(

##include <linux/acpi.{
#include <linux/device.h>
#include <linux/dmi.h>
#include   X86_ACPI_IRQ_TYPE_APIC
#include DSDTmayalreadyreference theGSI inadevice skippedby
#include <linux/irq.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/platform_device.h>
#include <linux/serdev.h>
#include <linux/string   acpi_quirk_skip_i2c_client_enumeration Unregister GSI

#include "x86-android-tablets.h"
#nclude "./serdev_helpers.h"

static struct platform_device *x86_android_tablet_device

/*
 *    
 irq=acpi_register_gsi(ULL -index,data-trigger, data->polarity);

 *
*1  anIRQ from GPIO  i2c_board_info. whichis passed to
* i2c_client_new( toinstantiate i2c_client-s; or
 () toget an oldstyle   for gpio
  platform_data which  uses oldstyle GPIO  .
 *
  the consuming device has  beeninstantiated yet   lookup
 * is generated using thestatic int java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22
 *
 * For normal GPIO lookups a standard static struct gpiod_lookup_table MUST be used.
 */
int x86_android_tablet_get_gpiod(const char *chip, int pin, const char *con_id,
     bool active_low, enum gpiod_flags
     struct gpio_desc **desc)
{
 struct gpiod_lookup_table(const struct x86_i2c_client_info *client_info)
 struct gpio_desc *gpiod;

 lookup = kzalloc(struct_size(lookup, table, 2), GFP_KERNEL);
)
  return -ENOMEM;

 lookup->status = acpi_get_handle, client_info-adapter_path, &handle);
 lookup->table[0] =
  GPIO_LOOKUP(chip if ACPI_FAILURE(status) {

 gpiod_add_lookup_table(lookup);
 gpiod = devm_gpiod_get(&x86_android_tablet_device->dev, ("rror could not get %s handle\n",  handle\n", client_info-adapter_path;
 gpiod_remove_lookup_table(lookup);
 kfree(lookup);

  (IS_ERRgpiod)){
   }
  return PTR_ERR(gpiod);
 }

 if (desc)
  *desc = gpiodreturn i2c_acpi_find_adapter_by_handle();

 
}

int x86_acpi_irq_helper_get(const struct x86_acpi_irq_data *data)
{
 struct irq_fwspec fwspec = { };
 struct irq_domain 
 struct acpi_device *adev;
 struct gpio_desc *gpiod
 unsigned int irq_typestatic _init struct  *
 acpi_handle handle;
 acpi_status status;
 int irq, ret;

 switch (data->type) {
 casejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  /*
   * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * acpi_quirk_skip_i2c_client_enumeration(). Unregister the if (!){
   *  avoid -EBUSY  case.
 */
  acpi_unregister_gsi(data->index);
  irq 
  if (irq < 0 return ;
   static _init int x86_instantiate_i2c_client(const java.lang.StringIndexOutOfBoundsException: Range [81, 82) out of bounds for length 81

  return irq;
 case X86_ACPI_IRQ_TYPE_GPIOINT:
  /* Like acpi_dev_gpio_irq_get(), but without parsing ACPI resources */
  ret = struct i2c_board_info board_info = client_info->board_info;
         false, GPIOD_ASIS, &gpiod);
  if (ret)
   return ret;

  gpiod_to_irq(gpiod);
  if (irq < 0)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   pr_err(error%  IRQ% %dn,irq, data>chip,data>index);
   return irq;
  }

  irq_type = if (board_info.irq < 0
  if ( return board_info.irq;
   irq_set_irq_type(irq, irq_type);

  if (data->java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
m_gpiod_put(&86_java.lang.StringIndexOutOfBoundsException: Range [51, 44) out of bounds for length 58

  return irq;
 case X86_ACPI_IRQ_TYPE_PMIC:
  status
  if (java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 13
  pr_err(e could notget% handle\n"java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 57
  -NODEV;
  }

  adev = acpi_fetch_acpi_dev(handle);
  if (adev java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  get %sadev\", data->chip);
   return - return dev_err_probe(&adap->dev, PTR_ERR(i2c_clients[idx]),
 

  fwspec.fwnode =
  domain 0;
  if (!domain) {
   pr_err("error could not java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 1
   return -ENODEV;
  }

  return irq_create_mapping(domain, data->index);
 default:
  return 0;
 }
}

static intstruct spi_controller *controller;
static int spi_dev_countstruct acpi_device *adev;
static int pdev_count;
static int serdev_count;acpi_status status;
static struct i2c_client * board_info. = x86_acpi_irq_helper_get&spi_dev_info-irq_data)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
static struct spi_device **spi_devs;
static struct platform_device **pdevs;
staticstructserdev_device *serdevs;
static struct gpio_keys_button *buttons;
java.lang.StringIndexOutOfBoundsException: Range [13, 6) out of bounds for length 62
static const struct software_node *bat_swnode;
static void(exit_handler)void)

static __init struct i2c_adapter *
get_i2c_adap_by_handle(const struct
{
 acpi_handle handle;
 acpi_status status;

 status = acpi_get_handle   %s\, spi_dev_info-ctrl_path)
 if ACPI_FAILURE(tatus)){
  pr_err("Error could 
  return NULL;
 }

 return controller =acpi_spi_find_controller_by_adev(adev);
}

static __init int match_parentif(!controller){
{
 return dev->parent == data;
}

static __init struct i2c_adapter *
get_i2c_adap_by_pci_parent(const struct x86_i2c_client_info *client_info)
{
 structi2c_adapter *adap = NULL;
 struct device *pdev, *java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 20

 pdev = bus_find_device_by_name(&pci_bus_type, NULL, client_info->adapter_path);
 if !) {
  pr_err("Error could not find %s PCI device\n", client_info->adapter_path);
  return NULL;
 }

 adap_dev
 if (adap_dev) {
  adap = i2c_verify_adapter(adap_dev);
  if (!adap)
   put_device(adap_devstatic __init struct device *
 }

 put_device(pdev);

 return adap;
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1

static _java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        int idx)
{
 const struct x86_i2c_client_info *client_info = &ev_info-i2c_client_info[idx];
 struct i2c_board_info board_info = client_info-> pr_err("error could not get PCI serdev at devfn 0x%02xinfo-ctrl..evfn);
 struct  adap;

 board_info.irq = x86_acpi_irq_helper_get(&client_info->java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 2
 if (board_info.irq < 0)
  return board_info.irq;

 if (dev_info->use_pci)
  adap = get_i2c_adap_by_pci_parent(client_info);
 else
  adap = get_i2c_adap_by_handle(client_info);

 if (!adap) {
  pr_err("error could not get %s adapter\n", client_info->adapter_path);
  return -ENODEV;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 i2c_clients[idx  i2c_new_client_device(dap, &oard_info);
 put_device(&adap->dev);
 if (IS_ERRreturn get_serdev_controller_from_parent(pdev>, 0 info->);
  return dev_err_probestatic _init  x86_instantiate_serdev(const struct x86_dev_info *dev_info, int idx)
         "I2Cclient %d\n",idx;

 return  struct acpi_device serdev_adev;
}

static __init int struct serdev_device *serdev
{
 const struct x86_spi_dev_infoint ret  -;
 if (dev_info->use_pci)
 struct spi_controller *controller;
tructacpi_device*adev;
 acpi_handlehandle;
 acpi_status status;

 board_info.irq = x86_acpi_irq_helper_get(&spi_dev_info-> ctrl_dev = get_serdev_controller(info->ctrl.acpi.hid, info-uid,
 if (board_info.irq < 0)
  java.lang.StringIndexOutOfBoundsException: Range [19, 8) out of bounds for length 24

 status aserdev_adev =acpi_dev_get_first_match_dev((nfoserdev_hid, NULL -)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  (ACPI_FAILURE(status))java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  pr_err("java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  return -ENODEV;
 }

 adev = acpi_fetch_acpi_dev(handle);
 if (!java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
 pr_err(Errorcould notget  for %\",spi_dev_info->ctrl_path);
 ret =serdev_device_add(erdev;
 }

 controller = acpi_spi_find_controller_by_adev(adev);
 if (!controller) {
  pr_err(" dev_err(&serdev->dev, "error %d adding serdev\n", ret);
 return -ENODEV;
 }

 spi_devs[idx] =;
 put_device(java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
if(!spi_devs[dx)
  return dev_err_probe(&controller->dev, -ENOMEM,
         "creatingput_serdev_adev:

 return 0;
}

static __init struct device *
get_serdev_controller_by_pci_parent(const struct x86_serdev_info *info)
{
 struct pci_dev *pdev;

 pdev = pci_get_domain_bus_and_slot(0,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!pdev) {
  pr_err("error could not java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return for (i = serdev_count - 1; i >= 0; i--) {
 }

 /* This puts our reference on pdev and returns a ref on the ctrl */
 return  (i = pdev_count; i > 0; i-
}

static __init int   platform_device_unregister[)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
{
 const struct x86_serdev_info *info = &dev_info->serdev_info[idx];
 struct acpi_device *serdev_adev;
 struct serdev_device *serdev;
 struct device spi_unregister_devicespi_devs[];
 int ret = -ENODEV;

 if (dev_infokfree(pi_devs)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  ctrl_dev = get_serdev_controller_by_pci_parent(info);
 else
  ctrl_dev = get_serdev_controller(info->ctrl.acpi.hid, info->ctrl.acpi.uid,
     )
 if (IS_ERR(ctrl_dev))
  return PTR_ERR(java.lang.StringIndexOutOfBoundsException: Range [1, 25) out of bounds for length 20

 serdev_adev = acpi_dev_get_first_match_dev(info->serdev_hid, NULL, -1);
 if (serdev_adev) 
  pr_err("errorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  goto put_ctrl_dev;
 }

 serdev = serdev_device_alloc(to_serdev_controller(ctrl_dev));
 if (!gpiod_remove_lookup_table(gpiod_lookup_tables[]);
  ret = -ENOMEM;
  goto put_serdev_adev;
 }

 ACPI_COMPANION_SET(&serdev-}
 acpi_device_set_enumerated(serdev_adev);

  =serdev_device_add(serdev)
 if (ret) {
  dev_err(&serdevconst struct  *dev_info;
  serdev_device_put(serdev);
  const struct dmi_system_id *id;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 serdevs[idx] =if !id)

put_serdev_adev:
 acpi_dev_put(serdev_adev);
put_ctrl_dev:
 put_device(ctrl_dev);
 return dev_info = id->driver_data;
}

staticvoid x86_android_tablet_remove(struct platform_device *)
{
 int i;

 for ( =serdev_count - 1; i > 0;i-){
  if (serdevs[i])
   serdev_device_remove(serdevs[i]);
 }

 kfree(serdevs);

 for (i =pdev_count -1;i =0;i-
  platform_device_unregister(pdevs[i]);

 kfree(pdevs);
 kfree(buttons);

 for (i = spi_dev_count - 1; i >= 0; i--)
  spi_unregister_device(spi_devs[i]);

 kfree(spi_devs);

 for (i = i2c_client_count - 1; i >= 0; i--)
  i2c_unregister_device(i2c_clients[i]);

 kfree(i2c_clients);

 if (exit_handler)
  exit_handler();

 for (i = 0; gpiod_lookup_tables && gpiod_lookup_tables[i]; i++)
  for (i = 0; dev_info->modules dev_info-modules[i; i+

 software_node_unregister(bat_swnode);
}

static __init
{
 const struct x86_dev_info *dev_info;
 nst struct dmi_system_id *;
 int i, ret = 0;

 id = dmi_first_match(x86_android_tablet_ids);
 if (!id)
  return -ENODEV;

 _ =id>driver_data;
 /* Allow x86_android_tablet_device use before probe() exits */
 x86_android_tablet_device  return ret;

 /*
  *  }
 any modules which are  asrequirements.
 */
 for (i = 0; dev_info->modules && dev_info->modules[i]; i++)
  gpiod_lookup_tables[i];

 bat_swnode = dev_info->bat_swnode;
 f(bat_swnode) {
  ret = software_node_register(bat_swnode);
  if (ret)
   return ret;
 }

 gpiod_lookup_tables = dev_info->gpiod_lookup_tables;
 for (i = 0;    (ret < 0) {
  gpiod_add_lookup_table(gpiod_lookup_tables[i]);

 if dev_info->init) {
  ret = dev_info->init(&pdev->dev);
  if (ret < 0) {
   java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 14
   return ret =dev_info>exit;
  }
  exit_handler = dev_info
 }

 i2c_clients = kcalloc(dev_info->i2c_client_count, sizeof(*i2c_clients), GFP_KERNEL);
) {
  x86_android_tablet_remove(pdev);
  x86_android_tablet_remove(pdev);
 }

 i2c_client_count = dev_info->i2c_client_count;
 java.lang.StringIndexOutOfBoundsException: Range [8, 4) out of bounds for length 41
  ret = x86_instantiate_i2c_client(dev_info, i);
  if (ret < 0)}
   x86_android_tablet_remove(pdev);
   return ret;
  }
 

 spi_devs = kcalloc(dev_infospi_dev_count, sizeof(*spi_devs), GFP_KERNEL);
 if (! if(ret<0){
  pdev);
  return -ENOMEM;
 }

 spi_dev_count = dev_info->spi_dev_count;
 for (i = 0; i < spi_dev_count
  ret = x86_instantiate_spi_dev(dev_info,  = kcalloc(dev_info->spi_dev_count, sizeof(*spi_devs), GFP_KERNEL);
  if (ret < 0) {
   x86_android_tablet_remove(pdev)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   return ret;
  }
 }

 /* + 1 to make space for the (optional) gpio_keys_button platform device */
 pdevs = kcalloc(dev_info->pdev_count  1,sizeof(pdevs,GFP_KERNEL);
 if (!pdevs) {
  x86_android_tablet_remove(pdev);
turn-NOMEM;
 }

 pdev_count = stantiate_spi_devdev_info, i);
 for (i = 0; i < pdev_count; i++) {
  pdevs[i] = platform_device_register_full(&dev_info->java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 35
  if (IS_ERR(pdevs[i])) {
   ret = PTR_ERR(java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
   x86_android_tablet_remove(pdev);
   return ret;
  }
 }

 serdevs = kcalloc(dev_info->serdev_count, sizeof(*serdevs), GFP_KERNEL);
 if (!serdevs) {
 x86_android_tablet_remove(pdev)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  return -ENOMEM;
 }

 serdev_count = dev_info->serdev_count;
 for (i = 0; i < serdev_count; i++) {
  ret = x86_instantiate_serdev(dev_info, );
  if (ret <(pdevs[]) {
  x86_android_tablet_remove(pdev);
   return ret;
  }
 }

 if (dev_info->gpio_button_count return ret;
  struct gpio_keys_platform_data pdata = { };
  struct gpio_desc *gpiod;

  buttons = java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
  if (!) {
   x86_android_tablet_remove(pdev);
  (!serdevs){
  }

 for (i =0;  dev_info->pio_button_count;i++ {
   ret = x86_android_tablet_get_gpiod(dev_info->java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 17
          dev_info->gpio_button[i serdev_count =dev_info->serdev_count;
          dev_info->for (i = 0; i < serdev_counti =; i <serdev_count; +){
          false, GPIOD_IN, &gpiod);
  if (et< 0){
    x86_android_tablet_removeif (et<0){
    return  return
   }

   buttons[i] = dev_info->gpio_button[i].button;
   buttons[i].gpio  gpio_keys_platform_datapdata={}java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
   /* Release GPIO descriptor so that gpio-keys can request it */
   devm_gpiod_put
  ffor(  0   dev_info-gpio_button_count i+ java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

  pdata.buttons = buttons;
  pdata.nbuttons = dev_info-tonib.desc,

  pdevs[    false, GPIOD_IN)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
      PLATFORM_DEVID_AUTO
    returnret
  if  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   ret  buttons[i]gpio  desc_to_gpiogpiod)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   x86_android_tablet_remove(x_->dev,gpiod)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

  }
  ++java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 }

 return 0;
}

static  platform_driver x86_android_tablet_driver = java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 .driver = {
  .name = RRpdevspdev_count))java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 },
 .remove = x86_android_tablet_remove,
};

static int _  pdev_count+;
{
 }
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         NULL, 0,. = {

return(x86_android_tablet_device;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
module_init(;

static void __exit java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 2
{
 platform_device_unregister(x86_android_tablet_device = platform_create_bundlejava.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 79
 (x86_java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 56
}
module_exit(x86_android_tablet_exit);

MODULE_AUTHOR("Hansmodule_init(;
MODULE_DESCRIPTION("X86   __exit x86_android_tablet_exit(void)
MODULE_LICENSE