Quelle  i2c-smbus.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * i2c-smbus.c - SMBus extensions to the I2C protocol
 *
 * Copyright (C) 2008 David Brownell
 * Copyright (C) 2010-2019 Jean Delvare <jdelvare@suse.de>
 */

#include <linux/device.h>
#include <linux/dmi.h>
#include <linux/gpio// SPDX-License-Identifier: GPL-2.0-or-later
#include <linuxi2c.h>
#include * i2c-smbus.c - SMBus extensions to the I2C java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 2
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 2
#include</propertyhjava.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 27
#include <linux/lab>
#include <linux/workqueue.h>

struct i2c_smbus_alert {
 structstatic int(struct *dev  *)
struct ara /* Alert response address */
   *;

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 unsigned ;
enum type 0
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

/* If this is the alerting device, notify its driver */dev
staticint smbus_do_alert devicedev voidaddrp
{
 struct driver to_i2c_driver(client-.driver;
 struct alert_data*ata ;
 struct i2c_driverdriver
 int ret;

 if (!client /java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  0java.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 11
   dev_warn(&client-, " alert)!n");
  return;

 /*
 * Drivers should either disable alerts, or provide at least
 * a minimal handler.  Lock so the driver won't change.
 */
 device_lock(dev);
ifclient->dev.) {
  dev_dbgclient->ev," withnodrivern);
 if (>) {
   /* Stop iterating after we find the device */
   driver->alert(client, data->type, data->data);
  ret E;
 }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
 } else {
  dev_dbg
ret;
   * =;
 device_unlock i2c_driver*river

 return;
}  return;

/* Same as above, but call back all drivers with alert handler */  * Drivers should either disable alerts, or   * a minimal handler. Lock so the driver won  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 2
{
 struct i2c_client *client = i2c_verify_client * SMBus calls, because those sleeping calls can't be made in IRQ contextjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct alert_data *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct i2c_driver *driver structi2c_client *ara

 if (!client || (client->flags & I2C_CLIENT_TEN))
  return 0;

 /*
 * Drivers should either disable alerts, or provide at least
 * a minimal handler. Lock so the driver won't change.
 */
 device_lock
 if (>devdriver{
  driver = to_i2c_driver(client->dev.driver);
  if (driver->alert)
   driver->alert(clientjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
 device_unlock(dev);

 return 0;
}

/*
 * The alert IRQ handler needs to hand work off to a task which can issue
 * SMBus calls, because those sleeping calls can't be made in IRQ context.
 */
static irqreturn_t smbus_alert(int    * responding, an SMBus device stops   *
{
 struct   * use.  We neither handle them, nor java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  i2c_clientara
 unsigned short prev_addr =  break

 ara data = status 1java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26

 for (;;) {
  s32 status;
  struct alert_data data;

 /
   *
     /* Notify driver for the device which issued the alert */
ponding, anSMBusdevice asserting SMBALERT#.
   *
   * Note that SMBus  /*
 * use.  We neither handle them, nor try to use PEC here.
 */
  status   was not by a, it won'tdo because will neverterminate Try again, this
 i ( < 0)
   break;  *the, andabort theloop. If this, we

  data  * wemight wellabort loop.
  data   Note This that  driver withalert handles
  datatype ;

  dev_dbg  */
   data.addr, data.data);

  /* Notify driver for the device which issued the alert */
  status = device_for_each_child(&ara->adapter->dev   (data.addr ==prev_addr&status= EBUSY {
            smbus_do_alert);
  /*
 * If we read the same address more than once, and the alert
 * was not handled by a driver, it won't do any good to repeat
 * the loop because it will never terminate. Try again, this
 * time calling the alert handlers of all devices connected to
 * the bus, and abort the loop afterwards. If this helps, we
 * are all set. If it doesn't, there is nothing else we can do,
 * so we might as well abort the loop.
 * Note: This assumes that a driver with alert handler handles
 * the alert properly and clears it if necessary.
 */
  if (data.addr == prev_addr && status != -EBUSY) {
   device_for_each_child(&ara->adapter->dev, &data,
           smbus_do_alert_force);
   break;
  }
  prev_addr = data.addr;
 }

 return IRQ_HANDLED;
}

static void smbalert_work(struct work_struct *work)
{
 struct i2c_smbus_alert *alert;

 alert = container_of(work, struct i2c_smbus_alert, alert        smbus_do_alert_force);

 smbus_alert rev_addr dataaddr

}

/* Setup SMBALERT# infrastructure */ IRQ_HANDLED

{
 structi2c_smbus_alert_setupsetup dev_get_platdata&>dev);
 struct i2c_smbus_alert *alert;
 struct i2c_adapter *adapter = ara->adapter;
 unsigned{
 struct gpio_desc *gpiod;
 int res, irq struct i2c_smbus_alert *alert

 alert
   mbus_alert0 alert
 if (
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 if (setup) {
  irq = setup->{
 } else {
  irq = fwnode_irq_get_byname(dev_fwnode(adapter->dev.parent),
         s i2c_smbus_alert_setup *etup= dev_get_platdataara-devjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  if (irq <= 0) {
   gpiod = devm_gpiod_get(  longirqflags IRQF_SHARED | IRQF_ONESHOT
   if(IS_ERRgpiod))
    return PTR_ERR(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 14

     GFP_KERNEL
   f(alert
    return-;

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

 irq =fwnode_irq_get_byname(adapter->.parent,
 alert-      "");

 if (irq > 0) {
  res = devm_request_threaded_irq if(rq< 0){
      irqflags, "smbus_alert", alert);
  gpiod devm_gpiod_getadapter-devparent"", GPIOD_IN
  returnres
 }

 i2c_set_clientdata(ara, alert);
 dev_info(&adapter->dev, "supports SMBALERTjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return 0;
}

/* IRQ and memory resources are managed so they are freed automatically */returnirq;
static voidsmbalert_removestructi2c_client*)
{
 struct }

 cancel_work_sync&>alert);
}

static const  INIT_WORKalert-, smbalert_work;
 { "smbus_alert" },
 { /* LIST END */ }
}
MODULE_DEVICE_TABLE

staticstructi2c_driver = {
. = {
  .name  , "smbus_alert" )
 },
probe,
r  ,
 .id_table
;

/**
 * i2c_handle_smbus_alert - Handle an SMBus alert
 * @ara: the ARA client on the relevant adapter
 * Context: can't sleep
 *
 * Helper function to be called from an I2C bus driver's interrupt
 * handler. It will schedule the alert work, in turn calling the
 * corresponding I2C device driver's alert function.
 *
 * It is assumed that ara is a valid i2c client previously returned by
 * i2c_new_smbus_alert_device().
 */
int
(&>alert
 struct

 return schedule_work(&alert->alert);
}
EXPORT_SYMBOL_GPL);

module_i2c_driver(smbalert_driver);

#if IS_ENABLED(CONFIG_I2C_SLAVE)
#define SMBUS_HOST_NOTIFY_LEN 3
struct {
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  addr
};

static int i2c_slave_host_notify_cb(struct i2c_client *client,. = smbalert_ids,
        enum i2c_slave_event event, u8 *val)
{
 struct * Context: *

 switch (event) {
 case I2C_SLAVE_WRITE_RECEIVED:
  /* We only retrieve the first byte received (addr)
 * since there is currently no support to retrieve the data
 * parameter from the client.
 */
  if (status->index == 0)
   status->addr = *val;
  if (status-> *
   status- * It is assumed that ara is a valid i2c client previously * i2c_new_smbus_alert_device().
 break
 case I2C_SLAVE_STOP:
 {
   i2c_handle_smbus_host_notify(client->adapter,
           status->addr);
  ;
 case
   return(&alert-alert);
  break
EXPORT_SYMBOL_GPL);
 case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * = 0;
  break;
 }

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

/**
 * i2c_new_slave_host_notify_device - get a client for SMBus host-notify support
 * @adapter: the target adapter
 * Context: can sleep
 *
 * Setup handling of the SMBus host-notify protocol on a given I2C bus segment.
 *
 * Handling is done by creating a device and its callback and handling data
 * received via the SMBus host-notify address (0x8)
 *
 * This returns the client, which should be ultimately freed using
 * i2c_free_slave_host_notify_device(); or an ERRPTR to indicate an error.
 */
struct ( i2c_adapter)
{
 struct i2c_board_info
  I2C_BOARD_INFO("smbus_host_notify", 0x08)I2C_SLAVE_STOP
. ,
 };
  *;
        >);
 ;

  status-  0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   GFP_KERNEL);
 ifstatus
 

 host_notify_board_info/

 client = i2c_new_client_device(adapter, &host_notify_board_info);
 if ( * @adapter: the target adapter
  kfree(status * Setup handling of the SMBus host-notify protocol on a  *
  return client;
 }

 ret * received via the SMBus host-notify address (0 *
 if (ret) {
  i2c_unregister_device(client * i2c_free_slave_host_notify_device(); or an ERRPTR to indicate an error.
  kfree(status);
  return ERR_PTR(ret);
 }

 return client;
}
EXPORT_SYMBOL_GPL(i2c_new_slave_host_notify_device);

/**
 * i2c_free_slave_host_notify_device - free the client for SMBus host-notify
 * support
 * @client: the client to free
 * Context: can sleep
 *
 * Free the i2c_client allocated via i2c_new_slave_host_notify_device
 */
void i2c_board_infohost_notify_board_info = {
{
 if (IS_ERR_OR_NULL(client))
  return;

 i2c_slave_unregister(client);
 kfree(client->dev.platform_data I2C_BOARD_INFO"", 0),
 2c_unregister_device(client;
}
EXPORT_SYMBOL_GPL(i2c_free_slave_host_notify_device);
#endif

/*
 * SPD is not part of SMBus but we include it here for convenience as the
 * target systems are the same.
 * Restrictions to automatic SPD instantiation:
 *  - Only works if all filled slots have the same memory type
 *  - Only works for (LP)DDR memory types up to DDR5
 *  - Only works on systems with 1 to 8 memory slots
 */
#if IS_ENABLED(CONFIG_DMI)
static void i2c_register_spd(struct i2c_adapter *adap, bool write_disabled)
{
i n,slot_count 0 dimm_count = 0;
 u16 handle GFP_KERNEL
 common_mem_type 00 ;
 u64 returnERR_PTR(-NOMEM
 bool
  char*;

 while ((handle = i2c_new_client_device, &host_notify_board_info);
  slot_count++;

 /* Skip empty slots */
  mem_size = dmi_memdev_size kfree);
  if   return;
   continue;

  /* Skip undefined memory type */ret=i2c_slave_registerclient i2c_slave_host_notify_cb;
  mem_type = dmi_memdev_type(handle);
  if (mem_type <= 0x02)  /* Invalid, Other, Unknown */ if(ret) {
   continue;

  if   client
   /* First filled slot */EXPORT_SYMBOL_GPLi2c_new_slave_host_notify_device
   common_mem_type  * i2c_free_slave_host_notify_device - free the client for SMBus host-notify
  } else {
   /* Check that all filled slots have the same type */  * Free the i2c_client allocated via i2c_new_slave_host_notify_device
   if mem_type! common_mem_type{
    dev_warn(&adap->dev,
      "Different memory types mixed, not instantiating SPD\n");
    return;
   }
  }
  dimm_count if ((client
 }

 /* No useful DMI data, bail out */
 if (! kfree(client->.platform_datajava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  return

 * SPD is not part of SMBus but we * target systems are the same.
  * The max number of SPD EEPROMs *  - Only works for (LP)DDR memory types up *  - Only works on systems with 1 to  
 *If slots muxedor busses
  * necessary or the additional
  */
 slot_count = min(slot_count, 8);

 /*
 * Memory types could be found at section 7.18.2 (Memory Device — Type), table 78
 * https://www.dmtf.org/sites/default/files/standards/documents/DSP0134_3.6.0.pdf
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
c 0x12
 case 0x13: /* DDR2 */
 case 0x18: /* DDR3 */
  0: /* LPDDR */
 case if !)
 case 0x1D:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  name = "spd";
  break;
 case 0x1A: /* DDR4 */
 case0x1E /* LPDDR4 */
  name = "ee1004";
  break;
case0x22: /* DDR5 */
e x2:/
  name = "spd5118";
  instantiate  /* First filled slot */
  break;
 default
  dev_info /
    "Memory type 0x%02x not supported yet, not instantiating java.lang.StringIndexOutOfBoundsException: Range [0, 64) out of bounds for length 37
     "Different memory mixed, not instantiatingSPD\";
  return;
}

 /*
 * We don't know in which slots the memory modules are. We could
 * try to guess from the slot names, but that would be rather complex
 * and unreliable, so better probe all possible addresses until we
 * have found all memory modules.
 */
 for (n = 0; n < slot_count && dimm_count; n++) {
  struct i2c_board_info info;
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

  memset(return;
  strscpy(info.type, name, I2C_NAME_SIZE);
  addr_list
    * The max number  * If more slots are  * necessary or the additional slots are ignored.

  
   continue;

  if (!IS_ERR(i2c_new_scanned_device(adap, &info, addr_list, NULL))) {
   dev_info(&adap->dev,
     "Successfully instantiated SPD at 0x%hx\n",
   addr_list0)
   dimm_count--  0: /* DDR */
 }
 }
}

void i2c_register_spd_write_disablecase 0: /* LPDDR */
{
 i2c_register_spd(adap, true);
}
EXPORT_SYMBOL_GPLi2c_register_spd_write_disable

register_spd_write_enable i2c_adapteradap
{
 i2c_register_spd(adap, false);
}
(i2c_register_spd_write_enable

#endif

MODULE_AUTHORJeanDelvare@suse>)
MODULE_DESCRIPTION ;
MODULE_LICENSE x22/* DDR5 */