litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Linus Torvalds <torvalds@linux-foundation.org>	2009-10-13 13:21:12 -0400
committer	Linus Torvalds <torvalds@linux-foundation.org>	2009-10-13 13:21:12 -0400
commit	a3bafbbbb5ac49355aa35e6a722eac6ef1dff19a (patch)
tree	445f7f2b241793210ca38a5a56f1f1381537ecdc /mm
parent	25d591587d3b0676fb89c29e7e55fe4a08597ec1 (diff)
parent	1a0c3298d6c6bfc357c38772e7f32d193c60c77d (diff)

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/percpu

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/percpu: percpu: fix compile warnings

Diffstat (limited to 'mm')

-rw-r--r--

mm/percpu.c

1 files changed, 3 insertions, 2 deletions

         max_distance = 0;
         for (group = 0; group < ai->nr_groups; group++) {
                 ai->groups[group].base_offset = areas[group] - base;
-                max_distance = max(max_distance, ai->groups[group].base_offset);
+                max_distance = max_t(size_t, max_distance,
+                                     ai->groups[group].base_offset);
         }
         max_distance += ai->unit_size;
         /* warn if maximum distance is further than 75% of vmalloc space */
         if (max_distance > (VMALLOC_END - VMALLOC_START) * 3 / 4) {
-                pr_warning("PERCPU: max_distance=0x%lx too large for vmalloc "
+                pr_warning("PERCPU: max_distance=0x%zx too large for vmalloc "
                            "space 0x%lx\n",
                            max_distance, VMALLOC_END - VMALLOC_START);
 #ifdef CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK

/* * Copyright (C) ST-Ericsson SA 2010 * * License Terms: GNU General Public License, version 2 * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson */ #include <linux/kernel.h> #include <linux/module.h> #include <linux/interrupt.h> #include <linux/irq.h> #include <linux/slab.h> #include <linux/i2c.h> #include <linux/mfd/core.h> #include <linux/mfd/stmpe.h> #include "stmpe.h" static int __stmpe_enable(struct stmpe *stmpe, unsigned int blocks) { return stmpe->variant->enable(stmpe, blocks, true); } static int __stmpe_disable(struct stmpe *stmpe, unsigned int blocks) { return stmpe->variant->enable(stmpe, blocks, false); } static int __stmpe_reg_read(struct stmpe *stmpe, u8 reg) { int ret; ret = i2c_smbus_read_byte_data(stmpe->i2c, reg); if (ret < 0) dev_err(stmpe->dev, "failed to read reg %#x: %d\n", reg, ret); dev_vdbg(stmpe->dev, "rd: reg %#x => data %#x\n", reg, ret); return ret; } static int __stmpe_reg_write(struct stmpe *stmpe, u8 reg, u8 val) { int ret; dev_vdbg(stmpe->dev, "wr: reg %#x <= %#x\n", reg, val); ret = i2c_smbus_write_byte_data(stmpe->i2c, reg, val); if (ret < 0) dev_err(stmpe->dev, "failed to write reg %#x: %d\n", reg, ret); return ret; } static int __stmpe_set_bits(struct stmpe *stmpe, u8 reg, u8 mask, u8 val) { int ret; ret = __stmpe_reg_read(stmpe, reg); if (ret < 0) return ret; ret &= ~mask; ret |= val; return __stmpe_reg_write(stmpe, reg, ret); } static int __stmpe_block_read(struct stmpe *stmpe, u8 reg, u8 length, u8 *values) { int ret; ret = i2c_smbus_read_i2c_block_data(stmpe->i2c, reg, length, values); if (ret < 0) dev_err(stmpe->dev, "failed to read regs %#x: %d\n", reg, ret); dev_vdbg(stmpe->dev, "rd: reg %#x (%d) => ret %#x\n", reg, length, ret); stmpe_dump_bytes("stmpe rd: ", values, length); return ret; } static int __stmpe_block_write(struct stmpe *stmpe, u8 reg, u8 length, const u8 *values) { int ret; dev_vdbg(stmpe->dev, "wr: regs %#x (%d)\n", reg, length); stmpe_dump_bytes("stmpe wr: ", values, length); ret = i2c_smbus_write_i2c_block_data(stmpe->i2c, reg, length, values); if (ret < 0) dev_err(stmpe->dev, "failed to write regs %#x: %d\n", reg, ret); return ret; } /** * stmpe_enable - enable blocks on an STMPE device * @stmpe: Device to work on * @blocks: Mask of blocks (enum stmpe_block values) to enable */ int stmpe_enable(struct stmpe *stmpe, unsigned int blocks) { int ret; mutex_lock(&stmpe->lock); ret = __stmpe_enable(stmpe, blocks); mutex_unlock(&stmpe->lock); return ret; } EXPORT_SYMBOL_GPL(stmpe_enable); /** * stmpe_disable - disable blocks on an STMPE device * @stmpe: Device to work on * @blocks: Mask of blocks (enum stmpe_block values) to enable */ int stmpe_disable(struct stmpe *stmpe, unsigned int blocks) { int ret; mutex_lock(&stmpe->lock); ret = __stmpe_disable(stmpe, blocks); mutex_unlock(&stmpe->lock); return ret; } EXPORT_SYMBOL_GPL(stmpe_disable); /** * stmpe_reg_read() - read a single STMPE register * @stmpe: Device to read from * @reg: Register to read */ int stmpe_reg_read(struct stmpe *stmpe, u8 reg) { int ret; mutex_lock(&stmpe->lock); ret = __stmpe_reg_read(stmpe, reg); mutex_unlock(&stmpe->lock); return ret; } EXPORT_SYMBOL_GPL(stmpe_reg_read); /** * stmpe_reg_write() - write a single STMPE register * @stmpe: Device to write to * @reg: Register to write * @val: Value to write */ int stmpe_reg_write(struct stmpe *stmpe, u8 reg, u8 val) { int ret; mutex_lock(&stmpe->lock); ret = __stmpe_reg_write(stmpe, reg, val); mutex_unlock(&stmpe->lock); return ret; } EXPORT_SYMBOL_GPL(stmpe_reg_write); /** * stmpe_set_bits() - set the value of a bitfield in a STMPE register * @stmpe: Device to write to * @reg: Register to write * @mask: Mask of bits to set * @val: Value to set */ int stmpe_set_bits(struct stmpe *stmpe, u8 reg, u8 mask, u8 val) { int ret; mutex_lock(&stmpe->lock); ret = __stmpe_set_bits(stmpe, reg, mask, val); mutex_unlock(&stmpe->lock); return ret; } EXPORT_SYMBOL_GPL(stmpe_set_bits); /** * stmpe_block_read() - read multiple STMPE registers * @stmpe: Device to read from * @reg: First register * @length: Number of registers * @values: Buffer to write to */ int stmpe_block_read(struct stmpe *stmpe, u8 reg, u8 length, u8 *values) { int ret; mutex_lock(&stmpe->lock); ret = __stmpe_block_read(stmpe, reg, length, values); mutex_unlock(&stmpe->lock); return ret; } EXPORT_SYMBOL_GPL(stmpe_block_read); /** * stmpe_block_write() - write multiple STMPE registers * @stmpe: Device to write to * @reg: First register * @length: Number of registers * @values: Values to write */ int stmpe_block_write(struct stmpe *stmpe, u8 reg, u8 length, const u8 *values) { int ret; mutex_lock(&stmpe->lock); ret = __stmpe_block_write(stmpe, reg, length, values); mutex_unlock(&stmpe->lock); return ret; } EXPORT_SYMBOL_GPL(stmpe_block_write); /** * stmpe_set_altfunc: set the alternate function for STMPE pins * @stmpe: Device to configure * @pins: Bitmask of pins to affect * @block: block to enable alternate functions for * * @pins is assumed to have a bit set for each of the bits whose alternate * function is to be changed, numbered according to the GPIOXY numbers. * * If the GPIO module is not enabled, this function automatically enables it in * order to perform the change. */ int stmpe_set_altfunc(struct stmpe *stmpe, u32 pins, enum stmpe_block block) { struct stmpe_variant_info *variant = stmpe->variant; u8 regaddr = stmpe->regs[STMPE_IDX_GPAFR_U_MSB]; int af_bits = variant->af_bits; int numregs = DIV_ROUND_UP(stmpe->num_gpios * af_bits, 8); int afperreg = 8 / af_bits; int mask = (1 << af_bits) - 1; u8 regs[numregs]; int af; int ret; mutex_lock(&stmpe->lock); ret = __stmpe_enable(stmpe, STMPE_BLOCK_GPIO); if (ret < 0) goto out; ret = __stmpe_block_read(stmpe, regaddr, numregs, regs); if (ret < 0) goto out; af = variant->get_altfunc(stmpe, block); while (pins) { int pin = __ffs(pins); int regoffset = numregs - (pin / afperreg) - 1; int pos = (pin % afperreg) * (8 / afperreg); regs[regoffset] &= ~(mask << pos); regs[regoffset] |= af << pos; pins &= ~(1 << pin); } ret = __stmpe_block_write(stmpe, regaddr, numregs, regs); out: mutex_unlock(&stmpe->lock); return ret; } EXPORT_SYMBOL_GPL(stmpe_set_altfunc); /* * GPIO (all variants) */ static struct resource stmpe_gpio_resources[] = { /* Start and end filled dynamically */ { .flags = IORESOURCE_IRQ, }, }; static struct mfd_cell stmpe_gpio_cell = { .name = "stmpe-gpio", .resources = stmpe_gpio_resources, .num_resources = ARRAY_SIZE(stmpe_gpio_resources), }; /* * Keypad (1601, 2401, 2403) */ static struct resource stmpe_keypad_resources[] = { { .name = "KEYPAD", .start = 0, .end = 0, .flags = IORESOURCE_IRQ, }, { .name = "KEYPAD_OVER", .start = 1, .end = 1, .flags = IORESOURCE_IRQ, }, }; static struct mfd_cell stmpe_keypad_cell = { .name = "stmpe-keypad", .resources = stmpe_keypad_resources, .num_resources = ARRAY_SIZE(stmpe_keypad_resources), }; /* * Touchscreen (STMPE811) */ static struct resource stmpe_ts_resources[] = { { .name = "TOUCH_DET", .start = 0, .end = 0, .flags = IORESOURCE_IRQ, }, { .name = "FIFO_TH", .start = 1, .end = 1, .flags = IORESOURCE_IRQ, }, }; static struct mfd_cell stmpe_ts_cell = { .name = "stmpe-ts", .resources = stmpe_ts_resources, .num_resources = ARRAY_SIZE(stmpe_ts_resources), }; /* * STMPE811 */ static const u8 stmpe811_regs[] = { [STMPE_IDX_CHIP_ID] = STMPE811_REG_CHIP_ID, [STMPE_IDX_ICR_LSB] = STMPE811_REG_INT_CTRL, [STMPE_IDX_IER_LSB] = STMPE811_REG_INT_EN, [STMPE_IDX_ISR_MSB] = STMPE811_REG_INT_STA, [STMPE_IDX_GPMR_LSB] = STMPE811_REG_GPIO_MP_STA, [STMPE_IDX_GPSR_LSB] = STMPE811_REG_GPIO_SET_PIN, [STMPE_IDX_GPCR_LSB] = STMPE811_REG_GPIO_CLR_PIN, [STMPE_IDX_GPDR_LSB] = STMPE811_REG_GPIO_DIR, [STMPE_IDX_GPRER_LSB] = STMPE811_REG_GPIO_RE, [STMPE_IDX_GPFER_LSB] = STMPE811_REG_GPIO_FE, [STMPE_IDX_GPAFR_U_MSB] = STMPE811_REG_GPIO_AF, [STMPE_IDX_IEGPIOR_LSB] = STMPE811_REG_GPIO_INT_EN, [STMPE_IDX_ISGPIOR_MSB] = STMPE811_REG_GPIO_INT_STA, [STMPE_IDX_GPEDR_MSB] = STMPE811_REG_GPIO_ED, }; static struct stmpe_variant_block stmpe811_blocks[] = { { .cell = &stmpe_gpio_cell, .irq = STMPE811_IRQ_GPIOC, .block = STMPE_BLOCK_GPIO, }, { .cell = &stmpe_ts_cell, .irq = STMPE811_IRQ_TOUCH_DET, .block = STMPE_BLOCK_TOUCHSCREEN, }, }; static int stmpe811_enable(struct stmpe *stmpe, unsigned int blocks, bool enable) { unsigned int mask = 0; if (blocks & STMPE_BLOCK_GPIO) mask |= STMPE811_SYS_CTRL2_GPIO_OFF; if (blocks & STMPE_BLOCK_ADC) mask |= STMPE811_SYS_CTRL2_ADC_OFF; if (blocks & STMPE_BLOCK_TOUCHSCREEN) mask |= STMPE811_SYS_CTRL2_TSC_OFF; return __stmpe_set_bits(stmpe, STMPE811_REG_SYS_CTRL2, mask, enable ? 0 : mask); } static int stmpe811_get_altfunc(struct stmpe *stmpe, enum stmpe_block block) { /* 0 for touchscreen, 1 for GPIO */ return block != STMPE_BLOCK_TOUCHSCREEN; } static struct stmpe_variant_info stmpe811 = { .name = "stmpe811", .id_val = 0x0811, .id_mask = 0xffff, .num_gpios = 8, .af_bits = 1, .regs = stmpe811_regs, .blocks = stmpe811_blocks, .num_blocks = ARRAY_SIZE(stmpe811_blocks), .num_irqs = STMPE811_NR_INTERNAL_IRQS, .enable = stmpe811_enable, .get_altfunc = stmpe811_get_altfunc, }; /* * STMPE1601 */ static const u8 stmpe1601_regs[] = { [STMPE_IDX_CHIP_ID] = STMPE1601_REG_CHIP_ID, [STMPE_IDX_ICR_LSB] = STMPE1601_REG_ICR_LSB, [STMPE_IDX_IER_LSB] = STMPE1601_REG_IER_LSB, [STMPE_IDX_ISR_MSB] = STMPE1601_REG_ISR_MSB, [STMPE_IDX_GPMR_LSB] = STMPE1601_REG_GPIO_MP_LSB, [STMPE_IDX_GPSR_LSB] = STMPE1601_REG_GPIO_SET_LSB, [STMPE_IDX_GPCR_LSB] = STMPE1601_REG_GPIO_CLR_LSB, [STMPE_IDX_GPDR_LSB] = STMPE1601_REG_GPIO_SET_DIR_LSB, [STMPE_IDX_GPRER_LSB] = STMPE1601_REG_GPIO_RE_LSB, [STMPE_IDX_GPFER_LSB] = STMPE1601_REG_GPIO_FE_LSB, [STMPE_IDX_GPAFR_U_MSB] = STMPE1601_REG_GPIO_AF_U_MSB, [STMPE_IDX_IEGPIOR_LSB] = STMPE1601_REG_INT_EN_GPIO_MASK_LSB, [STMPE_IDX_ISGPIOR_MSB] = STMPE1601_REG_INT_STA_GPIO_MSB, [STMPE_IDX_GPEDR_MSB] = STMPE1601_REG_GPIO_ED_MSB, }; static struct stmpe_variant_block stmpe1601_blocks[] = { { .cell = &stmpe_gpio_cell, .irq = STMPE24XX_IRQ_GPIOC, .block = STMPE_BLOCK_GPIO, }, { .cell = &stmpe_keypad_cell, .irq = STMPE24XX_IRQ_KEYPAD, .block = STMPE_BLOCK_KEYPAD, }, };


context:
space:
mode: