Page MenuHomeFreeBSD
Differential D2476

unbreak security/ruby-camellia
ClosedPublic
Actions

Authored by mmoll on May 7 2015, 10:04 PM.
Tags
None
Referenced Files
Unknown Object (File)
Feb 4 2025, 8:44 AM
Unknown Object (File)
Jan 10 2025, 5:32 PM
Unknown Object (File)
Dec 28 2024, 9:31 PM
Unknown Object (File)
Dec 23 2024, 1:39 PM
Unknown Object (File)
Dec 23 2024, 12:18 PM
Unknown Object (File)
Oct 26 2024, 10:36 PM
Unknown Object (File)
Oct 26 2024, 10:35 PM
Unknown Object (File)
Oct 26 2024, 10:22 PM
View All 52 Files
Subscribers
None

Details

Reviewers
swills
mat
Summary

Proposed commit message:

security/ruby-camellia: unbreak build for ruby 2.1+

PR:		199267
Submitted by:	Yoshisato Yanagisawa <osho@pcc-software.org> (maintainer)
Approved by:	swills (mentor), mat (mentor)
Test Plan

http://space.kvedulv.de/FreeBSD/ruby21-camellia-1.2.log - furthermore this also was build tested on 8.4-RELEASE and 9.3-RELEASE

Diff Detail

Repository
rP FreeBSD ports repository
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

mmoll updated this revision to Diff 5265.May 7 2015, 10:04 PM
mmoll retitled this revision from to unbreak security/ruby-camellia.
mmoll updated this object.
mmoll edited the test plan for this revision. (Show Details)
mmoll added reviewers: swills, mat.
swills accepted this revision.May 8 2015, 12:19 AM
swills edited edge metadata.

Approved

This revision is now accepted and ready to land.May 8 2015, 12:19 AM
mmoll closed this revision.May 8 2015, 9:23 AM

commited in rP385743

Revision Contents
Changeset List

PathSize
security/
ruby-camellia/
11 lines
31 lines
11 lines
2 lines

Diff 5265

View Options

