[mirror_ubuntu-bionic-kernel.git] / drivers / char / ipmi / ipmi_si_pci.c

/*
 * ipmi_si_pci.c
 *
 * Handling for IPMI devices on the PCI bus.
 */
#include <linux/module.h>
#include <linux/pci.h>
#include "ipmi_si.h"

#define PFX "ipmi_pci: "

static bool pci_registered;

static bool si_trypci = true;

module_param_named(trypci, si_trypci, bool, 0);
MODULE_PARM_DESC(trypci, "Setting this to zero will disable the"
		 " default scan of the interfaces identified via pci");

#define PCI_ERMC_CLASSCODE		0x0C0700
#define PCI_ERMC_CLASSCODE_MASK		0xffffff00
#define PCI_ERMC_CLASSCODE_TYPE_MASK	0xff
#define PCI_ERMC_CLASSCODE_TYPE_SMIC	0x00
#define PCI_ERMC_CLASSCODE_TYPE_KCS	0x01
#define PCI_ERMC_CLASSCODE_TYPE_BT	0x02

#define PCI_HP_VENDOR_ID    0x103C
#define PCI_MMC_DEVICE_ID   0x121A
#define PCI_MMC_ADDR_CW     0x10

static void ipmi_pci_cleanup(struct si_sm_io *io)
{
	struct pci_dev *pdev = io->addr_source_data;

	pci_disable_device(pdev);
}

static int ipmi_pci_probe_regspacing(struct si_sm_io *io)
{
	if (io->si_type == SI_KCS) {
		unsigned char	status;
		int		regspacing;

		io->regsize = DEFAULT_REGSIZE;
		io->regshift = 0;

		/* detect 1, 4, 16byte spacing */
		for (regspacing = DEFAULT_REGSPACING; regspacing <= 16;) {
			io->regspacing = regspacing;
			if (io->io_setup(io)) {
				dev_err(io->dev,
					"Could not setup I/O space\n");
				return DEFAULT_REGSPACING;
			}
			/* write invalid cmd */
			io->outputb(io, 1, 0x10);
			/* read status back */
			status = io->inputb(io, 1);
			io->io_cleanup(io);
			if (status)
				return regspacing;
			regspacing *= 4;
		}
	}
	return DEFAULT_REGSPACING;
}

static int ipmi_pci_probe(struct pci_dev *pdev,
				    const struct pci_device_id *ent)
{
	int rv;
	int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
	struct si_sm_io io;

	memset(&io, 0, sizeof(io));
	io.addr_source = SI_PCI;
	dev_info(&pdev->dev, "probing via PCI");

	switch (class_type) {
	case PCI_ERMC_CLASSCODE_TYPE_SMIC:
		io.si_type = SI_SMIC;
		break;

	case PCI_ERMC_CLASSCODE_TYPE_KCS:
		io.si_type = SI_KCS;
		break;

	case PCI_ERMC_CLASSCODE_TYPE_BT:
		io.si_type = SI_BT;
		break;

	default:
		dev_info(&pdev->dev, "Unknown IPMI type: %d\n", class_type);
		return -ENOMEM;
	}

	rv = pci_enable_device(pdev);
	if (rv) {
		dev_err(&pdev->dev, "couldn't enable PCI device\n");
		return rv;
	}

	io.addr_source_cleanup = ipmi_pci_cleanup;
	io.addr_source_data = pdev;

	if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
		io.addr_type = IPMI_IO_ADDR_SPACE;
		io.io_setup = ipmi_si_port_setup;
	} else {
		io.addr_type = IPMI_MEM_ADDR_SPACE;
		io.io_setup = ipmi_si_mem_setup;
	}
	io.addr_data = pci_resource_start(pdev, 0);

	io.regspacing = ipmi_pci_probe_regspacing(&io);
	io.regsize = DEFAULT_REGSIZE;
	io.regshift = 0;

	io.irq = pdev->irq;
	if (io.irq)
		io.irq_setup = ipmi_std_irq_setup;

	io.dev = &pdev->dev;

	dev_info(&pdev->dev, "%pR regsize %d spacing %d irq %d\n",
		&pdev->resource[0], io.regsize, io.regspacing, io.irq);

	rv = ipmi_si_add_smi(&io);
	if (rv)
		pci_disable_device(pdev);

	return rv;
}

static void ipmi_pci_remove(struct pci_dev *pdev)
{
	ipmi_si_remove_by_dev(&pdev->dev);
}

static const struct pci_device_id ipmi_pci_devices[] = {
	{ PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
	{ PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) },
	{ 0, }
};
MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);

static struct pci_driver ipmi_pci_driver = {
	.name =         DEVICE_NAME,
	.id_table =     ipmi_pci_devices,
	.probe =        ipmi_pci_probe,
	.remove =       ipmi_pci_remove,
};

void ipmi_si_pci_init(void)
{
	if (si_trypci) {
		int rv = pci_register_driver(&ipmi_pci_driver);
		if (rv)
			pr_err(PFX "Unable to register PCI driver: %d\n", rv);
		else
			pci_registered = true;
	}
}

