amdgpu_ras.c 63.5 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
 * Copyright 2018 Advanced Micro Devices, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 *
 */
#include <linux/debugfs.h>
#include <linux/list.h>
#include <linux/module.h>
27
#include <linux/uaccess.h>
28
29
#include <linux/reboot.h>
#include <linux/syscalls.h>
30
#include <linux/pm_runtime.h>
31

32
33
#include "amdgpu.h"
#include "amdgpu_ras.h"
34
#include "amdgpu_atomfirmware.h"
35
#include "amdgpu_xgmi.h"
36
#include "ivsrcid/nbio/irqsrcs_nbif_7_4.h"
37
#include "atom.h"
38

39
40
static const char *RAS_FS_NAME = "ras";

41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
const char *ras_error_string[] = {
	"none",
	"parity",
	"single_correctable",
	"multi_uncorrectable",
	"poison",
};

const char *ras_block_string[] = {
	"umc",
	"sdma",
	"gfx",
	"mmhub",
	"athub",
	"pcie_bif",
	"hdp",
	"xgmi_wafl",
	"df",
	"smn",
	"sem",
	"mp0",
	"mp1",
	"fuse",
};

#define ras_err_str(i) (ras_error_string[ffs(i)])
#define ras_block_str(i) (ras_block_string[i])

69
70
#define RAS_DEFAULT_FLAGS (AMDGPU_RAS_FLAG_INIT_BY_VBIOS)

71
72
73
/* inject address is 52 bits */
#define	RAS_UMC_INJECT_ADDR_LIMIT	(0x1ULL << 52)

74
75
76
/* typical ECC bad page rate(1 bad page per 100MB VRAM) */
#define RAS_BAD_PAGE_RATE		(100 * 1024 * 1024ULL)

77
78
79
80
81
enum amdgpu_ras_retire_page_reservation {
	AMDGPU_RAS_RETIRE_PAGE_RESERVED,
	AMDGPU_RAS_RETIRE_PAGE_PENDING,
	AMDGPU_RAS_RETIRE_PAGE_FAULT,
};
82
83
84

atomic_t amdgpu_ras_in_intr = ATOMIC_INIT(0);

85
86
static bool amdgpu_ras_check_bad_page_unlock(struct amdgpu_ras *con,
				uint64_t addr);
87
88
89
static bool amdgpu_ras_check_bad_page(struct amdgpu_device *adev,
				uint64_t addr);

90
91
void amdgpu_ras_set_error_query_ready(struct amdgpu_device *adev, bool ready)
{
92
	if (adev && amdgpu_ras_get_context(adev))
93
94
95
		amdgpu_ras_get_context(adev)->error_query_ready = ready;
}

96
static bool amdgpu_ras_get_error_query_ready(struct amdgpu_device *adev)
97
{
98
	if (adev && amdgpu_ras_get_context(adev))
99
100
101
102
103
		return amdgpu_ras_get_context(adev)->error_query_ready;

	return false;
}

104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
static int amdgpu_reserve_page_direct(struct amdgpu_device *adev, uint64_t address)
{
	struct ras_err_data err_data = {0, 0, 0, NULL};
	struct eeprom_table_record err_rec;

	if ((address >= adev->gmc.mc_vram_size) ||
	    (address >= RAS_UMC_INJECT_ADDR_LIMIT)) {
		dev_warn(adev->dev,
		         "RAS WARN: input address 0x%llx is invalid.\n",
		         address);
		return -EINVAL;
	}

	if (amdgpu_ras_check_bad_page(adev, address)) {
		dev_warn(adev->dev,
119
			 "RAS WARN: 0x%llx has already been marked as bad page!\n",
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
			 address);
		return 0;
	}

	memset(&err_rec, 0x0, sizeof(struct eeprom_table_record));

	err_rec.address = address;
	err_rec.retired_page = address >> AMDGPU_GPU_PAGE_SHIFT;
	err_rec.ts = (uint64_t)ktime_get_real_seconds();
	err_rec.err_type = AMDGPU_RAS_EEPROM_ERR_NON_RECOVERABLE;

	err_data.err_addr = &err_rec;
	err_data.err_addr_cnt = 1;

	if (amdgpu_bad_page_threshold != 0) {
		amdgpu_ras_add_bad_pages(adev, err_data.err_addr,
					 err_data.err_addr_cnt);
		amdgpu_ras_save_bad_pages(adev);
	}

	dev_warn(adev->dev, "WARNING: THIS IS ONLY FOR TEST PURPOSES AND WILL CORRUPT RAS EEPROM\n");
	dev_warn(adev->dev, "Clear EEPROM:\n");
	dev_warn(adev->dev, "    echo 1 > /sys/kernel/debug/dri/0/ras/ras_eeprom_reset\n");

	return 0;
}

147
148
149
150
151
152
153
154
155
156
static ssize_t amdgpu_ras_debugfs_read(struct file *f, char __user *buf,
					size_t size, loff_t *pos)
{
	struct ras_manager *obj = (struct ras_manager *)file_inode(f)->i_private;
	struct ras_query_if info = {
		.head = obj->head,
	};
	ssize_t s;
	char val[128];

157
	if (amdgpu_ras_query_error_status(obj->adev, &info))
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
		return -EINVAL;

	s = snprintf(val, sizeof(val), "%s: %lu\n%s: %lu\n",
			"ue", info.ue_count,
			"ce", info.ce_count);
	if (*pos >= s)
		return 0;

	s -= *pos;
	s = min_t(u64, s, size);


	if (copy_to_user(buf, &val[*pos], s))
		return -EINVAL;

	*pos += s;

	return s;
}

static const struct file_operations amdgpu_ras_debugfs_ops = {
	.owner = THIS_MODULE,
	.read = amdgpu_ras_debugfs_read,
181
	.write = NULL,
182
183
184
	.llseek = default_llseek
};

185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
static int amdgpu_ras_find_block_id_by_name(const char *name, int *block_id)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(ras_block_string); i++) {
		*block_id = i;
		if (strcmp(name, ras_block_str(i)) == 0)
			return 0;
	}
	return -EINVAL;
}

