Page MenuHomeFreeBSD
Differential D9620

Altera FIFO (SoftDMA®) driver
ClosedPublic
Actions

Authored by br on Feb 15 2017, 4:20 PM.
Tags
None
Referenced Files
Unknown Object (File)
Sat, Mar 22, 12:39 AM
Unknown Object (File)
Sun, Mar 16, 11:44 PM
Unknown Object (File)
Fri, Mar 14, 5:55 AM
Unknown Object (File)
Sun, Mar 9, 4:20 AM
Unknown Object (File)
Fri, Feb 28, 5:09 PM
Unknown Object (File)
Wed, Feb 26, 6:00 AM
Unknown Object (File)
Sat, Feb 22, 12:00 PM
Unknown Object (File)
Fri, Feb 21, 11:02 PM
View All Files
Subscribers
imp

Details

Reviewers
None
Commits
rS332472: Add driver for Altera SoftDMA® device.
Test Plan

tested with atse(4)

Diff Detail

Lint
Lint Skipped
Unit
Tests Skipped

Event Timeline

br updated this revision to Diff 25231.Feb 15 2017, 4:20 PM
br retitled this revision from to Altera FIFO (SoftDMA®) driver.
br updated this object.
br edited the test plan for this revision. (Show Details)
br added a parent revision: D9617: xDMA enqueuing (scatter-gather) support.
br updated this revision to Diff 25423.Feb 20 2017, 3:04 PM
br updated this revision to Diff 25431.Feb 20 2017, 4:25 PM
br updated this revision to Diff 25468.Feb 21 2017, 2:16 PM

move descriptors allocation out of xDMA

br updated this revision to Diff 25485.Feb 21 2017, 6:11 PM

add chan_capacity method

br updated this revision to Diff 25528.Feb 22 2017, 2:17 PM
br updated this revision to Diff 26826.Mar 30 2017, 2:22 PM
br updated this revision to Diff 26968.Apr 3 2017, 2:15 PM
This revision was not accepted when it landed; it landed in state Needs Review.Apr 13 2018, 2:18 PM
Closed by commit rS332472: Add driver for Altera SoftDMA® device. (authored by br). · Explain Why
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: imp. · View Herald TranscriptApr 13 2018, 2:18 PM

Revision Contents
Changeset List

PathSize
sys/
dev/
altera/
softdma/
96 lines
842 lines

Diff 25468

View Options

