392 lines
8.8 KiB
C
392 lines
8.8 KiB
C
/*
|
|
* IOSF-SB MailBox Interface Driver
|
|
* Copyright (c) 2013, Intel Corporation.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms and conditions of the GNU General Public License,
|
|
* version 2, as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope 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 IOSF-SB is a fabric bus available on Atom based SOC's that uses a
|
|
* mailbox interface (MBI) to communicate with mutiple devices. This
|
|
* driver implements access to this interface for those platforms that can
|
|
* enumerate the device using PCI.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/debugfs.h>
|
|
#include <linux/capability.h>
|
|
|
|
#include <asm/iosf_mbi.h>
|
|
|
|
#define PCI_DEVICE_ID_BAYTRAIL 0x0F00
|
|
#define PCI_DEVICE_ID_BRASWELL 0x2280
|
|
#define PCI_DEVICE_ID_QUARK_X1000 0x0958
|
|
#define PCI_DEVICE_ID_TANGIER 0x1170
|
|
|
|
static struct pci_dev *mbi_pdev;
|
|
static DEFINE_SPINLOCK(iosf_mbi_lock);
|
|
static DEFINE_MUTEX(iosf_mbi_punit_mutex);
|
|
static BLOCKING_NOTIFIER_HEAD(iosf_mbi_pmic_bus_access_notifier);
|
|
|
|
static inline u32 iosf_mbi_form_mcr(u8 op, u8 port, u8 offset)
|
|
{
|
|
return (op << 24) | (port << 16) | (offset << 8) | MBI_ENABLE;
|
|
}
|
|
|
|
static int iosf_mbi_pci_read_mdr(u32 mcrx, u32 mcr, u32 *mdr)
|
|
{
|
|
int result;
|
|
|
|
if (!mbi_pdev)
|
|
return -ENODEV;
|
|
|
|
if (mcrx) {
|
|
result = pci_write_config_dword(mbi_pdev, MBI_MCRX_OFFSET,
|
|
mcrx);
|
|
if (result < 0)
|
|
goto fail_read;
|
|
}
|
|
|
|
result = pci_write_config_dword(mbi_pdev, MBI_MCR_OFFSET, mcr);
|
|
if (result < 0)
|
|
goto fail_read;
|
|
|
|
result = pci_read_config_dword(mbi_pdev, MBI_MDR_OFFSET, mdr);
|
|
if (result < 0)
|
|
goto fail_read;
|
|
|
|
return 0;
|
|
|
|
fail_read:
|
|
dev_err(&mbi_pdev->dev, "PCI config access failed with %d\n", result);
|
|
return result;
|
|
}
|
|
|
|
static int iosf_mbi_pci_write_mdr(u32 mcrx, u32 mcr, u32 mdr)
|
|
{
|
|
int result;
|
|
|
|
if (!mbi_pdev)
|
|
return -ENODEV;
|
|
|
|
result = pci_write_config_dword(mbi_pdev, MBI_MDR_OFFSET, mdr);
|
|
if (result < 0)
|
|
goto fail_write;
|
|
|
|
if (mcrx) {
|
|
result = pci_write_config_dword(mbi_pdev, MBI_MCRX_OFFSET,
|
|
mcrx);
|
|
if (result < 0)
|
|
goto fail_write;
|
|
}
|
|
|
|
result = pci_write_config_dword(mbi_pdev, MBI_MCR_OFFSET, mcr);
|
|
if (result < 0)
|
|
goto fail_write;
|
|
|
|
return 0;
|
|
|
|
fail_write:
|
|
dev_err(&mbi_pdev->dev, "PCI config access failed with %d\n", result);
|
|
return result;
|
|
}
|
|
|
|
int iosf_mbi_read(u8 port, u8 opcode, u32 offset, u32 *mdr)
|
|
{
|
|
u32 mcr, mcrx;
|
|
unsigned long flags;
|
|
int ret;
|
|
|
|
/* Access to the GFX unit is handled by GPU code */
|
|
if (port == BT_MBI_UNIT_GFX) {
|
|
WARN_ON(1);
|
|
return -EPERM;
|
|
}
|
|
|
|
mcr = iosf_mbi_form_mcr(opcode, port, offset & MBI_MASK_LO);
|
|
mcrx = offset & MBI_MASK_HI;
|
|
|
|
spin_lock_irqsave(&iosf_mbi_lock, flags);
|
|
ret = iosf_mbi_pci_read_mdr(mcrx, mcr, mdr);
|
|
spin_unlock_irqrestore(&iosf_mbi_lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(iosf_mbi_read);
|
|
|
|
int iosf_mbi_write(u8 port, u8 opcode, u32 offset, u32 mdr)
|
|
{
|
|
u32 mcr, mcrx;
|
|
unsigned long flags;
|
|
int ret;
|
|
|
|
/* Access to the GFX unit is handled by GPU code */
|
|
if (port == BT_MBI_UNIT_GFX) {
|
|
WARN_ON(1);
|
|
return -EPERM;
|
|
}
|
|
|
|
mcr = iosf_mbi_form_mcr(opcode, port, offset & MBI_MASK_LO);
|
|
mcrx = offset & MBI_MASK_HI;
|
|
|
|
spin_lock_irqsave(&iosf_mbi_lock, flags);
|
|
ret = iosf_mbi_pci_write_mdr(mcrx, mcr, mdr);
|
|
spin_unlock_irqrestore(&iosf_mbi_lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(iosf_mbi_write);
|
|
|
|
int iosf_mbi_modify(u8 port, u8 opcode, u32 offset, u32 mdr, u32 mask)
|
|
{
|
|
u32 mcr, mcrx;
|
|
u32 value;
|
|
unsigned long flags;
|
|
int ret;
|
|
|
|
/* Access to the GFX unit is handled by GPU code */
|
|
if (port == BT_MBI_UNIT_GFX) {
|
|
WARN_ON(1);
|
|
return -EPERM;
|
|
}
|
|
|
|
mcr = iosf_mbi_form_mcr(opcode, port, offset & MBI_MASK_LO);
|
|
mcrx = offset & MBI_MASK_HI;
|
|
|
|
spin_lock_irqsave(&iosf_mbi_lock, flags);
|
|
|
|
/* Read current mdr value */
|
|
ret = iosf_mbi_pci_read_mdr(mcrx, mcr & MBI_RD_MASK, &value);
|
|
if (ret < 0) {
|
|
spin_unlock_irqrestore(&iosf_mbi_lock, flags);
|
|
return ret;
|
|
}
|
|
|
|
/* Apply mask */
|
|
value &= ~mask;
|
|
mdr &= mask;
|
|
value |= mdr;
|
|
|
|
/* Write back */
|
|
ret = iosf_mbi_pci_write_mdr(mcrx, mcr | MBI_WR_MASK, value);
|
|
|
|
spin_unlock_irqrestore(&iosf_mbi_lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(iosf_mbi_modify);
|
|
|
|
bool iosf_mbi_available(void)
|
|
{
|
|
/* Mbi isn't hot-pluggable. No remove routine is provided */
|
|
return mbi_pdev;
|
|
}
|
|
EXPORT_SYMBOL(iosf_mbi_available);
|
|
|
|
void iosf_mbi_punit_acquire(void)
|
|
{
|
|
mutex_lock(&iosf_mbi_punit_mutex);
|
|
}
|
|
EXPORT_SYMBOL(iosf_mbi_punit_acquire);
|
|
|
|
void iosf_mbi_punit_release(void)
|
|
{
|
|
mutex_unlock(&iosf_mbi_punit_mutex);
|
|
}
|
|
EXPORT_SYMBOL(iosf_mbi_punit_release);
|
|
|
|
int iosf_mbi_register_pmic_bus_access_notifier(struct notifier_block *nb)
|
|
{
|
|
int ret;
|
|
|
|
/* Wait for the bus to go inactive before registering */
|
|
mutex_lock(&iosf_mbi_punit_mutex);
|
|
ret = blocking_notifier_chain_register(
|
|
&iosf_mbi_pmic_bus_access_notifier, nb);
|
|
mutex_unlock(&iosf_mbi_punit_mutex);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(iosf_mbi_register_pmic_bus_access_notifier);
|
|
|
|
int iosf_mbi_unregister_pmic_bus_access_notifier_unlocked(
|
|
struct notifier_block *nb)
|
|
{
|
|
iosf_mbi_assert_punit_acquired();
|
|
|
|
return blocking_notifier_chain_unregister(
|
|
&iosf_mbi_pmic_bus_access_notifier, nb);
|
|
}
|
|
EXPORT_SYMBOL(iosf_mbi_unregister_pmic_bus_access_notifier_unlocked);
|
|
|
|
int iosf_mbi_unregister_pmic_bus_access_notifier(struct notifier_block *nb)
|
|
{
|
|
int ret;
|
|
|
|
/* Wait for the bus to go inactive before unregistering */
|
|
mutex_lock(&iosf_mbi_punit_mutex);
|
|
ret = iosf_mbi_unregister_pmic_bus_access_notifier_unlocked(nb);
|
|
mutex_unlock(&iosf_mbi_punit_mutex);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(iosf_mbi_unregister_pmic_bus_access_notifier);
|
|
|
|
int iosf_mbi_call_pmic_bus_access_notifier_chain(unsigned long val, void *v)
|
|
{
|
|
return blocking_notifier_call_chain(
|
|
&iosf_mbi_pmic_bus_access_notifier, val, v);
|
|
}
|
|
EXPORT_SYMBOL(iosf_mbi_call_pmic_bus_access_notifier_chain);
|
|
|
|
void iosf_mbi_assert_punit_acquired(void)
|
|
{
|
|
WARN_ON(!mutex_is_locked(&iosf_mbi_punit_mutex));
|
|
}
|
|
EXPORT_SYMBOL(iosf_mbi_assert_punit_acquired);
|
|
|
|
#ifdef CONFIG_IOSF_MBI_DEBUG
|
|
static u32 dbg_mdr;
|
|
static u32 dbg_mcr;
|
|
static u32 dbg_mcrx;
|
|
|
|
static int mcr_get(void *data, u64 *val)
|
|
{
|
|
*val = *(u32 *)data;
|
|
return 0;
|
|
}
|
|
|
|
static int mcr_set(void *data, u64 val)
|
|
{
|
|
u8 command = ((u32)val & 0xFF000000) >> 24,
|
|
port = ((u32)val & 0x00FF0000) >> 16,
|
|
offset = ((u32)val & 0x0000FF00) >> 8;
|
|
int err;
|
|
|
|
*(u32 *)data = val;
|
|
|
|
if (!capable(CAP_SYS_RAWIO))
|
|
return -EACCES;
|
|
|
|
if (command & 1u)
|
|
err = iosf_mbi_write(port,
|
|
command,
|
|
dbg_mcrx | offset,
|
|
dbg_mdr);
|
|
else
|
|
err = iosf_mbi_read(port,
|
|
command,
|
|
dbg_mcrx | offset,
|
|
&dbg_mdr);
|
|
|
|
return err;
|
|
}
|
|
DEFINE_SIMPLE_ATTRIBUTE(iosf_mcr_fops, mcr_get, mcr_set , "%llx\n");
|
|
|
|
static struct dentry *iosf_dbg;
|
|
|
|
static void iosf_sideband_debug_init(void)
|
|
{
|
|
struct dentry *d;
|
|
|
|
iosf_dbg = debugfs_create_dir("iosf_sb", NULL);
|
|
if (IS_ERR_OR_NULL(iosf_dbg))
|
|
return;
|
|
|
|
/* mdr */
|
|
d = debugfs_create_x32("mdr", 0660, iosf_dbg, &dbg_mdr);
|
|
if (!d)
|
|
goto cleanup;
|
|
|
|
/* mcrx */
|
|
d = debugfs_create_x32("mcrx", 0660, iosf_dbg, &dbg_mcrx);
|
|
if (!d)
|
|
goto cleanup;
|
|
|
|
/* mcr - initiates mailbox tranaction */
|
|
d = debugfs_create_file("mcr", 0660, iosf_dbg, &dbg_mcr, &iosf_mcr_fops);
|
|
if (!d)
|
|
goto cleanup;
|
|
|
|
return;
|
|
|
|
cleanup:
|
|
debugfs_remove_recursive(d);
|
|
}
|
|
|
|
static void iosf_debugfs_init(void)
|
|
{
|
|
iosf_sideband_debug_init();
|
|
}
|
|
|
|
static void iosf_debugfs_remove(void)
|
|
{
|
|
debugfs_remove_recursive(iosf_dbg);
|
|
}
|
|
#else
|
|
static inline void iosf_debugfs_init(void) { }
|
|
static inline void iosf_debugfs_remove(void) { }
|
|
#endif /* CONFIG_IOSF_MBI_DEBUG */
|
|
|
|
static int iosf_mbi_probe(struct pci_dev *pdev,
|
|
const struct pci_device_id *unused)
|
|
{
|
|
int ret;
|
|
|
|
ret = pci_enable_device(pdev);
|
|
if (ret < 0) {
|
|
dev_err(&pdev->dev, "error: could not enable device\n");
|
|
return ret;
|
|
}
|
|
|
|
mbi_pdev = pci_dev_get(pdev);
|
|
return 0;
|
|
}
|
|
|
|
static const struct pci_device_id iosf_mbi_pci_ids[] = {
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_BAYTRAIL) },
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_BRASWELL) },
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_QUARK_X1000) },
|
|
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_TANGIER) },
|
|
{ 0, },
|
|
};
|
|
MODULE_DEVICE_TABLE(pci, iosf_mbi_pci_ids);
|
|
|
|
static struct pci_driver iosf_mbi_pci_driver = {
|
|
.name = "iosf_mbi_pci",
|
|
.probe = iosf_mbi_probe,
|
|
.id_table = iosf_mbi_pci_ids,
|
|
};
|
|
|
|
static int __init iosf_mbi_init(void)
|
|
{
|
|
iosf_debugfs_init();
|
|
|
|
return pci_register_driver(&iosf_mbi_pci_driver);
|
|
}
|
|
|
|
static void __exit iosf_mbi_exit(void)
|
|
{
|
|
iosf_debugfs_remove();
|
|
|
|
pci_unregister_driver(&iosf_mbi_pci_driver);
|
|
pci_dev_put(mbi_pdev);
|
|
mbi_pdev = NULL;
|
|
}
|
|
|
|
module_init(iosf_mbi_init);
|
|
module_exit(iosf_mbi_exit);
|
|
|
|
MODULE_AUTHOR("David E. Box <david.e.box@linux.intel.com>");
|
|
MODULE_DESCRIPTION("IOSF Mailbox Interface accessor");
|
|
MODULE_LICENSE("GPL v2");
|