aerdrv.c 10.2 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2
/*
B
Bjorn Helgaas 已提交
3 4 5
 * Implement the AER root port service driver. The driver registers an IRQ
 * handler. When a root port triggers an AER interrupt, the IRQ handler
 * collects root port status and schedules work.
6 7 8 9 10 11 12
 *
 * Copyright (C) 2006 Intel Corp.
 *	Tom Long Nguyen (tom.l.nguyen@intel.com)
 *	Zhang Yanmin (yanmin.zhang@intel.com)
 */

#include <linux/pci.h>
13
#include <linux/pci-acpi.h>
14
#include <linux/sched.h>
15 16 17 18 19 20 21
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/pm.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/pcieport_if.h>
22
#include <linux/slab.h>
23 24

#include "aerdrv.h"
25
#include "../../pci.h"
26

27
static int aer_probe(struct pcie_device *dev);
28 29 30 31
static void aer_remove(struct pcie_device *dev);
static void aer_error_resume(struct pci_dev *dev);
static pci_ers_result_t aer_root_reset(struct pci_dev *dev);

32
static struct pcie_port_service_driver aerdriver = {
33
	.name		= "aer",
34
	.port_type	= PCI_EXP_TYPE_ROOT_PORT,
35
	.service	= PCIE_PORT_SERVICE_AER,
36 37 38

	.probe		= aer_probe,
	.remove		= aer_remove,
39
	.error_resume	= aer_error_resume,
40 41 42
	.reset_link	= aer_root_reset,
};

R
Randy Dunlap 已提交
43 44 45 46
static int pcie_aer_disable;

void pci_no_aer(void)
{
47
	pcie_aer_disable = 1;
R
Randy Dunlap 已提交
48 49
}

50 51 52 53 54
bool pci_aer_available(void)
{
	return !pcie_aer_disable && pci_msi_enabled();
}

55 56 57
static int set_device_error_reporting(struct pci_dev *dev, void *data)
{
	bool enable = *((bool *)data);
58
	int type = pci_pcie_type(dev);
59

60 61 62
	if ((type == PCI_EXP_TYPE_ROOT_PORT) ||
	    (type == PCI_EXP_TYPE_UPSTREAM) ||
	    (type == PCI_EXP_TYPE_DOWNSTREAM)) {
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
		if (enable)
			pci_enable_pcie_error_reporting(dev);
		else
			pci_disable_pcie_error_reporting(dev);
	}

	if (enable)
		pcie_set_ecrc_checking(dev);

	return 0;
}

/**
 * set_downstream_devices_error_reporting - enable/disable the error reporting  bits on the root port and its downstream ports.
 * @dev: pointer to root port's pci_dev data structure
 * @enable: true = enable error reporting, false = disable error reporting.
 */
static void set_downstream_devices_error_reporting(struct pci_dev *dev,
						   bool enable)
{
	set_device_error_reporting(dev, &enable);

	if (!dev->subordinate)
		return;
	pci_walk_bus(dev->subordinate, set_device_error_reporting, &enable);
}

/**
 * aer_enable_rootport - enable Root Port's interrupts when receiving messages
 * @rpc: pointer to a Root Port data structure
 *
 * Invoked when PCIe bus loads AER service driver.
 */
static void aer_enable_rootport(struct aer_rpc *rpc)
{
	struct pci_dev *pdev = rpc->rpd->port;
99
	int aer_pos;
100 101 102 103
	u16 reg16;
	u32 reg32;

	/* Clear PCIe Capability's Device Status */
104 105
	pcie_capability_read_word(pdev, PCI_EXP_DEVSTA, &reg16);
	pcie_capability_write_word(pdev, PCI_EXP_DEVSTA, reg16);
106 107

	/* Disable system error generation in response to error messages */
108 109
	pcie_capability_clear_word(pdev, PCI_EXP_RTCTL,
				   SYSTEM_ERROR_INTR_ON_MESG_MASK);
110

111
	aer_pos = pdev->aer_cap;
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
	/* Clear error status */
	pci_read_config_dword(pdev, aer_pos + PCI_ERR_ROOT_STATUS, &reg32);
	pci_write_config_dword(pdev, aer_pos + PCI_ERR_ROOT_STATUS, reg32);
	pci_read_config_dword(pdev, aer_pos + PCI_ERR_COR_STATUS, &reg32);
	pci_write_config_dword(pdev, aer_pos + PCI_ERR_COR_STATUS, reg32);
	pci_read_config_dword(pdev, aer_pos + PCI_ERR_UNCOR_STATUS, &reg32);
	pci_write_config_dword(pdev, aer_pos + PCI_ERR_UNCOR_STATUS, reg32);

	/*
	 * Enable error reporting for the root port device and downstream port
	 * devices.
	 */
	set_downstream_devices_error_reporting(pdev, true);

	/* Enable Root Port's interrupt in response to error messages */
	pci_read_config_dword(pdev, aer_pos + PCI_ERR_ROOT_COMMAND, &reg32);
	reg32 |= ROOT_PORT_INTR_ON_MESG_MASK;
	pci_write_config_dword(pdev, aer_pos + PCI_ERR_ROOT_COMMAND, reg32);
}