static int amdgpu_ras_debugfs_ctrl_parse_data(struct file *f,
		const char __user *buf, size_t size,
		loff_t *pos, struct ras_debug_if *data)
{
	ssize_t s = min_t(u64, 64, size);
	char str[65];
	char block_name[33];
	char err[9] = "ue";
	int op = -1;
	int block_id;
207
	uint32_t sub_block;
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
	u64 address, value;

	if (*pos)
		return -EINVAL;
	*pos = size;

	memset(str, 0, sizeof(str));
	memset(data, 0, sizeof(*data));

	if (copy_from_user(str, buf, s))
		return -EINVAL;

	if (sscanf(str, "disable %32s", block_name) == 1)
		op = 0;
	else if (sscanf(str, "enable %32s %8s", block_name, err) == 2)
		op = 1;
	else if (sscanf(str, "inject %32s %8s", block_name, err) == 2)
		op = 2;
226
	else if (strstr(str, "retire_page") != NULL)
227
		op = 3;
228
	else if (str[0] && str[1] && str[2] && str[3])
229
230
231
232
		/* ascii string, but commands are not matched. */
		return -EINVAL;

	if (op != -1) {
233
		if (op == 3) {
234
235
			if (sscanf(str, "%*s 0x%llx", &address) != 1 &&
			    sscanf(str, "%*s %llu", &address) != 1)
236
				return -EINVAL;
237
238
239
240
241
242
243

			data->op = op;
			data->inject.address = address;

			return 0;
		}

244
245
246
247
		if (amdgpu_ras_find_block_id_by_name(block_name, &block_id))
			return -EINVAL;

		data->head.block = block_id;
248
249
250
251
252
253
254
255
		/* only ue and ce errors are supported */
		if (!memcmp("ue", err, 2))
			data->head.type = AMDGPU_RAS_ERROR__MULTI_UNCORRECTABLE;
		else if (!memcmp("ce", err, 2))
			data->head.type = AMDGPU_RAS_ERROR__SINGLE_CORRECTABLE;
		else
			return -EINVAL;

256
257
258
		data->op = op;

		if (op == 2) {
259
260
261
			if (sscanf(str, "%*s %*s %*s 0x%x 0x%llx 0x%llx",
				   &sub_block, &address, &value) != 3 &&
			    sscanf(str, "%*s %*s %*s %u %llu %llu",
262
263
				   &sub_block, &address, &value) != 3)
				return -EINVAL;
264
			data->head.sub_block_index = sub_block;
265
266
267
268
			data->inject.address = address;
			data->inject.value = value;
		}
	} else {
xinhui pan's avatar
xinhui pan committed
269
		if (size < sizeof(*data))
270
271
272
273
274
275
276
277
			return -EINVAL;

		if (copy_from_user(data, buf, sizeof(*data)))
			return -EINVAL;
	}

	return 0;
}
278

279
280
/**
 * DOC: AMDGPU RAS debugfs control interface
xinhui pan's avatar
xinhui pan committed
281
 *
282
 * The control interface accepts struct ras_debug_if which has two members.
xinhui pan's avatar
xinhui pan committed
283
284
 *
 * First member: ras_debug_if::head or ras_debug_if::inject.
285
286
 *
 * head is used to indicate which IP block will be under control.
xinhui pan's avatar
xinhui pan committed
287
288
289
290
291
292
293
294
295
296
297
 *
 * head has four members, they are block, type, sub_block_index, name.
 * block: which IP will be under control.
 * type: what kind of error will be enabled/disabled/injected.
 * sub_block_index: some IPs have subcomponets. say, GFX, sDMA.
 * name: the name of IP.
 *
 * inject has two more members than head, they are address, value.
 * As their names indicate, inject operation will write the
 * value to the address.
 *
298
 * The second member: struct ras_debug_if::op.
299
 * It has three kinds of operations.
300
301
302
303
 *
 * - 0: disable RAS on the block. Take ::head as its data.
 * - 1: enable RAS on the block. Take ::head as its data.
 * - 2: inject errors on the block. Take ::inject as its data.
xinhui pan's avatar
xinhui pan committed
304
 *
305
 * How to use the interface?
306
 *
307
 * In a program
308
 *
309
310
 * Copy the struct ras_debug_if in your code and initialize it.
 * Write the struct to the control interface.
311
 *
312
 * From shell
313
 *
314
315
 * .. code-block:: bash
 *
316
317
318
 *	echo "disable <block>" > /sys/kernel/debug/dri/<N>/ras/ras_ctrl
 *	echo "enable  <block> <error>" > /sys/kernel/debug/dri/<N>/ras/ras_ctrl
 *	echo "inject  <block> <error> <sub-block> <address> <value> > /sys/kernel/debug/dri/<N>/ras/ras_ctrl
319
 *
320
 * Where N, is the card which you want to affect.
321
 *
322
323
324
 * "disable" requires only the block.
 * "enable" requires the block and error type.
 * "inject" requires the block, error type, address, and value.
325
 *
326
 * The block is one of: umc, sdma, gfx, etc.
327
 *	see ras_block_string[] for details
328
 *
329
330
331
 * The error type is one of: ue, ce, where,
 *	ue is multi-uncorrectable
 *	ce is single-correctable
332
 *
333
334
 * The sub-block is a the sub-block index, pass 0 if there is no sub-block.
 * The address and value are hexadecimal numbers, leading 0x is optional.
335
 *
336
 * For instance,
337
338
 *
 * .. code-block:: bash
339
 *
340
341
 *	echo inject umc ue 0x0 0x0 0x0 > /sys/kernel/debug/dri/0/ras/ras_ctrl
 *	echo inject umc ce 0 0 0 > /sys/kernel/debug/dri/0/ras/ras_ctrl
342
343
 *	echo disable umc > /sys/kernel/debug/dri/0/ras/ras_ctrl
 *
344
 * How to check the result of the operation?
xinhui pan's avatar
xinhui pan committed
345
 *
346
 * To check disable/enable, see "ras" features at,
xinhui pan's avatar
xinhui pan committed
347
348
 * /sys/class/drm/card[0/1/2...]/device/ras/features
 *
349
350
 * To check inject, see the corresponding error count at,
 * /sys/class/drm/card[0/1/2...]/device/ras/[gfx|sdma|umc|...]_err_count
xinhui pan's avatar
xinhui pan committed
351
 *
352
 * .. note::
353
 *	Operations are only allowed on blocks which are supported.
354
 *	Check the "ras" mask at /sys/module/amdgpu/parameters/ras_mask
355
356
 *	to see which blocks support RAS on a particular asic.
 *
xinhui pan's avatar
xinhui pan committed
357
358
359
360
361
362
363
364
 */
static ssize_t amdgpu_ras_debugfs_ctrl_write(struct file *f, const char __user *buf,
		size_t size, loff_t *pos)
{
	struct amdgpu_device *adev = (struct amdgpu_device *)file_inode(f)->i_private;
	struct ras_debug_if data;
	int ret = 0;

365
	if (!amdgpu_ras_get_error_query_ready(adev)) {
366
367
		dev_warn(adev->dev, "RAS WARN: error injection "
				"currently inaccessible\n");
368
369
370
		return size;
	}

371
372
	ret = amdgpu_ras_debugfs_ctrl_parse_data(f, buf, size, pos, &data);
	if (ret)
xinhui pan's avatar
xinhui pan committed
373
374
		return -EINVAL;

375
	if (data.op == 3) {
376
		ret = amdgpu_reserve_page_direct(adev, data.inject.address);
377
		if (!ret)
378
379
380
381
382
			return size;
		else
			return ret;
	}

xinhui pan's avatar
xinhui pan committed
383
384
385
386
387
388
389
390
391
392
393
	if (!amdgpu_ras_is_supported(adev, data.head.block))
		return -EINVAL;

	switch (data.op) {
	case 0:
		ret = amdgpu_ras_feature_enable(adev, &data.head, 0);
		break;
	case 1:
		ret = amdgpu_ras_feature_enable(adev, &data.head, 1);
		break;
	case 2:
394
395
		if ((data.inject.address >= adev->gmc.mc_vram_size) ||
		    (data.inject.address >= RAS_UMC_INJECT_ADDR_LIMIT)) {
396
397
398
			dev_warn(adev->dev, "RAS WARN: input address "
					"0x%llx is invalid.",
					data.inject.address);
399
400
401
402
			ret = -EINVAL;
			break;
		}

403
404
405
		/* umc ce/ue error injection for a bad page is not allowed */
		if ((data.head.block == AMDGPU_RAS_BLOCK__UMC) &&
		    amdgpu_ras_check_bad_page(adev, data.inject.address)) {
406
407
			dev_warn(adev->dev, "RAS WARN: 0x%llx has been marked "
					"as bad before error injection!\n",
408
409
410
411
					data.inject.address);
			break;
		}

412
		/* data.inject.address is offset instead of absolute gpu address */
xinhui pan's avatar
xinhui pan committed
413
414
		ret = amdgpu_ras_error_inject(adev, &data.inject);
		break;
415
416
417
	default:
		ret = -EINVAL;
		break;
418
	}
xinhui pan's avatar
xinhui pan committed
419
420
421
422
423
424
425

	if (ret)
		return -EINVAL;

	return size;
}

426
427
428
/**
 * DOC: AMDGPU RAS debugfs EEPROM table reset interface
 *
429
 * Some boards contain an EEPROM which is used to persistently store a list of
430
 * bad pages which experiences ECC errors in vram.  This interface provides
431
432
433
434
435
436
437
438
439
440
 * a way to reset the EEPROM, e.g., after testing error injection.
 *
 * Usage:
 *
 * .. code-block:: bash
 *
 *	echo 1 > ../ras/ras_eeprom_reset
 *
 * will reset EEPROM table to 0 entries.
 *
441
442
443
444
 */
static ssize_t amdgpu_ras_debugfs_eeprom_write(struct file *f, const char __user *buf,
		size_t size, loff_t *pos)
{
445
446
	struct amdgpu_device *adev =
		(struct amdgpu_device *)file_inode(f)->i_private;
447
448
	int ret;

449
450
	ret = amdgpu_ras_eeprom_reset_table(
			&(amdgpu_ras_get_context(adev)->eeprom_control));
451

452
453
454
455
456
457
	if (ret == 1) {
		amdgpu_ras_get_context(adev)->flags = RAS_DEFAULT_FLAGS;
		return size;
	} else {
		return -EIO;
	}
458
459
}

xinhui pan's avatar
xinhui pan committed
460
461
462
463
464
465
466
static const struct file_operations amdgpu_ras_debugfs_ctrl_ops = {
	.owner = THIS_MODULE,
	.read = NULL,
	.write = amdgpu_ras_debugfs_ctrl_write,
	.llseek = default_llseek
};

467
468
469
470
471
472
473
static const struct file_operations amdgpu_ras_debugfs_eeprom_ops = {
	.owner = THIS_MODULE,
	.read = NULL,
	.write = amdgpu_ras_debugfs_eeprom_write,
	.llseek = default_llseek
};

474
475
476
/**
 * DOC: AMDGPU RAS sysfs Error Count Interface
 *
477
 * It allows the user to read the error count for each IP block on the gpu through
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
 * /sys/class/drm/card[0/1/2...]/device/ras/[gfx/sdma/...]_err_count
 *
 * It outputs the multiple lines which report the uncorrected (ue) and corrected
 * (ce) error counts.
 *
 * The format of one line is below,
 *
 * [ce|ue]: count
 *
 * Example:
 *
 * .. code-block:: bash
 *
 *	ue: 0
 *	ce: 1
 *
 */
495
496
497
498
499
500
501
502
static ssize_t amdgpu_ras_sysfs_read(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct ras_manager *obj = container_of(attr, struct ras_manager, sysfs_attr);
	struct ras_query_if info = {
		.head = obj->head,
	};

503
	if (!amdgpu_ras_get_error_query_ready(obj->adev))
504
		return sysfs_emit(buf, "Query currently inaccessible\n");
505

506
	if (amdgpu_ras_query_error_status(obj->adev, &info))
507
508
		return -EINVAL;

509
510
511
512
513
514

	if (obj->adev->asic_type == CHIP_ALDEBARAN) {
		if (amdgpu_ras_reset_error_status(obj->adev, info.head.block))
			DRM_WARN("Failed to reset error counter and error status");
	}

515
516
	return sysfs_emit(buf, "%s: %lu\n%s: %lu\n", "ue", info.ue_count,
			  "ce", info.ce_count);
517
518
519
520
521
522
523
524
525
}

/* obj begin */

#define get_obj(obj) do { (obj)->use++; } while (0)
#define alive_obj(obj) ((obj)->use)

