Release 4.16 drivers/net/ethernet/mellanox/mlxsw/core_acl_flex_actions.c

/*
 * drivers/net/ethernet/mellanox/mlxsw/core_acl_flex_actions.c
 * Copyright (c) 2017 Mellanox Technologies. All rights reserved.
 * Copyright (c) 2017 Jiri Pirko <jiri@mellanox.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the names of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/rhashtable.h>
#include <linux/list.h>

#include "item.h"
#include "trap.h"
#include "core_acl_flex_actions.h"


enum mlxsw_afa_set_type {
	
MLXSW_AFA_SET_TYPE_NEXT,
	
MLXSW_AFA_SET_TYPE_GOTO,
};

/* afa_set_type
 * Type of the record at the end of the action set.
 */
MLXSW_ITEM32(afa, set, type, 0xA0, 28, 4);

/* afa_set_next_action_set_ptr
 * A pointer to the next action set in the KVD Centralized database.
 */
MLXSW_ITEM32(afa, set, next_action_set_ptr, 0xA4, 0, 24);

/* afa_set_goto_g
 * group - When set, the binding is of an ACL group. When cleared,
 * the binding is of an ACL.
 * Must be set to 1 for Spectrum.
 */
MLXSW_ITEM32(afa, set, goto_g, 0xA4, 29, 1);


enum mlxsw_afa_set_goto_binding_cmd {
	/* continue go the next binding point */
	
MLXSW_AFA_SET_GOTO_BINDING_CMD_NONE,
	/* jump to the next binding point no return */
	
MLXSW_AFA_SET_GOTO_BINDING_CMD_JUMP,
	/* terminate the acl binding */
	
MLXSW_AFA_SET_GOTO_BINDING_CMD_TERM = 4,
};

/* afa_set_goto_binding_cmd */
MLXSW_ITEM32(afa, set, goto_binding_cmd, 0xA4, 24, 3);

/* afa_set_goto_next_binding
 * ACL/ACL group identifier. If the g bit is set, this field should hold
 * the acl_group_id, else it should hold the acl_id.
 */
MLXSW_ITEM32(afa, set, goto_next_binding, 0xA4, 0, 16);

/* afa_all_action_type
 * Action Type.
 */
MLXSW_ITEM32(afa, all, action_type, 0x00, 24, 6);


struct mlxsw_afa {
	
unsigned int max_acts_per_set;
	
const struct mlxsw_afa_ops *ops;
	
void *ops_priv;
	
struct rhashtable set_ht;
	
struct rhashtable fwd_entry_ht;
};


#define MLXSW_AFA_SET_LEN 0xA8


struct mlxsw_afa_set_ht_key {
	
char enc_actions[MLXSW_AFA_SET_LEN]; /* Encoded set */
	
bool is_first;
};

/* Set structure holds one action set record. It contains up to three
 * actions (depends on size of particular actions). The set is either
 * put directly to a rule, or it is stored in KVD linear area.
 * To prevent duplicate entries in KVD linear area, a hashtable is
 * used to track sets that were previously inserted and may be shared.
 */


struct mlxsw_afa_set {
	
struct rhash_head ht_node;
	
struct mlxsw_afa_set_ht_key ht_key;
	
u32 kvdl_index;
	
bool shared; /* Inserted in hashtable (doesn't mean that
                      * kvdl_index is valid).
                      */
	
unsigned int ref_count;
	
struct mlxsw_afa_set *next; /* Pointer to the next set. */
	
struct mlxsw_afa_set *prev; /* Pointer to the previous set,
                                     * note that set may have multiple
                                     * sets from multiple blocks
                                     * pointing at it. This is only
                                     * usable until commit.
                                     */
};


static const struct rhashtable_params mlxsw_afa_set_ht_params = {
	.key_len = sizeof(struct mlxsw_afa_set_ht_key),
	.key_offset = offsetof(struct mlxsw_afa_set, ht_key),
	.head_offset = offsetof(struct mlxsw_afa_set, ht_node),
	.automatic_shrinking = true,
};


struct mlxsw_afa_fwd_entry_ht_key {
	
u8 local_port;
};


struct mlxsw_afa_fwd_entry {
	
struct rhash_head ht_node;
	
struct mlxsw_afa_fwd_entry_ht_key ht_key;
	
u32 kvdl_index;
	
unsigned int ref_count;
};


static const struct rhashtable_params mlxsw_afa_fwd_entry_ht_params = {
	.key_len = sizeof(struct mlxsw_afa_fwd_entry_ht_key),
	.key_offset = offsetof(struct mlxsw_afa_fwd_entry, ht_key),
	.head_offset = offsetof(struct mlxsw_afa_fwd_entry, ht_node),
	.automatic_shrinking = true,
};



