Page MenuHomeFreeBSD
Differential D13683

textproc/py-m2r/Makefile: Update to 0.1.12
ClosedPublic
Actions

Authored by joneum on Dec 29 2017, 8:57 PM.
Tags
None
Referenced Files
Unknown Object (File)
Sat, Mar 15, 6:23 PM
Unknown Object (File)
Tue, Mar 4, 3:22 AM
Unknown Object (File)
Tue, Mar 4, 3:03 AM
Unknown Object (File)
Jan 26 2025, 1:44 PM
Unknown Object (File)
Jan 21 2025, 3:07 PM
Unknown Object (File)
Jan 19 2025, 1:18 PM
Unknown Object (File)
Jan 4 2025, 5:24 PM
Unknown Object (File)
Dec 23 2024, 6:36 AM
View All 53 Files
Subscribers
mat

Details

Reviewers
tz
rene
tcberner
Commits
rP457545: textproc/py-m2r/Makefile: Update to 0.1.12
Summary

textproc/py-m2r/Makefile: Update to 0.1.12

PR: 224590
Submitted by: John W. O'Brien <john@saltant.com> (maintainer)
Approved by: xxx (mentor)
#Differential Revision: https://reviews.freebsd.org/Dxxxxx

Test Plan

poudriere testport:

10.3-amd64
10.3-i386
10.4-amd64
10.4-i386
11.1-amd64
11.1-i386
12.0-CURRENT r325045 amd64
12.0-CURRENT r325045 i386

Diff Detail

Repository
rP FreeBSD ports repository
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
head/
textproc/
py-m2r/
2 lines
6 lines
files/
10 lines

Diff 37199

View Options

head/textproc/py-m2r/Makefile

