modify sin led gpio

hc

2024-05-13 9d77db3c730780c8ef5ccd4b66403ff5675cfe4e

 kernel/drivers/gpu/drm/armada/armada_debugfs.c
..
..
@@ -1,16 +1,17 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
1
2
 /*
2
3
  * Copyright (C) 2012 Russell King
3
4
  *  Rewritten from the dovefb driver, and Armada510 manuals.
4
- *
5
- * This program is free software; you can redistribute it and/or modify
6
- * it under the terms of the GNU General Public License version 2 as
7
- * published by the Free Software Foundation.
8
5
  */
6
+
9
7
 #include <linux/ctype.h>
10
-#include <linux/debugfs.h>
11
8
 #include <linux/module.h>
12
9
 #include <linux/seq_file.h>
13
-#include <drm/drmP.h>
10
+#include <linux/uaccess.h>
11
+
12
+#include <drm/drm_debugfs.h>
13
+#include <drm/drm_file.h>
14
+
14
15
 #include "armada_crtc.h"
15
16
 #include "armada_drm.h"
16
17
 
..
..
@@ -18,7 +19,7 @@
18
19
 {
19
20
 	struct drm_info_node *node = m->private;
20
21
 	struct drm_device *dev = node->minor->dev;
21
-	struct armada_private *priv = dev->dev_private;
22
+	struct armada_private *priv = drm_to_armada_dev(dev);
22
23
 	struct drm_printer p = drm_seq_file_printer(m);
23
24
 
24
25
 	mutex_lock(&priv->linear_lock);
..
..
@@ -28,50 +29,33 @@
28
29
 	return 0;
29
30
 }
30
31
 
31
-static int armada_debugfs_reg_show(struct seq_file *m, void *data)
32
+static int armada_debugfs_crtc_reg_show(struct seq_file *m, void *data)
32
33
 {
33
-	struct drm_device *dev = m->private;
34
-	struct armada_private *priv = dev->dev_private;
35
-	int n, i;
34
+	struct armada_crtc *dcrtc = m->private;
35
+	int i;
36
36
 
37
-	if (priv) {
38
-		for (n = 0; n < ARRAY_SIZE(priv->dcrtc); n++) {
39
-			struct armada_crtc *dcrtc = priv->dcrtc[n];
40
-			if (!dcrtc)
41
-				continue;
42
-
43
-			for (i = 0x84; i <= 0x1c4; i += 4) {
44
-				uint32_t v = readl_relaxed(dcrtc->base + i);
45
-				seq_printf(m, "%u: 0x%04x: 0x%08x\n", n, i, v);
46
-			}
47
-		}
37
+	for (i = 0x84; i <= 0x1c4; i += 4) {
38
+		u32 v = readl_relaxed(dcrtc->base + i);
39
+		seq_printf(m, "0x%04x: 0x%08x\n", i, v);
48
40
 	}
49
41
 
50
42
 	return 0;
51
43
 }
52
44
 
53
-static int armada_debugfs_reg_r_open(struct inode *inode, struct file *file)
45
+static int armada_debugfs_crtc_reg_open(struct inode *inode, struct file *file)
54
46
 {
55
-	return single_open(file, armada_debugfs_reg_show, inode->i_private);
47
+	return single_open(file, armada_debugfs_crtc_reg_show,
48
+			   inode->i_private);
56
49
 }
57
50
 
58
-static const struct file_operations fops_reg_r = {
59
-	.owner = THIS_MODULE,
60
-	.open = armada_debugfs_reg_r_open,
61
-	.read = seq_read,
62
-	.llseek = seq_lseek,
63
-	.release = single_release,
64
-};
65
-
66
-static int armada_debugfs_write(struct file *file, const char __user *ptr,
67
-	size_t len, loff_t *off)
51
+static int armada_debugfs_crtc_reg_write(struct file *file,
52
+	const char __user *ptr, size_t len, loff_t *off)
68
53
 {
69
-	struct drm_device *dev = file->private_data;
70
-	struct armada_private *priv = dev->dev_private;
71
-	struct armada_crtc *dcrtc = priv->dcrtc[0];
72
-	char buf[32], *p;
73
-	uint32_t reg, val;
54
+	struct armada_crtc *dcrtc;
55
+	unsigned long reg, mask, val;
56
+	char buf[32];
74
57
 	int ret;
58
+	u32 v;
75
59
 
76
60
 	if (*off != 0)
77
61
 		return 0;
..
..
@@ -84,23 +68,34 @@
84
68
 		return ret;
85
69
 	buf[len] = '\0';
86
70
 
87
-	reg = simple_strtoul(buf, &p, 16);
88
-	if (!isspace(*p))
71
+	if (sscanf(buf, "%lx %lx %lx", &reg, &mask, &val) != 3)
89
72
 		return -EINVAL;
90
-	val = simple_strtoul(p + 1, NULL, 16);
73
+	if (reg < 0x84 || reg > 0x1c4 || reg & 3)
74
+		return -ERANGE;
91
75
 
92
-	if (reg >= 0x84 && reg <= 0x1c4)
93
-		writel(val, dcrtc->base + reg);
76
+	dcrtc = ((struct seq_file *)file->private_data)->private;
77
+	v = readl(dcrtc->base + reg);
78
+	v &= ~mask;
79
+	v |= val & mask;
80
+	writel(v, dcrtc->base + reg);
94
81
 
95
82
 	return len;
96
83
 }
97
84
 
98
-static const struct file_operations fops_reg_w = {
85
+static const struct file_operations armada_debugfs_crtc_reg_fops = {
99
86
 	.owner = THIS_MODULE,
100
-	.open = simple_open,
101
-	.write = armada_debugfs_write,
102
-	.llseek = noop_llseek,
87
+	.open = armada_debugfs_crtc_reg_open,
88
+	.read = seq_read,
89
+	.write = armada_debugfs_crtc_reg_write,
90
+	.llseek = seq_lseek,
91
+	.release = single_release,
103
92
 };
93
+
94
+void armada_drm_crtc_debugfs_init(struct armada_crtc *dcrtc)
95
+{
96
+	debugfs_create_file("armada-regs", 0600, dcrtc->crtc.debugfs_entry,
97
+			    dcrtc, &armada_debugfs_crtc_reg_fops);
98
+}
104
99
 
105
100
 static struct drm_info_list armada_debugfs_list[] = {
106
101
 	{ "gem_linear", armada_debugfs_gem_linear_show, 0 },
..
..
@@ -109,24 +104,8 @@
109
104
 
110
105
 int armada_drm_debugfs_init(struct drm_minor *minor)
111
106
 {
112
-	struct dentry *de;
113
-	int ret;
114
-
115
-	ret = drm_debugfs_create_files(armada_debugfs_list,
116
-				       ARMADA_DEBUGFS_ENTRIES,
117
-				       minor->debugfs_root, minor);
118
-	if (ret)
119
-		return ret;
120
-
121
-	de = debugfs_create_file("reg", S_IFREG | S_IRUSR,
122
-				 minor->debugfs_root, minor->dev, &fops_reg_r);
123
-	if (!de)
124
-		return -ENOMEM;
125
-
126
-	de = debugfs_create_file("reg_wr", S_IFREG | S_IWUSR,
127
-				 minor->debugfs_root, minor->dev, &fops_reg_w);
128
-	if (!de)
129
-		return -ENOMEM;
107
+	drm_debugfs_create_files(armada_debugfs_list, ARMADA_DEBUGFS_ENTRIES,
108
+				 minor->debugfs_root, minor);
130
109
 
131
110
 	return 0;
132
111
 }