static inline void put_obj(struct ras_manager *obj)
{
526
	if (obj && (--obj->use == 0))
527
		list_del(&obj->node);
528
529
	if (obj && (obj->use < 0))
		DRM_ERROR("RAS ERROR: Unbalance obj(%s) use\n", obj->head.name);
530
531
532
533
534
535
536
537
538
}

/* make one obj and return it. */
static struct ras_manager *amdgpu_ras_create_obj(struct amdgpu_device *adev,
		struct ras_common_if *head)
{
	struct amdgpu_ras *con = amdgpu_ras_get_context(adev);
	struct ras_manager *obj;

539
	if (!adev->ras_enabled || !con)
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
		return NULL;

	if (head->block >= AMDGPU_RAS_BLOCK_COUNT)
		return NULL;

	obj = &con->objs[head->block];
	/* already exist. return obj? */
	if (alive_obj(obj))
		return NULL;

	obj->head = *head;
	obj->adev = adev;
	list_add(&obj->node, &con->head);
	get_obj(obj);

	return obj;
}

/* return an obj equal to head, or the first when head is NULL */
559
struct ras_manager *amdgpu_ras_find_obj(struct amdgpu_device *adev,
560
561
562
563
564
565
		struct ras_common_if *head)
{
	struct amdgpu_ras *con = amdgpu_ras_get_context(adev);
	struct ras_manager *obj;
	int i;

566
	if (!adev->ras_enabled || !con)
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
		return NULL;

	if (head) {
		if (head->block >= AMDGPU_RAS_BLOCK_COUNT)
			return NULL;

		obj = &con->objs[head->block];

		if (alive_obj(obj)) {
			WARN_ON(head->block != obj->head.block);
			return obj;
		}
	} else {
		for (i = 0; i < AMDGPU_RAS_BLOCK_COUNT; i++) {
			obj = &con->objs[i];
			if (alive_obj(obj)) {
				WARN_ON(i != obj->head.block);
				return obj;
			}
		}
	}

	return NULL;
}
/* obj end */

/* feature ctl begin */
static int amdgpu_ras_is_feature_allowed(struct amdgpu_device *adev,
595
					 struct ras_common_if *head)
596
{
597
	return adev->ras_hw_enabled & BIT(head->block);
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
}

static int amdgpu_ras_is_feature_enabled(struct amdgpu_device *adev,
		struct ras_common_if *head)
{
	struct amdgpu_ras *con = amdgpu_ras_get_context(adev);

	return con->features & BIT(head->block);
}

/*
 * if obj is not created, then create one.
 * set feature enable flag.
 */
static int __amdgpu_ras_feature_enable(struct amdgpu_device *adev,
		struct ras_common_if *head, int enable)
{
	struct amdgpu_ras *con = amdgpu_ras_get_context(adev);
	struct ras_manager *obj = amdgpu_ras_find_obj(adev, head);

618
619
620
621
622
623
	/* If hardware does not support ras, then do not create obj.
	 * But if hardware support ras, we can create the obj.
	 * Ras framework checks con->hw_supported to see if it need do
	 * corresponding initialization.
	 * IP checks con->support to see if it need disable ras.
	 */
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
	if (!amdgpu_ras_is_feature_allowed(adev, head))
		return 0;
	if (!(!!enable ^ !!amdgpu_ras_is_feature_enabled(adev, head)))
		return 0;

	if (enable) {
		if (!obj) {
			obj = amdgpu_ras_create_obj(adev, head);
			if (!obj)
				return -EINVAL;
		} else {
			/* In case we create obj somewhere else */
			get_obj(obj);
		}
		con->features |= BIT(head->block);
	} else {
		if (obj && amdgpu_ras_is_feature_enabled(adev, head)) {
641
			con->features &= ~BIT(head->block);
642
643
644
645
646
647
648
649
650
651
652
653
			put_obj(obj);
		}
	}

	return 0;
}

/* wrapper of psp_ras_enable_features */
int amdgpu_ras_feature_enable(struct amdgpu_device *adev,
		struct ras_common_if *head, bool enable)
{
	struct amdgpu_ras *con = amdgpu_ras_get_context(adev);
654
	union ta_ras_cmd_input *info;
655
656
657
658
659
	int ret;

	if (!con)
		return -EINVAL;

660
	info = kzalloc(sizeof(union ta_ras_cmd_input), GFP_KERNEL);
661
662
663
	if (!info)
		return -ENOMEM;

664
	if (!enable) {
665
		info->disable_features = (struct ta_ras_disable_features_input) {
666
667
			.block_id =  amdgpu_ras_block_to_ta(head->block),
			.error_type = amdgpu_ras_error_to_ta(head->type),
668
669
		};
	} else {
670
		info->enable_features = (struct ta_ras_enable_features_input) {
671
672
			.block_id =  amdgpu_ras_block_to_ta(head->block),
			.error_type = amdgpu_ras_error_to_ta(head->type),
673
674
675
676
677
678
		};
	}

	/* Do not enable if it is not allowed. */
	WARN_ON(enable && !amdgpu_ras_is_feature_allowed(adev, head));
	/* Are we alerady in that state we are going to set? */
679
680
681
682
	if (!(!!enable ^ !!amdgpu_ras_is_feature_enabled(adev, head))) {
		ret = 0;
		goto out;
	}
683

684
	if (!amdgpu_ras_intr_triggered()) {
685
		ret = psp_ras_enable_features(&adev->psp, info, enable);
686
		if (ret) {
687
688
689
690
			dev_err(adev->dev, "ras %s %s failed %d\n",
				enable ? "enable":"disable",
				ras_block_str(head->block),
				ret);
691
			goto out;
692
		}
693
694
695
696
	}

	/* setup the obj */
	__amdgpu_ras_feature_enable(adev, head, enable);
697
698
699
700
	ret = 0;
out:
	kfree(info);
	return ret;
701
702
}

703
704
705
706
707
708
709
710
711
712
713
/* Only used in device probe stage and called only once. */
int amdgpu_ras_feature_enable_on_boot(struct amdgpu_device *adev,
		struct ras_common_if *head, bool enable)
{
	struct amdgpu_ras *con = amdgpu_ras_get_context(adev);
	int ret;

	if (!con)
		return -EINVAL;