Show First 20 Lines • Show All 289 Lines • ▼ Show 20 Linesnvme_ctrlr_disable(struct nvme_controller *ctrlr)
} }
if (rdy == 0) { if (rdy == 0) {
/* EN == 1, wait for RDY == 1 or timeout & fail */ /* EN == 1, wait for RDY == 1 or timeout & fail */
err = nvme_ctrlr_wait_for_ready(ctrlr, 1); err = nvme_ctrlr_wait_for_ready(ctrlr, 1);
if (err != 0) if (err != 0)
return (err); return (err);
} }
cc &= ~NVME_CC_REG_EN_MASK; cc &= ~NVMEM(NVME_CC_REG_EN);
nvme_mmio_write_4(ctrlr, cc, cc); nvme_mmio_write_4(ctrlr, cc, cc);
/* /*
* A few drives have firmware bugs that freeze the drive if we access * A few drives have firmware bugs that freeze the drive if we access
* the mmio too soon after we disable. * the mmio too soon after we disable.
*/ */
if (ctrlr->quirks & QUIRK_DELAY_B4_CHK_RDY) if (ctrlr->quirks & QUIRK_DELAY_B4_CHK_RDY)
pause("nvmeR", MSEC_2_TICKS(B4_CHK_RDY_DELAY_MS)); pause("nvmeR", MSEC_2_TICKS(B4_CHK_RDY_DELAY_MS));
▲ Show 20 Lines • Show All 903 Lines • ▼ Show 20 Linesnvme_pt_done(void *arg, const struct nvme_completion *cpl)
struct nvme_pt_command *pt = arg; struct nvme_pt_command *pt = arg;
struct mtx *mtx = pt->driver_lock; struct mtx *mtx = pt->driver_lock;
uint16_t status; uint16_t status;
bzero(&pt->cpl, sizeof(pt->cpl)); bzero(&pt->cpl, sizeof(pt->cpl));
pt->cpl.cdw0 = cpl->cdw0; pt->cpl.cdw0 = cpl->cdw0;
status = cpl->status; status = cpl->status;
status &= ~NVME_STATUS_P_MASK; status &= ~NVMEM(NVME_STATUS_P);
pt->cpl.status = status; pt->cpl.status = status;
mtx_lock(mtx); mtx_lock(mtx);
pt->driver_lock = NULL; pt->driver_lock = NULL;
wakeup(pt); wakeup(pt);
mtx_unlock(mtx); mtx_unlock(mtx);
} }
▲ Show 20 Lines • Show All 324 Lines • ▼ Show 20 Lines
void void
nvme_ctrlr_shutdown(struct nvme_controller *ctrlr) nvme_ctrlr_shutdown(struct nvme_controller *ctrlr)
{ {
uint32_t cc; uint32_t cc;
uint32_t csts; uint32_t csts;
int timeout; int timeout;
cc = nvme_mmio_read_4(ctrlr, cc); cc = nvme_mmio_read_4(ctrlr, cc);
cc &= ~(NVME_CC_REG_SHN_MASK << NVME_CC_REG_SHN_SHIFT); cc &= ~NVMEM(NVME_CC_REG_SHN);
cc |= NVME_SHN_NORMAL << NVME_CC_REG_SHN_SHIFT; cc |= NVME_SHN_NORMAL << NVME_CC_REG_SHN_SHIFT;
nvme_mmio_write_4(ctrlr, cc, cc); nvme_mmio_write_4(ctrlr, cc, cc);
timeout = ticks + (ctrlr->cdata.rtd3e == 0 ? 5 * hz : timeout = ticks + (ctrlr->cdata.rtd3e == 0 ? 5 * hz :
((uint64_t)ctrlr->cdata.rtd3e * hz + 999999) / 1000000); ((uint64_t)ctrlr->cdata.rtd3e * hz + 999999) / 1000000);
while (1) { while (1) {
csts = nvme_mmio_read_4(ctrlr, csts); csts = nvme_mmio_read_4(ctrlr, csts);
if (csts == NVME_GONE) /* Hot unplug. */ if (csts == NVME_GONE) /* Hot unplug. */
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines
View Options

head/textproc/py-m2r/distinfo

Show First 20 Lines • Show All 289 Lines • ▼ Show 20 Linesnvme_ctrlr_disable(struct nvme_controller *ctrlr)
} }
if (rdy == 0) { if (rdy == 0) {
/* EN == 1, wait for RDY == 1 or timeout & fail */ /* EN == 1, wait for RDY == 1 or timeout & fail */
err = nvme_ctrlr_wait_for_ready(ctrlr, 1); err = nvme_ctrlr_wait_for_ready(ctrlr, 1);
if (err != 0) if (err != 0)
return (err); return (err);
} }
cc &= ~NVME_CC_REG_EN_MASK; cc &= ~NVMEM(NVME_CC_REG_EN);
nvme_mmio_write_4(ctrlr, cc, cc); nvme_mmio_write_4(ctrlr, cc, cc);
/* /*
* A few drives have firmware bugs that freeze the drive if we access * A few drives have firmware bugs that freeze the drive if we access
* the mmio too soon after we disable. * the mmio too soon after we disable.
*/ */
if (ctrlr->quirks & QUIRK_DELAY_B4_CHK_RDY) if (ctrlr->quirks & QUIRK_DELAY_B4_CHK_RDY)
pause("nvmeR", MSEC_2_TICKS(B4_CHK_RDY_DELAY_MS)); pause("nvmeR", MSEC_2_TICKS(B4_CHK_RDY_DELAY_MS));
▲ Show 20 Lines • Show All 903 Lines • ▼ Show 20 Linesnvme_pt_done(void *arg, const struct nvme_completion *cpl)
struct nvme_pt_command *pt = arg; struct nvme_pt_command *pt = arg;
struct mtx *mtx = pt->driver_lock; struct mtx *mtx = pt->driver_lock;
uint16_t status; uint16_t status;
bzero(&pt->cpl, sizeof(pt->cpl)); bzero(&pt->cpl, sizeof(pt->cpl));
pt->cpl.cdw0 = cpl->cdw0; pt->cpl.cdw0 = cpl->cdw0;
status = cpl->status; status = cpl->status;
status &= ~NVME_STATUS_P_MASK; status &= ~NVMEM(NVME_STATUS_P);
pt->cpl.status = status; pt->cpl.status = status;
mtx_lock(mtx); mtx_lock(mtx);
pt->driver_lock = NULL; pt->driver_lock = NULL;
wakeup(pt); wakeup(pt);
mtx_unlock(mtx); mtx_unlock(mtx);
} }
▲ Show 20 Lines • Show All 324 Lines • ▼ Show 20 Lines
void void
nvme_ctrlr_shutdown(struct nvme_controller *ctrlr) nvme_ctrlr_shutdown(struct nvme_controller *ctrlr)
{ {
uint32_t cc; uint32_t cc;
uint32_t csts; uint32_t csts;
int timeout; int timeout;
cc = nvme_mmio_read_4(ctrlr, cc); cc = nvme_mmio_read_4(ctrlr, cc);
cc &= ~(NVME_CC_REG_SHN_MASK << NVME_CC_REG_SHN_SHIFT); cc &= ~NVMEM(NVME_CC_REG_SHN);
cc |= NVME_SHN_NORMAL << NVME_CC_REG_SHN_SHIFT; cc |= NVME_SHN_NORMAL << NVME_CC_REG_SHN_SHIFT;
nvme_mmio_write_4(ctrlr, cc, cc); nvme_mmio_write_4(ctrlr, cc, cc);
timeout = ticks + (ctrlr->cdata.rtd3e == 0 ? 5 * hz : timeout = ticks + (ctrlr->cdata.rtd3e == 0 ? 5 * hz :
((uint64_t)ctrlr->cdata.rtd3e * hz + 999999) / 1000000); ((uint64_t)ctrlr->cdata.rtd3e * hz + 999999) / 1000000);
while (1) { while (1) {
csts = nvme_mmio_read_4(ctrlr, csts); csts = nvme_mmio_read_4(ctrlr, csts);
if (csts == NVME_GONE) /* Hot unplug. */ if (csts == NVME_GONE) /* Hot unplug. */
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines
View Options

head/textproc/py-m2r/files/patch-setup.py

Show First 20 Lines • Show All 289 Lines • ▼ Show 20 Linesnvme_ctrlr_disable(struct nvme_controller *ctrlr)
} }
if (rdy == 0) { if (rdy == 0) {
/* EN == 1, wait for RDY == 1 or timeout & fail */ /* EN == 1, wait for RDY == 1 or timeout & fail */
err = nvme_ctrlr_wait_for_ready(ctrlr, 1); err = nvme_ctrlr_wait_for_ready(ctrlr, 1);
if (err != 0) if (err != 0)
return (err); return (err);
} }
cc &= ~NVME_CC_REG_EN_MASK; cc &= ~NVMEM(NVME_CC_REG_EN);
nvme_mmio_write_4(ctrlr, cc, cc); nvme_mmio_write_4(ctrlr, cc, cc);
/* /*
* A few drives have firmware bugs that freeze the drive if we access * A few drives have firmware bugs that freeze the drive if we access
* the mmio too soon after we disable. * the mmio too soon after we disable.
*/ */
if (ctrlr->quirks & QUIRK_DELAY_B4_CHK_RDY) if (ctrlr->quirks & QUIRK_DELAY_B4_CHK_RDY)
pause("nvmeR", MSEC_2_TICKS(B4_CHK_RDY_DELAY_MS)); pause("nvmeR", MSEC_2_TICKS(B4_CHK_RDY_DELAY_MS));
▲ Show 20 Lines • Show All 903 Lines • ▼ Show 20 Linesnvme_pt_done(void *arg, const struct nvme_completion *cpl)
struct nvme_pt_command *pt = arg; struct nvme_pt_command *pt = arg;
struct mtx *mtx = pt->driver_lock; struct mtx *mtx = pt->driver_lock;
uint16_t status; uint16_t status;
bzero(&pt->cpl, sizeof(pt->cpl)); bzero(&pt->cpl, sizeof(pt->cpl));
pt->cpl.cdw0 = cpl->cdw0; pt->cpl.cdw0 = cpl->cdw0;
status = cpl->status; status = cpl->status;
status &= ~NVME_STATUS_P_MASK; status &= ~NVMEM(NVME_STATUS_P);
pt->cpl.status = status; pt->cpl.status = status;
mtx_lock(mtx); mtx_lock(mtx);
pt->driver_lock = NULL; pt->driver_lock = NULL;
wakeup(pt); wakeup(pt);
mtx_unlock(mtx); mtx_unlock(mtx);
} }
▲ Show 20 Lines • Show All 324 Lines • ▼ Show 20 Lines
void void
nvme_ctrlr_shutdown(struct nvme_controller *ctrlr) nvme_ctrlr_shutdown(struct nvme_controller *ctrlr)
{ {
uint32_t cc; uint32_t cc;
uint32_t csts; uint32_t csts;
int timeout; int timeout;
cc = nvme_mmio_read_4(ctrlr, cc); cc = nvme_mmio_read_4(ctrlr, cc);
cc &= ~(NVME_CC_REG_SHN_MASK << NVME_CC_REG_SHN_SHIFT); cc &= ~NVMEM(NVME_CC_REG_SHN);
cc |= NVME_SHN_NORMAL << NVME_CC_REG_SHN_SHIFT; cc |= NVME_SHN_NORMAL << NVME_CC_REG_SHN_SHIFT;
nvme_mmio_write_4(ctrlr, cc, cc); nvme_mmio_write_4(ctrlr, cc, cc);
timeout = ticks + (ctrlr->cdata.rtd3e == 0 ? 5 * hz : timeout = ticks + (ctrlr->cdata.rtd3e == 0 ? 5 * hz :
((uint64_t)ctrlr->cdata.rtd3e * hz + 999999) / 1000000); ((uint64_t)ctrlr->cdata.rtd3e * hz + 999999) / 1000000);
while (1) { while (1) {
csts = nvme_mmio_read_4(ctrlr, csts); csts = nvme_mmio_read_4(ctrlr, csts);
if (csts == NVME_GONE) /* Hot unplug. */ if (csts == NVME_GONE) /* Hot unplug. */
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines