cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

i2c-viapro.c (13816B)


      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3    Copyright (c) 1998 - 2002  Frodo Looijaard <frodol@dds.nl>,
      4    Philip Edelbrock <phil@netroedge.com>, Kyösti Mälkki <kmalkki@cc.hut.fi>,
      5    Mark D. Studebaker <mdsxyz123@yahoo.com>
      6    Copyright (C) 2005 - 2008  Jean Delvare <jdelvare@suse.de>
      7
      8*/
      9
     10/*
     11   Supports the following VIA south bridges:
     12
     13   Chip name          PCI ID  REV     I2C block
     14   VT82C596A          0x3050             no
     15   VT82C596B          0x3051             no
     16   VT82C686A          0x3057  0x30       no
     17   VT82C686B          0x3057  0x40       yes
     18   VT8231             0x8235             no?
     19   VT8233             0x3074             yes
     20   VT8233A            0x3147             yes?
     21   VT8235             0x3177             yes
     22   VT8237R            0x3227             yes
     23   VT8237A            0x3337             yes
     24   VT8237S            0x3372             yes
     25   VT8251             0x3287             yes
     26   CX700              0x8324             yes
     27   VX800/VX820        0x8353             yes
     28   VX855/VX875        0x8409             yes
     29
     30   Note: we assume there can only be one device, with one SMBus interface.
     31*/
     32
     33#include <linux/module.h>
     34#include <linux/delay.h>
     35#include <linux/pci.h>
     36#include <linux/kernel.h>
     37#include <linux/stddef.h>
     38#include <linux/ioport.h>
     39#include <linux/i2c.h>
     40#include <linux/init.h>
     41#include <linux/acpi.h>
     42#include <linux/io.h>
     43
     44static struct pci_dev *vt596_pdev;
     45
     46#define SMBBA1		0x90
     47#define SMBBA2		0x80
     48#define SMBBA3		0xD0
     49
     50/* SMBus address offsets */
     51static unsigned short vt596_smba;
     52#define SMBHSTSTS	(vt596_smba + 0)
     53#define SMBHSTCNT	(vt596_smba + 2)
     54#define SMBHSTCMD	(vt596_smba + 3)
     55#define SMBHSTADD	(vt596_smba + 4)
     56#define SMBHSTDAT0	(vt596_smba + 5)
     57#define SMBHSTDAT1	(vt596_smba + 6)
     58#define SMBBLKDAT	(vt596_smba + 7)
     59
     60/* PCI Address Constants */
     61
     62/* SMBus data in configuration space can be found in two places,
     63   We try to select the better one */
     64
     65static unsigned short SMBHSTCFG = 0xD2;
     66
     67/* Other settings */
     68#define MAX_TIMEOUT	500
     69
     70/* VT82C596 constants */
     71#define VT596_QUICK		0x00
     72#define VT596_BYTE		0x04
     73#define VT596_BYTE_DATA		0x08
     74#define VT596_WORD_DATA		0x0C
     75#define VT596_PROC_CALL		0x10
     76#define VT596_BLOCK_DATA	0x14
     77#define VT596_I2C_BLOCK_DATA	0x34
     78
     79
     80/* If force is set to anything different from 0, we forcibly enable the
     81   VT596. DANGEROUS! */
     82static bool force;
     83module_param(force, bool, 0);
     84MODULE_PARM_DESC(force, "Forcibly enable the SMBus. DANGEROUS!");
     85
     86/* If force_addr is set to anything different from 0, we forcibly enable
     87   the VT596 at the given address. VERY DANGEROUS! */
     88static u16 force_addr;
     89module_param_hw(force_addr, ushort, ioport, 0);
     90MODULE_PARM_DESC(force_addr,
     91		 "Forcibly enable the SMBus at the given address. "
     92		 "EXTREMELY DANGEROUS!");
     93
     94
     95static struct pci_driver vt596_driver;
     96static struct i2c_adapter vt596_adapter;
     97
     98#define FEATURE_I2CBLOCK	(1<<0)
     99static unsigned int vt596_features;
    100
    101#ifdef DEBUG
    102static void vt596_dump_regs(const char *msg, u8 size)
    103{
    104	dev_dbg(&vt596_adapter.dev, "%s: STS=%02x CNT=%02x CMD=%02x ADD=%02x "
    105		"DAT=%02x,%02x\n", msg, inb_p(SMBHSTSTS), inb_p(SMBHSTCNT),
    106		inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
    107		inb_p(SMBHSTDAT1));
    108
    109	if (size == VT596_BLOCK_DATA
    110	 || size == VT596_I2C_BLOCK_DATA) {
    111		int i;
    112
    113		dev_dbg(&vt596_adapter.dev, "BLK=");
    114		for (i = 0; i < I2C_SMBUS_BLOCK_MAX / 2; i++)
    115			printk("%02x,", inb_p(SMBBLKDAT));
    116		printk("\n");
    117		dev_dbg(&vt596_adapter.dev, "    ");
    118		for (; i < I2C_SMBUS_BLOCK_MAX - 1; i++)
    119			printk("%02x,", inb_p(SMBBLKDAT));
    120		printk("%02x\n", inb_p(SMBBLKDAT));
    121	}
    122}
    123#else
    124static inline void vt596_dump_regs(const char *msg, u8 size) { }
    125#endif
    126
    127/* Return -1 on error, 0 on success */
    128static int vt596_transaction(u8 size)
    129{
    130	int temp;
    131	int result = 0;
    132	int timeout = 0;
    133
    134	vt596_dump_regs("Transaction (pre)", size);
    135
    136	/* Make sure the SMBus host is ready to start transmitting */
    137	if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
    138		dev_dbg(&vt596_adapter.dev, "SMBus busy (0x%02x). "
    139			"Resetting...\n", temp);
    140
    141		outb_p(temp, SMBHSTSTS);
    142		if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
    143			dev_err(&vt596_adapter.dev, "SMBus reset failed! "
    144				"(0x%02x)\n", temp);
    145			return -EBUSY;
    146		}
    147	}
    148
    149	/* Start the transaction by setting bit 6 */
    150	outb_p(0x40 | size, SMBHSTCNT);
    151
    152	/* We will always wait for a fraction of a second */
    153	do {
    154		msleep(1);
    155		temp = inb_p(SMBHSTSTS);
    156	} while ((temp & 0x01) && (++timeout < MAX_TIMEOUT));
    157
    158	/* If the SMBus is still busy, we give up */
    159	if (timeout == MAX_TIMEOUT) {
    160		result = -ETIMEDOUT;
    161		dev_err(&vt596_adapter.dev, "SMBus timeout!\n");
    162	}
    163
    164	if (temp & 0x10) {
    165		result = -EIO;
    166		dev_err(&vt596_adapter.dev, "Transaction failed (0x%02x)\n",
    167			size);
    168	}
    169
    170	if (temp & 0x08) {
    171		result = -EIO;
    172		dev_err(&vt596_adapter.dev, "SMBus collision!\n");
    173	}
    174
    175	if (temp & 0x04) {
    176		result = -ENXIO;
    177		dev_dbg(&vt596_adapter.dev, "No response\n");
    178	}
    179
    180	/* Resetting status register */
    181	if (temp & 0x1F)
    182		outb_p(temp, SMBHSTSTS);
    183
    184	vt596_dump_regs("Transaction (post)", size);
    185
    186	return result;
    187}
    188
    189/* Return negative errno on error, 0 on success */
    190static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
    191		unsigned short flags, char read_write, u8 command,
    192		int size, union i2c_smbus_data *data)
    193{
    194	int i;
    195	int status;
    196
    197	switch (size) {
    198	case I2C_SMBUS_QUICK:
    199		size = VT596_QUICK;
    200		break;
    201	case I2C_SMBUS_BYTE:
    202		if (read_write == I2C_SMBUS_WRITE)
    203			outb_p(command, SMBHSTCMD);
    204		size = VT596_BYTE;
    205		break;
    206	case I2C_SMBUS_BYTE_DATA:
    207		outb_p(command, SMBHSTCMD);
    208		if (read_write == I2C_SMBUS_WRITE)
    209			outb_p(data->byte, SMBHSTDAT0);
    210		size = VT596_BYTE_DATA;
    211		break;
    212	case I2C_SMBUS_WORD_DATA:
    213		outb_p(command, SMBHSTCMD);
    214		if (read_write == I2C_SMBUS_WRITE) {
    215			outb_p(data->word & 0xff, SMBHSTDAT0);
    216			outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
    217		}
    218		size = VT596_WORD_DATA;
    219		break;
    220	case I2C_SMBUS_PROC_CALL:
    221		outb_p(command, SMBHSTCMD);
    222		outb_p(data->word & 0xff, SMBHSTDAT0);
    223		outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
    224		size = VT596_PROC_CALL;
    225		break;
    226	case I2C_SMBUS_I2C_BLOCK_DATA:
    227		if (!(vt596_features & FEATURE_I2CBLOCK))
    228			goto exit_unsupported;
    229		if (read_write == I2C_SMBUS_READ)
    230			outb_p(data->block[0], SMBHSTDAT0);
    231		fallthrough;
    232	case I2C_SMBUS_BLOCK_DATA:
    233		outb_p(command, SMBHSTCMD);
    234		if (read_write == I2C_SMBUS_WRITE) {
    235			u8 len = data->block[0];
    236			if (len > I2C_SMBUS_BLOCK_MAX)
    237				len = I2C_SMBUS_BLOCK_MAX;
    238			outb_p(len, SMBHSTDAT0);
    239			inb_p(SMBHSTCNT);	/* Reset SMBBLKDAT */
    240			for (i = 1; i <= len; i++)
    241				outb_p(data->block[i], SMBBLKDAT);
    242		}
    243		size = (size == I2C_SMBUS_I2C_BLOCK_DATA) ?
    244		       VT596_I2C_BLOCK_DATA : VT596_BLOCK_DATA;
    245		break;
    246	default:
    247		goto exit_unsupported;
    248	}
    249
    250	outb_p(((addr & 0x7f) << 1) | read_write, SMBHSTADD);
    251
    252	status = vt596_transaction(size);
    253	if (status)
    254		return status;
    255
    256	if (size == VT596_PROC_CALL)
    257		read_write = I2C_SMBUS_READ;
    258
    259	if ((read_write == I2C_SMBUS_WRITE) || (size == VT596_QUICK))
    260		return 0;
    261
    262	switch (size) {
    263	case VT596_BYTE:
    264	case VT596_BYTE_DATA:
    265		data->byte = inb_p(SMBHSTDAT0);
    266		break;
    267	case VT596_WORD_DATA:
    268	case VT596_PROC_CALL:
    269		data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
    270		break;
    271	case VT596_I2C_BLOCK_DATA:
    272	case VT596_BLOCK_DATA:
    273		data->block[0] = inb_p(SMBHSTDAT0);
    274		if (data->block[0] > I2C_SMBUS_BLOCK_MAX)
    275			data->block[0] = I2C_SMBUS_BLOCK_MAX;
    276		inb_p(SMBHSTCNT);	/* Reset SMBBLKDAT */
    277		for (i = 1; i <= data->block[0]; i++)
    278			data->block[i] = inb_p(SMBBLKDAT);
    279		break;
    280	}
    281	return 0;
    282
    283exit_unsupported:
    284	dev_warn(&vt596_adapter.dev, "Unsupported transaction %d\n",
    285		 size);
    286	return -EOPNOTSUPP;
    287}
    288
    289static u32 vt596_func(struct i2c_adapter *adapter)
    290{
    291	u32 func = I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
    292	    I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
    293	    I2C_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_DATA;
    294
    295	if (vt596_features & FEATURE_I2CBLOCK)
    296		func |= I2C_FUNC_SMBUS_I2C_BLOCK;
    297	return func;
    298}
    299
    300static const struct i2c_algorithm smbus_algorithm = {
    301	.smbus_xfer	= vt596_access,
    302	.functionality	= vt596_func,
    303};
    304
    305static struct i2c_adapter vt596_adapter = {
    306	.owner		= THIS_MODULE,
    307	.class		= I2C_CLASS_HWMON | I2C_CLASS_SPD,
    308	.algo		= &smbus_algorithm,
    309};
    310
    311static int vt596_probe(struct pci_dev *pdev,
    312		       const struct pci_device_id *id)
    313{
    314	unsigned char temp;
    315	int error;
    316
    317	/* Determine the address of the SMBus areas */
    318	if (force_addr) {
    319		vt596_smba = force_addr & 0xfff0;
    320		force = 0;
    321		goto found;
    322	}
    323
    324	if ((pci_read_config_word(pdev, id->driver_data, &vt596_smba)) ||
    325	    !(vt596_smba & 0x0001)) {
    326		/* try 2nd address and config reg. for 596 */
    327		if (id->device == PCI_DEVICE_ID_VIA_82C596_3 &&
    328		    !pci_read_config_word(pdev, SMBBA2, &vt596_smba) &&
    329		    (vt596_smba & 0x0001)) {
    330			SMBHSTCFG = 0x84;
    331		} else {
    332			/* no matches at all */
    333			dev_err(&pdev->dev, "Cannot configure "
    334				"SMBus I/O Base address\n");
    335			return -ENODEV;
    336		}
    337	}
    338
    339	vt596_smba &= 0xfff0;
    340	if (vt596_smba == 0) {
    341		dev_err(&pdev->dev, "SMBus base address "
    342			"uninitialized - upgrade BIOS or use "
    343			"force_addr=0xaddr\n");
    344		return -ENODEV;
    345	}
    346
    347found:
    348	error = acpi_check_region(vt596_smba, 8, vt596_driver.name);
    349	if (error)
    350		return -ENODEV;
    351
    352	if (!request_region(vt596_smba, 8, vt596_driver.name)) {
    353		dev_err(&pdev->dev, "SMBus region 0x%x already in use!\n",
    354			vt596_smba);
    355		return -ENODEV;
    356	}
    357
    358	pci_read_config_byte(pdev, SMBHSTCFG, &temp);
    359	/* If force_addr is set, we program the new address here. Just to make
    360	   sure, we disable the VT596 first. */
    361	if (force_addr) {
    362		pci_write_config_byte(pdev, SMBHSTCFG, temp & 0xfe);
    363		pci_write_config_word(pdev, id->driver_data, vt596_smba);
    364		pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
    365		dev_warn(&pdev->dev, "WARNING: SMBus interface set to new "
    366			 "address 0x%04x!\n", vt596_smba);
    367	} else if (!(temp & 0x01)) {
    368		if (force) {
    369			/* NOTE: This assumes I/O space and other allocations
    370			 * WERE done by the Bios!  Don't complain if your
    371			 * hardware does weird things after enabling this.
    372			 * :') Check for Bios updates before resorting to
    373			 * this.
    374			 */
    375			pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
    376			dev_info(&pdev->dev, "Enabling SMBus device\n");
    377		} else {
    378			dev_err(&pdev->dev, "SMBUS: Error: Host SMBus "
    379				"controller not enabled! - upgrade BIOS or "
    380				"use force=1\n");
    381			error = -ENODEV;
    382			goto release_region;
    383		}
    384	}
    385
    386	dev_dbg(&pdev->dev, "VT596_smba = 0x%X\n", vt596_smba);
    387
    388	switch (pdev->device) {
    389	case PCI_DEVICE_ID_VIA_CX700:
    390	case PCI_DEVICE_ID_VIA_VX800:
    391	case PCI_DEVICE_ID_VIA_VX855:
    392	case PCI_DEVICE_ID_VIA_VX900:
    393	case PCI_DEVICE_ID_VIA_8251:
    394	case PCI_DEVICE_ID_VIA_8237:
    395	case PCI_DEVICE_ID_VIA_8237A:
    396	case PCI_DEVICE_ID_VIA_8237S:
    397	case PCI_DEVICE_ID_VIA_8235:
    398	case PCI_DEVICE_ID_VIA_8233A:
    399	case PCI_DEVICE_ID_VIA_8233_0:
    400		vt596_features |= FEATURE_I2CBLOCK;
    401		break;
    402	case PCI_DEVICE_ID_VIA_82C686_4:
    403		/* The VT82C686B (rev 0x40) does support I2C block
    404		   transactions, but the VT82C686A (rev 0x30) doesn't */
    405		if (pdev->revision >= 0x40)
    406			vt596_features |= FEATURE_I2CBLOCK;
    407		break;
    408	}
    409
    410	vt596_adapter.dev.parent = &pdev->dev;
    411	snprintf(vt596_adapter.name, sizeof(vt596_adapter.name),
    412		 "SMBus Via Pro adapter at %04x", vt596_smba);
    413
    414	vt596_pdev = pci_dev_get(pdev);
    415	error = i2c_add_adapter(&vt596_adapter);
    416	if (error) {
    417		pci_dev_put(vt596_pdev);
    418		vt596_pdev = NULL;
    419		goto release_region;
    420	}
    421
    422	/* Always return failure here.  This is to allow other drivers to bind
    423	 * to this pci device.  We don't really want to have control over the
    424	 * pci device, we only wanted to read as few register values from it.
    425	 */
    426	return -ENODEV;
    427
    428release_region:
    429	release_region(vt596_smba, 8);
    430	return error;
    431}
    432
    433static const struct pci_device_id vt596_ids[] = {
    434	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596_3),
    435	  .driver_data = SMBBA1 },
    436	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596B_3),
    437	  .driver_data = SMBBA1 },
    438	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4),
    439	  .driver_data = SMBBA1 },
    440	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233_0),
    441	  .driver_data = SMBBA3 },
    442	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233A),
    443	  .driver_data = SMBBA3 },
    444	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235),
    445	  .driver_data = SMBBA3 },
    446	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237),
    447	  .driver_data = SMBBA3 },
    448	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237A),
    449	  .driver_data = SMBBA3 },
    450	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237S),
    451	  .driver_data = SMBBA3 },
    452	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4),
    453	  .driver_data = SMBBA1 },
    454	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8251),
    455	  .driver_data = SMBBA3 },
    456	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_CX700),
    457	  .driver_data = SMBBA3 },
    458	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX800),
    459	  .driver_data = SMBBA3 },
    460	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX855),
    461	  .driver_data = SMBBA3 },
    462	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX900),
    463	  .driver_data = SMBBA3 },
    464	{ 0, }
    465};
    466
    467MODULE_DEVICE_TABLE(pci, vt596_ids);
    468
    469static struct pci_driver vt596_driver = {
    470	.name		= "vt596_smbus",
    471	.id_table	= vt596_ids,
    472	.probe		= vt596_probe,
    473};
    474
    475static int __init i2c_vt596_init(void)
    476{
    477	return pci_register_driver(&vt596_driver);
    478}
    479
    480
    481static void __exit i2c_vt596_exit(void)
    482{
    483	pci_unregister_driver(&vt596_driver);
    484	if (vt596_pdev != NULL) {
    485		i2c_del_adapter(&vt596_adapter);
    486		release_region(vt596_smba, 8);
    487		pci_dev_put(vt596_pdev);
    488		vt596_pdev = NULL;
    489	}
    490}
    491
    492MODULE_AUTHOR("Kyosti Malkki <kmalkki@cc.hut.fi>");
    493MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
    494MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
    495MODULE_DESCRIPTION("vt82c596 SMBus driver");
    496MODULE_LICENSE("GPL");
    497
    498module_init(i2c_vt596_init);
    499module_exit(i2c_vt596_exit);