/**
 * aer_disable_rootport - disable Root Port's interrupts when receiving messages
 * @rpc: pointer to a Root Port data structure
 *
 * Invoked when PCIe bus unloads AER service driver.
 */
static void aer_disable_rootport(struct aer_rpc *rpc)
{
	struct pci_dev *pdev = rpc->rpd->port;
	u32 reg32;
	int pos;

	/*
	 * Disable error reporting for the root port device and downstream port
	 * devices.
	 */
	set_downstream_devices_error_reporting(pdev, false);

150
	pos = pdev->aer_cap;
151 152 153 154 155 156 157 158 159 160
	/* Disable Root's interrupt in response to error messages */
	pci_read_config_dword(pdev, pos + PCI_ERR_ROOT_COMMAND, &reg32);
	reg32 &= ~ROOT_PORT_INTR_ON_MESG_MASK;
	pci_write_config_dword(pdev, pos + PCI_ERR_ROOT_COMMAND, reg32);

	/* Clear Root's error status reg */
	pci_read_config_dword(pdev, pos + PCI_ERR_ROOT_STATUS, &reg32);
	pci_write_config_dword(pdev, pos + PCI_ERR_ROOT_STATUS, reg32);
}

161 162 163 164 165 166
/**
 * aer_irq - Root Port's ISR
 * @irq: IRQ assigned to Root Port
 * @context: pointer to Root Port data structure
 *
 * Invoked when Root Port detects AER messages.
167
 */
168
irqreturn_t aer_irq(int irq, void *context)
169 170 171 172 173 174 175 176
{
	unsigned int status, id;
	struct pcie_device *pdev = (struct pcie_device *)context;
	struct aer_rpc *rpc = get_service_data(pdev);
	int next_prod_idx;
	unsigned long flags;
	int pos;

177
	pos = pdev->port->aer_cap;
178 179 180 181 182 183 184 185
	/*
	 * Must lock access to Root Error Status Reg, Root Error ID Reg,
	 * and Root error producer/consumer index
	 */
	spin_lock_irqsave(&rpc->e_lock, flags);

	/* Read error status */
	pci_read_config_dword(pdev->port, pos + PCI_ERR_ROOT_STATUS, &status);
186
	if (!(status & (PCI_ERR_ROOT_UNCOR_RCV|PCI_ERR_ROOT_COR_RCV))) {
187 188 189 190 191
		spin_unlock_irqrestore(&rpc->e_lock, flags);
		return IRQ_NONE;
	}

	/* Read error source and clear error status */
192
	pci_read_config_dword(pdev->port, pos + PCI_ERR_ROOT_ERR_SRC, &id);
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
	pci_write_config_dword(pdev->port, pos + PCI_ERR_ROOT_STATUS, status);

	/* Store error source for later DPC handler */
	next_prod_idx = rpc->prod_idx + 1;
	if (next_prod_idx == AER_ERROR_SOURCES_MAX)
		next_prod_idx = 0;
	if (next_prod_idx == rpc->cons_idx) {
		/*
		 * Error Storm Condition - possibly the same error occurred.
		 * Drop the error.
		 */
		spin_unlock_irqrestore(&rpc->e_lock, flags);
		return IRQ_HANDLED;
	}
	rpc->e_sources[rpc->prod_idx].status =  status;
	rpc->e_sources[rpc->prod_idx].id = id;
	rpc->prod_idx = next_prod_idx;
	spin_unlock_irqrestore(&rpc->e_lock, flags);

	/*  Invoke DPC handler */
	schedule_work(&rpc->dpc_handler);

	return IRQ_HANDLED;
}
217
EXPORT_SYMBOL_GPL(aer_irq);
218 219 220 221 222 223

/**
 * aer_alloc_rpc - allocate Root Port data structure
 * @dev: pointer to the pcie_dev data structure
 *
 * Invoked when Root Port's AER service is loaded.
224
 */
225
static struct aer_rpc *aer_alloc_rpc(struct pcie_device *dev)
226 227 228
{
	struct aer_rpc *rpc;

229 230
	rpc = kzalloc(sizeof(struct aer_rpc), GFP_KERNEL);
	if (!rpc)
231 232
		return NULL;

233
	/* Initialize Root lock access, e_lock, to Root Error Status Reg */
234
	spin_lock_init(&rpc->e_lock);
235 236

	rpc->rpd = dev;
237
	INIT_WORK(&rpc->dpc_handler, aer_isr);
238 239
	mutex_init(&rpc->rpc_mutex);

240
	/* Use PCIe bus function to store rpc into PCIe device */
241 242 243 244 245 246 247 248 249 250
	set_service_data(dev, rpc);

	return rpc;
}