	if (con->flags & AMDGPU_RAS_FLAG_INIT_BY_VBIOS) {
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
		if (enable) {
			/* There is no harm to issue a ras TA cmd regardless of
			 * the currecnt ras state.
			 * If current state == target state, it will do nothing
			 * But sometimes it requests driver to reset and repost
			 * with error code -EAGAIN.
			 */
			ret = amdgpu_ras_feature_enable(adev, head, 1);
			/* With old ras TA, we might fail to enable ras.
			 * Log it and just setup the object.
			 * TODO need remove this WA in the future.
			 */
			if (ret == -EINVAL) {
				ret = __amdgpu_ras_feature_enable(adev, head, 1);
				if (!ret)
729
730
					dev_info(adev->dev,
						"RAS INFO: %s setup object\n",
731
732
733
734
735
736
737
						ras_block_str(head->block));
			}
		} else {
			/* setup the object then issue a ras TA disable cmd.*/
			ret = __amdgpu_ras_feature_enable(adev, head, 1);
			if (ret)
				return ret;
738

739
740
741
742
			/* gfx block ras dsiable cmd must send to ras-ta */
			if (head->block == AMDGPU_RAS_BLOCK__GFX)
				con->features |= BIT(head->block);

743
			ret = amdgpu_ras_feature_enable(adev, head, 0);
744
745

			/* clean gfx block ras features flag */
746
			if (adev->ras_enabled && head->block == AMDGPU_RAS_BLOCK__GFX)
747
				con->features &= ~BIT(head->block);
748
		}
749
750
751
752
753
754
	} else
		ret = amdgpu_ras_feature_enable(adev, head, enable);

	return ret;
}

755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
static int amdgpu_ras_disable_all_features(struct amdgpu_device *adev,
		bool bypass)
{
	struct amdgpu_ras *con = amdgpu_ras_get_context(adev);
	struct ras_manager *obj, *tmp;

	list_for_each_entry_safe(obj, tmp, &con->head, node) {
		/* bypass psp.
		 * aka just release the obj and corresponding flags
		 */
		if (bypass) {
			if (__amdgpu_ras_feature_enable(adev, &obj->head, 0))
				break;
		} else {
			if (amdgpu_ras_feature_enable(adev, &obj->head, 0))
				break;
		}
772
	}
773
774
775
776
777
778
779
780
781
782

	return con->features;
}

static int amdgpu_ras_enable_all_features(struct amdgpu_device *adev,
		bool bypass)
{
	struct amdgpu_ras *con = amdgpu_ras_get_context(adev);
	int ras_block_count = AMDGPU_RAS_BLOCK_COUNT;
	int i;
783
784
	const enum amdgpu_ras_error_type default_ras_type =
		AMDGPU_RAS_ERROR__NONE;
785
786
787
788

	for (i = 0; i < ras_block_count; i++) {
		struct ras_common_if head = {
			.block = i,
789
			.type = default_ras_type,
790
791
792
793
794
795
796
797
798
799
800
801
802
803
			.sub_block_index = 0,
		};
		strcpy(head.name, ras_block_str(i));
		if (bypass) {
			/*
			 * bypass psp. vbios enable ras for us.
			 * so just create the obj
			 */
			if (__amdgpu_ras_feature_enable(adev, &head, 1))
				break;
		} else {
			if (amdgpu_ras_feature_enable(adev, &head, 1))
				break;
		}
804
	}
805
806
807
808
809
810

	return con->features;
}
/* feature ctl end */

/* query/inject/cure begin */
811
int amdgpu_ras_query_error_status(struct amdgpu_device *adev,
812
				  struct ras_query_if *info)
813
814
{
	struct ras_manager *obj = amdgpu_ras_find_obj(adev, &info->head);
815
	struct ras_err_data err_data = {0, 0, 0, NULL};
816
	int i;
817
818
819
820

	if (!obj)
		return -EINVAL;

821
822
	switch (info->head.block) {
	case AMDGPU_RAS_BLOCK__UMC:
823
824
825
		if (adev->umc.ras_funcs &&
		    adev->umc.ras_funcs->query_ras_error_count)
			adev->umc.ras_funcs->query_ras_error_count(adev, &err_data);
826
827
828
		/* umc query_ras_error_address is also responsible for clearing
		 * error status
		 */
829
830
831
		if (adev->umc.ras_funcs &&
		    adev->umc.ras_funcs->query_ras_error_address)
			adev->umc.ras_funcs->query_ras_error_address(adev, &err_data);
832
		break;
833
834
835
836
837
838
839
	case AMDGPU_RAS_BLOCK__SDMA:
		if (adev->sdma.funcs->query_ras_error_count) {
			for (i = 0; i < adev->sdma.num_instances; i++)
				adev->sdma.funcs->query_ras_error_count(adev, i,
									&err_data);
		}
		break;
840
	case AMDGPU_RAS_BLOCK__GFX:
841
842
843
		if (adev->gfx.ras_funcs &&
		    adev->gfx.ras_funcs->query_ras_error_count)
			adev->gfx.ras_funcs->query_ras_error_count(adev, &err_data);
844

845
846
847
		if (adev->gfx.ras_funcs &&
		    adev->gfx.ras_funcs->query_ras_error_status)
			adev->gfx.ras_funcs->query_ras_error_status(adev);
848
		break;
849
	case AMDGPU_RAS_BLOCK__MMHUB:
850
851
852
		if (adev->mmhub.ras_funcs &&
		    adev->mmhub.ras_funcs->query_ras_error_count)
			adev->mmhub.ras_funcs->query_ras_error_count(adev, &err_data);
853

854
855
856
		if (adev->mmhub.ras_funcs &&
		    adev->mmhub.ras_funcs->query_ras_error_status)
			adev->mmhub.ras_funcs->query_ras_error_status(adev);
857
		break;
858
	case AMDGPU_RAS_BLOCK__PCIE_BIF:
859
860
861
		if (adev->nbio.ras_funcs &&
		    adev->nbio.ras_funcs->query_ras_error_count)
			adev->nbio.ras_funcs->query_ras_error_count(adev, &err_data);
862
		break;
863
	case AMDGPU_RAS_BLOCK__XGMI_WAFL:
864
865
866
		if (adev->gmc.xgmi.ras_funcs &&
		    adev->gmc.xgmi.ras_funcs->query_ras_error_count)
			adev->gmc.xgmi.ras_funcs->query_ras_error_count(adev, &err_data);
867
		break;
868
869
870
871
872
	case AMDGPU_RAS_BLOCK__HDP:
		if (adev->hdp.ras_funcs &&
		    adev->hdp.ras_funcs->query_ras_error_count)
			adev->hdp.ras_funcs->query_ras_error_count(adev, &err_data);
		break;
873
874
875
	default:
		break;
	}
876
877
878
879

	obj->err_data.ue_count += err_data.ue_count;
	obj->err_data.ce_count += err_data.ce_count;

880
881
882
	info->ue_count = obj->err_data.ue_count;
	info->ce_count = obj->err_data.ce_count;

883
	if (err_data.ce_count) {
884
885
886
887
888
		if (adev->smuio.funcs &&
		    adev->smuio.funcs->get_socket_id &&
		    adev->smuio.funcs->get_die_id) {
			dev_info(adev->dev, "socket: %d, die: %d "
					"%ld correctable hardware errors "
889
890
					"detected in %s block, no user "
					"action is needed.\n",
891
892
					adev->smuio.funcs->get_socket_id(adev),
					adev->smuio.funcs->get_die_id(adev),
893
894
					obj->err_data.ce_count,
					ras_block_str(info->head.block));
895
896
		} else {
			dev_info(adev->dev, "%ld correctable hardware errors "
897
898
899
900
					"detected in %s block, no user "
					"action is needed.\n",
					obj->err_data.ce_count,
					ras_block_str(info->head.block));
901
		}
902
903
	}
	if (err_data.ue_count) {
904
905
906
907
908
		if (adev->smuio.funcs &&
		    adev->smuio.funcs->get_socket_id &&
		    adev->smuio.funcs->get_die_id) {
			dev_info(adev->dev, "socket: %d, die: %d "
					"%ld uncorrectable hardware errors "
909
					"detected in %s block\n",
910
911
					adev->smuio.funcs->get_socket_id(adev),
					adev->smuio.funcs->get_die_id(adev),
912
913
					obj->err_data.ue_count,
					ras_block_str(info->head.block));
914
915
		} else {
			dev_info(adev->dev, "%ld uncorrectable hardware errors "
916
917
918
					"detected in %s block\n",
					obj->err_data.ue_count,
					ras_block_str(info->head.block));
919
		}
920
	}
921

922
923
924
	return 0;
}