security/ruby-camellia/Makefile

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Linesrk8xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
*udelay = 0; *udelay = 0;
return (0); return (0);
} }
static void static void
rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv) rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv)
{ {
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
int change;
change =
((sc->def->voltage_min2 - sc->def->voltage_min) /
sc->def->voltage_step);
if (val > change) {
if (val < sc->def->voltage_nstep) {
*uv = sc->def->voltage_min2 +
(val - change) *
sc->def->voltage_step2;
} else
*uv = sc->def->voltage_max2;
return;
}
}
if (val < sc->def->voltage_nstep) if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step; *uv = sc->def->voltage_min + val * sc->def->voltage_step;
else else
*uv = sc->def->voltage_max;
} else {
if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step;
else
*uv = sc->def->voltage_min + *uv = sc->def->voltage_min +
(sc->def->voltage_nstep * sc->def->voltage_step); (sc->def->voltage_nstep * sc->def->voltage_step);
} }
}
static int static int
rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt, rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt,
int max_uvolt, uint8_t *val) int max_uvolt, uint8_t *val)
{ {
uint8_t nval; uint8_t nval;
int nstep, uvolt; int nstep, uvolt;
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
nval = 0; nval = 0;
uvolt = sc->def->voltage_min; uvolt = sc->def->voltage_min;
for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt; for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
nstep++) { nstep++) {
++nval; ++nval;
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
if (uvolt < sc->def->voltage_min2)
uvolt += sc->def->voltage_step; uvolt += sc->def->voltage_step;
else
uvolt += sc->def->voltage_step2;
} else
uvolt += sc->def->voltage_step;
} else
uvolt += sc->def->voltage_step;
} }
if (uvolt > max_uvolt) if (uvolt > max_uvolt)
return (EINVAL); return (EINVAL);
*val = nval; *val = nval;
return (0); return (0);
} }
Show All 13 Linesrk8xx_regnode_status(struct regnode *regnode, int *status)
return (0); return (0);
} }
static int static int
rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt, rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
int max_uvolt, int *udelay) int max_uvolt, int *udelay)
{ {
struct rk8xx_reg_sc *sc; struct rk8xx_reg_sc *sc;
uint8_t val; uint8_t val, old;
int uvolt; int uvolt;
struct rk8xx_softc *sc1;
sc = regnode_get_softc(regnode); sc = regnode_get_softc(regnode);
sc1 = device_get_softc(sc->base_dev);
if (!sc->def->voltage_step) if (!sc->def->voltage_step)
return (ENXIO); return (ENXIO);
dprintf(sc, "Setting %s to %d<->%d uvolts\n", dprintf(sc, "Setting %s to %d<->%d uvolts\n",
sc->def->name, sc->def->name,
min_uvolt, min_uvolt,
max_uvolt); max_uvolt);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
old = val;
if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0) if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
return (ERANGE); return (ERANGE);
if (sc1->type == RK809 || sc1->type == RK817)
val |= (old &= ~sc->def->voltage_mask);
rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
*udelay = 0; *udelay = 0;
rk8xx_regnode_reg_to_voltage(sc, val, &uvolt); rk8xx_regnode_reg_to_voltage(sc, val, &uvolt);
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines
View Options

security/ruby-camellia/files/

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Linesrk8xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
*udelay = 0; *udelay = 0;
return (0); return (0);
} }
static void static void
rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv) rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv)
{ {
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
int change;
change =
((sc->def->voltage_min2 - sc->def->voltage_min) /
sc->def->voltage_step);
if (val > change) {
if (val < sc->def->voltage_nstep) {
*uv = sc->def->voltage_min2 +
(val - change) *
sc->def->voltage_step2;
} else
*uv = sc->def->voltage_max2;
return;
}
}
if (val < sc->def->voltage_nstep) if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step; *uv = sc->def->voltage_min + val * sc->def->voltage_step;
else else
*uv = sc->def->voltage_max;
} else {
if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step;
else
*uv = sc->def->voltage_min + *uv = sc->def->voltage_min +
(sc->def->voltage_nstep * sc->def->voltage_step); (sc->def->voltage_nstep * sc->def->voltage_step);
} }
}
static int static int
rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt, rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt,
int max_uvolt, uint8_t *val) int max_uvolt, uint8_t *val)
{ {
uint8_t nval; uint8_t nval;
int nstep, uvolt; int nstep, uvolt;
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
nval = 0; nval = 0;
uvolt = sc->def->voltage_min; uvolt = sc->def->voltage_min;
for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt; for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
nstep++) { nstep++) {
++nval; ++nval;
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
if (uvolt < sc->def->voltage_min2)
uvolt += sc->def->voltage_step; uvolt += sc->def->voltage_step;
else
uvolt += sc->def->voltage_step2;
} else
uvolt += sc->def->voltage_step;
} else
uvolt += sc->def->voltage_step;
} }
if (uvolt > max_uvolt) if (uvolt > max_uvolt)
return (EINVAL); return (EINVAL);
*val = nval; *val = nval;
return (0); return (0);
} }
Show All 13 Linesrk8xx_regnode_status(struct regnode *regnode, int *status)
return (0); return (0);
} }
static int static int
rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt, rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
int max_uvolt, int *udelay) int max_uvolt, int *udelay)
{ {
struct rk8xx_reg_sc *sc; struct rk8xx_reg_sc *sc;
uint8_t val; uint8_t val, old;
int uvolt; int uvolt;
struct rk8xx_softc *sc1;
sc = regnode_get_softc(regnode); sc = regnode_get_softc(regnode);
sc1 = device_get_softc(sc->base_dev);
if (!sc->def->voltage_step) if (!sc->def->voltage_step)
return (ENXIO); return (ENXIO);
dprintf(sc, "Setting %s to %d<->%d uvolts\n", dprintf(sc, "Setting %s to %d<->%d uvolts\n",
sc->def->name, sc->def->name,
min_uvolt, min_uvolt,
max_uvolt); max_uvolt);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
old = val;
if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0) if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
return (ERANGE); return (ERANGE);
if (sc1->type == RK809 || sc1->type == RK817)
val |= (old &= ~sc->def->voltage_mask);
rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
*udelay = 0; *udelay = 0;
rk8xx_regnode_reg_to_voltage(sc, val, &uvolt); rk8xx_regnode_reg_to_voltage(sc, val, &uvolt);
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines
View Options

security/ruby-camellia/files/patch-ext_camellia-rb.c

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Linesrk8xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
*udelay = 0; *udelay = 0;
return (0); return (0);
} }
static void static void
rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv) rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv)
{ {
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
int change;
change =
((sc->def->voltage_min2 - sc->def->voltage_min) /
sc->def->voltage_step);
if (val > change) {
if (val < sc->def->voltage_nstep) {
*uv = sc->def->voltage_min2 +
(val - change) *
sc->def->voltage_step2;
} else
*uv = sc->def->voltage_max2;
return;
}
}
if (val < sc->def->voltage_nstep) if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step; *uv = sc->def->voltage_min + val * sc->def->voltage_step;
else else
*uv = sc->def->voltage_max;
} else {
if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step;
else
*uv = sc->def->voltage_min + *uv = sc->def->voltage_min +
(sc->def->voltage_nstep * sc->def->voltage_step); (sc->def->voltage_nstep * sc->def->voltage_step);
} }
}
static int static int
rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt, rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt,
int max_uvolt, uint8_t *val) int max_uvolt, uint8_t *val)
{ {
uint8_t nval; uint8_t nval;
int nstep, uvolt; int nstep, uvolt;
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
nval = 0; nval = 0;
uvolt = sc->def->voltage_min; uvolt = sc->def->voltage_min;
for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt; for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
nstep++) { nstep++) {
++nval; ++nval;
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
if (uvolt < sc->def->voltage_min2)
uvolt += sc->def->voltage_step; uvolt += sc->def->voltage_step;
else
uvolt += sc->def->voltage_step2;
} else
uvolt += sc->def->voltage_step;
} else
uvolt += sc->def->voltage_step;
} }
if (uvolt > max_uvolt) if (uvolt > max_uvolt)
return (EINVAL); return (EINVAL);
*val = nval; *val = nval;
return (0); return (0);
} }
Show All 13 Linesrk8xx_regnode_status(struct regnode *regnode, int *status)
return (0); return (0);
} }
static int static int
rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt, rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
int max_uvolt, int *udelay) int max_uvolt, int *udelay)
{ {
struct rk8xx_reg_sc *sc; struct rk8xx_reg_sc *sc;
uint8_t val; uint8_t val, old;
int uvolt; int uvolt;
struct rk8xx_softc *sc1;
sc = regnode_get_softc(regnode); sc = regnode_get_softc(regnode);
sc1 = device_get_softc(sc->base_dev);
if (!sc->def->voltage_step) if (!sc->def->voltage_step)
return (ENXIO); return (ENXIO);
dprintf(sc, "Setting %s to %d<->%d uvolts\n", dprintf(sc, "Setting %s to %d<->%d uvolts\n",
sc->def->name, sc->def->name,
min_uvolt, min_uvolt,
max_uvolt); max_uvolt);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
old = val;
if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0) if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
return (ERANGE); return (ERANGE);
if (sc1->type == RK809 || sc1->type == RK817)
val |= (old &= ~sc->def->voltage_mask);
rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
*udelay = 0; *udelay = 0;
rk8xx_regnode_reg_to_voltage(sc, val, &uvolt); rk8xx_regnode_reg_to_voltage(sc, val, &uvolt);
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines
View Options

security/ruby-camellia/files/patch-setup.rb

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Linesrk8xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
*udelay = 0; *udelay = 0;
return (0); return (0);
} }
static void static void
rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv) rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv)
{ {
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
int change;
change =
((sc->def->voltage_min2 - sc->def->voltage_min) /
sc->def->voltage_step);
if (val > change) {
if (val < sc->def->voltage_nstep) {
*uv = sc->def->voltage_min2 +
(val - change) *
sc->def->voltage_step2;
} else
*uv = sc->def->voltage_max2;
return;
}
}
if (val < sc->def->voltage_nstep) if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step; *uv = sc->def->voltage_min + val * sc->def->voltage_step;
else else
*uv = sc->def->voltage_max;
} else {
if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step;
else
*uv = sc->def->voltage_min + *uv = sc->def->voltage_min +
(sc->def->voltage_nstep * sc->def->voltage_step); (sc->def->voltage_nstep * sc->def->voltage_step);
} }
}
static int static int
rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt, rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt,
int max_uvolt, uint8_t *val) int max_uvolt, uint8_t *val)
{ {
uint8_t nval; uint8_t nval;
int nstep, uvolt; int nstep, uvolt;
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
nval = 0; nval = 0;
uvolt = sc->def->voltage_min; uvolt = sc->def->voltage_min;
for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt; for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
nstep++) { nstep++) {
++nval; ++nval;
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
if (uvolt < sc->def->voltage_min2)
uvolt += sc->def->voltage_step; uvolt += sc->def->voltage_step;
else
uvolt += sc->def->voltage_step2;
} else
uvolt += sc->def->voltage_step;
} else
uvolt += sc->def->voltage_step;
} }
if (uvolt > max_uvolt) if (uvolt > max_uvolt)
return (EINVAL); return (EINVAL);
*val = nval; *val = nval;
return (0); return (0);
} }
Show All 13 Linesrk8xx_regnode_status(struct regnode *regnode, int *status)
return (0); return (0);
} }
static int static int
rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt, rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
int max_uvolt, int *udelay) int max_uvolt, int *udelay)
{ {
struct rk8xx_reg_sc *sc; struct rk8xx_reg_sc *sc;
uint8_t val; uint8_t val, old;
int uvolt; int uvolt;
struct rk8xx_softc *sc1;
sc = regnode_get_softc(regnode); sc = regnode_get_softc(regnode);
sc1 = device_get_softc(sc->base_dev);
if (!sc->def->voltage_step) if (!sc->def->voltage_step)
return (ENXIO); return (ENXIO);
dprintf(sc, "Setting %s to %d<->%d uvolts\n", dprintf(sc, "Setting %s to %d<->%d uvolts\n",
sc->def->name, sc->def->name,
min_uvolt, min_uvolt,
max_uvolt); max_uvolt);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
old = val;
if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0) if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
return (ERANGE); return (ERANGE);
if (sc1->type == RK809 || sc1->type == RK817)
val |= (old &= ~sc->def->voltage_mask);
rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
*udelay = 0; *udelay = 0;
rk8xx_regnode_reg_to_voltage(sc, val, &uvolt); rk8xx_regnode_reg_to_voltage(sc, val, &uvolt);
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines
View Options

security/ruby-camellia/pkg-descr

Loading...