kernel-provided clamp_val is identical, delete the private limit_value helper.
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Cc: Michael Buesch <mb@bu3sch.de>
Cc: "John W. Linville" <linville@tuxdriver.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
 # define b43legacydbg(wl, fmt...) do { /* nothing */ } while (0)
 #endif /* DEBUG */
 
-
-/** Limit a value between two limits */
-#ifdef limit_value
-# undef limit_value
-#endif
-#define limit_value(value, min, max)  \
-       ({                                              \
-               typeof(value) __value = (value);        \
-               typeof(value) __min = (min);            \
-               typeof(value) __max = (max);            \
-               if (__value < __min)                    \
-                       __value = __min;                \
-               else if (__value > __max)               \
-                       __value = __max;                \
-               __value;                                \
-       })
-
 /* Macros for printing a value in Q5.2 format */
 #define Q52_FMT                "%u.%u"
 #define Q52_ARG(q52)   ((q52) / 4), (((q52) & 3) * 100 / 4)
 
        /* Get the noise samples. */
        B43legacy_WARN_ON(dev->noisecalc.nr_samples >= 8);
        i = dev->noisecalc.nr_samples;
-       noise[0] = limit_value(noise[0], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
-       noise[1] = limit_value(noise[1], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
-       noise[2] = limit_value(noise[2], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
-       noise[3] = limit_value(noise[3], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
+       noise[0] = clamp_val(noise[0], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
+       noise[1] = clamp_val(noise[1], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
+       noise[2] = clamp_val(noise[2], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
+       noise[3] = clamp_val(noise[3], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
        dev->noisecalc.samples[i][0] = phy->nrssi_lt[noise[0]];
        dev->noisecalc.samples[i][1] = phy->nrssi_lt[noise[1]];
        dev->noisecalc.samples[i][2] = phy->nrssi_lt[noise[2]];
 
                 * the value 0x7FFFFFFF here. I think that is some weird
                 * compiler optimization in the original driver.
                 * Essentially, what we do here is resetting all NRSSI LT
-                * entries to -32 (see the limit_value() in nrssi_hw_update())
+                * entries to -32 (see the clamp_val() in nrssi_hw_update())
                 */
                b43legacy_nrssi_hw_update(dev, 0xFFFF);
                b43legacy_calc_nrssi_threshold(dev);
        switch (phy->type) {
        case B43legacy_PHYTYPE_B:
        case B43legacy_PHYTYPE_G:
-               tmp = limit_value(tmp, 0x00, 0x3F);
+               tmp = clamp_val(tmp, 0x00, 0x3F);
                dbm = phy->tssi2dbm[tmp];
                break;
        default:
 
        /* find the desired power in Q5.2 - power_level is in dBm
         * and limit it - max_pwr is already in Q5.2 */
-       desired_pwr = limit_value(phy->power_level << 2, 0, max_pwr);
+       desired_pwr = clamp_val(phy->power_level << 2, 0, max_pwr);
        if (b43legacy_debug(dev, B43legacy_DBG_XMITPOWER))
                b43legacydbg(dev->wl, "Current TX power output: " Q52_FMT
                       " dBm, Desired TX power output: " Q52_FMT
                        radio_attenuation++;
                }
        }
-       baseband_attenuation = limit_value(baseband_attenuation, 0, 11);
+       baseband_attenuation = clamp_val(baseband_attenuation, 0, 11);
 
        txpower = phy->txctl1;
        if ((phy->radio_ver == 0x2050) && (phy->radio_rev == 2)) {
        }
        /* Save the control values */
        phy->txctl1 = txpower;
-       baseband_attenuation = limit_value(baseband_attenuation, 0, 11);
-       radio_attenuation = limit_value(radio_attenuation, 0, 9);
+       baseband_attenuation = clamp_val(baseband_attenuation, 0, 11);
+       radio_attenuation = clamp_val(radio_attenuation, 0, 9);
        phy->rfatt = radio_attenuation;
        phy->bbatt = baseband_attenuation;
 
                f = q;
                i++;
        } while (delta >= 2);
-       entry[index] = limit_value(b43legacy_tssi2dbm_ad(m1 * f, 8192),
+       entry[index] = clamp_val(b43legacy_tssi2dbm_ad(m1 * f, 8192),
                                   -127, 128);
        return 0;
 }
 
        for (i = 0; i < 64; i++) {
                tmp = b43legacy_nrssi_hw_read(dev, i);
                tmp -= val;
-               tmp = limit_value(tmp, -32, 31);
+               tmp = clamp_val(tmp, -32, 31);
                b43legacy_nrssi_hw_write(dev, i, tmp);
        }
 }
                tmp = (i - delta) * phy->nrssislope;
                tmp /= 0x10000;
                tmp += 0x3A;
-               tmp = limit_value(tmp, 0, 0x3F);
+               tmp = clamp_val(tmp, 0, 0x3F);
                phy->nrssi_lt[i] = tmp;
        }
 }
                } else
                        threshold = phy->nrssi[1] - 5;
 
-               threshold = limit_value(threshold, 0, 0x3E);
+               threshold = clamp_val(threshold, 0, 0x3E);
                b43legacy_phy_read(dev, 0x0020); /* dummy read */
                b43legacy_phy_write(dev, 0x0020, (((u16)threshold) << 8)
                                    | 0x001C);
                        else
                                a += 32;
                        a = a >> 6;
-                       a = limit_value(a, -31, 31);
+                       a = clamp_val(a, -31, 31);
 
                        b = b * (phy->nrssi[1] - phy->nrssi[0]);
                        b += (phy->nrssi[0] << 6);
                        else
                                b += 32;
                        b = b >> 6;
-                       b = limit_value(b, -31, 31);
+                       b = clamp_val(b, -31, 31);
 
                        tmp_u16 = b43legacy_phy_read(dev, 0x048A) & 0xF000;
                        tmp_u16 |= ((u32)b & 0x0000003F);
        u16 dac;
        u16 ilt;
 
-       txpower = limit_value(txpower, 0, 63);
+       txpower = clamp_val(txpower, 0, 63);
 
        pamp = b43legacy_get_txgain_freq_power_amp(txpower);
        pamp <<= 5;