925
926
927
928
929
930
931
932
int amdgpu_ras_reset_error_status(struct amdgpu_device *adev,
		enum amdgpu_ras_block block)
{
	if (!amdgpu_ras_is_supported(adev, block))
		return -EINVAL;

	switch (block) {
	case AMDGPU_RAS_BLOCK__GFX:
933
934
935
		if (adev->gfx.ras_funcs &&
		    adev->gfx.ras_funcs->reset_ras_error_count)
			adev->gfx.ras_funcs->reset_ras_error_count(adev);
936

937
938
939
		if (adev->gfx.ras_funcs &&
		    adev->gfx.ras_funcs->reset_ras_error_status)
			adev->gfx.ras_funcs->reset_ras_error_status(adev);
940
941
		break;
	case AMDGPU_RAS_BLOCK__MMHUB:
942
943
944
		if (adev->mmhub.ras_funcs &&
		    adev->mmhub.ras_funcs->reset_ras_error_count)
			adev->mmhub.ras_funcs->reset_ras_error_count(adev);
945
946
947
948

		if (adev->mmhub.ras_funcs &&
		    adev->mmhub.ras_funcs->reset_ras_error_status)
			adev->mmhub.ras_funcs->reset_ras_error_status(adev);
949
950
951
952
953
		break;
	case AMDGPU_RAS_BLOCK__SDMA:
		if (adev->sdma.funcs->reset_ras_error_count)
			adev->sdma.funcs->reset_ras_error_count(adev);
		break;
954
955
956
957
958
	case AMDGPU_RAS_BLOCK__HDP:
		if (adev->hdp.ras_funcs &&
		    adev->hdp.ras_funcs->reset_ras_error_count)
			adev->hdp.ras_funcs->reset_ras_error_count(adev);
		break;
959
960
961
962
963
964
965
	default:
		break;
	}

	return 0;
}

966
/* Trigger XGMI/WAFL error */
967
static int amdgpu_ras_error_inject_xgmi(struct amdgpu_device *adev,
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
				 struct ta_ras_trigger_error_input *block_info)
{
	int ret;

	if (amdgpu_dpm_set_df_cstate(adev, DF_CSTATE_DISALLOW))
		dev_warn(adev->dev, "Failed to disallow df cstate");

	if (amdgpu_dpm_allow_xgmi_power_down(adev, false))
		dev_warn(adev->dev, "Failed to disallow XGMI power down");

	ret = psp_ras_trigger_error(&adev->psp, block_info);

	if (amdgpu_ras_intr_triggered())
		return ret;

	if (amdgpu_dpm_allow_xgmi_power_down(adev, true))
		dev_warn(adev->dev, "Failed to allow XGMI power down");

986
	if (amdgpu_dpm_set_df_cstate(adev, DF_CSTATE_ALLOW))
987
988
989
990
991
		dev_warn(adev->dev, "Failed to allow df cstate");

	return ret;
}

992
993
994
995
996
997
/* wrapper of psp_ras_trigger_error */
int amdgpu_ras_error_inject(struct amdgpu_device *adev,
		struct ras_inject_if *info)
{
	struct ras_manager *obj = amdgpu_ras_find_obj(adev, &info->head);
	struct ta_ras_trigger_error_input block_info = {
998
999
		.block_id =  amdgpu_ras_block_to_ta(info->head.block),
		.inject_error_type = amdgpu_ras_error_to_ta(info->head.type),
1000
1001
1002
1003
1004
1005
1006
1007
1008
		.sub_block_index = info->head.sub_block_index,
		.address = info->address,
		.value = info->value,
	};
	int ret = 0;