/**
 * aer_remove - clean up resources
 * @dev: pointer to the pcie_dev data structure
 *
 * Invoked when PCI Express bus unloads or AER probe fails.
251
 */
252 253 254 255 256 257 258 259 260
static void aer_remove(struct pcie_device *dev)
{
	struct aer_rpc *rpc = get_service_data(dev);

	if (rpc) {
		/* If register interrupt service, it must be free. */
		if (rpc->isr)
			free_irq(dev->irq, dev);

261
		flush_work(&rpc->dpc_handler);
262 263
		aer_disable_rootport(rpc);
		kfree(rpc);
264 265 266 267 268 269 270 271 272
		set_service_data(dev, NULL);
	}
}

/**
 * aer_probe - initialize resources
 * @dev: pointer to the pcie_dev data structure
 *
 * Invoked when PCI Express bus loads AER service driver.
273
 */
274
static int aer_probe(struct pcie_device *dev)
275 276 277
{
	int status;
	struct aer_rpc *rpc;
278
	struct device *device = &dev->port->dev;
279 280

	/* Alloc rpc data structure */
281 282
	rpc = aer_alloc_rpc(dev);
	if (!rpc) {
283
		dev_printk(KERN_DEBUG, device, "alloc AER rpc failed\n");
284 285 286 287 288
		aer_remove(dev);
		return -ENOMEM;
	}

	/* Request IRQ ISR */
289 290
	status = request_irq(dev->irq, aer_irq, IRQF_SHARED, "aerdrv", dev);
	if (status) {
291 292
		dev_printk(KERN_DEBUG, device, "request AER IRQ %d failed\n",
			   dev->irq);
293 294 295 296 297 298 299
		aer_remove(dev);
		return status;
	}

	rpc->isr = 1;

	aer_enable_rootport(rpc);
300 301
	dev_info(device, "AER enabled with IRQ %d\n", dev->irq);
	return 0;
302 303 304 305 306 307 308
}

/**
 * aer_root_reset - reset link on Root Port
 * @dev: pointer to Root Port's pci_dev data structure
 *
 * Invoked by Port Bus driver when performing link reset at Root Port.
309
 */
310 311
static pci_ers_result_t aer_root_reset(struct pci_dev *dev)
{
312
	u32 reg32;
313 314
	int pos;

315
	pos = dev->aer_cap;
316 317

	/* Disable Root's interrupt in response to error messages */
318 319 320
	pci_read_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND, &reg32);
	reg32 &= ~ROOT_PORT_INTR_ON_MESG_MASK;
	pci_write_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND, reg32);
321

322
	pci_reset_bridge_secondary_bus(dev);
323
	pci_printk(KERN_DEBUG, dev, "Root Port link has been reset\n");
324

325 326 327 328
	/* Clear Root Error Status */
	pci_read_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, &reg32);
	pci_write_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, reg32);

329
	/* Enable Root Port's interrupt in response to error messages */
330 331 332
	pci_read_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND, &reg32);
	reg32 |= ROOT_PORT_INTR_ON_MESG_MASK;
	pci_write_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND, reg32);
333 334 335 336 337 338 339 340 341

	return PCI_ERS_RESULT_RECOVERED;
}

/**
 * aer_error_resume - clean up corresponding error status bits
 * @dev: pointer to Root Port's pci_dev data structure
 *
 * Invoked by Port Bus driver during nonfatal recovery.
342
 */
343 344 345 346 347 348 349
static void aer_error_resume(struct pci_dev *dev)
{
	int pos;
	u32 status, mask;
	u16 reg16;

	/* Clean up Root device status */
350 351
	pcie_capability_read_word(dev, PCI_EXP_DEVSTA, &reg16);
	pcie_capability_write_word(dev, PCI_EXP_DEVSTA, reg16);
352 353

	/* Clean AER Root Error Status */
354
	pos = dev->aer_cap;
355 356 357 358 359 360 361 362 363 364 365 366 367
	pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS, &status);
	pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_SEVER, &mask);
	if (dev->error_state == pci_channel_io_normal)
		status &= ~mask; /* Clear corresponding nonfatal bits */
	else
		status &= mask; /* Clear corresponding fatal bits */
	pci_write_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS, status);
}

/**
 * aer_service_init - register AER root service driver
 *
 * Invoked when AER root service driver is loaded.
368
 */
369 370
static int __init aer_service_init(void)
{
371
	if (!pci_aer_available() || aer_acpi_firmware_first())
372
		return -ENXIO;
373
	return pcie_port_service_register(&aerdriver);
374
}
375
device_initcall(aer_service_init);
新手
引导
客服 返回
顶部