struct mlxsw_afa *mlxsw_afa_create(unsigned int max_acts_per_set,
				   const struct mlxsw_afa_ops *ops,
				   void *ops_priv)
{
	struct mlxsw_afa *mlxsw_afa;
	int err;

	mlxsw_afa = kzalloc(sizeof(*mlxsw_afa), GFP_KERNEL);
	if (!mlxsw_afa)
		return ERR_PTR(-ENOMEM);
	err = rhashtable_init(&mlxsw_afa->set_ht, &mlxsw_afa_set_ht_params);
	if (err)
		goto err_set_rhashtable_init;
	err = rhashtable_init(&mlxsw_afa->fwd_entry_ht,
			      &mlxsw_afa_fwd_entry_ht_params);
	if (err)
		goto err_fwd_entry_rhashtable_init;
	mlxsw_afa->max_acts_per_set = max_acts_per_set;
	mlxsw_afa->ops = ops;
	mlxsw_afa->ops_priv = ops_priv;
	return mlxsw_afa;

err_fwd_entry_rhashtable_init:
	rhashtable_destroy(&mlxsw_afa->set_ht);
err_set_rhashtable_init:
	kfree(mlxsw_afa);
	return ERR_PTR(err);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
138
100.00%
1
100.00%
Total
138
100.00%
1
100.00%

EXPORT_SYMBOL(mlxsw_afa_create);



void mlxsw_afa_destroy(struct mlxsw_afa *mlxsw_afa)
{
	rhashtable_destroy(&mlxsw_afa->fwd_entry_ht);
	rhashtable_destroy(&mlxsw_afa->set_ht);
	kfree(mlxsw_afa);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
31
100.00%
1
100.00%
Total
31
100.00%
1
100.00%

EXPORT_SYMBOL(mlxsw_afa_destroy);



static void mlxsw_afa_set_goto_set(struct mlxsw_afa_set *set,
				   enum mlxsw_afa_set_goto_binding_cmd cmd,
				   u16 group_id)
{
	char *actions = set->ht_key.enc_actions;

	mlxsw_afa_set_type_set(actions, MLXSW_AFA_SET_TYPE_GOTO);
	mlxsw_afa_set_goto_g_set(actions, true);
	mlxsw_afa_set_goto_binding_cmd_set(actions, cmd);
	mlxsw_afa_set_goto_next_binding_set(actions, group_id);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
56
100.00%
1
100.00%
Total
56
100.00%
1
100.00%



static void mlxsw_afa_set_next_set(struct mlxsw_afa_set *set,
				   u32 next_set_kvdl_index)
{
	char *actions = set->ht_key.enc_actions;

	mlxsw_afa_set_type_set(actions, MLXSW_AFA_SET_TYPE_NEXT);
	mlxsw_afa_set_next_action_set_ptr_set(actions, next_set_kvdl_index);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
38
100.00%
1
100.00%
Total
38
100.00%
1
100.00%



static struct mlxsw_afa_set *mlxsw_afa_set_create(bool is_first)
{
	struct mlxsw_afa_set *set;

	set = kzalloc(sizeof(*set), GFP_KERNEL);
	if (!set)
		return NULL;
	/* Need to initialize the set to pass by default */
	mlxsw_afa_set_goto_set(set, MLXSW_AFA_SET_GOTO_BINDING_CMD_TERM, 0);
	set->ht_key.is_first = is_first;
	set->ref_count = 1;
	return set;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
64
100.00%
1
100.00%
Total
64
100.00%
1
100.00%



static void mlxsw_afa_set_destroy(struct mlxsw_afa_set *set)
{
	kfree(set);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
16
100.00%
1
100.00%
Total
16
100.00%
1
100.00%



static int mlxsw_afa_set_share(struct mlxsw_afa *mlxsw_afa,
			       struct mlxsw_afa_set *set)
{
	int err;

	err = rhashtable_insert_fast(&mlxsw_afa->set_ht, &set->ht_node,
				     mlxsw_afa_set_ht_params);
	if (err)
		return err;
	err = mlxsw_afa->ops->kvdl_set_add(mlxsw_afa->ops_priv,
					   &set->kvdl_index,
					   set->ht_key.enc_actions,
					   set->ht_key.is_first);
	if (err)
		goto err_kvdl_set_add;
	set->shared = true;
	set->prev = NULL;
	return 0;

err_kvdl_set_add:
	rhashtable_remove_fast(&mlxsw_afa->set_ht, &set->ht_node,
			       mlxsw_afa_set_ht_params);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
115
100.00%
1
100.00%
Total
115
100.00%
1
100.00%



static void mlxsw_afa_set_unshare(struct mlxsw_afa *mlxsw_afa,
				  struct mlxsw_afa_set *set)
{
	mlxsw_afa->ops->kvdl_set_del(mlxsw_afa->ops_priv,
				     set->kvdl_index,
				     set->ht_key.is_first);
	rhashtable_remove_fast(&mlxsw_afa->set_ht, &set->ht_node,
			       mlxsw_afa_set_ht_params);
	set->shared = false;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
58
100.00%
1
100.00%
Total
58
100.00%
1
100.00%



static void mlxsw_afa_set_put(struct mlxsw_afa *mlxsw_afa,
			      struct mlxsw_afa_set *set)
{
	if (--set->ref_count)
		return;
	if (set->shared)
		mlxsw_afa_set_unshare(mlxsw_afa, set);
	mlxsw_afa_set_destroy(set);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
42
100.00%
1
100.00%
Total
42
100.00%
1
100.00%



static struct mlxsw_afa_set *mlxsw_afa_set_get(struct mlxsw_afa *mlxsw_afa,
					       struct mlxsw_afa_set *orig_set)
{
	struct mlxsw_afa_set *set;
	int err;

	/* There is a hashtable of sets maintained. If a set with the exact
         * same encoding exists, we reuse it. Otherwise, the current set
         * is shared by making it available to others using the hash table.
         */
	set = rhashtable_lookup_fast(&mlxsw_afa->set_ht, &orig_set->ht_key,
				     mlxsw_afa_set_ht_params);
	if (set) {
		set->ref_count++;
		mlxsw_afa_set_put(mlxsw_afa, orig_set);
	} else {
		set = orig_set;
		err = mlxsw_afa_set_share(mlxsw_afa, set);
		if (err)
			return ERR_PTR(err);
	}
	return set;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
91
100.00%
1
100.00%
Total
91
100.00%
1
100.00%

/* Block structure holds a list of action sets. One action block
 * represents one chain of actions executed upon match of a rule.
 */


struct mlxsw_afa_block {
	
struct mlxsw_afa *afa;
	
bool finished;
	
struct mlxsw_afa_set *first_set;
	
struct mlxsw_afa_set *cur_set;
	
unsigned int cur_act_index; /* In current set. */
	
struct list_head resource_list; /* List of resources held by actions
                                         * in this block.
                                         */
};


struct mlxsw_afa_resource {
	
struct list_head list;
	
void (*destructor)(struct mlxsw_afa_block *block,
			   struct mlxsw_afa_resource *resource);
};



static void mlxsw_afa_resource_add(struct mlxsw_afa_block *block,
				   struct mlxsw_afa_resource *resource)
{
	list_add(&resource->list, &block->resource_list);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
29
100.00%
1
100.00%
Total
29
100.00%
1
100.00%



static void mlxsw_afa_resources_destroy(struct mlxsw_afa_block *block)
{
	struct mlxsw_afa_resource *resource, *tmp;

	list_for_each_entry_safe(resource, tmp, &block->resource_list, list) {
		list_del(&resource->list);
		resource->destructor(block, resource);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
48
100.00%
1
100.00%
Total
48
100.00%
1
100.00%



struct mlxsw_afa_block *mlxsw_afa_block_create(struct mlxsw_afa *mlxsw_afa)
{
	struct mlxsw_afa_block *block;

	block = kzalloc(sizeof(*block), GFP_KERNEL);
	if (!block)
		return NULL;
	INIT_LIST_HEAD(&block->resource_list);
	block->afa = mlxsw_afa;

	/* At least one action set is always present, so just create it here */
	block->first_set = mlxsw_afa_set_create(true);
	if (!block->first_set)
		goto err_first_set_create;
	block->cur_set = block->first_set;
	return block;

err_first_set_create:
	kfree(block);
	return NULL;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
93
100.00%
2
100.00%
Total
93
100.00%
2
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_create);



void mlxsw_afa_block_destroy(struct mlxsw_afa_block *block)
{
	struct mlxsw_afa_set *set = block->first_set;
	struct mlxsw_afa_set *next_set;

	do {
		next_set = set->next;
		mlxsw_afa_set_put(block->afa, set);
		set = next_set;
	} while (set);
	mlxsw_afa_resources_destroy(block);
	kfree(block);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
61
100.00%
2
100.00%
Total
61
100.00%
2
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_destroy);



int mlxsw_afa_block_commit(struct mlxsw_afa_block *block)
{
	struct mlxsw_afa_set *set = block->cur_set;
	struct mlxsw_afa_set *prev_set;

	block->cur_set = NULL;
	block->finished = true;

	/* Go over all linked sets starting from last
         * and try to find existing set in the hash table.
         * In case it is not there, assign a KVD linear index
         * and insert it.
         */
	do {
		prev_set = set->prev;
		set = mlxsw_afa_set_get(block->afa, set);
		if (IS_ERR(set))
			/* No rollback is needed since the chain is
                         * in consistent state and mlxsw_afa_block_destroy
                         * will take care of putting it away.
                         */
			return PTR_ERR(set);
		if (prev_set) {
			prev_set->next = set;
			mlxsw_afa_set_next_set(prev_set, set->kvdl_index);
			set = prev_set;
		}
	} while (prev_set);

	block->first_set = set;
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
110
100.00%
2
100.00%
Total
110
100.00%
2
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_commit);



char *mlxsw_afa_block_first_set(struct mlxsw_afa_block *block)
{
	return block->first_set->ht_key.enc_actions;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
20
100.00%
1
100.00%
Total
20
100.00%
1
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_first_set);



u32 mlxsw_afa_block_first_set_kvdl_index(struct mlxsw_afa_block *block)
{
	return block->first_set->kvdl_index;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
17
100.00%
1
100.00%
Total
17
100.00%
1
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_first_set_kvdl_index);



int mlxsw_afa_block_continue(struct mlxsw_afa_block *block)
{
	if (block->finished)
		return -EINVAL;
	mlxsw_afa_set_goto_set(block->cur_set,
			       MLXSW_AFA_SET_GOTO_BINDING_CMD_NONE, 0);
	block->finished = true;
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
40
100.00%
2
100.00%
Total
40
100.00%
2
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_continue);



int mlxsw_afa_block_jump(struct mlxsw_afa_block *block, u16 group_id)
{
	if (block->finished)
		return -EINVAL;
	mlxsw_afa_set_goto_set(block->cur_set,
			       MLXSW_AFA_SET_GOTO_BINDING_CMD_JUMP, group_id);
	block->finished = true;
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
43
100.00%
2
100.00%
Total
43
100.00%
2
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_jump);



int mlxsw_afa_block_terminate(struct mlxsw_afa_block *block)
{
	if (block->finished)
		return -EINVAL;
	mlxsw_afa_set_goto_set(block->cur_set,
			       MLXSW_AFA_SET_GOTO_BINDING_CMD_TERM, 0);
	block->finished = true;
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
40
100.00%
1
100.00%
Total
40
100.00%
1
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_terminate);


static struct mlxsw_afa_fwd_entry *

mlxsw_afa_fwd_entry_create(struct mlxsw_afa *mlxsw_afa, u8 local_port)
{
	struct mlxsw_afa_fwd_entry *fwd_entry;
	int err;

	fwd_entry = kzalloc(sizeof(*fwd_entry), GFP_KERNEL);
	if (!fwd_entry)
		return ERR_PTR(-ENOMEM);
	fwd_entry->ht_key.local_port = local_port;
	fwd_entry->ref_count = 1;

	err = rhashtable_insert_fast(&mlxsw_afa->fwd_entry_ht,
				     &fwd_entry->ht_node,
				     mlxsw_afa_fwd_entry_ht_params);
	if (err)
		goto err_rhashtable_insert;

	err = mlxsw_afa->ops->kvdl_fwd_entry_add(mlxsw_afa->ops_priv,
						 &fwd_entry->kvdl_index,
						 local_port);
	if (err)
		goto err_kvdl_fwd_entry_add;
	return fwd_entry;

err_kvdl_fwd_entry_add:
	rhashtable_remove_fast(&mlxsw_afa->fwd_entry_ht, &fwd_entry->ht_node,
			       mlxsw_afa_fwd_entry_ht_params);
err_rhashtable_insert:
	kfree(fwd_entry);
	return ERR_PTR(err);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
147
100.00%
1
100.00%
Total
147
100.00%
1
100.00%



static void mlxsw_afa_fwd_entry_destroy(struct mlxsw_afa *mlxsw_afa,
					struct mlxsw_afa_fwd_entry *fwd_entry)
{
	mlxsw_afa->ops->kvdl_fwd_entry_del(mlxsw_afa->ops_priv,
					   fwd_entry->kvdl_index);
	rhashtable_remove_fast(&mlxsw_afa->fwd_entry_ht, &fwd_entry->ht_node,
			       mlxsw_afa_fwd_entry_ht_params);
	kfree(fwd_entry);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
51
100.00%
1
100.00%
Total
51
100.00%
1
100.00%


static struct mlxsw_afa_fwd_entry *

mlxsw_afa_fwd_entry_get(struct mlxsw_afa *mlxsw_afa, u8 local_port)
{
	struct mlxsw_afa_fwd_entry_ht_key ht_key = {0};
	struct mlxsw_afa_fwd_entry *fwd_entry;

	ht_key.local_port = local_port;
	fwd_entry = rhashtable_lookup_fast(&mlxsw_afa->fwd_entry_ht, &ht_key,
					   mlxsw_afa_fwd_entry_ht_params);
	if (fwd_entry) {
		fwd_entry->ref_count++;
		return fwd_entry;
	}
	return mlxsw_afa_fwd_entry_create(mlxsw_afa, local_port);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
72
100.00%
1
100.00%
Total
72
100.00%
1
100.00%



static void mlxsw_afa_fwd_entry_put(struct mlxsw_afa *mlxsw_afa,
				    struct mlxsw_afa_fwd_entry *fwd_entry)
{
	if (--fwd_entry->ref_count)
		return;
	mlxsw_afa_fwd_entry_destroy(mlxsw_afa, fwd_entry);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
31
100.00%
1
100.00%
Total
31
100.00%
1
100.00%


struct mlxsw_afa_fwd_entry_ref {
	
struct mlxsw_afa_resource resource;
	
struct mlxsw_afa_fwd_entry *fwd_entry;
};


static void

mlxsw_afa_fwd_entry_ref_destroy(struct mlxsw_afa_block *block,
				struct mlxsw_afa_fwd_entry_ref *fwd_entry_ref)
{
	mlxsw_afa_fwd_entry_put(block->afa, fwd_entry_ref->fwd_entry);
	kfree(fwd_entry_ref);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
32
100.00%
2
100.00%
Total
32
100.00%
2
100.00%


static void

mlxsw_afa_fwd_entry_ref_destructor(struct mlxsw_afa_block *block,
				   struct mlxsw_afa_resource *resource)
{
	struct mlxsw_afa_fwd_entry_ref *fwd_entry_ref;

	fwd_entry_ref = container_of(resource, struct mlxsw_afa_fwd_entry_ref,
				     resource);
	mlxsw_afa_fwd_entry_ref_destroy(block, fwd_entry_ref);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
40
100.00%
1
100.00%
Total
40
100.00%
1
100.00%


static struct mlxsw_afa_fwd_entry_ref *

mlxsw_afa_fwd_entry_ref_create(struct mlxsw_afa_block *block, u8 local_port)
{
	struct mlxsw_afa_fwd_entry_ref *fwd_entry_ref;
	struct mlxsw_afa_fwd_entry *fwd_entry;
	int err;

	fwd_entry_ref = kzalloc(sizeof(*fwd_entry_ref), GFP_KERNEL);
	if (!fwd_entry_ref)
		return ERR_PTR(-ENOMEM);
	fwd_entry = mlxsw_afa_fwd_entry_get(block->afa, local_port);
	if (IS_ERR(fwd_entry)) {
		err = PTR_ERR(fwd_entry);
		goto err_fwd_entry_get;
	}
	fwd_entry_ref->fwd_entry = fwd_entry;
	fwd_entry_ref->resource.destructor = mlxsw_afa_fwd_entry_ref_destructor;
	mlxsw_afa_resource_add(block, &fwd_entry_ref->resource);
	return fwd_entry_ref;

err_fwd_entry_get:
	kfree(fwd_entry_ref);
	return ERR_PTR(err);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
124
100.00%
2
100.00%
Total
124
100.00%
2
100.00%


struct mlxsw_afa_counter {
	
struct mlxsw_afa_resource resource;
	
u32 counter_index;
};


static void

mlxsw_afa_counter_destroy(struct mlxsw_afa_block *block,
			  struct mlxsw_afa_counter *counter)
{
	block->afa->ops->counter_index_put(block->afa->ops_priv,
					   counter->counter_index);
	kfree(counter);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
40
100.00%
1
100.00%
Total
40
100.00%
1
100.00%


static void

mlxsw_afa_counter_destructor(struct mlxsw_afa_block *block,
			     struct mlxsw_afa_resource *resource)
{
	struct mlxsw_afa_counter *counter;

	counter = container_of(resource, struct mlxsw_afa_counter, resource);
	mlxsw_afa_counter_destroy(block, counter);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
40
100.00%
1
100.00%
Total
40
100.00%
1
100.00%


static struct mlxsw_afa_counter *

mlxsw_afa_counter_create(struct mlxsw_afa_block *block)
{
	struct mlxsw_afa_counter *counter;
	int err;

	counter = kzalloc(sizeof(*counter), GFP_KERNEL);
	if (!counter)
		return ERR_PTR(-ENOMEM);

	err = block->afa->ops->counter_index_get(block->afa->ops_priv,
						 &counter->counter_index);
	if (err)
		goto err_counter_index_get;
	counter->resource.destructor = mlxsw_afa_counter_destructor;
	mlxsw_afa_resource_add(block, &counter->resource);
	return counter;

err_counter_index_get:
	kfree(counter);
	return ERR_PTR(err);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
109
100.00%
1
100.00%
Total
109
100.00%
1
100.00%


#define MLXSW_AFA_ONE_ACTION_LEN 32

#define MLXSW_AFA_PAYLOAD_OFFSET 4



static char *mlxsw_afa_block_append_action(struct mlxsw_afa_block *block,
					   u8 action_code, u8 action_size)
{
	char *oneact;
	char *actions;

	if (WARN_ON(block->finished))
		return NULL;
	if (block->cur_act_index + action_size >
	    block->afa->max_acts_per_set) {
		struct mlxsw_afa_set *set;

		/* The appended action won't fit into the current action set,
                 * so create a new set.
                 */
		set = mlxsw_afa_set_create(false);
		if (!set)
			return NULL;
		set->prev = block->cur_set;
		block->cur_act_index = 0;
		block->cur_set->next = set;
		block->cur_set = set;
	}

	actions = block->cur_set->ht_key.enc_actions;
	oneact = actions + block->cur_act_index * MLXSW_AFA_ONE_ACTION_LEN;
	block->cur_act_index += action_size;
	mlxsw_afa_all_action_type_set(oneact, action_code);
	return oneact + MLXSW_AFA_PAYLOAD_OFFSET;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
141
100.00%
1
100.00%
Total
141
100.00%
1
100.00%

/* VLAN Action
 * -----------
 * VLAN action is used for manipulating VLANs. It can be used to implement QinQ,
 * VLAN translation, change of PCP bits of the VLAN tag, push, pop as swap VLANs
 * and more.
 */


#define MLXSW_AFA_VLAN_CODE 0x02

#define MLXSW_AFA_VLAN_SIZE 1


enum mlxsw_afa_vlan_vlan_tag_cmd {
	
MLXSW_AFA_VLAN_VLAN_TAG_CMD_NOP,
	
MLXSW_AFA_VLAN_VLAN_TAG_CMD_PUSH_TAG,
	
MLXSW_AFA_VLAN_VLAN_TAG_CMD_POP_TAG,
};


enum mlxsw_afa_vlan_cmd {
	
MLXSW_AFA_VLAN_CMD_NOP,
	
MLXSW_AFA_VLAN_CMD_SET_OUTER,
	
MLXSW_AFA_VLAN_CMD_SET_INNER,
	
MLXSW_AFA_VLAN_CMD_COPY_OUTER_TO_INNER,
	
MLXSW_AFA_VLAN_CMD_COPY_INNER_TO_OUTER,
	
MLXSW_AFA_VLAN_CMD_SWAP,
};

/* afa_vlan_vlan_tag_cmd
 * Tag command: push, pop, nop VLAN header.
 */
MLXSW_ITEM32(afa, vlan, vlan_tag_cmd, 0x00, 29, 3);

/* afa_vlan_vid_cmd */
MLXSW_ITEM32(afa, vlan, vid_cmd, 0x04, 29, 3);

/* afa_vlan_vid */
MLXSW_ITEM32(afa, vlan, vid, 0x04, 0, 12);

/* afa_vlan_ethertype_cmd */
MLXSW_ITEM32(afa, vlan, ethertype_cmd, 0x08, 29, 3);

/* afa_vlan_ethertype
 * Index to EtherTypes in Switch VLAN EtherType Register (SVER).
 */
MLXSW_ITEM32(afa, vlan, ethertype, 0x08, 24, 3);

/* afa_vlan_pcp_cmd */
MLXSW_ITEM32(afa, vlan, pcp_cmd, 0x08, 13, 3);

/* afa_vlan_pcp */
MLXSW_ITEM32(afa, vlan, pcp, 0x08, 8, 3);


static inline void

mlxsw_afa_vlan_pack(char *payload,
		    enum mlxsw_afa_vlan_vlan_tag_cmd vlan_tag_cmd,
		    enum mlxsw_afa_vlan_cmd vid_cmd, u16 vid,
		    enum mlxsw_afa_vlan_cmd pcp_cmd, u8 pcp,
		    enum mlxsw_afa_vlan_cmd ethertype_cmd, u8 ethertype)
{
	mlxsw_afa_vlan_vlan_tag_cmd_set(payload, vlan_tag_cmd);
	mlxsw_afa_vlan_vid_cmd_set(payload, vid_cmd);
	mlxsw_afa_vlan_vid_set(payload, vid);
	mlxsw_afa_vlan_pcp_cmd_set(payload, pcp_cmd);
	mlxsw_afa_vlan_pcp_set(payload, pcp);
	mlxsw_afa_vlan_ethertype_cmd_set(payload, ethertype_cmd);
	mlxsw_afa_vlan_ethertype_set(payload, ethertype);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Petr Machata
85
100.00%
1
100.00%
Total
85
100.00%
1
100.00%



int mlxsw_afa_block_append_vlan_modify(struct mlxsw_afa_block *block,
				       u16 vid, u8 pcp, u8 et)
{
	char *act = mlxsw_afa_block_append_action(block,
						  MLXSW_AFA_VLAN_CODE,
						  MLXSW_AFA_VLAN_SIZE);

	if (!act)
		return -ENOBUFS;
	mlxsw_afa_vlan_pack(act, MLXSW_AFA_VLAN_VLAN_TAG_CMD_NOP,
			    MLXSW_AFA_VLAN_CMD_SET_OUTER, vid,
			    MLXSW_AFA_VLAN_CMD_SET_OUTER, pcp,
			    MLXSW_AFA_VLAN_CMD_SET_OUTER, et);
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Petr Machata
63
100.00%
1
100.00%
Total
63
100.00%
1
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_append_vlan_modify);

/* Trap / Discard Action
 * ---------------------
 * The Trap / Discard action enables trapping / mirroring packets to the CPU
 * as well as discarding packets.
 * The ACL Trap / Discard separates the forward/discard control from CPU
 * trap control. In addition, the Trap / Discard action enables activating
 * SPAN (port mirroring).
 */


#define MLXSW_AFA_TRAPDISC_CODE 0x03

#define MLXSW_AFA_TRAPDISC_SIZE 1


enum mlxsw_afa_trapdisc_trap_action {
	
MLXSW_AFA_TRAPDISC_TRAP_ACTION_NOP = 0,
	
MLXSW_AFA_TRAPDISC_TRAP_ACTION_TRAP = 2,
};

/* afa_trapdisc_trap_action
 * Trap Action.
 */
MLXSW_ITEM32(afa, trapdisc, trap_action, 0x00, 24, 4);


enum mlxsw_afa_trapdisc_forward_action {
	
MLXSW_AFA_TRAPDISC_FORWARD_ACTION_FORWARD = 1,
	
MLXSW_AFA_TRAPDISC_FORWARD_ACTION_DISCARD = 3,
};

/* afa_trapdisc_forward_action
 * Forward Action.
 */
MLXSW_ITEM32(afa, trapdisc, forward_action, 0x00, 0, 4);

/* afa_trapdisc_trap_id
 * Trap ID to configure.
 */
MLXSW_ITEM32(afa, trapdisc, trap_id, 0x04, 0, 9);

/* afa_trapdisc_mirror_agent
 * Mirror agent.
 */
MLXSW_ITEM32(afa, trapdisc, mirror_agent, 0x08, 29, 3);

/* afa_trapdisc_mirror_enable
 * Mirror enable.
 */
MLXSW_ITEM32(afa, trapdisc, mirror_enable, 0x08, 24, 1);


static inline void

mlxsw_afa_trapdisc_pack(char *payload,
			enum mlxsw_afa_trapdisc_trap_action trap_action,
			enum mlxsw_afa_trapdisc_forward_action forward_action,
			u16 trap_id)
{
	mlxsw_afa_trapdisc_trap_action_set(payload, trap_action);
	mlxsw_afa_trapdisc_forward_action_set(payload, forward_action);
	mlxsw_afa_trapdisc_trap_id_set(payload, trap_id);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
43
100.00%
2
100.00%
Total
43
100.00%
2
100.00%


static inline void

mlxsw_afa_trapdisc_mirror_pack(char *payload, bool mirror_enable,
			       u8 mirror_agent)
{
	mlxsw_afa_trapdisc_mirror_enable_set(payload, mirror_enable);
	mlxsw_afa_trapdisc_mirror_agent_set(payload, mirror_agent);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Arkadi Sharshevsky
31
100.00%
1
100.00%
Total
31
100.00%
1
100.00%



int mlxsw_afa_block_append_drop(struct mlxsw_afa_block *block)
{
	char *act = mlxsw_afa_block_append_action(block,
						  MLXSW_AFA_TRAPDISC_CODE,
						  MLXSW_AFA_TRAPDISC_SIZE);

	if (!act)
		return -ENOBUFS;
	mlxsw_afa_trapdisc_pack(act, MLXSW_AFA_TRAPDISC_TRAP_ACTION_NOP,
				MLXSW_AFA_TRAPDISC_FORWARD_ACTION_DISCARD, 0);
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
46
100.00%
2
100.00%
Total
46
100.00%
2
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_append_drop);



int mlxsw_afa_block_append_trap(struct mlxsw_afa_block *block, u16 trap_id)
{
	char *act = mlxsw_afa_block_append_action(block,
						  MLXSW_AFA_TRAPDISC_CODE,
						  MLXSW_AFA_TRAPDISC_SIZE);

	if (!act)
		return -ENOBUFS;
	mlxsw_afa_trapdisc_pack(act, MLXSW_AFA_TRAPDISC_TRAP_ACTION_TRAP,
				MLXSW_AFA_TRAPDISC_FORWARD_ACTION_DISCARD,
				trap_id);
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
45
91.84%
1
50.00%
Yotam Gigi
4
8.16%
1
50.00%
Total
49
100.00%
2
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_append_trap);



int mlxsw_afa_block_append_trap_and_forward(struct mlxsw_afa_block *block,
					    u16 trap_id)
{
	char *act = mlxsw_afa_block_append_action(block,
						  MLXSW_AFA_TRAPDISC_CODE,
						  MLXSW_AFA_TRAPDISC_SIZE);

	if (!act)
		return -ENOBUFS;
	mlxsw_afa_trapdisc_pack(act, MLXSW_AFA_TRAPDISC_TRAP_ACTION_TRAP,
				MLXSW_AFA_TRAPDISC_FORWARD_ACTION_FORWARD,
				trap_id);
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Yotam Gigi
49
100.00%
1
100.00%
Total
49
100.00%
1
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_append_trap_and_forward);


struct mlxsw_afa_mirror {
	
struct mlxsw_afa_resource resource;
	
int span_id;
	
u8 local_in_port;
	
u8 local_out_port;
	
bool ingress;
};


static void

mlxsw_afa_mirror_destroy(struct mlxsw_afa_block *block,
			 struct mlxsw_afa_mirror *mirror)
{
	block->afa->ops->mirror_del(block->afa->ops_priv,
				    mirror->local_in_port,
				    mirror->local_out_port,
				    mirror->ingress);
	kfree(mirror);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Arkadi Sharshevsky
48
100.00%
1
100.00%
Total
48
100.00%
1
100.00%


static void

mlxsw_afa_mirror_destructor(struct mlxsw_afa_block *block,
			    struct mlxsw_afa_resource *resource)
{
	struct mlxsw_afa_mirror *mirror;

	mirror = container_of(resource, struct mlxsw_afa_mirror, resource);
	mlxsw_afa_mirror_destroy(block, mirror);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Arkadi Sharshevsky
40
100.00%
1
100.00%
Total
40
100.00%
1
100.00%


static struct mlxsw_afa_mirror *

mlxsw_afa_mirror_create(struct mlxsw_afa_block *block,
			u8 local_in_port, u8 local_out_port,
			bool ingress)
{
	struct mlxsw_afa_mirror *mirror;
	int err;

	mirror = kzalloc(sizeof(*mirror), GFP_KERNEL);
	if (!mirror)
		return ERR_PTR(-ENOMEM);

	err = block->afa->ops->mirror_add(block->afa->ops_priv,
					  local_in_port, local_out_port,
					  ingress, &mirror->span_id);
	if (err)
		goto err_mirror_add;

	mirror->ingress = ingress;
	mirror->local_out_port = local_out_port;
	mirror->local_in_port = local_in_port;
	mirror->resource.destructor = mlxsw_afa_mirror_destructor;
	mlxsw_afa_resource_add(block, &mirror->resource);
	return mirror;

err_mirror_add:
	kfree(mirror);
	return ERR_PTR(err);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Arkadi Sharshevsky
142
100.00%
2
100.00%
Total
142
100.00%
2
100.00%


static int

mlxsw_afa_block_append_allocated_mirror(struct mlxsw_afa_block *block,
					u8 mirror_agent)
{
	char *act = mlxsw_afa_block_append_action(block,
						  MLXSW_AFA_TRAPDISC_CODE,
						  MLXSW_AFA_TRAPDISC_SIZE);
	if (!act)
		return -ENOBUFS;
	mlxsw_afa_trapdisc_pack(act, MLXSW_AFA_TRAPDISC_TRAP_ACTION_NOP,
				MLXSW_AFA_TRAPDISC_FORWARD_ACTION_FORWARD, 0);
	mlxsw_afa_trapdisc_mirror_pack(act, true, mirror_agent);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Arkadi Sharshevsky
59
100.00%
2
100.00%
Total
59
100.00%
2
100.00%


int

mlxsw_afa_block_append_mirror(struct mlxsw_afa_block *block,
			      u8 local_in_port, u8 local_out_port, bool ingress)
{
	struct mlxsw_afa_mirror *mirror;
	int err;

	mirror = mlxsw_afa_mirror_create(block, local_in_port, local_out_port,
					 ingress);
	if (IS_ERR(mirror))
		return PTR_ERR(mirror);

	err = mlxsw_afa_block_append_allocated_mirror(block, mirror->span_id);
	if (err)
		goto err_append_allocated_mirror;

	return 0;

err_append_allocated_mirror:
	mlxsw_afa_mirror_destroy(block, mirror);
	return err;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Arkadi Sharshevsky
86
100.00%
1
100.00%
Total
86
100.00%
1
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_append_mirror);

/* Forwarding Action
 * -----------------
 * Forwarding Action can be used to implement Policy Based Switching (PBS)
 * as well as OpenFlow related "Output" action.
 */


#define MLXSW_AFA_FORWARD_CODE 0x07

#define MLXSW_AFA_FORWARD_SIZE 1


enum mlxsw_afa_forward_type {
	/* PBS, Policy Based Switching */
	
MLXSW_AFA_FORWARD_TYPE_PBS,
	/* Output, OpenFlow output type */
	
MLXSW_AFA_FORWARD_TYPE_OUTPUT,
};

/* afa_forward_type */
MLXSW_ITEM32(afa, forward, type, 0x00, 24, 2);

/* afa_forward_pbs_ptr
 * A pointer to the PBS entry configured by PPBS register.
 * Reserved when in_port is set.
 */
MLXSW_ITEM32(afa, forward, pbs_ptr, 0x08, 0, 24);

/* afa_forward_in_port
 * Packet is forwarded back to the ingress port.
 */
MLXSW_ITEM32(afa, forward, in_port, 0x0C, 0, 1);


static inline void

mlxsw_afa_forward_pack(char *payload, enum mlxsw_afa_forward_type type,
		       u32 pbs_ptr, bool in_port)
{
	mlxsw_afa_forward_type_set(payload, type);
	mlxsw_afa_forward_pbs_ptr_set(payload, pbs_ptr);
	mlxsw_afa_forward_in_port_set(payload, in_port);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
42
100.00%
1
100.00%
Total
42
100.00%
1
100.00%



int mlxsw_afa_block_append_fwd(struct mlxsw_afa_block *block,
			       u8 local_port, bool in_port)
{
	struct mlxsw_afa_fwd_entry_ref *fwd_entry_ref;
	u32 kvdl_index;
	char *act;
	int err;

	if (in_port)
		return -EOPNOTSUPP;
	fwd_entry_ref = mlxsw_afa_fwd_entry_ref_create(block, local_port);
	if (IS_ERR(fwd_entry_ref))
		return PTR_ERR(fwd_entry_ref);
	kvdl_index = fwd_entry_ref->fwd_entry->kvdl_index;

	act = mlxsw_afa_block_append_action(block, MLXSW_AFA_FORWARD_CODE,
					    MLXSW_AFA_FORWARD_SIZE);
	if (!act) {
		err = -ENOBUFS;
		goto err_append_action;
	}
	mlxsw_afa_forward_pack(act, MLXSW_AFA_FORWARD_TYPE_PBS,
			       kvdl_index, in_port);
	return 0;

err_append_action:
	mlxsw_afa_fwd_entry_ref_destroy(block, fwd_entry_ref);
	return err;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
121
100.00%
2
100.00%
Total
121
100.00%
2
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_append_fwd);

/* Policing and Counting Action
 * ----------------------------
 * Policing and Counting action is used for binding policer and counter
 * to ACL rules.
 */


#define MLXSW_AFA_POLCNT_CODE 0x08

#define MLXSW_AFA_POLCNT_SIZE 1


enum mlxsw_afa_polcnt_counter_set_type {
	/* No count */
	
MLXSW_AFA_POLCNT_COUNTER_SET_TYPE_NO_COUNT = 0x00,
	/* Count packets and bytes */
	
MLXSW_AFA_POLCNT_COUNTER_SET_TYPE_PACKETS_BYTES = 0x03,
	/* Count only packets */
	
MLXSW_AFA_POLCNT_COUNTER_SET_TYPE_PACKETS = 0x05,
};

/* afa_polcnt_counter_set_type
 * Counter set type for flow counters.
 */
MLXSW_ITEM32(afa, polcnt, counter_set_type, 0x04, 24, 8);

/* afa_polcnt_counter_index
 * Counter index for flow counters.
 */
MLXSW_ITEM32(afa, polcnt, counter_index, 0x04, 0, 24);


static inline void

mlxsw_afa_polcnt_pack(char *payload,
		      enum mlxsw_afa_polcnt_counter_set_type set_type,
		      u32 counter_index)
{
	mlxsw_afa_polcnt_counter_set_type_set(payload, set_type);
	mlxsw_afa_polcnt_counter_index_set(payload, counter_index);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Arkadi Sharshevsky
32
100.00%
1
100.00%
Total
32
100.00%
1
100.00%



int mlxsw_afa_block_append_allocated_counter(struct mlxsw_afa_block *block,
					     u32 counter_index)
{
	char *act = mlxsw_afa_block_append_action(block, MLXSW_AFA_POLCNT_CODE,
						  MLXSW_AFA_POLCNT_SIZE);
	if (!act)
		return -ENOBUFS;
	mlxsw_afa_polcnt_pack(act, MLXSW_AFA_POLCNT_COUNTER_SET_TYPE_PACKETS_BYTES,
			      counter_index);
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Arkadi Sharshevsky
46
97.87%
1
50.00%
Jiri Pirko
1
2.13%
1
50.00%
Total
47
100.00%
2
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_append_allocated_counter);



int mlxsw_afa_block_append_counter(struct mlxsw_afa_block *block,
				   u32 *p_counter_index)
{
	struct mlxsw_afa_counter *counter;
	u32 counter_index;
	int err;

	counter = mlxsw_afa_counter_create(block);
	if (IS_ERR(counter))
		return PTR_ERR(counter);
	counter_index = counter->counter_index;

	err = mlxsw_afa_block_append_allocated_counter(block, counter_index);
	if (err)
		goto err_append_allocated_counter;

	if (p_counter_index)
		*p_counter_index = counter_index;
	return 0;

err_append_allocated_counter:
	mlxsw_afa_counter_destroy(block, counter);
	return err;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
91
100.00%
1
100.00%
Total
91
100.00%
1
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_append_counter);

/* Virtual Router and Forwarding Domain Action
 * -------------------------------------------
 * Virtual Switch action is used for manipulate the Virtual Router (VR),
 * MPLS label space and the Forwarding Identifier (FID).
 */


#define MLXSW_AFA_VIRFWD_CODE 0x0E

#define MLXSW_AFA_VIRFWD_SIZE 1


enum mlxsw_afa_virfwd_fid_cmd {
	/* Do nothing */
	
MLXSW_AFA_VIRFWD_FID_CMD_NOOP,
	/* Set the Forwarding Identifier (FID) to fid */
	
MLXSW_AFA_VIRFWD_FID_CMD_SET,
};

/* afa_virfwd_fid_cmd */
MLXSW_ITEM32(afa, virfwd, fid_cmd, 0x08, 29, 3);

/* afa_virfwd_fid
 * The FID value.
 */
MLXSW_ITEM32(afa, virfwd, fid, 0x08, 0, 16);



static inline void mlxsw_afa_virfwd_pack(char *payload,
					 enum mlxsw_afa_virfwd_fid_cmd fid_cmd,
					 u16 fid)
{
	mlxsw_afa_virfwd_fid_cmd_set(payload, fid_cmd);
	mlxsw_afa_virfwd_fid_set(payload, fid);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
32
100.00%
1
100.00%
Total
32
100.00%
1
100.00%



int mlxsw_afa_block_append_fid_set(struct mlxsw_afa_block *block, u16 fid)
{
	char *act = mlxsw_afa_block_append_action(block,
						  MLXSW_AFA_VIRFWD_CODE,
						  MLXSW_AFA_VIRFWD_SIZE);
	if (!act)
		return -ENOBUFS;
	mlxsw_afa_virfwd_pack(act, MLXSW_AFA_VIRFWD_FID_CMD_SET, fid);
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
47
100.00%
1
100.00%
Total
47
100.00%
1
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_append_fid_set);

/* MC Routing Action
 * -----------------
 * The Multicast router action. Can be used by RMFT_V2 - Router Multicast
 * Forwarding Table Version 2 Register.
 */


#define MLXSW_AFA_MCROUTER_CODE 0x10

#define MLXSW_AFA_MCROUTER_SIZE 2


enum mlxsw_afa_mcrouter_rpf_action {
	
MLXSW_AFA_MCROUTER_RPF_ACTION_NOP,
	
MLXSW_AFA_MCROUTER_RPF_ACTION_TRAP,
	
MLXSW_AFA_MCROUTER_RPF_ACTION_DISCARD_ERROR,
};

/* afa_mcrouter_rpf_action */
MLXSW_ITEM32(afa, mcrouter, rpf_action, 0x00, 28, 3);

/* afa_mcrouter_expected_irif */
MLXSW_ITEM32(afa, mcrouter, expected_irif, 0x00, 0, 16);

/* afa_mcrouter_min_mtu */
MLXSW_ITEM32(afa, mcrouter, min_mtu, 0x08, 0, 16);


enum mlxsw_afa_mrouter_vrmid {
	
MLXSW_AFA_MCROUTER_VRMID_INVALID,
	
MLXSW_AFA_MCROUTER_VRMID_VALID
};

/* afa_mcrouter_vrmid
 * Valid RMID: rigr_rmid_index is used as RMID
 */
MLXSW_ITEM32(afa, mcrouter, vrmid, 0x0C, 31, 1);

/* afa_mcrouter_rigr_rmid_index
 * When the vrmid field is set to invalid, the field is used as pointer to
 * Router Interface Group (RIGR) Table in the KVD linear.
 * When the vrmid is set to valid, the field is used as RMID index, ranged
 * from 0 to max_mid - 1. The index is to the Port Group Table.
 */
MLXSW_ITEM32(afa, mcrouter, rigr_rmid_index, 0x0C, 0, 24);


static inline void

mlxsw_afa_mcrouter_pack(char *payload,
			enum mlxsw_afa_mcrouter_rpf_action rpf_action,
			u16 expected_irif, u16 min_mtu,
			enum mlxsw_afa_mrouter_vrmid vrmid, u32 rigr_rmid_index)

{
	mlxsw_afa_mcrouter_rpf_action_set(payload, rpf_action);
	mlxsw_afa_mcrouter_expected_irif_set(payload, expected_irif);
	mlxsw_afa_mcrouter_min_mtu_set(payload, min_mtu);
	mlxsw_afa_mcrouter_vrmid_set(payload, vrmid);
	mlxsw_afa_mcrouter_rigr_rmid_index_set(payload, rigr_rmid_index);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Yotam Gigi
63
100.00%
1
100.00%
Total
63
100.00%
1
100.00%



int mlxsw_afa_block_append_mcrouter(struct mlxsw_afa_block *block,
				    u16 expected_irif, u16 min_mtu,
				    bool rmid_valid, u32 kvdl_index)
{
	char *act = mlxsw_afa_block_append_action(block,
						  MLXSW_AFA_MCROUTER_CODE,
						  MLXSW_AFA_MCROUTER_SIZE);
	if (!act)
		return -ENOBUFS;
	mlxsw_afa_mcrouter_pack(act, MLXSW_AFA_MCROUTER_RPF_ACTION_TRAP,
				expected_irif, min_mtu, rmid_valid, kvdl_index);
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Yotam Gigi
62
100.00%
1
100.00%
Total
62
100.00%
1
100.00%

EXPORT_SYMBOL(mlxsw_afa_block_append_mcrouter);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Jiri Pirko
3155
72.35%
9
56.25%
Arkadi Sharshevsky
607
13.92%
3
18.75%
Petr Machata
300
6.88%
1
6.25%
Yotam Gigi
299
6.86%
3
18.75%
Total
4361
100.00%
16
100.00%
Directory: drivers/net/ethernet/mellanox/mlxsw

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.