linux/kernel.h: sync min, max, min3, max3 macros with Linux

U-Boot has never cared about the type when we get max/min of two
values, but Linux Kernel does.  This commit gets min, max, min3, max3
macros synced with the kernel introducing type checks.

Many of references of those macros must be fixed to suppress warnings.
We have two options:
 - Use min, max, min3, max3 only when the arguments have the same type
   (or add casts to the arguments)
 - Use min_t/max_t instead with the appropriate type for the first
   argument

Signed-off-by: Masahiro Yamada <yamada.m@jp.panasonic.com>
Acked-by: Pavel Machek <pavel@denx.de>
Acked-by: Lukasz Majewski <l.majewski@samsung.com>
Tested-by: Lukasz Majewski <l.majewski@samsung.com>
[trini: Fixup arch/blackfin/lib/string.c]
Signed-off-by: Tom Rini <trini@ti.com>

diff --git a/arch/arm/cpu/arm1176/tnetv107x/clock.c b/arch/arm/cpu/arm1176/tnetv107x/clock.c
index 47c23bb2688f6f9cc5070998db1d7a795eb7c92a..7ba28d329fa8f6dc2766891425e086043a50cb9e 100644 (file)
--- a/arch/arm/cpu/arm1176/tnetv107x/clock.c
+++ b/arch/arm/cpu/arm1176/tnetv107x/clock.c
@@ -16,7 +16,7 @@
 #define BIT(x)                 (1 << (x))
 
 #define MAX_PREDIV             64
-#define MAX_POSTDIV            8
+#define MAX_POSTDIV            8UL
 #define MAX_MULT               512
 #define MAX_DIV                        (MAX_PREDIV * MAX_POSTDIV)
 
@@ -362,7 +362,7 @@ static void init_pll(const struct pll_init_data *data)
        pllctl_reg_write(data->pll, ctl, tmp);
 
        mult = data->pll_freq / fpll;