sys/dev/altera/softdma/a_api.h

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Linesstatic const char *blessed[] = {
"so_rcv_sx", "so_rcv_sx",
NULL NULL
}; };
static int slptime_threshold = 1800; static int slptime_threshold = 1800;
static int blktime_threshold = 900; static int blktime_threshold = 900;
static int sleepfreq = 3; static int sleepfreq = 3;
static void static void
deadlkres(void) deadlres_td_on_lock(struct proc *p, struct thread *td, int blkticks)
{ {
struct proc *p; int tticks;
struct thread *td;
void *wchan;
int blkticks, i, slpticks, slptype, tryl, tticks;
tryl = 0; sx_assert(&allproc_lock, SX_LOCKED);
for (;;) { PROC_LOCK_ASSERT(p, MA_OWNED);
blkticks = blktime_threshold * hz; THREAD_LOCK_ASSERT(td, MA_OWNED);
slpticks = slptime_threshold * hz;
/* /*
* Avoid to sleep on the sx_lock in order to avoid a possible * The thread should be blocked on a turnstile, simply check
* priority inversion problem leading to starvation. * if the turnstile channel is in good state.
* If the lock can't be held after 100 tries, panic.
*/ */
if (!sx_try_slock(&allproc_lock)) {
if (tryl > 100)
panic("%s: possible deadlock detected on allproc_lock\n",
__func__);
tryl++;
pause("allproc", sleepfreq * hz);
continue;
}
tryl = 0;
FOREACH_PROC_IN_SYSTEM(p) {
PROC_LOCK(p);
if (p->p_state == PRS_NEW) {
PROC_UNLOCK(p);
continue;
}
FOREACH_THREAD_IN_PROC(p, td) {
thread_lock(td);
if (TD_ON_LOCK(td)) {
/*
* The thread should be blocked on a
* turnstile, simply check if the
* turnstile channel is in good state.
*/
MPASS(td->td_blocked != NULL); MPASS(td->td_blocked != NULL);
tticks = ticks - td->td_blktick; tticks = ticks - td->td_blktick;
thread_unlock(td); if (tticks > blkticks)
if (tticks > blkticks) {
/* /*
* Accordingly with provided * Accordingly with provided thresholds, this thread is stuck
* thresholds, this thread is * for too long on a turnstile.
* stuck for too long on a
* turnstile.
*/ */
PROC_UNLOCK(p); panic("%s: possible deadlock detected for %p, "
sx_sunlock(&allproc_lock); "blocked for %d ticks\n", __func__, td, tticks);
panic("%s: possible deadlock detected for %p, blocked for %d ticks\n",
__func__, td, tticks);
} }
} else if (TD_IS_SLEEPING(td) &&
TD_ON_SLEEPQ(td)) {
static void
deadlres_td_sleep_q(struct proc *p, struct thread *td, int slpticks)
{
void *wchan;
int i, slptype, tticks;
sx_assert(&allproc_lock, SX_LOCKED);
PROC_LOCK_ASSERT(p, MA_OWNED);
THREAD_LOCK_ASSERT(td, MA_OWNED);
/* /*
* Check if the thread is sleeping on a * Check if the thread is sleeping on a lock, otherwise skip the check.
* lock, otherwise skip the check. * Drop the thread lock in order to avoid a LOR with the sleepqueue
* Drop the thread lock in order to
* avoid a LOR with the sleepqueue
* spinlock. * spinlock.
*/ */
wchan = td->td_wchan; wchan = td->td_wchan;
tticks = ticks - td->td_slptick; tticks = ticks - td->td_slptick;
thread_unlock(td);
slptype = sleepq_type(wchan); slptype = sleepq_type(wchan);
if ((slptype == SLEEPQ_SX || if ((slptype == SLEEPQ_SX || slptype == SLEEPQ_LK) &&
slptype == SLEEPQ_LK) &&
tticks > slpticks) { tticks > slpticks) {
/* /*
* Accordingly with provided * Accordingly with provided thresholds, this thread is stuck
* thresholds, this thread is * for too long on a sleepqueue.
* stuck for too long on a * However, being on a sleepqueue, we might still check for the
* sleepqueue. * blessed list.
* However, being on a
* sleepqueue, we might still
* check for the blessed
* list.
*/ */
tryl = 0; for (i = 0; blessed[i] != NULL; i++)
for (i = 0; blessed[i] != NULL; if (!strcmp(blessed[i], td->td_wmesg))
i++) { return;
if (!strcmp(blessed[i],
td->td_wmesg)) { panic("%s: possible deadlock detected for %p, "
tryl = 1; "blocked for %d ticks\n", __func__, td, tticks);
break;
} }
} }
if (tryl != 0) {
static void
deadlkres(void)
{
struct proc *p;
struct thread *td;
int blkticks, slpticks, tryl;
tryl = 0; tryl = 0;
for (;;) {
blkticks = blktime_threshold * hz;
slpticks = slptime_threshold * hz;
/*
* Avoid to sleep on the sx_lock in order to avoid a
* possible priority inversion problem leading to
* starvation.
* If the lock can't be held after 100 tries, panic.
*/
if (!sx_try_slock(&allproc_lock)) {
if (tryl > 100)
panic("%s: possible deadlock detected "
"on allproc_lock\n", __func__);
tryl++;
pause("allproc", sleepfreq * hz);
continue; continue;
} }
tryl = 0;
FOREACH_PROC_IN_SYSTEM(p) {
PROC_LOCK(p);
if (p->p_state == PRS_NEW) {
PROC_UNLOCK(p); PROC_UNLOCK(p);
sx_sunlock(&allproc_lock); continue;
panic("%s: possible deadlock detected for %p, blocked for %d ticks\n",
__func__, td, tticks);
} }
} else FOREACH_THREAD_IN_PROC(p, td) {
thread_lock(td);
if (TD_ON_LOCK(td))
deadlres_td_on_lock(p, td,
blkticks);
else if (TD_IS_SLEEPING(td) &&
TD_ON_SLEEPQ(td))
deadlres_td_sleep_q(p, td,
slpticks);
thread_unlock(td); thread_unlock(td);
} }
PROC_UNLOCK(p); PROC_UNLOCK(p);
} }
sx_sunlock(&allproc_lock); sx_sunlock(&allproc_lock);
/* Sleep for sleepfreq seconds. */ /* Sleep for sleepfreq seconds. */
pause("-", sleepfreq * hz); pause("-", sleepfreq * hz);
} }
▲ Show 20 Lines • Show All 599 Lines • Show Last 20 Lines
View Options

sys/dev/altera/softdma/softdma.c

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Linesstatic const char *blessed[] = {
"so_rcv_sx", "so_rcv_sx",
NULL NULL
}; };
static int slptime_threshold = 1800; static int slptime_threshold = 1800;
static int blktime_threshold = 900; static int blktime_threshold = 900;
static int sleepfreq = 3; static int sleepfreq = 3;
static void static void
deadlkres(void) deadlres_td_on_lock(struct proc *p, struct thread *td, int blkticks)
{ {
struct proc *p; int tticks;
struct thread *td;
void *wchan;
int blkticks, i, slpticks, slptype, tryl, tticks;
tryl = 0; sx_assert(&allproc_lock, SX_LOCKED);
for (;;) { PROC_LOCK_ASSERT(p, MA_OWNED);
blkticks = blktime_threshold * hz; THREAD_LOCK_ASSERT(td, MA_OWNED);
slpticks = slptime_threshold * hz;
/* /*
* Avoid to sleep on the sx_lock in order to avoid a possible * The thread should be blocked on a turnstile, simply check
* priority inversion problem leading to starvation. * if the turnstile channel is in good state.
* If the lock can't be held after 100 tries, panic.
*/ */
if (!sx_try_slock(&allproc_lock)) {
if (tryl > 100)
panic("%s: possible deadlock detected on allproc_lock\n",
__func__);
tryl++;
pause("allproc", sleepfreq * hz);
continue;
}
tryl = 0;
FOREACH_PROC_IN_SYSTEM(p) {
PROC_LOCK(p);
if (p->p_state == PRS_NEW) {
PROC_UNLOCK(p);
continue;
}
FOREACH_THREAD_IN_PROC(p, td) {
thread_lock(td);
if (TD_ON_LOCK(td)) {
/*
* The thread should be blocked on a
* turnstile, simply check if the
* turnstile channel is in good state.
*/
MPASS(td->td_blocked != NULL); MPASS(td->td_blocked != NULL);
tticks = ticks - td->td_blktick; tticks = ticks - td->td_blktick;
thread_unlock(td); if (tticks > blkticks)
if (tticks > blkticks) {
/* /*
* Accordingly with provided * Accordingly with provided thresholds, this thread is stuck
* thresholds, this thread is * for too long on a turnstile.
* stuck for too long on a
* turnstile.
*/ */
PROC_UNLOCK(p); panic("%s: possible deadlock detected for %p, "
sx_sunlock(&allproc_lock); "blocked for %d ticks\n", __func__, td, tticks);
panic("%s: possible deadlock detected for %p, blocked for %d ticks\n",
__func__, td, tticks);
} }
} else if (TD_IS_SLEEPING(td) &&
TD_ON_SLEEPQ(td)) {
static void
deadlres_td_sleep_q(struct proc *p, struct thread *td, int slpticks)
{
void *wchan;
int i, slptype, tticks;
sx_assert(&allproc_lock, SX_LOCKED);
PROC_LOCK_ASSERT(p, MA_OWNED);
THREAD_LOCK_ASSERT(td, MA_OWNED);
/* /*
* Check if the thread is sleeping on a * Check if the thread is sleeping on a lock, otherwise skip the check.
* lock, otherwise skip the check. * Drop the thread lock in order to avoid a LOR with the sleepqueue
* Drop the thread lock in order to
* avoid a LOR with the sleepqueue
* spinlock. * spinlock.
*/ */
wchan = td->td_wchan; wchan = td->td_wchan;
tticks = ticks - td->td_slptick; tticks = ticks - td->td_slptick;
thread_unlock(td);
slptype = sleepq_type(wchan); slptype = sleepq_type(wchan);
if ((slptype == SLEEPQ_SX || if ((slptype == SLEEPQ_SX || slptype == SLEEPQ_LK) &&
slptype == SLEEPQ_LK) &&
tticks > slpticks) { tticks > slpticks) {
/* /*
* Accordingly with provided * Accordingly with provided thresholds, this thread is stuck
* thresholds, this thread is * for too long on a sleepqueue.
* stuck for too long on a * However, being on a sleepqueue, we might still check for the
* sleepqueue. * blessed list.
* However, being on a
* sleepqueue, we might still
* check for the blessed
* list.
*/ */
tryl = 0; for (i = 0; blessed[i] != NULL; i++)
for (i = 0; blessed[i] != NULL; if (!strcmp(blessed[i], td->td_wmesg))
i++) { return;
if (!strcmp(blessed[i],
td->td_wmesg)) { panic("%s: possible deadlock detected for %p, "
tryl = 1; "blocked for %d ticks\n", __func__, td, tticks);
break;
} }
} }
if (tryl != 0) {
static void
deadlkres(void)
{
struct proc *p;
struct thread *td;
int blkticks, slpticks, tryl;
tryl = 0; tryl = 0;
for (;;) {
blkticks = blktime_threshold * hz;
slpticks = slptime_threshold * hz;
/*
* Avoid to sleep on the sx_lock in order to avoid a
* possible priority inversion problem leading to
* starvation.
* If the lock can't be held after 100 tries, panic.
*/
if (!sx_try_slock(&allproc_lock)) {
if (tryl > 100)
panic("%s: possible deadlock detected "
"on allproc_lock\n", __func__);
tryl++;
pause("allproc", sleepfreq * hz);
continue; continue;
} }
tryl = 0;
FOREACH_PROC_IN_SYSTEM(p) {
PROC_LOCK(p);
if (p->p_state == PRS_NEW) {
PROC_UNLOCK(p); PROC_UNLOCK(p);
sx_sunlock(&allproc_lock); continue;
panic("%s: possible deadlock detected for %p, blocked for %d ticks\n",
__func__, td, tticks);
} }
} else FOREACH_THREAD_IN_PROC(p, td) {
thread_lock(td);
if (TD_ON_LOCK(td))
deadlres_td_on_lock(p, td,
blkticks);
else if (TD_IS_SLEEPING(td) &&
TD_ON_SLEEPQ(td))
deadlres_td_sleep_q(p, td,
slpticks);
thread_unlock(td); thread_unlock(td);
} }
PROC_UNLOCK(p); PROC_UNLOCK(p);
} }
sx_sunlock(&allproc_lock); sx_sunlock(&allproc_lock);
/* Sleep for sleepfreq seconds. */ /* Sleep for sleepfreq seconds. */
pause("-", sleepfreq * hz); pause("-", sleepfreq * hz);
} }
▲ Show 20 Lines • Show All 599 Lines • Show Last 20 Lines