Move devel/py-gflags to devel/py-python-gflags and update to 3.1.0

[sunpoet]

Summary

• Move devel/py-gflags to devel/py-python-gflags
• Update to 3.1.0
• Add LICENSE_FILE
• Add NO_ARCH
• Relax USES=python
• Allow concurrent installation (USE_PYTHON=concurrent)
• Remove PROJECTHOST
• Update WWW

Changes: https://github.com/google/python-gflags/releases

MOVED

rk8xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
         *udelay = 0;
 
         return (0);
 }
 
 static void
 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)
                         *uv = sc->def->voltage_min + val * sc->def->voltage_step;
                 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 +
-                       (sc->def->voltage_nstep * sc->def->voltage_step);
+                            (sc->def->voltage_nstep * sc->def->voltage_step);
         }
+}
 
 static int
 rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt,
     int max_uvolt, uint8_t *val)
 {
         uint8_t nval;
         int nstep, uvolt;
+        struct rk8xx_softc *sc1;
 
+        sc1 = device_get_softc(sc->base_dev);
         nval = 0;
         uvolt = sc->def->voltage_min;
 
         for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
              nstep++) {
                 ++nval;
+                if (sc1->type == RK809 || sc1->type == RK817) {
+                        if (sc->def->voltage_step2) {
+                                if (uvolt < sc->def->voltage_min2)
                                         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)
                 return (EINVAL);
 
         *val = nval;
         return (0);
 }
 
rk8xx_regnode_status(struct regnode *regnode, int *status)
         return (0);
 }
 
 static int
 rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
     int max_uvolt, int *udelay)
 {
         struct rk8xx_reg_sc *sc;
-        uint8_t val;
+        uint8_t val, old;
         int uvolt;
+        struct rk8xx_softc *sc1;
 
         sc = regnode_get_softc(regnode);
+        sc1 = device_get_softc(sc->base_dev);
 
         if (!sc->def->voltage_step)
                 return (ENXIO);
 
         dprintf(sc, "Setting %s to %d<->%d uvolts\n",
             sc->def->name,
             min_uvolt,
             max_uvolt);
         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)
                 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_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
 
         *udelay = 0;
 
         rk8xx_regnode_reg_to_voltage(sc, val, &uvolt);

deskutils/gcalcli/Makefile

rk8xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
         *udelay = 0;
 
         return (0);
 }
 
 static void
 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)
                         *uv = sc->def->voltage_min + val * sc->def->voltage_step;
                 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 +
-                       (sc->def->voltage_nstep * sc->def->voltage_step);
+                            (sc->def->voltage_nstep * sc->def->voltage_step);
         }
+}
 
 static int
 rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt,
     int max_uvolt, uint8_t *val)
 {
         uint8_t nval;
         int nstep, uvolt;
+        struct rk8xx_softc *sc1;
 
+        sc1 = device_get_softc(sc->base_dev);
         nval = 0;
         uvolt = sc->def->voltage_min;
 
         for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
              nstep++) {
                 ++nval;
+                if (sc1->type == RK809 || sc1->type == RK817) {
+                        if (sc->def->voltage_step2) {
+                                if (uvolt < sc->def->voltage_min2)
                                         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)
                 return (EINVAL);
 
         *val = nval;
         return (0);
 }
 
rk8xx_regnode_status(struct regnode *regnode, int *status)
         return (0);
 }
 
 static int
 rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
     int max_uvolt, int *udelay)
 {
         struct rk8xx_reg_sc *sc;
-        uint8_t val;
+        uint8_t val, old;
         int uvolt;
+        struct rk8xx_softc *sc1;
 
         sc = regnode_get_softc(regnode);
+        sc1 = device_get_softc(sc->base_dev);
 
         if (!sc->def->voltage_step)
                 return (ENXIO);
 
         dprintf(sc, "Setting %s to %d<->%d uvolts\n",
             sc->def->name,
             min_uvolt,
             max_uvolt);
         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)
                 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_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
 
         *udelay = 0;
 
         rk8xx_regnode_reg_to_voltage(sc, val, &uvolt);

devel/Makefile

rk8xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
         *udelay = 0;
 
         return (0);
 }
 
 static void
 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)
                         *uv = sc->def->voltage_min + val * sc->def->voltage_step;
                 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 +
-                       (sc->def->voltage_nstep * sc->def->voltage_step);
+                            (sc->def->voltage_nstep * sc->def->voltage_step);
         }
+}
 
 static int
 rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt,
     int max_uvolt, uint8_t *val)
 {
         uint8_t nval;
         int nstep, uvolt;
+        struct rk8xx_softc *sc1;
 
+        sc1 = device_get_softc(sc->base_dev);
         nval = 0;
         uvolt = sc->def->voltage_min;
 
         for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
              nstep++) {
                 ++nval;
+                if (sc1->type == RK809 || sc1->type == RK817) {
+                        if (sc->def->voltage_step2) {
+                                if (uvolt < sc->def->voltage_min2)
                                         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)
                 return (EINVAL);
 
         *val = nval;
         return (0);
 }
 
rk8xx_regnode_status(struct regnode *regnode, int *status)
         return (0);
 }
 
 static int
 rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
     int max_uvolt, int *udelay)
 {
         struct rk8xx_reg_sc *sc;
-        uint8_t val;
+        uint8_t val, old;
         int uvolt;
+        struct rk8xx_softc *sc1;
 
         sc = regnode_get_softc(regnode);
+        sc1 = device_get_softc(sc->base_dev);
 
         if (!sc->def->voltage_step)
                 return (ENXIO);
 
         dprintf(sc, "Setting %s to %d<->%d uvolts\n",
             sc->def->name,
             min_uvolt,
             max_uvolt);
         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)
                 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_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
 
         *udelay = 0;
 
         rk8xx_regnode_reg_to_voltage(sc, val, &uvolt);

devel/py-adb/Makefile

rk8xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
         *udelay = 0;
 
         return (0);
 }
 
 static void
 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)
                         *uv = sc->def->voltage_min + val * sc->def->voltage_step;
                 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 +
-                       (sc->def->voltage_nstep * sc->def->voltage_step);
+                            (sc->def->voltage_nstep * sc->def->voltage_step);
         }
+}
 
 static int
 rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt,
     int max_uvolt, uint8_t *val)
 {
         uint8_t nval;
         int nstep, uvolt;
+        struct rk8xx_softc *sc1;
 
+        sc1 = device_get_softc(sc->base_dev);
         nval = 0;
         uvolt = sc->def->voltage_min;
 
         for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
              nstep++) {
                 ++nval;
+                if (sc1->type == RK809 || sc1->type == RK817) {
+                        if (sc->def->voltage_step2) {
+                                if (uvolt < sc->def->voltage_min2)
                                         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)
                 return (EINVAL);
 
         *val = nval;
         return (0);
 }
 
rk8xx_regnode_status(struct regnode *regnode, int *status)
         return (0);
 }
 
 static int
 rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
     int max_uvolt, int *udelay)
 {
         struct rk8xx_reg_sc *sc;
-        uint8_t val;
+        uint8_t val, old;
         int uvolt;
+        struct rk8xx_softc *sc1;
 
         sc = regnode_get_softc(regnode);
+        sc1 = device_get_softc(sc->base_dev);
 
         if (!sc->def->voltage_step)
                 return (ENXIO);
 
         dprintf(sc, "Setting %s to %d<->%d uvolts\n",
             sc->def->name,
             min_uvolt,
             max_uvolt);
         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)
                 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_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
 
         *udelay = 0;
 
         rk8xx_regnode_reg_to_voltage(sc, val, &uvolt);