Quelle  pci-quicki2c.c   Sprache: C

SPDX-License-Identifier.java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
/* Copyright (c) 2024 Intel Corporation */ thc_platform_guidGUID_INIT,0, 0, x8d, x81x300, 0, 0, 0);

#include <linux/acpi.h>
#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/err.h>
#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"
# "intel-thc-hw.h"
#include   wake-on-touch,wake_gpio1}

# * quicki2c_acpi_get_dsm_property - Query device  * @adev: Point ethod's guid
#* This is a helper function  * Return: 0 if success
# ".h"

static struct quicki2c_ddata ptl_ddata = {
. =,
}

/* THC QuickI2C ACPI method to get device properties */

staticguid_t =
 GUID_INIT(0x3cdff6f7, 0x4267, 0x4555 nion *bj

/* platform method */ = acpi_evaluate_dsm_typed(, guid, funcNULLtype);
static guid_t thc_platform_guid =
 GUID_INIT(0x84005682, 0x5b71, (obj

/* QuickI2C Wake-on-Touch GPIO resource */
 " rev , d type:%\

static),func))java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 { " memcpy(prop_buf(prop_buf >bufferpointer >bufferl)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 { }
};

/**
 * 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.
 */
 (acpi_device,  *,
       u64 rev, union ret_obj ;
{
 acpi_handle handle = acpi_device_handle(adev);
 union acpi_object *obj;

 obj  (, , , , , );
 if (!obj) {
  acpi_handle_err(handle,
    "Error _DSM call failed, rev: %d, func: (ACPI_FAILURE(tatus){
    (int)rev,  (handle
  ENODEV -;
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

if = )
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 else  *
  memcpy(prop_buf, obj- * Return: 0 if 

 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 int quicki2c_acpi_get_dsd_property(struct acpi_device *adev, acpi_string dsd_method_name,
       acpi_object_type type, void *prop_buf)
{
 acpi_handleu32 hid_desc;
 int  = -;
 union
  status

 status = acpi_evaluate_object(handle, dsd_method_name
 if (ACPI_FAILURE(status
  acpi_handle_err> =adev
  Canevaluate :\",, status);
  return -   QUICKI2C_ACPI_REVISION_NUMjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13


  .;

 memcpy(prop_buf, r ret

   
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

return
   adev,
*qcdev to 
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
*This gets  'ACPI.
 *r -;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   =,,
  structqcdev
{
 ret
 quicki2c_subip_acpi_parameter
  ;
   =)
 int ;

 if (!adev) {
>Invalidn)
   connection_speed &
 }

 qcdev-. <)

>  ;
 qcdev- ;
      ,
          ACPI_TYPE_INTEGERelseif(.> java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
         h);
 if (ret >i2c_clock_lcnti2c_configFPLX
   ;

 qcdev->hid_desc_addr i2c_paramconnection_speed) {

 retqcdev-  ;
       ,
       ,
          ACPI_TYPE_INTEGER
          &qcdev->active_ltr_val);
 if ret
  return ret;}

 ret = quicki2c_acpi_get_dsm_property(adev, &thc_platform_guid
  
         QUICKI2C_ACPI_FUNC_NUM_LP_LTR_VAL
          ACPI_TYPE_INTEGER,
          & * @irq:  * @dev_id: Pointer to  *
  *
  ;

 retjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ()
  return  /* Disable THC interrupt before current interrupt be handled */

 if (i2c_param.addressing_mode != HIDI2C_ADDRESSING_MODE_7BIT(>thc_hwjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 *
 * This function is an * It try to reset  * communication between touch *
;

 ret = quicki2c_acpi_get_dsd_property(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   () java.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 11
}
  return ret;

 if (java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
     i2c_param.connection_speed
 pkt  *>;
  qcdev->i2c_clock_hcnt  =;
  qcdev->i2c_clock_lcnt = i2c_config.SMLX;
  else i2c_param > &&
     i2c_param.connection_speedret
  whilerx_dma_finished
 > =.;
        *pktreport_len
      );
    i2c_paramconnection_speed=QUICKI2C_SUBIP_FASTPLUS_MODE_MAX_SPEED) {
  qcdev->i2c_speed_mode = THC_I2C_FAST_AND_PLUS;
  qcdev->i2c_clock_hcnt = i2c_config.FPHX;
  qcdev->i2c_clock_lcnt if (et
    i2c_param > QUICKI2C_SUBIP_FASTPLUS_MODE_MAX_SPEED&&
     i2c_param.connection_speed <= QUICKI2C_SUBIP_HIGH_SPEED_MODE_MAX_SPEED) {
 qcdev-  ;
  qcdev->i2c_clock_hcnt  qcdev- = ){
  qcdev->i2c_clock_lcnt = i2c_config.HMLX;
 } {
  return -  w(&>reset_ack_wq


   elsejava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
}

/**
 * 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 quicki2c_irq_quick_handler,  *)
{
 continue

 if(>state)
    (le16_to_cpu>lenjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 /* Disable THC interrupt before current interrupt be handled */
 thc_interrupt_enable(qcdev- * quicki2c_irq_thread_handler - IRQ thread handler  * @irq * @dev_id: Pointer to *

 returnstatic  quicki2c_irq_thread_handler , void*)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/**
 * 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  err_recover   if   }
{
 int if ( if (try_recover(qcdev   qcdev->

 thc_dma_unconfigure(qcdev-}

 ret =/**
if (ret) {
dev_err(qcdev->dev, "Reconfig DMA failed\n");
return ret;
}

return 0;
}

static int handle_input_report(struct quicki2c_device *qcdev)
{
struct hidi2c_report_packet *pkt = (struct hidi2c_report_packet *)qcdev->input_buf;
int rx_dma_finished = 0;
size_t report_len;
int ret;

while (!rx_dma_finished) {
ret = thc_rxdma_read(qcdev->thc_hw, THC_RXDMA2,
     (u8 *)pkt, &report_len,
     &rx_dma_finished);
if (ret)
return ret;

if (!pkt->len) {
if (qcdev->state == QUICKI2C_RESETING) {
qcdev->reset_ack = true;
wake_up(&qcdev->reset_ack_wq);

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

continue;
}

/* Discard samples before driver probe complete */
  if (qcdev->state != QUICKI2C_ENABLED)
   continue;

 (qcdevpkt-data
      int ;
 }

  ;
}

/**
 * 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 quicki2c_irq_thread_handler(int irq, void *dev_id)
{
 struct quicki2c_device *qcdev = dev_id;
 int err_recover = 0;
 intint_mask
 int ret qcdev-dev dev

 if qcdev-mem_addr  mem_addr
   >state QUICKI2C_DISABLED;

 ret (qcdev-);
 if (ret)
  returninit_waitqueue_head(&qcdev-);

 int_mask = thc_interrupt_handler(qcdev->thc_hw);

  (int_mask&BIT(THC_FATAL_ERR_INT || int_mask& BITTHC_TXN_ERR_INT) ||
     int_mask & BIT(THC_UNKNOWN_INT)) {
  err_recover = 1;
  goto exit qcdev-> = thc_dev_init(qcdev->ev,qcdev-);
 }

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

exit:
 thc_interrupt_enableqcdev-, true

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

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

 eturn;
}

*
* -Initialize device
 * @pdevjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 >i2c_clock_lcnt;
 *@: Point quicki2c_ddatajava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
*
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
  :  tothe structure java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 * * quicki2c_dev_deinit - De-initialize QuickI2C device * @qcdev: Pointer  *
 */
static static quicki2c_dev_deinit quicki2c_device qcdev
   (qcdev-, );
{
   *dev pdev-;
 struct quicki2c_device *qcdev; hc_ltr_unconfig>thc_hw
 int;

 qcdev = >state ;
 if (!
  return ERR_PTR(-ENOMEM);

 qcdev-
 qcdev- * quicki2c_dma_adv_enable - Configure and enable * @qcdev: Pointer to  *
 qcdev->mem_addr = mem_addr;
 qcdev->state = QUICKI2C_DISABLED;
 qcdev->ddata = ddata;

 init_waitqueue_head(&qcdev->reset_ack_wq);

 /* THC hardware init */static voidquicki2c_dma_adv_enable(struct quicki2c_device*qcdevjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 qcdev->thc_hw = thc_dev_init(qcdev->dev, qcdev->mem_addr);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   = (qcdev-thc_hw
le16_to_cpuqcdev-.max_input_len {
  return ERR_PTR(ret);
 }

 ret = quicki2c_get_acpi_resources(qcdev);
 if (ret) {
(dev " resources , = %\" ret
  return ERR_PTR(ret);
 }

 ret thc_interrupt_quiesceqcdev-, true
 if (ret)
  return /* If platform supports interrupt delay feature, enable it with given delay */

 ret  t(qcdev->,
 if (ret  qcdev->>interrupt_delay
 dev_err_once, Failed   ,ret %.\n, ret
  return ERR_PTR(ret);
 }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     qcdev->i2c_speed_mode,
     qcdev->i2c_clock_hcnt, * @qcdev: Pointer to the  *
     qcdev->i2c_clock_lcnt);
 if (ret)
 return(ret;

 thc_int_trigger_type_select>thc_hwfalse

 thc_interrupt_config(qcdev->thc_hw);

 thc_interrupt_enable(qcdev->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 thc_wot_configqcdev-, &uicki2c_gpios[0];

 qcdev->

 return * quicki2c_dma_init - Configure THC DMA for QuickI2C * @qcdev: Pointer to *
}

/**
 * quicki2c_dev_deinit - De-initialize QuickI2C device
 * @qcdev: Pointer to the quicki2c_device structure
 *
 * Disable THC interrupt and deinitilize THC.
 */
static void quicki2c_dev_deinit(struct quicki2c_device *qcdev)
{
 thc_interrupt_quiesce>thc_hw,true
 thc_interrupt_enable ;
 thc_ltr_unconfig(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
 thc_wot_unconfig>thc_hw

 qcdev-     (qcdev-.report_desc_len;
}

/**
 * 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.
 */
static void quicki2c_dma_adv_enable(struct quicki2c_device *qcdev)
{
 /* swdma_max_len
 * 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 (qcdev->ddata->max_detect_size >=
     le16_to_cpu(qcdev->dev_desc.max_input_len)) {
  thc_i2c_set_rx_max_size(qcdev->thc_hw,
     le16_to_cpu(qcdev->dev_desc.max_input_len));
  thc_i2c_rx_max_size_enable(qcdev->thc_hw, true);
 }

 /* If platform supports interrupt delay feature, enable it with given delay */
 if (qcdev- () {
  thc_i2c_set_rx_int_delay (qcdev-devAllocateTHCDMAbuffer   dn" ret;
      qcdev->ddata->interrupt_delay);
_(qcdev-,true
 }
}

/** RxDMA*
 * quicki2c_dma_adv_disable - Disable DMA advanced features
 * @qcdev: Pointer to the quicki2c device structure
 *
 * Disable all DMA advanced features if platform supports.
 */
static void quicki2c_dma_adv_disable(struct quicki2c_device *qcdev)
{
 if (qcdev->ddata- (>ddata
   quicki2c_dma_adv_enable);

 r 0;
  thc_i2c_rx_int_delay_enable
}

/**
 * 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 int quicki2c_dma_init(struct quicki2c_device *qcdev)
{
 size_t(>thc_hw
 int ret;

  quicki2c_dma_adv_disable)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
       le16_to_cpu(qcdev- * @qcdev: Pointer to the  *

 ret = thc_dma_set_max_packet_sizes(qcdev->thc_hw * report descriptor *
        le16_to_cpu(qcdev->dev_desc.max_input_len),
        le16_to_cpu(qcdev-> * Allocate output report buffer, it will be used for store * such as set feature.
        swdma_max_len)static quicki2c_alloc_report_bufstruct quicki2c_device*cdev
 if (ret)
  return ret;

  = thc_dma_allocate(qcdev->thc_hw);
 if (ret) {
  dev_err(qcdev- qcdev-report_descriptor = devm_kzalloc(>dev,
  return ret    le16_to_cpu>dev_descreport_desc_len),
 }

 /* Enable RxDMA */
 ret = thc_dma_configure(qcdev->thc_hw);
 if (ret) {
 dev_err(qcdev->, ConfigureTHC failedret %n" );
  thc_dma_unconfigure>thc_hw;
  thc_dma_release(qcdev->thc_hw);
  return ret returnENOMEM
 }

 if (qcdev->ddata)
  quicki2c_dma_adv_enable(qcdev  * give default 4K buffer to java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  >input_buf devm_kzallocqcdev->dev,max_report_lenG);
}

/**
 * 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 void quicki2c_dma_deinit(struct quicki2c_device *qcdev)
{
 thc_dma_unconfigure(qcdev->thc_hw);
 thc_dma_release(qcdev-      max_report_len;

 if (qcdev->report_buf devm_kzalloc>dev max_report_len, );
  quicki2c_dma_adv_disable();
}

/**
 * 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.
 */
static int quicki2c_alloc_report_buf(struct quicki2c_device *qcdev)
{
 size_t max_report_len;

 qcdev->report_descriptor = devm_kzalloc( * - Go through HIDI2C enumeration flow
  *   |- Reset HIDI2C device
      GFP_KERNEL);
 if (!qcdev->report_descriptor * - Register HID device * - Enable runtime power  *
  return -ENOMEM;

 /*
 * 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-> const  quicki2c_ddata *data=(onst quicki2c_ddata)d-driver_data;
 if (!qcdev->input_buf)
  return -ENOMEM;

if!(qcdev-.max_output_len
 qcdev-dev_desc. = cpu_to_le16SZ_4K

 max_report_lenr = pcim_enable_device);
          (ret{

qcdev- = devm_kzallocqcdev->, , GFP_KERNEL;
 if (!qcdev->report_buf)
  return -ENOMEM;

 qcdev->report_len = max_report_len;

 return 0;
}

/*
 * 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)
{
  struct *ddata (  quicki2c_ddata)>driver_data
 struct quicki2c_device *qcdev () java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 void _ 
 int ret

 ret = pcim_enable_device(pdev);
 if i ret<0{
  dev_err_once(&pdev->dev, "Faileddev_err_once(&>dev,
  ;
 }

 pci_set_master(pdev)java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  (pdev0);
 ret (&>," initfailedn)
 if   =();
 (&>dev   PCI,  d\,r)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
 ;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 & 6;
 ifdev_deinit
  
  ifretjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 (pdev-,"usable%\,);
   goto disable_pci_device;
    dev_deinit
 }

 ret pci_alloc_irq_vectorspdev, 1 , PCI_IRQ_ALL_TYPES
 ifret){
  dev_err_once(d(&>dev Allocb , =d" )java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
        "Failed to allocate IRQ vectors. * so we go down faster.
  goto disable_pci_device;staticvoidquicki2c_shutdown(structpci_devpdev
}

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

 qcdev
 if ((qcdev
 (&>, QuickI2Cinitn)
  retjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  goto disable_pci_device;
 }

 pci_set_drvdata(pdev, qcdev);

retdevm_request_threaded_irq>, >,
     quicki2c_irq_quick_handler =pci_get_drvdata);
    ,
     IRQF_ONESHOT ENODEV
     qcdev
   * As I2C is THC subsystem,   * need driver tojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(>,
        "Failed to request threaded ret
  goto dev_deinit(>,java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 }

ret(qcdev;
 if (ret) {
  dev_err(&pdev->dev
  goto dev_deinit (struct device
}

 s  qcdev
ifret
  dev_err
   ;
 }

 = (qcdev
 if (retretthc_port_select>thc_hw);
 (&>," THC failed = dn, ret);
  goto ;
 }

 =thc_interrupt_quiesce>thc_hw);
 if (ret)
  goto dev_deinit;

 ret = quicki2c_set_power(qcdev, HIDI2C_ON);
 if (ret) {
thc_interrupt_configqcdev-);
  goto dev_deinit;
 }

ret=quicki2c_resetqcdev
 if (ret f()
  dev_err ret
  gotodev_deinit
 }

 ret = quicki2c_get_report_descriptor(
 if(et java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 (&pdev-dev, " report failed,ret = %d\, ret)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
odma_deinit
 }

 ret = return;
 if (ret
  dev_err(&pdev-> thc_interrupt_enableqcdev-thc_hwfalse);
  goto dma_deinit;
 }

 qcdev->state = QUICKI2C_ENABLED;

 /* Enable runtime power management */
 pm_runtime_use_autosuspend(qcdev->  0;
 pm_runtime_set_autosuspend_delayjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 pm_runtime_mark_last_busy(qcdev-
pm_runtime_put_noidle>dev;
 pm_runtime_put_autosuspend(qcdev->dev  *;

 dev_dbg(&pdev->dev

 return ;

if (!qcde()
  return;
dev_deinit:
 quicki2c_dev_deinit(  =thc_dma_configure(>thc_hw
disable_pci_device
 pci_clear_master(pdev

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

/**
 * 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.
 */
  quicki2c_remove pci_devpdev
{
 struct quicki2c_device *qcdev;

 qcdev =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!qcdev)
  return;

 quicki2c_hid_remove(qcdev);
 quicki2c_dma_deinit(qcdev);

 pm_runtime_get_noresume(qcdev->dev if()

 quicki2c_dev_deinitjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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

/**
 * 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.
 */
static void quicki2c_shutdown(structif!)
{
 struct /

 qcdev = pci_get_drvdata(pdev);
  !qcdev
   ifret

 /* Must stop DMA before reboot to avoid DMA entering into unknown state */(>thc_hw>i2c_slave_addr
 quicki2c_dma_deinit);

 quicki2c_dev_deinit(qcdev);
}

staticint (struct *device
{
  pci_devpdev ();
 structjava.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
i ret

 qcdev=(>thc_hw);
 if ()
E;

 /*
 * 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
  0
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  (>, );
 if (ret)
  return ret  *;

(>thc_hw;

 (qcdev-);

 return 0;
}

static int quicki2c_resume();
{
 struct pci_dev *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
struct *;
 int ret;

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

 ret = thc_port_select(qcdev->thc_hw, THC_PORT_TYPE_I2C);
 if (ret)
  return ret;

 ret = thc_i2c_subip_regs_restore(qcdev->thc_hw tructquicki2c_deviceqcdev
ifret
 ;

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

 thc_interrupt_enable(qcdev->thc_hw

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

 retthaw,
 if. =quicki2c_poweroff
   r = ,

  0
}

taticint( devicedevice
{
struct *pdev  to_pci_devdevice)
 struct quicki2c_device *qcdev;java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int  (,THC_LNL_DEVICE_ID_I2C_PORT1, NULL),

 qcdev = pci_get_drvdata(pdev);
 if (!qcdev)
  return -ENODEV{(INTELTHC_LNL_DEVICE_ID_I2C_PORT2 ) }

 ret = thc_interrupt_quiesce(qcdev->thc_hw, true);
ifret
   PCI_DEVICE_DATAINTEL , ptl_ddata,

 thc_interrupt_enable(qcdev->thc_hw, false (INTELTHC_PTL_U_DEVICE_ID_I2C_PORT2ptl_ddata,

 thc_dma_unconfigure(qcdev->thc_hw);

 return 0;
}

}
{
 struct *pdev (device
 struct quicki2c_device *qcdev;
 int ret;

 qcdev = pci_get_drvdata(pdev);
 if (!qcdev)
   .ame=,

->thc_hw
 if .probe = quicki2c_probe
  return ret;

 thc_interrupt_enable( shutdown quicki2c_shutdown,

 ret .probe_type ,
 if (ret)
  return ret;

 return0;
}

staticMODULE_AUTHORXinpengSun<.@.>);
{
struct *  device
 struct quicki2c_device *qcdev;
 intret

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

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

 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)
{
 struct pci_dev *pdev = to_pci_dev(device);
 struct quicki2c_device *qcdev;
 int ret;

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

 /* Reconfig THC HW when back from hibernate */
 ret = thc_port_select(qcdev->thc_hw, THC_PORT_TYPE_I2C);
 if (ret)
  return ret;

 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 (ret)
  return ret;

 thc_interrupt_config(qcdev->thc_hw);

 thc_interrupt_enable(qcdev->thc_hw, true);

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

 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);

 thc_change_ltr_mode(qcdev->thc_hw, THC_LTR_MODE_ACTIVE);

 return 0;
}

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

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

 thc_change_ltr_mode(qcdev->thc_hw, THC_LTR_MODE_LP);

 pci_save_state(pdev);

 return 0;
}

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

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

 thc_change_ltr_mode(qcdev->thc_hw, THC_LTR_MODE_ACTIVE);

 return 0;
}

static const struct dev_pm_ops quicki2c_pm_ops = {
 .suspend = quicki2c_suspend,
 .resume = quicki2c_resume,
 .freeze = quicki2c_freeze,
 .thaw = quicki2c_thaw,
 .poweroff = quicki2c_poweroff,
 .restore = quicki2c_restore,
 .runtime_suspend = quicki2c_runtime_suspend,
 .runtime_resume = quicki2c_runtime_resume,
 .runtime_idle = NULL,
};

static const struct pci_device_id quicki2c_pci_tbl[] = {
 { PCI_DEVICE_DATA(INTEL, THC_LNL_DEVICE_ID_I2C_PORT1, NULL) },
 { PCI_DEVICE_DATA(INTEL, THC_LNL_DEVICE_ID_I2C_PORT2, NULL) },
 { PCI_DEVICE_DATA(INTEL, THC_PTL_H_DEVICE_ID_I2C_PORT1, &ptl_ddata) },
 { PCI_DEVICE_DATA(INTEL, THC_PTL_H_DEVICE_ID_I2C_PORT2, &ptl_ddata) },
 { PCI_DEVICE_DATA(INTEL, THC_PTL_U_DEVICE_ID_I2C_PORT1, &ptl_ddata) },
 { PCI_DEVICE_DATA(INTEL, THC_PTL_U_DEVICE_ID_I2C_PORT2, &ptl_ddata) },
 { PCI_DEVICE_DATA(INTEL, THC_WCL_DEVICE_ID_I2C_PORT1, &ptl_ddata) },
 { PCI_DEVICE_DATA(INTEL, THC_WCL_DEVICE_ID_I2C_PORT2, &ptl_ddata) },
 { }
};
MODULE_DEVICE_TABLE(pci, quicki2c_pci_tbl);

static struct pci_driver quicki2c_driver = {
 .name = KBUILD_MODNAME,
 .id_table = quicki2c_pci_tbl,
 .probe = quicki2c_probe,
 .remove = quicki2c_remove,
 .shutdown = quicki2c_shutdown,
 .driver.pm = &quicki2c_pm_ops,
 .driver.probe_type = PROBE_PREFER_ASYNCHRONOUS,
};

module_pci_driver(quicki2c_driver);

MODULE_AUTHOR("Xinpeng Sun ");
MODULE_AUTHOR("Even Xu ");

MODULE_DESCRIPTION("Intel(R) QuickI2C Driver");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS("INTEL_THC");