Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit eb62722a authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'i2c/for-current' of git://git.kernel.org/pub/scm/linux/kernel/git/wsa/linux 

Pull i2c fixes from Wolfram Sang:
 "A couple of bugfixes for I2C drivers.

  Because the changes for the piix4 driver are larger than usual, the
  patches have been in linux-next for more than a week with no reports
  coming in. The rest is usual stuff"

* 'i2c/for-current' of git://git.kernel.org/pub/scm/linux/kernel/git/wsa/linux:
  i2c: omap: Fix error handling for clk_get()
  i2c: piix4: Disable completely the IMC during SMBUS_BLOCK_DATA
  i2c: piix4: Fix SMBus port selection for AMD Family 17h chips
  i2c: imx: fix misleading bus recovery debug message
  i2c: imx: use IRQF_SHARED mode to request IRQ
  i2c: ismt: Separate I2C block read from SMBus block read
parents 03b652e5 883b3b65

drivers/i2c/busses/i2c-imx.c

+2 −2
Original line number Diff line number Diff line
@@ -1021,7 +1021,7 @@ static int i2c_imx_init_recovery_info(struct imx_i2c_struct *i2c_imx, 
	}



	dev_dbg(&pdev->dev, "using scl-gpio %d and sda-gpio %d for recovery\n",

			rinfo->sda_gpio, rinfo->scl_gpio);

			rinfo->scl_gpio, rinfo->sda_gpio);



	rinfo->prepare_recovery = i2c_imx_prepare_recovery;

	rinfo->unprepare_recovery = i2c_imx_unprepare_recovery;
