* [PATCH bpf-next v2 1/2] bpf: change uapi for bpf iterator map elements
From: Yonghong Song @ 2020-08-03 7:33 UTC (permalink / raw)
To: bpf, netdev; +Cc: Alexei Starovoitov, Daniel Borkmann, kernel-team
In-Reply-To: <20200803073326.3745149-1-yhs@fb.com>
Commit a5cbe05a6673 ("bpf: Implement bpf iterator for
map elements") added bpf iterator support for
map elements. The map element bpf iterator requires
info to identify a particular map. In the above
commit, the attr->link_create.target_fd is used
to carry map_fd and an enum bpf_iter_link_info
is added to uapi to specify the target_fd actually
representing a map_fd:
enum bpf_iter_link_info {
BPF_ITER_LINK_UNSPEC = 0,
BPF_ITER_LINK_MAP_FD = 1,
MAX_BPF_ITER_LINK_INFO,
};
This is an extensible approach as we can grow
enumerator for pid, cgroup_id, etc. and we can
unionize target_fd for pid, cgroup_id, etc.
But in the future, there are chances that
more complex customization may happen, e.g.,
for tasks, it could be filtered based on
both cgroup_id and user_id.
This patch changed the uapi to have fields
__aligned_u64 iter_info;
__u32 iter_info_len;
for additional iter_info for link_create.
The iter_info is defined as
union bpf_iter_link_info {
struct {
__u32 map_fd;
} map;
};
So future extension for additional customization
will be easier. The bpf_iter_link_info will be
passed to target callback to validate and generic
bpf_iter framework does not need to deal it any
more.
Signed-off-by: Yonghong Song <yhs@fb.com>
---
include/linux/bpf.h | 10 ++++---
include/uapi/linux/bpf.h | 15 +++++-----
kernel/bpf/bpf_iter.c | 58 +++++++++++++++++++--------------------
kernel/bpf/map_iter.c | 34 +++++++++++++++++------
kernel/bpf/syscall.c | 2 +-
net/core/bpf_sk_storage.c | 34 +++++++++++++++++------
6 files changed, 96 insertions(+), 57 deletions(-)
Note: I did not copy include/uapi/linux/bpf.h to
tools/include/uapi/linux/bpf.h in this patch. The
reason is due to resolve_btfids in kernel build.
The resolve_btfids has a dependence on libbpf.
Updating tools/include/uapi/linux/bpf.h without
addition other libbpf changes in the next patch
will cause libbpf build failure and hence
the failure for resolve_btfids build.
diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index cef4ef0d2b4e..55f694b63164 100644
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -1214,15 +1214,17 @@ struct bpf_iter_aux_info {
struct bpf_map *map;
};
-typedef int (*bpf_iter_check_target_t)(struct bpf_prog *prog,
- struct bpf_iter_aux_info *aux);
+typedef int (*bpf_iter_attach_target_t)(struct bpf_prog *prog,
+ union bpf_iter_link_info *linfo,
+ struct bpf_iter_aux_info *aux);
+typedef void (*bpf_iter_detach_target_t)(struct bpf_iter_aux_info *aux);
#define BPF_ITER_CTX_ARG_MAX 2
struct bpf_iter_reg {
const char *target;
- bpf_iter_check_target_t check_target;
+ bpf_iter_attach_target_t attach_target;
+ bpf_iter_detach_target_t detach_target;
u32 ctx_arg_info_size;
- enum bpf_iter_link_info req_linfo;
struct bpf_ctx_arg_aux ctx_arg_info[BPF_ITER_CTX_ARG_MAX];
const struct bpf_iter_seq_info *seq_info;
};
diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h
index b134e679e9db..0480f893facd 100644
--- a/include/uapi/linux/bpf.h
+++ b/include/uapi/linux/bpf.h
@@ -81,6 +81,12 @@ struct bpf_cgroup_storage_key {
__u32 attach_type; /* program attach type */
};
+union bpf_iter_link_info {
+ struct {
+ __u32 map_fd;
+ } map;
+};
+
/* BPF syscall commands, see bpf(2) man-page for details. */
enum bpf_cmd {
BPF_MAP_CREATE,
@@ -249,13 +255,6 @@ enum bpf_link_type {
MAX_BPF_LINK_TYPE,
};
-enum bpf_iter_link_info {
- BPF_ITER_LINK_UNSPEC = 0,
- BPF_ITER_LINK_MAP_FD = 1,
-
- MAX_BPF_ITER_LINK_INFO,
-};
-
/* cgroup-bpf attach flags used in BPF_PROG_ATTACH command
*
* NONE(default): No further bpf programs allowed in the subtree.
@@ -623,6 +622,8 @@ union bpf_attr {
};
__u32 attach_type; /* attach type */
__u32 flags; /* extra flags */
+ __aligned_u64 iter_info; /* extra bpf_iter_link_info */
+ __u32 iter_info_len; /* iter_info length */
} link_create;
struct { /* struct used by BPF_LINK_UPDATE command */
diff --git a/kernel/bpf/bpf_iter.c b/kernel/bpf/bpf_iter.c
index 363b9cafc2d8..b6715964b685 100644
--- a/kernel/bpf/bpf_iter.c
+++ b/kernel/bpf/bpf_iter.c
@@ -338,8 +338,8 @@ static void bpf_iter_link_release(struct bpf_link *link)
struct bpf_iter_link *iter_link =
container_of(link, struct bpf_iter_link, link);
- if (iter_link->aux.map)
- bpf_map_put_with_uref(iter_link->aux.map);
+ if (iter_link->tinfo->reg_info->detach_target)
+ iter_link->tinfo->reg_info->detach_target(&iter_link->aux);
}
static void bpf_iter_link_dealloc(struct bpf_link *link)
@@ -390,15 +390,35 @@ bool bpf_link_is_iter(struct bpf_link *link)
int bpf_iter_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)
{
+ union bpf_iter_link_info __user *ulinfo;
struct bpf_link_primer link_primer;
struct bpf_iter_target_info *tinfo;
- struct bpf_iter_aux_info aux = {};
+ union bpf_iter_link_info linfo;
struct bpf_iter_link *link;
- u32 prog_btf_id, target_fd;
+ u32 prog_btf_id, linfo_len;
bool existed = false;
- struct bpf_map *map;
int err;
+ if (attr->link_create.target_fd || attr->link_create.flags)
+ return -EINVAL;
+
+ memset(&linfo, 0, sizeof(union bpf_iter_link_info));
+
+ ulinfo = u64_to_user_ptr(attr->link_create.iter_info);
+ linfo_len = attr->link_create.iter_info_len;
+ if (!ulinfo ^ !linfo_len)
+ return -EINVAL;
+
+ if (ulinfo) {
+ err = bpf_check_uarg_tail_zero(ulinfo, sizeof(linfo),
+ linfo_len);
+ if (err)
+ return err;
+ linfo_len = min_t(u32, linfo_len, sizeof(linfo));
+ if (copy_from_user(&linfo, ulinfo, linfo_len))
+ return -EFAULT;
+ }
+
prog_btf_id = prog->aux->attach_btf_id;
mutex_lock(&targets_mutex);
list_for_each_entry(tinfo, &targets, list) {
@@ -411,13 +431,6 @@ int bpf_iter_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)
if (!existed)
return -ENOENT;
- /* Make sure user supplied flags are target expected. */
- target_fd = attr->link_create.target_fd;
- if (attr->link_create.flags != tinfo->reg_info->req_linfo)
- return -EINVAL;
- if (!attr->link_create.flags && target_fd)
- return -EINVAL;
-
link = kzalloc(sizeof(*link), GFP_USER | __GFP_NOWARN);
if (!link)
return -ENOMEM;
@@ -431,28 +444,15 @@ int bpf_iter_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)
return err;
}
- if (tinfo->reg_info->req_linfo == BPF_ITER_LINK_MAP_FD) {
- map = bpf_map_get_with_uref(target_fd);
- if (IS_ERR(map)) {
- err = PTR_ERR(map);
- goto cleanup_link;
- }
-
- aux.map = map;
- err = tinfo->reg_info->check_target(prog, &aux);
+ if (tinfo->reg_info->attach_target) {
+ err = tinfo->reg_info->attach_target(prog, &linfo, &link->aux);
if (err) {
- bpf_map_put_with_uref(map);
- goto cleanup_link;
+ bpf_link_cleanup(&link_primer);
+ return err;
}
-
- link->aux.map = map;
}
return bpf_link_settle(&link_primer);
-
-cleanup_link:
- bpf_link_cleanup(&link_primer);
- return err;
}
static void init_seq_meta(struct bpf_iter_priv_data *priv_data,
diff --git a/kernel/bpf/map_iter.c b/kernel/bpf/map_iter.c
index fbe1f557cb88..69ce577edf2f 100644
--- a/kernel/bpf/map_iter.c
+++ b/kernel/bpf/map_iter.c
@@ -98,12 +98,18 @@ static struct bpf_iter_reg bpf_map_reg_info = {
.seq_info = &bpf_map_seq_info,
};
-static int bpf_iter_check_map(struct bpf_prog *prog,
- struct bpf_iter_aux_info *aux)
+static int bpf_iter_attach_map(struct bpf_prog *prog,
+ union bpf_iter_link_info *linfo,
+ struct bpf_iter_aux_info *aux)
{
u32 key_acc_size, value_acc_size, key_size, value_size;
- struct bpf_map *map = aux->map;
+ struct bpf_map *map;
bool is_percpu = false;
+ int err = -EINVAL;
+
+ map = bpf_map_get_with_uref(linfo->map.map_fd);
+ if (IS_ERR(map))
+ return PTR_ERR(map);
if (map->map_type == BPF_MAP_TYPE_PERCPU_HASH ||
map->map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH ||
@@ -112,7 +118,7 @@ static int bpf_iter_check_map(struct bpf_prog *prog,
else if (map->map_type != BPF_MAP_TYPE_HASH &&
map->map_type != BPF_MAP_TYPE_LRU_HASH &&
map->map_type != BPF_MAP_TYPE_ARRAY)
- return -EINVAL;
+ goto put_map;
key_acc_size = prog->aux->max_rdonly_access;
value_acc_size = prog->aux->max_rdwr_access;
@@ -122,10 +128,22 @@ static int bpf_iter_check_map(struct bpf_prog *prog,
else
value_size = round_up(map->value_size, 8) * num_possible_cpus();
- if (key_acc_size > key_size || value_acc_size > value_size)
- return -EACCES;
+ if (key_acc_size > key_size || value_acc_size > value_size) {
+ err = -EACCES;
+ goto put_map;
+ }
+ aux->map = map;
return 0;
+
+put_map:
+ bpf_map_put_with_uref(map);
+ return err;
+}
+
+static void bpf_iter_detach_map(struct bpf_iter_aux_info *aux)
+{
+ bpf_map_put_with_uref(aux->map);
}
DEFINE_BPF_ITER_FUNC(bpf_map_elem, struct bpf_iter_meta *meta,
@@ -133,8 +151,8 @@ DEFINE_BPF_ITER_FUNC(bpf_map_elem, struct bpf_iter_meta *meta,
static const struct bpf_iter_reg bpf_map_elem_reg_info = {
.target = "bpf_map_elem",
- .check_target = bpf_iter_check_map,
- .req_linfo = BPF_ITER_LINK_MAP_FD,
+ .attach_target = bpf_iter_attach_map,
+ .detach_target = bpf_iter_detach_map,
.ctx_arg_info_size = 2,
.ctx_arg_info = {
{ offsetof(struct bpf_iter__bpf_map_elem, key),
diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index 2f343ce15747..86299a292214 100644
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -3883,7 +3883,7 @@ static int tracing_bpf_link_attach(const union bpf_attr *attr, struct bpf_prog *
return -EINVAL;
}
-#define BPF_LINK_CREATE_LAST_FIELD link_create.flags
+#define BPF_LINK_CREATE_LAST_FIELD link_create.iter_info_len
static int link_create(union bpf_attr *attr)
{
enum bpf_prog_type ptype;
diff --git a/net/core/bpf_sk_storage.c b/net/core/bpf_sk_storage.c
index d3377c90a291..fbd83244984f 100644
--- a/net/core/bpf_sk_storage.c
+++ b/net/core/bpf_sk_storage.c
@@ -1384,18 +1384,36 @@ static int bpf_iter_init_sk_storage_map(void *priv_data,
return 0;
}
-static int bpf_iter_check_map(struct bpf_prog *prog,
- struct bpf_iter_aux_info *aux)
+static int bpf_iter_attach_map(struct bpf_prog *prog,
+ union bpf_iter_link_info *linfo,
+ struct bpf_iter_aux_info *aux)
{
- struct bpf_map *map = aux->map;
+ struct bpf_map *map;
+ int err = -EINVAL;
+
+ map = bpf_map_get_with_uref(linfo->map.map_fd);
+ if (IS_ERR(map))
+ return PTR_ERR(map);
if (map->map_type != BPF_MAP_TYPE_SK_STORAGE)
- return -EINVAL;
+ goto put_map;
- if (prog->aux->max_rdonly_access > map->value_size)
- return -EACCES;
+ if (prog->aux->max_rdonly_access > map->value_size) {
+ err = -EACCES;
+ goto put_map;
+ }
+ aux->map = map;
return 0;
+
+put_map:
+ bpf_map_put_with_uref(map);
+ return err;
+}
+
+static void bpf_iter_detach_map(struct bpf_iter_aux_info *aux)
+{
+ bpf_map_put_with_uref(aux->map);
}
static const struct seq_operations bpf_sk_storage_map_seq_ops = {
@@ -1414,8 +1432,8 @@ static const struct bpf_iter_seq_info iter_seq_info = {
static struct bpf_iter_reg bpf_sk_storage_map_reg_info = {
.target = "bpf_sk_storage_map",
- .check_target = bpf_iter_check_map,
- .req_linfo = BPF_ITER_LINK_MAP_FD,
+ .attach_target = bpf_iter_attach_map,
+ .detach_target = bpf_iter_detach_map,
.ctx_arg_info_size = 2,
.ctx_arg_info = {
{ offsetof(struct bpf_iter__bpf_sk_storage_map, sk),
--
2.24.1
^ permalink raw reply related
* [PATCH bpf-next v2 2/2] tools/bpf: support new uapi for map element bpf iterator
From: Yonghong Song @ 2020-08-03 7:33 UTC (permalink / raw)
To: bpf, netdev; +Cc: Alexei Starovoitov, Daniel Borkmann, kernel-team
In-Reply-To: <20200803073326.3745149-1-yhs@fb.com>
Previous commit adjusted kernel uapi for map
element bpf iterator. This patch adjusted libbpf API
due to uapi change. bpftool and bpf_iter selftests
are also changed accordingly.
Signed-off-by: Yonghong Song <yhs@fb.com>
---
tools/bpf/bpftool/iter.c | 8 +++--
tools/include/uapi/linux/bpf.h | 15 ++++----
tools/lib/bpf/bpf.c | 3 ++
tools/lib/bpf/bpf.h | 4 ++-
tools/lib/bpf/libbpf.c | 6 ++--
tools/lib/bpf/libbpf.h | 4 +--
.../selftests/bpf/prog_tests/bpf_iter.c | 34 ++++++++++++++-----
7 files changed, 50 insertions(+), 24 deletions(-)
diff --git a/tools/bpf/bpftool/iter.c b/tools/bpf/bpftool/iter.c
index c9dba7543dba..6e25b4236a4f 100644
--- a/tools/bpf/bpftool/iter.c
+++ b/tools/bpf/bpftool/iter.c
@@ -11,6 +11,7 @@
static int do_pin(int argc, char **argv)
{
DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, iter_opts);
+ union bpf_iter_link_info linfo;
const char *objfile, *path;
struct bpf_program *prog;
struct bpf_object *obj;
@@ -36,6 +37,10 @@ static int do_pin(int argc, char **argv)
map_fd = map_parse_fd(&argc, &argv);
if (map_fd < 0)
return -1;
+
+ memset(&linfo, 0, sizeof(linfo));
+ linfo.map.map_fd = map_fd;
+ iter_opts.link_info = &linfo;
}
}
@@ -57,9 +62,6 @@ static int do_pin(int argc, char **argv)
goto close_obj;
}
- if (map_fd >= 0)
- iter_opts.map_fd = map_fd;
-
link = bpf_program__attach_iter(prog, &iter_opts);
if (IS_ERR(link)) {
err = PTR_ERR(link);
diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h
index b134e679e9db..0480f893facd 100644
--- a/tools/include/uapi/linux/bpf.h
+++ b/tools/include/uapi/linux/bpf.h
@@ -81,6 +81,12 @@ struct bpf_cgroup_storage_key {
__u32 attach_type; /* program attach type */
};
+union bpf_iter_link_info {
+ struct {
+ __u32 map_fd;
+ } map;
+};
+
/* BPF syscall commands, see bpf(2) man-page for details. */
enum bpf_cmd {
BPF_MAP_CREATE,
@@ -249,13 +255,6 @@ enum bpf_link_type {
MAX_BPF_LINK_TYPE,
};
-enum bpf_iter_link_info {
- BPF_ITER_LINK_UNSPEC = 0,
- BPF_ITER_LINK_MAP_FD = 1,
-
- MAX_BPF_ITER_LINK_INFO,
-};
-
/* cgroup-bpf attach flags used in BPF_PROG_ATTACH command
*
* NONE(default): No further bpf programs allowed in the subtree.
@@ -623,6 +622,8 @@ union bpf_attr {
};
__u32 attach_type; /* attach type */
__u32 flags; /* extra flags */
+ __aligned_u64 iter_info; /* extra bpf_iter_link_info */
+ __u32 iter_info_len; /* iter_info length */
} link_create;
struct { /* struct used by BPF_LINK_UPDATE command */
diff --git a/tools/lib/bpf/bpf.c b/tools/lib/bpf/bpf.c
index eab14c97c15d..0750681057c2 100644
--- a/tools/lib/bpf/bpf.c
+++ b/tools/lib/bpf/bpf.c
@@ -599,6 +599,9 @@ int bpf_link_create(int prog_fd, int target_fd,
attr.link_create.target_fd = target_fd;
attr.link_create.attach_type = attach_type;
attr.link_create.flags = OPTS_GET(opts, flags, 0);
+ attr.link_create.iter_info =
+ ptr_to_u64(OPTS_GET(opts, iter_info, (void *)0));
+ attr.link_create.iter_info_len = OPTS_GET(opts, iter_info_len, 0);
return sys_bpf(BPF_LINK_CREATE, &attr, sizeof(attr));
}
diff --git a/tools/lib/bpf/bpf.h b/tools/lib/bpf/bpf.h
index 28855fd5b5f4..832c7615af80 100644
--- a/tools/lib/bpf/bpf.h
+++ b/tools/lib/bpf/bpf.h
@@ -171,8 +171,10 @@ LIBBPF_API int bpf_prog_detach2(int prog_fd, int attachable_fd,
struct bpf_link_create_opts {
size_t sz; /* size of this struct for forward/backward compatibility */
__u32 flags;
+ union bpf_iter_link_info *iter_info;
+ __u32 iter_info_len;
};
-#define bpf_link_create_opts__last_field flags
+#define bpf_link_create_opts__last_field iter_info_len
LIBBPF_API int bpf_link_create(int prog_fd, int target_fd,
enum bpf_attach_type attach_type,
diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 7be04e45d29c..22cc051d1b66 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -8306,9 +8306,9 @@ bpf_program__attach_iter(struct bpf_program *prog,
if (!OPTS_VALID(opts, bpf_iter_attach_opts))
return ERR_PTR(-EINVAL);
- if (OPTS_HAS(opts, map_fd)) {
- target_fd = opts->map_fd;
- link_create_opts.flags = BPF_ITER_LINK_MAP_FD;
+ if (OPTS_HAS(opts, link_info)) {
+ link_create_opts.iter_info = opts->link_info;
+ link_create_opts.iter_info_len = sizeof(*opts->link_info);
}
prog_fd = bpf_program__fd(prog);
diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h
index 3ed1399bfbbc..4263e2682c9d 100644
--- a/tools/lib/bpf/libbpf.h
+++ b/tools/lib/bpf/libbpf.h
@@ -267,9 +267,9 @@ LIBBPF_API struct bpf_link *bpf_map__attach_struct_ops(struct bpf_map *map);
struct bpf_iter_attach_opts {
size_t sz; /* size of this struct for forward/backward compatibility */
- __u32 map_fd;
+ union bpf_iter_link_info *link_info;
};
-#define bpf_iter_attach_opts__last_field map_fd
+#define bpf_iter_attach_opts__last_field link_info
LIBBPF_API struct bpf_link *
bpf_program__attach_iter(struct bpf_program *prog,
diff --git a/tools/testing/selftests/bpf/prog_tests/bpf_iter.c b/tools/testing/selftests/bpf/prog_tests/bpf_iter.c
index 4ffefdc1130f..cabc1f90c94b 100644
--- a/tools/testing/selftests/bpf/prog_tests/bpf_iter.c
+++ b/tools/testing/selftests/bpf/prog_tests/bpf_iter.c
@@ -468,6 +468,7 @@ static void test_bpf_hash_map(void)
DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
struct bpf_iter_bpf_hash_map *skel;
int err, i, len, map_fd, iter_fd;
+ union bpf_iter_link_info linfo;
__u64 val, expected_val = 0;
struct bpf_link *link;
struct key_t {
@@ -490,13 +491,15 @@ static void test_bpf_hash_map(void)
goto out;
/* iterator with hashmap2 and hashmap3 should fail */
- opts.map_fd = bpf_map__fd(skel->maps.hashmap2);
+ memset(&linfo, 0, sizeof(linfo));
+ linfo.map.map_fd = bpf_map__fd(skel->maps.hashmap2);
+ opts.link_info = &linfo;
link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
if (CHECK(!IS_ERR(link), "attach_iter",
"attach_iter for hashmap2 unexpected succeeded\n"))
goto out;
- opts.map_fd = bpf_map__fd(skel->maps.hashmap3);
+ linfo.map.map_fd = bpf_map__fd(skel->maps.hashmap3);
link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
if (CHECK(!IS_ERR(link), "attach_iter",
"attach_iter for hashmap3 unexpected succeeded\n"))
@@ -519,7 +522,7 @@ static void test_bpf_hash_map(void)
goto out;
}
- opts.map_fd = map_fd;
+ linfo.map.map_fd = map_fd;
link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
goto out;
@@ -562,6 +565,7 @@ static void test_bpf_percpu_hash_map(void)
DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
struct bpf_iter_bpf_percpu_hash_map *skel;
int err, i, j, len, map_fd, iter_fd;
+ union bpf_iter_link_info linfo;
__u32 expected_val = 0;
struct bpf_link *link;
struct key_t {
@@ -606,7 +610,9 @@ static void test_bpf_percpu_hash_map(void)
goto out;
}
- opts.map_fd = map_fd;
+ memset(&linfo, 0, sizeof(linfo));
+ linfo.map.map_fd = map_fd;
+ opts.link_info = &linfo;
link = bpf_program__attach_iter(skel->progs.dump_bpf_percpu_hash_map, &opts);
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
goto out;
@@ -649,6 +655,7 @@ static void test_bpf_array_map(void)
DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
__u32 expected_key = 0, res_first_key;
struct bpf_iter_bpf_array_map *skel;
+ union bpf_iter_link_info linfo;
int err, i, map_fd, iter_fd;
struct bpf_link *link;
char buf[64] = {};
@@ -673,7 +680,9 @@ static void test_bpf_array_map(void)
goto out;
}
- opts.map_fd = map_fd;
+ memset(&linfo, 0, sizeof(linfo));
+ linfo.map.map_fd = map_fd;
+ opts.link_info = &linfo;
link = bpf_program__attach_iter(skel->progs.dump_bpf_array_map, &opts);
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
goto out;
@@ -730,6 +739,7 @@ static void test_bpf_percpu_array_map(void)
DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
struct bpf_iter_bpf_percpu_array_map *skel;
__u32 expected_key = 0, expected_val = 0;
+ union bpf_iter_link_info linfo;
int err, i, j, map_fd, iter_fd;
struct bpf_link *link;
char buf[64];
@@ -765,7 +775,9 @@ static void test_bpf_percpu_array_map(void)
goto out;
}
- opts.map_fd = map_fd;
+ memset(&linfo, 0, sizeof(linfo));
+ linfo.map.map_fd = map_fd;
+ opts.link_info = &linfo;
link = bpf_program__attach_iter(skel->progs.dump_bpf_percpu_array_map, &opts);
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
goto out;
@@ -803,6 +815,7 @@ static void test_bpf_sk_storage_map(void)
DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
int err, i, len, map_fd, iter_fd, num_sockets;
struct bpf_iter_bpf_sk_storage_map *skel;
+ union bpf_iter_link_info linfo;
int sock_fd[3] = {-1, -1, -1};
__u32 val, expected_val = 0;
struct bpf_link *link;
@@ -829,7 +842,9 @@ static void test_bpf_sk_storage_map(void)
goto out;
}
- opts.map_fd = map_fd;
+ memset(&linfo, 0, sizeof(linfo));
+ linfo.map.map_fd = map_fd;
+ opts.link_info = &linfo;
link = bpf_program__attach_iter(skel->progs.dump_bpf_sk_storage_map, &opts);
if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))
goto out;
@@ -871,6 +886,7 @@ static void test_rdonly_buf_out_of_bound(void)
{
DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
struct bpf_iter_test_kern5 *skel;
+ union bpf_iter_link_info linfo;
struct bpf_link *link;
skel = bpf_iter_test_kern5__open_and_load();
@@ -878,7 +894,9 @@ static void test_rdonly_buf_out_of_bound(void)
"skeleton open_and_load failed\n"))
return;
- opts.map_fd = bpf_map__fd(skel->maps.hashmap1);
+ memset(&linfo, 0, sizeof(linfo));
+ linfo.map.map_fd = bpf_map__fd(skel->maps.hashmap1);
+ opts.link_info = &linfo;
link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &opts);
if (CHECK(!IS_ERR(link), "attach_iter", "unexpected success\n"))
bpf_link__destroy(link);
--
2.24.1
^ permalink raw reply related
* [PATCH bpf-next v2 0/2] bpf: change uapi for bpf iterator map elements
From: Yonghong Song @ 2020-08-03 7:33 UTC (permalink / raw)
To: bpf, netdev; +Cc: Alexei Starovoitov, Daniel Borkmann, kernel-team
Andrii raised a concern that current uapi for bpf iterator map
element is a little restrictive and not suitable for future potential
complex customization. This is a valid suggestion, considering people
may indeed add more complex custimization to the iterator, e.g.,
cgroup_id + user_id, etc. for task or task_file. Another example might
be map_id plus additional control so that the bpf iterator may bail
out a bucket earlier if a bucket has too many elements which may hold
lock too long and impact other parts of systems.
Patch #1 modified uapi with kernel changes. Patch #2
adjusted libbpf api accordingly.
Changelogs:
v1 -> v2:
. ensure link_create target_fd/flags == 0 since they are not used. (Andrii)
. if either of iter_info ptr == 0 or iter_info_len == 0, but not both,
return error to user space. (Andrii)
. do not reject iter_info.map.map_fd == 0, go ahead to use it trying to
get a map reference since the map_fd is required for map_elem iterator.
. use bpf_iter_link_info in bpf_iter_attach_opts instead of map_fd.
this way, user space is responsible to set up bpf_iter_link_info and
libbpf just passes the data to the kernel, simplifying libbpf design.
(Andrii)
Yonghong Song (2):
bpf: change uapi for bpf iterator map elements
tools/bpf: support new uapi for map element bpf iterator
include/linux/bpf.h | 10 ++--
include/uapi/linux/bpf.h | 15 ++---
kernel/bpf/bpf_iter.c | 58 +++++++++----------
kernel/bpf/map_iter.c | 34 ++++++++---
kernel/bpf/syscall.c | 2 +-
net/core/bpf_sk_storage.c | 34 ++++++++---
tools/bpf/bpftool/iter.c | 8 ++-
tools/include/uapi/linux/bpf.h | 15 ++---
tools/lib/bpf/bpf.c | 3 +
tools/lib/bpf/bpf.h | 4 +-
tools/lib/bpf/libbpf.c | 6 +-
tools/lib/bpf/libbpf.h | 4 +-
.../selftests/bpf/prog_tests/bpf_iter.c | 34 ++++++++---
13 files changed, 146 insertions(+), 81 deletions(-)
--
2.24.1
^ permalink raw reply
* [PATCH net v2 0/2] netfilter: conntrack: Fix CT offload timeout on heavily loaded systems
From: Roi Dayan @ 2020-08-03 7:33 UTC (permalink / raw)
To: netdev; +Cc: pablo, Paul Blakey, Oz Shlomo, Roi Dayan, Marcelo Ricardo Leitner
On heavily loaded systems the GC can take time to go over all existing
conns and reset their timeout. At that time other calls like from
nf_conntrack_in() can call of nf_ct_is_expired() and see the conn as
expired. To fix this when we set the offload bit we should also reset
the timeout instead of counting on GC to finish first iteration over
all conns before the initial timeout.
First commit is to expose the function that updates the timeout.
Second commit is to use it from flow_offload_add().
Roi Dayan (2):
netfilter: conntrack: Move nf_ct_offload_timeout to header file
netfilter: flowtable: Set offload timeout when adding flow
include/net/netfilter/nf_conntrack.h | 12 ++++++++++++
net/netfilter/nf_conntrack_core.c | 12 ------------
net/netfilter/nf_flow_table_core.c | 2 ++
3 files changed, 14 insertions(+), 12 deletions(-)
--
2.8.4
^ permalink raw reply
* [PATCH net v2 1/2] netfilter: conntrack: Move nf_ct_offload_timeout to header file
From: Roi Dayan @ 2020-08-03 7:33 UTC (permalink / raw)
To: netdev; +Cc: pablo, Paul Blakey, Oz Shlomo, Roi Dayan, Marcelo Ricardo Leitner
In-Reply-To: <20200803073305.702079-1-roid@mellanox.com>
To be used by callers from other modules.
Signed-off-by: Roi Dayan <roid@mellanox.com>
Reviewed-by: Oz Shlomo <ozsh@mellanox.com>
---
include/net/netfilter/nf_conntrack.h | 12 ++++++++++++
net/netfilter/nf_conntrack_core.c | 12 ------------
2 files changed, 12 insertions(+), 12 deletions(-)
diff --git a/include/net/netfilter/nf_conntrack.h b/include/net/netfilter/nf_conntrack.h
index 90690e37a56f..8481819ff632 100644
--- a/include/net/netfilter/nf_conntrack.h
+++ b/include/net/netfilter/nf_conntrack.h
@@ -279,6 +279,18 @@ static inline bool nf_ct_should_gc(const struct nf_conn *ct)
!nf_ct_is_dying(ct);
}
+#define DAY (86400 * HZ)
+
+/* Set an arbitrary timeout large enough not to ever expire, this save
+ * us a check for the IPS_OFFLOAD_BIT from the packet path via
+ * nf_ct_is_expired().
+ */
+static inline void nf_ct_offload_timeout(struct nf_conn *ct)
+{
+ if (nf_ct_expires(ct) < DAY / 2)
+ ct->timeout = nfct_time_stamp + DAY;
+}
+
struct kernel_param;
int nf_conntrack_set_hashsize(const char *val, const struct kernel_param *kp);
diff --git a/net/netfilter/nf_conntrack_core.c b/net/netfilter/nf_conntrack_core.c
index 79cd9dde457b..947c6d9437c3 100644
--- a/net/netfilter/nf_conntrack_core.c
+++ b/net/netfilter/nf_conntrack_core.c
@@ -1344,18 +1344,6 @@ static bool gc_worker_can_early_drop(const struct nf_conn *ct)
return false;
}
-#define DAY (86400 * HZ)
-
-/* Set an arbitrary timeout large enough not to ever expire, this save
- * us a check for the IPS_OFFLOAD_BIT from the packet path via
- * nf_ct_is_expired().
- */
-static void nf_ct_offload_timeout(struct nf_conn *ct)
-{
- if (nf_ct_expires(ct) < DAY / 2)
- ct->timeout = nfct_time_stamp + DAY;
-}
-
static void gc_worker(struct work_struct *work)
{
unsigned int min_interval = max(HZ / GC_MAX_BUCKETS_DIV, 1u);
--
2.8.4
^ permalink raw reply related
* [PATCH net v2 2/2] netfilter: flowtable: Set offload timeout when adding flow
From: Roi Dayan @ 2020-08-03 7:33 UTC (permalink / raw)
To: netdev; +Cc: pablo, Paul Blakey, Oz Shlomo, Roi Dayan, Marcelo Ricardo Leitner
In-Reply-To: <20200803073305.702079-1-roid@mellanox.com>
On heavily loaded systems the GC can take time to go over all existing
conns and reset their timeout. At that time other calls like from
nf_conntrack_in() can call of nf_ct_is_expired() and see the conn as
expired. To fix this when we set the offload bit we should also reset
the timeout instead of counting on GC to finish first iteration over
all conns before the initial timeout.
Fixes: 90964016e5d3 ("netfilter: nf_conntrack: add IPS_OFFLOAD status bit")
Signed-off-by: Roi Dayan <roid@mellanox.com>
---
Notes:
v2
- timeout fix from flow_offload_add() instead of act_ct
net/netfilter/nf_flow_table_core.c | 2 ++
1 file changed, 2 insertions(+)
diff --git a/net/netfilter/nf_flow_table_core.c b/net/netfilter/nf_flow_table_core.c
index b1eb5272b379..4f7a567c536e 100644
--- a/net/netfilter/nf_flow_table_core.c
+++ b/net/netfilter/nf_flow_table_core.c
@@ -243,6 +243,8 @@ int flow_offload_add(struct nf_flowtable *flow_table, struct flow_offload *flow)
return err;
}
+ nf_ct_offload_timeout(flow->ct);
+
if (nf_flowtable_hw_offload(flow_table)) {
__set_bit(NF_FLOW_HW, &flow->flags);
nf_flow_offload_add(flow_table, flow);
--
2.8.4
^ permalink raw reply related
* [PATCH] qmi_wwan: support modify usbnet's rx_urb_size
From: yzc666 @ 2020-08-03 6:51 UTC (permalink / raw)
To: bjorn; +Cc: davem, kuba, netdev, linux-usb, carl
From: carl <carl.yin@quectel.com>
When QMUX enabled, the 'dl-datagram-max-size' can be 4KB/16KB/31KB depend on QUALCOMM's chipsets.
User can set 'dl-datagram-max-size' by 'QMI_WDA_SET_DATA_FORMAT'.
The usbnet's rx_urb_size must lager than or equal to the 'dl-datagram-max-size'.
This patch allow user to modify usbnet's rx_urb_size by next command.
echo 4096 > /sys/class/net/wwan0/qmi/rx_urb_size
Next commnds show how to set and query 'dl-datagram-max-size' by qmicli
# qmicli -d /dev/cdc-wdm1 --wda-set-data-format="link-layer-protocol=raw-ip, ul-protocol=qmap,
dl-protocol=qmap, dl-max-datagrams=32, dl-datagram-max-size=31744, ep-type=hsusb, ep-iface-number=4"
[/dev/cdc-wdm1] Successfully set data format
QoS flow header: no
Link layer protocol: 'raw-ip'
Uplink data aggregation protocol: 'qmap'
Downlink data aggregation protocol: 'qmap'
NDP signature: '0'
Downlink data aggregation max datagrams: '10'
Downlink data aggregation max size: '4096'
# qmicli -d /dev/cdc-wdm1 --wda-get-data-format
[/dev/cdc-wdm1] Successfully got data format
QoS flow header: no
Link layer protocol: 'raw-ip'
Uplink data aggregation protocol: 'qmap'
Downlink data aggregation protocol: 'qmap'
NDP signature: '0'
Downlink data aggregation max datagrams: '10'
Downlink data aggregation max size: '4096'
Signed-off-by: carl <carl.yin@quectel.com>
---
drivers/net/usb/qmi_wwan.c | 39 ++++++++++++++++++++++++++++++++++++++
1 file changed, 39 insertions(+)
diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c
index 07c42c0719f5b..8ea57fd99ae43 100644
--- a/drivers/net/usb/qmi_wwan.c
+++ b/drivers/net/usb/qmi_wwan.c
@@ -400,6 +400,44 @@ static ssize_t raw_ip_store(struct device *d, struct device_attribute *attr, co
return ret;
}
+static ssize_t rx_urb_size_show(struct device *d, struct device_attribute *attr, char *buf)
+{
+ struct usbnet *dev = netdev_priv(to_net_dev(d));
+
+ return sprintf(buf, "%zd\n", dev->rx_urb_size);
+}
+
+static ssize_t rx_urb_size_store(struct device *d, struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ struct usbnet *dev = netdev_priv(to_net_dev(d));
+ u32 rx_urb_size;
+ int ret;
+
+ if (kstrtou32(buf, 0, &rx_urb_size))
+ return -EINVAL;
+
+ /* no change? */
+ if (rx_urb_size == dev->rx_urb_size)
+ return len;
+
+ if (!rtnl_trylock())
+ return restart_syscall();
+
+ /* we don't want to modify a running netdev */
+ if (netif_running(dev->net)) {
+ netdev_err(dev->net, "Cannot change a running device\n");
+ ret = -EBUSY;
+ goto err;
+ }
+
+ dev->rx_urb_size = rx_urb_size;
+ ret = len;
+err:
+ rtnl_unlock();
+ return ret;
+}
+
static ssize_t add_mux_show(struct device *d, struct device_attribute *attr, char *buf)
{
struct net_device *dev = to_net_dev(d);
@@ -505,6 +543,7 @@ static DEVICE_ATTR_RW(add_mux);
static DEVICE_ATTR_RW(del_mux);
static struct attribute *qmi_wwan_sysfs_attrs[] = {
+ &dev_attr_rx_urb_size.attr,
&dev_attr_raw_ip.attr,
&dev_attr_add_mux.attr,
&dev_attr_del_mux.attr,
--
2.17.1
^ permalink raw reply related
* Re: [PATCH net 2/2] net/sched: act_ct: Set offload timeout when setting the offload bit
From: Roi Dayan @ 2020-08-03 7:21 UTC (permalink / raw)
To: Marcelo Ricardo Leitner; +Cc: netdev, pablo, Paul Blakey, Oz Shlomo
In-Reply-To: <20200729171044.GI3307@localhost.localdomain>
On 2020-07-29 8:10 PM, Marcelo Ricardo Leitner wrote:
> On Wed, Jul 29, 2020 at 03:55:53PM +0300, Roi Dayan wrote:
>>
>>
>> On 2020-07-28 5:42 PM, Marcelo Ricardo Leitner wrote:
>>> On Tue, Jul 28, 2020 at 02:57:59PM +0300, Roi Dayan wrote:
>>>> On heavily loaded systems the GC can take time to go over all existing
>>>> conns and reset their timeout. At that time other calls like from
>>>> nf_conntrack_in() can call of nf_ct_is_expired() and see the conn as
>>>> expired. To fix this when we set the offload bit we should also reset
>>>> the timeout instead of counting on GC to finish first iteration over
>>>> all conns before the initial timeout.
>>>>
>>>> Fixes: 64ff70b80fd4 ("net/sched: act_ct: Offload established connections to flow table")
>>>> Signed-off-by: Roi Dayan <roid@mellanox.com>
>>>> Reviewed-by: Oz Shlomo <ozsh@mellanox.com>
>>>> ---
>>>> net/sched/act_ct.c | 2 ++
>>>> 1 file changed, 2 insertions(+)
>>>>
>>>> diff --git a/net/sched/act_ct.c b/net/sched/act_ct.c
>>>> index e9f3576cbf71..650c2d78a346 100644
>>>> --- a/net/sched/act_ct.c
>>>> +++ b/net/sched/act_ct.c
>>>> @@ -366,6 +366,8 @@ static void tcf_ct_flow_table_add(struct tcf_ct_flow_table *ct_ft,
>>>
>>> Extra context line:
>>> err = flow_offload_add(&ct_ft->nf_ft, entry);
>>>> if (err)
>>>> goto err_add;
>>>>
>>>> + nf_ct_offload_timeout(ct);
>>>> +
>>>
>>> What about adding this to flow_offload_add() instead?
>>> It is already adjusting the flow_offload timeout there and then it
>>> also effective for nft.
>>>
>>
>> As you said, in flow_offload_add() we adjust the flow timeout.
>> Here we adjust the conn timeout.
>> So it's outside flow_offload_add() which only touch the flow struct.
>> I guess it's like conn offload bit is set outside here and for nft.
>
> Right, but
>
>> What do you think?
>
> I don't see why it can't update both. flow_offload_fixup_ct_timeout(),
> called by flow_offload_del(), is updating ct->timeout already. It
> looks consistent to me to update it in _add as well then.
>
I don't mind. just add is not consistent with del.
del also clears the ips_offload_bit but add doesn't add it.
i'll send v2 with your suggestion.
>>
>>>> return;
>>>>
>>>> err_add:
>>>> --
>>>> 2.8.4
>>>>
^ permalink raw reply
* [PATCH net v3 3/5] fsl/fman: fix unreachable code
From: Florinel Iordache @ 2020-08-03 7:07 UTC (permalink / raw)
To: madalin.bucur, davem, kuba, netdev; +Cc: linux-kernel, Florinel Iordache
In-Reply-To: <1596438454-4895-1-git-send-email-florinel.iordache@nxp.com>
The parameter 'priority' is incorrectly forced to zero which ultimately
induces logically dead code in the subsequent lines.
Fixes: 57ba4c9b56d8 ("fsl/fman: Add FMan MAC support")
Signed-off-by: Florinel Iordache <florinel.iordache@nxp.com>
---
drivers/net/ethernet/freescale/fman/fman_memac.c | 1 -
1 file changed, 1 deletion(-)
diff --git a/drivers/net/ethernet/freescale/fman/fman_memac.c b/drivers/net/ethernet/freescale/fman/fman_memac.c
index a5500ed..bb02b37 100644
--- a/drivers/net/ethernet/freescale/fman/fman_memac.c
+++ b/drivers/net/ethernet/freescale/fman/fman_memac.c
@@ -852,7 +852,6 @@ int memac_set_tx_pause_frames(struct fman_mac *memac, u8 priority,
tmp = ioread32be(®s->command_config);
tmp &= ~CMD_CFG_PFC_MODE;
- priority = 0;
iowrite32be(tmp, ®s->command_config);
--
1.9.1
^ permalink raw reply related
* [PATCH net v3 2/5] fsl/fman: fix dereference null return value
From: Florinel Iordache @ 2020-08-03 7:07 UTC (permalink / raw)
To: madalin.bucur, davem, kuba, netdev; +Cc: linux-kernel, Florinel Iordache
In-Reply-To: <1596438454-4895-1-git-send-email-florinel.iordache@nxp.com>
Check before using returned value to avoid dereferencing null pointer.
Fixes: 18a6c85fcc78 ("fsl/fman: Add FMan Port Support")
Signed-off-by: Florinel Iordache <florinel.iordache@nxp.com>
---
drivers/net/ethernet/freescale/fman/fman_port.c | 9 ++++++++-
1 file changed, 8 insertions(+), 1 deletion(-)
diff --git a/drivers/net/ethernet/freescale/fman/fman_port.c b/drivers/net/ethernet/freescale/fman/fman_port.c
index 87b26f0..c27df15 100644
--- a/drivers/net/ethernet/freescale/fman/fman_port.c
+++ b/drivers/net/ethernet/freescale/fman/fman_port.c
@@ -1767,6 +1767,7 @@ static int fman_port_probe(struct platform_device *of_dev)
struct fman_port *port;
struct fman *fman;
struct device_node *fm_node, *port_node;
+ struct platform_device *fm_pdev;
struct resource res;
struct resource *dev_res;
u32 val;
@@ -1791,8 +1792,14 @@ static int fman_port_probe(struct platform_device *of_dev)
goto return_err;
}
- fman = dev_get_drvdata(&of_find_device_by_node(fm_node)->dev);
+ fm_pdev = of_find_device_by_node(fm_node);
of_node_put(fm_node);
+ if (!fm_pdev) {
+ err = -EINVAL;
+ goto return_err;
+ }
+
+ fman = dev_get_drvdata(&fm_pdev->dev);
if (!fman) {
err = -EINVAL;
goto return_err;
--
1.9.1
^ permalink raw reply related
* [PATCH net v3 1/5] fsl/fman: use 32-bit unsigned integer
From: Florinel Iordache @ 2020-08-03 7:07 UTC (permalink / raw)
To: madalin.bucur, davem, kuba, netdev; +Cc: linux-kernel, Florinel Iordache
In-Reply-To: <1596438454-4895-1-git-send-email-florinel.iordache@nxp.com>
Potentially overflowing expression (ts_freq << 16 and intgr << 16)
declared as type u32 (32-bit unsigned) is evaluated using 32-bit
arithmetic and then used in a context that expects an expression of
type u64 (64-bit unsigned) which ultimately is used as 16-bit
unsigned by typecasting to u16. Fixed by using an unsigned 32-bit
integer since the value is truncated anyway in the end.
Fixes: 414fd46e7762 ("fsl/fman: Add FMan support")
Signed-off-by: Florinel Iordache <florinel.iordache@nxp.com>
---
drivers/net/ethernet/freescale/fman/fman.c | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/drivers/net/ethernet/freescale/fman/fman.c b/drivers/net/ethernet/freescale/fman/fman.c
index f151d6e..ef67e85 100644
--- a/drivers/net/ethernet/freescale/fman/fman.c
+++ b/drivers/net/ethernet/freescale/fman/fman.c
@@ -1398,8 +1398,7 @@ static void enable_time_stamp(struct fman *fman)
{
struct fman_fpm_regs __iomem *fpm_rg = fman->fpm_regs;
u16 fm_clk_freq = fman->state->fm_clk_freq;
- u32 tmp, intgr, ts_freq;
- u64 frac;
+ u32 tmp, intgr, ts_freq, frac;
ts_freq = (u32)(1 << fman->state->count1_micro_bit);
/* configure timestamp so that bit 8 will count 1 microsecond
--
1.9.1
^ permalink raw reply related
* [PATCH net v3 5/5] fsl/fman: fix eth hash table allocation
From: Florinel Iordache @ 2020-08-03 7:07 UTC (permalink / raw)
To: madalin.bucur, davem, kuba, netdev; +Cc: linux-kernel, Florinel Iordache
In-Reply-To: <1596438454-4895-1-git-send-email-florinel.iordache@nxp.com>
Fix memory allocation for ethernet address hash table.
The code was wrongly allocating an array for eth hash table which
is incorrect because this is the main structure for eth hash table
(struct eth_hash_t) that contains inside a number of elements.
Fixes: 57ba4c9b56d8 ("fsl/fman: Add FMan MAC support")
Signed-off-by: Florinel Iordache <florinel.iordache@nxp.com>
---
drivers/net/ethernet/freescale/fman/fman_mac.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/net/ethernet/freescale/fman/fman_mac.h b/drivers/net/ethernet/freescale/fman/fman_mac.h
index dd6d052..19f327e 100644
--- a/drivers/net/ethernet/freescale/fman/fman_mac.h
+++ b/drivers/net/ethernet/freescale/fman/fman_mac.h
@@ -252,7 +252,7 @@ static inline struct eth_hash_t *alloc_hash_table(u16 size)
struct eth_hash_t *hash;
/* Allocate address hash table */
- hash = kmalloc_array(size, sizeof(struct eth_hash_t *), GFP_KERNEL);
+ hash = kmalloc(sizeof(*hash), GFP_KERNEL);
if (!hash)
return NULL;
--
1.9.1
^ permalink raw reply related
* [PATCH net v3 4/5] fsl/fman: check dereferencing null pointer
From: Florinel Iordache @ 2020-08-03 7:07 UTC (permalink / raw)
To: madalin.bucur, davem, kuba, netdev; +Cc: linux-kernel, Florinel Iordache
In-Reply-To: <1596438454-4895-1-git-send-email-florinel.iordache@nxp.com>
Add a safe check to avoid dereferencing null pointer
Fixes: 57ba4c9b56d8 ("fsl/fman: Add FMan MAC support")
Signed-off-by: Florinel Iordache <florinel.iordache@nxp.com>
---
drivers/net/ethernet/freescale/fman/fman_dtsec.c | 4 ++--
drivers/net/ethernet/freescale/fman/fman_memac.c | 2 +-
drivers/net/ethernet/freescale/fman/fman_tgec.c | 2 +-
3 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/drivers/net/ethernet/freescale/fman/fman_dtsec.c b/drivers/net/ethernet/freescale/fman/fman_dtsec.c
index 004c266..bce3c93 100644
--- a/drivers/net/ethernet/freescale/fman/fman_dtsec.c
+++ b/drivers/net/ethernet/freescale/fman/fman_dtsec.c
@@ -1200,7 +1200,7 @@ int dtsec_del_hash_mac_address(struct fman_mac *dtsec, enet_addr_t *eth_addr)
list_for_each(pos,
&dtsec->multicast_addr_hash->lsts[bucket]) {
hash_entry = ETH_HASH_ENTRY_OBJ(pos);
- if (hash_entry->addr == addr) {
+ if (hash_entry && hash_entry->addr == addr) {
list_del_init(&hash_entry->node);
kfree(hash_entry);
break;
@@ -1213,7 +1213,7 @@ int dtsec_del_hash_mac_address(struct fman_mac *dtsec, enet_addr_t *eth_addr)
list_for_each(pos,
&dtsec->unicast_addr_hash->lsts[bucket]) {
hash_entry = ETH_HASH_ENTRY_OBJ(pos);
- if (hash_entry->addr == addr) {
+ if (hash_entry && hash_entry->addr == addr) {
list_del_init(&hash_entry->node);
kfree(hash_entry);
break;
diff --git a/drivers/net/ethernet/freescale/fman/fman_memac.c b/drivers/net/ethernet/freescale/fman/fman_memac.c
index bb02b37..645764a 100644
--- a/drivers/net/ethernet/freescale/fman/fman_memac.c
+++ b/drivers/net/ethernet/freescale/fman/fman_memac.c
@@ -981,7 +981,7 @@ int memac_del_hash_mac_address(struct fman_mac *memac, enet_addr_t *eth_addr)
list_for_each(pos, &memac->multicast_addr_hash->lsts[hash]) {
hash_entry = ETH_HASH_ENTRY_OBJ(pos);
- if (hash_entry->addr == addr) {
+ if (hash_entry && hash_entry->addr == addr) {
list_del_init(&hash_entry->node);
kfree(hash_entry);
break;
diff --git a/drivers/net/ethernet/freescale/fman/fman_tgec.c b/drivers/net/ethernet/freescale/fman/fman_tgec.c
index 8c7eb87..41946b1 100644
--- a/drivers/net/ethernet/freescale/fman/fman_tgec.c
+++ b/drivers/net/ethernet/freescale/fman/fman_tgec.c
@@ -626,7 +626,7 @@ int tgec_del_hash_mac_address(struct fman_mac *tgec, enet_addr_t *eth_addr)
list_for_each(pos, &tgec->multicast_addr_hash->lsts[hash]) {
hash_entry = ETH_HASH_ENTRY_OBJ(pos);
- if (hash_entry->addr == addr) {
+ if (hash_entry && hash_entry->addr == addr) {
list_del_init(&hash_entry->node);
kfree(hash_entry);
break;
--
1.9.1
^ permalink raw reply related
* [PATCH net v3 0/5] DPAA FMan driver fixes
From: Florinel Iordache @ 2020-08-03 7:07 UTC (permalink / raw)
To: madalin.bucur, davem, kuba, netdev; +Cc: linux-kernel, Florinel Iordache
Here are several fixes for the DPAA FMan driver.
v2 changes:
* corrected patch 4 by removing the line added by mistake
* used longer fixes tags with the first 12 characters of the SHA-1 ID
v3 changes:
* remove the empty line inserted after fixes tag
Florinel Iordache (5):
fsl/fman: use 32-bit unsigned integer
fsl/fman: fix dereference null return value
fsl/fman: fix unreachable code
fsl/fman: check dereferencing null pointer
fsl/fman: fix eth hash table allocation
drivers/net/ethernet/freescale/fman/fman.c | 3 +--
drivers/net/ethernet/freescale/fman/fman_dtsec.c | 4 ++--
drivers/net/ethernet/freescale/fman/fman_mac.h | 2 +-
drivers/net/ethernet/freescale/fman/fman_memac.c | 3 +--
drivers/net/ethernet/freescale/fman/fman_port.c | 9 ++++++++-
drivers/net/ethernet/freescale/fman/fman_tgec.c | 2 +-
6 files changed, 14 insertions(+), 9 deletions(-)
--
1.9.1
^ permalink raw reply
* Re: [RFC PATCH 00/17] Drop uses of pci_read_config_*() return value
From: Christoph Hellwig @ 2020-08-03 6:56 UTC (permalink / raw)
To: Bjorn Helgaas
Cc: Borislav Petkov, Saheed Bolarinwa, trix, Kalle Valo,
David S. Miller, Jakub Kicinski, Wolfgang Grandegger,
Marc Kleine-Budde, Miquel Raynal, Richard Weinberger,
Vignesh Raghavendra, Joerg Roedel, bjorn, skhan,
linux-kernel-mentees, linux-pci, linux-kernel, linux-wireless,
netdev, linux-mtd, iommu, linux-rdma, linux-ide, linux-i2c,
linux-hwmon, dri-devel, intel-gfx, linux-gpio, linux-fpga,
linux-edac, dmaengine, linux-crypto, linux-atm-general
In-Reply-To: <20200802191406.GA248232@bjorn-Precision-5520>
On Sun, Aug 02, 2020 at 02:14:06PM -0500, Bjorn Helgaas wrote:
> But what guarantees that a PCI config register cannot contain ~0?
> If there's something about that in the spec I'd love to know where it
> is because it would simplify a lot of things.
There isn't. An we even have cases like the NVMe controller memory
buffer and persistent memory region, which are BARs that store
abritrary values for later retreival, so it can't. (now those
features have a major issue with error detection, but that is another
issue)
^ permalink raw reply
* Re: [PATCH bpf-next 1/2] bpf: change uapi for bpf iterator map elements
From: Yonghong Song @ 2020-08-03 6:21 UTC (permalink / raw)
To: Andrii Nakryiko
Cc: bpf, Networking, Alexei Starovoitov, Daniel Borkmann, Kernel Team
In-Reply-To: <CAEf4Bzbr--=tbmLqrgbtA4ERy8KmCYvBDfP5PciXx9x3yWpmsQ@mail.gmail.com>
On 8/2/20 10:11 PM, Andrii Nakryiko wrote:
> On Sun, Aug 2, 2020 at 7:23 PM Yonghong Song <yhs@fb.com> wrote:
>>
>>
>>
>> On 8/2/20 6:25 PM, Andrii Nakryiko wrote:
>>> On Sat, Aug 1, 2020 at 9:22 PM Yonghong Song <yhs@fb.com> wrote:
>>>>
>>>> Commit a5cbe05a6673 ("bpf: Implement bpf iterator for
>>>> map elements") added bpf iterator support for
>>>> map elements. The map element bpf iterator requires
>>>> info to identify a particular map. In the above
>>>> commit, the attr->link_create.target_fd is used
>>>> to carry map_fd and an enum bpf_iter_link_info
>>>> is added to uapi to specify the target_fd actually
>>>> representing a map_fd:
>>>> enum bpf_iter_link_info {
>>>> BPF_ITER_LINK_UNSPEC = 0,
>>>> BPF_ITER_LINK_MAP_FD = 1,
>>>>
>>>> MAX_BPF_ITER_LINK_INFO,
>>>> };
>>>>
>>>> This is an extensible approach as we can grow
>>>> enumerator for pid, cgroup_id, etc. and we can
>>>> unionize target_fd for pid, cgroup_id, etc.
>>>> But in the future, there are chances that
>>>> more complex customization may happen, e.g.,
>>>> for tasks, it could be filtered based on
>>>> both cgroup_id and user_id.
>>>>
>>>> This patch changed the uapi to have fields
>>>> __aligned_u64 iter_info;
>>>> __u32 iter_info_len;
>>>> for additional iter_info for link_create.
>>>> The iter_info is defined as
>>>> union bpf_iter_link_info {
>>>> struct {
>>>> __u32 map_fd;
>>>> } map;
>>>> };
>>>>
>>>> So future extension for additional customization
>>>> will be easier. The bpf_iter_link_info will be
>>>> passed to target callback to validate and generic
>>>> bpf_iter framework does not need to deal it any
>>>> more.
>>>>
>>>> Signed-off-by: Yonghong Song <yhs@fb.com>
>>>> ---
>>>> include/linux/bpf.h | 10 ++++---
>>>> include/uapi/linux/bpf.h | 15 +++++-----
>>>> kernel/bpf/bpf_iter.c | 52 +++++++++++++++-------------------
>>>> kernel/bpf/map_iter.c | 37 ++++++++++++++++++------
>>>> kernel/bpf/syscall.c | 2 +-
>>>> net/core/bpf_sk_storage.c | 37 ++++++++++++++++++------
>>>> tools/include/uapi/linux/bpf.h | 15 +++++-----
>>>> 7 files changed, 104 insertions(+), 64 deletions(-)
>>>>
>>>
>>> [...]
>>>
>>>> int bpf_iter_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)
>>>> {
>>>> + union bpf_iter_link_info __user *ulinfo;
>>>> struct bpf_link_primer link_primer;
>>>> struct bpf_iter_target_info *tinfo;
>>>> - struct bpf_iter_aux_info aux = {};
>>>> + union bpf_iter_link_info linfo;
>>>> struct bpf_iter_link *link;
>>>> - u32 prog_btf_id, target_fd;
>>>> + u32 prog_btf_id, linfo_len;
>>>> bool existed = false;
>>>> - struct bpf_map *map;
>>>> int err;
>>>>
>>>> + memset(&linfo, 0, sizeof(union bpf_iter_link_info));
>>>> +
>>>> + ulinfo = u64_to_user_ptr(attr->link_create.iter_info);
>>>> + linfo_len = attr->link_create.iter_info_len;
>>>> + if (ulinfo && linfo_len) {
>>>
>>> We probably want to be more strict here: if either pointer or len is
>>> non-zero, both should be present and valid. Otherwise we can have
>>> garbage in iter_info, as long as iter_info_len is zero.
>>
>> yes, it is possible iter_info_len = 0 and iter_info is not null and
>> if this happens, iter_info will not be examined.
>>
>> in kernel, we have places this is handled similarly. For example,
>> for cgroup bpf_prog query.
>>
>> kernel/bpf/cgroup.c, function __cgroup_bpf_query
>>
>> __u32 __user *prog_ids = u64_to_user_ptr(attr->query.prog_ids);
>> ...
>> if (attr->query.prog_cnt == 0 || !prog_ids || !cnt)
>> return 0;
>>
>> In the above case, it is possible prog_cnt = 0 and prog_ids != NULL,
>> or prog_ids == NULL and prog_cnt != 0, and we won't return error
>> to user space.
>>
>> Not 100% sure whether we have convention here or not.
>
> I don't know either, but I'd assume that we didn't think about 100%
> strictness when originally implementing this. So I'd go with a very
> strict check for this new functionality.
Agreed. This should be fine as the functionality is new.
>
>>
>>>
>>>> + err = bpf_check_uarg_tail_zero(ulinfo, sizeof(linfo),
>>>> + linfo_len);
>>>> + if (err)
>>>> + return err;
>>>> + linfo_len = min_t(u32, linfo_len, sizeof(linfo));
>>>> + if (copy_from_user(&linfo, ulinfo, linfo_len))
>>>> + return -EFAULT;
>>>> + }
>>>> +
>>>> prog_btf_id = prog->aux->attach_btf_id;
>>>> mutex_lock(&targets_mutex);
>>>> list_for_each_entry(tinfo, &targets, list) {
>>>> @@ -411,13 +425,6 @@ int bpf_iter_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)
>>>> if (!existed)
>>>> return -ENOENT;
>>>>
>>>> - /* Make sure user supplied flags are target expected. */
>>>> - target_fd = attr->link_create.target_fd;
>>>> - if (attr->link_create.flags != tinfo->reg_info->req_linfo)
>>>> - return -EINVAL;
>>>> - if (!attr->link_create.flags && target_fd)
>>>> - return -EINVAL;
>>>> -
>>>
>>> Please still ensure that no flags are specified.
>>
>> Make sense. I also need to ensure target_fd is 0 since it is not used
>> any more.
>>
>
> yep, good catch
>
>>>
>>>
>>>> link = kzalloc(sizeof(*link), GFP_USER | __GFP_NOWARN);
>>>> if (!link)
>>>> return -ENOMEM;
[...]
^ permalink raw reply
* RE: [PATCH] ieee802154/adf7242: check status of adf7242_read_reg
From: Hennerich, Michael @ 2020-08-03 6:20 UTC (permalink / raw)
To: trix@redhat.com, alex.aring@gmail.com, stefan@datenfreihafen.org,
davem@davemloft.net, kuba@kernel.org, marcel@holtmann.org
Cc: linux-wpan@vger.kernel.org, netdev@vger.kernel.org,
linux-kernel@vger.kernel.org
In-Reply-To: <20200802142339.21091-1-trix@redhat.com>
> -----Original Message-----
> From: trix@redhat.com <trix@redhat.com>
> Sent: Sonntag, 2. August 2020 16:24
> To: Hennerich, Michael <Michael.Hennerich@analog.com>;
> alex.aring@gmail.com; stefan@datenfreihafen.org; davem@davemloft.net;
> kuba@kernel.org; marcel@holtmann.org
> Cc: linux-wpan@vger.kernel.org; netdev@vger.kernel.org; linux-
> kernel@vger.kernel.org; Tom Rix <trix@redhat.com>
> Subject: [PATCH] ieee802154/adf7242: check status of adf7242_read_reg
>
>
> From: Tom Rix <trix@redhat.com>
>
> Clang static analysis reports this error
>
> adf7242.c:887:6: warning: Assigned value is garbage or undefined
> len = len_u8;
> ^ ~~~~~~
>
> len_u8 is set in
> adf7242_read_reg(lp, 0, &len_u8);
>
> When this call fails, len_u8 is not set.
>
> So check the return code.
>
> Fixes: 7302b9d90117 ("ieee802154/adf7242: Driver for ADF7242 MAC
> IEEE802154")
>
> Signed-off-by: Tom Rix <trix@redhat.com>
Acked-by: Michael Hennerich <michael.hennerich@analog.com>
> ---
> drivers/net/ieee802154/adf7242.c | 4 +++-
> 1 file changed, 3 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/net/ieee802154/adf7242.c
> b/drivers/net/ieee802154/adf7242.c
> index c11f32f644db..7db9cbd0f5de 100644
> --- a/drivers/net/ieee802154/adf7242.c
> +++ b/drivers/net/ieee802154/adf7242.c
> @@ -882,7 +882,9 @@ static int adf7242_rx(struct adf7242_local *lp)
> int ret;
> u8 lqi, len_u8, *data;
>
> - adf7242_read_reg(lp, 0, &len_u8);
> + ret = adf7242_read_reg(lp, 0, &len_u8);
> + if (ret)
> + return ret;
>
> len = len_u8;
>
> --
> 2.18.1
^ permalink raw reply
* Re: [PATCH] kprobes: fix NULL pointer dereference at kprobe_ftrace_handler
From: Song Liu @ 2020-08-03 6:01 UTC (permalink / raw)
To: Muchun Song
Cc: naveen.n.rao@linux.ibm.com, anil.s.keshavamurthy@intel.com,
davem@davemloft.net, mhiramat@kernel.org, ast@kernel.org,
daniel@iogearbox.net, Martin Lau, Yonghong Song, Andrii Nakryiko,
john.fastabend@gmail.com, kpsingh@chromium.org,
linux-kernel@vger.kernel.org, netdev@vger.kernel.org,
bpf@vger.kernel.org, Chengming Zhou
In-Reply-To: <20200728064536.24405-1-songmuchun@bytedance.com>
> On Jul 27, 2020, at 11:45 PM, Muchun Song <songmuchun@bytedance.com> wrote:
>
> We found a case of kernel panic on our server. The stack trace is as
> follows(omit some irrelevant information):
>
> BUG: kernel NULL pointer dereference, address: 0000000000000080
> RIP: 0010:kprobe_ftrace_handler+0x5e/0xe0
> RSP: 0018:ffffb512c6550998 EFLAGS: 00010282
> RAX: 0000000000000000 RBX: ffff8e9d16eea018 RCX: 0000000000000000
> RDX: ffffffffbe1179c0 RSI: ffffffffc0535564 RDI: ffffffffc0534ec0
> RBP: ffffffffc0534ec1 R08: ffff8e9d1bbb0f00 R09: 0000000000000004
> R10: 0000000000000000 R11: 0000000000000000 R12: 0000000000000000
> R13: ffff8e9d1f797060 R14: 000000000000bacc R15: ffff8e9ce13eca00
> CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
> CR2: 0000000000000080 CR3: 00000008453d0005 CR4: 00000000003606e0
> DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
> DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
> Call Trace:
> <IRQ>
> ftrace_ops_assist_func+0x56/0xe0
> ftrace_call+0x5/0x34
> tcpa_statistic_send+0x5/0x130 [ttcp_engine]
>
> The tcpa_statistic_send is the function being kprobed. After analysis,
> the root cause is that the fourth parameter regs of kprobe_ftrace_handler
> is NULL. Why regs is NULL? We use the crash tool to analyze the kdump.
>
> crash> dis tcpa_statistic_send -r
> <tcpa_statistic_send>: callq 0xffffffffbd8018c0 <ftrace_caller>
>
> The tcpa_statistic_send calls ftrace_caller instead of ftrace_regs_caller.
> So it is reasonable that the fourth parameter regs of kprobe_ftrace_handler
> is NULL. In theory, we should call the ftrace_regs_caller instead of the
> ftrace_caller. After in-depth analysis, we found a reproducible path.
>
> Writing a simple kernel module which starts a periodic timer. The
> timer's handler is named 'kprobe_test_timer_handler'. The module
> name is kprobe_test.ko.
>
> 1) insmod kprobe_test.ko
> 2) bpftrace -e 'kretprobe:kprobe_test_timer_handler {}'
> 3) echo 0 > /proc/sys/kernel/ftrace_enabled
> 4) rmmod kprobe_test
> 5) stop step 2) kprobe
> 6) insmod kprobe_test.ko
> 7) bpftrace -e 'kretprobe:kprobe_test_timer_handler {}'
>
> We mark the kprobe as GONE but not disarm the kprobe in the step 4).
> The step 5) also do not disarm the kprobe when unregister kprobe. So
> we do not remove the ip from the filter. In this case, when the module
> loads again in the step 6), we will replace the code to ftrace_caller
> via the ftrace_module_enable(). When we register kprobe again, we will
> not replace ftrace_caller to ftrace_regs_caller because the ftrace is
> disabled in the step 3). So the step 7) will trigger kernel panic. Fix
> this problem by disarming the kprobe when the module is going away.
>
> Signed-off-by: Muchun Song <songmuchun@bytedance.com>
> Co-developed-by: Chengming Zhou <zhouchengming@bytedance.com>
> Signed-off-by: Chengming Zhou <zhouchengming@bytedance.com>
Looks good.
Acked-by: Song Liu <songliubraving@fb.com>
> ---
> kernel/kprobes.c | 7 +++++++
> 1 file changed, 7 insertions(+)
>
> diff --git a/kernel/kprobes.c b/kernel/kprobes.c
> index 146c648eb943..503add629599 100644
> --- a/kernel/kprobes.c
> +++ b/kernel/kprobes.c
> @@ -2148,6 +2148,13 @@ static void kill_kprobe(struct kprobe *p)
> * the original probed function (which will be freed soon) any more.
> */
> arch_remove_kprobe(p);
> +
> + /*
> + * The module is going away. We should disarm the kprobe which
> + * is using ftrace.
> + */
> + if (kprobe_ftrace(p))
> + disarm_kprobe_ftrace(p);
> }
>
> /* Disable one kprobe */
> --
> 2.11.0
>
^ permalink raw reply
* Re: [PATCH] kprobes: fix NULL pointer dereference at kprobe_ftrace_handler
From: Muchun Song @ 2020-08-03 5:46 UTC (permalink / raw)
To: naveen.n.rao, anil.s.keshavamurthy, davem, mhiramat, ast, daniel,
kafai, songliubraving, yhs, andriin, john.fastabend, kpsingh
Cc: LKML, netdev, bpf, Chengming Zhou
In-Reply-To: <20200728064536.24405-1-songmuchun@bytedance.com>
Ping guys. Any comments or suggestions?
On Tue, Jul 28, 2020 at 2:45 PM Muchun Song <songmuchun@bytedance.com> wrote:
>
> We found a case of kernel panic on our server. The stack trace is as
> follows(omit some irrelevant information):
>
> BUG: kernel NULL pointer dereference, address: 0000000000000080
> RIP: 0010:kprobe_ftrace_handler+0x5e/0xe0
> RSP: 0018:ffffb512c6550998 EFLAGS: 00010282
> RAX: 0000000000000000 RBX: ffff8e9d16eea018 RCX: 0000000000000000
> RDX: ffffffffbe1179c0 RSI: ffffffffc0535564 RDI: ffffffffc0534ec0
> RBP: ffffffffc0534ec1 R08: ffff8e9d1bbb0f00 R09: 0000000000000004
> R10: 0000000000000000 R11: 0000000000000000 R12: 0000000000000000
> R13: ffff8e9d1f797060 R14: 000000000000bacc R15: ffff8e9ce13eca00
> CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
> CR2: 0000000000000080 CR3: 00000008453d0005 CR4: 00000000003606e0
> DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
> DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
> Call Trace:
> <IRQ>
> ftrace_ops_assist_func+0x56/0xe0
> ftrace_call+0x5/0x34
> tcpa_statistic_send+0x5/0x130 [ttcp_engine]
>
> The tcpa_statistic_send is the function being kprobed. After analysis,
> the root cause is that the fourth parameter regs of kprobe_ftrace_handler
> is NULL. Why regs is NULL? We use the crash tool to analyze the kdump.
>
> crash> dis tcpa_statistic_send -r
> <tcpa_statistic_send>: callq 0xffffffffbd8018c0 <ftrace_caller>
>
> The tcpa_statistic_send calls ftrace_caller instead of ftrace_regs_caller.
> So it is reasonable that the fourth parameter regs of kprobe_ftrace_handler
> is NULL. In theory, we should call the ftrace_regs_caller instead of the
> ftrace_caller. After in-depth analysis, we found a reproducible path.
>
> Writing a simple kernel module which starts a periodic timer. The
> timer's handler is named 'kprobe_test_timer_handler'. The module
> name is kprobe_test.ko.
>
> 1) insmod kprobe_test.ko
> 2) bpftrace -e 'kretprobe:kprobe_test_timer_handler {}'
> 3) echo 0 > /proc/sys/kernel/ftrace_enabled
> 4) rmmod kprobe_test
> 5) stop step 2) kprobe
> 6) insmod kprobe_test.ko
> 7) bpftrace -e 'kretprobe:kprobe_test_timer_handler {}'
>
> We mark the kprobe as GONE but not disarm the kprobe in the step 4).
> The step 5) also do not disarm the kprobe when unregister kprobe. So
> we do not remove the ip from the filter. In this case, when the module
> loads again in the step 6), we will replace the code to ftrace_caller
> via the ftrace_module_enable(). When we register kprobe again, we will
> not replace ftrace_caller to ftrace_regs_caller because the ftrace is
> disabled in the step 3). So the step 7) will trigger kernel panic. Fix
> this problem by disarming the kprobe when the module is going away.
>
> Signed-off-by: Muchun Song <songmuchun@bytedance.com>
> Co-developed-by: Chengming Zhou <zhouchengming@bytedance.com>
> Signed-off-by: Chengming Zhou <zhouchengming@bytedance.com>
> ---
> kernel/kprobes.c | 7 +++++++
> 1 file changed, 7 insertions(+)
>
> diff --git a/kernel/kprobes.c b/kernel/kprobes.c
> index 146c648eb943..503add629599 100644
> --- a/kernel/kprobes.c
> +++ b/kernel/kprobes.c
> @@ -2148,6 +2148,13 @@ static void kill_kprobe(struct kprobe *p)
> * the original probed function (which will be freed soon) any more.
> */
> arch_remove_kprobe(p);
> +
> + /*
> + * The module is going away. We should disarm the kprobe which
> + * is using ftrace.
> + */
> + if (kprobe_ftrace(p))
> + disarm_kprobe_ftrace(p);
> }
>
> /* Disable one kprobe */
> --
> 2.11.0
>
--
Yours,
Muchun
^ permalink raw reply
* [PATCH v4 00/11] microchip: add support for ksz88x3 driver family
From: Michael Grzeschik @ 2020-08-03 5:44 UTC (permalink / raw)
To: andrew; +Cc: netdev, f.fainelli, davem, kernel
This series adds support for the ksz88x3 driver family to the dsa based ksz
drivers. The driver is making use of the already available ksz8795 driver and
moves it to an generic driver for the ksz8 based chips which have similar
functions but an totaly different register layout.
Andrew Lunn (1):
net: phy: Add support for microchip SMI0 MDIO bus
Michael Grzeschik (10):
dt-bindings: net: mdio-gpio: add compatible for microchip,mdio-smi0
net: tag: ksz: Add KSZ8863 tag code
net: dsa: microchip: ksz8795: use port_cnt where possible
net: dsa: microchip: ksz8795: dynamic allocate memory for
flush_dyn_mac_table
net: dsa: microchip: ksz8795: change drivers prefix to be generic
net: dsa: microchip: ksz8795: move register offsets and shifts to
separate struct
net: dsa: microchip: ksz8795: add support for ksz88xx chips
net: dsa: microchip: Add Microchip KSZ8863 SMI based driver support
net: dsa: microchip: Add Microchip KSZ8863 SPI based driver support
dt-bindings: net: dsa: document additional Microchip KSZ8863/8873
switch
.../devicetree/bindings/net/dsa/ksz.txt | 2 +
.../devicetree/bindings/net/mdio-gpio.txt | 1 +
drivers/net/dsa/microchip/Kconfig | 9 +
drivers/net/dsa/microchip/Makefile | 1 +
drivers/net/dsa/microchip/ksz8.h | 68 ++
drivers/net/dsa/microchip/ksz8795.c | 926 ++++++++++++------
drivers/net/dsa/microchip/ksz8795_reg.h | 214 ++--
drivers/net/dsa/microchip/ksz8795_spi.c | 64 +-
drivers/net/dsa/microchip/ksz8863_reg.h | 124 +++
drivers/net/dsa/microchip/ksz8863_smi.c | 204 ++++
drivers/net/dsa/microchip/ksz_common.h | 2 +-
drivers/net/phy/mdio-bitbang.c | 8 +-
drivers/net/phy/mdio-gpio.c | 9 +
include/linux/mdio-bitbang.h | 3 +
include/net/dsa.h | 2 +
net/dsa/tag_ksz.c | 57 ++
16 files changed, 1275 insertions(+), 419 deletions(-)
create mode 100644 drivers/net/dsa/microchip/ksz8.h
create mode 100644 drivers/net/dsa/microchip/ksz8863_reg.h
create mode 100644 drivers/net/dsa/microchip/ksz8863_smi.c
--
2.28.0
^ permalink raw reply
* [PATCH v4 09/11] net: dsa: microchip: Add Microchip KSZ8863 SMI based driver support
From: Michael Grzeschik @ 2020-08-03 5:44 UTC (permalink / raw)
To: andrew; +Cc: netdev, f.fainelli, davem, kernel
In-Reply-To: <20200803054442.20089-1-m.grzeschik@pengutronix.de>
Add KSZ88X3 driver support. We add support for the KXZ88X3 three port
switches using the Microchip SMI Interface. They are supported using the
MDIO-Bitbang Interface.
Signed-off-by: Michael Grzeschik <m.grzeschik@pengutronix.de>
---
v1 -> v2: - this code was part of previuos patch
v2 -> v3: - this code was part of previuos patch
v3 -> v4: - moved this glue code so separate patch
- fixed locking in regmap and mdio_read/mdio_write
drivers/net/dsa/microchip/Kconfig | 9 ++
drivers/net/dsa/microchip/Makefile | 1 +
drivers/net/dsa/microchip/ksz8863_smi.c | 204 ++++++++++++++++++++++++
3 files changed, 214 insertions(+)
create mode 100644 drivers/net/dsa/microchip/ksz8863_smi.c
diff --git a/drivers/net/dsa/microchip/Kconfig b/drivers/net/dsa/microchip/Kconfig
index 4ec6a47b7f7284f..c5819bd4121cc7c 100644
--- a/drivers/net/dsa/microchip/Kconfig
+++ b/drivers/net/dsa/microchip/Kconfig
@@ -40,3 +40,12 @@ config NET_DSA_MICROCHIP_KSZ8795_SPI
It is required to use the KSZ8795 switch driver as the only access
is through SPI.
+
+config NET_DSA_MICROCHIP_KSZ8863_SMI
+ tristate "KSZ series SMI connected switch driver"
+ depends on NET_DSA_MICROCHIP_KSZ8795
+ select MDIO_BITBANG
+ default y
+ help
+ Select to enable support for registering switches configured through
+ Microchip SMI. It Supports the KSZ8863 and KSZ8873 Switch.
diff --git a/drivers/net/dsa/microchip/Makefile b/drivers/net/dsa/microchip/Makefile
index 929caa81e782ed2..2a03b21a3386f5d 100644
--- a/drivers/net/dsa/microchip/Makefile
+++ b/drivers/net/dsa/microchip/Makefile
@@ -5,3 +5,4 @@ obj-$(CONFIG_NET_DSA_MICROCHIP_KSZ9477_I2C) += ksz9477_i2c.o
obj-$(CONFIG_NET_DSA_MICROCHIP_KSZ9477_SPI) += ksz9477_spi.o
obj-$(CONFIG_NET_DSA_MICROCHIP_KSZ8795) += ksz8795.o
obj-$(CONFIG_NET_DSA_MICROCHIP_KSZ8795_SPI) += ksz8795_spi.o
+obj-$(CONFIG_NET_DSA_MICROCHIP_KSZ8863_SMI) += ksz8863_smi.o
diff --git a/drivers/net/dsa/microchip/ksz8863_smi.c b/drivers/net/dsa/microchip/ksz8863_smi.c
new file mode 100644
index 000000000000000..fd493441d725284
--- /dev/null
+++ b/drivers/net/dsa/microchip/ksz8863_smi.c
@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Microchip KSZ8863 series register access through SMI
+ *
+ * Copyright (C) 2019 Pengutronix, Michael Grzeschik <kernel@pengutronix.de>
+ */
+
+#include "ksz8.h"
+#include "ksz_common.h"
+
+/* Serial Management Interface (SMI) uses the following frame format:
+ *
+ * preamble|start|Read/Write| PHY | REG |TA| Data bits | Idle
+ * |frame| OP code |address |address| | |
+ * read | 32x1´s | 01 | 00 | 1xRRR | RRRRR |Z0| 00000000DDDDDDDD | Z
+ * write| 32x1´s | 01 | 00 | 0xRRR | RRRRR |10| xxxxxxxxDDDDDDDD | Z
+ *
+ */
+
+static int ksz8863_mdio_read(void *ctx, const void *reg_buf, size_t reg_len,
+ void *val_buf, size_t val_len)
+{
+ struct ksz_device *dev = (struct ksz_device *)ctx;
+ struct ksz8 *ksz8 = dev->priv;
+ struct mdio_device *mdev = ksz8->priv;
+ u8 reg = *(u8 *)reg_buf;
+ u8 *val = val_buf;
+ int ret = 0;
+ int i;
+
+ mutex_lock_nested(&mdev->bus->mdio_lock, MDIO_MUTEX_NESTED);
+ for (i = 0; i < val_len; i++) {
+ int tmp = reg + i;
+
+ ret = __mdiobus_read(mdev->bus, ((tmp & 0xE0) >> 5) |
+ BIT(4), tmp);
+ if (ret < 0)
+ goto out;
+
+ val[i] = ret;
+ }
+ ret = 0;
+
+ out:
+ mutex_unlock(&mdev->bus->mdio_lock);
+
+ return ret;
+}
+
+static int ksz8863_mdio_write(void *ctx, const void *data, size_t count)
+{
+ struct ksz_device *dev = (struct ksz_device *)ctx;
+ struct ksz8 *ksz8 = dev->priv;
+ struct mdio_device *mdev = ksz8->priv;
+ u8 *val = (u8 *)(data + 4);
+ u32 reg = *(u32 *)data;
+ int ret = 0;
+ int i;
+
+ mutex_lock_nested(&mdev->bus->mdio_lock, MDIO_MUTEX_NESTED);
+ for (i = 0; i < (count - 4); i++) {
+ int tmp = reg + i;
+
+ ret = __mdiobus_write(mdev->bus, ((tmp & 0xE0) >> 5),
+ tmp, val[i]);
+ if (ret < 0)
+ goto out;
+ }
+
+ out:
+ mutex_unlock(&mdev->bus->mdio_lock);
+
+ return ret;
+}
+
+static const struct regmap_bus regmap_smi[] = {
+ {
+ .read = ksz8863_mdio_read,
+ .write = ksz8863_mdio_write,
+ .max_raw_read = 1,
+ .max_raw_write = 1,
+ },
+ {
+ .read = ksz8863_mdio_read,
+ .write = ksz8863_mdio_write,
+ .val_format_endian_default = REGMAP_ENDIAN_BIG,
+ .max_raw_read = 2,
+ .max_raw_write = 2,
+ },
+ {
+ .read = ksz8863_mdio_read,
+ .write = ksz8863_mdio_write,
+ .val_format_endian_default = REGMAP_ENDIAN_BIG,
+ .max_raw_read = 4,
+ .max_raw_write = 4,
+ }
+};
+
+static const struct regmap_config ksz8863_regmap_config[] = {
+ {
+ .name = "#8",
+ .reg_bits = 8,
+ .pad_bits = 24,
+ .val_bits = 8,
+ .cache_type = REGCACHE_NONE,
+ .use_single_read = 1,
+ .lock = ksz_regmap_lock,
+ .unlock = ksz_regmap_unlock,
+ },
+ {
+ .name = "#16",
+ .reg_bits = 8,
+ .pad_bits = 24,
+ .val_bits = 16,
+ .cache_type = REGCACHE_NONE,
+ .use_single_read = 1,
+ .lock = ksz_regmap_lock,
+ .unlock = ksz_regmap_unlock,
+ },
+ {
+ .name = "#32",
+ .reg_bits = 8,
+ .pad_bits = 24,
+ .val_bits = 32,
+ .cache_type = REGCACHE_NONE,
+ .use_single_read = 1,
+ .lock = ksz_regmap_lock,
+ .unlock = ksz_regmap_unlock,
+ }
+};
+
+static int ksz8863_smi_probe(struct mdio_device *mdiodev)
+{
+ struct regmap_config rc;
+ struct ksz_device *dev;
+ struct ksz8 *ksz8;
+ int ret;
+ int i;
+
+ ksz8 = devm_kzalloc(&mdiodev->dev, sizeof(struct ksz8), GFP_KERNEL);
+ ksz8->priv = mdiodev;
+
+ dev = ksz_switch_alloc(&mdiodev->dev, ksz8);
+ if (!dev)
+ return -EINVAL;
+
+ for (i = 0; i < ARRAY_SIZE(ksz8863_regmap_config); i++) {
+ rc = ksz8863_regmap_config[i];
+ rc.lock_arg = &dev->regmap_mutex;
+ dev->regmap[i] = devm_regmap_init(&mdiodev->dev,
+ ®map_smi[i], dev,
+ &rc);
+ if (IS_ERR(dev->regmap[i])) {
+ ret = PTR_ERR(dev->regmap[i]);
+ dev_err(&mdiodev->dev,
+ "Failed to initialize regmap%i: %d\n",
+ ksz8863_regmap_config[i].val_bits, ret);
+ return ret;
+ }
+ }
+
+ if (mdiodev->dev.platform_data)
+ dev->pdata = mdiodev->dev.platform_data;
+
+ ret = ksz8_switch_register(dev);
+
+ /* Main DSA driver may not be started yet. */
+ if (ret)
+ return ret;
+
+ dev_set_drvdata(&mdiodev->dev, dev);
+
+ return 0;
+}
+
+static void ksz8863_smi_remove(struct mdio_device *mdiodev)
+{
+ struct ksz_device *dev = dev_get_drvdata(&mdiodev->dev);
+
+ if (dev)
+ ksz_switch_remove(dev);
+}
+
+static const struct of_device_id ksz8863_dt_ids[] = {
+ { .compatible = "microchip,ksz8863" },
+ { .compatible = "microchip,ksz8873" },
+ { },
+};
+MODULE_DEVICE_TABLE(of, ksz8863_dt_ids);
+
+static struct mdio_driver ksz8863_driver = {
+ .probe = ksz8863_smi_probe,
+ .remove = ksz8863_smi_remove,
+ .mdiodrv.driver = {
+ .name = "ksz8863-switch",
+ .of_match_table = ksz8863_dt_ids,
+ },
+};
+
+mdio_module_driver(ksz8863_driver);
+
+MODULE_AUTHOR("Michael Grzeschik <m.grzeschik@pengutronix.de>");
+MODULE_DESCRIPTION("Microchip KSZ8863 SMI Switch driver");
+MODULE_LICENSE("GPL v2");
--
2.28.0
^ permalink raw reply related
* [PATCH v4 10/11] net: dsa: microchip: Add Microchip KSZ8863 SPI based driver support
From: Michael Grzeschik @ 2020-08-03 5:44 UTC (permalink / raw)
To: andrew; +Cc: netdev, f.fainelli, davem, kernel
In-Reply-To: <20200803054442.20089-1-m.grzeschik@pengutronix.de>
Add KSZ88X3 driver support. We add support for the KXZ88X3 three port
switches using the SPI Interface.
Signed-off-by: Michael Grzeschik <m.grzeschik@pengutronix.de>
---
v1 -> v2: - this glue was not implemented
v2 -> v3: - this glue was part of previous bigger patch
v3 -> v4: - this glue was moved to this separate patch
drivers/net/dsa/microchip/ksz8795_spi.c | 62 ++++++++++++++++++-------
1 file changed, 45 insertions(+), 17 deletions(-)
diff --git a/drivers/net/dsa/microchip/ksz8795_spi.c b/drivers/net/dsa/microchip/ksz8795_spi.c
index 3bab09c46f6a7bd..d13a83c27428cdc 100644
--- a/drivers/net/dsa/microchip/ksz8795_spi.c
+++ b/drivers/net/dsa/microchip/ksz8795_spi.c
@@ -14,34 +14,70 @@
#include <linux/regmap.h>
#include <linux/spi/spi.h>
+#include "ksz8.h"
#include "ksz_common.h"
-#define SPI_ADDR_SHIFT 12
-#define SPI_ADDR_ALIGN 3
-#define SPI_TURNAROUND_SHIFT 1
+#define KSZ8795_SPI_ADDR_SHIFT 12
+#define KSZ8795_SPI_ADDR_ALIGN 3
+#define KSZ8795_SPI_TURNAROUND_SHIFT 1
-KSZ_REGMAP_TABLE(ksz8795, 16, SPI_ADDR_SHIFT,
- SPI_TURNAROUND_SHIFT, SPI_ADDR_ALIGN);
+#define KSZ8863_SPI_ADDR_SHIFT 8
+#define KSZ8863_SPI_ADDR_ALIGN 8
+#define KSZ8863_SPI_TURNAROUND_SHIFT 0
+
+KSZ_REGMAP_TABLE(ksz8795, 16, KSZ8795_SPI_ADDR_SHIFT,
+ KSZ8795_SPI_TURNAROUND_SHIFT, KSZ8795_SPI_ADDR_ALIGN);
+
+KSZ_REGMAP_TABLE(ksz8863, 16, KSZ8863_SPI_ADDR_SHIFT,
+ KSZ8863_SPI_TURNAROUND_SHIFT, KSZ8863_SPI_ADDR_ALIGN);
+
+static const struct of_device_id ksz8795_dt_ids[] = {
+ { .compatible = "microchip,ksz8765", .data = &ksz8795_regmap_config },
+ { .compatible = "microchip,ksz8794", .data = &ksz8795_regmap_config },
+ { .compatible = "microchip,ksz8795", .data = &ksz8795_regmap_config },
+ { .compatible = "microchip,ksz8863", .data = &ksz8863_regmap_config },
+ { .compatible = "microchip,ksz8873", .data = &ksz8863_regmap_config },
+ {},
+};
+MODULE_DEVICE_TABLE(of, ksz8795_dt_ids);
static int ksz8795_spi_probe(struct spi_device *spi)
{
+ const struct regmap_config *regmap_config;
+ const struct of_device_id *match;
+ struct device *ddev = &spi->dev;
+ struct ksz8 *ksz8;
struct regmap_config rc;
struct ksz_device *dev;
- int i, ret;
+ int i, ret = 0;
- dev = ksz_switch_alloc(&spi->dev, spi);
+ ksz8 = devm_kzalloc(&spi->dev, sizeof(struct ksz8), GFP_KERNEL);
+ ksz8->priv = spi;
+
+ dev = ksz_switch_alloc(&spi->dev, ksz8);
if (!dev)
return -ENOMEM;
+ regmap_config = ksz8795_regmap_config;
+
+ if (ddev->of_node) {
+ match = of_match_node(ksz8795_dt_ids, ddev->of_node);
+ if (!match)
+ return -ENOTSUPP;
+
+ if (match->data)
+ regmap_config = match->data;
+ }
+
for (i = 0; i < ARRAY_SIZE(ksz8795_regmap_config); i++) {
- rc = ksz8795_regmap_config[i];
+ rc = regmap_config[i];
rc.lock_arg = &dev->regmap_mutex;
dev->regmap[i] = devm_regmap_init_spi(spi, &rc);
if (IS_ERR(dev->regmap[i])) {
ret = PTR_ERR(dev->regmap[i]);
dev_err(&spi->dev,
"Failed to initialize regmap%i: %d\n",
- ksz8795_regmap_config[i].val_bits, ret);
+ regmap_config[i].val_bits, ret);
return ret;
}
}
@@ -78,14 +114,6 @@ static void ksz8795_spi_shutdown(struct spi_device *spi)
dev->dev_ops->shutdown(dev);
}
-static const struct of_device_id ksz8795_dt_ids[] = {
- { .compatible = "microchip,ksz8765" },
- { .compatible = "microchip,ksz8794" },
- { .compatible = "microchip,ksz8795" },
- {},
-};
-MODULE_DEVICE_TABLE(of, ksz8795_dt_ids);
-
static struct spi_driver ksz8795_spi_driver = {
.driver = {
.name = "ksz8795-switch",
--
2.28.0
^ permalink raw reply related
* [PATCH v4 07/11] net: dsa: microchip: ksz8795: move register offsets and shifts to separate struct
From: Michael Grzeschik @ 2020-08-03 5:44 UTC (permalink / raw)
To: andrew; +Cc: netdev, f.fainelli, davem, kernel
In-Reply-To: <20200803054442.20089-1-m.grzeschik@pengutronix.de>
In order to get this driver used with other switches the functions need
to use different offsets and register shifts. This patch changes the
direct use of the register defines to register description structures,
which can be set depending on the chips register layout.
Signed-off-by: Michael Grzeschik <m.grzeschik@pengutronix.de>
---
v1 -> v4: - extracted this change from bigger previous patch
drivers/net/dsa/microchip/ksz8.h | 68 ++++++++
drivers/net/dsa/microchip/ksz8795.c | 242 +++++++++++++++++++---------
2 files changed, 235 insertions(+), 75 deletions(-)
create mode 100644 drivers/net/dsa/microchip/ksz8.h
diff --git a/drivers/net/dsa/microchip/ksz8.h b/drivers/net/dsa/microchip/ksz8.h
new file mode 100644
index 000000000000000..a2fb6b9e2d1e5d5
--- /dev/null
+++ b/drivers/net/dsa/microchip/ksz8.h
@@ -0,0 +1,68 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Microchip KSZ8863 series register access through SMI
+ *
+ * Copyright (C) 2019 Pengutronix, Michael Grzeschik <kernel@pengutronix.de>
+ */
+
+#ifndef __KSZ8XXX_H
+#define __KSZ8XXX_H
+
+struct ksz_regs {
+ int ind_ctrl_0;
+ int ind_data_8;
+ int ind_data_check;
+ int ind_data_hi;
+ int ind_data_lo;
+ int ind_mib_check;
+ int p_force_ctrl;
+ int p_link_status;
+ int p_local_ctrl;
+ int p_neg_restart_ctrl;
+ int p_remote_status;
+ int p_speed_status;
+ int s_tail_tag_ctrl;
+};
+
+struct ksz_masks {
+ int port_802_1p_remapping;
+ int sw_tail_tag_enable;
+ int mib_counter_overflow;
+ int mib_counter_valid;
+ int vlan_table_fid;
+ int vlan_table_membership;
+ int vlan_table_valid;
+ int static_mac_table_valid;
+ int static_mac_table_use_fid;
+ int static_mac_table_fid;
+ int static_mac_table_override;
+ int static_mac_table_fwd_ports;
+ int dynamic_mac_table_entries_h;
+ int dynamic_mac_table_mac_empty;
+ int dynamic_mac_table_not_ready;
+ int dynamic_mac_table_entries;
+ int dynamic_mac_table_fid;
+ int dynamic_mac_table_src_port;
+ int dynamic_mac_table_timestamp;
+};
+
+struct ksz_shifts {
+ int vlan_table_membership;
+ int vlan_table;
+ int static_mac_fwd_ports;
+ int static_mac_fid;
+ int dynamic_mac_entries_h;
+ int dynamic_mac_entries;
+ int dynamic_mac_fid;
+ int dynamic_mac_timestamp;
+ int dynamic_mac_src_port;
+};
+
+struct ksz8 {
+ struct ksz_regs *regs;
+ struct ksz_masks *masks;
+ struct ksz_shifts *shifts;
+ void *priv;
+};
+
+#endif
diff --git a/drivers/net/dsa/microchip/ksz8795.c b/drivers/net/dsa/microchip/ksz8795.c
index c21125a0b30e5c8..480143905d75579 100644
--- a/drivers/net/dsa/microchip/ksz8795.c
+++ b/drivers/net/dsa/microchip/ksz8795.c
@@ -20,6 +20,46 @@
#include "ksz_common.h"
#include "ksz8795_reg.h"
+#include "ksz8.h"
+
+static struct ksz_regs ksz8795_regs = {
+ .ind_ctrl_0 = REG_IND_CTRL_0,
+ .ind_data_8 = REG_IND_DATA_8,
+ .ind_data_check = REG_IND_DATA_CHECK,
+ .ind_data_hi = REG_IND_DATA_HI,
+ .ind_data_lo = REG_IND_DATA_LO,
+ .ind_mib_check = REG_IND_MIB_CHECK,
+ .p_force_ctrl = P_FORCE_CTRL,
+ .p_link_status = P_LINK_STATUS,
+ .p_local_ctrl = P_LOCAL_CTRL,
+ .p_neg_restart_ctrl = P_NEG_RESTART_CTRL,
+ .p_remote_status = P_REMOTE_STATUS,
+ .p_speed_status = P_SPEED_STATUS,
+ .s_tail_tag_ctrl = S_TAIL_TAG_CTRL,
+};
+
+static struct ksz_masks ksz8795_masks = {
+ .port_802_1p_remapping = PORT_802_1P_REMAPPING,
+ .sw_tail_tag_enable = SW_TAIL_TAG_ENABLE,
+ .mib_counter_overflow = MIB_COUNTER_OVERFLOW,
+ .mib_counter_valid = MIB_COUNTER_VALID,
+ .vlan_table_fid = VLAN_TABLE_FID,
+ .vlan_table_membership = VLAN_TABLE_MEMBERSHIP,
+ .vlan_table_valid = VLAN_TABLE_VALID,
+ .static_mac_table_valid = STATIC_MAC_TABLE_VALID,
+ .static_mac_table_use_fid = STATIC_MAC_TABLE_USE_FID,
+ .static_mac_table_fid = STATIC_MAC_TABLE_FID,
+ .static_mac_table_override = STATIC_MAC_TABLE_OVERRIDE,
+ .static_mac_table_fwd_ports = STATIC_MAC_TABLE_FWD_PORTS,
+ .dynamic_mac_table_entries_h = DYNAMIC_MAC_TABLE_ENTRIES_H,
+ .dynamic_mac_table_mac_empty = DYNAMIC_MAC_TABLE_MAC_EMPTY,
+ .dynamic_mac_table_not_ready = DYNAMIC_MAC_TABLE_NOT_READY,
+ .dynamic_mac_table_entries = DYNAMIC_MAC_TABLE_ENTRIES,
+ .dynamic_mac_table_fid = DYNAMIC_MAC_TABLE_FID,
+ .dynamic_mac_table_src_port = DYNAMIC_MAC_TABLE_SRC_PORT,
+ .dynamic_mac_table_timestamp = DYNAMIC_MAC_TABLE_TIMESTAMP,
+};
+
static const struct {
char string[ETH_GSTRING_LEN];
@@ -119,26 +159,29 @@ static void ksz8795_set_prio_queue(struct ksz_device *dev, int port, int queue)
static void ksz8_r_mib_cnt(struct ksz_device *dev, int port, u16 addr, u64 *cnt)
{
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_regs *regs = ksz8->regs;
+ struct ksz_masks *masks = ksz8->masks;
u16 ctrl_addr;
u32 data;
u8 check;
int loop;
- ctrl_addr = addr + SWITCH_COUNTER_NUM * port;
+ ctrl_addr = addr + dev->reg_mib_cnt * port;
ctrl_addr |= IND_ACC_TABLE(TABLE_MIB | TABLE_READ);
mutex_lock(&dev->alu_mutex);
- ksz_write16(dev, REG_IND_CTRL_0, ctrl_addr);
+ ksz_write16(dev, regs->ind_ctrl_0, ctrl_addr);
/* It is almost guaranteed to always read the valid bit because of
* slow SPI speed.
*/
for (loop = 2; loop > 0; loop--) {
- ksz_read8(dev, REG_IND_MIB_CHECK, &check);
+ ksz_read8(dev, regs->ind_mib_check, &check);
- if (check & MIB_COUNTER_VALID) {
- ksz_read32(dev, REG_IND_DATA_LO, &data);
- if (check & MIB_COUNTER_OVERFLOW)
+ if (check & masks->mib_counter_valid) {
+ ksz_read32(dev, regs->ind_data_lo, &data);
+ if (check & masks->mib_counter_overflow)
*cnt += MIB_COUNTER_VALUE + 1;
*cnt += data & MIB_COUNTER_VALUE;
break;
@@ -150,6 +193,8 @@ static void ksz8_r_mib_cnt(struct ksz_device *dev, int port, u16 addr, u64 *cnt)
static void ksz8_r_mib_pkt(struct ksz_device *dev, int port, u16 addr,
u64 *dropped, u64 *cnt)
{
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_regs *regs = ksz8->regs;
u16 ctrl_addr;
u32 data;
u8 check;
@@ -161,16 +206,16 @@ static void ksz8_r_mib_pkt(struct ksz_device *dev, int port, u16 addr,
ctrl_addr |= IND_ACC_TABLE(TABLE_MIB | TABLE_READ);
mutex_lock(&dev->alu_mutex);
- ksz_write16(dev, REG_IND_CTRL_0, ctrl_addr);
+ ksz_write16(dev, regs->ind_ctrl_0, ctrl_addr);
/* It is almost guaranteed to always read the valid bit because of
* slow SPI speed.
*/
for (loop = 2; loop > 0; loop--) {
- ksz_read8(dev, REG_IND_MIB_CHECK, &check);
+ ksz_read8(dev, regs->ind_mib_check, &check);
if (check & MIB_COUNTER_VALID) {
- ksz_read32(dev, REG_IND_DATA_LO, &data);
+ ksz_read32(dev, regs->ind_data_lo, &data);
if (addr < 2) {
u64 total;
@@ -236,46 +281,53 @@ static void ksz8_port_init_cnt(struct ksz_device *dev, int port)
static void ksz8_r_table(struct ksz_device *dev, int table, u16 addr, u64 *data)
{
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_regs *regs = ksz8->regs;
u16 ctrl_addr;
ctrl_addr = IND_ACC_TABLE(table | TABLE_READ) | addr;
mutex_lock(&dev->alu_mutex);
- ksz_write16(dev, REG_IND_CTRL_0, ctrl_addr);
- ksz_read64(dev, REG_IND_DATA_HI, data);
+ ksz_write16(dev, regs->ind_ctrl_0, ctrl_addr);
+ ksz_read64(dev, regs->ind_data_hi, data);
mutex_unlock(&dev->alu_mutex);
}
static void ksz8_w_table(struct ksz_device *dev, int table, u16 addr, u64 data)
{
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_regs *regs = ksz8->regs;
u16 ctrl_addr;
ctrl_addr = IND_ACC_TABLE(table) | addr;
mutex_lock(&dev->alu_mutex);
- ksz_write64(dev, REG_IND_DATA_HI, data);
- ksz_write16(dev, REG_IND_CTRL_0, ctrl_addr);
+ ksz_write64(dev, regs->ind_data_hi, data);
+ ksz_write16(dev, regs->ind_ctrl_0, ctrl_addr);
mutex_unlock(&dev->alu_mutex);
}
static int ksz8_valid_dyn_entry(struct ksz_device *dev, u8 *data)
{
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_regs *regs = ksz8->regs;
+ struct ksz_masks *masks = ksz8->masks;
int timeout = 100;
do {
- ksz_read8(dev, REG_IND_DATA_CHECK, data);
+ ksz_read8(dev, regs->ind_data_check, data);
timeout--;
- } while ((*data & DYNAMIC_MAC_TABLE_NOT_READY) && timeout);
+ } while ((*data & masks->dynamic_mac_table_not_ready) && timeout);
/* Entry is not ready for accessing. */
- if (*data & DYNAMIC_MAC_TABLE_NOT_READY) {
+ if (*data & masks->dynamic_mac_table_not_ready) {
return -EAGAIN;
/* Entry is ready for accessing. */
} else {
- ksz_read8(dev, REG_IND_DATA_8, data);
+ ksz_read8(dev, regs->ind_data_8, data);
/* There is no valid entry in the table. */
- if (*data & DYNAMIC_MAC_TABLE_MAC_EMPTY)
+ if (*data & masks->dynamic_mac_table_mac_empty)
return -ENXIO;
}
return 0;
@@ -285,6 +337,10 @@ static int ksz8_r_dyn_mac_table(struct ksz_device *dev, u16 addr,
u8 *mac_addr, u8 *fid, u8 *src_port,
u8 *timestamp, u16 *entries)
{
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_regs *regs = ksz8->regs;
+ struct ksz_masks *masks = ksz8->masks;
+ struct ksz_shifts *shifts = ksz8->shifts;
u32 data_hi, data_lo;
u16 ctrl_addr;
u8 data;
@@ -293,7 +349,7 @@ static int ksz8_r_dyn_mac_table(struct ksz_device *dev, u16 addr,
ctrl_addr = IND_ACC_TABLE(TABLE_DYNAMIC_MAC | TABLE_READ) | addr;
mutex_lock(&dev->alu_mutex);
- ksz_write16(dev, REG_IND_CTRL_0, ctrl_addr);
+ ksz_write16(dev, regs->ind_ctrl_0, ctrl_addr);
rc = ksz8_valid_dyn_entry(dev, &data);
if (rc == -EAGAIN) {
@@ -306,23 +362,23 @@ static int ksz8_r_dyn_mac_table(struct ksz_device *dev, u16 addr,
u64 buf = 0;
int cnt;
- ksz_read64(dev, REG_IND_DATA_HI, &buf);
+ ksz_read64(dev, regs->ind_data_hi, &buf);
data_hi = (u32)(buf >> 32);
data_lo = (u32)buf;
/* Check out how many valid entry in the table. */
- cnt = data & DYNAMIC_MAC_TABLE_ENTRIES_H;
- cnt <<= DYNAMIC_MAC_ENTRIES_H_S;
- cnt |= (data_hi & DYNAMIC_MAC_TABLE_ENTRIES) >>
- DYNAMIC_MAC_ENTRIES_S;
+ cnt = data & masks->dynamic_mac_table_entries_h;
+ cnt <<= shifts->dynamic_mac_entries_h;
+ cnt |= (data_hi & masks->dynamic_mac_table_entries) >>
+ shifts->dynamic_mac_entries;
*entries = cnt + 1;
- *fid = (data_hi & DYNAMIC_MAC_TABLE_FID) >>
- DYNAMIC_MAC_FID_S;
- *src_port = (data_hi & DYNAMIC_MAC_TABLE_SRC_PORT) >>
- DYNAMIC_MAC_SRC_PORT_S;
- *timestamp = (data_hi & DYNAMIC_MAC_TABLE_TIMESTAMP) >>
- DYNAMIC_MAC_TIMESTAMP_S;
+ *fid = (data_hi & masks->dynamic_mac_table_fid) >>
+ shifts->dynamic_mac_fid;
+ *src_port = (data_hi & masks->dynamic_mac_table_src_port) >>
+ shifts->dynamic_mac_src_port;
+ *timestamp = (data_hi & masks->dynamic_mac_table_timestamp) >>
+ shifts->dynamic_mac_timestamp;
mac_addr[5] = (u8)data_lo;
mac_addr[4] = (u8)(data_lo >> 8);
@@ -341,27 +397,33 @@ static int ksz8_r_dyn_mac_table(struct ksz_device *dev, u16 addr,
static int ksz8_r_sta_mac_table(struct ksz_device *dev, u16 addr,
struct alu_struct *alu)
{
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_masks *masks = ksz8->masks;
+ struct ksz_shifts *shifts = ksz8->shifts;
u32 data_hi, data_lo;
u64 data;
ksz8_r_table(dev, TABLE_STATIC_MAC, addr, &data);
data_hi = data >> 32;
data_lo = (u32)data;
- if (data_hi & (STATIC_MAC_TABLE_VALID | STATIC_MAC_TABLE_OVERRIDE)) {
+ if (data_hi & (masks->static_mac_table_valid |
+ masks->static_mac_table_override)) {
alu->mac[5] = (u8)data_lo;
alu->mac[4] = (u8)(data_lo >> 8);
alu->mac[3] = (u8)(data_lo >> 16);
alu->mac[2] = (u8)(data_lo >> 24);
alu->mac[1] = (u8)data_hi;
alu->mac[0] = (u8)(data_hi >> 8);
- alu->port_forward = (data_hi & STATIC_MAC_TABLE_FWD_PORTS) >>
- STATIC_MAC_FWD_PORTS_S;
+ alu->port_forward =
+ (data_hi & masks->static_mac_table_fwd_ports) >>
+ shifts->static_mac_fwd_ports;
alu->is_override =
- (data_hi & STATIC_MAC_TABLE_OVERRIDE) ? 1 : 0;
+ (data_hi & masks->static_mac_table_override) ? 1 : 0;
data_hi >>= 1;
- alu->is_use_fid = (data_hi & STATIC_MAC_TABLE_USE_FID) ? 1 : 0;
- alu->fid = (data_hi & STATIC_MAC_TABLE_FID) >>
- STATIC_MAC_FID_S;
+ alu->is_use_fid =
+ (data_hi & masks->static_mac_table_use_fid) ? 1 : 0;
+ alu->fid = (data_hi & masks->static_mac_table_fid) >>
+ shifts->static_mac_fid;
return 0;
}
return -ENXIO;
@@ -370,6 +432,9 @@ static int ksz8_r_sta_mac_table(struct ksz_device *dev, u16 addr,
static void ksz8_w_sta_mac_table(struct ksz_device *dev, u16 addr,
struct alu_struct *alu)
{
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_masks *masks = ksz8->masks;
+ struct ksz_shifts *shifts = ksz8->shifts;
u32 data_hi, data_lo;
u64 data;
@@ -377,36 +442,47 @@ static void ksz8_w_sta_mac_table(struct ksz_device *dev, u16 addr,
((u32)alu->mac[3] << 16) |
((u32)alu->mac[4] << 8) | alu->mac[5];
data_hi = ((u32)alu->mac[0] << 8) | alu->mac[1];
- data_hi |= (u32)alu->port_forward << STATIC_MAC_FWD_PORTS_S;
+ data_hi |= (u32)alu->port_forward << shifts->static_mac_fwd_ports;
if (alu->is_override)
- data_hi |= STATIC_MAC_TABLE_OVERRIDE;
+ data_hi |= masks->static_mac_table_override;
if (alu->is_use_fid) {
- data_hi |= STATIC_MAC_TABLE_USE_FID;
- data_hi |= (u32)alu->fid << STATIC_MAC_FID_S;
+ data_hi |= masks->static_mac_table_use_fid;
+ data_hi |= (u32)alu->fid << shifts->static_mac_fid;
}
if (alu->is_static)
- data_hi |= STATIC_MAC_TABLE_VALID;
+ data_hi |= masks->static_mac_table_valid;
else
- data_hi &= ~STATIC_MAC_TABLE_OVERRIDE;
+ data_hi &= ~masks->static_mac_table_override;
data = (u64)data_hi << 32 | data_lo;
ksz8_w_table(dev, TABLE_STATIC_MAC, addr, data);
}
-static void ksz8_from_vlan(u16 vlan, u8 *fid, u8 *member, u8 *valid)
+static void ksz8_from_vlan(struct ksz_device *dev, u32 vlan, u8 *fid,
+ u8 *member, u8 *valid)
{
- *fid = vlan & VLAN_TABLE_FID;
- *member = (vlan & VLAN_TABLE_MEMBERSHIP) >> VLAN_TABLE_MEMBERSHIP_S;
- *valid = !!(vlan & VLAN_TABLE_VALID);
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_masks *masks = ksz8->masks;
+ struct ksz_shifts *shifts = ksz8->shifts;
+
+ *fid = vlan & masks->vlan_table_fid;
+ *member = (vlan & masks->vlan_table_membership) >>
+ shifts->vlan_table_membership;
+ *valid = !!(vlan & masks->vlan_table_valid);
}
-static void ksz8_to_vlan(u8 fid, u8 member, u8 valid, u16 *vlan)
+static void ksz8_to_vlan(struct ksz_device *dev, u8 fid, u8 member, u8 valid,
+ u32 *vlan)
{
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_masks *masks = ksz8->masks;
+ struct ksz_shifts *shifts = ksz8->shifts;
+
*vlan = fid;
- *vlan |= (u16)member << VLAN_TABLE_MEMBERSHIP_S;
+ *vlan |= (u16)member << shifts->vlan_table_membership;
if (valid)
- *vlan |= VLAN_TABLE_VALID;
+ *vlan |= masks->vlan_table_valid;
}
static void ksz8_r_vlan_entries(struct ksz_device *dev, u16 addr)
@@ -420,7 +496,7 @@ static void ksz8_r_vlan_entries(struct ksz_device *dev, u16 addr)
addr *= dev->port_cnt;
for (i = 0; i < dev->port_cnt; i++) {
dev->vlan_cache[addr + i].table[0] = (u16)data;
- data >>= VLAN_TABLE_S;
+ data >>= shifts->vlan_table;
}
}
@@ -456,6 +532,8 @@ static void ksz8_w_vlan_table(struct ksz_device *dev, u16 vid, u32 vlan)
static void ksz8_r_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 *val)
{
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_regs *regs = ksz8->regs;
u8 restart, speed, ctrl, link;
int processed = true;
u16 data = 0;
@@ -463,9 +541,9 @@ static void ksz8_r_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 *val)
switch (reg) {
case PHY_REG_CTRL:
- ksz_pread8(dev, p, P_NEG_RESTART_CTRL, &restart);
- ksz_pread8(dev, p, P_SPEED_STATUS, &speed);
- ksz_pread8(dev, p, P_FORCE_CTRL, &ctrl);
+ ksz_pread8(dev, p, regs->p_neg_restart_ctrl, &restart);
+ ksz_pread8(dev, p, regs->p_speed_status, &speed);
+ ksz_pread8(dev, p, regs->p_force_ctrl, &ctrl);
if (restart & PORT_PHY_LOOPBACK)
data |= PHY_LOOPBACK;
if (ctrl & PORT_FORCE_100_MBIT)
@@ -490,7 +568,7 @@ static void ksz8_r_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 *val)
data |= PHY_LED_DISABLE;
break;
case PHY_REG_STATUS:
- ksz_pread8(dev, p, P_LINK_STATUS, &link);
+ ksz_pread8(dev, p, regs->p_link_status, &link);
data = PHY_100BTX_FD_CAPABLE |
PHY_100BTX_CAPABLE |
PHY_10BT_FD_CAPABLE |
@@ -508,7 +586,7 @@ static void ksz8_r_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 *val)
data = KSZ8795_ID_LO;
break;
case PHY_REG_AUTO_NEGOTIATION:
- ksz_pread8(dev, p, P_LOCAL_CTRL, &ctrl);
+ ksz_pread8(dev, p, regs->p_local_ctrl, &ctrl);
data = PHY_AUTO_NEG_802_3;
if (ctrl & PORT_AUTO_NEG_SYM_PAUSE)
data |= PHY_AUTO_NEG_SYM_PAUSE;
@@ -522,7 +600,7 @@ static void ksz8_r_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 *val)
data |= PHY_AUTO_NEG_10BT;
break;
case PHY_REG_REMOTE_CAPABILITY:
- ksz_pread8(dev, p, P_REMOTE_STATUS, &link);
+ ksz_pread8(dev, p, regs->p_remote_status, &link);
data = PHY_AUTO_NEG_802_3;
if (link & PORT_REMOTE_SYM_PAUSE)
data |= PHY_AUTO_NEG_SYM_PAUSE;
@@ -548,6 +626,8 @@ static void ksz8_r_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 *val)
static void ksz8_w_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 val)
{
u8 p = phy;
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_regs *regs = ksz8->regs;
u8 restart, speed, ctrl, data;
switch (reg) {
@@ -556,15 +636,15 @@ static void ksz8_w_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 val)
/* Do not support PHY reset function. */
if (val & PHY_RESET)
break;
- ksz_pread8(dev, p, P_SPEED_STATUS, &speed);
+ ksz_pread8(dev, p, regs->p_speed_status, &speed);
data = speed;
if (val & PHY_HP_MDIX)
data |= PORT_HP_MDIX;
else
data &= ~PORT_HP_MDIX;
if (data != speed)
- ksz_pwrite8(dev, p, P_SPEED_STATUS, data);
- ksz_pread8(dev, p, P_FORCE_CTRL, &ctrl);
+ ksz_pwrite8(dev, p, regs->p_speed_status, data);
+ ksz_pread8(dev, p, regs->p_force_ctrl, &ctrl);
data = ctrl;
if (!(val & PHY_AUTO_NEG_ENABLE))
data |= PORT_AUTO_NEG_DISABLE;
@@ -583,8 +663,8 @@ static void ksz8_w_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 val)
else
data &= ~PORT_FORCE_FULL_DUPLEX;
if (data != ctrl)
- ksz_pwrite8(dev, p, P_FORCE_CTRL, data);
- ksz_pread8(dev, p, P_NEG_RESTART_CTRL, &restart);
+ ksz_pwrite8(dev, p, regs->p_force_ctrl, data);
+ ksz_pread8(dev, p, regs->p_neg_restart_ctrl, &restart);
data = restart;
if (val & PHY_LED_DISABLE)
data |= PORT_LED_OFF;
@@ -615,10 +695,10 @@ static void ksz8_w_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 val)
else
data &= ~PORT_PHY_LOOPBACK;
if (data != restart)
- ksz_pwrite8(dev, p, P_NEG_RESTART_CTRL, data);
+ ksz_pwrite8(dev, p, regs->p_neg_restart_ctrl, data);
break;
case PHY_REG_AUTO_NEGOTIATION:
- ksz_pread8(dev, p, P_LOCAL_CTRL, &ctrl);
+ ksz_pread8(dev, p, regs->p_local_ctrl, &ctrl);
data = ctrl;
data &= ~(PORT_AUTO_NEG_SYM_PAUSE |
PORT_AUTO_NEG_100BTX_FD |
@@ -636,7 +716,7 @@ static void ksz8_w_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 val)
if (val & PHY_AUTO_NEG_10BT)
data |= PORT_AUTO_NEG_10BT;
if (data != ctrl)
- ksz_pwrite8(dev, p, P_LOCAL_CTRL, data);
+ ksz_pwrite8(dev, p, regs->p_local_ctrl, data);
break;
default:
break;
@@ -793,14 +873,15 @@ static void ksz8_port_vlan_add(struct dsa_switch *ds, int port,
{
bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
struct ksz_device *dev = ds->priv;
- u16 data, vid, new_pvid = 0;
+ u16 vid, new_pvid = 0;
+ u32 data = 0;
u8 fid, member, valid;
ksz_port_cfg(dev, port, P_TAG_CTRL, PORT_REMOVE_TAG, untagged);
for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
ksz8_r_vlan_table(dev, vid, &data);
- ksz8_from_vlan(data, &fid, &member, &valid);
+ ksz8_from_vlan(dev, data, &fid, &member, &valid);
/* First time to setup the VLAN entry. */
if (!valid) {
@@ -810,9 +891,8 @@ static void ksz8_port_vlan_add(struct dsa_switch *ds, int port,
}
member |= BIT(port);
- ksz8_to_vlan(fid, member, valid, &data);
+ ksz8_to_vlan(dev, fid, member, valid, &data);
ksz8_w_vlan_table(dev, vid, data);
-
/* change PVID */
if (vlan->flags & BRIDGE_VLAN_INFO_PVID)
new_pvid = vid;
@@ -831,7 +911,8 @@ static int ksz8_port_vlan_del(struct dsa_switch *ds, int port,
{
bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
struct ksz_device *dev = ds->priv;
- u16 data, vid, pvid, new_pvid = 0;
+ u32 data = 0;
+ u16 vid, pvid, new_pvid = 0;
u8 fid, member, valid;
ksz_pread16(dev, port, REG_PORT_CTRL_VID, &pvid);
@@ -841,7 +922,7 @@ static int ksz8_port_vlan_del(struct dsa_switch *ds, int port,
for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
ksz8_r_vlan_table(dev, vid, &data);
- ksz8_from_vlan(data, &fid, &member, &valid);
+ ksz8_from_vlan(dev, data, &fid, &member, &valid);
member &= ~BIT(port);
@@ -854,7 +935,7 @@ static int ksz8_port_vlan_del(struct dsa_switch *ds, int port,
if (pvid == vid)
new_pvid = 1;
- ksz8_to_vlan(fid, member, valid, &data);
+ ksz8_to_vlan(dev, fid, member, valid, &data);
ksz8_w_vlan_table(dev, vid, data);
}
@@ -913,6 +994,8 @@ static void ksz8_port_setup(struct ksz_device *dev, int port, bool cpu_port)
{
struct ksz_port *p = &dev->ports[port];
u8 data8, member;
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_masks *masks = ksz8->masks;
/* enable broadcast storm limit */
ksz_port_cfg(dev, port, P_BCAST_STORM_CTRL, PORT_BROADCAST_STORM, true);
@@ -923,7 +1006,8 @@ static void ksz8_port_setup(struct ksz_device *dev, int port, bool cpu_port)
ksz_port_cfg(dev, port, P_PRIO_CTRL, PORT_DIFFSERV_ENABLE, false);
/* replace priority */
- ksz_port_cfg(dev, port, P_802_1P_CTRL, PORT_802_1P_REMAPPING, false);
+ ksz_port_cfg(dev, port, P_802_1P_CTRL,
+ masks->port_802_1p_remapping, false);
/* enable 802.1p priority */
ksz_port_cfg(dev, port, P_PRIO_CTRL, PORT_802_1P_ENABLE, true);
@@ -973,6 +1057,9 @@ static void ksz8_port_setup(struct ksz_device *dev, int port, bool cpu_port)
static void ksz8_config_cpu_port(struct dsa_switch *ds)
{
struct ksz_device *dev = ds->priv;
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_regs *regs = ksz8->regs;
+ struct ksz_masks *masks = ksz8->masks;
struct ksz_port *p;
u8 remote;
int i;
@@ -981,7 +1068,7 @@ static void ksz8_config_cpu_port(struct dsa_switch *ds)
/* Switch marks the maximum frame with extra byte as oversize. */
ksz_cfg(dev, REG_SW_CTRL_2, SW_LEGAL_PACKET_DISABLE, true);
- ksz_cfg(dev, S_TAIL_TAG_CTRL, SW_TAIL_TAG_ENABLE, true);
+ ksz_cfg(dev, regs->s_tail_tag_ctrl, masks->sw_tail_tag_enable, true);
p = &dev->ports[dev->cpu_port];
p->vid_member = dev->port_mask;
@@ -1010,7 +1097,7 @@ static void ksz8_config_cpu_port(struct dsa_switch *ds)
p = &dev->ports[i];
if (!p->on)
continue;
- ksz_pread8(dev, i, P_REMOTE_STATUS, &remote);
+ ksz_pread8(dev, i, regs->p_remote_status, &remote);
if (remote & PORT_FIBER_MODE)
p->fiber = 1;
if (p->fiber)
@@ -1204,6 +1291,7 @@ static const struct ksz_chip_data ksz8_switch_chips[] = {
static int ksz8_switch_init(struct ksz_device *dev)
{
int i;
+ struct ksz8 *ksz8 = dev->priv;
dev->ds->ops = &ksz8_switch_ops;
@@ -1226,6 +1314,10 @@ static int ksz8_switch_init(struct ksz_device *dev)
if (!dev->cpu_ports)
return -ENODEV;
+ ksz8->regs = &ksz8795_regs;
+ ksz8->masks = &ksz8795_masks;
+ ksz8->shifts = &ksz8795_shifts;
+
dev->port_mask = BIT(dev->port_cnt) - 1;
dev->port_mask |= dev->host_mask;
--
2.28.0
^ permalink raw reply related
* [PATCH v4 08/11] net: dsa: microchip: ksz8795: add support for ksz88xx chips
From: Michael Grzeschik @ 2020-08-03 5:44 UTC (permalink / raw)
To: andrew; +Cc: netdev, f.fainelli, davem, kernel
In-Reply-To: <20200803054442.20089-1-m.grzeschik@pengutronix.de>
We add support for the ksz8863 and ksz8873 chips which are
using the same register patterns but other offsets as the
ksz8795.
Signed-off-by: Michael Grzeschik <m.grzeschik@pengutronix.de>
---
v1 -> v4: - extracted this change from bigger previous patch
drivers/net/dsa/microchip/ksz8795.c | 541 +++++++++++++++++-------
drivers/net/dsa/microchip/ksz8795_reg.h | 214 +++++-----
drivers/net/dsa/microchip/ksz8863_reg.h | 124 ++++++
3 files changed, 629 insertions(+), 250 deletions(-)
create mode 100644 drivers/net/dsa/microchip/ksz8863_reg.h
diff --git a/drivers/net/dsa/microchip/ksz8795.c b/drivers/net/dsa/microchip/ksz8795.c
index 480143905d75579..4531bc413001c1e 100644
--- a/drivers/net/dsa/microchip/ksz8795.c
+++ b/drivers/net/dsa/microchip/ksz8795.c
@@ -20,50 +20,109 @@
#include "ksz_common.h"
#include "ksz8795_reg.h"
+#include "ksz8863_reg.h"
#include "ksz8.h"
static struct ksz_regs ksz8795_regs = {
- .ind_ctrl_0 = REG_IND_CTRL_0,
- .ind_data_8 = REG_IND_DATA_8,
- .ind_data_check = REG_IND_DATA_CHECK,
- .ind_data_hi = REG_IND_DATA_HI,
- .ind_data_lo = REG_IND_DATA_LO,
- .ind_mib_check = REG_IND_MIB_CHECK,
- .p_force_ctrl = P_FORCE_CTRL,
- .p_link_status = P_LINK_STATUS,
- .p_local_ctrl = P_LOCAL_CTRL,
- .p_neg_restart_ctrl = P_NEG_RESTART_CTRL,
- .p_remote_status = P_REMOTE_STATUS,
- .p_speed_status = P_SPEED_STATUS,
- .s_tail_tag_ctrl = S_TAIL_TAG_CTRL,
+ .ind_ctrl_0 = KSZ8795_REG_IND_CTRL_0,
+ .ind_data_8 = KSZ8795_REG_IND_DATA_8,
+ .ind_data_check = KSZ8795_REG_IND_DATA_CHECK,
+ .ind_data_hi = KSZ8795_REG_IND_DATA_HI,
+ .ind_data_lo = KSZ8795_REG_IND_DATA_LO,
+ .ind_mib_check = KSZ8795_REG_IND_MIB_CHECK,
+ .p_force_ctrl = KSZ8795_P_FORCE_CTRL,
+ .p_link_status = KSZ8795_P_LINK_STATUS,
+ .p_local_ctrl = KSZ8795_P_LOCAL_CTRL,
+ .p_neg_restart_ctrl = KSZ8795_P_NEG_RESTART_CTRL,
+ .p_remote_status = KSZ8795_P_REMOTE_STATUS,
+ .p_speed_status = KSZ8795_P_SPEED_STATUS,
+ .s_tail_tag_ctrl = KSZ8795_S_TAIL_TAG_CTRL,
};
static struct ksz_masks ksz8795_masks = {
- .port_802_1p_remapping = PORT_802_1P_REMAPPING,
- .sw_tail_tag_enable = SW_TAIL_TAG_ENABLE,
- .mib_counter_overflow = MIB_COUNTER_OVERFLOW,
- .mib_counter_valid = MIB_COUNTER_VALID,
- .vlan_table_fid = VLAN_TABLE_FID,
- .vlan_table_membership = VLAN_TABLE_MEMBERSHIP,
- .vlan_table_valid = VLAN_TABLE_VALID,
- .static_mac_table_valid = STATIC_MAC_TABLE_VALID,
- .static_mac_table_use_fid = STATIC_MAC_TABLE_USE_FID,
- .static_mac_table_fid = STATIC_MAC_TABLE_FID,
- .static_mac_table_override = STATIC_MAC_TABLE_OVERRIDE,
- .static_mac_table_fwd_ports = STATIC_MAC_TABLE_FWD_PORTS,
- .dynamic_mac_table_entries_h = DYNAMIC_MAC_TABLE_ENTRIES_H,
- .dynamic_mac_table_mac_empty = DYNAMIC_MAC_TABLE_MAC_EMPTY,
- .dynamic_mac_table_not_ready = DYNAMIC_MAC_TABLE_NOT_READY,
- .dynamic_mac_table_entries = DYNAMIC_MAC_TABLE_ENTRIES,
- .dynamic_mac_table_fid = DYNAMIC_MAC_TABLE_FID,
- .dynamic_mac_table_src_port = DYNAMIC_MAC_TABLE_SRC_PORT,
- .dynamic_mac_table_timestamp = DYNAMIC_MAC_TABLE_TIMESTAMP,
+ .port_802_1p_remapping = KSZ8795_PORT_802_1P_REMAPPING,
+ .sw_tail_tag_enable = KSZ8795_SW_TAIL_TAG_ENABLE,
+ .mib_counter_overflow = KSZ8795_MIB_COUNTER_OVERFLOW,
+ .mib_counter_valid = KSZ8795_MIB_COUNTER_VALID,
+ .vlan_table_fid = KSZ8795_VLAN_TABLE_FID,
+ .vlan_table_membership = KSZ8795_VLAN_TABLE_MEMBERSHIP,
+ .vlan_table_valid = KSZ8795_VLAN_TABLE_VALID,
+ .static_mac_table_valid = KSZ8795_STATIC_MAC_TABLE_VALID,
+ .static_mac_table_use_fid = KSZ8795_STATIC_MAC_TABLE_USE_FID,
+ .static_mac_table_fid = KSZ8795_STATIC_MAC_TABLE_FID,
+ .static_mac_table_override = KSZ8795_STATIC_MAC_TABLE_OVERRIDE,
+ .static_mac_table_fwd_ports = KSZ8795_STATIC_MAC_TABLE_FWD_PORTS,
+ .dynamic_mac_table_entries_h = KSZ8795_DYNAMIC_MAC_TABLE_ENTRIES_H,
+ .dynamic_mac_table_mac_empty = KSZ8795_DYNAMIC_MAC_TABLE_MAC_EMPTY,
+ .dynamic_mac_table_not_ready = KSZ8795_DYNAMIC_MAC_TABLE_NOT_READY,
+ .dynamic_mac_table_entries = KSZ8795_DYNAMIC_MAC_TABLE_ENTRIES,
+ .dynamic_mac_table_fid = KSZ8795_DYNAMIC_MAC_TABLE_FID,
+ .dynamic_mac_table_src_port = KSZ8795_DYNAMIC_MAC_TABLE_SRC_PORT,
+ .dynamic_mac_table_timestamp = KSZ8795_DYNAMIC_MAC_TABLE_TIMESTAMP,
};
+static struct ksz_shifts ksz8795_shifts = {
+ .vlan_table_membership = KSZ8795_VLAN_TABLE_MEMBERSHIP_S,
+ .vlan_table = KSZ8795_VLAN_TABLE_S,
+ .static_mac_fwd_ports = KSZ8795_STATIC_MAC_FWD_PORTS_S,
+ .static_mac_fid = KSZ8795_STATIC_MAC_FID_S,
+ .dynamic_mac_entries = KSZ8795_DYNAMIC_MAC_ENTRIES_S,
+ .dynamic_mac_fid = KSZ8795_DYNAMIC_MAC_FID_S,
+ .dynamic_mac_timestamp = KSZ8795_DYNAMIC_MAC_TIMESTAMP_S,
+ .dynamic_mac_src_port = KSZ8795_DYNAMIC_MAC_SRC_PORT_S,
+};
+
+static struct ksz_regs ksz8863_regs = {
+ .ind_ctrl_0 = KSZ8863_REG_IND_CTRL_0,
+ .ind_data_8 = KSZ8863_REG_IND_DATA_8,
+ .ind_data_check = KSZ8863_REG_IND_DATA_CHECK,
+ .ind_data_hi = KSZ8863_REG_IND_DATA_HI,
+ .ind_data_lo = KSZ8863_REG_IND_DATA_LO,
+ .ind_mib_check = KSZ8863_REG_IND_MIB_CHECK,
+ .p_force_ctrl = KSZ8863_P_FORCE_CTRL,
+ .p_link_status = KSZ8863_P_LINK_STATUS,
+ .p_local_ctrl = KSZ8863_P_LOCAL_CTRL,
+ .p_neg_restart_ctrl = KSZ8863_P_NEG_RESTART_CTRL,
+ .p_remote_status = KSZ8863_P_REMOTE_STATUS,
+ .p_speed_status = KSZ8863_P_SPEED_STATUS,
+ .s_tail_tag_ctrl = KSZ8863_S_TAIL_TAG_CTRL,
+};
+
+static struct ksz_masks ksz8863_masks = {
+ .port_802_1p_remapping = KSZ8863_PORT_802_1P_REMAPPING,
+ .sw_tail_tag_enable = KSZ8863_SW_TAIL_TAG_ENABLE,
+ .mib_counter_overflow = KSZ8863_MIB_COUNTER_OVERFLOW,
+ .mib_counter_valid = KSZ8863_MIB_COUNTER_VALID,
+ .vlan_table_fid = KSZ8863_VLAN_TABLE_FID,
+ .vlan_table_membership = KSZ8863_VLAN_TABLE_MEMBERSHIP,
+ .vlan_table_valid = KSZ8863_VLAN_TABLE_VALID,
+ .static_mac_table_valid = KSZ8863_STATIC_MAC_TABLE_VALID,
+ .static_mac_table_use_fid = KSZ8863_STATIC_MAC_TABLE_USE_FID,
+ .static_mac_table_fid = KSZ8863_STATIC_MAC_TABLE_FID,
+ .static_mac_table_override = KSZ8863_STATIC_MAC_TABLE_OVERRIDE,
+ .static_mac_table_fwd_ports = KSZ8863_STATIC_MAC_TABLE_FWD_PORTS,
+ .dynamic_mac_table_entries_h = KSZ8863_DYNAMIC_MAC_TABLE_ENTRIES_H,
+ .dynamic_mac_table_mac_empty = KSZ8863_DYNAMIC_MAC_TABLE_MAC_EMPTY,
+ .dynamic_mac_table_not_ready = KSZ8863_DYNAMIC_MAC_TABLE_NOT_READY,
+ .dynamic_mac_table_entries = KSZ8863_DYNAMIC_MAC_TABLE_ENTRIES,
+ .dynamic_mac_table_fid = KSZ8863_DYNAMIC_MAC_TABLE_FID,
+ .dynamic_mac_table_src_port = KSZ8863_DYNAMIC_MAC_TABLE_SRC_PORT,
+ .dynamic_mac_table_timestamp = KSZ8863_DYNAMIC_MAC_TABLE_TIMESTAMP,
+};
+
+static struct ksz_shifts ksz8863_shifts = {
+ .vlan_table_membership = KSZ8863_VLAN_TABLE_MEMBERSHIP_S,
+ .static_mac_fwd_ports = KSZ8863_STATIC_MAC_FWD_PORTS_S,
+ .static_mac_fid = KSZ8863_STATIC_MAC_FID_S,
+ .dynamic_mac_entries = KSZ8863_DYNAMIC_MAC_ENTRIES_S,
+ .dynamic_mac_fid = KSZ8863_DYNAMIC_MAC_FID_S,
+ .dynamic_mac_timestamp = KSZ8863_DYNAMIC_MAC_TIMESTAMP_S,
+ .dynamic_mac_src_port = KSZ8863_DYNAMIC_MAC_SRC_PORT_S,
+};
static const struct {
char string[ETH_GSTRING_LEN];
-} mib_names[TOTAL_SWITCH_COUNTER_NUM] = {
+} ksz87xx_mib_names[TOTAL_KSZ8795_COUNTER_NUM] = {
{ "rx_hi" },
{ "rx_undersize" },
{ "rx_fragments" },
@@ -102,6 +161,45 @@ static const struct {
{ "tx_discards" },
};
+static const struct {
+ char string[ETH_GSTRING_LEN];
+} ksz88xx_mib_names[TOTAL_KSZ8863_COUNTER_NUM] = {
+ { "rx" },
+ { "rx_hi" },
+ { "rx_undersize" },
+ { "rx_fragments" },
+ { "rx_oversize" },
+ { "rx_jabbers" },
+ { "rx_symbol_err" },
+ { "rx_crc_err" },
+ { "rx_align_err" },
+ { "rx_mac_ctrl" },
+ { "rx_pause" },
+ { "rx_bcast" },
+ { "rx_mcast" },
+ { "rx_ucast" },
+ { "rx_64_or_less" },
+ { "rx_65_127" },
+ { "rx_128_255" },
+ { "rx_256_511" },
+ { "rx_512_1023" },
+ { "rx_1024_1522" },
+ { "tx" },
+ { "tx_hi" },
+ { "tx_late_col" },
+ { "tx_pause" },
+ { "tx_bcast" },
+ { "tx_mcast" },
+ { "tx_ucast" },
+ { "tx_deferred" },
+ { "tx_total_col" },
+ { "tx_exc_col" },
+ { "tx_single_col" },
+ { "tx_mult_col" },
+ { "rx_discards" },
+ { "tx_discards" },
+};
+
static void ksz_cfg(struct ksz_device *dev, u32 addr, u8 bits, bool set)
{
regmap_update_bits(dev->regmap[0], addr, bits, set ? bits : 0);
@@ -114,12 +212,23 @@ static void ksz_port_cfg(struct ksz_device *dev, int port, int offset, u8 bits,
bits, set ? bits : 0);
}
+static int ksz_is_87(struct ksz_device *dev)
+{
+ return (((dev->chip_id) >> 8) == KSZ87_FAMILY_ID);
+}
+
static int ksz8_reset_switch(struct ksz_device *dev)
{
- /* reset switch */
- ksz_write8(dev, REG_POWER_MANAGEMENT_1,
- SW_SOFTWARE_POWER_DOWN << SW_POWER_MANAGEMENT_MODE_S);
- ksz_write8(dev, REG_POWER_MANAGEMENT_1, 0);
+ if (ksz_is_87(dev)) {
+ /* reset switch */
+ ksz_write8(dev, REG_POWER_MANAGEMENT_1,
+ SW_SOFTWARE_POWER_DOWN << SW_POWER_MANAGEMENT_MODE_S);
+ ksz_write8(dev, REG_POWER_MANAGEMENT_1, 0);
+ } else {
+ /* reset switch */
+ ksz_cfg(dev, KSZ8863_REG_SW_RESET,
+ KSZ8863_GLOBAL_SOFTWARE_RESET | KSZ8863_PCS_RESET, true);
+ }
return 0;
}
@@ -190,8 +299,8 @@ static void ksz8_r_mib_cnt(struct ksz_device *dev, int port, u16 addr, u64 *cnt)
mutex_unlock(&dev->alu_mutex);
}
-static void ksz8_r_mib_pkt(struct ksz_device *dev, int port, u16 addr,
- u64 *dropped, u64 *cnt)
+static void ksz8795_r_mib_pkt(struct ksz_device *dev, int port, u16 addr,
+ u64 *dropped, u64 *cnt)
{
struct ksz8 *ksz8 = dev->priv;
struct ksz_regs *regs = ksz8->regs;
@@ -200,9 +309,9 @@ static void ksz8_r_mib_pkt(struct ksz_device *dev, int port, u16 addr,
u8 check;
int loop;
- addr -= SWITCH_COUNTER_NUM;
- ctrl_addr = (KS_MIB_TOTAL_RX_1 - KS_MIB_TOTAL_RX_0) * port;
- ctrl_addr += addr + KS_MIB_TOTAL_RX_0;
+ addr -= dev->reg_mib_cnt;
+ ctrl_addr = (KSZ8795_MIB_TOTAL_RX_1 - KSZ8795_MIB_TOTAL_RX_0) * port;
+ ctrl_addr += addr + KSZ8795_MIB_TOTAL_RX_0;
ctrl_addr |= IND_ACC_TABLE(TABLE_MIB | TABLE_READ);
mutex_lock(&dev->alu_mutex);
@@ -214,7 +323,7 @@ static void ksz8_r_mib_pkt(struct ksz_device *dev, int port, u16 addr,
for (loop = 2; loop > 0; loop--) {
ksz_read8(dev, regs->ind_mib_check, &check);
- if (check & MIB_COUNTER_VALID) {
+ if (check & KSZ8795_MIB_COUNTER_VALID) {
ksz_read32(dev, regs->ind_data_lo, &data);
if (addr < 2) {
u64 total;
@@ -223,13 +332,13 @@ static void ksz8_r_mib_pkt(struct ksz_device *dev, int port, u16 addr,
total <<= 32;
*cnt += total;
*cnt += data;
- if (check & MIB_COUNTER_OVERFLOW) {
+ if (check & KSZ8795_MIB_COUNTER_OVERFLOW) {
total = MIB_TOTAL_BYTES_H + 1;
total <<= 32;
*cnt += total;
}
} else {
- if (check & MIB_COUNTER_OVERFLOW)
+ if (check & KSZ8795_MIB_COUNTER_OVERFLOW)
*cnt += MIB_PACKET_DROPPED + 1;
*cnt += data & MIB_PACKET_DROPPED;
}
@@ -239,8 +348,53 @@ static void ksz8_r_mib_pkt(struct ksz_device *dev, int port, u16 addr,
mutex_unlock(&dev->alu_mutex);
}
+static void ksz8863_r_mib_pkt(struct ksz_device *dev, int port, u16 addr,
+ u64 *dropped, u64 *cnt)
+{
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_regs *regs = ksz8->regs;
+ u32 *last = (u32 *)dropped;
+ u16 ctrl_addr;
+ u32 data;
+ u32 cur;
+
+ addr -= dev->reg_mib_cnt;
+ ctrl_addr = addr ? KSZ8863_MIB_PACKET_DROPPED_TX_0 :
+ KSZ8863_MIB_PACKET_DROPPED_RX_0;
+ ctrl_addr += port;
+ ctrl_addr |= IND_ACC_TABLE(TABLE_MIB | TABLE_READ);
+
+ mutex_lock(&dev->alu_mutex);
+ ksz_write16(dev, regs->ind_ctrl_0, ctrl_addr);
+ ksz_read32(dev, regs->ind_data_lo, &data);
+ mutex_unlock(&dev->alu_mutex);
+
+ data &= MIB_PACKET_DROPPED;
+ cur = last[addr];
+ if (data != cur) {
+ last[addr] = data;
+ if (data < cur)
+ data += MIB_PACKET_DROPPED + 1;
+ data -= cur;
+ *cnt += data;
+ }
+}
+
+static void ksz8_r_mib_pkt(struct ksz_device *dev, int port, u16 addr,
+ u64 *dropped, u64 *cnt)
+{
+ if (ksz_is_87(dev)) {
+ ksz8795_r_mib_pkt(dev, port, addr, dropped, cnt);
+ } else {
+ ksz8863_r_mib_pkt(dev, port, addr, dropped, cnt);
+ }
+}
+
static void ksz8_freeze_mib(struct ksz_device *dev, int port, bool freeze)
{
+ if (!ksz_is_87(dev))
+ return;
+
/* enable the port for flush/freeze function */
if (freeze)
ksz_cfg(dev, REG_SW_CTRL_6, BIT(port), true);
@@ -254,11 +408,14 @@ static void ksz8_freeze_mib(struct ksz_device *dev, int port, bool freeze)
static void ksz8_port_init_cnt(struct ksz_device *dev, int port)
{
struct ksz_port_mib *mib = &dev->ports[port].mib;
+ u64 *dropped;
- /* flush all enabled port MIB counters */
- ksz_cfg(dev, REG_SW_CTRL_6, BIT(port), true);
- ksz_cfg(dev, REG_SW_CTRL_6, SW_MIB_COUNTER_FLUSH, true);
- ksz_cfg(dev, REG_SW_CTRL_6, BIT(port), false);
+ if (ksz_is_87(dev)) {
+ /* flush all enabled port MIB counters */
+ ksz_cfg(dev, REG_SW_CTRL_6, BIT(port), true);
+ ksz_cfg(dev, REG_SW_CTRL_6, SW_MIB_COUNTER_FLUSH, true);
+ ksz_cfg(dev, REG_SW_CTRL_6, BIT(port), false);
+ }
mib->cnt_ptr = 0;
@@ -269,10 +426,13 @@ static void ksz8_port_init_cnt(struct ksz_device *dev, int port)
++mib->cnt_ptr;
}
+ /* last one in storage */
+ dropped = &mib->counters[dev->mib_cnt];
+
/* Some ports may not have MIB counters after SWITCH_COUNTER_NUM. */
while (mib->cnt_ptr < dev->mib_cnt) {
dev->dev_ops->r_mib_pkt(dev, port, mib->cnt_ptr,
- NULL, &mib->counters[mib->cnt_ptr]);
+ dropped, &mib->counters[mib->cnt_ptr]);
++mib->cnt_ptr;
}
mib->cnt_ptr = 0;
@@ -420,6 +580,7 @@ static int ksz8_r_sta_mac_table(struct ksz_device *dev, u16 addr,
alu->is_override =
(data_hi & masks->static_mac_table_override) ? 1 : 0;
data_hi >>= 1;
+ alu->is_static = true;
alu->is_use_fid =
(data_hi & masks->static_mac_table_use_fid) ? 1 : 0;
alu->fid = (data_hi & masks->static_mac_table_fid) >>
@@ -495,37 +656,45 @@ static void ksz8_r_vlan_entries(struct ksz_device *dev, u16 addr)
ksz8_r_table(dev, TABLE_VLAN, addr, &data);
addr *= dev->port_cnt;
for (i = 0; i < dev->port_cnt; i++) {
- dev->vlan_cache[addr + i].table[0] = (u16)data;
- data >>= shifts->vlan_table;
+ if (ksz_is_87(dev)) {
+ dev->vlan_cache[addr + i].table[0] = (u16)data;
+ data >>= shifts->vlan_table;
+ } else {
+ dev->vlan_cache[addr + i].table[0] = (u32)data;
+ }
}
}
static void ksz8_r_vlan_table(struct ksz_device *dev, u16 vid, u32 *vlan)
{
- int index;
- u16 *data;
- u16 addr;
+ u16 addr = vid / dev->port_cnt;
u64 buf;
- data = (u16 *)&buf;
- addr = vid / dev->port_cnt;
- index = vid & 3;
ksz8_r_table(dev, TABLE_VLAN, addr, &buf);
- *vlan = data[index];
+ if (ksz_is_87(dev)) {
+ u16 *data = (u16 *)&buf;
+
+ *vlan = data[vid & 3];
+ } else {
+ *vlan = (u32)buf;
+ }
}
static void ksz8_w_vlan_table(struct ksz_device *dev, u16 vid, u32 vlan)
{
- int index;
- u16 *data;
- u16 addr;
+ u16 addr = vid / dev->port_cnt;
u64 buf;
- data = (u16 *)&buf;
- addr = vid / dev->port_cnt;
- index = vid & 3;
ksz8_r_table(dev, TABLE_VLAN, addr, &buf);
- data[index] = vlan;
+
+ if (ksz_is_87(dev)) {
+ u16 *data = (u16 *)&buf;
+
+ data[vid & 3] = vlan;
+ } else {
+ buf = vlan;
+ }
+
dev->vlan_cache[vid].table[0] = vlan;
ksz8_w_table(dev, TABLE_VLAN, addr, buf);
}
@@ -548,8 +717,13 @@ static void ksz8_r_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 *val)
data |= PHY_LOOPBACK;
if (ctrl & PORT_FORCE_100_MBIT)
data |= PHY_SPEED_100MBIT;
- if (!(ctrl & PORT_AUTO_NEG_DISABLE))
- data |= PHY_AUTO_NEG_ENABLE;
+ if (ksz_is_87(dev)) {
+ if (!(ctrl & PORT_AUTO_NEG_DISABLE))
+ data |= PHY_AUTO_NEG_ENABLE;
+ } else {
+ if ((ctrl & PORT_AUTO_NEG_ENABLE))
+ data |= PHY_AUTO_NEG_ENABLE;
+ }
if (restart & PORT_POWER_DOWN)
data |= PHY_POWER_DOWN;
if (restart & PORT_AUTO_NEG_RESTART)
@@ -580,10 +754,16 @@ static void ksz8_r_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 *val)
data |= PHY_LINK_STATUS;
break;
case PHY_REG_ID_1:
- data = KSZ8795_ID_HI;
+ if (ksz_is_87(dev))
+ data = KSZ8795_ID_HI;
+ else
+ data = KSZ8863_ID_HI;
break;
case PHY_REG_ID_2:
- data = KSZ8795_ID_LO;
+ if (ksz_is_87(dev))
+ data = KSZ8795_ID_LO;
+ else
+ data = KSZ8863_ID_LO;
break;
case PHY_REG_AUTO_NEGOTIATION:
ksz_pread8(dev, p, regs->p_local_ctrl, &ctrl);
@@ -646,14 +826,21 @@ static void ksz8_w_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 val)
ksz_pwrite8(dev, p, regs->p_speed_status, data);
ksz_pread8(dev, p, regs->p_force_ctrl, &ctrl);
data = ctrl;
- if (!(val & PHY_AUTO_NEG_ENABLE))
- data |= PORT_AUTO_NEG_DISABLE;
- else
- data &= ~PORT_AUTO_NEG_DISABLE;
-
- /* Fiber port does not support auto-negotiation. */
- if (dev->ports[p].fiber)
- data |= PORT_AUTO_NEG_DISABLE;
+ if (ksz_is_87(dev)) {
+ if (!(val & PHY_AUTO_NEG_ENABLE))
+ data |= PORT_AUTO_NEG_DISABLE;
+ else
+ data &= ~PORT_AUTO_NEG_DISABLE;
+
+ /* Fiber port does not support auto-negotiation. */
+ if (dev->ports[p].fiber)
+ data |= PORT_AUTO_NEG_DISABLE;
+ } else {
+ if ((val & PHY_AUTO_NEG_ENABLE))
+ data |= PORT_AUTO_NEG_ENABLE;
+ else
+ data &= ~PORT_AUTO_NEG_ENABLE;
+ }
if (val & PHY_SPEED_100MBIT)
data |= PORT_FORCE_100_MBIT;
else
@@ -727,26 +914,46 @@ static enum dsa_tag_protocol ksz8_get_tag_protocol(struct dsa_switch *ds,
int port,
enum dsa_tag_protocol mp)
{
- return DSA_TAG_PROTO_KSZ8795;
+ struct ksz_device *dev = ds->priv;
+
+ return ksz_is_87(dev) ?
+ DSA_TAG_PROTO_KSZ8795 : DSA_TAG_PROTO_KSZ8863;
}
static void ksz8_get_strings(struct dsa_switch *ds, int port,
u32 stringset, uint8_t *buf)
{
+ struct ksz_device *dev = ds->priv;
+ int switch_counter;
int i;
- for (i = 0; i < TOTAL_SWITCH_COUNTER_NUM; i++) {
- memcpy(buf + i * ETH_GSTRING_LEN, mib_names[i].string,
- ETH_GSTRING_LEN);
+ if (ksz_is_87(dev))
+ switch_counter = TOTAL_KSZ8795_COUNTER_NUM;
+ else
+ switch_counter = TOTAL_KSZ8863_COUNTER_NUM;
+
+ for (i = 0; i < switch_counter; i++) {
+ const char *s;
+
+ if (ksz_is_87(dev))
+ s = ksz87xx_mib_names[i].string;
+ else
+ s = ksz88xx_mib_names[i].string;
+
+ memcpy(buf + i * ETH_GSTRING_LEN, s, ETH_GSTRING_LEN);
}
}
static void ksz8_cfg_port_member(struct ksz_device *dev, int port, u8 member)
{
+ int membership = PORT_VLAN_MEMBERSHIP;
u8 data;
+ if (!ksz_is_87(dev))
+ membership = (membership >> 2);
+
ksz_pread8(dev, port, P_MIRROR_CTRL, &data);
- data &= ~PORT_VLAN_MEMBERSHIP;
+ data &= ~(membership);
data |= (member & dev->port_mask);
ksz_pwrite8(dev, port, P_MIRROR_CTRL, data);
dev->ports[port].member = member;
@@ -990,17 +1197,58 @@ static void ksz8_port_mirror_del(struct dsa_switch *ds, int port,
PORT_MIRROR_SNIFFER, false);
}
+static void ksz8795_cpu_interface_select(struct ksz_device *dev, int port)
+{
+ struct ksz_port *p = &dev->ports[port];
+ u8 data8;
+
+ /* Configure MII interface for proper network communication. */
+ ksz_read8(dev, REG_PORT_5_CTRL_6, &data8);
+ data8 &= ~PORT_INTERFACE_TYPE;
+ data8 &= ~PORT_GMII_1GPS_MODE;
+ switch (dev->interface) {
+ case PHY_INTERFACE_MODE_MII:
+ p->phydev.speed = SPEED_100;
+ break;
+ case PHY_INTERFACE_MODE_RMII:
+ data8 |= PORT_INTERFACE_RMII;
+ p->phydev.speed = SPEED_100;
+ break;
+ case PHY_INTERFACE_MODE_GMII:
+ data8 |= PORT_GMII_1GPS_MODE;
+ data8 |= PORT_INTERFACE_GMII;
+ p->phydev.speed = SPEED_1000;
+ break;
+ default:
+ data8 &= ~PORT_RGMII_ID_IN_ENABLE;
+ data8 &= ~PORT_RGMII_ID_OUT_ENABLE;
+ if (dev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
+ dev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
+ data8 |= PORT_RGMII_ID_IN_ENABLE;
+ if (dev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
+ dev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
+ data8 |= PORT_RGMII_ID_OUT_ENABLE;
+ data8 |= PORT_GMII_1GPS_MODE;
+ data8 |= PORT_INTERFACE_RGMII;
+ p->phydev.speed = SPEED_1000;
+ break;
+ }
+ ksz_write8(dev, REG_PORT_5_CTRL_6, data8);
+ p->phydev.duplex = 1;
+}
+
static void ksz8_port_setup(struct ksz_device *dev, int port, bool cpu_port)
{
struct ksz_port *p = &dev->ports[port];
- u8 data8, member;
+ u8 member;
struct ksz8 *ksz8 = dev->priv;
struct ksz_masks *masks = ksz8->masks;
/* enable broadcast storm limit */
ksz_port_cfg(dev, port, P_BCAST_STORM_CTRL, PORT_BROADCAST_STORM, true);
- ksz8795_set_prio_queue(dev, port, 4);
+ if (ksz_is_87(dev))
+ ksz8795_set_prio_queue(dev, port, 4);
/* disable DiffServ priority */
ksz_port_cfg(dev, port, P_PRIO_CTRL, PORT_DIFFSERV_ENABLE, false);
@@ -1013,39 +1261,8 @@ static void ksz8_port_setup(struct ksz_device *dev, int port, bool cpu_port)
ksz_port_cfg(dev, port, P_PRIO_CTRL, PORT_802_1P_ENABLE, true);
if (cpu_port) {
- /* Configure MII interface for proper network communication. */
- ksz_read8(dev, REG_PORT_5_CTRL_6, &data8);
- data8 &= ~PORT_INTERFACE_TYPE;
- data8 &= ~PORT_GMII_1GPS_MODE;
- switch (dev->interface) {
- case PHY_INTERFACE_MODE_MII:
- p->phydev.speed = SPEED_100;
- break;
- case PHY_INTERFACE_MODE_RMII:
- data8 |= PORT_INTERFACE_RMII;
- p->phydev.speed = SPEED_100;
- break;
- case PHY_INTERFACE_MODE_GMII:
- data8 |= PORT_GMII_1GPS_MODE;
- data8 |= PORT_INTERFACE_GMII;
- p->phydev.speed = SPEED_1000;
- break;
- default:
- data8 &= ~PORT_RGMII_ID_IN_ENABLE;
- data8 &= ~PORT_RGMII_ID_OUT_ENABLE;
- if (dev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
- dev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
- data8 |= PORT_RGMII_ID_IN_ENABLE;
- if (dev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
- dev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
- data8 |= PORT_RGMII_ID_OUT_ENABLE;
- data8 |= PORT_GMII_1GPS_MODE;
- data8 |= PORT_INTERFACE_RGMII;
- p->phydev.speed = SPEED_1000;
- break;
- }
- ksz_write8(dev, REG_PORT_5_CTRL_6, data8);
- p->phydev.duplex = 1;
+ if (ksz_is_87(dev))
+ ksz8795_cpu_interface_select(dev, port);
member = dev->port_mask;
} else {
@@ -1097,9 +1314,11 @@ static void ksz8_config_cpu_port(struct dsa_switch *ds)
p = &dev->ports[i];
if (!p->on)
continue;
- ksz_pread8(dev, i, regs->p_remote_status, &remote);
- if (remote & PORT_FIBER_MODE)
- p->fiber = 1;
+ if (ksz_is_87(dev)) {
+ ksz_pread8(dev, i, regs->p_remote_status, &remote);
+ if (remote & PORT_FIBER_MODE)
+ p->fiber = 1;
+ }
if (p->fiber)
ksz_port_cfg(dev, i, P_STP_CTRL, PORT_FORCE_FLOW_CTRL,
true);
@@ -1120,7 +1339,7 @@ static int ksz8_setup(struct dsa_switch *ds)
if (!dev->vlan_cache)
return -ENOMEM;
- ret = ksz8_reset_switch(dev);
+ ksz8_reset_switch(dev);
if (ret) {
dev_err(ds->dev, "failed to reset switch\n");
return ret;
@@ -1157,7 +1376,7 @@ static int ksz8_setup(struct dsa_switch *ds)
(BROADCAST_STORM_VALUE *
BROADCAST_STORM_PROT_RATE) / 100);
- for (i = 0; i < VLAN_TABLE_ENTRIES; i++)
+ for (i = 0; i < (dev->num_vlans / 2); i++)
ksz8_r_vlan_entries(dev, i);
/* Setup STP address for STP operation. */
@@ -1218,25 +1437,39 @@ static int ksz8_switch_detect(struct ksz_device *dev)
id1 = id16 >> 8;
id2 = id16 & SW_CHIP_ID_M;
- if (id1 != FAMILY_ID ||
- (id2 != CHIP_ID_94 && id2 != CHIP_ID_95))
- return -ENODEV;
- dev->mib_port_cnt = TOTAL_PORT_NUM;
- dev->phy_port_cnt = SWITCH_PORT_NUM;
- dev->port_cnt = SWITCH_PORT_NUM;
-
- if (id2 == CHIP_ID_95) {
- u8 val;
-
- id2 = 0x95;
- ksz_read8(dev, REG_PORT_1_STATUS_0, &val);
- if (val & PORT_FIBER_MODE)
- id2 = 0x65;
- } else if (id2 == CHIP_ID_94) {
- dev->port_cnt--;
- dev->last_port = dev->port_cnt;
- id2 = 0x94;
+ switch (id1) {
+ case KSZ87_FAMILY_ID:
+ if ((id2 != CHIP_ID_94 && id2 != CHIP_ID_95))
+ return -ENODEV;
+
+ dev->mib_port_cnt = KSZ8795_TOTAL_PORT_NUM;
+ dev->phy_port_cnt = KSZ8795_SWITCH_PORT_NUM;
+ dev->port_cnt = KSZ8795_SWITCH_PORT_NUM;
+ if (id2 == CHIP_ID_95) {
+ u8 val;
+
+ id2 = 0x95;
+ ksz_read8(dev, KSZ8795_REG_PORT_STATUS_0, &val);
+ if (val & PORT_FIBER_MODE)
+ id2 = 0x65;
+ } else if (id2 == CHIP_ID_94) {
+ dev->port_cnt--;
+ dev->last_port = dev->port_cnt;
+ id2 = 0x94;
+ }
+ break;
+ case KSZ88_FAMILY_ID:
+ if (id2 != CHIP_ID_63)
+ return -ENODEV;
+
+ dev->mib_port_cnt = KSZ8863_TOTAL_PORT_NUM;
+ dev->phy_port_cnt = KSZ8863_SWITCH_PORT_NUM;
+ dev->port_cnt = KSZ8863_SWITCH_PORT_NUM;
+ break;
+ default:
+ dev_err(dev->dev, "invalid family id: %d\n", id1);
+ return -ENODEV;
}
id16 &= ~0xff;
id16 |= id2;
@@ -1286,6 +1519,15 @@ static const struct ksz_chip_data ksz8_switch_chips[] = {
.cpu_ports = 0x10, /* can be configured as cpu port */
.port_cnt = 4, /* total physical port count */
},
+ {
+ .chip_id = 0x8830,
+ .dev_name = "KSZ8863/KSZ8873",
+ .num_vlans = 16,
+ .num_alus = 0,
+ .num_statics = 8,
+ .cpu_ports = 0x4, /* can be configured as cpu port */
+ .port_cnt = 2, /* total physical port count */
+ },
};
static int ksz8_switch_init(struct ksz_device *dev)
@@ -1314,15 +1556,22 @@ static int ksz8_switch_init(struct ksz_device *dev)
if (!dev->cpu_ports)
return -ENODEV;
- ksz8->regs = &ksz8795_regs;
- ksz8->masks = &ksz8795_masks;
- ksz8->shifts = &ksz8795_shifts;
+ if (ksz_is_87(dev)) {
+ ksz8->regs = &ksz8795_regs;
+ ksz8->masks = &ksz8795_masks;
+ ksz8->shifts = &ksz8795_shifts;
+ dev->mib_cnt = TOTAL_KSZ8795_COUNTER_NUM;
+ } else {
+ ksz8->regs = &ksz8863_regs;
+ ksz8->masks = &ksz8863_masks;
+ ksz8->shifts = &ksz8863_shifts;
+ dev->mib_cnt = TOTAL_KSZ8863_COUNTER_NUM;
+ }
dev->port_mask = BIT(dev->port_cnt) - 1;
dev->port_mask |= dev->host_mask;
dev->reg_mib_cnt = SWITCH_COUNTER_NUM;
- dev->mib_cnt = TOTAL_SWITCH_COUNTER_NUM;
i = dev->mib_port_cnt;
dev->ports = devm_kzalloc(dev->dev, sizeof(struct ksz_port) * i,
@@ -1334,7 +1583,7 @@ static int ksz8_switch_init(struct ksz_device *dev)
dev->ports[i].mib.counters =
devm_kzalloc(dev->dev,
sizeof(u64) *
- (TOTAL_SWITCH_COUNTER_NUM + 1),
+ (dev->mib_cnt + 1),
GFP_KERNEL);
if (!dev->ports[i].mib.counters)
return -ENOMEM;
diff --git a/drivers/net/dsa/microchip/ksz8795_reg.h b/drivers/net/dsa/microchip/ksz8795_reg.h
index 3a50462df8fa9d2..ed543ceac6b7d7b 100644
--- a/drivers/net/dsa/microchip/ksz8795_reg.h
+++ b/drivers/net/dsa/microchip/ksz8795_reg.h
@@ -16,7 +16,7 @@
#define REG_CHIP_ID0 0x00
-#define FAMILY_ID 0x87
+#define KSZ87_FAMILY_ID 0x87
#define REG_CHIP_ID1 0x01
@@ -32,7 +32,7 @@
#define REG_SW_CTRL_0 0x02
#define SW_NEW_BACKOFF BIT(7)
-#define SW_GLOBAL_RESET BIT(6)
+#define KSZ8795_SW_GLOBAL_RESET BIT(6)
#define SW_FLUSH_DYN_MAC_TABLE BIT(5)
#define SW_FLUSH_STA_MAC_TABLE BIT(4)
#define SW_LINK_AUTO_AGING BIT(0)
@@ -98,7 +98,7 @@
#define REG_SW_CTRL_10 0x0C
-#define SW_TAIL_TAG_ENABLE BIT(1)
+#define KSZ8795_SW_TAIL_TAG_ENABLE BIT(1)
#define SW_PASS_PAUSE BIT(0)
#define REG_SW_CTRL_11 0x0D
@@ -150,7 +150,7 @@
#define REG_PORT_4_CTRL_2 0x42
#define REG_PORT_5_CTRL_2 0x52
-#define PORT_802_1P_REMAPPING BIT(7)
+#define KSZ8795_PORT_802_1P_REMAPPING BIT(7)
#define PORT_INGRESS_FILTER BIT(6)
#define PORT_DISCARD_NON_VID BIT(5)
#define PORT_FORCE_FLOW_CTRL BIT(4)
@@ -269,6 +269,7 @@
#define REG_PORT_3_CTRL_9 0x3C
#define REG_PORT_4_CTRL_9 0x4C
+#define PORT_AUTO_NEG_ENABLE BIT(7)
#define PORT_AUTO_NEG_DISABLE BIT(7)
#define PORT_FORCE_100_MBIT BIT(6)
#define PORT_FORCE_FULL_DUPLEX BIT(5)
@@ -320,30 +321,36 @@
#define REG_PORT_CTRL_5 0x05
#define REG_PORT_CTRL_7 0x07
-#define REG_PORT_STATUS_0 0x08
-#define REG_PORT_STATUS_1 0x09
+
+#define KSZ8795_REG_PORT_STATUS_0 0x08
+#define KSZ8795_REG_PORT_STATUS_1 0x09
+
#define REG_PORT_LINK_MD_CTRL 0x0A
#define REG_PORT_LINK_MD_RESULT 0x0B
-#define REG_PORT_CTRL_9 0x0C
-#define REG_PORT_CTRL_10 0x0D
-#define REG_PORT_STATUS_2 0x0E
-#define REG_PORT_STATUS_3 0x0F
-
-#define REG_PORT_CTRL_12 0xA0
-#define REG_PORT_CTRL_13 0xA1
-#define REG_PORT_RATE_CTRL_3 0xA2
-#define REG_PORT_RATE_CTRL_2 0xA3
-#define REG_PORT_RATE_CTRL_1 0xA4
-#define REG_PORT_RATE_CTRL_0 0xA5
-#define REG_PORT_RATE_LIMIT 0xA6
-#define REG_PORT_IN_RATE_0 0xA7
-#define REG_PORT_IN_RATE_1 0xA8
-#define REG_PORT_IN_RATE_2 0xA9
-#define REG_PORT_IN_RATE_3 0xAA
-#define REG_PORT_OUT_RATE_0 0xAB
-#define REG_PORT_OUT_RATE_1 0xAC
-#define REG_PORT_OUT_RATE_2 0xAD
-#define REG_PORT_OUT_RATE_3 0xAE
+
+#define KSZ8795_REG_PORT_CTRL_9 0x0C
+#define KSZ8795_REG_PORT_CTRL_10 0x0D
+#define KSZ8795_REG_PORT_STATUS_2 0x0E
+#define KSZ8795_REG_PORT_STATUS_3 0x0F
+
+#define REG_PORT_CTRL_12 0x0C
+#define REG_PORT_CTRL_13 0x0D
+
+#define KSZ8795_REG_PORT_CTRL_12 0xA0
+#define KSZ8795_REG_PORT_CTRL_13 0xA1
+#define KSZ8795_REG_PORT_RATE_CTRL_3 0xA2
+#define KSZ8795_REG_PORT_RATE_CTRL_2 0xA3
+#define KSZ8795_REG_PORT_RATE_CTRL_1 0xA4
+#define KSZ8795_REG_PORT_RATE_CTRL_0 0xA5
+#define KSZ8795_REG_PORT_RATE_LIMIT 0xA6
+#define KSZ8795_REG_PORT_IN_RATE_0 0xA7
+#define KSZ8795_REG_PORT_IN_RATE_1 0xA8
+#define KSZ8795_REG_PORT_IN_RATE_2 0xA9
+#define KSZ8795_REG_PORT_IN_RATE_3 0xAA
+#define KSZ8795_REG_PORT_OUT_RATE_0 0xAB
+#define KSZ8795_REG_PORT_OUT_RATE_1 0xAC
+#define KSZ8795_REG_PORT_OUT_RATE_2 0xAD
+#define KSZ8795_REG_PORT_OUT_RATE_3 0xAE
#define PORT_CTRL_ADDR(port, addr) \
((addr) + REG_PORT_1_CTRL_0 + (port) * \
@@ -356,7 +363,7 @@
#define REG_SW_MAC_ADDR_4 0x6C
#define REG_SW_MAC_ADDR_5 0x6D
-#define REG_IND_CTRL_0 0x6E
+#define KSZ8795_REG_IND_CTRL_0 0x6E
#define TABLE_EXT_SELECT_S 5
#define TABLE_EEE_V 1
@@ -378,27 +385,27 @@
#define TABLE_DYNAMIC_MAC (TABLE_DYNAMIC_MAC_V << TABLE_SELECT_S)
#define TABLE_MIB (TABLE_MIB_V << TABLE_SELECT_S)
-#define REG_IND_CTRL_1 0x6F
+#define KSZ8795_REG_IND_CTRL_1 0x6F
#define TABLE_ENTRY_MASK 0x03FF
#define TABLE_EXT_ENTRY_MASK 0x0FFF
-#define REG_IND_DATA_8 0x70
-#define REG_IND_DATA_7 0x71
-#define REG_IND_DATA_6 0x72
-#define REG_IND_DATA_5 0x73
-#define REG_IND_DATA_4 0x74
-#define REG_IND_DATA_3 0x75
-#define REG_IND_DATA_2 0x76
-#define REG_IND_DATA_1 0x77
-#define REG_IND_DATA_0 0x78
+#define KSZ8795_REG_IND_DATA_8 0x70
+#define KSZ8795_REG_IND_DATA_7 0x71
+#define KSZ8795_REG_IND_DATA_6 0x72
+#define KSZ8795_REG_IND_DATA_5 0x73
+#define KSZ8795_REG_IND_DATA_4 0x74
+#define KSZ8795_REG_IND_DATA_3 0x75
+#define KSZ8795_REG_IND_DATA_2 0x76
+#define KSZ8795_REG_IND_DATA_1 0x77
+#define KSZ8795_REG_IND_DATA_0 0x78
-#define REG_IND_DATA_PME_EEE_ACL 0xA0
+#define KSZ8795_REG_IND_DATA_PME_EEE_ACL 0xA0
-#define REG_IND_DATA_CHECK REG_IND_DATA_6
-#define REG_IND_MIB_CHECK REG_IND_DATA_4
-#define REG_IND_DATA_HI REG_IND_DATA_7
-#define REG_IND_DATA_LO REG_IND_DATA_3
+#define KSZ8795_REG_IND_DATA_CHECK KSZ8795_REG_IND_DATA_6
+#define KSZ8795_REG_IND_MIB_CHECK KSZ8795_REG_IND_DATA_4
+#define KSZ8795_REG_IND_DATA_HI KSZ8795_REG_IND_DATA_7
+#define KSZ8795_REG_IND_DATA_LO KSZ8795_REG_IND_DATA_3
#define REG_INT_STATUS 0x7C
#define REG_INT_ENABLE 0x7D
@@ -846,16 +853,15 @@
#define KS_PRIO_IN_REG 4
-#define TOTAL_PORT_NUM 5
+#define KSZ8795_TOTAL_PORT_NUM 5
/* Host port can only be last of them. */
-#define SWITCH_PORT_NUM (TOTAL_PORT_NUM - 1)
+#define KSZ8795_SWITCH_PORT_NUM (KSZ8795_TOTAL_PORT_NUM - 1)
#define KSZ8795_COUNTER_NUM 0x20
#define TOTAL_KSZ8795_COUNTER_NUM (KSZ8795_COUNTER_NUM + 4)
#define SWITCH_COUNTER_NUM KSZ8795_COUNTER_NUM
-#define TOTAL_SWITCH_COUNTER_NUM TOTAL_KSZ8795_COUNTER_NUM
/* Common names used by other drivers */
@@ -865,16 +871,16 @@
#define P_MIRROR_CTRL REG_PORT_CTRL_1
#define P_802_1P_CTRL REG_PORT_CTRL_2
#define P_STP_CTRL REG_PORT_CTRL_2
-#define P_LOCAL_CTRL REG_PORT_CTRL_7
-#define P_REMOTE_STATUS REG_PORT_STATUS_0
-#define P_FORCE_CTRL REG_PORT_CTRL_9
-#define P_NEG_RESTART_CTRL REG_PORT_CTRL_10
-#define P_SPEED_STATUS REG_PORT_STATUS_1
-#define P_LINK_STATUS REG_PORT_STATUS_2
-#define P_PASS_ALL_CTRL REG_PORT_CTRL_12
-#define P_INS_SRC_PVID_CTRL REG_PORT_CTRL_12
-#define P_DROP_TAG_CTRL REG_PORT_CTRL_13
-#define P_RATE_LIMIT_CTRL REG_PORT_RATE_LIMIT
+#define KSZ8795_P_LOCAL_CTRL REG_PORT_CTRL_7
+#define KSZ8795_P_REMOTE_STATUS KSZ8795_REG_PORT_STATUS_0
+#define KSZ8795_P_FORCE_CTRL KSZ8795_REG_PORT_CTRL_9
+#define KSZ8795_P_NEG_RESTART_CTRL KSZ8795_REG_PORT_CTRL_10
+#define KSZ8795_P_SPEED_STATUS KSZ8795_REG_PORT_STATUS_1
+#define KSZ8795_P_LINK_STATUS KSZ8795_REG_PORT_STATUS_2
+#define P_PASS_ALL_CTRL KSZ8795_REG_PORT_CTRL_12
+#define P_INS_SRC_PVID_CTRL KSZ8795_REG_PORT_CTRL_12
+#define P_DROP_TAG_CTRL KSZ8795_REG_PORT_CTRL_13
+#define P_RATE_LIMIT_CTRL KSZ8795_REG_PORT_RATE_LIMIT
#define S_UNKNOWN_DA_CTRL REG_SWITCH_CTRL_12
#define S_FORWARD_INVALID_VID_CTRL REG_FORWARD_INVALID_VID
@@ -885,7 +891,7 @@
#define S_MIRROR_CTRL REG_SW_CTRL_3
#define S_REPLACE_VID_CTRL REG_SW_CTRL_4
#define S_PASS_PAUSE_CTRL REG_SW_CTRL_10
-#define S_TAIL_TAG_CTRL REG_SW_CTRL_10
+#define KSZ8795_S_TAIL_TAG_CTRL REG_SW_CTRL_10
#define S_802_1P_PRIO_CTRL REG_SW_CTRL_12
#define S_TOS_PRIO_CTRL REG_TOS_PRIO_CTRL_0
#define S_IPV6_MLD_CTRL REG_SW_CTRL_21
@@ -907,15 +913,15 @@
* STATIC_MAC_TABLE_FID 00-7F000000-00000000
*/
-#define STATIC_MAC_TABLE_ADDR 0x0000FFFF
-#define STATIC_MAC_TABLE_FWD_PORTS 0x001F0000
-#define STATIC_MAC_TABLE_VALID 0x00200000
-#define STATIC_MAC_TABLE_OVERRIDE 0x00400000
-#define STATIC_MAC_TABLE_USE_FID 0x00800000
-#define STATIC_MAC_TABLE_FID 0x7F000000
+#define KSZ8795_STATIC_MAC_TABLE_ADDR 0x0000FFFF
+#define KSZ8795_STATIC_MAC_TABLE_FWD_PORTS 0x001F0000
+#define KSZ8795_STATIC_MAC_TABLE_VALID 0x00200000
+#define KSZ8795_STATIC_MAC_TABLE_OVERRIDE 0x00400000
+#define KSZ8795_STATIC_MAC_TABLE_USE_FID 0x00800000
+#define KSZ8795_STATIC_MAC_TABLE_FID 0x7F000000
-#define STATIC_MAC_FWD_PORTS_S 16
-#define STATIC_MAC_FID_S 24
+#define KSZ8795_STATIC_MAC_FWD_PORTS_S 16
+#define KSZ8795_STATIC_MAC_FID_S 24
/**
* VLAN_TABLE_FID 00-007F007F-007F007F
@@ -923,12 +929,12 @@
* VLAN_TABLE_VALID 00-10001000-10001000
*/
-#define VLAN_TABLE_FID 0x007F
-#define VLAN_TABLE_MEMBERSHIP 0x0F80
-#define VLAN_TABLE_VALID 0x1000
+#define KSZ8795_VLAN_TABLE_FID 0x007F
+#define KSZ8795_VLAN_TABLE_MEMBERSHIP 0x0F80
+#define KSZ8795_VLAN_TABLE_VALID 0x1000
-#define VLAN_TABLE_MEMBERSHIP_S 7
-#define VLAN_TABLE_S 16
+#define KSZ8795_VLAN_TABLE_MEMBERSHIP_S 7
+#define KSZ8795_VLAN_TABLE_S 16
/**
* DYNAMIC_MAC_TABLE_ADDR 00-0000FFFF-FFFFFFFF
@@ -940,22 +946,22 @@
* DYNAMIC_MAC_TABLE_MAC_EMPTY 80-00000000-00000000
*/
-#define DYNAMIC_MAC_TABLE_ADDR 0x0000FFFF
-#define DYNAMIC_MAC_TABLE_FID 0x007F0000
-#define DYNAMIC_MAC_TABLE_SRC_PORT 0x07000000
-#define DYNAMIC_MAC_TABLE_TIMESTAMP 0x18000000
-#define DYNAMIC_MAC_TABLE_ENTRIES 0xE0000000
+#define KSZ8795_DYNAMIC_MAC_TABLE_ADDR 0x0000FFFF
+#define KSZ8795_DYNAMIC_MAC_TABLE_FID 0x007F0000
+#define KSZ8795_DYNAMIC_MAC_TABLE_SRC_PORT 0x07000000
+#define KSZ8795_DYNAMIC_MAC_TABLE_TIMESTAMP 0x18000000
+#define KSZ8795_DYNAMIC_MAC_TABLE_ENTRIES 0xE0000000
-#define DYNAMIC_MAC_TABLE_NOT_READY 0x80
+#define KSZ8795_DYNAMIC_MAC_TABLE_NOT_READY 0x80
-#define DYNAMIC_MAC_TABLE_ENTRIES_H 0x7F
-#define DYNAMIC_MAC_TABLE_MAC_EMPTY 0x80
+#define KSZ8795_DYNAMIC_MAC_TABLE_ENTRIES_H 0x7F
+#define KSZ8795_DYNAMIC_MAC_TABLE_MAC_EMPTY 0x80
-#define DYNAMIC_MAC_FID_S 16
-#define DYNAMIC_MAC_SRC_PORT_S 24
-#define DYNAMIC_MAC_TIMESTAMP_S 27
-#define DYNAMIC_MAC_ENTRIES_S 29
-#define DYNAMIC_MAC_ENTRIES_H_S 3
+#define KSZ8795_DYNAMIC_MAC_FID_S 16
+#define KSZ8795_DYNAMIC_MAC_SRC_PORT_S 24
+#define KSZ8795_DYNAMIC_MAC_TIMESTAMP_S 27
+#define KSZ8795_DYNAMIC_MAC_ENTRIES_S 29
+#define KSZ8795_DYNAMIC_MAC_ENTRIES_H_S 3
/**
* MIB_COUNTER_VALUE 00-00000000-3FFFFFFF
@@ -965,31 +971,31 @@
* MIB_COUNTER_OVERFLOW 00-00000040-00000000
*/
-#define MIB_COUNTER_OVERFLOW BIT(6)
-#define MIB_COUNTER_VALID BIT(5)
+#define KSZ8795_MIB_COUNTER_OVERFLOW BIT(6)
+#define KSZ8795_MIB_COUNTER_VALID BIT(5)
#define MIB_COUNTER_VALUE 0x3FFFFFFF
-#define KS_MIB_TOTAL_RX_0 0x100
-#define KS_MIB_TOTAL_TX_0 0x101
-#define KS_MIB_PACKET_DROPPED_RX_0 0x102
-#define KS_MIB_PACKET_DROPPED_TX_0 0x103
-#define KS_MIB_TOTAL_RX_1 0x104
-#define KS_MIB_TOTAL_TX_1 0x105
-#define KS_MIB_PACKET_DROPPED_TX_1 0x106
-#define KS_MIB_PACKET_DROPPED_RX_1 0x107
-#define KS_MIB_TOTAL_RX_2 0x108
-#define KS_MIB_TOTAL_TX_2 0x109
-#define KS_MIB_PACKET_DROPPED_TX_2 0x10A
-#define KS_MIB_PACKET_DROPPED_RX_2 0x10B
-#define KS_MIB_TOTAL_RX_3 0x10C
-#define KS_MIB_TOTAL_TX_3 0x10D
-#define KS_MIB_PACKET_DROPPED_TX_3 0x10E
-#define KS_MIB_PACKET_DROPPED_RX_3 0x10F
-#define KS_MIB_TOTAL_RX_4 0x110
-#define KS_MIB_TOTAL_TX_4 0x111
-#define KS_MIB_PACKET_DROPPED_TX_4 0x112
-#define KS_MIB_PACKET_DROPPED_RX_4 0x113
+#define KSZ8795_MIB_TOTAL_RX_0 0x100
+#define KSZ8795_MIB_TOTAL_TX_0 0x101
+#define KSZ8795_MIB_PACKET_DROPPED_RX_0 0x102
+#define KSZ8795_MIB_PACKET_DROPPED_TX_0 0x103
+#define KSZ8795_MIB_TOTAL_RX_1 0x104
+#define KSZ8795_MIB_TOTAL_TX_1 0x105
+#define KSZ8795_MIB_PACKET_DROPPED_TX_1 0x106
+#define KSZ8795_MIB_PACKET_DROPPED_RX_1 0x107
+#define KSZ8795_MIB_TOTAL_RX_2 0x108
+#define KSZ8795_MIB_TOTAL_TX_2 0x109
+#define KSZ8795_MIB_PACKET_DROPPED_TX_2 0x10A
+#define KSZ8795_MIB_PACKET_DROPPED_RX_2 0x10B
+#define KSZ8795_MIB_TOTAL_RX_3 0x10C
+#define KSZ8795_MIB_TOTAL_TX_3 0x10D
+#define KSZ8795_MIB_PACKET_DROPPED_TX_3 0x10E
+#define KSZ8795_MIB_PACKET_DROPPED_RX_3 0x10F
+#define KSZ8795_MIB_TOTAL_RX_4 0x110
+#define KSZ8795_MIB_TOTAL_TX_4 0x111
+#define KSZ8795_MIB_PACKET_DROPPED_TX_4 0x112
+#define KSZ8795_MIB_PACKET_DROPPED_RX_4 0x113
#define MIB_PACKET_DROPPED 0x0000FFFF
diff --git a/drivers/net/dsa/microchip/ksz8863_reg.h b/drivers/net/dsa/microchip/ksz8863_reg.h
new file mode 100644
index 000000000000000..6dbe7e1cf921fc4
--- /dev/null
+++ b/drivers/net/dsa/microchip/ksz8863_reg.h
@@ -0,0 +1,124 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Microchip KSZ8863 register definitions
+ *
+ * Copyright (C) 2019 Pengutronix, Michael Grzeschik <kernel@pengutronix.de>
+ */
+
+#ifndef __KSZ8863_REG_H
+#define __KSZ8863_REG_H
+
+#define KSZ88_FAMILY_ID 0x88
+
+#define CHIP_ID_63 0x30
+
+#define KSZ8863_REG_SW_RESET 0x43
+
+#define KSZ8863_GLOBAL_SOFTWARE_RESET BIT(4)
+#define KSZ8863_PCS_RESET BIT(0)
+
+#define KSZ8863_SW_TAIL_TAG_ENABLE BIT(6)
+
+#define KSZ8863_REG_POWER_MANAGEMENT 0xC3
+
+#define KSZ8863_PORT_802_1P_REMAPPING BIT(3)
+
+#define KSZ8863_REG_PORT_STATUS_0 0x0E
+#define KSZ8863_REG_PORT_STATUS_1 0x0F
+
+#define KSZ8863_REG_IND_CTRL_0 0x79
+
+#define KSZ8863_REG_IND_CTRL_1 0x7A
+
+#define KSZ8863_REG_IND_DATA_8 0x7B
+#define KSZ8863_REG_IND_DATA_7 0x7C
+#define KSZ8863_REG_IND_DATA_6 0x7D
+#define KSZ8863_REG_IND_DATA_5 0x7E
+#define KSZ8863_REG_IND_DATA_4 0x7F
+#define KSZ8863_REG_IND_DATA_3 0x80
+#define KSZ8863_REG_IND_DATA_2 0x81
+#define KSZ8863_REG_IND_DATA_1 0x82
+#define KSZ8863_REG_IND_DATA_0 0x83
+
+#define KSZ8863_REG_IND_DATA_CHECK KSZ8863_REG_IND_DATA_8
+#define KSZ8863_REG_IND_MIB_CHECK KSZ8863_REG_IND_DATA_3
+#define KSZ8863_REG_IND_DATA_HI KSZ8863_REG_IND_DATA_7
+#define KSZ8863_REG_IND_DATA_LO KSZ8863_REG_IND_DATA_3
+
+#define KSZ8863_ID_HI 0x0022
+#define KSZ8863_ID_LO 0x1430
+
+#define KSZ8863_TOTAL_PORT_NUM 3
+#define KSZ8863_SWITCH_PORT_NUM (KSZ8863_TOTAL_PORT_NUM - 1)
+
+#define KSZ8863_COUNTER_NUM 0x20
+#define TOTAL_KSZ8863_COUNTER_NUM (KSZ8863_COUNTER_NUM + 2)
+
+#define KSZ8863_P_LOCAL_CTRL REG_PORT_CTRL_12
+#define KSZ8863_P_REMOTE_STATUS KSZ8863_REG_PORT_STATUS_0
+#define KSZ8863_P_FORCE_CTRL REG_PORT_CTRL_12
+#define KSZ8863_P_NEG_RESTART_CTRL REG_PORT_CTRL_13
+#define KSZ8863_P_SPEED_STATUS KSZ8863_REG_PORT_STATUS_1
+#define KSZ8863_P_LINK_STATUS KSZ8863_REG_PORT_STATUS_0
+#define KSZ8863_S_TAIL_TAG_CTRL REG_SW_CTRL_1
+
+/**
+ * STATIC_MAC_TABLE_ADDR 00-0000FFFF-FFFFFFFF
+ * STATIC_MAC_TABLE_FWD_PORTS 00-00070000-00000000
+ * STATIC_MAC_TABLE_VALID 00-00080000-00000000
+ * STATIC_MAC_TABLE_OVERRIDE 00-00100000-00000000
+ * STATIC_MAC_TABLE_USE_FID 00-00200000-00000000
+ * STATIC_MAC_TABLE_FID 00-3C000000-00000000
+ */
+
+#define KSZ8863_STATIC_MAC_TABLE_ADDR 0x0000FFFF
+#define KSZ8863_STATIC_MAC_TABLE_FWD_PORTS 0x00070000
+#define KSZ8863_STATIC_MAC_TABLE_VALID 0x00080000
+#define KSZ8863_STATIC_MAC_TABLE_OVERRIDE 0x00100000
+#define KSZ8863_STATIC_MAC_TABLE_USE_FID 0x00200000
+#define KSZ8863_STATIC_MAC_TABLE_FID 0x3C000000
+
+#define KSZ8863_STATIC_MAC_FWD_PORTS_S 16
+#define KSZ8863_STATIC_MAC_FID_S 22
+
+/**
+ * VLAN_TABLE_VID 00-00000000-00000FFF
+ * VLAN_TABLE_FID 00-00000000-0000F000
+ * VLAN_TABLE_MEMBERSHIP 00-00000000-00070000
+ * VLAN_TABLE_VALID 00-00000000-00080000
+ */
+
+#define KSZ8863_VLAN_TABLE_VID 0x00FFF
+#define KSZ8863_VLAN_TABLE_FID 0x0F000
+#define KSZ8863_VLAN_TABLE_MEMBERSHIP 0x70000
+#define KSZ8863_VLAN_TABLE_VALID 0x80000
+
+#define KSZ8863_VLAN_TABLE_MEMBERSHIP_S 16
+
+#define KSZ8863_DYNAMIC_MAC_TABLE_ADDR 0x0000FFFF
+#define KSZ8863_DYNAMIC_MAC_TABLE_FID 0x000F0000
+#define KSZ8863_DYNAMIC_MAC_TABLE_SRC_PORT 0x00300000
+#define KSZ8863_DYNAMIC_MAC_TABLE_TIMESTAMP 0x00C00000
+#define KSZ8863_DYNAMIC_MAC_TABLE_ENTRIES 0xF0000000
+
+#define KSZ8863_DYNAMIC_MAC_TABLE_NOT_READY 0x80
+
+#define KSZ8863_DYNAMIC_MAC_TABLE_ENTRIES_H 0x3F
+#define KSZ8863_DYNAMIC_MAC_TABLE_MAC_EMPTY 0x80
+
+#define KSZ8863_DYNAMIC_MAC_FID_S 16
+#define KSZ8863_DYNAMIC_MAC_SRC_PORT_S 20
+#define KSZ8863_DYNAMIC_MAC_TIMESTAMP_S 24
+#define KSZ8863_DYNAMIC_MAC_ENTRIES_S 24
+#define KSZ8863_DYNAMIC_MAC_ENTRIES_H_S 3
+
+#define KSZ8863_MIB_COUNTER_OVERFLOW BIT(7)
+#define KSZ8863_MIB_COUNTER_VALID BIT(6)
+
+#define KSZ8863_MIB_PACKET_DROPPED_TX_0 0x100
+#define KSZ8863_MIB_PACKET_DROPPED_RX_0 0x105
+
+#define KSZ8863_REG_INT_ENABLE 0xBB
+#define KSZ8863_REG_INT_STATUS 0xBC
+
+#endif
--
2.28.0
^ permalink raw reply related
* [PATCH v4 06/11] net: dsa: microchip: ksz8795: change drivers prefix to be generic
From: Michael Grzeschik @ 2020-08-03 5:44 UTC (permalink / raw)
To: andrew; +Cc: netdev, f.fainelli, davem, kernel
In-Reply-To: <20200803054442.20089-1-m.grzeschik@pengutronix.de>
The driver can be used on other chips of this type. To reflect
this we rename the drivers prefix from ksz8795 to ksz8.
Signed-off-by: Michael Grzeschik <m.grzeschik@pengutronix.de>
---
v1 -> v4: - extracted this change from bigger previous patch
drivers/net/dsa/microchip/ksz8795.c | 222 ++++++++++++------------
drivers/net/dsa/microchip/ksz8795_spi.c | 2 +-
drivers/net/dsa/microchip/ksz_common.h | 2 +-
3 files changed, 111 insertions(+), 115 deletions(-)
diff --git a/drivers/net/dsa/microchip/ksz8795.c b/drivers/net/dsa/microchip/ksz8795.c
index ba722f730bf0f7b..c21125a0b30e5c8 100644
--- a/drivers/net/dsa/microchip/ksz8795.c
+++ b/drivers/net/dsa/microchip/ksz8795.c
@@ -74,7 +74,7 @@ static void ksz_port_cfg(struct ksz_device *dev, int port, int offset, u8 bits,
bits, set ? bits : 0);
}
-static int ksz8795_reset_switch(struct ksz_device *dev)
+static int ksz8_reset_switch(struct ksz_device *dev)
{
/* reset switch */
ksz_write8(dev, REG_POWER_MANAGEMENT_1,
@@ -117,8 +117,7 @@ static void ksz8795_set_prio_queue(struct ksz_device *dev, int port, int queue)
true);
}
-static void ksz8795_r_mib_cnt(struct ksz_device *dev, int port, u16 addr,
- u64 *cnt)
+static void ksz8_r_mib_cnt(struct ksz_device *dev, int port, u16 addr, u64 *cnt)
{
u16 ctrl_addr;
u32 data;
@@ -148,8 +147,8 @@ static void ksz8795_r_mib_cnt(struct ksz_device *dev, int port, u16 addr,
mutex_unlock(&dev->alu_mutex);
}
-static void ksz8795_r_mib_pkt(struct ksz_device *dev, int port, u16 addr,
- u64 *dropped, u64 *cnt)
+static void ksz8_r_mib_pkt(struct ksz_device *dev, int port, u16 addr,
+ u64 *dropped, u64 *cnt)
{
u16 ctrl_addr;
u32 data;
@@ -195,7 +194,7 @@ static void ksz8795_r_mib_pkt(struct ksz_device *dev, int port, u16 addr,
mutex_unlock(&dev->alu_mutex);
}
-static void ksz8795_freeze_mib(struct ksz_device *dev, int port, bool freeze)
+static void ksz8_freeze_mib(struct ksz_device *dev, int port, bool freeze)
{
/* enable the port for flush/freeze function */
if (freeze)
@@ -207,7 +206,7 @@ static void ksz8795_freeze_mib(struct ksz_device *dev, int port, bool freeze)
ksz_cfg(dev, REG_SW_CTRL_6, BIT(port), false);
}
-static void ksz8795_port_init_cnt(struct ksz_device *dev, int port)
+static void ksz8_port_init_cnt(struct ksz_device *dev, int port)
{
struct ksz_port_mib *mib = &dev->ports[port].mib;
@@ -235,8 +234,7 @@ static void ksz8795_port_init_cnt(struct ksz_device *dev, int port)
memset(mib->counters, 0, dev->mib_cnt * sizeof(u64));
}
-static void ksz8795_r_table(struct ksz_device *dev, int table, u16 addr,
- u64 *data)
+static void ksz8_r_table(struct ksz_device *dev, int table, u16 addr, u64 *data)
{
u16 ctrl_addr;
@@ -248,8 +246,7 @@ static void ksz8795_r_table(struct ksz_device *dev, int table, u16 addr,
mutex_unlock(&dev->alu_mutex);
}
-static void ksz8795_w_table(struct ksz_device *dev, int table, u16 addr,
- u64 data)
+static void ksz8_w_table(struct ksz_device *dev, int table, u16 addr, u64 data)
{
u16 ctrl_addr;
@@ -261,7 +258,7 @@ static void ksz8795_w_table(struct ksz_device *dev, int table, u16 addr,
mutex_unlock(&dev->alu_mutex);
}
-static int ksz8795_valid_dyn_entry(struct ksz_device *dev, u8 *data)
+static int ksz8_valid_dyn_entry(struct ksz_device *dev, u8 *data)
{
int timeout = 100;
@@ -284,9 +281,9 @@ static int ksz8795_valid_dyn_entry(struct ksz_device *dev, u8 *data)
return 0;
}
-static int ksz8795_r_dyn_mac_table(struct ksz_device *dev, u16 addr,
- u8 *mac_addr, u8 *fid, u8 *src_port,
- u8 *timestamp, u16 *entries)
+static int ksz8_r_dyn_mac_table(struct ksz_device *dev, u16 addr,
+ u8 *mac_addr, u8 *fid, u8 *src_port,
+ u8 *timestamp, u16 *entries)
{
u32 data_hi, data_lo;
u16 ctrl_addr;
@@ -298,7 +295,7 @@ static int ksz8795_r_dyn_mac_table(struct ksz_device *dev, u16 addr,
mutex_lock(&dev->alu_mutex);
ksz_write16(dev, REG_IND_CTRL_0, ctrl_addr);
- rc = ksz8795_valid_dyn_entry(dev, &data);
+ rc = ksz8_valid_dyn_entry(dev, &data);
if (rc == -EAGAIN) {
if (addr == 0)
*entries = 0;
@@ -341,13 +338,13 @@ static int ksz8795_r_dyn_mac_table(struct ksz_device *dev, u16 addr,
return rc;
}
-static int ksz8795_r_sta_mac_table(struct ksz_device *dev, u16 addr,
- struct alu_struct *alu)
+static int ksz8_r_sta_mac_table(struct ksz_device *dev, u16 addr,
+ struct alu_struct *alu)
{
u32 data_hi, data_lo;
u64 data;
- ksz8795_r_table(dev, TABLE_STATIC_MAC, addr, &data);
+ ksz8_r_table(dev, TABLE_STATIC_MAC, addr, &data);
data_hi = data >> 32;
data_lo = (u32)data;
if (data_hi & (STATIC_MAC_TABLE_VALID | STATIC_MAC_TABLE_OVERRIDE)) {
@@ -370,8 +367,8 @@ static int ksz8795_r_sta_mac_table(struct ksz_device *dev, u16 addr,
return -ENXIO;
}
-static void ksz8795_w_sta_mac_table(struct ksz_device *dev, u16 addr,
- struct alu_struct *alu)
+static void ksz8_w_sta_mac_table(struct ksz_device *dev, u16 addr,
+ struct alu_struct *alu)
{
u32 data_hi, data_lo;
u64 data;
@@ -394,17 +391,17 @@ static void ksz8795_w_sta_mac_table(struct ksz_device *dev, u16 addr,
data_hi &= ~STATIC_MAC_TABLE_OVERRIDE;
data = (u64)data_hi << 32 | data_lo;
- ksz8795_w_table(dev, TABLE_STATIC_MAC, addr, data);
+ ksz8_w_table(dev, TABLE_STATIC_MAC, addr, data);
}
-static void ksz8795_from_vlan(u16 vlan, u8 *fid, u8 *member, u8 *valid)
+static void ksz8_from_vlan(u16 vlan, u8 *fid, u8 *member, u8 *valid)
{
*fid = vlan & VLAN_TABLE_FID;
*member = (vlan & VLAN_TABLE_MEMBERSHIP) >> VLAN_TABLE_MEMBERSHIP_S;
*valid = !!(vlan & VLAN_TABLE_VALID);
}
-static void ksz8795_to_vlan(u8 fid, u8 member, u8 valid, u16 *vlan)
+static void ksz8_to_vlan(u8 fid, u8 member, u8 valid, u16 *vlan)
{
*vlan = fid;
*vlan |= (u16)member << VLAN_TABLE_MEMBERSHIP_S;
@@ -412,12 +409,14 @@ static void ksz8795_to_vlan(u8 fid, u8 member, u8 valid, u16 *vlan)
*vlan |= VLAN_TABLE_VALID;
}
-static void ksz8795_r_vlan_entries(struct ksz_device *dev, u16 addr)
+static void ksz8_r_vlan_entries(struct ksz_device *dev, u16 addr)
{
+ struct ksz8 *ksz8 = dev->priv;
+ struct ksz_shifts *shifts = ksz8->shifts;
u64 data;
int i;
- ksz8795_r_table(dev, TABLE_VLAN, addr, &data);
+ ksz8_r_table(dev, TABLE_VLAN, addr, &data);
addr *= dev->port_cnt;
for (i = 0; i < dev->port_cnt; i++) {
dev->vlan_cache[addr + i].table[0] = (u16)data;
@@ -425,7 +424,7 @@ static void ksz8795_r_vlan_entries(struct ksz_device *dev, u16 addr)
}
}
-static void ksz8795_r_vlan_table(struct ksz_device *dev, u16 vid, u16 *vlan)
+static void ksz8_r_vlan_table(struct ksz_device *dev, u16 vid, u32 *vlan)
{
int index;
u16 *data;
@@ -435,11 +434,11 @@ static void ksz8795_r_vlan_table(struct ksz_device *dev, u16 vid, u16 *vlan)
data = (u16 *)&buf;
addr = vid / dev->port_cnt;
index = vid & 3;
- ksz8795_r_table(dev, TABLE_VLAN, addr, &buf);
+ ksz8_r_table(dev, TABLE_VLAN, addr, &buf);
*vlan = data[index];
}
-static void ksz8795_w_vlan_table(struct ksz_device *dev, u16 vid, u16 vlan)
+static void ksz8_w_vlan_table(struct ksz_device *dev, u16 vid, u32 vlan)
{
int index;
u16 *data;
@@ -449,13 +448,13 @@ static void ksz8795_w_vlan_table(struct ksz_device *dev, u16 vid, u16 vlan)
data = (u16 *)&buf;
addr = vid / dev->port_cnt;
index = vid & 3;
- ksz8795_r_table(dev, TABLE_VLAN, addr, &buf);
+ ksz8_r_table(dev, TABLE_VLAN, addr, &buf);
data[index] = vlan;
dev->vlan_cache[vid].table[0] = vlan;
- ksz8795_w_table(dev, TABLE_VLAN, addr, buf);
+ ksz8_w_table(dev, TABLE_VLAN, addr, buf);
}
-static void ksz8795_r_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 *val)
+static void ksz8_r_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 *val)
{
u8 restart, speed, ctrl, link;
int processed = true;
@@ -546,7 +545,7 @@ static void ksz8795_r_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 *val)
*val = data;
}
-static void ksz8795_w_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 val)
+static void ksz8_w_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 val)
{
u8 p = phy;
u8 restart, speed, ctrl, data;
@@ -644,15 +643,15 @@ static void ksz8795_w_phy(struct ksz_device *dev, u16 phy, u16 reg, u16 val)
}
}
-static enum dsa_tag_protocol ksz8795_get_tag_protocol(struct dsa_switch *ds,
- int port,
- enum dsa_tag_protocol mp)
+static enum dsa_tag_protocol ksz8_get_tag_protocol(struct dsa_switch *ds,
+ int port,
+ enum dsa_tag_protocol mp)
{
return DSA_TAG_PROTO_KSZ8795;
}
-static void ksz8795_get_strings(struct dsa_switch *ds, int port,
- u32 stringset, uint8_t *buf)
+static void ksz8_get_strings(struct dsa_switch *ds, int port,
+ u32 stringset, uint8_t *buf)
{
int i;
@@ -662,8 +661,7 @@ static void ksz8795_get_strings(struct dsa_switch *ds, int port,
}
}
-static void ksz8795_cfg_port_member(struct ksz_device *dev, int port,
- u8 member)
+static void ksz8_cfg_port_member(struct ksz_device *dev, int port, u8 member)
{
u8 data;
@@ -674,8 +672,7 @@ static void ksz8795_cfg_port_member(struct ksz_device *dev, int port,
dev->ports[port].member = member;
}
-static void ksz8795_port_stp_state_set(struct dsa_switch *ds, int port,
- u8 state)
+static void ksz8_port_stp_state_set(struct dsa_switch *ds, int port, u8 state)
{
struct ksz_device *dev = ds->priv;
int forward = dev->member;
@@ -733,7 +730,7 @@ static void ksz8795_port_stp_state_set(struct dsa_switch *ds, int port,
p->stp_state = state;
/* Port membership may share register with STP state. */
if (member >= 0 && member != p->member)
- ksz8795_cfg_port_member(dev, port, (u8)member);
+ ksz8_cfg_port_member(dev, port, (u8)member);
/* Check if forwarding needs to be updated. */
if (state != BR_STATE_FORWARDING) {
@@ -748,7 +745,7 @@ static void ksz8795_port_stp_state_set(struct dsa_switch *ds, int port,
ksz_update_port_member(dev, port);
}
-static void ksz8795_flush_dyn_mac_table(struct ksz_device *dev, int port)
+static void ksz8_flush_dyn_mac_table(struct ksz_device *dev, int port)
{
u8 *learn = kzalloc(dev->mib_port_cnt, GFP_KERNEL);
int first, index, cnt;
@@ -782,8 +779,7 @@ static void ksz8795_flush_dyn_mac_table(struct ksz_device *dev, int port)
kfree(learn);
}
-static int ksz8795_port_vlan_filtering(struct dsa_switch *ds, int port,
- bool flag)
+static int ksz8_port_vlan_filtering(struct dsa_switch *ds, int port, bool flag)
{
struct ksz_device *dev = ds->priv;
@@ -792,8 +788,8 @@ static int ksz8795_port_vlan_filtering(struct dsa_switch *ds, int port,
return 0;
}
-static void ksz8795_port_vlan_add(struct dsa_switch *ds, int port,
- const struct switchdev_obj_port_vlan *vlan)
+static void ksz8_port_vlan_add(struct dsa_switch *ds, int port,
+ const struct switchdev_obj_port_vlan *vlan)
{
bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
struct ksz_device *dev = ds->priv;
@@ -803,8 +799,8 @@ static void ksz8795_port_vlan_add(struct dsa_switch *ds, int port,
ksz_port_cfg(dev, port, P_TAG_CTRL, PORT_REMOVE_TAG, untagged);
for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
- ksz8795_r_vlan_table(dev, vid, &data);
- ksz8795_from_vlan(data, &fid, &member, &valid);
+ ksz8_r_vlan_table(dev, vid, &data);
+ ksz8_from_vlan(data, &fid, &member, &valid);
/* First time to setup the VLAN entry. */
if (!valid) {
@@ -814,8 +810,8 @@ static void ksz8795_port_vlan_add(struct dsa_switch *ds, int port,
}
member |= BIT(port);
- ksz8795_to_vlan(fid, member, valid, &data);
- ksz8795_w_vlan_table(dev, vid, data);
+ ksz8_to_vlan(fid, member, valid, &data);
+ ksz8_w_vlan_table(dev, vid, data);
/* change PVID */
if (vlan->flags & BRIDGE_VLAN_INFO_PVID)
@@ -830,8 +826,8 @@ static void ksz8795_port_vlan_add(struct dsa_switch *ds, int port,
}
}
-static int ksz8795_port_vlan_del(struct dsa_switch *ds, int port,
- const struct switchdev_obj_port_vlan *vlan)
+static int ksz8_port_vlan_del(struct dsa_switch *ds, int port,
+ const struct switchdev_obj_port_vlan *vlan)
{
bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
struct ksz_device *dev = ds->priv;
@@ -844,8 +840,8 @@ static int ksz8795_port_vlan_del(struct dsa_switch *ds, int port,
ksz_port_cfg(dev, port, P_TAG_CTRL, PORT_REMOVE_TAG, untagged);
for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
- ksz8795_r_vlan_table(dev, vid, &data);
- ksz8795_from_vlan(data, &fid, &member, &valid);
+ ksz8_r_vlan_table(dev, vid, &data);
+ ksz8_from_vlan(data, &fid, &member, &valid);
member &= ~BIT(port);
@@ -858,8 +854,8 @@ static int ksz8795_port_vlan_del(struct dsa_switch *ds, int port,
if (pvid == vid)
new_pvid = 1;
- ksz8795_to_vlan(fid, member, valid, &data);
- ksz8795_w_vlan_table(dev, vid, data);
+ ksz8_to_vlan(fid, member, valid, &data);
+ ksz8_w_vlan_table(dev, vid, data);
}
if (new_pvid != pvid)
@@ -868,9 +864,9 @@ static int ksz8795_port_vlan_del(struct dsa_switch *ds, int port,
return 0;
}
-static int ksz8795_port_mirror_add(struct dsa_switch *ds, int port,
- struct dsa_mall_mirror_tc_entry *mirror,
- bool ingress)
+static int ksz8_port_mirror_add(struct dsa_switch *ds, int port,
+ struct dsa_mall_mirror_tc_entry *mirror,
+ bool ingress)
{
struct ksz_device *dev = ds->priv;
@@ -892,8 +888,8 @@ static int ksz8795_port_mirror_add(struct dsa_switch *ds, int port,
return 0;
}
-static void ksz8795_port_mirror_del(struct dsa_switch *ds, int port,
- struct dsa_mall_mirror_tc_entry *mirror)
+static void ksz8_port_mirror_del(struct dsa_switch *ds, int port,
+ struct dsa_mall_mirror_tc_entry *mirror)
{
struct ksz_device *dev = ds->priv;
u8 data;
@@ -913,7 +909,7 @@ static void ksz8795_port_mirror_del(struct dsa_switch *ds, int port,
PORT_MIRROR_SNIFFER, false);
}
-static void ksz8795_port_setup(struct ksz_device *dev, int port, bool cpu_port)
+static void ksz8_port_setup(struct ksz_device *dev, int port, bool cpu_port)
{
struct ksz_port *p = &dev->ports[port];
u8 data8, member;
@@ -971,10 +967,10 @@ static void ksz8795_port_setup(struct ksz_device *dev, int port, bool cpu_port)
} else {
member = dev->host_mask | p->vid_member;
}
- ksz8795_cfg_port_member(dev, port, member);
+ ksz8_cfg_port_member(dev, port, member);
}
-static void ksz8795_config_cpu_port(struct dsa_switch *ds)
+static void ksz8_config_cpu_port(struct dsa_switch *ds)
{
struct ksz_device *dev = ds->priv;
struct ksz_port *p;
@@ -991,7 +987,7 @@ static void ksz8795_config_cpu_port(struct dsa_switch *ds)
p->vid_member = dev->port_mask;
p->on = 1;
- ksz8795_port_setup(dev, dev->cpu_port, true);
+ ksz8_port_setup(dev, dev->cpu_port, true);
dev->member = dev->host_mask;
for (i = 0; i < dev->port_cnt; i++) {
@@ -1002,7 +998,7 @@ static void ksz8795_config_cpu_port(struct dsa_switch *ds)
*/
p->vid_member = BIT(i);
p->member = dev->port_mask;
- ksz8795_port_stp_state_set(ds, i, BR_STATE_DISABLED);
+ ksz8_port_stp_state_set(ds, i, BR_STATE_DISABLED);
/* Last port may be disabled. */
if (i == dev->port_cnt)
@@ -1026,7 +1022,7 @@ static void ksz8795_config_cpu_port(struct dsa_switch *ds)
}
}
-static int ksz8795_setup(struct dsa_switch *ds)
+static int ksz8_setup(struct dsa_switch *ds)
{
struct ksz_device *dev = ds->priv;
struct alu_struct alu;
@@ -1037,7 +1033,7 @@ static int ksz8795_setup(struct dsa_switch *ds)
if (!dev->vlan_cache)
return -ENOMEM;
- ret = ksz8795_reset_switch(dev);
+ ret = ksz8_reset_switch(dev);
if (ret) {
dev_err(ds->dev, "failed to reset switch\n");
return ret;
@@ -1060,7 +1056,7 @@ static int ksz8795_setup(struct dsa_switch *ds)
UNICAST_VLAN_BOUNDARY | NO_EXC_COLLISION_DROP,
UNICAST_VLAN_BOUNDARY | NO_EXC_COLLISION_DROP);
- ksz8795_config_cpu_port(ds);
+ ksz8_config_cpu_port(ds);
ksz_cfg(dev, REG_SW_CTRL_2, MULTICAST_STORM_DISABLE, true);
@@ -1075,7 +1071,7 @@ static int ksz8795_setup(struct dsa_switch *ds)
BROADCAST_STORM_PROT_RATE) / 100);
for (i = 0; i < VLAN_TABLE_ENTRIES; i++)
- ksz8795_r_vlan_entries(dev, i);
+ ksz8_r_vlan_entries(dev, i);
/* Setup STP address for STP operation. */
memset(&alu, 0, sizeof(alu));
@@ -1084,45 +1080,45 @@ static int ksz8795_setup(struct dsa_switch *ds)
alu.is_override = true;
alu.port_forward = dev->host_mask;
- ksz8795_w_sta_mac_table(dev, 0, &alu);
+ ksz8_w_sta_mac_table(dev, 0, &alu);
ksz_init_mib_timer(dev);
return 0;
}
-static const struct dsa_switch_ops ksz8795_switch_ops = {
- .get_tag_protocol = ksz8795_get_tag_protocol,
- .setup = ksz8795_setup,
+static const struct dsa_switch_ops ksz8_switch_ops = {
+ .get_tag_protocol = ksz8_get_tag_protocol,
+ .setup = ksz8_setup,
.phy_read = ksz_phy_read16,
.phy_write = ksz_phy_write16,
.phylink_mac_link_down = ksz_mac_link_down,
.port_enable = ksz_enable_port,
- .get_strings = ksz8795_get_strings,
+ .get_strings = ksz8_get_strings,
.get_ethtool_stats = ksz_get_ethtool_stats,
.get_sset_count = ksz_sset_count,
.port_bridge_join = ksz_port_bridge_join,
.port_bridge_leave = ksz_port_bridge_leave,
- .port_stp_state_set = ksz8795_port_stp_state_set,
+ .port_stp_state_set = ksz8_port_stp_state_set,
.port_fast_age = ksz_port_fast_age,
- .port_vlan_filtering = ksz8795_port_vlan_filtering,
+ .port_vlan_filtering = ksz8_port_vlan_filtering,
.port_vlan_prepare = ksz_port_vlan_prepare,
- .port_vlan_add = ksz8795_port_vlan_add,
- .port_vlan_del = ksz8795_port_vlan_del,
+ .port_vlan_add = ksz8_port_vlan_add,
+ .port_vlan_del = ksz8_port_vlan_del,
.port_fdb_dump = ksz_port_fdb_dump,
.port_mdb_prepare = ksz_port_mdb_prepare,
.port_mdb_add = ksz_port_mdb_add,
.port_mdb_del = ksz_port_mdb_del,
- .port_mirror_add = ksz8795_port_mirror_add,
- .port_mirror_del = ksz8795_port_mirror_del,
+ .port_mirror_add = ksz8_port_mirror_add,
+ .port_mirror_del = ksz8_port_mirror_del,
};
-static u32 ksz8795_get_port_addr(int port, int offset)
+static u32 ksz8_get_port_addr(int port, int offset)
{
return PORT_CTRL_ADDR(port, offset);
}
-static int ksz8795_switch_detect(struct ksz_device *dev)
+static int ksz8_switch_detect(struct ksz_device *dev)
{
u8 id1, id2;
u16 id16;
@@ -1175,7 +1171,7 @@ struct ksz_chip_data {
int port_cnt;
};
-static const struct ksz_chip_data ksz8795_switch_chips[] = {
+static const struct ksz_chip_data ksz8_switch_chips[] = {
{
.chip_id = 0x8795,
.dev_name = "KSZ8795",
@@ -1205,14 +1201,14 @@ static const struct ksz_chip_data ksz8795_switch_chips[] = {
},
};
-static int ksz8795_switch_init(struct ksz_device *dev)
+static int ksz8_switch_init(struct ksz_device *dev)
{
int i;
- dev->ds->ops = &ksz8795_switch_ops;
+ dev->ds->ops = &ksz8_switch_ops;
- for (i = 0; i < ARRAY_SIZE(ksz8795_switch_chips); i++) {
- const struct ksz_chip_data *chip = &ksz8795_switch_chips[i];
+ for (i = 0; i < ARRAY_SIZE(ksz8_switch_chips); i++) {
+ const struct ksz_chip_data *chip = &ksz8_switch_chips[i];
if (dev->chip_id == chip->chip_id) {
dev->name = chip->dev_name;
@@ -1258,36 +1254,36 @@ static int ksz8795_switch_init(struct ksz_device *dev)
return 0;
}
-static void ksz8795_switch_exit(struct ksz_device *dev)
+static void ksz8_switch_exit(struct ksz_device *dev)
{
- ksz8795_reset_switch(dev);
+ ksz8_reset_switch(dev);
}
-static const struct ksz_dev_ops ksz8795_dev_ops = {
- .get_port_addr = ksz8795_get_port_addr,
- .cfg_port_member = ksz8795_cfg_port_member,
- .flush_dyn_mac_table = ksz8795_flush_dyn_mac_table,
- .port_setup = ksz8795_port_setup,
- .r_phy = ksz8795_r_phy,
- .w_phy = ksz8795_w_phy,
- .r_dyn_mac_table = ksz8795_r_dyn_mac_table,
- .r_sta_mac_table = ksz8795_r_sta_mac_table,
- .w_sta_mac_table = ksz8795_w_sta_mac_table,
- .r_mib_cnt = ksz8795_r_mib_cnt,
- .r_mib_pkt = ksz8795_r_mib_pkt,
- .freeze_mib = ksz8795_freeze_mib,
- .port_init_cnt = ksz8795_port_init_cnt,
- .shutdown = ksz8795_reset_switch,
- .detect = ksz8795_switch_detect,
- .init = ksz8795_switch_init,
- .exit = ksz8795_switch_exit,
+static const struct ksz_dev_ops ksz8_dev_ops = {
+ .get_port_addr = ksz8_get_port_addr,
+ .cfg_port_member = ksz8_cfg_port_member,
+ .flush_dyn_mac_table = ksz8_flush_dyn_mac_table,
+ .port_setup = ksz8_port_setup,
+ .r_phy = ksz8_r_phy,
+ .w_phy = ksz8_w_phy,
+ .r_dyn_mac_table = ksz8_r_dyn_mac_table,
+ .r_sta_mac_table = ksz8_r_sta_mac_table,
+ .w_sta_mac_table = ksz8_w_sta_mac_table,
+ .r_mib_cnt = ksz8_r_mib_cnt,
+ .r_mib_pkt = ksz8_r_mib_pkt,
+ .freeze_mib = ksz8_freeze_mib,
+ .port_init_cnt = ksz8_port_init_cnt,
+ .shutdown = ksz8_reset_switch,
+ .detect = ksz8_switch_detect,
+ .init = ksz8_switch_init,
+ .exit = ksz8_switch_exit,
};
-int ksz8795_switch_register(struct ksz_device *dev)
+int ksz8_switch_register(struct ksz_device *dev)
{
- return ksz_switch_register(dev, &ksz8795_dev_ops);
+ return ksz_switch_register(dev, &ksz8_dev_ops);
}
-EXPORT_SYMBOL(ksz8795_switch_register);
+EXPORT_SYMBOL(ksz8_switch_register);
MODULE_AUTHOR("Tristram Ha <Tristram.Ha@microchip.com>");
MODULE_DESCRIPTION("Microchip KSZ8795 Series Switch DSA Driver");
diff --git a/drivers/net/dsa/microchip/ksz8795_spi.c b/drivers/net/dsa/microchip/ksz8795_spi.c
index 8b00f8e6c02f4f2..3bab09c46f6a7bd 100644
--- a/drivers/net/dsa/microchip/ksz8795_spi.c
+++ b/drivers/net/dsa/microchip/ksz8795_spi.c
@@ -49,7 +49,7 @@ static int ksz8795_spi_probe(struct spi_device *spi)
if (spi->dev.platform_data)
dev->pdata = spi->dev.platform_data;
- ret = ksz8795_switch_register(dev);
+ ret = ksz8_switch_register(dev);
/* Main DSA driver may not be started yet. */
if (ret)
diff --git a/drivers/net/dsa/microchip/ksz_common.h b/drivers/net/dsa/microchip/ksz_common.h
index 206838160f4940f..cd5aec59d3978c5 100644
--- a/drivers/net/dsa/microchip/ksz_common.h
+++ b/drivers/net/dsa/microchip/ksz_common.h
@@ -143,7 +143,7 @@ int ksz_switch_register(struct ksz_device *dev,
const struct ksz_dev_ops *ops);
void ksz_switch_remove(struct ksz_device *dev);
-int ksz8795_switch_register(struct ksz_device *dev);
+int ksz8_switch_register(struct ksz_device *dev);
int ksz9477_switch_register(struct ksz_device *dev);
void ksz_update_port_member(struct ksz_device *dev, int port);
--
2.28.0
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox