Release 4.7 drivers/mfd/sta2x11-mfd.c

Directory: drivers/mfd
/*
 * Copyright (c) 2009-2011 Wind River Systems, Inc.
 * Copyright (c) 2011 ST Microelectronics (Alessandro Rubini, Davide Ciminaghi)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/errno.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/io.h>
#include <linux/ioport.h>
#include <linux/pci.h>
#include <linux/seq_file.h>
#include <linux/platform_device.h>
#include <linux/mfd/core.h>
#include <linux/mfd/sta2x11-mfd.h>
#include <linux/regmap.h>

#include <asm/sta2x11.h>



static inline int __reg_within_range(unsigned int r,
				     unsigned int start,
				     unsigned int end)
{
	return ((r >= start) && (r <= end));
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%

/* This describes STA2X11 MFD chip for us, we may have several */

struct sta2x11_mfd {
	
struct sta2x11_instance *instance;
	
struct regmap *regmap[sta2x11_n_mfd_plat_devs];
	
spinlock_t lock[sta2x11_n_mfd_plat_devs];
	
struct list_head list;
	
void __iomem *regs[sta2x11_n_mfd_plat_devs];
};

static LIST_HEAD(sta2x11_mfd_list);

/* Three functions to act on the list */


static struct sta2x11_mfd *sta2x11_mfd_find(struct pci_dev *pdev)
{
	struct sta2x11_instance *instance;
	struct sta2x11_mfd *mfd;

	if (!pdev && !list_empty(&sta2x11_mfd_list)) {
		pr_warning("%s: Unspecified device, "
			    "using first instance\n", __func__);
		return list_entry(sta2x11_mfd_list.next,
				  struct sta2x11_mfd, list);
	}