@@ -1100,7 +1100,7 @@ static int i2c_imx_probe(struct platform_device *pdev) 
	}



	/* Request IRQ */

	ret = devm_request_irq(&pdev->dev, irq, i2c_imx_isr, 0,

	ret = devm_request_irq(&pdev->dev, irq, i2c_imx_isr, IRQF_SHARED,

				pdev->name, i2c_imx);

	if (ret) {

		dev_err(&pdev->dev, "can't claim irq %d\n", irq);

drivers/i2c/busses/i2c-ismt.c

+4 −1
Original line number Diff line number Diff line
@@ -340,12 +340,15 @@ static int ismt_process_desc(const struct ismt_desc *desc, 
			data->word = dma_buffer[0] | (dma_buffer[1] << 8);

			break;

		case I2C_SMBUS_BLOCK_DATA:

		case I2C_SMBUS_I2C_BLOCK_DATA:

			if (desc->rxbytes != dma_buffer[0] + 1)

				return -EMSGSIZE;



			memcpy(data->block, dma_buffer, desc->rxbytes);

			break;

		case I2C_SMBUS_I2C_BLOCK_DATA:

			memcpy(&data->block[1], dma_buffer, desc->rxbytes);

			data->block[0] = desc->rxbytes;

			break;

		}

		return 0;

	}

drivers/i2c/busses/i2c-omap.c

+14 −0
Original line number Diff line number Diff line
@@ -360,6 +360,7 @@ static int omap_i2c_init(struct omap_i2c_dev *omap) 
	unsigned long fclk_rate = 12000000;

	unsigned long internal_clk = 0;

	struct clk *fclk;

	int error;



	if (omap->rev >= OMAP_I2C_REV_ON_3430_3530) {

		/*
@@ -378,6 +379,13 @@ static int omap_i2c_init(struct omap_i2c_dev *omap) 
		 * do this bit unconditionally.

		 */

		fclk = clk_get(omap->dev, "fck");

		if (IS_ERR(fclk)) {

			error = PTR_ERR(fclk);

			dev_err(omap->dev, "could not get fck: %i\n", error);



			return error;

		}



		fclk_rate = clk_get_rate(fclk);

		clk_put(fclk);
@@ -410,6 +418,12 @@ static int omap_i2c_init(struct omap_i2c_dev *omap) 
		else

			internal_clk = 4000;

		fclk = clk_get(omap->dev, "fck");

		if (IS_ERR(fclk)) {

			error = PTR_ERR(fclk);

			dev_err(omap->dev, "could not get fck: %i\n", error);



			return error;

		}

		fclk_rate = clk_get_rate(fclk) / 1000;

		clk_put(fclk);

drivers/i2c/busses/i2c-piix4.c

+152 −10
Original line number Diff line number Diff line
@@ -85,6 +85,9 @@ 
/* SB800 constants */

#define SB800_PIIX4_SMB_IDX		0xcd6



#define KERNCZ_IMC_IDX			0x3e

#define KERNCZ_IMC_DATA			0x3f



/*

 * SB800 port is selected by bits 2:1 of the smb_en register (0x2c)

 * or the smb_sel register (0x2e), depending on bit 0 of register 0x2f.
@@ -94,6 +97,12 @@ 
#define SB800_PIIX4_PORT_IDX_ALT	0x2e

#define SB800_PIIX4_PORT_IDX_SEL	0x2f

#define SB800_PIIX4_PORT_IDX_MASK	0x06

#define SB800_PIIX4_PORT_IDX_SHIFT	1



/* On kerncz, SmBus0Sel is at bit 20:19 of PMx00 DecodeEn */

#define SB800_PIIX4_PORT_IDX_KERNCZ		0x02

#define SB800_PIIX4_PORT_IDX_MASK_KERNCZ	0x18

#define SB800_PIIX4_PORT_IDX_SHIFT_KERNCZ	3



/* insmod parameters */
@@ -149,6 +158,8 @@ static const struct dmi_system_id piix4_dmi_ibm[] = { 
 */

static DEFINE_MUTEX(piix4_mutex_sb800);

static u8 piix4_port_sel_sb800;

static u8 piix4_port_mask_sb800;

static u8 piix4_port_shift_sb800;

static const char *piix4_main_port_names_sb800[PIIX4_MAX_ADAPTERS] = {

	" port 0", " port 2", " port 3", " port 4"

};
@@ -159,6 +170,7 @@ struct i2c_piix4_adapdata { 


	/* SB800 */

	bool sb800_main;

	bool notify_imc;

	u8 port;		/* Port number, shifted */

};
@@ -347,7 +359,19 @@ static int piix4_setup_sb800(struct pci_dev *PIIX4_dev, 


	/* Find which register is used for port selection */

	if (PIIX4_dev->vendor == PCI_VENDOR_ID_AMD) {

		switch (PIIX4_dev->device) {

		case PCI_DEVICE_ID_AMD_KERNCZ_SMBUS:

			piix4_port_sel_sb800 = SB800_PIIX4_PORT_IDX_KERNCZ;

			piix4_port_mask_sb800 = SB800_PIIX4_PORT_IDX_MASK_KERNCZ;

			piix4_port_shift_sb800 = SB800_PIIX4_PORT_IDX_SHIFT_KERNCZ;

			break;

		case PCI_DEVICE_ID_AMD_HUDSON2_SMBUS:

		default:

			piix4_port_sel_sb800 = SB800_PIIX4_PORT_IDX_ALT;

			piix4_port_mask_sb800 = SB800_PIIX4_PORT_IDX_MASK;

			piix4_port_shift_sb800 = SB800_PIIX4_PORT_IDX_SHIFT;

			break;

		}

	} else {

		mutex_lock(&piix4_mutex_sb800);

		outb_p(SB800_PIIX4_PORT_IDX_SEL, SB800_PIIX4_SMB_IDX);
@@ -355,6 +379,8 @@ static int piix4_setup_sb800(struct pci_dev *PIIX4_dev, 
		piix4_port_sel_sb800 = (port_sel & 0x01) ?

				       SB800_PIIX4_PORT_IDX_ALT :

				       SB800_PIIX4_PORT_IDX;

		piix4_port_mask_sb800 = SB800_PIIX4_PORT_IDX_MASK;

		piix4_port_shift_sb800 = SB800_PIIX4_PORT_IDX_SHIFT;

		mutex_unlock(&piix4_mutex_sb800);

	}
@@ -572,6 +598,67 @@ static s32 piix4_access(struct i2c_adapter * adap, u16 addr, 
	return 0;

}



static uint8_t piix4_imc_read(uint8_t idx)

{

	outb_p(idx, KERNCZ_IMC_IDX);

	return inb_p(KERNCZ_IMC_DATA);

}



static void piix4_imc_write(uint8_t idx, uint8_t value)

{

	outb_p(idx, KERNCZ_IMC_IDX);

	outb_p(value, KERNCZ_IMC_DATA);

}



static int piix4_imc_sleep(void)

{

	int timeout = MAX_TIMEOUT;



	if (!request_muxed_region(KERNCZ_IMC_IDX, 2, "smbus_kerncz_imc"))

		return -EBUSY;



	/* clear response register */

	piix4_imc_write(0x82, 0x00);

	/* request ownership flag */

	piix4_imc_write(0x83, 0xB4);

	/* kick off IMC Mailbox command 96 */

	piix4_imc_write(0x80, 0x96);



	while (timeout--) {

		if (piix4_imc_read(0x82) == 0xfa) {

			release_region(KERNCZ_IMC_IDX, 2);

			return 0;

		}

		usleep_range(1000, 2000);

	}



	release_region(KERNCZ_IMC_IDX, 2);

	return -ETIMEDOUT;

}



static void piix4_imc_wakeup(void)

{

	int timeout = MAX_TIMEOUT;



	if (!request_muxed_region(KERNCZ_IMC_IDX, 2, "smbus_kerncz_imc"))

		return;



	/* clear response register */

	piix4_imc_write(0x82, 0x00);

	/* release ownership flag */

	piix4_imc_write(0x83, 0xB5);

	/* kick off IMC Mailbox command 96 */

	piix4_imc_write(0x80, 0x96);



	while (timeout--) {

		if (piix4_imc_read(0x82) == 0xfa)

			break;

		usleep_range(1000, 2000);

	}



	release_region(KERNCZ_IMC_IDX, 2);

}



/*

 * Handles access to multiple SMBus ports on the SB800.

 * The port is selected by bits 2:1 of the smb_en register (0x2c).
@@ -612,12 +699,47 @@ static s32 piix4_access_sb800(struct i2c_adapter *adap, u16 addr, 
		return -EBUSY;

	}



	/*

	 * Notify the IMC (Integrated Micro Controller) if required.

	 * Among other responsibilities, the IMC is in charge of monitoring

	 * the System fans and temperature sensors, and act accordingly.

	 * All this is done through SMBus and can/will collide

	 * with our transactions if they are long (BLOCK_DATA).

	 * Therefore we need to request the ownership flag during those

	 * transactions.

	 */

	if ((size == I2C_SMBUS_BLOCK_DATA) && adapdata->notify_imc) {

		int ret;



		ret = piix4_imc_sleep();

		switch (ret) {

		case -EBUSY:

			dev_warn(&adap->dev,

				 "IMC base address index region 0x%x already in use.\n",

				 KERNCZ_IMC_IDX);

			break;

		case -ETIMEDOUT:

			dev_warn(&adap->dev,

				 "Failed to communicate with the IMC.\n");

			break;

		default:

			break;

		}



		/* If IMC communication fails do not retry */

		if (ret) {

			dev_warn(&adap->dev,

				 "Continuing without IMC notification.\n");

			adapdata->notify_imc = false;

		}

	}



	outb_p(piix4_port_sel_sb800, SB800_PIIX4_SMB_IDX);

	smba_en_lo = inb_p(SB800_PIIX4_SMB_IDX + 1);



	port = adapdata->port;

	if ((smba_en_lo & SB800_PIIX4_PORT_IDX_MASK) != port)

		outb_p((smba_en_lo & ~SB800_PIIX4_PORT_IDX_MASK) | port,

	if ((smba_en_lo & piix4_port_mask_sb800) != port)

		outb_p((smba_en_lo & ~piix4_port_mask_sb800) | port,

		       SB800_PIIX4_SMB_IDX + 1);



	retval = piix4_access(adap, addr, flags, read_write,
@@ -628,6 +750,9 @@ static s32 piix4_access_sb800(struct i2c_adapter *adap, u16 addr, 
	/* Release the semaphore */

	outb_p(smbslvcnt | 0x20, SMBSLVCNT);



	if ((size == I2C_SMBUS_BLOCK_DATA) && adapdata->notify_imc)

		piix4_imc_wakeup();



	mutex_unlock(&piix4_mutex_sb800);



	return retval;
@@ -679,7 +804,7 @@ static struct i2c_adapter *piix4_main_adapters[PIIX4_MAX_ADAPTERS]; 
static struct i2c_adapter *piix4_aux_adapter;



static int piix4_add_adapter(struct pci_dev *dev, unsigned short smba,

			     bool sb800_main, u8 port,

			     bool sb800_main, u8 port, bool notify_imc,

			     const char *name, struct i2c_adapter **padap)

{

	struct i2c_adapter *adap;
@@ -706,7 +831,8 @@ static int piix4_add_adapter(struct pci_dev *dev, unsigned short smba, 


	adapdata->smba = smba;

	adapdata->sb800_main = sb800_main;

	adapdata->port = port << 1;

	adapdata->port = port << piix4_port_shift_sb800;

	adapdata->notify_imc = notify_imc;



	/* set up the sysfs linkage to our parent device */

	adap->dev.parent = &dev->dev;
@@ -728,14 +854,15 @@ static int piix4_add_adapter(struct pci_dev *dev, unsigned short smba, 
	return 0;

}



static int piix4_add_adapters_sb800(struct pci_dev *dev, unsigned short smba)

static int piix4_add_adapters_sb800(struct pci_dev *dev, unsigned short smba,

				    bool notify_imc)

{

	struct i2c_piix4_adapdata *adapdata;

	int port;

	int retval;



	for (port = 0; port < PIIX4_MAX_ADAPTERS; port++) {

		retval = piix4_add_adapter(dev, smba, true, port,

		retval = piix4_add_adapter(dev, smba, true, port, notify_imc,

					   piix4_main_port_names_sb800[port],

					   &piix4_main_adapters[port]);

		if (retval < 0)
@@ -769,6 +896,7 @@ static int piix4_probe(struct pci_dev *dev, const struct pci_device_id *id) 
	     dev->device == PCI_DEVICE_ID_ATI_SBX00_SMBUS &&

	     dev->revision >= 0x40) ||

	    dev->vendor == PCI_VENDOR_ID_AMD) {

		bool notify_imc = false;

		is_sb800 = true;



		if (!request_region(SB800_PIIX4_SMB_IDX, 2, "smba_idx")) {
@@ -778,6 +906,20 @@ static int piix4_probe(struct pci_dev *dev, const struct pci_device_id *id) 
			return -EBUSY;

		}



		if (dev->vendor == PCI_VENDOR_ID_AMD &&

		    dev->device == PCI_DEVICE_ID_AMD_KERNCZ_SMBUS) {

			u8 imc;



			/*

			 * Detect if IMC is active or not, this method is

			 * described on coreboot's AMD IMC notes

			 */

			pci_bus_read_config_byte(dev->bus, PCI_DEVFN(0x14, 3),

						 0x40, &imc);

			if (imc & 0x80)

				notify_imc = true;

		}



		/* base address location etc changed in SB800 */

		retval = piix4_setup_sb800(dev, id, 0);

		if (retval < 0) {
@@ -789,7 +931,7 @@ static int piix4_probe(struct pci_dev *dev, const struct pci_device_id *id) 
		 * Try to register multiplexed main SMBus adapter,

		 * give up if we can't

		 */

		retval = piix4_add_adapters_sb800(dev, retval);

		retval = piix4_add_adapters_sb800(dev, retval, notify_imc);

		if (retval < 0) {

			release_region(SB800_PIIX4_SMB_IDX, 2);

			return retval;
@@ -800,7 +942,7 @@ static int piix4_probe(struct pci_dev *dev, const struct pci_device_id *id) 
			return retval;



		/* Try to register main SMBus adapter, give up if we can't */

		retval = piix4_add_adapter(dev, retval, false, 0, "",

		retval = piix4_add_adapter(dev, retval, false, 0, false, "",

					   &piix4_main_adapters[0]);

		if (retval < 0)

			return retval;
@@ -827,7 +969,7 @@ static int piix4_probe(struct pci_dev *dev, const struct pci_device_id *id) 
	if (retval > 0) {

		/* Try to add the aux adapter if it exists,

		 * piix4_add_adapter will clean up if this fails */

		piix4_add_adapter(dev, retval, false, 0,

		piix4_add_adapter(dev, retval, false, 0, false,

				  is_sb800 ? piix4_aux_port_name_sb800 : "",

				  &piix4_aux_adapter);

	}