void ipmi_si_pci_shutdown(void)
{
	if (pci_registered)
		pci_unregister_driver(&ipmi_pci_driver);
}
Commit	Line	Data
13d0b35c CM	1	/*
	2	* ipmi_si_pci.c
	3	*
	4	* Handling for IPMI devices on the PCI bus.
	5	*/
	6	#include <linux/module.h>
	7	#include <linux/pci.h>
	8	#include "ipmi_si.h"
	9
	10	#define PFX "ipmi_pci: "
	11
	12	static bool pci_registered;
	13
	14	static bool si_trypci = true;
	15
	16	module_param_named(trypci, si_trypci, bool, 0);
	17	MODULE_PARM_DESC(trypci, "Setting this to zero will disable the"
	18	" default scan of the interfaces identified via pci");
	19
	20	#define PCI_ERMC_CLASSCODE 0x0C0700
	21	#define PCI_ERMC_CLASSCODE_MASK 0xffffff00
	22	#define PCI_ERMC_CLASSCODE_TYPE_MASK 0xff
	23	#define PCI_ERMC_CLASSCODE_TYPE_SMIC 0x00
	24	#define PCI_ERMC_CLASSCODE_TYPE_KCS 0x01
	25	#define PCI_ERMC_CLASSCODE_TYPE_BT 0x02
	26
	27	#define PCI_HP_VENDOR_ID 0x103C
	28	#define PCI_MMC_DEVICE_ID 0x121A
	29	#define PCI_MMC_ADDR_CW 0x10
	30
	31	static void ipmi_pci_cleanup(struct si_sm_io *io)
	32	{
	33	struct pci_dev *pdev = io->addr_source_data;
	34
	35	pci_disable_device(pdev);
	36	}
	37
	38	static int ipmi_pci_probe_regspacing(struct si_sm_io *io)
	39	{
	40	if (io->si_type == SI_KCS) {
	41	unsigned char status;
	42	int regspacing;
	43
	44	io->regsize = DEFAULT_REGSIZE;
	45	io->regshift = 0;
	46
	47	/* detect 1, 4, 16byte spacing */
	48	for (regspacing = DEFAULT_REGSPACING; regspacing <= 16;) {
	49	io->regspacing = regspacing;
	50	if (io->io_setup(io)) {
	51	dev_err(io->dev,
	52	"Could not setup I/O space\n");
	53	return DEFAULT_REGSPACING;
	54	}
	55	/* write invalid cmd */
	56	io->outputb(io, 1, 0x10);
	57	/* read status back */
	58	status = io->inputb(io, 1);
	59	io->io_cleanup(io);
	60	if (status)
	61	return regspacing;
	62	regspacing *= 4;
	63	}
	64	}
65	return DEFAULT_REGSPACING;
66	}
67
68	static int ipmi_pci_probe(struct pci_dev *pdev,
69	const struct pci_device_id *ent)
70	{
71	int rv;
72	int class_type = pdev->class & PCI_ERMC_CLASSCODE_TYPE_MASK;
73	struct si_sm_io io;
74
75	memset(&io, 0, sizeof(io));
76	io.addr_source = SI_PCI;
77	dev_info(&pdev->dev, "probing via PCI");
78
79	switch (class_type) {
80	case PCI_ERMC_CLASSCODE_TYPE_SMIC:
81	io.si_type = SI_SMIC;
82	break;
83
84	case PCI_ERMC_CLASSCODE_TYPE_KCS:
85	io.si_type = SI_KCS;
86	break;
87
88	case PCI_ERMC_CLASSCODE_TYPE_BT:
89	io.si_type = SI_BT;
90	break;
91
92	default:
93	dev_info(&pdev->dev, "Unknown IPMI type: %d\n", class_type);
94	return -ENOMEM;
95	}
96
97	rv = pci_enable_device(pdev);
98	if (rv) {
99	dev_err(&pdev->dev, "couldn't enable PCI device\n");
100	return rv;
101	}
102
103	io.addr_source_cleanup = ipmi_pci_cleanup;
104	io.addr_source_data = pdev;
105
1ac8aa8d	106	if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
13d0b35c	107	io.addr_type = IPMI_IO_ADDR_SPACE;
1ac8aa8d CM	108	io.io_setup = ipmi_si_port_setup;
1ac8aa8d CM	109	} else {
13d0b35c	110	io.addr_type = IPMI_MEM_ADDR_SPACE;
1ac8aa8d CM	111	io.io_setup = ipmi_si_mem_setup;
1ac8aa8d CM	112	}
13d0b35c CM	113	io.addr_data = pci_resource_start(pdev, 0);
	114
	115	io.regspacing = ipmi_pci_probe_regspacing(&io);
	116	io.regsize = DEFAULT_REGSIZE;
	117	io.regshift = 0;
	118
	119	io.irq = pdev->irq;
	120	if (io.irq)
	121	io.irq_setup = ipmi_std_irq_setup;
	122
	123	io.dev = &pdev->dev;
	124
	125	dev_info(&pdev->dev, "%pR regsize %d spacing %d irq %d\n",
	126	&pdev->resource[0], io.regsize, io.regspacing, io.irq);
	127
	128	rv = ipmi_si_add_smi(&io);
	129	if (rv)
	130	pci_disable_device(pdev);
	131
	132	return rv;
	133	}
	134
	135	static void ipmi_pci_remove(struct pci_dev *pdev)
	136	{
	137	ipmi_si_remove_by_dev(&pdev->dev);
	138	}
	139
	140	static const struct pci_device_id ipmi_pci_devices[] = {
	141	{ PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
	142	{ PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) },
	143	{ 0, }
	144	};
	145	MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
	146
	147	static struct pci_driver ipmi_pci_driver = {
	148	.name = DEVICE_NAME,
	149	.id_table = ipmi_pci_devices,
	150	.probe = ipmi_pci_probe,
	151	.remove = ipmi_pci_remove,
	152	};
	153
	154	void ipmi_si_pci_init(void)
	155	{
	156	if (si_trypci) {
	157	int rv = pci_register_driver(&ipmi_pci_driver);
	158	if (rv)
	159	pr_err(PFX "Unable to register PCI driver: %d\n", rv);
	160	else
	161	pci_registered = true;
	162	}
	163	}
	164
	165	void ipmi_si_pci_shutdown(void)
	166	{
	167	if (pci_registered)
	168	pci_unregister_driver(&ipmi_pci_driver);
	169	}