559 lines
12 KiB
C
559 lines
12 KiB
C
|
/*
|
||
|
|
* This file is part of the Chelsio T4 Ethernet driver for Linux.
|
||
|
|
*
|
||
|
|
* Copyright (c) 2016 Chelsio Communications, Inc. All rights reserved.
|
||
|
|
*
|
||
|
|
* This software is available to you under a choice of one of two
|
||
|
|
* licenses. You may choose to be licensed under the terms of the GNU
|
||
|
|
* General Public License (GPL) Version 2, available from the file
|
||
|
|
* COPYING in the main directory of this source tree, or the
|
||
|
|
* OpenIB.org BSD license below:
|
||
|
|
*
|
||
|
|
* Redistribution and use in source and binary forms, with or
|
||
|
|
* without modification, are permitted provided that the following
|
||
|
|
* conditions are met:
|
||
|
|
*
|
||
|
|
* - Redistributions of source code must retain the above
|
||
|
|
* copyright notice, this list of conditions and the following
|
||
|
|
* disclaimer.
|
||
|
|
*
|
||
|
|
* - 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.
|
||
|
|
*
|
||
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||
|
|
* SOFTWARE.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <linux/module.h>
|
||
|
|
#include <linux/netdevice.h>
|
||
|
|
|
||
|
|
#include "cxgb4.h"
|
||
|
|
#include "sched.h"
|
||
|
|
|
||
|
|
/* Spinlock must be held by caller */
|
||
|
|
static int t4_sched_class_fw_cmd(struct port_info *pi,
|
||
|
|
struct ch_sched_params *p,
|
||
|
|
enum sched_fw_ops op)
|
||
|
|
{
|
||
|
|
struct adapter *adap = pi->adapter;
|
||
|
|
struct sched_table *s = pi->sched_tbl;
|
||
|
|
struct sched_class *e;
|
||
|
|
int err = 0;
|
||
|
|
|
||
|
|
e = &s->tab[p->u.params.class];
|
||
|
|
switch (op) {
|
||
|
|
case SCHED_FW_OP_ADD:
|
||
|
|
err = t4_sched_params(adap, p->type,
|
||
|
|
p->u.params.level, p->u.params.mode,
|
||
|
|
p->u.params.rateunit,
|
||
|
|
p->u.params.ratemode,
|
||
|
|
p->u.params.channel, e->idx,
|
||
|
|
p->u.params.minrate, p->u.params.maxrate,
|
||
|
|
p->u.params.weight, p->u.params.pktsize);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
err = -ENOTSUPP;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Spinlock must be held by caller */
|
||
|
|
static int t4_sched_bind_unbind_op(struct port_info *pi, void *arg,
|
||
|
|
enum sched_bind_type type, bool bind)
|
||
|
|
{
|
||
|
|
struct adapter *adap = pi->adapter;
|
||
|
|
u32 fw_mnem, fw_class, fw_param;
|
||
|
|
unsigned int pf = adap->pf;
|
||
|
|
unsigned int vf = 0;
|
||
|
|
int err = 0;
|
||
|
|
|
||
|
|
switch (type) {
|
||
|
|
case SCHED_QUEUE: {
|
||
|
|
struct sched_queue_entry *qe;
|
||
|
|
|
||
|
|
qe = (struct sched_queue_entry *)arg;
|
||
|
|
|
||
|
|
/* Create a template for the FW_PARAMS_CMD mnemonic and
|
||
|
|
* value (TX Scheduling Class in this case).
|
||
|
|
*/
|
||
|
|
fw_mnem = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DMAQ) |
|
||
|
|
FW_PARAMS_PARAM_X_V(
|
||
|
|
FW_PARAMS_PARAM_DMAQ_EQ_SCHEDCLASS_ETH));
|
||
|
|
fw_class = bind ? qe->param.class : FW_SCHED_CLS_NONE;
|
||
|
|
fw_param = (fw_mnem | FW_PARAMS_PARAM_YZ_V(qe->cntxt_id));
|
||
|
|
|
||
|
|
pf = adap->pf;
|
||
|
|
vf = 0;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
err = -ENOTSUPP;
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
err = t4_set_params(adap, adap->mbox, pf, vf, 1, &fw_param, &fw_class);
|
||
|
|
|
||
|
|
out:
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static struct sched_class *t4_sched_queue_lookup(struct port_info *pi,
|
||
|
|
const unsigned int qid,
|
||
|
|
int *index)
|
||
|
|
{
|
||
|
|
struct sched_table *s = pi->sched_tbl;
|
||
|
|
struct sched_class *e, *end;
|
||
|
|
struct sched_class *found = NULL;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
/* Look for a class with matching bound queue parameters */
|
||
|
|
end = &s->tab[s->sched_size];
|
||
|
|
for (e = &s->tab[0]; e != end; ++e) {
|
||
|
|
struct sched_queue_entry *qe;
|
||
|
|
|
||
|
|
i = 0;
|
||
|
|
if (e->state == SCHED_STATE_UNUSED)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
list_for_each_entry(qe, &e->queue_list, list) {
|
||
|
|
if (qe->cntxt_id == qid) {
|
||
|
|
found = e;
|
||
|
|
if (index)
|
||
|
|
*index = i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (found)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return found;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int t4_sched_queue_unbind(struct port_info *pi, struct ch_sched_queue *p)
|
||
|
|
{
|
||
|
|
struct adapter *adap = pi->adapter;
|
||
|
|
struct sched_class *e;
|
||
|
|
struct sched_queue_entry *qe = NULL;
|
||
|
|
struct sge_eth_txq *txq;
|
||
|
|
unsigned int qid;
|
||
|
|
int index = -1;
|
||
|
|
int err = 0;
|
||
|
|
|
||
|
|
if (p->queue < 0 || p->queue >= pi->nqsets)
|
||
|
|
return -ERANGE;
|
||
|
|
|
||
|
|
txq = &adap->sge.ethtxq[pi->first_qset + p->queue];
|
||
|
|
qid = txq->q.cntxt_id;
|
||
|
|
|
||
|
|
/* Find the existing class that the queue is bound to */
|
||
|
|
e = t4_sched_queue_lookup(pi, qid, &index);
|
||
|
|
if (e && index >= 0) {
|
||
|
|
int i = 0;
|
||
|
|
|
||
|
|
spin_lock(&e->lock);
|
||
|
|
list_for_each_entry(qe, &e->queue_list, list) {
|
||
|
|
if (i == index)
|
||
|
|
break;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
err = t4_sched_bind_unbind_op(pi, (void *)qe, SCHED_QUEUE,
|
||
|
|
false);
|
||
|
|
if (err) {
|
||
|
|
spin_unlock(&e->lock);
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
list_del(&qe->list);
|
||
|
|
t4_free_mem(qe);
|
||
|
|
if (atomic_dec_and_test(&e->refcnt)) {
|
||
|
|
e->state = SCHED_STATE_UNUSED;
|
||
|
|
memset(&e->info, 0, sizeof(e->info));
|
||
|
|
}
|
||
|
|
spin_unlock(&e->lock);
|
||
|
|
}
|
||
|
|
out:
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int t4_sched_queue_bind(struct port_info *pi, struct ch_sched_queue *p)
|
||
|
|
{
|
||
|
|
struct adapter *adap = pi->adapter;
|
||
|
|
struct sched_table *s = pi->sched_tbl;
|
||
|
|
struct sched_class *e;
|
||
|
|
struct sched_queue_entry *qe = NULL;
|
||
|
|
struct sge_eth_txq *txq;
|
||
|
|
unsigned int qid;
|
||
|
|
int err = 0;
|
||
|
|
|
||
|
|
if (p->queue < 0 || p->queue >= pi->nqsets)
|
||
|
|
return -ERANGE;
|
||
|
|
|
||
|
|
qe = t4_alloc_mem(sizeof(struct sched_queue_entry));
|
||
|
|
if (!qe)
|
||
|
|
return -ENOMEM;
|
||
|
|
|
||
|
|
txq = &adap->sge.ethtxq[pi->first_qset + p->queue];
|
||
|
|
qid = txq->q.cntxt_id;
|
||
|
|
|
||
|
|
/* Unbind queue from any existing class */
|
||
|
|
err = t4_sched_queue_unbind(pi, p);
|
||
|
|
if (err) {
|
||
|
|
t4_free_mem(qe);
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Bind queue to specified class */
|
||
|
|
memset(qe, 0, sizeof(*qe));
|
||
|
|
qe->cntxt_id = qid;
|
||
|
|
memcpy(&qe->param, p, sizeof(qe->param));
|
||
|
|
|
||
|
|
e = &s->tab[qe->param.class];
|
||
|
|
spin_lock(&e->lock);
|
||
|
|
err = t4_sched_bind_unbind_op(pi, (void *)qe, SCHED_QUEUE, true);
|
||
|
|
if (err) {
|
||
|
|
t4_free_mem(qe);
|
||
|
|
spin_unlock(&e->lock);
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
|
||
|
|
list_add_tail(&qe->list, &e->queue_list);
|
||
|
|
atomic_inc(&e->refcnt);
|
||
|
|
spin_unlock(&e->lock);
|
||
|
|
out:
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void t4_sched_class_unbind_all(struct port_info *pi,
|
||
|
|
struct sched_class *e,
|
||
|
|
enum sched_bind_type type)
|
||
|
|
{
|
||
|
|
if (!e)
|
||
|
|
return;
|
||
|
|
|
||
|
|
switch (type) {
|
||
|
|
case SCHED_QUEUE: {
|
||
|
|
struct sched_queue_entry *qe;
|
||
|
|
|
||
|
|
list_for_each_entry(qe, &e->queue_list, list)
|
||
|
|
t4_sched_queue_unbind(pi, &qe->param);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static int t4_sched_class_bind_unbind_op(struct port_info *pi, void *arg,
|
||
|
|
enum sched_bind_type type, bool bind)
|
||
|
|
{
|
||
|
|
int err = 0;
|
||
|
|
|
||
|
|
if (!arg)
|
||
|
|
return -EINVAL;
|
||
|
|
|
||
|
|
switch (type) {
|
||
|
|
case SCHED_QUEUE: {
|
||
|
|
struct ch_sched_queue *qe = (struct ch_sched_queue *)arg;
|
||
|
|
|
||
|
|
if (bind)
|
||
|
|
err = t4_sched_queue_bind(pi, qe);
|
||
|
|
else
|
||
|
|
err = t4_sched_queue_unbind(pi, qe);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
err = -ENOTSUPP;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* cxgb4_sched_class_bind - Bind an entity to a scheduling class
|
||
|
|
* @dev: net_device pointer
|
||
|
|
* @arg: Entity opaque data
|
||
|
|
* @type: Entity type (Queue)
|
||
|
|
*
|
||
|
|
* Binds an entity (queue) to a scheduling class. If the entity
|
||
|
|
* is bound to another class, it will be unbound from the other class
|
||
|
|
* and bound to the class specified in @arg.
|
||
|
|
*/
|
||
|
|
int cxgb4_sched_class_bind(struct net_device *dev, void *arg,
|
||
|
|
enum sched_bind_type type)
|
||
|
|
{
|
||
|
|
struct port_info *pi = netdev2pinfo(dev);
|
||
|
|
struct sched_table *s;
|
||
|
|
int err = 0;
|
||
|
|
u8 class_id;
|
||
|
|
|
||
|
|
if (!can_sched(dev))
|
||
|
|
return -ENOTSUPP;
|
||
|
|
|
||
|
|
if (!arg)
|
||
|
|
return -EINVAL;
|
||
|
|
|
||
|
|
switch (type) {
|
||
|
|
case SCHED_QUEUE: {
|
||
|
|
struct ch_sched_queue *qe = (struct ch_sched_queue *)arg;
|
||
|
|
|
||
|
|
class_id = qe->class;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
return -ENOTSUPP;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!valid_class_id(dev, class_id))
|
||
|
|
return -EINVAL;
|
||
|
|
|
||
|
|
if (class_id == SCHED_CLS_NONE)
|
||
|
|
return -ENOTSUPP;
|
||
|
|
|
||
|
|
s = pi->sched_tbl;
|
||
|
|
write_lock(&s->rw_lock);
|
||
|
|
err = t4_sched_class_bind_unbind_op(pi, arg, type, true);
|
||
|
|
write_unlock(&s->rw_lock);
|
||
|
|
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* cxgb4_sched_class_unbind - Unbind an entity from a scheduling class
|
||
|
|
* @dev: net_device pointer
|
||
|
|
* @arg: Entity opaque data
|
||
|
|
* @type: Entity type (Queue)
|
||
|
|
*
|
||
|
|
* Unbinds an entity (queue) from a scheduling class.
|
||
|
|
*/
|
||
|
|
int cxgb4_sched_class_unbind(struct net_device *dev, void *arg,
|
||
|
|
enum sched_bind_type type)
|
||
|
|
{
|
||
|
|
struct port_info *pi = netdev2pinfo(dev);
|
||
|
|
struct sched_table *s;
|
||
|
|
int err = 0;
|
||
|
|
u8 class_id;
|
||
|
|
|
||
|
|
if (!can_sched(dev))
|
||
|
|
return -ENOTSUPP;
|
||
|
|
|
||
|
|
if (!arg)
|
||
|
|
return -EINVAL;
|
||
|
|
|
||
|
|
switch (type) {
|
||
|
|
case SCHED_QUEUE: {
|
||
|
|
struct ch_sched_queue *qe = (struct ch_sched_queue *)arg;
|
||
|
|
|
||
|
|
class_id = qe->class;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
return -ENOTSUPP;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!valid_class_id(dev, class_id))
|
||
|
|
return -EINVAL;
|
||
|
|
|
||
|
|
s = pi->sched_tbl;
|
||
|
|
write_lock(&s->rw_lock);
|
||
|
|
err = t4_sched_class_bind_unbind_op(pi, arg, type, false);
|
||
|
|
write_unlock(&s->rw_lock);
|
||
|
|
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* If @p is NULL, fetch any available unused class */
|
||
|
|
static struct sched_class *t4_sched_class_lookup(struct port_info *pi,
|
||
|
|
const struct ch_sched_params *p)
|
||
|
|
{
|
||
|
|
struct sched_table *s = pi->sched_tbl;
|
||
|
|
struct sched_class *e, *end;
|
||
|
|
struct sched_class *found = NULL;
|
||
|
|
|
||
|
|
if (!p) {
|
||
|
|
/* Get any available unused class */
|
||
|
|
end = &s->tab[s->sched_size];
|
||
|
|
for (e = &s->tab[0]; e != end; ++e) {
|
||
|
|
if (e->state == SCHED_STATE_UNUSED) {
|
||
|
|
found = e;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
/* Look for a class with matching scheduling parameters */
|
||
|
|
struct ch_sched_params info;
|
||
|
|
struct ch_sched_params tp;
|
||
|
|
|
||
|
|
memset(&info, 0, sizeof(info));
|
||
|
|
memset(&tp, 0, sizeof(tp));
|
||
|
|
|
||
|
|
memcpy(&tp, p, sizeof(tp));
|
||
|
|
/* Don't try to match class parameter */
|
||
|
|
tp.u.params.class = SCHED_CLS_NONE;
|
||
|
|
|
||
|
|
end = &s->tab[s->sched_size];
|
||
|
|
for (e = &s->tab[0]; e != end; ++e) {
|
||
|
|
if (e->state == SCHED_STATE_UNUSED)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
memset(&info, 0, sizeof(info));
|
||
|
|
memcpy(&info, &e->info, sizeof(info));
|
||
|
|
/* Don't try to match class parameter */
|
||
|
|
info.u.params.class = SCHED_CLS_NONE;
|
||
|
|
|
||
|
|
if ((info.type == tp.type) &&
|
||
|
|
(!memcmp(&info.u.params, &tp.u.params,
|
||
|
|
sizeof(info.u.params)))) {
|
||
|
|
found = e;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return found;
|
||
|
|
}
|
||
|
|
|
||
|
|
static struct sched_class *t4_sched_class_alloc(struct port_info *pi,
|
||
|
|
struct ch_sched_params *p)
|
||
|
|
{
|
||
|
|
struct sched_table *s = pi->sched_tbl;
|
||
|
|
struct sched_class *e;
|
||
|
|
u8 class_id;
|
||
|
|
int err;
|
||
|
|
|
||
|
|
if (!p)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
class_id = p->u.params.class;
|
||
|
|
|
||
|
|
/* Only accept search for existing class with matching params
|
||
|
|
* or allocation of new class with specified params
|
||
|
|
*/
|
||
|
|
if (class_id != SCHED_CLS_NONE)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
write_lock(&s->rw_lock);
|
||
|
|
/* See if there's an exisiting class with same
|
||
|
|
* requested sched params
|
||
|
|
*/
|
||
|
|
e = t4_sched_class_lookup(pi, p);
|
||
|
|
if (!e) {
|
||
|
|
struct ch_sched_params np;
|
||
|
|
|
||
|
|
/* Fetch any available unused class */
|
||
|
|
e = t4_sched_class_lookup(pi, NULL);
|
||
|
|
if (!e)
|
||
|
|
goto out;
|
||
|
|
|
||
|
|
memset(&np, 0, sizeof(np));
|
||
|
|
memcpy(&np, p, sizeof(np));
|
||
|
|
np.u.params.class = e->idx;
|
||
|
|
|
||
|
|
spin_lock(&e->lock);
|
||
|
|
/* New class */
|
||
|
|
err = t4_sched_class_fw_cmd(pi, &np, SCHED_FW_OP_ADD);
|
||
|
|
if (err) {
|
||
|
|
spin_unlock(&e->lock);
|
||
|
|
e = NULL;
|
||
|
|
goto out;
|
||
|
|
}
|
||
|
|
memcpy(&e->info, &np, sizeof(e->info));
|
||
|
|
atomic_set(&e->refcnt, 0);
|
||
|
|
e->state = SCHED_STATE_ACTIVE;
|
||
|
|
spin_unlock(&e->lock);
|
||
|
|
}
|
||
|
|
|
||
|
|
out:
|
||
|
|
write_unlock(&s->rw_lock);
|
||
|
|
return e;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* cxgb4_sched_class_alloc - allocate a scheduling class
|
||
|
|
* @dev: net_device pointer
|
||
|
|
* @p: new scheduling class to create.
|
||
|
|
*
|
||
|
|
* Returns pointer to the scheduling class created. If @p is NULL, then
|
||
|
|
* it allocates and returns any available unused scheduling class. If a
|
||
|
|
* scheduling class with matching @p is found, then the matching class is
|
||
|
|
* returned.
|
||
|
|
*/
|
||
|
|
struct sched_class *cxgb4_sched_class_alloc(struct net_device *dev,
|
||
|
|
struct ch_sched_params *p)
|
||
|
|
{
|
||
|
|
struct port_info *pi = netdev2pinfo(dev);
|
||
|
|
u8 class_id;
|
||
|
|
|
||
|
|
if (!can_sched(dev))
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
class_id = p->u.params.class;
|
||
|
|
if (!valid_class_id(dev, class_id))
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
return t4_sched_class_alloc(pi, p);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void t4_sched_class_free(struct port_info *pi, struct sched_class *e)
|
||
|
|
{
|
||
|
|
t4_sched_class_unbind_all(pi, e, SCHED_QUEUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
struct sched_table *t4_init_sched(unsigned int sched_size)
|
||
|
|
{
|
||
|
|
struct sched_table *s;
|
||
|
|
unsigned int i;
|
||
|
|
|
||
|
|
s = t4_alloc_mem(sizeof(*s) + sched_size * sizeof(struct sched_class));
|
||
|
|
if (!s)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
s->sched_size = sched_size;
|
||
|
|
rwlock_init(&s->rw_lock);
|
||
|
|
|
||
|
|
for (i = 0; i < s->sched_size; i++) {
|
||
|
|
memset(&s->tab[i], 0, sizeof(struct sched_class));
|
||
|
|
s->tab[i].idx = i;
|
||
|
|
s->tab[i].state = SCHED_STATE_UNUSED;
|
||
|
|
INIT_LIST_HEAD(&s->tab[i].queue_list);
|
||
|
|
spin_lock_init(&s->tab[i].lock);
|
||
|
|
atomic_set(&s->tab[i].refcnt, 0);
|
||
|
|
}
|
||
|
|
return s;
|
||
|
|
}
|
||
|
|
|
||
|
|
void t4_cleanup_sched(struct adapter *adap)
|
||
|
|
{
|
||
|
|
struct sched_table *s;
|
||
|
|
unsigned int i;
|
||
|
|
|
||
|
|
for_each_port(adap, i) {
|
||
|
|
struct port_info *pi = netdev2pinfo(adap->port[i]);
|
||
|
|
|
||
|
|
s = pi->sched_tbl;
|
||
|
|
for (i = 0; i < s->sched_size; i++) {
|
||
|
|
struct sched_class *e;
|
||
|
|
|
||
|
|
write_lock(&s->rw_lock);
|
||
|
|
e = &s->tab[i];
|
||
|
|
if (e->state == SCHED_STATE_ACTIVE)
|
||
|
|
t4_sched_class_free(pi, e);
|
||
|
|
write_unlock(&s->rw_lock);
|
||
|
|
}
|
||
|
|
t4_free_mem(s);
|
||
|
|
}
|
||
|
|
}
|