	instance = sta2x11_get_instance(pdev);
	if (!instance)
		return NULL;
	list_for_each_entry(mfd, &sta2x11_mfd_list, list) {
		if (mfd->instance == instance)
			return mfd;
	}
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
alessandro rubini alessandro rubini 97 100.00% 1 100.00%
Total 97 100.00% 1 100.00%



static int sta2x11_mfd_add(struct pci_dev *pdev, gfp_t flags)
{
	int i;
	struct sta2x11_mfd *mfd = sta2x11_mfd_find(pdev);
	struct sta2x11_instance *instance;

	if (mfd)
		return -EBUSY;
	instance = sta2x11_get_instance(pdev);
	if (!instance)
		return -EINVAL;
	mfd = kzalloc(sizeof(*mfd), flags);
	if (!mfd)
		return -ENOMEM;
	INIT_LIST_HEAD(&mfd->list);
	for (i = 0; i < ARRAY_SIZE(mfd->lock); i++)
		spin_lock_init(&mfd->lock[i]);
	mfd->instance = instance;
	list_add(&mfd->list, &sta2x11_mfd_list);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
alessandro rubini alessandro rubini 111 82.22% 1 50.00%
davide ciminaghi davide ciminaghi 24 17.78% 1 50.00%
Total 135 100.00% 2 100.00%

/* This function is exported and is not expected to fail */


u32 __sta2x11_mfd_mask(struct pci_dev *pdev, u32 reg, u32 mask, u32 val,
		       enum sta2x11_mfd_plat_dev index)
{
	struct sta2x11_mfd *mfd = sta2x11_mfd_find(pdev);
	u32 r;
	unsigned long flags;
	void __iomem *regs;

	if (!mfd) {
		dev_warn(&pdev->dev, ": can't access sctl regs\n");
		return 0;
	}

	regs = mfd->regs[index];
	if (!regs) {
		dev_warn(&pdev->dev, ": system ctl not initialized\n");
		return 0;
	}
	spin_lock_irqsave(&mfd->lock[index], flags);
	r = readl(regs + reg);
	r &= ~mask;
	r |= val;
	if (mask)
		writel(r, regs + reg);
	spin_unlock_irqrestore(&mfd->lock[index], flags);
	return r;
}
Contributors
Person Tokens Prop Commits CommitProp
alessandro rubini alessandro rubini 128 83.12% 1 25.00%
davide ciminaghi davide ciminaghi 17 11.04% 2 50.00%
wei yongjun wei yongjun 9 5.84% 1 25.00%
Total 154 100.00% 4 100.00%


EXPORT_SYMBOL(__sta2x11_mfd_mask);



int sta2x11_mfd_get_regs_data(struct platform_device *dev,
			      enum sta2x11_mfd_plat_dev index,
			      void __iomem **regs,
			      spinlock_t **lock)
{
	struct pci_dev *pdev = *(struct pci_dev **)dev_get_platdata(&dev->dev);
	struct sta2x11_mfd *mfd;

	if (!pdev)
		return -ENODEV;
	mfd = sta2x11_mfd_find(pdev);
	if (!mfd)
		return -ENODEV;
	if (index >= sta2x11_n_mfd_plat_devs)
		return -ENODEV;
	*regs = mfd->regs[index];
	*lock = &mfd->lock[index];
	pr_debug("%s %d *regs = %p\n", __func__, __LINE__, *regs);
	return *regs ? 0 : -ENODEV;
}
Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 80 62.99% 1 33.33%
alessandro rubini alessandro rubini 43 33.86% 1 33.33%
jingoo han jingoo han 4 3.15% 1 33.33%
Total 127 100.00% 3 100.00%


EXPORT_SYMBOL(sta2x11_mfd_get_regs_data);

/*
 * Special sta2x11-mfd regmap lock/unlock functions
 */



static void sta2x11_regmap_lock(void *__lock)
{
	spinlock_t *lock = __lock;
	spin_lock(lock);
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 16 76.19% 1 50.00%
alessandro rubini alessandro rubini 5 23.81% 1 50.00%
Total 21 100.00% 2 100.00%



static void sta2x11_regmap_unlock(void *__lock)
{
	spinlock_t *lock = __lock;
	spin_unlock(lock);
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 19 90.48% 1 50.00%
alessandro rubini alessandro rubini 2 9.52% 1 50.00%
Total 21 100.00% 2 100.00%

/* OTP (one time programmable registers do not require locking */


static void sta2x11_regmap_nolock(void *__lock)
{
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 9 100.00% 1 100.00%
Total 9 100.00% 1 100.00%


static const char *sta2x11_mfd_names[sta2x11_n_mfd_plat_devs] = {
	[sta2x11_sctl] = STA2X11_MFD_SCTL_NAME,
	[sta2x11_apbreg] = STA2X11_MFD_APBREG_NAME,
	[sta2x11_apb_soc_regs] = STA2X11_MFD_APB_SOC_REGS_NAME,
	[sta2x11_scr] = STA2X11_MFD_SCR_NAME,
};



static bool sta2x11_sctl_writeable_reg(struct device *dev, unsigned int reg)
{
	return !__reg_within_range(reg, SCTL_SCPCIECSBRST, SCTL_SCRSTSTA);
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 22 84.62% 1 50.00%
alessandro rubini alessandro rubini 4 15.38% 1 50.00%
Total 26 100.00% 2 100.00%


static struct regmap_config sta2x11_sctl_regmap_config = {
	.reg_bits = 32,
	.reg_stride = 4,
	.val_bits = 32,
	.lock = sta2x11_regmap_lock,
	.unlock = sta2x11_regmap_unlock,
	.max_register = SCTL_SCRSTSTA,
	.writeable_reg = sta2x11_sctl_writeable_reg,
};



static bool sta2x11_scr_readable_reg(struct device *dev, unsigned int reg)
{
	return (reg == STA2X11_SECR_CR) ||
		__reg_within_range(reg, STA2X11_SECR_FVR0, STA2X11_SECR_FVR1);
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%



static bool sta2x11_scr_writeable_reg(struct device *dev, unsigned int reg)
{
	return false;
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%


static struct regmap_config sta2x11_scr_regmap_config = {
	.reg_bits = 32,
	.reg_stride = 4,
	.val_bits = 32,
	.lock = sta2x11_regmap_nolock,
	.unlock = sta2x11_regmap_nolock,
	.max_register = STA2X11_SECR_FVR1,
	.readable_reg = sta2x11_scr_readable_reg,
	.writeable_reg = sta2x11_scr_writeable_reg,
};



static bool sta2x11_apbreg_readable_reg(struct device *dev, unsigned int reg)
{
	/* Two blocks (CAN and MLB, SARAC) 0x100 bytes apart */
	if (reg >= APBREG_BSR_SARAC)
		reg -= APBREG_BSR_SARAC;
	switch (reg) {
	case APBREG_BSR:
	case APBREG_PAER:
	case APBREG_PWAC:
	case APBREG_PRAC:
	case APBREG_PCG:
	case APBREG_PUR:
	case APBREG_EMU_PCG:
		return true;
	default:
		return false;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 50 83.33% 1 50.00%
alessandro rubini alessandro rubini 10 16.67% 1 50.00%
Total 60 100.00% 2 100.00%



static bool sta2x11_apbreg_writeable_reg(struct device *dev, unsigned int reg)
{
	if (reg >= APBREG_BSR_SARAC)
		reg -= APBREG_BSR_SARAC;
	if (!sta2x11_apbreg_readable_reg(dev, reg))
		return false;
	return reg != APBREG_PAER;
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 42 97.67% 2 66.67%
alessandro rubini alessandro rubini 1 2.33% 1 33.33%
Total 43 100.00% 3 100.00%


static struct regmap_config sta2x11_apbreg_regmap_config = {
	.reg_bits = 32,
	.reg_stride = 4,
	.val_bits = 32,
	.lock = sta2x11_regmap_lock,
	.unlock = sta2x11_regmap_unlock,
	.max_register = APBREG_EMU_PCG_SARAC,
	.readable_reg = sta2x11_apbreg_readable_reg,
	.writeable_reg = sta2x11_apbreg_writeable_reg,
};



static bool sta2x11_apb_soc_regs_readable_reg(struct device *dev,
					      unsigned int reg)
{
	return reg <= PCIE_SoC_INT_ROUTER_STATUS3_REG ||
		__reg_within_range(reg, DMA_IP_CTRL_REG, SPARE3_RESERVED) ||
		__reg_within_range(reg, MASTER_LOCK_REG,
				   SYSTEM_CONFIG_STATUS_REG) ||
		reg == MSP_CLK_CTRL_REG ||
		__reg_within_range(reg, COMPENSATION_REG1, TEST_CTL_REG);
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 37 72.55% 2 66.67%
alessandro rubini alessandro rubini 14 27.45% 1 33.33%
Total 51 100.00% 3 100.00%



static bool sta2x11_apb_soc_regs_writeable_reg(struct device *dev,
					       unsigned int reg)
{
	if (!sta2x11_apb_soc_regs_readable_reg(dev, reg))
		return false;
	switch (reg) {
	case PCIE_COMMON_CLOCK_CONFIG_0_4_0:
	case SYSTEM_CONFIG_STATUS_REG:
	case COMPENSATION_REG1:
	case PCIE_SoC_INT_ROUTER_STATUS0_REG...PCIE_SoC_INT_ROUTER_STATUS3_REG:
	case PCIE_PM_STATUS_0_PORT_0_4...PCIE_PM_STATUS_7_0_EP4:
		return false;
	default:
		return true;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 45 75.00% 1 50.00%
alessandro rubini alessandro rubini 15 25.00% 1 50.00%
Total 60 100.00% 2 100.00%


static struct regmap_config sta2x11_apb_soc_regs_regmap_config = {
	.reg_bits = 32,
	.reg_stride = 4,
	.val_bits = 32,
	.lock = sta2x11_regmap_lock,
	.unlock = sta2x11_regmap_unlock,
	.max_register = TEST_CTL_REG,
	.readable_reg = sta2x11_apb_soc_regs_readable_reg,
	.writeable_reg = sta2x11_apb_soc_regs_writeable_reg,
};

static struct regmap_config *

sta2x11_mfd_regmap_configs[sta2x11_n_mfd_plat_devs] = {
	[sta2x11_sctl] = &sta2x11_sctl_regmap_config,
	[sta2x11_apbreg] = &sta2x11_apbreg_regmap_config,
	[sta2x11_apb_soc_regs] = &sta2x11_apb_soc_regs_regmap_config,
	[sta2x11_scr] = &sta2x11_scr_regmap_config,
};

/* Probe for the four platform devices */



static int sta2x11_mfd_platform_probe(struct platform_device *dev,
				      enum sta2x11_mfd_plat_dev index)
{
	struct pci_dev **pdev;
	struct sta2x11_mfd *mfd;
	struct resource *res;
	const char *name = sta2x11_mfd_names[index];
	struct regmap_config *regmap_config = sta2x11_mfd_regmap_configs[index];

	pdev = dev_get_platdata(&dev->dev);
	mfd = sta2x11_mfd_find(*pdev);
	if (!mfd)
		return -ENODEV;
	if (!regmap_config)
		return -ENODEV;

	res = platform_get_resource(dev, IORESOURCE_MEM, 0);
	if (!res)
		return -ENOMEM;

	if (!request_mem_region(res->start, resource_size(res), name))
		return -EBUSY;

	mfd->regs[index] = ioremap(res->start, resource_size(res));
	if (!mfd->regs[index]) {
		release_mem_region(res->start, resource_size(res));
		return -ENOMEM;
	}
	regmap_config->lock_arg = &mfd->lock;
	/*
           No caching, registers could be reached both via regmap and via
           void __iomem *
        */
	regmap_config->cache_type = REGCACHE_NONE;
	mfd->regmap[index] = devm_regmap_init_mmio(&dev->dev, mfd->regs[index],
						   regmap_config);
	WARN_ON(IS_ERR(mfd->regmap[index]));

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
alessandro rubini alessandro rubini 147 63.64% 1 20.00%
davide ciminaghi davide ciminaghi 77 33.33% 2 40.00%
jingoo han jingoo han 4 1.73% 1 20.00%
wei yongjun wei yongjun 3 1.30% 1 20.00%
Total 231 100.00% 5 100.00%



static int sta2x11_sctl_probe(struct platform_device *dev)
{
	return sta2x11_mfd_platform_probe(dev, sta2x11_sctl);
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 17 89.47% 1 50.00%
alessandro rubini alessandro rubini 2 10.53% 1 50.00%
Total 19 100.00% 2 100.00%



static int sta2x11_apbreg_probe(struct platform_device *dev)
{
	return sta2x11_mfd_platform_probe(dev, sta2x11_apbreg);
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 18 94.74% 1 50.00%
alessandro rubini alessandro rubini 1 5.26% 1 50.00%
Total 19 100.00% 2 100.00%



static int sta2x11_apb_soc_regs_probe(struct platform_device *dev)
{
	return sta2x11_mfd_platform_probe(dev, sta2x11_apb_soc_regs);
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 18 94.74% 1 50.00%
alessandro rubini alessandro rubini 1 5.26% 1 50.00%
Total 19 100.00% 2 100.00%



static int sta2x11_scr_probe(struct platform_device *dev)
{
	return sta2x11_mfd_platform_probe(dev, sta2x11_scr);
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%

/* The three platform drivers */

static struct platform_driver sta2x11_sctl_platform_driver = {
	.driver = {
		.name	= STA2X11_MFD_SCTL_NAME,
        },
	.probe		= sta2x11_sctl_probe,
};


static struct platform_driver sta2x11_platform_driver = {
	.driver = {
		.name	= STA2X11_MFD_APBREG_NAME,
        },
	.probe		= sta2x11_apbreg_probe,
};


static struct platform_driver sta2x11_apb_soc_regs_platform_driver = {
	.driver = {
		.name	= STA2X11_MFD_APB_SOC_REGS_NAME,
        },
	.probe		= sta2x11_apb_soc_regs_probe,
};


static struct platform_driver sta2x11_scr_platform_driver = {
	.driver = {
		.name = STA2X11_MFD_SCR_NAME,
        },
	.probe = sta2x11_scr_probe,
};


static struct platform_driver * const drivers[] = {
	&sta2x11_platform_driver,
	&sta2x11_sctl_platform_driver,
	&sta2x11_apb_soc_regs_platform_driver,
	&sta2x11_scr_platform_driver,
};



static int __init sta2x11_drivers_init(void)
{
	return platform_register_drivers(drivers, ARRAY_SIZE(drivers));
}

Contributors
Person Tokens Prop Commits CommitProp
alessandro rubini alessandro rubini 13 65.00% 1 50.00%
thierry reding thierry reding 7 35.00% 1 50.00%
Total 20 100.00% 2 100.00%

/*
 * What follows are the PCI devices that host the above pdevs.
 * Each logic block is 4kB and they are all consecutive: we use this info.
 */

/* Mfd 0 device */

/* Mfd 0, Bar 0 */

enum mfd0_bar0_cells {
	
STA2X11_GPIO_0 = 0,
	
STA2X11_GPIO_1,
	
STA2X11_GPIO_2,
	
STA2X11_GPIO_3,
	
STA2X11_SCTL,
	
STA2X11_SCR,
	
STA2X11_TIME,
};
/* Mfd 0 , Bar 1 */

enum mfd0_bar1_cells {
	
STA2X11_APBREG = 0,
};

#define CELL_4K(_name, _cell) { \
                .name = _name, \
                .start = _cell * 4096, .end = _cell * 4096 + 4095, \
                .flags = IORESOURCE_MEM, \
                }


static const struct resource gpio_resources[] = {
	{
		/* 4 consecutive cells, 1 driver */
		.name = STA2X11_MFD_GPIO_NAME,
		.start = 0,
		.end = (4 * 4096) - 1,
		.flags = IORESOURCE_MEM,
        }
};

static const struct resource sctl_resources[] = {
	CELL_4K(STA2X11_MFD_SCTL_NAME, STA2X11_SCTL),
};

static const struct resource scr_resources[] = {
	CELL_4K(STA2X11_MFD_SCR_NAME, STA2X11_SCR),
};

static const struct resource time_resources[] = {
	CELL_4K(STA2X11_MFD_TIME_NAME, STA2X11_TIME),
};


static const struct resource apbreg_resources[] = {
	CELL_4K(STA2X11_MFD_APBREG_NAME, STA2X11_APBREG),
};


#define DEV(_name, _r) \
	{ .name = _name, .num_resources = ARRAY_SIZE(_r), .resources = _r, }


static struct mfd_cell sta2x11_mfd0_bar0[] = {
	/* offset 0: we add pdata later */
	DEV(STA2X11_MFD_GPIO_NAME, gpio_resources),
	DEV(STA2X11_MFD_SCTL_NAME, sctl_resources),
	DEV(STA2X11_MFD_SCR_NAME,  scr_resources),
	DEV(STA2X11_MFD_TIME_NAME, time_resources),
};


static struct mfd_cell sta2x11_mfd0_bar1[] = {
	DEV(STA2X11_MFD_APBREG_NAME, apbreg_resources),
};

/* Mfd 1 devices */

/* Mfd 1, Bar 0 */

enum mfd1_bar0_cells {
	
STA2X11_VIC = 0,
};

/* Mfd 1, Bar 1 */

enum mfd1_bar1_cells {
	
STA2X11_APB_SOC_REGS = 0,
};


static const struct resource vic_resources[] = {
	CELL_4K(STA2X11_MFD_VIC_NAME, STA2X11_VIC),
};


static const struct resource apb_soc_regs_resources[] = {
	CELL_4K(STA2X11_MFD_APB_SOC_REGS_NAME, STA2X11_APB_SOC_REGS),
};


static struct mfd_cell sta2x11_mfd1_bar0[] = {
	DEV(STA2X11_MFD_VIC_NAME, vic_resources),
};


static struct mfd_cell sta2x11_mfd1_bar1[] = {
	DEV(STA2X11_MFD_APB_SOC_REGS_NAME, apb_soc_regs_resources),
};




static int sta2x11_mfd_suspend(struct pci_dev *pdev, pm_message_t state)
{
	pci_save_state(pdev);
	pci_disable_device(pdev);
	pci_set_power_state(pdev, pci_choose_state(pdev, state));

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
alessandro rubini alessandro rubini 39 100.00% 1 100.00%
Total 39 100.00% 1 100.00%



static int sta2x11_mfd_resume(struct pci_dev *pdev)
{
	int err;

	pci_set_power_state(pdev, PCI_D0);
	err = pci_enable_device(pdev);
	if (err)
		return err;
	pci_restore_state(pdev);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 29 67.44% 1 33.33%
alessandro rubini alessandro rubini 13 30.23% 1 33.33%
julia lawall julia lawall 1 2.33% 1 33.33%
Total 43 100.00% 3 100.00%


struct sta2x11_mfd_bar_setup_data {
	
struct mfd_cell *cells;
	
int ncells;
};


struct sta2x11_mfd_setup_data {
	
struct sta2x11_mfd_bar_setup_data bars[2];
};


#define STA2X11_MFD0 0

#define STA2X11_MFD1 1


static struct sta2x11_mfd_setup_data mfd_setup_data[] = {
	/* Mfd 0: gpio, sctl, scr, timers / apbregs */
	[STA2X11_MFD0] = {
		.bars = {
			[0] = {
				.cells = sta2x11_mfd0_bar0,
				.ncells = ARRAY_SIZE(sta2x11_mfd0_bar0),
                        },
			[1] = {
				.cells = sta2x11_mfd0_bar1,
				.ncells = ARRAY_SIZE(sta2x11_mfd0_bar1),
                        },
                },
        },
	/* Mfd 1: vic / apb-soc-regs */
	[STA2X11_MFD1] = {
		.bars = {
			[0] = {
				.cells = sta2x11_mfd1_bar0,
				.ncells = ARRAY_SIZE(sta2x11_mfd1_bar0),
                        },
			[1] = {
				.cells = sta2x11_mfd1_bar1,
				.ncells = ARRAY_SIZE(sta2x11_mfd1_bar1),
                        },
                },
        },
};



static void sta2x11_mfd_setup(struct pci_dev *pdev,
			      struct sta2x11_mfd_setup_data *sd)
{
	int i, j;
	for (i = 0; i < ARRAY_SIZE(sd->bars); i++)
		for (j = 0; j < sd->bars[i].ncells; j++) {
			sd->bars[i].cells[j].pdata_size = sizeof(pdev);
			sd->bars[i].cells[j].platform_data = &pdev;
		}
}

Contributors
Person Tokens Prop Commits CommitProp
davide ciminaghi davide ciminaghi 77 79.38% 1 50.00%
alessandro rubini alessandro rubini 20 20.62% 1 50.00%
Total 97 100.00% 2 100.00%



static int sta2x11_mfd_probe(struct pci_dev *pdev,
			     const struct pci_device_id *pci_id)
{
	int err, i;
	struct sta2x11_mfd_setup_data *setup_data;

	dev_info(&pdev->dev, "%s\n", __func__);

	err = pci_enable_device(pdev);
	if (err) {
		dev_err(&pdev->dev, "Can't enable device.\n");
		return err;
	}

	err = pci_enable_msi(pdev);
	if (err)
		dev_info(&pdev->dev, "Enable msi failed\n");

	setup_data = pci_id->device == PCI_DEVICE_ID_STMICRO_GPIO ?
		&mfd_setup_data[STA2X11_MFD0] :
		&mfd_setup_data[STA2X11_MFD1];

	/* platform data is the pci device for all of them */
	sta2x11_mfd_setup(pdev, setup_data);

	/* Record this pdev before mfd_add_devices: their probe looks for it */
	if (!sta2x11_mfd_find(pdev))
		sta2x11_mfd_add(pdev, GFP_ATOMIC);

	/* Just 2 bars for all mfd's at present */
	for (i = 0; i < 2; i++) {
		err = mfd_add_devices(&pdev->dev, -1,
				      setup_data->bars[i].cells,
				      setup_data->bars[i].ncells,
				      &pdev->resource[i],
				      0, NULL);
		if (err) {
			dev_err(&pdev->dev,
				"mfd_add_devices[%d] failed: %d\n", i, err);
			goto err_disable;
		}
	}

	return 0;

err_disable:
	mfd_remove_devices(&pdev->dev);
	pci_disable_device(pdev);
	pci_disable_msi(pdev);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
alessandro rubini alessandro rubini 188 78.99% 1 25.00%
davide ciminaghi davide ciminaghi 48 20.17% 2 50.00%
mark brown mark brown 2 0.84% 1 25.00%
Total 238 100.00% 4 100.00%


static const struct pci_device_id sta2x11_mfd_tbl[] = {
	{PCI_DEVICE(PCI_VENDOR_ID_STMICRO, PCI_DEVICE_ID_STMICRO_GPIO)},
	{PCI_DEVICE(PCI_VENDOR_ID_STMICRO, PCI_DEVICE_ID_STMICRO_VIC)},
	{0,},
};


static struct pci_driver sta2x11_mfd_driver = {
	.name =		"sta2x11-mfd",
	.id_table =	sta2x11_mfd_tbl,
	.probe =	sta2x11_mfd_probe,
	.suspend =	sta2x11_mfd_suspend,
	.resume =	sta2x11_mfd_resume,
};



static int __init sta2x11_mfd_init(void)
{
	pr_info("%s\n", __func__);
	return pci_register_driver(&sta2x11_mfd_driver);
}

Contributors
Person Tokens Prop Commits CommitProp
alessandro rubini alessandro rubini 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%

/*
 * All of this must be ready before "normal" devices like MMCI appear.
 * But MFD (the pci device) can't be too early. The following choice
 * prepares platform drivers very early and probe the PCI device later,
 * but before other PCI devices.
 */

subsys_initcall(sta2x11_drivers_init);

rootfs_initcall(sta2x11_mfd_init);

MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Wind River");
MODULE_DESCRIPTION("STA2x11 mfd for GPIO, SCTL and APBREG");
MODULE_DEVICE_TABLE(pci, sta2x11_mfd_tbl);
Overall Contributors
Person Tokens Prop Commits CommitProp
alessandro rubini alessandro rubini 1312 49.47% 1 5.26%
davide ciminaghi davide ciminaghi 1248 47.06% 8 42.11%
thierry reding thierry reding 30 1.13% 1 5.26%
bill pemberton bill pemberton 21 0.79% 2 10.53%
jingoo han jingoo han 14 0.53% 2 10.53%
greg kroah-hartman greg kroah-hartman 12 0.45% 1 5.26%
wei yongjun wei yongjun 12 0.45% 2 10.53%
mark brown mark brown 2 0.08% 1 5.26%
julia lawall julia lawall 1 0.04% 1 5.26%
Total 2652 100.00% 19 100.00%
  Directory: drivers/mfd

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
davide ciminaghi	davide ciminaghi	34	100.00%	1	100.00%
	Total	34	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/mfd/sta2x11-mfd.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