	if (!obj)
		return -EINVAL;

1009
1010
	/* Calculate XGMI relative offset */
	if (adev->gmc.xgmi.num_physical_nodes > 1) {
1011
1012
1013
		block_info.address =
			amdgpu_xgmi_get_relative_phy_addr(adev,
							  block_info.address);
1014
1015
	}

1016
1017
	switch (info->head.block) {
	case AMDGPU_RAS_BLOCK__GFX:
1018
1019
1020
		if (adev->gfx.ras_funcs &&
		    adev->gfx.ras_funcs->ras_error_inject)
			ret = adev->gfx.ras_funcs->ras_error_inject(adev, info);
1021
1022
1023
1024
		else
			ret = -EINVAL;
		break;
	case AMDGPU_RAS_BLOCK__UMC:
1025
	case AMDGPU_RAS_BLOCK__SDMA:
1026
	case AMDGPU_RAS_BLOCK__MMHUB:
1027
	case AMDGPU_RAS_BLOCK__PCIE_BIF:
1028
1029
		ret = psp_ras_trigger_error(&adev->psp, &block_info);
		break;
1030
1031
1032
	case AMDGPU_RAS_BLOCK__XGMI_WAFL:
		ret = amdgpu_ras_error_inject_xgmi(adev, &block_info);
		break;
1033
	default:
1034
		dev_info(adev->dev, "%s error injection is not supported yet\n",
1035
			 ras_block_str(info->head.block));
1036
		ret = -EINVAL;
1037
1038
	}

1039
1040
1041
	if (ret)
		dev_err(adev->dev, "ras inject %s failed %d\n",
			ras_block_str(info->head.block), ret);
1042
1043
1044
1045

	return ret;
}

1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
/**
 * amdgpu_ras_query_error_count -- Get error counts of all IPs
 * adev: pointer to AMD GPU device
 * ce_count: pointer to an integer to be set to the count of correctible errors.
 * ue_count: pointer to an integer to be set to the count of uncorrectible
 * errors.
 *
 * If set, @ce_count or @ue_count, count and return the corresponding
 * error counts in those integer pointers. Return 0 if the device
 * supports RAS. Return -EOPNOTSUPP if the device doesn't support RAS.
 */
int amdgpu_ras_query_error_count(struct amdgpu_device *adev,
				 unsigned long *ce_count,
				 unsigned long *ue_count)
1060
1061
1062
{
	struct amdgpu_ras *con = amdgpu_ras_get_context(adev);
	struct ras_manager *obj;
1063
	unsigned long ce, ue;
1064

1065
	if (!adev->ras_enabled || !con)
1066
1067
1068
1069
1070
1071
		return -EOPNOTSUPP;

	/* Don't count since no reporting.
	 */
	if (!ce_count && !ue_count)
		return 0;
1072

1073
1074
	ce = 0;
	ue = 0;
1075
1076
1077
1078
	list_for_each_entry(obj, &con->head, node) {
		struct ras_query_if info = {
			.head = obj->head,
		};
1079
		int res;
1080

1081
1082
1083
		res = amdgpu_ras_query_error_status(adev, &info);
		if (res)
			return res;
1084

1085
1086
		ce += info.ce_count;
		ue += info.ue_count;
1087
1088
	}

1089
1090
1091
1092
1093
	if (ce_count)
		*ce_count = ce;

	if (ue_count)
		*ue_count = ue;
1094
1095

	return 0;
1096
1097
1098
1099
1100
1101
}
/* query/inject/cure end */


/* sysfs begin */

1102
1103
1104
1105
1106
1107
static int amdgpu_ras_badpages_read(struct amdgpu_device *adev,
		struct ras_badpage **bps, unsigned int *count);

static char *amdgpu_ras_badpage_flags_str(unsigned int flags)
{
	switch (flags) {
1108
	case AMDGPU_RAS_RETIRE_PAGE_RESERVED:
1109
		return "R";
1110
	case AMDGPU_RAS_RETIRE_PAGE_PENDING:
1111
		return "P";
1112
	case AMDGPU_RAS_RETIRE_PAGE_FAULT:
1113
1114
	default:
		return "F";
1115
	}
1116
1117
}

1118
1119
/**
 * DOC: AMDGPU RAS sysfs gpu_vram_bad_pages Interface
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
 *
 * It allows user to read the bad pages of vram on the gpu through
 * /sys/class/drm/card[0/1/2...]/device/ras/gpu_vram_bad_pages
 *
 * It outputs multiple lines, and each line stands for one gpu page.
 *
 * The format of one line is below,
 * gpu pfn : gpu page size : flags
 *
 * gpu pfn and gpu page size are printed in hex format.
 * flags can be one of below character,
1131
 *
1132
 * R: reserved, this gpu page is reserved and not able to use.
1133
 *
1134
 * P: pending for reserve, this gpu page is marked as bad, will be reserved
1135
1136
 * in next window of page_reserve.
 *
1137
1138
 * F: unable to reserve. this gpu page can't be reserved due to some reasons.
 *
1139
1140
1141
1142
1143
1144
1145
 * Examples:
 *
 * .. code-block:: bash
 *
 *	0x00000001 : 0x00001000 : R
 *	0x00000002 : 0x00001000 : P
 *
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
 */

static ssize_t amdgpu_ras_sysfs_badpages_read(struct file *f,
		struct kobject *kobj, struct bin_attribute *attr,
		char *buf, loff_t ppos, size_t count)
{
	struct amdgpu_ras *con =
		container_of(attr, struct amdgpu_ras, badpages_attr);
	struct amdgpu_device *adev = con->adev;
	const unsigned int element_size =
		sizeof("0xabcdabcd : 0x12345678 : R\n") - 1;
1157
1158
	unsigned int start = div64_ul(ppos + element_size - 1, element_size);
	unsigned int end = div64_ul(ppos + count - 1, element_size);
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
	ssize_t s = 0;
	struct ras_badpage *bps = NULL;
	unsigned int bps_count = 0;

	memset(buf, 0, count);

	if (amdgpu_ras_badpages_read(adev, &bps, &bps_count))
		return 0;

	for (; start < end && start < bps_count; start++)
		s += scnprintf(&buf[s], element_size + 1,
				"0x%08x : 0x%08x : %1s\n",
				bps[start].bp,
				bps[start].size,
				amdgpu_ras_badpage_flags_str(bps[start].flags));

	kfree(bps);

	return s;
}

