Quellcode-Bibliothek pci-quicki2c.c   Sprache: C

/* SPDX-License-Identifier: GPL-2.0 */
/* Copyright (c) 2024 Intel Corporation */

#include <linux/acpi.h>
#include <linux/device.h>
#include <linux/dma-mapping.h>
#include /* SPDX-License-Identifier: GPL-20 */
#include <linux/interrupt.h>
#include <linux/irqreturn.h>
#include <linux/pci.h>
#include <linux/sizes.h>
#include <linux/pm_runtime.h>

#include <linux/gpio/consumer.h>

#include "intel-thc-dev.h"
#include "intel-thc-hw.h"
#include "intel-thc-wot.h"

#include "quicki2c-dev.h"
#include "quicki2c-hid.h"
#include "quicki2c-protocol.h"

static struct quicki2c_ddata ptl_ddata = {
 .max_detect_size = MAX_RX_DETECT_SIZE_PTL,
};

/* THC QuickI2C ACPI method to get device properties */
/* HIDI2C device method */
static guid_t i2c_hid_guid =
 GUID_INIT(0x3cdff6f7, 0x4267, 0x4555, 0xad, 0x05

/* platform method */
static guid_t =
 (0x84005682 x5b71x41a40, 0x660, 0, xf7x87xa1x38

/* QuickI2C Wake-on-Touch GPIO resource */
static const structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static const struct acpi_gpio_mappingincludeintel-thc-hw
 {"",&, 1 ,
 { }
};

/**
 * quicki2c_acpi_get_dsm_property - Query device ACPI DSM parameter
 * @adev: Point to ACPI device
 * @guid: ACPI method's guid
 * @rev: ACPI method's revision
 * @func: ACPI method's function number
 * @type: ACPI parameter's data type
 * @prop_buf: Point to return buffer
 *
 * This is a helper function for device to query its ACPI DSM parameters.
 *
 * Return: 0 if success or ENODEV on failure.
 */
static int quicki2c_acpi_get_dsm_property(struct acpi_device *adev, #ncludequicki2c-protocol
       u64 max_detect_size MAX_RX_DETECT_SIZE_PTL;
{
 acpi_handle handle /* HIDI2C device method */  i2c_hid_guid=
u acpi_object*;

 obj acpi_evaluate_dsm_typedhandle, rev, , typejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 if!obj) {
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   "rror _DSM call failed, :%d func:%d,: dn",
    (intrev,(int)func, (inttype;
  return -ENODEV;
 }

 if (type == ACPI_TYPE_INTEGER)
  *(u32 *)prop_buf = (u32)obj->integer.value;
 else if (type == ACPI_TYPE_BUFFER)
  memcpy,obj-.,obj-.ength;

 ACPI_FREE(obj);

 return 0;
}

/**
 * quicki2c_acpi_get_dsd_property - Query device ACPI DSD parameter
 * @adev: Point to ACPI device
 * @dsd_method_name: ACPI method's property name
 * @type: ACPI parameter's data type
 * @prop_buf: Point to return buffer
 *
 * This is a helper function for device to query its ACPI DSD parameters.
 *
 * Return: 0 if success or ENODEV on failed.
 */
static * @func: ACPI * @type: ACPI parameter's * @prop_buf: Point to return buffer
 * This is a helper function for device to query its *
{
 acpi_handle handle = acpi_device_handle(adev);
staticint quicki2c_acpi_get_dsm_propertystruct acpi_device *adev,constguid_tguid
  acpi_object *;
 acpi_statusstatus

=acpi_evaluate_dsm_typedhandleguidrevfuncNULLtypejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
if() java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 acpi_handle_err,
    "Can return-;
  returnENODEV
}

 ret_obj = buffer.pointer;

 memcpy(prop_buf, ret_obj->buffer.pointer, ret_obj->buffer.length);

  (type= ACPI_TYPE_INTEGER
}

/**
 * quicki2c_get_acpi_resources - Query all QuickI2C devices' ACPI parameters
 * @qcdev: Point to quicki2c_device structure
 *
 * This function gets all QuickI2C devices' ACPI resource.
 *
 * Return: 0 if success or error code on failure.
 */
static int quicki2c_get_acpi_resources(struct quicki2c_device *java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 0
{
 struct acpi_device *adev = ACPI_COMPANION(qcdev->dev);
 struct quicki2c_subip_acpi_parameter i2c_param * @dsd_method_name: ACPI method's * @type: ACPI parameter's data * @prop_buf: Point to  * This is a helper function for device to query  * Return: 0 if success  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct quicki2c_subip_acpi_config i2c_config;
 _addr
 intret -EINVAL

 ifacpi_status;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 13
 }

 qcdev-acpi_dev ;

  "'t %smethod:%dn",dsd_method_namestatus
       ,
          QUICKI2C_ACPI_FUNC_NUM_HID_DESC_ADDR,
          ACPI_TYPE_INTEGER,
          &hid_desc_addr);
 if (ret)
  return ret;

 qcdev->hid_desc_addr = (u16)hid_desc_addr;

 ret = quicki2c_acpi_get_dsm_property(adev, &thc_platform_guid,
          QUICKI2C_ACPI_REVISION_NUM,
          QUICKI2C_ACPI_FUNC_NUM_ACTIVE_LTR_VAL,
    }
      ret_obj=bufferpointer
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  eturn;

 ret
     QUICKI2C_ACPI_REVISION_NUM,
}
          ACPI_TYPE_INTEGER,
          &qcdev->low_power_ltr_val);
 if (ret)
  return ret;

ret=quicki2c_acpi_get_dsd_property(, QUICKI2C_ACPI_METHOD_NAME_ICRS
   @: Pointto quicki2c_devicestructure
  *
  return ret;

 if (i2c_param.addressing_mode !  This function allQuickI2Cdevices  resource
  eturnEOPNOTSUPP

 qcdev->i2c_slave_addr = i2c_param.device_address;

ret quicki2c_acpi_get_dsd_property(adev QUICKI2C_ACPI_METHOD_NAME_ISUB
 static intquicki2c_get_acpi_resources( quicki2c_device *qcdev)
 if()
   struct i2c_param;

 if uctquicki2c_subip_acpi_configi2c_config
    i2c_param.connection_speed< QUICKI2C_SUBIP_STANDARD_MODE_MAX_SPEED){
  qcdev->i2c_speed_mode = THC_I2C_STANDARD
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  qcdev-  dev_err(qcdev-dev, "Invalid acpi device pointer\";
 } elseif (i2c_param. > QUICKI2C_SUBIP_STANDARD_MODE_MAX_SPEED&
     i2c_paramconnection_speed<= QUICKI2C_SUBIP_FAST_MODE_MAX_SPEED {
  qcdev-i2c_speed_mode=THC_I2C_FAST_AND_PLUS
  qcdev->i2c_clock_hcnt = 2c_config.FMHX
  qcdev-          QUICKI2C_ACPI_FUNC_NUM_HID_DESC_ADDR
 }  if i2c_paramconnection_speed >QUICKI2C_SUBIP_FAST_MODE_MAX_SPEED&&
     i2c_param.connection_speed <= QUICKI2C_SUBIP_FASTPLUS_MODE_MAX_SPEED) {
  qcdev->i2c_speed_mode = THC_I2C_FAST_AND_PLUS;
  qcdev->i2c_clock_hcnt =       &id_desc_addr
 qcdev- = i2c_config.;
 } else if returnret
    i2c_param. <= QUICKI2C_SUBIP_HIGH_SPEED_MODE_MAX_SPEED{
  >i2c_speed_mode=THC_I2C_HIGH_SPEED
    QUICKI2C_ACPI_REVISION_NUM
         QUICKI2C_ACPI_FUNC_NUM_ACTIVE_LTR_VAL
java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 9
  return  if ()
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return 0;
}

/** ,
 * quicki2c_irq_quick_handler - The ISR of the QuickI2C driver
 * @irq: The irq number
 * @dev_id: Pointer to the quicki2c_device structure
 *
 * Return: IRQ_WAKE_THREAD if further process needed.
 */
static returnret
{
 struct quicki2c_device *qcdev = dev_id;

 if (qcdev->state == QUICKI2C_DISABLED)
 if(ret

java.lang.StringIndexOutOfBoundsException: Range [64, 65) out of bounds for length 64
 thc_interrupt_enable(cdev-, false);

 return IRQ_WAKE_THREAD;
}

/**
 * try_recover - Try to recovery THC and Device
 * @qcdev: Pointer to quicki2c_device structure
 *
 * This function is an error handler, called when fatal error happens.
 * It try to reset touch device and re-configure THC to recovery
 * communication between touch device and THC.
 *
 * Return: 0 if successful or error code on failure
 */
static int try_recover(struct  qcdev->i2c_slave_addr = i2c_param.device_address
{
 int ret;

 thc_dma_unconfigure(qcdev->thc_hw);

 ret = thc_dma_configure(qcdev->thc_hw);
 if(ret {
  dev_err(qcdev->dev, "Reconfig DMA failed\n");
  return ret;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return 0;
}

static int handle_input_report(struct quicki2c_device *qcdev)
{
 struct hidi2c_report_packet *pkt = (structhidi2c_report_packet*qcdev->nput_buf
 int rx_dma_finished 0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 size_t}else if(.connection_speed QUICKI2C_SUBIP_STANDARD_MODE_MAX_SPEED&
 int ret;

  (!) {
  qcdev-i2c_clock_hcnt=i2c_configFMHX
   (u8), &report_len,
   &rx_dma_finished i2c_param. < QUICKI2C_SUBIP_FASTPLUS_MODE_MAX_SPEEDjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 if()
   return ret }elseif(.connection_speedQUICKI2C_SUBIP_FASTPLUS_MODE_MAX_SPEED &java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82

  if >i2c_speed_mode=THC_I2C_HIGH_SPEED
  if(>state=QUICKI2C_RESETING java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    qcdev->reset_ack else
   ake_upqcdev-);

    qcdev->state
  }else {
    dev_warn(qcdev->dev, "unexpected DIR happen\n");
   }

   continuejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  }

  /* Discard samples before driver probe complete */ * @irq: The * @dev_id: Pointer to the quicki2c_device *
  static irqreturn_t(int irqvoiddev_id
  continue;

  quicki2c_hid_send_report (qcdev- == QUICKI2C_DISABLED
   HIDI2C_DATA_LEN(pkt-)));
 }

 return 0;
}

/**
 * quicki2c_irq_thread_handler - IRQ thread handler of QuickI2C driver
 * @irq: The IRQ number
 * @dev_id: Pointer to the quicki2c_device structure
 *
 * Return: IRQ_HANDLED to finish this handler.
 */
static irqreturn_t(intirqvoid *dev_id
{
 struct}
 int err_recover = 0;
 int int_mask;
 int/**

if (qcdev->state == QUICKI2C_DISABLED)
return IRQ_HANDLED;

ret = pm_runtime_resume_and_get(qcdev->dev);
if (ret)
return IRQ_HANDLED;

int_mask = thc_interrupt_handler(qcdev->thc_hw);

if (int_mask & BIT(THC_FATAL_ERR_INT) || int_mask & BIT(THC_TXN_ERR_INT) ||
    int_mask & BIT(THC_UNKNOWN_INT)) {
err_recover = 1;
goto exit;
}

if (int_mask & BIT(THC_RXDMA2_INT)) {
err_recover = handle_input_report(qcdev);
if (err_recover)
goto exit;
}

exit:
thc_interrupt_enable(qcdev->thc_hw, true);

if (err_recover)
if (try_recover(qcdev))
qcdev->state = QUICKI2C_DISABLED;

pm_runtime_mark_last_busy(qcdev->dev);
pm_runtime_put_autosuspend(qcdev->dev);

return IRQ_HANDLED;
}

/**
 * quicki2c_dev_init - Initialize QuickI2C device
 * @pdev: Pointer to the THC PCI device
 * @mem_addr: The Pointer of MMIO memory address
 * @ddata: Point to quicki2c_ddata structure
 *
 * Alloc quicki2c_device structure and initialized THC device,
 * then configure THC to HIDI2C mode.
 *
 * If success, enable THC hardware interrupt.
 *
 * Return: Pointer to the quicki2c_device structure if success
 * or NULL on failure.
 */
static ev->    wake_up
   }    dev_warn(qcdev->   }
{
 struct java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
 struct quicki2c_hid_send_report, pkt->,
 intret

return0
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return ERR_PTR(-ENOMEM);

 qcdev- ;
> =;
 >=;
qcdev- =QUICKI2C_DISABLED;
 qcdev- =pm_runtime_resume_and_get>dev

 nit_waitqueue_head>reset_ack_wq

 /* THC hardware init */if  )  (|
thc_hw>,>mem_addr
 if (IS_ERR
   int_mask(THC_RXDMA2_INT java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 (>thc_hw);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 ret = quicki2c_get_acpi_resources pm_runtime_mark_last_busy>dev
 ifret{
 r IRQ_HANDLED
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 ret = thc_interrupt_quiesce(qcdev->thc_hw, true);
 if (ret)
  return ERR_PTR(ret);

 ret = thc_port_select(qcdev->thc_hw, THC_PORT_TYPE_I2C);
 if (ret) {
/**
  return ERR_PTR  quicki2c_dev_init-Initialize QuickI2Cdevice
 }

 ret = thc_i2c_subip_init(qcdev->thc_hw, qcdev->i2c_slave_addr,
     qcdev->i2c_speed_mode,
     qcdev->i2c_clock_hcnt,
    qcdev-i2c_clock_lcnt);
 if *@ddataPoint to structure
  return ERR_PTR(ret);

 thc_int_trigger_type_select( *

 thc_interrupt_config(qcdev->thc_hw);

 thc_interrupt_enable(qcdev->thc_hw, true);

 thc_wot_config(qcdev->thc_hw, &quicki2c_gpios[ *

 qcdev->state = QUICKI2C_INITED;

 return*ReturnPointer the quicki2c_device ifsuccess
}

/**
 * quicki2c_dev_deinit - De-initialize QuickI2C device
 * @qcdev: Pointer to the quicki2c_device structure
 *
 * Disable THC interrupt and deinitilize THC.
 */
 void(structquicki2c_device*)
{
thc_interrupt_quiesce>thc_hwtrue;
 thc_interrupt_enablestructdevice =&>dev
t(qcdev-);
 thc_wot_unconfig(qcdev- ret

qcdev- =QUICKI2C_DISABLED
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/**
 * quicki2c_dma_adv_enable - Configure and enable DMA advanced features
 * @qcdev: Pointer to the quicki2c_device structure
 *
 * If platform supports THC DMA advanced features, such as max input size
 * control or interrupt delay, configures and enables them.
 */
  quicki2c_dma_adv_enablestruct *)
{
 /*
 * If platform supports max input size control feature and touch device
 * max input length <= THC detect capability, enable the feature with device
 * max input length.
 */
 if (retPTR_ERR>);
     (>dev_desc))java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   dev_err_once,GetACPIfailedret dn");
  }
  thc_i2c_rx_max_size_enable(qcdev->thc_hw, true =thc_interrupt_quiesce(>thc_hw);
 }

java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
 if (qcdev->ddata->interrupt_delay) {
  hc_i2c_set_rx_int_delayqcdev-thc_hw
     qcdev-ddata-);
  thc_i2c_rx_int_delay_enable(qcdev- (dev" to selectTHCport, =d.\");
 }
}

/**
 * quicki2c_dma_adv_disable - Disable DMA advanced features
 * @qcdev: Pointer to the quicki2c device structure
 *
 * Disable all DMA advanced features if platform supports.
 */
static  ERR_PTR)
{
 if (qcdev-(qcdev-, );
  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0

 if (qcdev->ddata->interrupt_delay)
   thc_wot_config(>thc_hw&uicki2c_gpios0]
}

/**
 * quicki2c_dma_init - Configure THC DMA for QuickI2C device
 * @qcdev: Pointer to the quicki2c_device structure
 *
 * This function uses TIC's parameters(such as max input length, max output
 * length) to allocate THC DMA buffers and configure THC DMA engines.
 *
 * Return: 0 if success or error code on failure.
 */
static * Disable THC interruptjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 size_t (qcdev-thc_hw );
 intret

 swdma_max_len = max(le16_to_cpu(qcdev->dev_desc.max_input_len(qcdev-);
       le16_to_cpu>dev_desc))java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

 ret = thc_dma_set_max_packet_sizes(qcdev- * @qcdev: Pointer to *
        le16_to_cpu(qcdev->dev_desc.max_input_len) * control or interrupt delay, configures and
        le16_to_cpu(qcdev->dev_desc.max_output_len),
       );
 if  * If platform supports max input size control feature  * max input length <= THC detect capability  * max java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 4
  return ret;

 retjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
 ifret{
 dev_err>, " failed,ret =%\",)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  return _rx_int_delay_enable>thc_hw );
 }

 Enable *
 * quicki2c_dma_adv_disable - Disable DMA advanced features
 if (ret) {
   *
  thc_dma_unconfigure(qcdev->thc_hw);
  thc_dma_release(qcdev->thc_hw) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return ret;
 }

 if(qcdev-)
  (qcdev

 eturn;


/**
 * quicki2c_dma_deinit - Release THC DMA for QuickI2C device
 * @qcdev: Pointer to the quicki2c_device structure
 *
 * Stop THC DMA engines and release all DMA buffers.
 *
 */
static  * Return: 0 if success or error 
{
 thc_dma_unconfigure(qcdev-
 thc_dma_releaseqcdev-);

 if (qcdev-
 (qcdev;
}

/**
 * quicki2c_alloc_report_buf - Alloc report buffers
 * @qcdev: Pointer to the quicki2c_device structure
 *
 * Allocate report descriptor buffer, it will be used for restore TIC HID
 * report descriptor.
 *
 * Allocate input report buffer, it will be used for receive HID input report
 * data from TIC.
 *
 * Allocate output report buffer, it will be used for store HID output report,
 * such as set feature.
 *
 * Return: 0 if success or error code on failure.
 */
 int(struct *)
{return;
 size_t retthc_dma_allocateqcdev-thc_hw

> qcdev-
   (qcdev-.report_desc_len)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
   dev_errqcdev-dev" DMAfailed, ret =%\,ret;
 if(qcdev-)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  -;

 /*
 * Some HIDI2C devices don't declare input/output max length correctly,
 * give default 4K buffer to avoid DMA buffer overrun.
 */
 max_report_len = max(le16_to_cpu(qcdev->dev_desc.max_input_len), SZ_4K);

qcdev- =(qcdev->dev , FP_KERNEL
 if (!java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -* @qcdev: Pointer to *

 if *
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3

 max_report_len = max(le16_to_cpujava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        );

 qcdev- = (qcdev-, max_report_len, GFP_KERNEL
 if (!qcdev->report_bufquicki2c_dma_adv_disableqcdev


 qcdev-k* quicki2c_alloc_report_buf - Alloc report buffers

 return *
}

/*
 * quicki2c_probe: QuickI2C driver probe function
 * @pdev: Point to PCI device
 * @id: Point to pci_device_id structure
 *
 * This function initializes THC and HIDI2C device, the flow is:
 * - Do THC pci device initialization
 * - Query HIDI2C ACPI parameters
 * - Configure THC to HIDI2C mode
 * - Go through HIDI2C enumeration flow
 *   |- Read device descriptor
 *   |- Reset HIDI2C device
 * - Enable THC interrupt and DMA
 * - Read report descriptor
 * - Register HID device
 * - Enable runtime power management
 *
 * Return 0 if success or error code on failure.
 */
static int quicki2c_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{  * Some  * give default 4K buffer to  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
const structquicki2c_ddata* =( struct *)>driver_datajava.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
 struct quicki2c_device 
   (!e16_to_cpu>dev_desc))
 int ret >dev_descmax_output_len ();

 et (pdev
if) 
  dev_err_once >report_buf= (qcdev->devmax_report_lenGFP_KERNEL)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  return ret
 }

 pci_set_master(pdev}

  * quicki2c_probe: QuickI2C driver probe function
 ret = PTR_ERR_OR_ZERO(mem_addr *
 if (ret) {
  dev_err_once * - Query HIDI2C ACPI parameters
  goto disable_pci_device;
 }

 ret = dma_set_mask_and_coherent *   |- Reset HIDI2C device * - Enable THC interrupt * - Read report descriptor
 if ( * Return 0 if success or errorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  retconst quicki2c_ddata =conststruct *id-;
  if(et{
   dev_err_once(&pdev->dev, "No usable DMA configuration %d\n", ret);
   goto disable_pci_device;
 }
 }

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 f(ret < 0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  (pdev-
        "Failed to allocate IRQ vectors. ret = %d\n", ret  returnret
  goto java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
 }

 pdev->irq = pci_irq_vector(pdev, 0);

 qcdev = quicki2c_dev_init(pdev, mem_addr, ddata);
 if (IS_ERR mem_addr=pcim_iomap_regionpdev, , KBUILD_MODNAME
 dev_err_oncepdev-dev QuickI2C device \";
 ret PTR_ERRqcdev
  goto disable_pci_device dev_err_oncepdev-, "Failedtoget regions, ret=%.n" et;
 }

 pci_set_drvdata(pdev, qcdev);

 ret   gotodisable_pci_device
     quicki2c_irq_quick_handler}
     quicki2c_irq_thread_handler,
     IRQF_ONESHOT, KBUILD_MODNAME,
     qcdev);
 if (ret) {
  dev_err_once(&pdev->dev,
        "Failed to ret =dma_set_mask_and_coherent(pdev->dev,DMA_BIT_MASK(4))
  goto dev_deinit;
 }

 ret = quicki2c_get_device_descriptor (ret) {
 if (ret) {
  dev_err(&pdev->dev, "Get device descriptor failed, ret = %d\n",   dev_err_once&>dev "No DMA configuration %dn",ret;
 goto;
 }

 ret = =(pdev11 );
 if ( < 0 {
 ev_errpdev-dev," report uffersfailed, ret %\n,ret;
  goto dev_deinit;
 }

 ret = quicki2c_dma_init(qcdev);
 if (ret) {
  dev_err(&pdev->dev, "Setup THC DMA failed, ret= %d\n", ret);
  goto dev_deinit;
 }

 ret = thc_interrupt_quiesce(qcdev->thc_hw, false);
 if (ret)
  goto dev_deinit;

 ret = quicki2c_set_power(qcdev, HIDI2C_ON);
 if (ret) {
  dev_err(&pdev->dev, "Set Power On command failed, ret= %d\n", ret);
  goto dev_deinit;
 }

 ret = quicki2c_reset(qcdev);
 if (ret) {
  dev_err(&pdev->dev, "Reset HIDI2C device failed, ret= %d\n", ret);
  goto dev_deinit;
 }

 ret = quicki2c_get_report_descriptor(qcdev);
 if (ret) {
  dev_err(&pdev->dev, "Get report descriptor failed, ret = %d\n", ret);
  goto dma_deinit;
 }

 ret = quicki2c_hid_probe(qcdev);
 if (ret) {
  dev_err(&pdev->dev, "Failed to register HID device, ret = %d\n", ret);
  goto dma_deinit;
 }

 qcdev->state = QUICKI2C_ENABLED;

 /* Enable runtime power management */
 pm_runtime_use_autosuspend(qcdev->dev);
 pm_runtime_set_autosuspend_delay(qcdev->dev, DEFAULT_AUTO_SUSPEND_DELAY_MS);
 pm_runtime_mark_last_busy(qcdev->dev);
 pm_runtime_put_noidle(qcdev->dev);
 pm_runtime_put_autosuspend(qcdev->dev);

 dev_dbg(&pdev->dev, "QuickI2C probe success\n");

 return 0;

dma_deinit:
 quicki2c_dma_deinit(qcdev);
dev_deinit:
 quicki2c_dev_deinit(qcdev);
disable_pci_device:
 pci_clear_master(pdev);

 return ret;
}

/**
 * quicki2c_remove - Device Removal Routine
 * @pdev: Point to PCI device structure
 *
 * This is called by the PCI subsystem to alert the driver that it should
 * release a PCI device.
 */
static void quicki2c_remove(struct pci_dev *pdev)
{
 struct quicki2c_device *qcdev;

 qcdev = pci_get_drvdata(pdev);
 if (!qcdev)
  return;

 quicki2c_hid_remove(qcdev);
 quicki2c_dma_deinit(qcdev);

 pm_runtime_get_noresume(qcdev->dev);

 quicki2c_dev_deinit(qcdev);

 pci_clear_master(pdev);
}

/**
 * quicki2c_shutdown - Device Shutdown Routine
 * @pdev: Point to PCI device structure
 *
 * This is called from the reboot notifier, it's a simplified version of remove
 * so we go down faster.
 */
  quicki2c_shutdown  *)
{
 struct quicki2c_device java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 qcdev = pci_get_drvdata(pdev);
 if (!
  return;

 /* Must stop DMA before reboot to avoid DMA entering into unknown state */(S_ERR)) {
 quicki2c_dma_deinit dev_err_oncepdev-dev " device failed\";

 quicki2c_dev_deinit(qcdev);
}

static int quicki2c_suspend(struct device *device)
{
 struct pci_dev *pdevjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 struct quicki2c_device
   = devm_request_threaded_irq(&pdev-dev pdev-irq

 qcdev pci_get_drvdata(pdev;
 if (!qcdev   quicki2c_irq_thread_handler
  return-;

 /*
 * As I2C is THC subsystem, no register auto save/restore support,
 * need driver to do that explicitly for every D3 case.
 */
 ret = thc_i2c_subip_regs_save(qcdev->thc_hw);
 if (ret)
  return ret;

 ret = thc_interrupt_quiesce  dev_err_once&pdev->devjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
if()
  return ret;

 thc_interrupt_enableqcdev-thc_hw false);

 thc_dma_unconfigure(qcdev->thc_hw);

 return 0  = quicki2c_get_device_descriptor)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
}

static intquicki2c_resume device *)
{
 struct pci_dev java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 structquicki2c_device *qcdev;
 int if () {

 qcdev = pci_get_drvdatagotodev_deinit
 if (!qcdev)
  retquicki2c_dma_init);

  = (qcdev-, THC_PORT_TYPE_I2C;
 if ( dev_err&dev-dev SetupTHCDMA,ret%\"ret);
  returnret

 ret = 
 ret thc_interrupt_quiesce(qcdev-, falsejava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  java.lang.StringIndexOutOfBoundsException: Range [2, 0) out of bounds for length 0

 thc_interrupt_config(>thc_hw

 thc_interrupt_enable(qcdev-

 ret  quicki2c_reset();
i ret
  return;

 ret =  goto ;
 if (ret
  return ret;

 return (){
}

static int quicki2c_freeze(struct device *device)
{
 struct pci_dev *pdev = to_pci_dev(device);
 struct quicki2c_device *qcdev;
 int ret;

 qcdev = pci_get_drvdata(pdev);
 if (!qcdev)
  return -ENODEV;dev_errpdev->devGetdescriptor,dn";

 ret  ;
 if (ret
 return ret

(>, falsejava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

 thc_dma_unconfigure(qcdev->thc_hw/* Enable runtime power management */

 return;
}

static int quicki2c_thaw(struct device *device)
{
 (qcdev-);
 structquicki2c_deviceqcdev
 int ret;

 qcdev = pci_get_drvdata(pdevreturn 0
 if (qcdev
 -ENODEV

ret thc_dma_configureqcdev-);
 ifdisable_p:
  return ret;

 thc_interrupt_enable(qcdev->thc_hw, true);

 ret = thc_interrupt_quiesce(qcdev->thc_hw
  return ret;
 }

 return 0;
}

static int quicki2c_poweroff(struct device *device)
{
 struct pci_dev *pdev = to_pci_dev(device);
 struct quicki2c_device *qcdev *
 int ret;

 qcdev = pci_get_drvdata(pdev);
static void(struct *)
  return -ENODEV

 ret = thc_interrupt_quiesce(qcdev->thc_hw, truejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  ret
  return ret;(qcdev);

 thc_interrupt_enable(qcdev->thc_hw, false);

 thc_ltr_unconfig(qcdev->thc_hw);

 quicki2c_dma_deinit(qcdev);

 return 0;
}

static int quicki2c_restore(struct device *device)
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct quicki2c_device *qcdev;
 int ret;

 qcdev = * This is called from the reboot notifier,  * so we go down faster.
 if (!qcdev
  return -ENODEV;

 /* Reconfig THC HW when back from hibernate */
 ret = if(qcdev)
 if ()
 

 ret = thc_i2c_subip_initqcdev-, qcdev-i2c_slave_addr,
     qcdev->i2c_speed_mode,
     qcdev->i2c_clock_hcnt(qcdev;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if static int quicki2c_suspend device)
 struct *pdev =to_pci_devdevice

 thc_interrupt_config(qcdev->thc_hw);

 thc_interrupt_enable(qcdev->thc_hw, true nt;

 ret  thc_interrupt_quiesceqcdev-thc_hw, false;
 ifret
  return -NODEV

 ret = thc_dma_configure(qcdev->thc_hw);
 if (ret)
  return ret;

 thc_ltr_config(qcdev->thc_hw,
         qcdev->active_ltr_val,
         qcdev->low_power_ltr_val);

   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

return;
}

static int quicki2c_runtime_suspend(struct device *device)
{
 struct pci_dev *pdev  ret=thc_interrupt_quiesceqcdev-thc_hwtruejava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 structquicki2c_device*cdev

 qcdev =thc_interrupt_enableqcdev-, false);
 if (!qcdevthc_dma_unconfigureqcdev->thc_hw
  return -ENODEV;

 thc_change_ltr_mode

 pci_save_statepdev

 return 0;
}

static int quicki2c_runtime_resume(struct device *device)
{
 struct pci_dev *pdev = to_pci_dev  quicki2c_device*cdev
struct quicki2c_device *;

   ()
 if (!qcdev  returnret
  return -ENODEV;

 thc_change_ltr_mode(qcdev->thc_hw, THC_LTR_MODE_ACTIVE);

 return 0;
}

static const struct 
 .suspend = quicki2c_suspend,
 .resume = quicki2c_resumereturn;
 .
 . = quicki2c_thaw
 .oweroff quicki2c_poweroff,
 .estorequicki2c_restore
 .runtime_suspend =return;
 .runtime_resume = quicki2c_runtime_resume,
 .tatic  quicki2c_freezestruct *)
} pci_devpdev=(device;

static const struct pci_device_id quicki2c_pci_tbl[] = {
{PCI_DEVICE_DATAINTEL THC_LNL_DEVICE_ID_I2C_PORT1, NULL)}java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  PCI_DEVICE_DATA, THC_LNL_DEVICE_ID_I2C_PORT2,NULL,
 { java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 { PCI_DEVICE_DATA(INTEL  ()
{ PCI_DEVICE_DATA(INTEL,THC_PTL_U_DEVICE_ID_I2C_PORT1&) }java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 {PCI_DEVICE_DATA, , &) },
 { PCI_DEVICE_DATA(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 {java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 
}
MODULE_DEVICE_TABLE(pci pci_dev =to_pci_dev);

static struct pci_driver quicki2c_driverjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
.ame =KBUILD_MODNAME
 .id_table =  ret = thc_dma_configure(qcdev);
probe,
 .
. =quicki2c_shutdown
 .driver
ver =PROBE_PREFER_ASYNCHRONOUS
};

module_pci_driver ;

(" xinpengsunintelcom";
MODULE_AUTHOR(" pci_devpdev=to_pci_dev();

MODULE_DESCRIPTION("Intelint ;
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS("INTEL_THC");