986 lines
28 KiB
C
986 lines
28 KiB
C
/*
|
|
* This file is provided under a dual BSD/GPLv2 license. When using or
|
|
* redistributing this file, you may do so under either license.
|
|
*
|
|
* Copyright(c) 2012 Intel Corporation. All rights reserved.
|
|
*
|
|
* GPL LICENSE SUMMARY
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of version 2 of the GNU General Public License as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
* The full GNU General Public License is included in this distribution
|
|
* in the file called LICENSE.GPL.
|
|
*
|
|
* BSD LICENSE
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
* * Neither the name of Intel Corporation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* Supports the SMBus Message Transport (SMT) in the Intel Atom Processor
|
|
* S12xx Product Family.
|
|
*
|
|
* Features supported by this driver:
|
|
* Hardware PEC yes
|
|
* Block buffer yes
|
|
* Block process call transaction yes
|
|
* Slave mode no
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/stddef.h>
|
|
#include <linux/completion.h>
|
|
#include <linux/dma-mapping.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/acpi.h>
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/io-64-nonatomic-lo-hi.h>
|
|
|
|
/* PCI Address Constants */
|
|
#define SMBBAR 0
|
|
|
|
/* PCI DIDs for the Intel SMBus Message Transport (SMT) Devices */
|
|
#define PCI_DEVICE_ID_INTEL_S1200_SMT0 0x0c59
|
|
#define PCI_DEVICE_ID_INTEL_S1200_SMT1 0x0c5a
|
|
#define PCI_DEVICE_ID_INTEL_CDF_SMT 0x18ac
|
|
#define PCI_DEVICE_ID_INTEL_DNV_SMT 0x19ac
|
|
#define PCI_DEVICE_ID_INTEL_EBG_SMT 0x1bff
|
|
#define PCI_DEVICE_ID_INTEL_AVOTON_SMT 0x1f15
|
|
|
|
#define ISMT_DESC_ENTRIES 2 /* number of descriptor entries */
|
|
#define ISMT_MAX_RETRIES 3 /* number of SMBus retries to attempt */
|
|
#define ISMT_LOG_ENTRIES 3 /* number of interrupt cause log entries */
|
|
|
|
/* Hardware Descriptor Constants - Control Field */
|
|
#define ISMT_DESC_CWRL 0x01 /* Command/Write Length */
|
|
#define ISMT_DESC_BLK 0X04 /* Perform Block Transaction */
|
|
#define ISMT_DESC_FAIR 0x08 /* Set fairness flag upon successful arbit. */
|
|
#define ISMT_DESC_PEC 0x10 /* Packet Error Code */
|
|
#define ISMT_DESC_I2C 0x20 /* I2C Enable */
|
|
#define ISMT_DESC_INT 0x40 /* Interrupt */
|
|
#define ISMT_DESC_SOE 0x80 /* Stop On Error */
|
|
|
|
/* Hardware Descriptor Constants - Status Field */
|
|
#define ISMT_DESC_SCS 0x01 /* Success */
|
|
#define ISMT_DESC_DLTO 0x04 /* Data Low Time Out */
|
|
#define ISMT_DESC_NAK 0x08 /* NAK Received */
|
|
#define ISMT_DESC_CRC 0x10 /* CRC Error */
|
|
#define ISMT_DESC_CLTO 0x20 /* Clock Low Time Out */
|
|
#define ISMT_DESC_COL 0x40 /* Collisions */
|
|
#define ISMT_DESC_LPR 0x80 /* Large Packet Received */
|
|
|
|
/* Macros */
|
|
#define ISMT_DESC_ADDR_RW(addr, rw) (((addr) << 1) | (rw))
|
|
|
|
/* iSMT General Register address offsets (SMBBAR + <addr>) */
|
|
#define ISMT_GR_GCTRL 0x000 /* General Control */
|
|
#define ISMT_GR_SMTICL 0x008 /* SMT Interrupt Cause Location */
|
|
#define ISMT_GR_ERRINTMSK 0x010 /* Error Interrupt Mask */
|
|
#define ISMT_GR_ERRAERMSK 0x014 /* Error AER Mask */
|
|
#define ISMT_GR_ERRSTS 0x018 /* Error Status */
|
|
#define ISMT_GR_ERRINFO 0x01c /* Error Information */
|
|
|
|
/* iSMT Master Registers */
|
|
#define ISMT_MSTR_MDBA 0x100 /* Master Descriptor Base Address */
|
|
#define ISMT_MSTR_MCTRL 0x108 /* Master Control */
|
|
#define ISMT_MSTR_MSTS 0x10c /* Master Status */
|
|
#define ISMT_MSTR_MDS 0x110 /* Master Descriptor Size */
|
|
#define ISMT_MSTR_RPOLICY 0x114 /* Retry Policy */
|
|
|
|
/* iSMT Miscellaneous Registers */
|
|
#define ISMT_SPGT 0x300 /* SMBus PHY Global Timing */
|
|
|
|
/* General Control Register (GCTRL) bit definitions */
|
|
#define ISMT_GCTRL_TRST 0x04 /* Target Reset */
|
|
#define ISMT_GCTRL_KILL 0x08 /* Kill */
|
|
#define ISMT_GCTRL_SRST 0x40 /* Soft Reset */
|
|
|
|
/* Master Control Register (MCTRL) bit definitions */
|
|
#define ISMT_MCTRL_SS 0x01 /* Start/Stop */
|
|
#define ISMT_MCTRL_MEIE 0x10 /* Master Error Interrupt Enable */
|
|
#define ISMT_MCTRL_FMHP 0x00ff0000 /* Firmware Master Head Ptr (FMHP) */
|
|
|
|
/* Master Status Register (MSTS) bit definitions */
|
|
#define ISMT_MSTS_HMTP 0xff0000 /* HW Master Tail Pointer (HMTP) */
|
|
#define ISMT_MSTS_MIS 0x20 /* Master Interrupt Status (MIS) */
|
|
#define ISMT_MSTS_MEIS 0x10 /* Master Error Int Status (MEIS) */
|
|
#define ISMT_MSTS_IP 0x01 /* In Progress */
|
|
|
|
/* Master Descriptor Size (MDS) bit definitions */
|
|
#define ISMT_MDS_MASK 0xff /* Master Descriptor Size mask (MDS) */
|
|
|
|
/* SMBus PHY Global Timing Register (SPGT) bit definitions */
|
|
#define ISMT_SPGT_SPD_MASK 0xc0000000 /* SMBus Speed mask */
|
|
#define ISMT_SPGT_SPD_80K 0x00 /* 80 kHz */
|
|
#define ISMT_SPGT_SPD_100K (0x1 << 30) /* 100 kHz */
|
|
#define ISMT_SPGT_SPD_400K (0x2U << 30) /* 400 kHz */
|
|
#define ISMT_SPGT_SPD_1M (0x3U << 30) /* 1 MHz */
|
|
|
|
|
|
/* MSI Control Register (MSICTL) bit definitions */
|
|
#define ISMT_MSICTL_MSIE 0x01 /* MSI Enable */
|
|
|
|
/* iSMT Hardware Descriptor */
|
|
struct ismt_desc {
|
|
u8 tgtaddr_rw; /* target address & r/w bit */
|
|
u8 wr_len_cmd; /* write length in bytes or a command */
|
|
u8 rd_len; /* read length */
|
|
u8 control; /* control bits */
|
|
u8 status; /* status bits */
|
|
u8 retry; /* collision retry and retry count */
|
|
u8 rxbytes; /* received bytes */
|
|
u8 txbytes; /* transmitted bytes */
|
|
u32 dptr_low; /* lower 32 bit of the data pointer */
|
|
u32 dptr_high; /* upper 32 bit of the data pointer */
|
|
} __packed;
|
|
|
|
struct ismt_priv {
|
|
struct i2c_adapter adapter;
|
|
void __iomem *smba; /* PCI BAR */
|
|
struct pci_dev *pci_dev;
|
|
struct ismt_desc *hw; /* descriptor virt base addr */
|
|
dma_addr_t io_rng_dma; /* descriptor HW base addr */
|
|
u8 head; /* ring buffer head pointer */
|
|
struct completion cmp; /* interrupt completion */
|
|
u8 buffer[I2C_SMBUS_BLOCK_MAX + 16]; /* temp R/W data buffer */
|
|
dma_addr_t log_dma;
|
|
u32 *log;
|
|
};
|
|
|
|
static const struct pci_device_id ismt_ids[] = {
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_S1200_SMT0) },
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_S1200_SMT1) },
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_CDF_SMT) },
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_DNV_SMT) },
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_EBG_SMT) },
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_AVOTON_SMT) },
|
|
{ 0, }
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(pci, ismt_ids);
|
|
|
|
/* Bus speed control bits for slow debuggers - refer to the docs for usage */
|
|
static unsigned int bus_speed;
|
|
module_param(bus_speed, uint, S_IRUGO);
|
|
MODULE_PARM_DESC(bus_speed, "Bus Speed in kHz (0 = BIOS default)");
|
|
|
|
/**
|
|
* __ismt_desc_dump() - dump the contents of a specific descriptor
|
|
* @dev: the iSMT device
|
|
* @desc: the iSMT hardware descriptor
|
|
*/
|
|
static void __ismt_desc_dump(struct device *dev, const struct ismt_desc *desc)
|
|
{
|
|
|
|
dev_dbg(dev, "Descriptor struct: %p\n", desc);
|
|
dev_dbg(dev, "\ttgtaddr_rw=0x%02X\n", desc->tgtaddr_rw);
|
|
dev_dbg(dev, "\twr_len_cmd=0x%02X\n", desc->wr_len_cmd);
|
|
dev_dbg(dev, "\trd_len= 0x%02X\n", desc->rd_len);
|
|
dev_dbg(dev, "\tcontrol= 0x%02X\n", desc->control);
|
|
dev_dbg(dev, "\tstatus= 0x%02X\n", desc->status);
|
|
dev_dbg(dev, "\tretry= 0x%02X\n", desc->retry);
|
|
dev_dbg(dev, "\trxbytes= 0x%02X\n", desc->rxbytes);
|
|
dev_dbg(dev, "\ttxbytes= 0x%02X\n", desc->txbytes);
|
|
dev_dbg(dev, "\tdptr_low= 0x%08X\n", desc->dptr_low);
|
|
dev_dbg(dev, "\tdptr_high= 0x%08X\n", desc->dptr_high);
|
|
}
|
|
/**
|
|
* ismt_desc_dump() - dump the contents of a descriptor for debug purposes
|
|
* @priv: iSMT private data
|
|
*/
|
|
static void ismt_desc_dump(struct ismt_priv *priv)
|
|
{
|
|
struct device *dev = &priv->pci_dev->dev;
|
|
struct ismt_desc *desc = &priv->hw[priv->head];
|
|
|
|
dev_dbg(dev, "Dump of the descriptor struct: 0x%X\n", priv->head);
|
|
__ismt_desc_dump(dev, desc);
|
|
}
|
|
|
|
/**
|
|
* ismt_gen_reg_dump() - dump the iSMT General Registers
|
|
* @priv: iSMT private data
|
|
*/
|
|
static void ismt_gen_reg_dump(struct ismt_priv *priv)
|
|
{
|
|
struct device *dev = &priv->pci_dev->dev;
|
|
|
|
dev_dbg(dev, "Dump of the iSMT General Registers\n");
|
|
dev_dbg(dev, " GCTRL.... : (0x%p)=0x%X\n",
|
|
priv->smba + ISMT_GR_GCTRL,
|
|
readl(priv->smba + ISMT_GR_GCTRL));
|
|
dev_dbg(dev, " SMTICL... : (0x%p)=0x%016llX\n",
|
|
priv->smba + ISMT_GR_SMTICL,
|
|
(long long unsigned int)readq(priv->smba + ISMT_GR_SMTICL));
|
|
dev_dbg(dev, " ERRINTMSK : (0x%p)=0x%X\n",
|
|
priv->smba + ISMT_GR_ERRINTMSK,
|
|
readl(priv->smba + ISMT_GR_ERRINTMSK));
|
|
dev_dbg(dev, " ERRAERMSK : (0x%p)=0x%X\n",
|
|
priv->smba + ISMT_GR_ERRAERMSK,
|
|
readl(priv->smba + ISMT_GR_ERRAERMSK));
|
|
dev_dbg(dev, " ERRSTS... : (0x%p)=0x%X\n",
|
|
priv->smba + ISMT_GR_ERRSTS,
|
|
readl(priv->smba + ISMT_GR_ERRSTS));
|
|
dev_dbg(dev, " ERRINFO.. : (0x%p)=0x%X\n",
|
|
priv->smba + ISMT_GR_ERRINFO,
|
|
readl(priv->smba + ISMT_GR_ERRINFO));
|
|
}
|
|
|
|
/**
|
|
* ismt_mstr_reg_dump() - dump the iSMT Master Registers
|
|
* @priv: iSMT private data
|
|
*/
|
|
static void ismt_mstr_reg_dump(struct ismt_priv *priv)
|
|
{
|
|
struct device *dev = &priv->pci_dev->dev;
|
|
|
|
dev_dbg(dev, "Dump of the iSMT Master Registers\n");
|
|
dev_dbg(dev, " MDBA..... : (0x%p)=0x%016llX\n",
|
|
priv->smba + ISMT_MSTR_MDBA,
|
|
(long long unsigned int)readq(priv->smba + ISMT_MSTR_MDBA));
|
|
dev_dbg(dev, " MCTRL.... : (0x%p)=0x%X\n",
|
|
priv->smba + ISMT_MSTR_MCTRL,
|
|
readl(priv->smba + ISMT_MSTR_MCTRL));
|
|
dev_dbg(dev, " MSTS..... : (0x%p)=0x%X\n",
|
|
priv->smba + ISMT_MSTR_MSTS,
|
|
readl(priv->smba + ISMT_MSTR_MSTS));
|
|
dev_dbg(dev, " MDS...... : (0x%p)=0x%X\n",
|
|
priv->smba + ISMT_MSTR_MDS,
|
|
readl(priv->smba + ISMT_MSTR_MDS));
|
|
dev_dbg(dev, " RPOLICY.. : (0x%p)=0x%X\n",
|
|
priv->smba + ISMT_MSTR_RPOLICY,
|
|
readl(priv->smba + ISMT_MSTR_RPOLICY));
|
|
dev_dbg(dev, " SPGT..... : (0x%p)=0x%X\n",
|
|
priv->smba + ISMT_SPGT,
|
|
readl(priv->smba + ISMT_SPGT));
|
|
}
|
|
|
|
/**
|
|
* ismt_submit_desc() - add a descriptor to the ring
|
|
* @priv: iSMT private data
|
|
*/
|
|
static void ismt_submit_desc(struct ismt_priv *priv)
|
|
{
|
|
uint fmhp;
|
|
uint val;
|
|
|
|
ismt_desc_dump(priv);
|
|
ismt_gen_reg_dump(priv);
|
|
ismt_mstr_reg_dump(priv);
|
|
|
|
/* Set the FMHP (Firmware Master Head Pointer)*/
|
|
fmhp = ((priv->head + 1) % ISMT_DESC_ENTRIES) << 16;
|
|
val = readl(priv->smba + ISMT_MSTR_MCTRL);
|
|
writel((val & ~ISMT_MCTRL_FMHP) | fmhp,
|
|
priv->smba + ISMT_MSTR_MCTRL);
|
|
|
|
/* Set the start bit */
|
|
val = readl(priv->smba + ISMT_MSTR_MCTRL);
|
|
writel(val | ISMT_MCTRL_SS,
|
|
priv->smba + ISMT_MSTR_MCTRL);
|
|
}
|
|
|
|
/**
|
|
* ismt_process_desc() - handle the completion of the descriptor
|
|
* @desc: the iSMT hardware descriptor
|
|
* @data: data buffer from the upper layer
|
|
* @priv: ismt_priv struct holding our dma buffer
|
|
* @size: SMBus transaction type
|
|
* @read_write: flag to indicate if this is a read or write
|
|
*/
|
|
static int ismt_process_desc(const struct ismt_desc *desc,
|
|
union i2c_smbus_data *data,
|
|
struct ismt_priv *priv, int size,
|
|
char read_write)
|
|
{
|
|
u8 *dma_buffer = PTR_ALIGN(&priv->buffer[0], 16);
|
|
|
|
dev_dbg(&priv->pci_dev->dev, "Processing completed descriptor\n");
|
|
__ismt_desc_dump(&priv->pci_dev->dev, desc);
|
|
ismt_gen_reg_dump(priv);
|
|
ismt_mstr_reg_dump(priv);
|
|
|
|
if (desc->status & ISMT_DESC_SCS) {
|
|
if (read_write == I2C_SMBUS_WRITE &&
|
|
size != I2C_SMBUS_PROC_CALL &&
|
|
size != I2C_SMBUS_BLOCK_PROC_CALL)
|
|
return 0;
|
|
|
|
switch (size) {
|
|
case I2C_SMBUS_BYTE:
|
|
case I2C_SMBUS_BYTE_DATA:
|
|
data->byte = dma_buffer[0];
|
|
break;
|
|
case I2C_SMBUS_WORD_DATA:
|
|
case I2C_SMBUS_PROC_CALL:
|
|
data->word = dma_buffer[0] | (dma_buffer[1] << 8);
|
|
break;
|
|
case I2C_SMBUS_BLOCK_DATA:
|
|
case I2C_SMBUS_BLOCK_PROC_CALL:
|
|
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;
|
|
}
|
|
|
|
if (likely(desc->status & ISMT_DESC_NAK))
|
|
return -ENXIO;
|
|
|
|
if (desc->status & ISMT_DESC_CRC)
|
|
return -EBADMSG;
|
|
|
|
if (desc->status & ISMT_DESC_COL)
|
|
return -EAGAIN;
|
|
|
|
if (desc->status & ISMT_DESC_LPR)
|
|
return -EPROTO;
|
|
|
|
if (desc->status & (ISMT_DESC_DLTO | ISMT_DESC_CLTO))
|
|
return -ETIMEDOUT;
|
|
|
|
return -EIO;
|
|
}
|
|
|
|
/**
|
|
* ismt_access() - process an SMBus command
|
|
* @adap: the i2c host adapter
|
|
* @addr: address of the i2c/SMBus target
|
|
* @flags: command options
|
|
* @read_write: read from or write to device
|
|
* @command: the i2c/SMBus command to issue
|
|
* @size: SMBus transaction type
|
|
* @data: read/write data buffer
|
|
*/
|
|
static int ismt_access(struct i2c_adapter *adap, u16 addr,
|
|
unsigned short flags, char read_write, u8 command,
|
|
int size, union i2c_smbus_data *data)
|
|
{
|
|
int ret;
|
|
unsigned long time_left;
|
|
dma_addr_t dma_addr = 0; /* address of the data buffer */
|
|
u8 dma_size = 0;
|
|
enum dma_data_direction dma_direction = 0;
|
|
struct ismt_desc *desc;
|
|
struct ismt_priv *priv = i2c_get_adapdata(adap);
|
|
struct device *dev = &priv->pci_dev->dev;
|
|
u8 *dma_buffer = PTR_ALIGN(&priv->buffer[0], 16);
|
|
|
|
desc = &priv->hw[priv->head];
|
|
|
|
/* Initialize the DMA buffer */
|
|
memset(priv->buffer, 0, sizeof(priv->buffer));
|
|
|
|
/* Initialize the descriptor */
|
|
memset(desc, 0, sizeof(struct ismt_desc));
|
|
desc->tgtaddr_rw = ISMT_DESC_ADDR_RW(addr, read_write);
|
|
|
|
/* Always clear the log entries */
|
|
memset(priv->log, 0, ISMT_LOG_ENTRIES * sizeof(u32));
|
|
|
|
/* Initialize common control bits */
|
|
if (likely(pci_dev_msi_enabled(priv->pci_dev)))
|
|
desc->control = ISMT_DESC_INT | ISMT_DESC_FAIR;
|
|
else
|
|
desc->control = ISMT_DESC_FAIR;
|
|
|
|
if ((flags & I2C_CLIENT_PEC) && (size != I2C_SMBUS_QUICK)
|
|
&& (size != I2C_SMBUS_I2C_BLOCK_DATA))
|
|
desc->control |= ISMT_DESC_PEC;
|
|
|
|
switch (size) {
|
|
case I2C_SMBUS_QUICK:
|
|
dev_dbg(dev, "I2C_SMBUS_QUICK\n");
|
|
break;
|
|
|
|
case I2C_SMBUS_BYTE:
|
|
if (read_write == I2C_SMBUS_WRITE) {
|
|
/*
|
|
* Send Byte
|
|
* The command field contains the write data
|
|
*/
|
|
dev_dbg(dev, "I2C_SMBUS_BYTE: WRITE\n");
|
|
desc->control |= ISMT_DESC_CWRL;
|
|
desc->wr_len_cmd = command;
|
|
} else {
|
|
/* Receive Byte */
|
|
dev_dbg(dev, "I2C_SMBUS_BYTE: READ\n");
|
|
dma_size = 1;
|
|
dma_direction = DMA_FROM_DEVICE;
|
|
desc->rd_len = 1;
|
|
}
|
|
break;
|
|
|
|
case I2C_SMBUS_BYTE_DATA:
|
|
if (read_write == I2C_SMBUS_WRITE) {
|
|
/*
|
|
* Write Byte
|
|
* Command plus 1 data byte
|
|
*/
|
|
dev_dbg(dev, "I2C_SMBUS_BYTE_DATA: WRITE\n");
|
|
desc->wr_len_cmd = 2;
|
|
dma_size = 2;
|
|
dma_direction = DMA_TO_DEVICE;
|
|
dma_buffer[0] = command;
|
|
dma_buffer[1] = data->byte;
|
|
} else {
|
|
/* Read Byte */
|
|
dev_dbg(dev, "I2C_SMBUS_BYTE_DATA: READ\n");
|
|
desc->control |= ISMT_DESC_CWRL;
|
|
desc->wr_len_cmd = command;
|
|
desc->rd_len = 1;
|
|
dma_size = 1;
|
|
dma_direction = DMA_FROM_DEVICE;
|
|
}
|
|
break;
|
|
|
|
case I2C_SMBUS_WORD_DATA:
|
|
if (read_write == I2C_SMBUS_WRITE) {
|
|
/* Write Word */
|
|
dev_dbg(dev, "I2C_SMBUS_WORD_DATA: WRITE\n");
|
|
desc->wr_len_cmd = 3;
|
|
dma_size = 3;
|
|
dma_direction = DMA_TO_DEVICE;
|
|
dma_buffer[0] = command;
|
|
dma_buffer[1] = data->word & 0xff;
|
|
dma_buffer[2] = data->word >> 8;
|
|
} else {
|
|
/* Read Word */
|
|
dev_dbg(dev, "I2C_SMBUS_WORD_DATA: READ\n");
|
|
desc->wr_len_cmd = command;
|
|
desc->control |= ISMT_DESC_CWRL;
|
|
desc->rd_len = 2;
|
|
dma_size = 2;
|
|
dma_direction = DMA_FROM_DEVICE;
|
|
}
|
|
break;
|
|
|
|
case I2C_SMBUS_PROC_CALL:
|
|
dev_dbg(dev, "I2C_SMBUS_PROC_CALL\n");
|
|
desc->wr_len_cmd = 3;
|
|
desc->rd_len = 2;
|
|
dma_size = 3;
|
|
dma_direction = DMA_BIDIRECTIONAL;
|
|
dma_buffer[0] = command;
|
|
dma_buffer[1] = data->word & 0xff;
|
|
dma_buffer[2] = data->word >> 8;
|
|
break;
|
|
|
|
case I2C_SMBUS_BLOCK_DATA:
|
|
if (read_write == I2C_SMBUS_WRITE) {
|
|
/* Block Write */
|
|
dev_dbg(dev, "I2C_SMBUS_BLOCK_DATA: WRITE\n");
|
|
if (data->block[0] < 1 || data->block[0] > I2C_SMBUS_BLOCK_MAX)
|
|
return -EINVAL;
|
|
|
|
dma_size = data->block[0] + 1;
|
|
dma_direction = DMA_TO_DEVICE;
|
|
desc->wr_len_cmd = dma_size;
|
|
desc->control |= ISMT_DESC_BLK;
|
|
dma_buffer[0] = command;
|
|
memcpy(&dma_buffer[1], &data->block[1], dma_size - 1);
|
|
} else {
|
|
/* Block Read */
|
|
dev_dbg(dev, "I2C_SMBUS_BLOCK_DATA: READ\n");
|
|
dma_size = I2C_SMBUS_BLOCK_MAX;
|
|
dma_direction = DMA_FROM_DEVICE;
|
|
desc->rd_len = dma_size;
|
|
desc->wr_len_cmd = command;
|
|
desc->control |= (ISMT_DESC_BLK | ISMT_DESC_CWRL);
|
|
}
|
|
break;
|
|
|
|
case I2C_SMBUS_BLOCK_PROC_CALL:
|
|
dev_dbg(dev, "I2C_SMBUS_BLOCK_PROC_CALL\n");
|
|
if (data->block[0] > I2C_SMBUS_BLOCK_MAX)
|
|
return -EINVAL;
|
|
|
|
dma_size = I2C_SMBUS_BLOCK_MAX;
|
|
desc->tgtaddr_rw = ISMT_DESC_ADDR_RW(addr, 1);
|
|
desc->wr_len_cmd = data->block[0] + 1;
|
|
desc->rd_len = dma_size;
|
|
desc->control |= ISMT_DESC_BLK;
|
|
dma_direction = DMA_BIDIRECTIONAL;
|
|
dma_buffer[0] = command;
|
|
memcpy(&dma_buffer[1], &data->block[1], data->block[0]);
|
|
break;
|
|
|
|
case I2C_SMBUS_I2C_BLOCK_DATA:
|
|
/* Make sure the length is valid */
|
|
if (data->block[0] < 1)
|
|
data->block[0] = 1;
|
|
|
|
if (data->block[0] > I2C_SMBUS_BLOCK_MAX)
|
|
data->block[0] = I2C_SMBUS_BLOCK_MAX;
|
|
|
|
if (read_write == I2C_SMBUS_WRITE) {
|
|
/* i2c Block Write */
|
|
dev_dbg(dev, "I2C_SMBUS_I2C_BLOCK_DATA: WRITE\n");
|
|
dma_size = data->block[0] + 1;
|
|
dma_direction = DMA_TO_DEVICE;
|
|
desc->wr_len_cmd = dma_size;
|
|
desc->control |= ISMT_DESC_I2C;
|
|
dma_buffer[0] = command;
|
|
memcpy(&dma_buffer[1], &data->block[1], dma_size - 1);
|
|
} else {
|
|
/* i2c Block Read */
|
|
dev_dbg(dev, "I2C_SMBUS_I2C_BLOCK_DATA: READ\n");
|
|
dma_size = data->block[0];
|
|
dma_direction = DMA_FROM_DEVICE;
|
|
desc->rd_len = dma_size;
|
|
desc->wr_len_cmd = command;
|
|
desc->control |= (ISMT_DESC_I2C | ISMT_DESC_CWRL);
|
|
/*
|
|
* Per the "Table 15-15. I2C Commands",
|
|
* in the External Design Specification (EDS),
|
|
* (Document Number: 508084, Revision: 2.0),
|
|
* the _rw bit must be 0
|
|
*/
|
|
desc->tgtaddr_rw = ISMT_DESC_ADDR_RW(addr, 0);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
dev_err(dev, "Unsupported transaction %d\n",
|
|
size);
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
/* map the data buffer */
|
|
if (dma_size != 0) {
|
|
dev_dbg(dev, " dev=%p\n", dev);
|
|
dev_dbg(dev, " data=%p\n", data);
|
|
dev_dbg(dev, " dma_buffer=%p\n", dma_buffer);
|
|
dev_dbg(dev, " dma_size=%d\n", dma_size);
|
|
dev_dbg(dev, " dma_direction=%d\n", dma_direction);
|
|
|
|
dma_addr = dma_map_single(dev,
|
|
dma_buffer,
|
|
dma_size,
|
|
dma_direction);
|
|
|
|
if (dma_mapping_error(dev, dma_addr)) {
|
|
dev_err(dev, "Error in mapping dma buffer %p\n",
|
|
dma_buffer);
|
|
return -EIO;
|
|
}
|
|
|
|
dev_dbg(dev, " dma_addr = %pad\n", &dma_addr);
|
|
|
|
desc->dptr_low = lower_32_bits(dma_addr);
|
|
desc->dptr_high = upper_32_bits(dma_addr);
|
|
}
|
|
|
|
reinit_completion(&priv->cmp);
|
|
|
|
/* Add the descriptor */
|
|
ismt_submit_desc(priv);
|
|
|
|
/* Now we wait for interrupt completion, 1s */
|
|
time_left = wait_for_completion_timeout(&priv->cmp, HZ*1);
|
|
|
|
/* unmap the data buffer */
|
|
if (dma_size != 0)
|
|
dma_unmap_single(dev, dma_addr, dma_size, dma_direction);
|
|
|
|
if (unlikely(!time_left)) {
|
|
dev_err(dev, "completion wait timed out\n");
|
|
ret = -ETIMEDOUT;
|
|
goto out;
|
|
}
|
|
|
|
/* do any post processing of the descriptor here */
|
|
ret = ismt_process_desc(desc, data, priv, size, read_write);
|
|
|
|
out:
|
|
/* Update the ring pointer */
|
|
priv->head++;
|
|
priv->head %= ISMT_DESC_ENTRIES;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ismt_func() - report which i2c commands are supported by this adapter
|
|
* @adap: the i2c host adapter
|
|
*/
|
|
static u32 ismt_func(struct i2c_adapter *adap)
|
|
{
|
|
return I2C_FUNC_SMBUS_QUICK |
|
|
I2C_FUNC_SMBUS_BYTE |
|
|
I2C_FUNC_SMBUS_BYTE_DATA |
|
|
I2C_FUNC_SMBUS_WORD_DATA |
|
|
I2C_FUNC_SMBUS_PROC_CALL |
|
|
I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
|
|
I2C_FUNC_SMBUS_BLOCK_DATA |
|
|
I2C_FUNC_SMBUS_I2C_BLOCK |
|
|
I2C_FUNC_SMBUS_PEC;
|
|
}
|
|
|
|
static const struct i2c_algorithm smbus_algorithm = {
|
|
.smbus_xfer = ismt_access,
|
|
.functionality = ismt_func,
|
|
};
|
|
|
|
/**
|
|
* ismt_handle_isr() - interrupt handler bottom half
|
|
* @priv: iSMT private data
|
|
*/
|
|
static irqreturn_t ismt_handle_isr(struct ismt_priv *priv)
|
|
{
|
|
complete(&priv->cmp);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
|
|
/**
|
|
* ismt_do_interrupt() - IRQ interrupt handler
|
|
* @vec: interrupt vector
|
|
* @data: iSMT private data
|
|
*/
|
|
static irqreturn_t ismt_do_interrupt(int vec, void *data)
|
|
{
|
|
u32 val;
|
|
struct ismt_priv *priv = data;
|
|
|
|
/*
|
|
* check to see it's our interrupt, return IRQ_NONE if not ours
|
|
* since we are sharing interrupt
|
|
*/
|
|
val = readl(priv->smba + ISMT_MSTR_MSTS);
|
|
|
|
if (!(val & (ISMT_MSTS_MIS | ISMT_MSTS_MEIS)))
|
|
return IRQ_NONE;
|
|
else
|
|
writel(val | ISMT_MSTS_MIS | ISMT_MSTS_MEIS,
|
|
priv->smba + ISMT_MSTR_MSTS);
|
|
|
|
return ismt_handle_isr(priv);
|
|
}
|
|
|
|
/**
|
|
* ismt_do_msi_interrupt() - MSI interrupt handler
|
|
* @vec: interrupt vector
|
|
* @data: iSMT private data
|
|
*/
|
|
static irqreturn_t ismt_do_msi_interrupt(int vec, void *data)
|
|
{
|
|
return ismt_handle_isr(data);
|
|
}
|
|
|
|
/**
|
|
* ismt_hw_init() - initialize the iSMT hardware
|
|
* @priv: iSMT private data
|
|
*/
|
|
static void ismt_hw_init(struct ismt_priv *priv)
|
|
{
|
|
u32 val;
|
|
struct device *dev = &priv->pci_dev->dev;
|
|
|
|
/* initialize the Master Descriptor Base Address (MDBA) */
|
|
writeq(priv->io_rng_dma, priv->smba + ISMT_MSTR_MDBA);
|
|
|
|
writeq(priv->log_dma, priv->smba + ISMT_GR_SMTICL);
|
|
|
|
/* initialize the Master Control Register (MCTRL) */
|
|
writel(ISMT_MCTRL_MEIE, priv->smba + ISMT_MSTR_MCTRL);
|
|
|
|
/* initialize the Master Status Register (MSTS) */
|
|
writel(0, priv->smba + ISMT_MSTR_MSTS);
|
|
|
|
/* initialize the Master Descriptor Size (MDS) */
|
|
val = readl(priv->smba + ISMT_MSTR_MDS);
|
|
writel((val & ~ISMT_MDS_MASK) | (ISMT_DESC_ENTRIES - 1),
|
|
priv->smba + ISMT_MSTR_MDS);
|
|
|
|
/*
|
|
* Set the SMBus speed (could use this for slow HW debuggers)
|
|
*/
|
|
|
|
val = readl(priv->smba + ISMT_SPGT);
|
|
|
|
switch (bus_speed) {
|
|
case 0:
|
|
break;
|
|
|
|
case 80:
|
|
dev_dbg(dev, "Setting SMBus clock to 80 kHz\n");
|
|
writel(((val & ~ISMT_SPGT_SPD_MASK) | ISMT_SPGT_SPD_80K),
|
|
priv->smba + ISMT_SPGT);
|
|
break;
|
|
|
|
case 100:
|
|
dev_dbg(dev, "Setting SMBus clock to 100 kHz\n");
|
|
writel(((val & ~ISMT_SPGT_SPD_MASK) | ISMT_SPGT_SPD_100K),
|
|
priv->smba + ISMT_SPGT);
|
|
break;
|
|
|
|
case 400:
|
|
dev_dbg(dev, "Setting SMBus clock to 400 kHz\n");
|
|
writel(((val & ~ISMT_SPGT_SPD_MASK) | ISMT_SPGT_SPD_400K),
|
|
priv->smba + ISMT_SPGT);
|
|
break;
|
|
|
|
case 1000:
|
|
dev_dbg(dev, "Setting SMBus clock to 1000 kHz\n");
|
|
writel(((val & ~ISMT_SPGT_SPD_MASK) | ISMT_SPGT_SPD_1M),
|
|
priv->smba + ISMT_SPGT);
|
|
break;
|
|
|
|
default:
|
|
dev_warn(dev, "Invalid SMBus clock speed, only 0, 80, 100, 400, and 1000 are valid\n");
|
|
break;
|
|
}
|
|
|
|
val = readl(priv->smba + ISMT_SPGT);
|
|
|
|
switch (val & ISMT_SPGT_SPD_MASK) {
|
|
case ISMT_SPGT_SPD_80K:
|
|
bus_speed = 80;
|
|
break;
|
|
case ISMT_SPGT_SPD_100K:
|
|
bus_speed = 100;
|
|
break;
|
|
case ISMT_SPGT_SPD_400K:
|
|
bus_speed = 400;
|
|
break;
|
|
case ISMT_SPGT_SPD_1M:
|
|
bus_speed = 1000;
|
|
break;
|
|
}
|
|
dev_dbg(dev, "SMBus clock is running at %d kHz\n", bus_speed);
|
|
}
|
|
|
|
/**
|
|
* ismt_dev_init() - initialize the iSMT data structures
|
|
* @priv: iSMT private data
|
|
*/
|
|
static int ismt_dev_init(struct ismt_priv *priv)
|
|
{
|
|
/* allocate memory for the descriptor */
|
|
priv->hw = dmam_alloc_coherent(&priv->pci_dev->dev,
|
|
(ISMT_DESC_ENTRIES
|
|
* sizeof(struct ismt_desc)),
|
|
&priv->io_rng_dma,
|
|
GFP_KERNEL);
|
|
if (!priv->hw)
|
|
return -ENOMEM;
|
|
|
|
priv->head = 0;
|
|
init_completion(&priv->cmp);
|
|
|
|
priv->log = dmam_alloc_coherent(&priv->pci_dev->dev,
|
|
ISMT_LOG_ENTRIES * sizeof(u32),
|
|
&priv->log_dma, GFP_KERNEL);
|
|
if (!priv->log)
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ismt_int_init() - initialize interrupts
|
|
* @priv: iSMT private data
|
|
*/
|
|
static int ismt_int_init(struct ismt_priv *priv)
|
|
{
|
|
int err;
|
|
|
|
/* Try using MSI interrupts */
|
|
err = pci_enable_msi(priv->pci_dev);
|
|
if (err)
|
|
goto intx;
|
|
|
|
err = devm_request_irq(&priv->pci_dev->dev,
|
|
priv->pci_dev->irq,
|
|
ismt_do_msi_interrupt,
|
|
0,
|
|
"ismt-msi",
|
|
priv);
|
|
if (err) {
|
|
pci_disable_msi(priv->pci_dev);
|
|
goto intx;
|
|
}
|
|
|
|
return 0;
|
|
|
|
/* Try using legacy interrupts */
|
|
intx:
|
|
dev_warn(&priv->pci_dev->dev,
|
|
"Unable to use MSI interrupts, falling back to legacy\n");
|
|
|
|
err = devm_request_irq(&priv->pci_dev->dev,
|
|
priv->pci_dev->irq,
|
|
ismt_do_interrupt,
|
|
IRQF_SHARED,
|
|
"ismt-intx",
|
|
priv);
|
|
if (err) {
|
|
dev_err(&priv->pci_dev->dev, "no usable interrupts\n");
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct pci_driver ismt_driver;
|
|
|
|
/**
|
|
* ismt_probe() - probe for iSMT devices
|
|
* @pdev: PCI-Express device
|
|
* @id: PCI-Express device ID
|
|
*/
|
|
static int
|
|
ismt_probe(struct pci_dev *pdev, const struct pci_device_id *id)
|
|
{
|
|
int err;
|
|
struct ismt_priv *priv;
|
|
unsigned long start, len;
|
|
|
|
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
|
|
if (!priv)
|
|
return -ENOMEM;
|
|
|
|
pci_set_drvdata(pdev, priv);
|
|
|
|
i2c_set_adapdata(&priv->adapter, priv);
|
|
priv->adapter.owner = THIS_MODULE;
|
|
priv->adapter.class = I2C_CLASS_HWMON;
|
|
priv->adapter.algo = &smbus_algorithm;
|
|
priv->adapter.dev.parent = &pdev->dev;
|
|
ACPI_COMPANION_SET(&priv->adapter.dev, ACPI_COMPANION(&pdev->dev));
|
|
priv->adapter.retries = ISMT_MAX_RETRIES;
|
|
|
|
priv->pci_dev = pdev;
|
|
|
|
err = pcim_enable_device(pdev);
|
|
if (err) {
|
|
dev_err(&pdev->dev, "Failed to enable SMBus PCI device (%d)\n",
|
|
err);
|
|
return err;
|
|
}
|
|
|
|
/* enable bus mastering */
|
|
pci_set_master(pdev);
|
|
|
|
/* Determine the address of the SMBus area */
|
|
start = pci_resource_start(pdev, SMBBAR);
|
|
len = pci_resource_len(pdev, SMBBAR);
|
|
if (!start || !len) {
|
|
dev_err(&pdev->dev,
|
|
"SMBus base address uninitialized, upgrade BIOS\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
snprintf(priv->adapter.name, sizeof(priv->adapter.name),
|
|
"SMBus iSMT adapter at %lx", start);
|
|
|
|
dev_dbg(&priv->pci_dev->dev, " start=0x%lX\n", start);
|
|
dev_dbg(&priv->pci_dev->dev, " len=0x%lX\n", len);
|
|
|
|
err = acpi_check_resource_conflict(&pdev->resource[SMBBAR]);
|
|
if (err) {
|
|
dev_err(&pdev->dev, "ACPI resource conflict!\n");
|
|
return err;
|
|
}
|
|
|
|
err = pci_request_region(pdev, SMBBAR, ismt_driver.name);
|
|
if (err) {
|
|
dev_err(&pdev->dev,
|
|
"Failed to request SMBus region 0x%lx-0x%lx\n",
|
|
start, start + len);
|
|
return err;
|
|
}
|
|
|
|
priv->smba = pcim_iomap(pdev, SMBBAR, len);
|
|
if (!priv->smba) {
|
|
dev_err(&pdev->dev, "Unable to ioremap SMBus BAR\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
|
|
if (err) {
|
|
dev_err(&pdev->dev, "dma_set_mask fail\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
err = ismt_dev_init(priv);
|
|
if (err)
|
|
return err;
|
|
|
|
ismt_hw_init(priv);
|
|
|
|
err = ismt_int_init(priv);
|
|
if (err)
|
|
return err;
|
|
|
|
err = i2c_add_adapter(&priv->adapter);
|
|
if (err)
|
|
return -ENODEV;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ismt_remove() - release driver resources
|
|
* @pdev: PCI-Express device
|
|
*/
|
|
static void ismt_remove(struct pci_dev *pdev)
|
|
{
|
|
struct ismt_priv *priv = pci_get_drvdata(pdev);
|
|
|
|
i2c_del_adapter(&priv->adapter);
|
|
}
|
|
|
|
static struct pci_driver ismt_driver = {
|
|
.name = "ismt_smbus",
|
|
.id_table = ismt_ids,
|
|
.probe = ismt_probe,
|
|
.remove = ismt_remove,
|
|
};
|
|
|
|
module_pci_driver(ismt_driver);
|
|
|
|
MODULE_LICENSE("Dual BSD/GPL");
|
|
MODULE_AUTHOR("Bill E. Brown <bill.e.brown@intel.com>");
|
|
MODULE_DESCRIPTION("Intel SMBus Message Transport (iSMT) driver");
|