1180
1181
1182
1183
1184
1185
static ssize_t amdgpu_ras_sysfs_features_read(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct amdgpu_ras *con =
		container_of(attr, struct amdgpu_ras, features_attr);

1186
	return scnprintf(buf, PAGE_SIZE, "feature mask: 0x%x\n", con->features);
1187
1188
}

1189
1190
1191
1192
1193
1194
1195
1196
1197
static void amdgpu_ras_sysfs_remove_bad_page_node(struct amdgpu_device *adev)
{
	struct amdgpu_ras *con = amdgpu_ras_get_context(adev);

	sysfs_remove_file_from_group(&adev->dev->kobj,
				&con->badpages_attr.attr,
				RAS_FS_NAME);
}

1198
1199
1200
1201
1202
1203
1204
1205
static int amdgpu_ras_sysfs_remove_feature_node(struct amdgpu_device *adev)
{
	struct amdgpu_ras *con = amdgpu_ras_get_context(adev);
	struct attribute *attrs[] = {
		&con->features_attr.attr,
		NULL
	};
	struct attribute_group group = {
1206
		.name = RAS_FS_NAME,
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
		.attrs = attrs,
	};

	sysfs_remove_group(&adev->dev->kobj, &group);

	return 0;
}

int amdgpu_ras_sysfs_create(struct amdgpu_device *adev,
		struct ras_fs_if *head)
{
	struct ras_manager *obj = amdgpu_ras_find_obj(adev, &head->head);

	if (!obj || obj->attr_inuse)
		return -EINVAL;

	get_obj(obj);

	memcpy(obj->fs_data.sysfs_name,
			head->sysfs_name,
			sizeof(obj->fs_data.sysfs_name));

	obj->sysfs_attr = (struct device_attribute){
		.attr = {
			.name = obj->fs_data.sysfs_name,
			.mode = S_IRUGO,
		},
			.show = amdgpu_ras_sysfs_read,
	};
1236
	sysfs_attr_init(&obj->sysfs_attr.attr);
1237
1238
1239

	if (sysfs_add_file_to_group(&adev->dev->kobj,
				&obj->sysfs_attr.attr,
1240
				RAS_FS_NAME)) {
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
		put_obj(obj);
		return -EINVAL;
	}

	obj->attr_inuse = 1;

	return 0;
}

int amdgpu_ras_sysfs_remove(struct amdgpu_device *adev,
		struct ras_common_if *head)
{
	struct ras_manager *obj = amdgpu_ras_find_obj(adev, head);

	if (!obj || !obj->attr_inuse)
		return -EINVAL;

	sysfs_remove_file_from_group(&adev->dev->kobj,
				&obj->sysfs_attr.attr,
1260
				RAS_FS_NAME);
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
	obj->attr_inuse = 0;
	put_obj(obj);

	return 0;
}

static int amdgpu_ras_sysfs_remove_all(struct amdgpu_device *adev)
{
	struct amdgpu_ras *con = amdgpu_ras_get_context(adev);
	struct ras_manager *obj, *tmp;

	list_for_each_entry_safe(obj, tmp, &con->head, node) {
		amdgpu_ras_sysfs_remove(adev, &obj->head);
	}

1276
1277
1278
	if (amdgpu_bad_page_threshold != 0)
		amdgpu_ras_sysfs_remove_bad_page_node(adev);

1279
1280
1281
1282
1283
1284
	amdgpu_ras_sysfs_remove_feature_node(adev);

	return 0;
}
/* sysfs end */

1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
/**
 * DOC: AMDGPU RAS Reboot Behavior for Unrecoverable Errors
 *
 * Normally when there is an uncorrectable error, the driver will reset
 * the GPU to recover.  However, in the event of an unrecoverable error,
 * the driver provides an interface to reboot the system automatically
 * in that event.
 *
 * The following file in debugfs provides that interface:
 * /sys/kernel/debug/dri/[0/1/2...]/ras/auto_reboot
 *
 * Usage:
 *
 * .. code-block:: bash
 *
 *	echo true > .../ras/auto_reboot
 *
 */
1303
/* debugfs begin */
1304
static struct dentry *amdgpu_ras_debugfs_create_ctrl_node(struct amdgpu_device *adev)
xinhui pan's avatar
xinhui pan committed
1305
1306
{
	struct amdgpu_ras *con = amdgpu_ras_get_context(adev);
1307
1308
	struct drm_minor  *minor = adev_to_drm(adev)->primary;
	struct dentry     *dir;
xinhui pan's avatar
xinhui pan committed
1309

1310
1311
1312
1313
1314
	dir = debugfs_create_dir(RAS_FS_NAME, minor->debugfs_root);
	debugfs_create_file("ras_ctrl", S_IWUGO | S_IRUGO, dir, adev,
			    &amdgpu_ras_debugfs_ctrl_ops);
	debugfs_create_file("ras_eeprom_reset", S_IWUGO | S_IRUGO, dir, adev,
			    &amdgpu_ras_debugfs_eeprom_ops);
1315
1316
	debugfs_create_u32("bad_page_cnt_threshold", 0444, dir,
			   &con->bad_page_cnt_threshold);
1317
1318
	debugfs_create_x32("ras_hw_enabled", 0444, dir, &adev->ras_hw_enabled);
	debugfs_create_x32("ras_enabled", 0444, dir, &adev->ras_enabled);
1319
1320
1321
1322
1323
1324
1325
1326
1327

	/*
	 * After one uncorrectable error happens, usually GPU recovery will
	 * be scheduled. But due to the known problem in GPU recovery failing
	 * to bring GPU back, below interface provides one direct way to
	 * user to reboot system automatically in such case within
	 * ERREVENT_ATHUB_INTERRUPT generated. Normal GPU recovery routine
	 * will never be called.
	 */
1328
	debugfs_create_bool("auto_reboot", S_IWUGO | S_IRUGO, dir, &con->reboot);
1329
1330
1331
1332
1333

	/*
	 * User could set this not to clean up hardware's error count register
	 * of RAS IPs during ras recovery.
	 */
1334
1335
1336
	debugfs_create_bool("disable_ras_err_cnt_harvest", 0644, dir,
			    &con->disable_ras_err_cnt_harvest);
	return dir;
xinhui pan's avatar
xinhui pan committed
1337
1338
}

1339
static void amdgpu_ras_debugfs_create(struct amdgpu_device *adev,
1340
1341
				      struct ras_fs_if *head,
				      struct dentry *dir)