-       for (mult = max(mult, 1); mult <= MAX_MULT; mult++) {
+       for (mult = max(mult, 1UL); mult <= MAX_MULT; mult++) {
                div = (fpll * mult) / data->pll_freq;
                if (div < 1 || div > MAX_DIV)
                        continue;

diff --git a/arch/arm/cpu/armv7/exynos/clock.c b/arch/arm/cpu/armv7/exynos/clock.c
index 7558effdb3388b7dce91a5561e7df0a5071fa85c..c0c95fbc83dc805953717b48d8701b15c52f7211 100644 (file)
--- a/arch/arm/cpu/armv7/exynos/clock.c
+++ b/arch/arm/cpu/armv7/exynos/clock.c
@@ -1422,8 +1422,8 @@ static int clock_calc_best_scalar(unsigned int main_scaler_bits,
                return 1;
 
        for (i = 1; i <= loops; i++) {
-               const unsigned int effective_div = max(min(input_rate / i /
-                                                       target_rate, cap), 1);
+               const unsigned int effective_div =
+                       max(min(input_rate / i / target_rate, cap), 1U);
                const unsigned int effective_rate = input_rate / i /
                                                        effective_div;
                const int error = target_rate - effective_rate;

diff --git a/arch/arm/cpu/armv7/exynos/spl_boot.c b/arch/arm/cpu/armv7/exynos/spl_boot.c
index 658e4cb715f92647d108780c4c81a70b10295bf0..ae3ad0167d19d5197e95c477ace390e58ead0147 100644 (file)
--- a/arch/arm/cpu/armv7/exynos/spl_boot.c
+++ b/arch/arm/cpu/armv7/exynos/spl_boot.c
@@ -151,7 +151,7 @@ static void exynos_spi_copy(unsigned int uboot_size, unsigned int uboot_addr)
        }
 
        for (upto = 0, i = 0; upto < uboot_size; upto += todo, i++) {
-               todo = min(uboot_size - upto, (1 << 15));
+               todo = min(uboot_size - upto, (unsigned int)(1 << 15));
                spi_rx_tx(regs, todo, (void *)(uboot_addr),
                          (void *)(SPI_FLASH_UBOOT_POS), i);
        }

diff --git a/arch/arm/cpu/armv7/tegra20/display.c b/arch/arm/cpu/armv7/tegra20/display.c
index d98cec90180f5d133432d57c68bf6759649c0c0c..61efed6464455b2e0a85d0efe54835a9fb9a5d0c 100644 (file)
--- a/arch/arm/cpu/armv7/tegra20/display.c
+++ b/arch/arm/cpu/armv7/tegra20/display.c
@@ -45,8 +45,8 @@ static void update_window(struct dc_ctlr *dc, struct disp_ctl_win *win)
        writel(0, &dc->win.h_initial_dda);
        writel(0, &dc->win.v_initial_dda);
 
-       h_dda = (win->w * 0x1000) / max(win->out_w - 1, 1);
-       v_dda = (win->h * 0x1000) / max(win->out_h - 1, 1);
+       h_dda = (win->w * 0x1000) / max(win->out_w - 1, 1U);
+       v_dda = (win->h * 0x1000) / max(win->out_h - 1, 1U);
 
        val = h_dda << H_DDA_INC_SHIFT;
        val |= v_dda << V_DDA_INC_SHIFT;

diff --git a/arch/avr32/cpu/at32ap700x/clk.c b/arch/avr32/cpu/at32ap700x/clk.c
index d5dbe3b908f9ef08fdaea5b1d213245b4ef044d7..0fc6088e3ee10e23584df8203a92ad39dfd15b33 100644 (file)
--- a/arch/avr32/cpu/at32ap700x/clk.c
+++ b/arch/avr32/cpu/at32ap700x/clk.c
@@ -72,7 +72,7 @@ unsigned long __gclk_set_rate(unsigned int id, enum gclk_parent parent,
                sm_writel(PM_GCCTRL(id), parent | SM_BIT(CEN));
                rate = parent_rate;
        } else {
-               divider = min(255, divider / 2 - 1);
+               divider = min(255UL, divider / 2 - 1);
                sm_writel(PM_GCCTRL(id), parent | SM_BIT(CEN) | SM_BIT(DIVEN)
                                | SM_BF(DIV, divider));
                rate = parent_rate / (2 * (divider + 1));

diff --git a/arch/blackfin/cpu/jtag-console.c b/arch/blackfin/cpu/jtag-console.c
index b8be3182a0906ff309ff8cb3ccc744b95fe8d21a..b0abeda90aec71025aa8568426bc93b7620d28bc 100644 (file)
--- a/arch/blackfin/cpu/jtag-console.c
+++ b/arch/blackfin/cpu/jtag-console.c
@@ -168,7 +168,7 @@ static int jtag_getc(struct stdio_dev *dev)
                inbound_len = emudat;
        } else {
                /* store the bytes */
-               leftovers_len = min(4, inbound_len);
+               leftovers_len = min((size_t)4, inbound_len);
                inbound_len -= leftovers_len;
                leftovers = emudat;
        }

diff --git a/arch/blackfin/lib/string.c b/arch/blackfin/lib/string.c
index f0a061b47ab1ee5555294cc858f4c6e8be415059..211df7b430c246b28b3977d6ecfadced44dac0ef 100644 (file)
--- a/arch/blackfin/lib/string.c
+++ b/arch/blackfin/lib/string.c
@@ -121,7 +121,7 @@ static void dma_calc_size(unsigned long ldst, unsigned long lsrc, size_t count,
        *dshift = WDSIZE_P;
 #endif
 
-       *bpos = min(limit, ffs(ldst | lsrc | count)) - 1;
+       *bpos = min(limit, (unsigned long)ffs(ldst | lsrc | count)) - 1;
 }
 
 /* This version misbehaves for count values of 0 and 2^16+.
@@ -157,7 +157,7 @@ void dma_memcpy_nocache(void *dst, const void *src, size_t count)
 
 #ifdef PSIZE
        /* The max memory DMA peripheral transfer size is 4 bytes. */
-       dsize |= min(2, bpos) << PSIZE_P;
+       dsize |= min(2UL, bpos) << PSIZE_P;
 #endif
 
        /* Copy sram functions from sdram to sram */

diff --git a/arch/powerpc/cpu/mpc85xx/tlb.c b/arch/powerpc/cpu/mpc85xx/tlb.c
index 129ec662fe8a84ba289bb914cddd296eb8e08967..4adba95aaf804995cf6ed6a81b67e5534f1e2cd7 100644 (file)
--- a/arch/powerpc/cpu/mpc85xx/tlb.c
+++ b/arch/powerpc/cpu/mpc85xx/tlb.c
@@ -300,7 +300,7 @@ unsigned int setup_ddr_tlbs_phys(phys_addr_t p_addr,
        unsigned int ram_tlb_address = (unsigned int)CONFIG_SYS_DDR_SDRAM_BASE;
        u64 memsize = (u64)memsize_in_meg << 20;
 
-       memsize = min(memsize, CONFIG_MAX_MEM_MAPPED);
+       memsize = min(memsize, (u64)CONFIG_MAX_MEM_MAPPED);
        memsize = tlb_map_range(ram_tlb_address, p_addr, memsize, TLB_MAP_RAM);
 
        if (memsize)

diff --git a/arch/powerpc/cpu/ppc4xx/44x_spd_ddr2.c b/arch/powerpc/cpu/ppc4xx/44x_spd_ddr2.c
index f8d03cba2d6f7a27dd69d3b5a5f793f166e87dcb..71bb9d776fa59c24303d985d21a269e10938a344 100644 (file)
--- a/arch/powerpc/cpu/ppc4xx/44x_spd_ddr2.c
+++ b/arch/powerpc/cpu/ppc4xx/44x_spd_ddr2.c
@@ -1661,7 +1661,7 @@ static void program_mode(unsigned long *dimm_populated,
                for (dimm_num = 0; dimm_num < num_dimm_banks; dimm_num++) {
                        /* If a dimm is installed in a particular slot ... */
                        if (dimm_populated[dimm_num] != SDRAM_NONE)
-                               t_wr_ns = max(t_wr_ns,
+                               t_wr_ns = max(t_wr_ns, (unsigned long)
                                              spd_read(iic0_dimm_addr[dimm_num], 36) >> 2);
                }
 
@@ -1838,12 +1838,18 @@ static void program_tr(unsigned long *dimm_populated,
                        else
                                sdram_ddr1 = false;
 
-                       t_rcd_ns = max(t_rcd_ns, spd_read(iic0_dimm_addr[dimm_num], 29) >> 2);
-                       t_rrd_ns = max(t_rrd_ns, spd_read(iic0_dimm_addr[dimm_num], 28) >> 2);
-                       t_rp_ns  = max(t_rp_ns,  spd_read(iic0_dimm_addr[dimm_num], 27) >> 2);
-                       t_ras_ns = max(t_ras_ns, spd_read(iic0_dimm_addr[dimm_num], 30));
-                       t_rc_ns  = max(t_rc_ns,  spd_read(iic0_dimm_addr[dimm_num], 41));
-                       t_rfc_ns = max(t_rfc_ns, spd_read(iic0_dimm_addr[dimm_num], 42));
+                       t_rcd_ns = max(t_rcd_ns,
+                                      (unsigned long)spd_read(iic0_dimm_addr[dimm_num], 29) >> 2);
+                       t_rrd_ns = max(t_rrd_ns,
+                                      (unsigned long)spd_read(iic0_dimm_addr[dimm_num], 28) >> 2);
+                       t_rp_ns  = max(t_rp_ns,
+                                      (unsigned long)spd_read(iic0_dimm_addr[dimm_num], 27) >> 2);
+                       t_ras_ns = max(t_ras_ns,
+                                      (unsigned long)spd_read(iic0_dimm_addr[dimm_num], 30));
+                       t_rc_ns  = max(t_rc_ns,
+                                      (unsigned long)spd_read(iic0_dimm_addr[dimm_num], 41));
+                       t_rfc_ns = max(t_rfc_ns,
+                                      (unsigned long)spd_read(iic0_dimm_addr[dimm_num], 42));
                }
        }
 
@@ -1916,9 +1922,12 @@ static void program_tr(unsigned long *dimm_populated,
                for (dimm_num = 0; dimm_num < num_dimm_banks; dimm_num++) {
                        /* If a dimm is installed in a particular slot ... */
                        if (dimm_populated[dimm_num] != SDRAM_NONE) {
-                               t_wpc_ns = max(t_wtr_ns, spd_read(iic0_dimm_addr[dimm_num], 36) >> 2);
-                               t_wtr_ns = max(t_wtr_ns, spd_read(iic0_dimm_addr[dimm_num], 37) >> 2);
-                               t_rpc_ns = max(t_rpc_ns, spd_read(iic0_dimm_addr[dimm_num], 38) >> 2);
+                               t_wpc_ns = max(t_wtr_ns,
+                                              (unsigned long)spd_read(iic0_dimm_addr[dimm_num], 36) >> 2);
+                               t_wtr_ns = max(t_wtr_ns,
+                                              (unsigned long)spd_read(iic0_dimm_addr[dimm_num], 37) >> 2);
+                               t_rpc_ns = max(t_rpc_ns,
+                                              (unsigned long)spd_read(iic0_dimm_addr[dimm_num], 38) >> 2);
                        }
                }
 
@@ -2314,7 +2323,8 @@ static void program_ecc(unsigned long *dimm_populated,
        for (dimm_num = 0; dimm_num < MAXDIMMS; dimm_num++) {
                /* If a dimm is installed in a particular slot ... */
                if (dimm_populated[dimm_num] != SDRAM_NONE)
-                       ecc = max(ecc, spd_read(iic0_dimm_addr[dimm_num], 11));
+                       ecc = max(ecc,
+                                 (unsigned long)spd_read(iic0_dimm_addr[dimm_num], 11));
        }
        if (ecc == 0)
                return;

diff --git a/arch/powerpc/lib/bootm.c b/arch/powerpc/lib/bootm.c
index 33099a492dbe92ac7b31f20fe26f3b625b22f6f6..ef15e7ac92f292dd482cf65cf7bf9d2c05da91dc 100644 (file)
--- a/arch/powerpc/lib/bootm.c
+++ b/arch/powerpc/lib/bootm.c
@@ -126,7 +126,7 @@ void arch_lmb_reserve(struct lmb *lmb)
 #endif
 
        size = min(bootm_size, get_effective_memsize());
-       size = min(size, CONFIG_SYS_LINUX_LOWMEM_MAX_SIZE);
+       size = min(size, (ulong)CONFIG_SYS_LINUX_LOWMEM_MAX_SIZE);
 
        if (size < bootm_size) {
                ulong base = bootmap_base + size;

diff --git a/arch/sandbox/cpu/start.c b/arch/sandbox/cpu/start.c
index 53a99ae71b1361131637b0827a8b2afb142273e7..0df77704c6f769c7085940ca81592d064c7362af 100644 (file)
--- a/arch/sandbox/cpu/start.c
+++ b/arch/sandbox/cpu/start.c
@@ -39,7 +39,7 @@ int sandbox_early_getopt_check(void)
 
        max_arg_len = 0;
        for (i = 0; i < num_options; ++i)
-               max_arg_len = max(strlen(sb_opt[i]->flag), max_arg_len);
+               max_arg_len = max((int)strlen(sb_opt[i]->flag), max_arg_len);
        max_noarg_len = max_arg_len + 7;
 
        for (i = 0; i < num_options; ++i) {

diff --git a/arch/x86/cpu/coreboot/pci.c b/arch/x86/cpu/coreboot/pci.c
index 33f16a3079381e15f694b94418791e5aa96d255a..b35d70cf1773ab9720ead0cad11aa76d704c1bc0 100644 (file)
--- a/arch/x86/cpu/coreboot/pci.c
+++ b/arch/x86/cpu/coreboot/pci.c
@@ -20,7 +20,7 @@ static void config_pci_bridge(struct pci_controller *hose, pci_dev_t dev,
 {
        u8 secondary;
        hose->read_byte(hose, dev, PCI_SECONDARY_BUS, &secondary);
-       hose->last_busno = max(hose->last_busno, secondary);
+       hose->last_busno = max(hose->last_busno, (int)secondary);
        pci_hose_scan_bus(hose, secondary);
 }
 

diff --git a/arch/x86/cpu/coreboot/sdram.c b/arch/x86/cpu/coreboot/sdram.c
index 959feaaea3407b7c92da443b22c1c795ab4753f9..3140b6bb9108804ffea82795fd94e0602d2228aa 100644 (file)
--- a/arch/x86/cpu/coreboot/sdram.c
+++ b/arch/x86/cpu/coreboot/sdram.c
@@ -22,7 +22,7 @@ unsigned install_e820_map(unsigned max_entries, struct e820entry *entries)
 {
        int i;
 
-       unsigned num_entries = min(lib_sysinfo.n_memranges, max_entries);
+       unsigned num_entries = min((unsigned)lib_sysinfo.n_memranges, max_entries);
        if (num_entries < lib_sysinfo.n_memranges) {
                printf("Warning: Limiting e820 map to %d entries.\n",
                        num_entries);

diff --git a/board/freescale/common/sys_eeprom.c b/board/freescale/common/sys_eeprom.c
index 6144c533ef27af60d629103aa5f117369ed373b4..c9c8eaade233d590c702236b06b70585d98b116b 100644 (file)
--- a/board/freescale/common/sys_eeprom.c
+++ b/board/freescale/common/sys_eeprom.c
@@ -114,7 +114,7 @@ static void show_eeprom(void)
                e.date[3] & 0x80 ? "PM" : "");
 
        /* Show MAC addresses  */
-       for (i = 0; i < min(e.mac_count, MAX_NUM_PORTS); i++) {
+       for (i = 0; i < min(e.mac_count, (u8)MAX_NUM_PORTS); i++) {
 
                u8 *p = e.mac[i];
 
@@ -223,7 +223,7 @@ static int prog_eeprom(void)
         */
        for (i = 0, p = &e; i < sizeof(e); i += 8, p += 8) {
                ret = i2c_write(CONFIG_SYS_I2C_EEPROM_ADDR, i, CONFIG_SYS_I2C_EEPROM_ADDR_LEN,
-                       p, min((sizeof(e) - i), 8));
+                               p, min((int)(sizeof(e) - i), 8));
                if (ret)
                        break;
                udelay(5000);   /* 5ms write cycle timing */
@@ -461,7 +461,7 @@ int mac_read_from_eeprom(void)
                memset(e.mac[8], 0xff, 6);
 #endif
 
-       for (i = 0; i < min(e.mac_count, MAX_NUM_PORTS); i++) {
+       for (i = 0; i < min(e.mac_count, (u8)MAX_NUM_PORTS); i++) {
                if (memcmp(&e.mac[i], "\0\0\0\0\0\0", 6) &&
                    memcmp(&e.mac[i], "\xFF\xFF\xFF\xFF\xFF\xFF", 6)) {
                        char ethaddr[18];

diff --git a/board/gdsys/p1022/controlcenterd-id.c b/board/gdsys/p1022/controlcenterd-id.c
index 70eff912aa6bc7d99634d101e7b54225c61f98b4..317669b9ab180190207c70ec5258520f461fd2e8 100644 (file)
--- a/board/gdsys/p1022/controlcenterd-id.c
+++ b/board/gdsys/p1022/controlcenterd-id.c
@@ -236,7 +236,7 @@ static int ccdm_mmc_read(struct mmc *mmc, u64 src, u8 *dst, int size)
                        tmp_buf);
                if (!n)
                        goto failure;
-               result = min(size, blk_len - ofs);
+               result = min(size, (int)(blk_len - ofs));
                memcpy(dst, tmp_buf + ofs, result);
                dst += result;
                size -= result;
@@ -736,7 +736,8 @@ do_bin_func:
                                src_buf = buf;
                                for (ptr = (uint8_t *)src_buf, i = 20; i > 0;
                                        i -= data_size, ptr += data_size)
-                                       memcpy(ptr, data, min(i, data_size));
+                                       memcpy(ptr, data,
+                                              min_t(size_t, i, data_size));
                        }
                }
                bin_func(dst_reg->digest, src_buf, 20);

diff --git a/board/imgtec/malta/malta.c b/board/imgtec/malta/malta.c
index d363e49919e96454e692658289271b448c29f64f..78c4bd4efe7114767e9c52ef07a42c6fe8c1460c 100644 (file)
--- a/board/imgtec/malta/malta.c
+++ b/board/imgtec/malta/malta.c
@@ -37,7 +37,7 @@ static void malta_lcd_puts(const char *str)
        void *reg = (void *)CKSEG1ADDR(MALTA_ASCIIPOS0);
 
        /* print up to 8 characters of the string */
-       for (i = 0; i < min(strlen(str), 8); i++) {
+       for (i = 0; i < min((int)strlen(str), 8); i++) {
                __raw_writel(str[i], reg);
                reg += MALTA_ASCIIPOS1 - MALTA_ASCIIPOS0;
        }

diff --git a/common/cmd_elf.c b/common/cmd_elf.c
index 42a52965c2722282c36e6ebeaa0049c8c21b4c9f..58b61c26403b9fe79fe041c7c6cf2b6123309759 100644 (file)
--- a/common/cmd_elf.c
+++ b/common/cmd_elf.c
@@ -210,9 +210,9 @@ int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
         */
        bootline = getenv("bootargs");
        if (bootline) {
-               memcpy((void *) bootaddr, bootline,
-                       max(strlen(bootline), 255));
-               flush_cache(bootaddr, max(strlen(bootline), 255));
+               memcpy((void *)bootaddr, bootline,
+                      max(strlen(bootline), (size_t)255));
+               flush_cache(bootaddr, max(strlen(bootline), (size_t)255));
        } else {
                sprintf(build_buf, CONFIG_SYS_VXWORKS_BOOT_DEVICE);
                tmp = getenv("bootfile");
@@ -240,9 +240,9 @@ int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                         CONFIG_SYS_VXWORKS_ADD_PARAMS);
 #endif
 
-               memcpy((void *) bootaddr, build_buf,
-                       max(strlen(build_buf), 255));
-               flush_cache(bootaddr, max(strlen(build_buf), 255));
+               memcpy((void *)bootaddr, build_buf,
+                      max(strlen(build_buf), (size_t)255));
+               flush_cache(bootaddr, max(strlen(build_buf), (size_t)255));
        }
 
        /*

diff --git a/common/cmd_sf.c b/common/cmd_sf.c
index 95a6f89a845da57b5e5430b339dbda12f4d5d354..5c788e96bdb821de3b7cd6f4f6cb8a40a0238cc4 100644 (file)
--- a/common/cmd_sf.c
+++ b/common/cmd_sf.c
@@ -18,7 +18,6 @@
 
 static struct spi_flash *flash;
 
-
 /*
  * This function computes the length argument for the erase command.
  * The length on which the command is to operate can be given in two forms:
@@ -71,9 +70,9 @@ static ulong bytes_per_second(unsigned int len, ulong start_ms)
 {
        /* less accurate but avoids overflow */
        if (len >= ((unsigned int) -1) / 1024)
-               return len / (max(get_timer(start_ms) / 1024, 1));
+               return len / (max(get_timer(start_ms) / 1024, 1UL));
        else
-               return 1024 * len / max(get_timer(start_ms), 1);
+               return 1024 * len / max(get_timer(start_ms), 1UL);
 }
 
 static int do_spi_flash_probe(int argc, char * const argv[])
@@ -223,7 +222,7 @@ static int spi_flash_update(struct spi_flash *flash, u32 offset,
                ulong last_update = get_timer(0);
 
                for (; buf < end && !err_oper; buf += todo, offset += todo) {
-                       todo = min(end - buf, flash->sector_size);
+                       todo = min_t(size_t, end - buf, flash->sector_size);
                        if (get_timer(last_update) > 100) {
                                printf("   \rUpdating, %zu%% %lu B/s",
                                       100 - (end - buf) / scale,
@@ -421,7 +420,8 @@ static int spi_flash_test(struct spi_flash *flash, uint8_t *buf, ulong len,
        for (i = 0; i < len; i++) {
                if (vbuf[i] != 0xff) {
                        printf("Check failed at %d\n", i);
-                       print_buffer(i, vbuf + i, 1, min(len - i, 0x40), 0);
+                       print_buffer(i, vbuf + i, 1,
+                                    min_t(uint, len - i, 0x40), 0);
                        return -1;
                }
        }
@@ -443,9 +443,11 @@ static int spi_flash_test(struct spi_flash *flash, uint8_t *buf, ulong len,
        for (i = 0; i < len; i++) {
                if (buf[i] != vbuf[i]) {
                        printf("Verify failed at %d, good data:\n", i);
-                       print_buffer(i, buf + i, 1, min(len - i, 0x40), 0);
+                       print_buffer(i, buf + i, 1,
+                                    min_t(uint, len - i, 0x40), 0);
                        printf("Bad data:\n");
-                       print_buffer(i, vbuf + i, 1, min(len - i, 0x40), 0);
+                       print_buffer(i, vbuf + i, 1,
+                                    min_t(uint, len - i, 0x40), 0);
                        return -1;
                }
        }

diff --git a/common/env_nand.c b/common/env_nand.c
index 749605fe3fa89ab798a0ebde92f1f90e4a40fb2b..9c9bb82c0faf81f3d6d6295f99ecfcfd3a1cea2b 100644 (file)
--- a/common/env_nand.c
+++ b/common/env_nand.c
@@ -132,7 +132,7 @@ static int writeenv(size_t offset, u_char *buf)
        u_char *char_ptr;
 
        blocksize = nand_info[0].erasesize;
-       len = min(blocksize, CONFIG_ENV_SIZE);
+       len = min(blocksize, (size_t)CONFIG_ENV_SIZE);
 
        while (amount_saved < CONFIG_ENV_SIZE && offset < end) {
                if (nand_block_isbad(&nand_info[0], offset)) {
@@ -244,7 +244,7 @@ static int readenv(size_t offset, u_char *buf)
        if (!blocksize)
                return 1;
 
-       len = min(blocksize, CONFIG_ENV_SIZE);
+       len = min(blocksize, (size_t)CONFIG_ENV_SIZE);
 
        while (amount_loaded < CONFIG_ENV_SIZE && offset < end) {
                if (nand_block_isbad(&nand_info[0], offset)) {

diff --git a/common/fdt_support.c b/common/fdt_support.c
index 3f641566b977aff76275656c86093051d2b1217c..2d3c3870b19a3d42f0edb0e4f1f9c88272072b1e 100644 (file)
--- a/common/fdt_support.c
+++ b/common/fdt_support.c
@@ -1199,7 +1199,8 @@ int fdt_node_offset_by_compat_reg(void *blob, const char *compat,
  */
 int fdt_alloc_phandle(void *blob)
 {
-       int offset, phandle = 0;
+       int offset;
+       uint32_t phandle = 0;
 
        for (offset = fdt_next_node(blob, -1, NULL); offset >= 0;
             offset = fdt_next_node(blob, offset, NULL)) {

diff --git a/common/lcd.c b/common/lcd.c
index 37147af805ce8972081dd7a59420ecb14a2b0453..d8e13715c18f82c269cfd3b670a9567bbf895fd3 100644 (file)
--- a/common/lcd.c
+++ b/common/lcd.c
@@ -746,7 +746,7 @@ static void splash_align_axis(int *axis, unsigned long panel_size,
        else
                return;
 
-       *axis = max(0, axis_alignment);
+       *axis = max(0, (int)axis_alignment);
 }
 #endif
 
@@ -1145,8 +1145,8 @@ U_BOOT_ENV_CALLBACK(splashimage, on_splashimage);
 
 void lcd_position_cursor(unsigned col, unsigned row)
 {
-       console_col = min(col, CONSOLE_COLS - 1);
-       console_row = min(row, CONSOLE_ROWS - 1);
+       console_col = min_t(short, col, CONSOLE_COLS - 1);
+       console_row = min_t(short, row, CONSOLE_ROWS - 1);
 }
 
 int lcd_get_pixel_width(void)

diff --git a/common/usb_hub.c b/common/usb_hub.c
index 0f1eab448649541a45e674bcfbd599460cc89677..66b4a725d1b3c1d2caf0fe005fe40e036b9b251f 100644 (file)
--- a/common/usb_hub.c
+++ b/common/usb_hub.c
@@ -300,7 +300,8 @@ static int usb_hub_configure(struct usb_device *dev)
        }
        descriptor = (struct usb_hub_descriptor *)buffer;
 
-       length = min(descriptor->bLength, sizeof(struct usb_hub_descriptor));
+       length = min_t(int, descriptor->bLength,
+                      sizeof(struct usb_hub_descriptor));
 
        if (usb_get_hub_descriptor(dev, buffer, length) < 0) {
                debug("usb_hub_configure: failed to get hub " \

diff --git a/drivers/block/ahci.c b/drivers/block/ahci.c
index a93a8e1c04b797fe4d8cce58b3e232721c886519..c9a3beb79b2368d96905160052cbec38003ea2cb 100644 (file)
--- a/drivers/block/ahci.c
+++ b/drivers/block/ahci.c
@@ -730,7 +730,7 @@ static int ata_scsiop_read_write(ccb *pccb, u8 is_write)
                u16 now_blocks; /* number of blocks per iteration */
                u32 transfer_size; /* number of bytes per iteration */
 
-               now_blocks = min(MAX_SATA_BLOCKS_READ_WRITE, blocks);
+               now_blocks = min((u16)MAX_SATA_BLOCKS_READ_WRITE, blocks);
 
                transfer_size = ATA_SECT_SIZE * now_blocks;
                if (transfer_size > user_buffer_size) {

diff --git a/drivers/ddr/fsl/ctrl_regs.c b/drivers/ddr/fsl/ctrl_regs.c
index 9a156bfd5e18c41d9ddcdfb4add0f63937808e11..9e2a4d2f467ee834078369344c2bf178c9d33f9c 100644 (file)
--- a/drivers/ddr/fsl/ctrl_regs.c
+++ b/drivers/ddr/fsl/ctrl_regs.c
@@ -303,7 +303,7 @@ static void set_timing_cfg_0(fsl_ddr_cfg_regs_t *ddr,
 
 #ifdef CONFIG_SYS_FSL_DDR4
        /* tXP=max(4nCK, 6ns) */
-       int txp = max(mclk_ps * 4, 6000); /* unit=ps */
+       int txp = max((int)mclk_ps * 4, 6000); /* unit=ps */
        trwt_mclk = 2;
        twrt_mclk = 1;
        act_pd_exit_mclk = picos_to_mclk(txp);
@@ -312,7 +312,7 @@ static void set_timing_cfg_0(fsl_ddr_cfg_regs_t *ddr,
         * MRS_CYC = max(tMRD, tMOD)
         * tMRD = 8nCK, tMOD = max(24nCK, 15ns)
         */
-       tmrd_mclk = max(24, picos_to_mclk(15000));
+       tmrd_mclk = max(24U, picos_to_mclk(15000));
 #elif defined(CONFIG_SYS_FSL_DDR3)
        unsigned int data_rate = get_ddr_freq(0);
        int txp;
@@ -325,7 +325,7 @@ static void set_timing_cfg_0(fsl_ddr_cfg_regs_t *ddr,
         * spec has not the tAXPD, we use
         * tAXPD=1, need design to confirm.
         */
-       txp = max(mclk_ps * 3, (mclk_ps > 1540 ? 7500 : 6000));
+       txp = max((int)mclk_ps * 3, (mclk_ps > 1540 ? 7500 : 6000));
 
        tmrd_mclk = 4;
        /* set the turnaround time */
@@ -511,8 +511,8 @@ static void set_timing_cfg_1(fsl_ddr_cfg_regs_t *ddr,
 #ifdef CONFIG_SYS_FSL_DDR4
        refrec_ctrl = picos_to_mclk(common_dimm->trfc1_ps) - 8;
        wrrec_mclk = picos_to_mclk(common_dimm->twr_ps);
-       acttoact_mclk = max(picos_to_mclk(common_dimm->trrds_ps), 4);
-       wrtord_mclk = max(2, picos_to_mclk(2500));
+       acttoact_mclk = max(picos_to_mclk(common_dimm->trrds_ps), 4U);
+       wrtord_mclk = max(2U, picos_to_mclk(2500));
        if ((wrrec_mclk < 1) || (wrrec_mclk > 24))
                printf("Error: WRREC doesn't support %d clocks\n", wrrec_mclk);
        else
@@ -627,14 +627,14 @@ static void set_timing_cfg_2(fsl_ddr_cfg_regs_t *ddr,
        wr_data_delay = popts->write_data_delay;
 #ifdef CONFIG_SYS_FSL_DDR4
        cpo = 0;
-       cke_pls = max(3, picos_to_mclk(5000));
+       cke_pls = max(3U, picos_to_mclk(5000));
 #elif defined(CONFIG_SYS_FSL_DDR3)
        /*
         * cke pulse = max(3nCK, 7.5ns) for DDR3-800
         *             max(3nCK, 5.625ns) for DDR3-1066, 1333
         *             max(3nCK, 5ns) for DDR3-1600, 1866, 2133
         */
-       cke_pls = max(3, picos_to_mclk(mclk_ps > 1870 ? 7500 :
+       cke_pls = max(3U, picos_to_mclk(mclk_ps > 1870 ? 7500 :
                                       (mclk_ps > 1245 ? 5625 : 5000)));
 #else
        cke_pls = FSL_DDR_MIN_TCKE_PULSE_WIDTH_DDR;
@@ -1810,9 +1810,9 @@ static void set_timing_cfg_7(fsl_ddr_cfg_regs_t *ddr,
        unsigned int txpr, tcksre, tcksrx;
        unsigned int cke_rst, cksre, cksrx, par_lat, cs_to_cmd;
 
-       txpr = max(5, picos_to_mclk(common_dimm->trfc1_ps + 10000));
-       tcksre = max(5, picos_to_mclk(10000));
-       tcksrx = max(5, picos_to_mclk(10000));
+       txpr = max(5U, picos_to_mclk(common_dimm->trfc1_ps + 10000));
+       tcksre = max(5U, picos_to_mclk(10000));
+       tcksrx = max(5U, picos_to_mclk(10000));
        par_lat = 0;
        cs_to_cmd = 0;
 
@@ -1877,7 +1877,7 @@ static void set_timing_cfg_8(fsl_ddr_cfg_regs_t *ddr,
        }
 
        acttoact_bg = picos_to_mclk(common_dimm->trrdl_ps);
-       wrtord_bg = max(4, picos_to_mclk(7500));
+       wrtord_bg = max(4U, picos_to_mclk(7500));
        if (popts->otf_burst_chop_en)
                wrtord_bg += 2;
 

diff --git a/drivers/ddr/fsl/lc_common_dimm_params.c b/drivers/ddr/fsl/lc_common_dimm_params.c
index 05a24dd6efdba2658cfcf68898dd7f7948edb922..73db4446153a213f127dfa31bb0bf8bd9ef74c04 100644 (file)
--- a/drivers/ddr/fsl/lc_common_dimm_params.c
+++ b/drivers/ddr/fsl/lc_common_dimm_params.c
@@ -289,48 +289,58 @@ compute_lowest_common_dimm_parameters(const dimm_params_t *dimm_params,
                 * Find minimum tckmax_ps to find fastest slow speed,
                 * i.e., this is the slowest the whole system can go.
                 */
-               tckmax_ps = min(tckmax_ps, dimm_params[i].tckmax_ps);
+               tckmax_ps = min(tckmax_ps,
+                               (unsigned int)dimm_params[i].tckmax_ps);
 #if defined(CONFIG_SYS_FSL_DDR3) || defined(CONFIG_SYS_FSL_DDR4)
-               taamin_ps = max(taamin_ps, dimm_params[i].taa_ps);
+               taamin_ps = max(taamin_ps,
+                               (unsigned int)dimm_params[i].taa_ps);
 #endif
-               tckmin_x_ps = max(tckmin_x_ps, dimm_params[i].tckmin_x_ps);
-               trcd_ps = max(trcd_ps, dimm_params[i].trcd_ps);
-               trp_ps = max(trp_ps, dimm_params[i].trp_ps);
-               tras_ps = max(tras_ps, dimm_params[i].tras_ps);
+               tckmin_x_ps = max(tckmin_x_ps,
+                                 (unsigned int)dimm_params[i].tckmin_x_ps);
+               trcd_ps = max(trcd_ps, (unsigned int)dimm_params[i].trcd_ps);
+               trp_ps = max(trp_ps, (unsigned int)dimm_params[i].trp_ps);
+               tras_ps = max(tras_ps, (unsigned int)dimm_params[i].tras_ps);
 #ifdef CONFIG_SYS_FSL_DDR4
-               trfc1_ps = max(trfc1_ps, dimm_params[i].trfc1_ps);
-               trfc2_ps = max(trfc2_ps, dimm_params[i].trfc2_ps);
-               trfc4_ps = max(trfc4_ps, dimm_params[i].trfc4_ps);
-               trrds_ps = max(trrds_ps, dimm_params[i].trrds_ps);
-               trrdl_ps = max(trrdl_ps, dimm_params[i].trrdl_ps);
-               tccdl_ps = max(tccdl_ps, dimm_params[i].tccdl_ps);
+               trfc1_ps = max(trfc1_ps,
+                              (unsigned int)dimm_params[i].trfc1_ps);
+               trfc2_ps = max(trfc2_ps,
+                              (unsigned int)dimm_params[i].trfc2_ps);
+               trfc4_ps = max(trfc4_ps,
+                              (unsigned int)dimm_params[i].trfc4_ps);
+               trrds_ps = max(trrds_ps,
+                              (unsigned int)dimm_params[i].trrds_ps);
+               trrdl_ps = max(trrdl_ps,
+                              (unsigned int)dimm_params[i].trrdl_ps);
+               tccdl_ps = max(tccdl_ps,
+                              (unsigned int)dimm_params[i].tccdl_ps);
 #else
-               twr_ps = max(twr_ps, dimm_params[i].twr_ps);
-               twtr_ps = max(twtr_ps, dimm_params[i].twtr_ps);
-               trfc_ps = max(trfc_ps, dimm_params[i].trfc_ps);
-               trrd_ps = max(trrd_ps, dimm_params[i].trrd_ps);
-               trtp_ps = max(trtp_ps, dimm_params[i].trtp_ps);
+               twr_ps = max(twr_ps, (unsigned int)dimm_params[i].twr_ps);
+               twtr_ps = max(twtr_ps, (unsigned int)dimm_params[i].twtr_ps);
+               trfc_ps = max(trfc_ps, (unsigned int)dimm_params[i].trfc_ps);
+               trrd_ps = max(trrd_ps, (unsigned int)dimm_params[i].trrd_ps);
+               trtp_ps = max(trtp_ps, (unsigned int)dimm_params[i].trtp_ps);
 #endif
-               trc_ps = max(trc_ps, dimm_params[i].trc_ps);
+               trc_ps = max(trc_ps, (unsigned int)dimm_params[i].trc_ps);
 #if defined(CONFIG_SYS_FSL_DDR1) || defined(CONFIG_SYS_FSL_DDR2)
-               tis_ps = max(tis_ps, dimm_params[i].tis_ps);
-               tih_ps = max(tih_ps, dimm_params[i].tih_ps);
-               tds_ps = max(tds_ps, dimm_params[i].tds_ps);
-               tdh_ps = max(tdh_ps, dimm_params[i].tdh_ps);
-               tqhs_ps = max(tqhs_ps, dimm_params[i].tqhs_ps);
+               tis_ps = max(tis_ps, (unsigned int)dimm_params[i].tis_ps);
+               tih_ps = max(tih_ps, (unsigned int)dimm_params[i].tih_ps);
+               tds_ps = max(tds_ps, (unsigned int)dimm_params[i].tds_ps);
+               tdh_ps = max(tdh_ps, (unsigned int)dimm_params[i].tdh_ps);
+               tqhs_ps = max(tqhs_ps, (unsigned int)dimm_params[i].tqhs_ps);
                /*
                 * Find maximum tdqsq_max_ps to find slowest.
                 *
                 * FIXME: is finding the slowest value the correct
                 * strategy for this parameter?
                 */
-               tdqsq_max_ps = max(tdqsq_max_ps, dimm_params[i].tdqsq_max_ps);
+               tdqsq_max_ps = max(tdqsq_max_ps,
+                                  (unsigned int)dimm_params[i].tdqsq_max_ps);
 #endif
                refresh_rate_ps = max(refresh_rate_ps,
-                                     dimm_params[i].refresh_rate_ps);
+                                     (unsigned int)dimm_params[i].refresh_rate_ps);
                /* extended_op_srt is either 0 or 1, 0 having priority */
                extended_op_srt = min(extended_op_srt,
-                                     dimm_params[i].extended_op_srt);
+                                     (unsigned int)dimm_params[i].extended_op_srt);
        }
 
        outpdimm->ndimms_present = number_of_dimms - temp1;

diff --git a/drivers/ddr/fsl/main.c b/drivers/ddr/fsl/main.c
index b43b669e41ffc9be2b1bf812de30fa1eb714d6ff..6f291ebc03222c7a72f18a417f73554412b796ef 100644 (file)
--- a/drivers/ddr/fsl/main.c
+++ b/drivers/ddr/fsl/main.c
@@ -106,7 +106,8 @@ static void __get_spd(generic_spd_eeprom_t *spd, u8 i2c_address)
                i2c_write(SPD_SPA1_ADDRESS, 0, 1, &dummy, 1);
                ret = i2c_read(i2c_address, 0, 1,
                               (uchar *)((ulong)spd + 256),
-                              min(256, sizeof(generic_spd_eeprom_t) - 256));
+                              min(256,
+                                  (int)sizeof(generic_spd_eeprom_t) - 256));
        }
 #else
        ret = i2c_read(i2c_address, 0, 1, (uchar *)spd,

diff --git a/drivers/dfu/dfu.c b/drivers/dfu/dfu.c
index 55e6a83b9ad6956ccc1013bdb227d99d5f9ddfbc..c0aba6e197c5ef3ea940685f874f75dd014c4dc4 100644 (file)
--- a/drivers/dfu/dfu.c
+++ b/drivers/dfu/dfu.c
@@ -289,7 +289,7 @@ static int dfu_read_buffer_fill(struct dfu_entity *dfu, void *buf, int size)
        readn = 0;
        while (size > 0) {
                /* get chunk that can be read */
-               chunk = min(size, dfu->b_left);
+               chunk = min((long)size, dfu->b_left);
                /* consume */
                if (chunk > 0) {
                        memcpy(buf, dfu->i_buf, chunk);

diff --git a/drivers/i2c/fsl_i2c.c b/drivers/i2c/fsl_i2c.c
index 7bb1702bba283aa5b58000e12a4a3187a909137e..ff7f25a0ef7cdf2ce46cecc7954e654bc0d0d853 100644 (file)
--- a/drivers/i2c/fsl_i2c.c
+++ b/drivers/i2c/fsl_i2c.c
@@ -127,7 +127,7 @@ static const struct {
 static unsigned int set_i2c_bus_speed(const struct fsl_i2c *dev,
        unsigned int i2c_clk, unsigned int speed)
 {
-       unsigned short divider = min(i2c_clk / speed, (unsigned short) -1);
+       unsigned short divider = min(i2c_clk / speed, (unsigned int)USHRT_MAX);
 
        /*
         * We want to choose an FDR/DFSR that generates an I2C bus speed that

diff --git a/drivers/misc/cros_ec_spi.c b/drivers/misc/cros_ec_spi.c
index e403664bb561755184c60e9020e028b84169d40f..e6dba298b1e9f2a37b31b4511cf9c8902c9ff227 100644 (file)
--- a/drivers/misc/cros_ec_spi.c
+++ b/drivers/misc/cros_ec_spi.c
@@ -143,7 +143,7 @@ int cros_ec_spi_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
                return -1;
        }
 
-       len = min(p[1], din_len);
+       len = min((int)p[1], din_len);
        cros_ec_dump_data("in", -1, p, len + 3);
 
        /* Response code is first byte of message */

diff --git a/drivers/mmc/fsl_esdhc.c b/drivers/mmc/fsl_esdhc.c
index 26406072482f202a8ca6e2fa6cd8a54c87fbea4c..90b8ed01ccb033aba79a0a5cd1357a1fa2a40884 100644 (file)
--- a/drivers/mmc/fsl_esdhc.c
+++ b/drivers/mmc/fsl_esdhc.c
@@ -610,7 +610,7 @@ int fsl_esdhc_initialize(bd_t *bis, struct fsl_esdhc_cfg *cfg)
 #endif
 
        cfg->cfg.f_min = 400000;
-       cfg->cfg.f_max = min(gd->arch.sdhc_clk, 52000000);
+       cfg->cfg.f_max = min(gd->arch.sdhc_clk, (u32)52000000);
 
        cfg->cfg.b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
 

diff --git a/drivers/mmc/pxa_mmc_gen.c b/drivers/mmc/pxa_mmc_gen.c
index 1f297571e563c7c69bf653f574c890ea916ac69b..25ab0b1fc8e19b5d8213b835e3cb438f6042d2dd 100644 (file)
--- a/drivers/mmc/pxa_mmc_gen.c
+++ b/drivers/mmc/pxa_mmc_gen.c
@@ -197,7 +197,7 @@ static int pxa_mmc_do_read_xfer(struct mmc *mmc, struct mmc_data *data)
        while (len) {
                /* The controller has data ready */
                if (readl(&regs->i_reg) & MMC_I_REG_RXFIFO_RD_REQ) {
-                       size = min(len, PXAMMC_FIFO_SIZE);
+                       size = min(len, (uint32_t)PXAMMC_FIFO_SIZE);
                        len -= size;
                        size /= 4;
 
@@ -233,14 +233,14 @@ static int pxa_mmc_do_write_xfer(struct mmc *mmc, struct mmc_data *data)
        while (len) {
                /* The controller is ready to receive data */
                if (readl(&regs->i_reg) & MMC_I_REG_TXFIFO_WR_REQ) {
-                       size = min(len, PXAMMC_FIFO_SIZE);
+                       size = min(len, (uint32_t)PXAMMC_FIFO_SIZE);
                        len -= size;
                        size /= 4;
 
                        while (size--)
                                writel(*buf++, &regs->txfifo);
 
-                       if (min(len, PXAMMC_FIFO_SIZE) < 32)
+                       if (min(len, (uint32_t)PXAMMC_FIFO_SIZE) < 32)
                                writel(MMC_PRTBUF_BUF_PART_FULL, &regs->prtbuf);
                }
 

diff --git a/drivers/mtd/nand/denali_spl.c b/drivers/mtd/nand/denali_spl.c
index 65fdde8a65290eeb062f479a10ae26449d55703a..e98f537c2c36fa1d8035b4cfbc91ed2c6c0a98ee 100644 (file)
--- a/drivers/mtd/nand/denali_spl.c
+++ b/drivers/mtd/nand/denali_spl.c
@@ -203,7 +203,7 @@ int nand_spl_load_image(uint32_t offs, unsigned int size, void *dst)
                        if (ret < 0)
                                return ret;
 
-                       readlen = min(page_size - column, size);
+                       readlen = min(page_size - column, (int)size);
                        memcpy(dst, page_buffer, readlen);
 
                        column = 0;

diff --git a/drivers/mtd/spi/sandbox.c b/drivers/mtd/spi/sandbox.c
index 1cf2f98310a17493a5a99cce29caa652cb9aabd1..be6c43ed88ac34ceeab141585a7916b4ce06c17d 100644 (file)
--- a/drivers/mtd/spi/sandbox.c
+++ b/drivers/mtd/spi/sandbox.c
@@ -315,7 +315,7 @@ int sandbox_erase_part(struct sandbox_spi_flash *sbsf, int size)
        int ret;
 
        while (size > 0) {
-               todo = min(size, sizeof(sandbox_sf_0xff));
+               todo = min(size, (int)sizeof(sandbox_sf_0xff));
                ret = os_write(sbsf->fd, sandbox_sf_0xff, todo);
                if (ret != todo)
                        return ret;

diff --git a/drivers/mtd/spi/sf_ops.c b/drivers/mtd/spi/sf_ops.c
index 85cf22d42ecd08761a149639ddbc2dda47ea590a..759231f2e34b6d66f55ac38e25a85c179cd50732 100644 (file)
--- a/drivers/mtd/spi/sf_ops.c
+++ b/drivers/mtd/spi/sf_ops.c
@@ -313,10 +313,11 @@ int spi_flash_cmd_write_ops(struct spi_flash *flash, u32 offset,
                        return ret;
 #endif
                byte_addr = offset % page_size;
-               chunk_len = min(len - actual, page_size - byte_addr);
+               chunk_len = min(len - actual, (size_t)(page_size - byte_addr));
 
                if (flash->spi->max_write_size)
-                       chunk_len = min(chunk_len, flash->spi->max_write_size);
+                       chunk_len = min(chunk_len,
+                                       (size_t)flash->spi->max_write_size);
 
                spi_flash_addr(write_addr, cmd);
 

diff --git a/drivers/net/netconsole.c b/drivers/net/netconsole.c
index 623f7492c753652a8f0736658965756bd2e82438..677c89f0486f2a19f334db02b45a58a443b3e2da 100644 (file)
--- a/drivers/net/netconsole.c
+++ b/drivers/net/netconsole.c
@@ -256,7 +256,7 @@ static void nc_puts(struct stdio_dev *dev, const char *s)
 
        len = strlen(s);
        while (len) {
-               int send_len = min(len, sizeof(input_buffer));
+               int send_len = min(len, (int)sizeof(input_buffer));
                nc_send_packet(s, send_len);
                len -= send_len;
                s += send_len;

diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 60c333e2c0191d5ef8753075669a7edc3af95532..5d547901b81659e43d86c291a252eaa7ded9b10b 100644 (file)
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -662,13 +662,15 @@ int pci_hose_scan_bus(struct pci_controller *hose, int bus)
 #endif
 
 #ifdef CONFIG_PCI_PNP
-               sub_bus = max(pciauto_config_device(hose, dev), sub_bus);
+               sub_bus = max((unsigned int)pciauto_config_device(hose, dev),
+                             sub_bus);
 #else
                cfg = pci_find_config(hose, class, vendor, device,
                                      PCI_BUS(dev), PCI_DEV(dev), PCI_FUNC(dev));
                if (cfg) {
                        cfg->config_device(hose, dev, cfg);
-                       sub_bus = max(sub_bus, hose->current_busno);
+                       sub_bus = max(sub_bus,
+                                     (unsigned int)hose->current_busno);
                }
 #endif
 

diff --git a/drivers/pci/pci_auto.c b/drivers/pci/pci_auto.c
index 86ba6b523c11da2f7eb5ed47fe31b7798d1f59d1..44470fa812b0ed42ca475bb27262d1b7be0fb733 100644 (file)
--- a/drivers/pci/pci_auto.c
+++ b/drivers/pci/pci_auto.c
@@ -387,7 +387,7 @@ int pciauto_config_device(struct pci_controller *hose, pci_dev_t dev)
                n = pci_hose_scan_bus(hose, hose->current_busno);
 
                /* figure out the deepest we've gone for this leg */
-               sub_bus = max(n, sub_bus);
+               sub_bus = max((unsigned int)n, sub_bus);
                pciauto_postscan_setup_bridge(hose, dev, sub_bus);
 
                sub_bus = hose->current_busno;

diff --git a/drivers/serial/usbtty.c b/drivers/serial/usbtty.c
index 7fb0b92078d327782e18f2004ea12b6808f35f91..75f0ec31bbfb9a6faedeaf9cf137ea1212ceefd5 100644 (file)
--- a/drivers/serial/usbtty.c
+++ b/drivers/serial/usbtty.c
@@ -882,7 +882,7 @@ static int write_buffer (circbuf_t * buf)
                        space_avail =
                                current_urb->buffer_length -
                                current_urb->actual_length;
-                       popnum = min(space_avail, buf->size);
+                       popnum = min(space_avail, (int)buf->size);
                        if (popnum == 0)
                                break;
 

diff --git a/drivers/spi/fsl_espi.c b/drivers/spi/fsl_espi.c
index ae0fe58f2c06400e2cebfbd3b9bc680354ae99be..375dc07f5f47f521d51544dd337a058873809a59 100644 (file)
--- a/drivers/spi/fsl_espi.c
+++ b/drivers/spi/fsl_espi.c
@@ -273,7 +273,7 @@ int spi_xfer(struct spi_slave *slave, unsigned int bitlen, const void *data_out,
                        spi_cs_deactivate(slave);
                        return 0;
                }
-               buf_len = 2 * cmd_len + min(data_len, max_tran_len);
+               buf_len = 2 * cmd_len + min(data_len, (size_t)max_tran_len);
                len = cmd_len + data_len;
                rx_offset = cmd_len;
                buffer = (unsigned char *)malloc(buf_len);
@@ -306,7 +306,7 @@ int spi_xfer(struct spi_slave *slave, unsigned int bitlen, const void *data_out,
                if (data_in)
                        din = buffer + rx_offset;
                dout = buffer;
-               tran_len = min(data_len , max_tran_len);
+               tran_len = min(data_len, (size_t)max_tran_len);
                num_blks = DIV_ROUND_UP(tran_len + cmd_len, 4);
                num_bytes = (tran_len + cmd_len) % 4;
                fsl->data_len = tran_len + cmd_len;

diff --git a/drivers/spi/mxc_spi.c b/drivers/spi/mxc_spi.c
index 23f2ba6223dce6d089ac6af3ac153b19d4e79844..08815994fe5d21d0effd00394cea05ce6698508c 100644 (file)
--- a/drivers/spi/mxc_spi.c
+++ b/drivers/spi/mxc_spi.c
@@ -315,7 +315,7 @@ int spi_xchg_single(struct spi_slave *slave, unsigned int bitlen,
                tmp = reg_read(&regs->rxdata);
                data = cpu_to_be32(tmp);
                debug("SPI Rx: 0x%x 0x%x\n", tmp, data);
-               cnt = min(nbytes, sizeof(data));
+               cnt = min_t(u32, nbytes, sizeof(data));
                if (din) {
                        memcpy(din, &data, cnt);
                        din += cnt;

diff --git a/drivers/spi/spi-uclass.c b/drivers/spi/spi-uclass.c
index 13c6b77d73df350f943b1dd3c77ce8c7e0fef0c3..637d420a3b2120be60cee9e751ff63403f6fd904 100644 (file)
--- a/drivers/spi/spi-uclass.c
+++ b/drivers/spi/spi-uclass.c
@@ -57,7 +57,7 @@ int spi_claim_bus(struct spi_slave *slave)
        speed = slave->max_hz;
        if (spi->max_hz) {
                if (speed)
-                       speed = min(speed, spi->max_hz);
+                       speed = min(speed, (int)spi->max_hz);
                else
                        speed = spi->max_hz;
        }

diff --git a/drivers/tpm/tpm_tis_lpc.c b/drivers/tpm/tpm_tis_lpc.c
index eecf18cbf920ebe7721bea11178b5dbf5068b095..d09f8cee05b0940ea32c7707e5aeb4a1e6d2e90e 100644 (file)
--- a/drivers/tpm/tpm_tis_lpc.c
+++ b/drivers/tpm/tpm_tis_lpc.c
@@ -274,7 +274,7 @@ static u32 tis_senddata(const u8 * const data, u32 len)
                 * changes to zero exactly after the last byte is fed into the
                 * FIFO.
                 */
-               count = min(burst, len - offset - 1);
+               count = min((u32)burst, len - offset - 1);
                while (count--)
                        tpm_write_byte(data[offset++],
                                  &lpc_tpm_dev[locality].data);

diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index 7bd25629c8ca5124b009df2b06dd423334ed7898..a4c5606527a824bca5f53a5c7514d38e2d530f8b 100644 (file)
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -743,8 +743,8 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                        if (!gadget_is_dualspeed(gadget))
                                break;
                        device_qual(cdev);
-                       value = min(w_length,
-                               sizeof(struct usb_qualifier_descriptor));
+                       value = min_t(int, w_length,
+                                     sizeof(struct usb_qualifier_descriptor));
                        break;
                case USB_DT_OTHER_SPEED_CONFIG:
                        if (!gadget_is_dualspeed(gadget))

diff --git a/drivers/usb/gadget/designware_udc.c b/drivers/usb/gadget/designware_udc.c
index 3559400b284778d838f20cedc9043a29767e26c6..0db7a3b6c15566b65b4d7260603a30c59284b43f 100644 (file)
--- a/drivers/usb/gadget/designware_udc.c
+++ b/drivers/usb/gadget/designware_udc.c
@@ -269,8 +269,8 @@ static void dw_write_noniso_tx_fifo(struct usb_endpoint_instance
                UDCDBGA("urb->buffer %p, buffer_length %d, actual_length %d",
                        urb->buffer, urb->buffer_length, urb->actual_length);
 
-               last = min(urb->actual_length - endpoint->sent,
-                          endpoint->tx_packetSize);
+               last = min_t(u32, urb->actual_length - endpoint->sent,
+                            endpoint->tx_packetSize);
 
                if (last) {
                        u8 *cp = urb->buffer + endpoint->sent;

diff --git a/drivers/usb/gadget/pxa27x_udc.c b/drivers/usb/gadget/pxa27x_udc.c
index efd5c7fda146177cb521dd819fcae332679a60bb..942355528084b0022c475b5e35d3b136f6957e2c 100644 (file)
--- a/drivers/usb/gadget/pxa27x_udc.c
+++ b/drivers/usb/gadget/pxa27x_udc.c
@@ -65,7 +65,8 @@ static int udc_write_urb(struct usb_endpoint_instance *endpoint)
        if (!urb || !urb->actual_length)
                return -1;
 
-       n = min(urb->actual_length - endpoint->sent, endpoint->tx_packetSize);
+       n = min_t(unsigned int, urb->actual_length - endpoint->sent,
+                 endpoint->tx_packetSize);
        if (n <= 0)
                return -1;
 

diff --git a/drivers/usb/gadget/s3c_udc_otg_xfer_dma.c b/drivers/usb/gadget/s3c_udc_otg_xfer_dma.c
index 9c54b462c4ee5bb681832796c11395732df28500..7e7a2c2d906d73ec7f9a4753e9731955c191c2f9 100644 (file)
--- a/drivers/usb/gadget/s3c_udc_otg_xfer_dma.c
+++ b/drivers/usb/gadget/s3c_udc_otg_xfer_dma.c
@@ -97,8 +97,8 @@ static int setdma_rx(struct s3c_ep *ep, struct s3c_request *req)
        u32 ep_num = ep_index(ep);
 
        buf = req->req.buf + req->req.actual;
-       length = min(req->req.length - req->req.actual,
-                    ep_num ? DMA_BUFFER_SIZE : ep->ep.maxpacket);
+       length = min_t(u32, req->req.length - req->req.actual,
+                      ep_num ? DMA_BUFFER_SIZE : ep->ep.maxpacket);
 
        ep->len = length;
        ep->dma_buf = buf;

diff --git a/drivers/usb/host/dwc2.c b/drivers/usb/host/dwc2.c
index 2a5bbf5ac0e9be839f19a7cb7149927e0e9a1f30..e8142ac0922f1974c2b36c00de24eaa223d11215 100644 (file)
--- a/drivers/usb/host/dwc2.c
+++ b/drivers/usb/host/dwc2.c
@@ -503,23 +503,23 @@ static int dwc_otg_submit_rh_msg_in_descriptor(struct usb_device *dev,
        case 0:
                switch (wValue & 0xff00) {
                case 0x0100:    /* device descriptor */
-                       len = min3(txlen, sizeof(root_hub_dev_des), wLength);
+                       len = min3(txlen, (int)sizeof(root_hub_dev_des), (int)wLength);
                        memcpy(buffer, root_hub_dev_des, len);
                        break;
                case 0x0200:    /* configuration descriptor */
-                       len = min3(txlen, sizeof(root_hub_config_des), wLength);
+                       len = min3(txlen, (int)sizeof(root_hub_config_des), (int)wLength);
                        memcpy(buffer, root_hub_config_des, len);
                        break;
                case 0x0300:    /* string descriptors */
                        switch (wValue & 0xff) {
                        case 0x00:
-                               len = min3(txlen, sizeof(root_hub_str_index0),
-                                          wLength);
+                               len = min3(txlen, (int)sizeof(root_hub_str_index0),
+                                          (int)wLength);
                                memcpy(buffer, root_hub_str_index0, len);
                                break;
                        case 0x01:
-                               len = min3(txlen, sizeof(root_hub_str_index1),
-                                          wLength);
+                               len = min3(txlen, (int)sizeof(root_hub_str_index1),
+                                          (int)wLength);
                                memcpy(buffer, root_hub_str_index1, len);
                                break;
                        }
@@ -556,7 +556,7 @@ static int dwc_otg_submit_rh_msg_in_descriptor(struct usb_device *dev,
                        data[10] = data[9];
                }
 
-               len = min3(txlen, data[0], wLength);
+               len = min3(txlen, (int)data[0], (int)wLength);
                memcpy(buffer, data, len);
                break;
        default:

diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index c671c72cb1cfc014a00b47b8b7ad38c1a52e5b0f..5520805af37a1c99b84843535d10b7e78496b452 100644 (file)
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -910,7 +910,7 @@ ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *buffer,
        }
 
        mdelay(1);
-       len = min3(srclen, le16_to_cpu(req->length), length);
+       len = min3(srclen, (int)le16_to_cpu(req->length), length);
        if (srcptr != NULL && len > 0)
                memcpy(buffer, srcptr, len);
        else

diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 19c3ec62118d95c77957679de5cca93368ab24a3..b5aade988d484691d61065de2af4040e8739ed53 100644 (file)
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -511,7 +511,7 @@ static void record_transfer_result(struct usb_device *udev,
                                   union xhci_trb *event, int length)
 {
        udev->act_len = min(length, length -
-               EVENT_TRB_LEN(le32_to_cpu(event->trans_event.transfer_len)));
+               (int)EVENT_TRB_LEN(le32_to_cpu(event->trans_event.transfer_len)));
 
        switch (GET_COMP_CODE(le32_to_cpu(event->trans_event.transfer_len))) {
        case COMP_SUCCESS:

diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 59dc096b0c3200c14c6cc39e9465c9af8e4b7578..87f2972cb266593fd6001c6be8aa9aefa37cfd97 100644 (file)
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -829,7 +829,7 @@ static int xhci_submit_root(struct usb_device *udev, unsigned long pipe,
        debug("scrlen = %d\n req->length = %d\n",
                srclen, le16_to_cpu(req->length));
 
-       len = min(srclen, le16_to_cpu(req->length));
+       len = min(srclen, (int)le16_to_cpu(req->length));
 
        if (srcptr != NULL && len > 0)
                memcpy(buffer, srcptr, len);

diff --git a/drivers/video/cfb_console.c b/drivers/video/cfb_console.c
index a347e13d7de8fa5fc360524a76afdd85c70cb26e..a653bb4168551b78272f8f4f6ee087d63c7fec4b 100644 (file)
--- a/drivers/video/cfb_console.c
+++ b/drivers/video/cfb_console.c
@@ -1541,14 +1541,14 @@ int video_display_bitmap(ulong bmp_image, int x, int y)
 
 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
        if (x == BMP_ALIGN_CENTER)
-               x = max(0, (VIDEO_VISIBLE_COLS - width) / 2);
+               x = max(0, (int)(VIDEO_VISIBLE_COLS - width) / 2);
        else if (x < 0)
-               x = max(0, VIDEO_VISIBLE_COLS - width + x + 1);
+               x = max(0, (int)(VIDEO_VISIBLE_COLS - width + x + 1));
 
        if (y == BMP_ALIGN_CENTER)
-               y = max(0, (VIDEO_VISIBLE_ROWS - height) / 2);
+               y = max(0, (int)(VIDEO_VISIBLE_ROWS - height) / 2);
        else if (y < 0)
-               y = max(0, VIDEO_VISIBLE_ROWS - height + y + 1);
+               y = max(0, (int)(VIDEO_VISIBLE_ROWS - height + y + 1));
 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
 
        /*
@@ -1874,14 +1874,14 @@ static void plot_logo_or_black(void *screen, int width, int x, int y, int black)
 
 #ifdef CONFIG_SPLASH_SCREEN_ALIGN
        if (x == BMP_ALIGN_CENTER)
-               x = max(0, (VIDEO_VISIBLE_COLS - VIDEO_LOGO_WIDTH) / 2);
+               x = max(0, (int)(VIDEO_VISIBLE_COLS - VIDEO_LOGO_WIDTH) / 2);
        else if (x < 0)
-               x = max(0, VIDEO_VISIBLE_COLS - VIDEO_LOGO_WIDTH + x + 1);
+               x = max(0, (int)(VIDEO_VISIBLE_COLS - VIDEO_LOGO_WIDTH + x + 1));
 
        if (y == BMP_ALIGN_CENTER)
-               y = max(0, (VIDEO_VISIBLE_ROWS - VIDEO_LOGO_HEIGHT) / 2);
+               y = max(0, (int)(VIDEO_VISIBLE_ROWS - VIDEO_LOGO_HEIGHT) / 2);
        else if (y < 0)
-               y = max(0, VIDEO_VISIBLE_ROWS - VIDEO_LOGO_HEIGHT + y + 1);
+               y = max(0, (int)(VIDEO_VISIBLE_ROWS - VIDEO_LOGO_HEIGHT + y + 1));
 #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
 
        dest = (unsigned char *)screen + (y * width  + x) * VIDEO_PIXEL_SIZE;
@@ -2028,7 +2028,7 @@ static void *video_logo(void)
                 * we need to adjust the logo height
                 */
                if (video_logo_ypos == BMP_ALIGN_CENTER)
-                       video_logo_height += max(0, (VIDEO_VISIBLE_ROWS - \
+                       video_logo_height += max(0, (int)(VIDEO_VISIBLE_ROWS -
                                                     VIDEO_LOGO_HEIGHT) / 2);
                else if (video_logo_ypos > 0)
                        video_logo_height += video_logo_ypos;

diff --git a/fs/ext4/dev.c b/fs/ext4/dev.c
index e0b513a4efb9f595ccec817bd5cce5c2c7b9ff6b..c77c02cdfce262cdb6910a4746b149f2b9f0d07f 100644 (file)
--- a/fs/ext4/dev.c
+++ b/fs/ext4/dev.c
@@ -73,6 +73,7 @@ int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf)
        debug(" <" LBAFU ", %d, %d>\n", sector, byte_offset, byte_len);
 
        if (byte_offset != 0) {
+               int readlen;
                /* read first part which isn't aligned with start of sector */
                if (ext4fs_block_dev_desc->
                    block_read(ext4fs_block_dev_desc->dev,
@@ -81,13 +82,11 @@ int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf)
                        printf(" ** ext2fs_devread() read error **\n");
                        return 0;
                }
-               memcpy(buf, sec_buf + byte_offset,
-                       min(ext4fs_block_dev_desc->blksz
-                           - byte_offset, byte_len));
-               buf += min(ext4fs_block_dev_desc->blksz
-                          - byte_offset, byte_len);
-               byte_len -= min(ext4fs_block_dev_desc->blksz
-                               - byte_offset, byte_len);
+               readlen = min((int)ext4fs_block_dev_desc->blksz - byte_offset,
+                             byte_len);
+               memcpy(buf, sec_buf + byte_offset, readlen);
+               buf += readlen;
+               byte_len -= readlen;
                sector++;
        }
 

diff --git a/fs/fat/fat.c b/fs/fat/fat.c
index 561921fa2d364e548629fe8152cb953861699b3f..0481de3eb029decb4c0b58ef98229c7d7b2b8993 100644 (file)
--- a/fs/fat/fat.c
+++ b/fs/fat/fat.c
@@ -364,7 +364,7 @@ get_contents(fsdata *mydata, dir_entry *dentptr, unsigned long pos,
 
        /* align to beginning of next cluster if any */
        if (pos) {
-               actsize = min(filesize, bytesperclust);
+               actsize = min(filesize, (unsigned long)bytesperclust);
                if (get_cluster(mydata, curclust, get_contents_vfatname_block,
                                (int)actsize) != 0) {
                        printf("Error reading cluster\n");

diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 0e838de094569ac5b2ede26846ac248e6a37ab81..89fcae0983c1d011cc2420efe1dec837c8f3e1a7 100644 (file)
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -150,26 +150,17 @@
 #define min(x, y) ({                           \
        typeof(x) _min1 = (x);                  \
        typeof(y) _min2 = (y);                  \
+       (void) (&_min1 == &_min2);              \
        _min1 < _min2 ? _min1 : _min2; })
 
 #define max(x, y) ({                           \
        typeof(x) _max1 = (x);                  \
        typeof(y) _max2 = (y);                  \
+       (void) (&_max1 == &_max2);              \
        _max1 > _max2 ? _max1 : _max2; })
 
-#define min3(x, y, z) ({                       \
-       typeof(x) _min1 = (x);                  \
-       typeof(y) _min2 = (y);                  \
-       typeof(z) _min3 = (z);                  \
-       _min1 < _min2 ? (_min1 < _min3 ? _min1 : _min3) : \
-               (_min2 < _min3 ? _min2 : _min3); })
-
-#define max3(x, y, z) ({                       \
-       typeof(x) _max1 = (x);                  \
-       typeof(y) _max2 = (y);                  \
-       typeof(z) _max3 = (z);                  \
-       _max1 > _max2 ? (_max1 > _max3 ? _max1 : _max3) : \
-               (_max2 > _max3 ? _max2 : _max3); })
+#define min3(x, y, z) min((typeof(x))min(x, y), z)
+#define max3(x, y, z) max((typeof(x))max(x, y), z)
 
 /**
  * min_not_zero - return the minimum that is _not_ zero, unless both are zero