retronetworking
/
dahdi-linux
mirror of https://gerrit.osmocom.org/dahdi-linux
13
0
Fork 0
Code Issues Projects Releases Wiki Activity

wct4xxp: Remove unnused ENABLE_WORKQUEUE code paths 

ENABLE_WORKQUEUE was only defined for kernels that were older than the
currently supported kernels. Instead of forward porting support for
workqueues in the wct4xxp driver, I think it better just to remove
support for them since they are not longer used.

Signed-off-by: Shaun Ruffell <sruffell@sruffell.net>
This commit is contained in:
Shaun Ruffell 2019-01-11 05:04:45 +00:00
parent 4af6f69fff
commit 4f3a724036
1 changed files with 0 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

162
drivers/dahdi/wct4xxp/base.c
View File

@ -48,13 +48,6 @@
#include "wct4xxp.h" #include "wct4xxp.h"
#include "vpm450m.h" #include "vpm450m.h"
/*
* Work queues can significantly improve performance and scalability
* on multi-processor machines, but requires bypassing some kernel
* API's, so it's not guaranteed to be compatible with all kernels.
*/
/* #define ENABLE_WORKQUEUES */
/* Support first generation cards? */ /* Support first generation cards? */
#define SUPPORT_GEN1 #define SUPPORT_GEN1
@ -76,88 +69,6 @@
/* Maximum latency to be used with Gen 5 */ /* Maximum latency to be used with Gen 5 */
#define GEN5_MAX_LATENCY 127 #define GEN5_MAX_LATENCY 127
#ifdef ENABLE_WORKQUEUES
#include <linux/cpu.h>
/* XXX UGLY!!!! XXX We have to access the direct structures of the workqueue which
are only defined within workqueue.c because they don't give us a routine to allow us
to nail a work to a particular thread of the CPU. Nailing to threads gives us substantially
higher scalability in multi-CPU environments though! */
/*
* The per-CPU workqueue (if single thread, we always use cpu 0's).
*
* The sequence counters are for flush_scheduled_work(). It wants to wait
* until until all currently-scheduled works are completed, but it doesn't
* want to be livelocked by new, incoming ones. So it waits until
* remove_sequence is >= the insert_sequence which pertained when
* flush_scheduled_work() was called.
*/
struct cpu_workqueue_struct {
spinlock_t lock;
long remove_sequence; /* Least-recently added (next to run) */
long insert_sequence; /* Next to add */
struct list_head worklist;
wait_queue_head_t more_work;
wait_queue_head_t work_done;
struct workqueue_struct *wq;
task_t *thread;
int run_depth; /* Detect run_workqueue() recursion depth */
} ____cacheline_aligned;
/*
* The externally visible workqueue abstraction is an array of
* per-CPU workqueues:
*/
struct workqueue_struct {
/* TODO: Find out exactly where the API changed */
struct cpu_workqueue_struct *cpu_wq;
const char *name;
struct list_head list; /* Empty if single thread */
};
/* Preempt must be disabled. */
static void __t4_queue_work(struct cpu_workqueue_struct *cwq,
struct work_struct *work)
{
unsigned long flags;
spin_lock_irqsave(&cwq->lock, flags);
work->wq_data = cwq;
list_add_tail(&work->entry, &cwq->worklist);
cwq->insert_sequence++;
wake_up(&cwq->more_work);
spin_unlock_irqrestore(&cwq->lock, flags);
}
/*
* Queue work on a workqueue. Return non-zero if it was successfully
* added.
*
* We queue the work to the CPU it was submitted, but there is no
* guarantee that it will be processed by that CPU.
*/
static inline int t4_queue_work(struct workqueue_struct *wq, struct work_struct *work, int cpu)
{
int ret = 0;
get_cpu();
if (!test_and_set_bit(0, &work->pending)) {
BUG_ON(!list_empty(&work->entry));
__t4_queue_work(wq->cpu_wq + cpu, work);
ret = 1;
}
put_cpu();
return ret;
}
#endif
/* /*
* Define CONFIG_FORCE_EXTENDED_RESET to allow the qfalc framer extra time * Define CONFIG_FORCE_EXTENDED_RESET to allow the qfalc framer extra time
* to reset itself upon hardware initialization. This exits for rare * to reset itself upon hardware initialization. This exits for rare
@ -321,9 +232,6 @@ struct t4_span {
unsigned long dtmfmask; unsigned long dtmfmask;
unsigned long dtmfmutemask; unsigned long dtmfmutemask;
#endif #endif
#ifdef ENABLE_WORKQUEUES
struct work_struct swork;
#endif
struct dahdi_chan *chans[32]; /* Individual channels */ struct dahdi_chan *chans[32]; /* Individual channels */
struct dahdi_echocan_state *ec[32]; /* Echocan state for each channel */ struct dahdi_echocan_state *ec[32]; /* Echocan state for each channel */
}; };
@ -356,10 +264,6 @@ struct t4 {
int spansstarted; /* number of spans started */ int spansstarted; /* number of spans started */
u32 *writechunk; /* Double-word aligned write memory */ u32 *writechunk; /* Double-word aligned write memory */
u32 *readchunk; /* Double-word aligned read memory */ u32 *readchunk; /* Double-word aligned read memory */
#ifdef ENABLE_WORKQUEUES
atomic_t worklist;
struct workqueue_struct *workq;
#endif
int last0; /* for detecting double-missed IRQ */ int last0; /* for detecting double-missed IRQ */
/* DMA related fields */ /* DMA related fields */
@ -3192,19 +3096,6 @@ static inline void __transmit_span(struct t4_span *ts)
_dahdi_transmit(&ts->span); _dahdi_transmit(&ts->span);
} }
#ifdef ENABLE_WORKQUEUES
static void workq_handlespan(void *data)
{
struct t4_span *ts = data;
struct t4 *wc = ts->owner;
__receive_span(ts);
__transmit_span(ts);
atomic_dec(&wc->worklist);
if (!atomic_read(&wc->worklist))
t4_pci_out(wc, WC_INTR, 0);
}
#else
static void t4_prep_gen2(struct t4 *wc) static void t4_prep_gen2(struct t4 *wc)
{ {
int x; int x;
@ -3216,7 +3107,6 @@ static void t4_prep_gen2(struct t4 *wc)
} }
} }
#endif
#ifdef SUPPORT_GEN1 #ifdef SUPPORT_GEN1
static void t4_transmitprep(struct t4 *wc, int irq) static void t4_transmitprep(struct t4 *wc, int irq)
{ {
@ -4094,10 +3984,6 @@ static irqreturn_t _t4_interrupt_gen2(int irq, void *dev_id)
return IRQ_NONE; return IRQ_NONE;
} }
#ifdef ENABLE_WORKQUEUES
__t4_pci_out(wc, WC_INTR, status & 0x00000008);
#endif
if (unlikely(!wc->spansstarted)) { if (unlikely(!wc->spansstarted)) {
dev_info(&wc->dev->dev, "Not prepped yet!\n"); dev_info(&wc->dev->dev, "Not prepped yet!\n");
return IRQ_NONE; return IRQ_NONE;
@ -4160,28 +4046,6 @@ static irqreturn_t _t4_interrupt_gen2(int irq, void *dev_id)
#endif #endif
if (likely(status & 0x2)) { if (likely(status & 0x2)) {
#ifdef ENABLE_WORKQUEUES
int cpus = num_online_cpus();
atomic_set(&wc->worklist, wc->numspans);
if (wc->tspans[0]->span.flags & DAHDI_FLAG_RUNNING)
t4_queue_work(wc->workq, &wc->tspans[0]->swork, 0);
else
atomic_dec(&wc->worklist);
if (wc->tspans[1]->span.flags & DAHDI_FLAG_RUNNING)
t4_queue_work(wc->workq, &wc->tspans[1]->swork, 1 % cpus);
else
atomic_dec(&wc->worklist);
if (wc->numspans == 4) {
if (wc->tspans[2]->span.flags & DAHDI_FLAG_RUNNING)
t4_queue_work(wc->workq, &wc->tspans[2]->swork, 2 % cpus);
else
atomic_dec(&wc->worklist);
if (wc->tspans[3]->span.flags & DAHDI_FLAG_RUNNING)
t4_queue_work(wc->workq, &wc->tspans[3]->swork, 3 % cpus);
else
atomic_dec(&wc->worklist);
}
#else
unsigned int reg5 = __t4_pci_in(wc, 5); unsigned int reg5 = __t4_pci_in(wc, 5);
#ifdef DEBUG #ifdef DEBUG
@ -4201,7 +4065,6 @@ static irqreturn_t _t4_interrupt_gen2(int irq, void *dev_id)
t4_prep_gen2(wc); t4_prep_gen2(wc);
} }
#endif
t4_do_counters(wc); t4_do_counters(wc);
spin_lock(&wc->reglock); spin_lock(&wc->reglock);
__handle_leds(wc); __handle_leds(wc);
@ -4256,10 +4119,7 @@ out:
if (unlikely(test_bit(T4_CHANGE_LATENCY, &wc->checkflag) || test_bit(T4_CHECK_VPM, &wc->checkflag))) if (unlikely(test_bit(T4_CHANGE_LATENCY, &wc->checkflag) || test_bit(T4_CHECK_VPM, &wc->checkflag)))
schedule_work(&wc->bh_work); schedule_work(&wc->bh_work);
#ifndef ENABLE_WORKQUEUES
__t4_pci_out(wc, WC_INTR, 0); __t4_pci_out(wc, WC_INTR, 0);
#endif
return IRQ_RETVAL(1); return IRQ_RETVAL(1);
} }
@ -4925,9 +4785,6 @@ __t4_hardware_init_1(struct t4 *wc, unsigned int cardflags, bool first_time)
if (debug) { if (debug) {
dev_info(&wc->dev->dev, "Burst Mode: %s\n", dev_info(&wc->dev->dev, "Burst Mode: %s\n",
(!(cardflags & FLAG_BURST) && noburst) ? "Off" : "On"); (!(cardflags & FLAG_BURST) && noburst) ? "Off" : "On");
#ifdef ENABLE_WORKQUEUES
dev_info(&wc->dev->dev, "Work Queues: Enabled\n");
#endif
} }
/* Check the field updatable firmware for the wcte820 */ /* Check the field updatable firmware for the wcte820 */
@ -5286,15 +5143,6 @@ t4_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
wc->num = x; wc->num = x;
cards[x] = wc; cards[x] = wc;
#ifdef ENABLE_WORKQUEUES
if (wc->devtype->flags & FLAG_2NDGEN) {
char tmp[20];
sprintf(tmp, "te%dxxp[%d]", wc->numspans, wc->num);
wc->workq = create_workqueue(tmp);
}
#endif
/* Allocate pieces we need here */ /* Allocate pieces we need here */
for (x = 0; x < ports_on_framer(wc); x++) { for (x = 0; x < ports_on_framer(wc); x++) {
struct t4_span *ts; struct t4_span *ts;
@ -5307,9 +5155,6 @@ t4_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
} }
wc->tspans[x] = ts; wc->tspans[x] = ts;
#ifdef ENABLE_WORKQUEUES
INIT_WORK(&ts->swork, workq_handlespan, ts);
#endif
ts->spanflags |= wc->devtype->flags; ts->spanflags |= wc->devtype->flags;
linemode = (wc->t1e1 & (1 << x)) ? E1 : ((j1mode) ? J1 : T1); linemode = (wc->t1e1 & (1 << x)) ? E1 : ((j1mode) ? J1 : T1);
t4_alloc_channels(wc, wc->tspans[x], linemode); t4_alloc_channels(wc, wc->tspans[x], linemode);
@ -5449,13 +5294,6 @@ static void _t4_remove_one(struct t4 *wc)
if (!(wc->tspans[0]->spanflags & FLAG_2NDGEN)) if (!(wc->tspans[0]->spanflags & FLAG_2NDGEN))
basesize = basesize * 2; basesize = basesize * 2;
#ifdef ENABLE_WORKQUEUES
if (wc->workq) {
flush_workqueue(wc->workq);
destroy_workqueue(wc->workq);
}
#endif
free_irq(wc->dev->irq, wc); free_irq(wc->dev->irq, wc);
if (wc->membase) if (wc->membase)