Merge git://git.kernel.org/pub/scm/linux/kernel/git/wim/linux-2.6-watchdog
authorLinus Torvalds <torvalds@linux-foundation.org>
Thu, 28 Oct 2010 22:47:21 +0000 (15:47 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Thu, 28 Oct 2010 22:47:21 +0000 (15:47 -0700)
* git://git.kernel.org/pub/scm/linux/kernel/git/wim/linux-2.6-watchdog:
  watchdog: iTCO_wdt.c: remove extra pci_dev_put()'s from init code
  watchdog: add support for Broadcom BCM63xx built-in watchdog
  watchdog: f71808e_wdt: add support for the F71889FG
  watchdog: MachZ: fix debug macro
  watchdog: it8712f_wdt: Add module parameter for alternative reset sources
  watchdog: it8712f_wdt: Add comments for config/control register names
  watchdog: it87_wdt: Add support for watchdogs with 8b timers
  watchdog: it87_wdt: Add support for IT8720F watchdog
  watchdog:  Use static const char * const where possible
  watchdog: iTCO_wdt: Cleanup warning messages
  watchdog: iTCO_wdt: TCO Watchdog patch for Intel Patsburg DeviceIDs

30 files changed:
Documentation/kbuild/makefiles.txt
Kbuild
Makefile
drivers/regulator/Kconfig
drivers/regulator/Makefile
drivers/regulator/core.c
drivers/regulator/dummy.h
drivers/regulator/lp3972.c [new file with mode: 0644]
drivers/regulator/max8952.c [new file with mode: 0644]
fs/ext4/inode.c
fs/nfs/direct.c
fs/nfs/idmap.c
fs/nfs/nfs4proc.c
fs/nfs/pagelist.c
include/asm-generic/vmlinux.lds.h
include/linux/regulator/lp3972.h [new file with mode: 0644]
include/linux/regulator/machine.h
include/linux/regulator/max8952.h [new file with mode: 0644]
init/initramfs.c
scripts/Makefile.clean
scripts/Makefile.lib
scripts/kallsyms.c
scripts/mod/modpost.c
scripts/setlocalversion
usr/Makefile
usr/initramfs_data.S
usr/initramfs_data.bz2.S [deleted file]
usr/initramfs_data.gz.S [deleted file]
usr/initramfs_data.lzma.S [deleted file]
usr/initramfs_data.lzo.S [deleted file]

index c787ae5..0ef00bd 100644 (file)
@@ -776,6 +776,13 @@ This will delete the directory debian, including all subdirectories.
 Kbuild will assume the directories to be in the same relative path as the
 Makefile if no absolute path is specified (path does not start with '/').
 
+To exclude certain files from make clean, use the $(no-clean-files) variable.
+This is only a special case used in the top level Kbuild file:
+
+       Example:
+               #Kbuild
+               no-clean-files := $(bounds-file) $(offsets-file)
+
 Usually kbuild descends down in subdirectories due to "obj-* := dir/",
 but in the architecture makefiles where the kbuild infrastructure
 is not sufficient this sometimes needs to be explicit.
diff --git a/Kbuild b/Kbuild
index b00037a..2114113 100644 (file)
--- a/Kbuild
+++ b/Kbuild
@@ -95,5 +95,5 @@ PHONY += missing-syscalls
 missing-syscalls: scripts/checksyscalls.sh FORCE
        $(call cmd,syscalls)
 
-# Delete all targets during make clean
-clean-files := $(addprefix $(objtree)/,$(filter-out $(bounds-file) $(offsets-file),$(targets)))
+# Keep these two files during make clean
+no-clean-files := $(bounds-file) $(offsets-file)
index 3e43805..6b23f1b 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -1137,21 +1137,13 @@ MRPROPER_FILES += .config .config.old .version .old_version             \
 #
 clean: rm-dirs  := $(CLEAN_DIRS)
 clean: rm-files := $(CLEAN_FILES)
-clean-dirs      := $(addprefix _clean_,$(srctree) $(vmlinux-alldirs) Documentation)
+clean-dirs      := $(addprefix _clean_, . $(vmlinux-alldirs) Documentation)
 
 PHONY += $(clean-dirs) clean archclean
 $(clean-dirs):
        $(Q)$(MAKE) $(clean)=$(patsubst _clean_%,%,$@)
 
-clean: archclean $(clean-dirs)
-       $(call cmd,rmdirs)
-       $(call cmd,rmfiles)
-       @find . $(RCS_FIND_IGNORE) \
-               \( -name '*.[oas]' -o -name '*.ko' -o -name '.*.cmd' \
-               -o -name '.*.d' -o -name '.*.tmp' -o -name '*.mod.c' \
-               -o -name '*.symtypes' -o -name 'modules.order' \
-               -o -name modules.builtin -o -name '.tmp_*.o.*' \
-               -o -name '*.gcno' \) -type f -print | xargs rm -f
+clean: archclean
 
 # mrproper - Delete all generated files, including .config
 #
@@ -1352,16 +1344,7 @@ $(clean-dirs):
        $(Q)$(MAKE) $(clean)=$(patsubst _clean_%,%,$@)
 
 clean: rm-dirs := $(MODVERDIR)
-clean: rm-files := $(KBUILD_EXTMOD)/Module.symvers \
-                   $(KBUILD_EXTMOD)/modules.order \
-                   $(KBUILD_EXTMOD)/modules.builtin
-clean: $(clean-dirs)
-       $(call cmd,rmdirs)
-       $(call cmd,rmfiles)
-       @find $(KBUILD_EXTMOD) $(RCS_FIND_IGNORE) \
-               \( -name '*.[oas]' -o -name '*.ko' -o -name '.*.cmd' \
-               -o -name '.*.d' -o -name '.*.tmp' -o -name '*.mod.c' \
-               -o -name '*.gcno' \) -type f -print | xargs rm -f
+clean: rm-files := $(KBUILD_EXTMOD)/Module.symvers
 
 help:
        @echo  '  Building external modules.'
@@ -1378,6 +1361,16 @@ prepare: ;
 scripts: ;
 endif # KBUILD_EXTMOD
 
+clean: $(clean-dirs)
+       $(call cmd,rmdirs)
+       $(call cmd,rmfiles)
+       @find $(or $(KBUILD_EXTMOD), .) $(RCS_FIND_IGNORE) \
+               \( -name '*.[oas]' -o -name '*.ko' -o -name '.*.cmd' \
+               -o -name '.*.d' -o -name '.*.tmp' -o -name '*.mod.c' \
+               -o -name '*.symtypes' -o -name 'modules.order' \
+               -o -name modules.builtin -o -name '.tmp_*.o.*' \
+               -o -name '*.gcno' \) -type f -print | xargs rm -f
+
 # Generate tags for editors
 # ---------------------------------------------------------------------------
 quiet_cmd_tags = GEN     $@
index 172951b..dd30e88 100644 (file)
@@ -100,6 +100,14 @@ config REGULATOR_MAX8925
        help
          Say y here to support the voltage regulaltor of Maxim MAX8925 PMIC.
 
+config REGULATOR_MAX8952
+       tristate "Maxim MAX8952 Power Management IC"
+       depends on I2C
+       help
+         This driver controls a Maxim 8952 voltage output regulator
+         via I2C bus. Maxim 8952 has one voltage output and supports 4 DVS
+         modes ranging from 0.77V to 1.40V by 0.01V steps.
+
 config REGULATOR_MAX8998
        tristate "Maxim 8998 voltage regulator"
        depends on MFD_MAX8998
@@ -164,6 +172,13 @@ config REGULATOR_LP3971
         Say Y here to support the voltage regulators and convertors
         on National Semiconductors LP3971 PMIC
 
+config REGULATOR_LP3972
+       tristate "National Semiconductors LP3972 PMIC regulator driver"
+       depends on I2C
+       help
+        Say Y here to support the voltage regulators and convertors
+        on National Semiconductors LP3972 PMIC
+
 config REGULATOR_PCAP
        tristate "PCAP2 regulator driver"
        depends on EZX_PCAP
index 8285fd8..bff8157 100644 (file)
@@ -3,20 +3,21 @@
 #
 
 
-obj-$(CONFIG_REGULATOR) += core.o
+obj-$(CONFIG_REGULATOR) += core.o dummy.o
 obj-$(CONFIG_REGULATOR_FIXED_VOLTAGE) += fixed.o
 obj-$(CONFIG_REGULATOR_VIRTUAL_CONSUMER) += virtual.o
 obj-$(CONFIG_REGULATOR_USERSPACE_CONSUMER) += userspace-consumer.o
 
 obj-$(CONFIG_REGULATOR_AD5398) += ad5398.o
 obj-$(CONFIG_REGULATOR_BQ24022) += bq24022.o
-obj-$(CONFIG_REGULATOR_DUMMY) += dummy.o
 obj-$(CONFIG_REGULATOR_LP3971) += lp3971.o
+obj-$(CONFIG_REGULATOR_LP3972) += lp3972.o
 obj-$(CONFIG_REGULATOR_MAX1586) += max1586.o
 obj-$(CONFIG_REGULATOR_TWL4030) += twl-regulator.o
 obj-$(CONFIG_REGULATOR_MAX8649)        += max8649.o
 obj-$(CONFIG_REGULATOR_MAX8660) += max8660.o
 obj-$(CONFIG_REGULATOR_MAX8925) += max8925-regulator.o
+obj-$(CONFIG_REGULATOR_MAX8952) += max8952.o
 obj-$(CONFIG_REGULATOR_MAX8998) += max8998.o
 obj-$(CONFIG_REGULATOR_WM831X) += wm831x-dcdc.o
 obj-$(CONFIG_REGULATOR_WM831X) += wm831x-isink.o
index cc8b337..f1d10c9 100644 (file)
@@ -33,6 +33,7 @@ static DEFINE_MUTEX(regulator_list_mutex);
 static LIST_HEAD(regulator_list);
 static LIST_HEAD(regulator_map_list);
 static int has_full_constraints;
+static bool board_wants_dummy_regulator;
 
 /*
  * struct regulator_map
@@ -63,7 +64,8 @@ struct regulator {
 };
 
 static int _regulator_is_enabled(struct regulator_dev *rdev);
-static int _regulator_disable(struct regulator_dev *rdev);
+static int _regulator_disable(struct regulator_dev *rdev,
+               struct regulator_dev **supply_rdev_ptr);
 static int _regulator_get_voltage(struct regulator_dev *rdev);
 static int _regulator_get_current_limit(struct regulator_dev *rdev);
 static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
@@ -1108,6 +1110,11 @@ static struct regulator *_regulator_get(struct device *dev, const char *id,
                }
        }
 
+       if (board_wants_dummy_regulator) {
+               rdev = dummy_regulator_rdev;
+               goto found;
+       }
+
 #ifdef CONFIG_REGULATOR_DUMMY
        if (!devname)
                devname = "deviceless";
@@ -1348,7 +1355,8 @@ int regulator_enable(struct regulator *regulator)
 EXPORT_SYMBOL_GPL(regulator_enable);
 
 /* locks held by regulator_disable() */
-static int _regulator_disable(struct regulator_dev *rdev)
+static int _regulator_disable(struct regulator_dev *rdev,
+               struct regulator_dev **supply_rdev_ptr)
 {
        int ret = 0;
 
@@ -1376,8 +1384,7 @@ static int _regulator_disable(struct regulator_dev *rdev)
                }
 
                /* decrease our supplies ref count and disable if required */
-               if (rdev->supply)
-                       _regulator_disable(rdev->supply);
+               *supply_rdev_ptr = rdev->supply;
 
                rdev->use_count = 0;
        } else if (rdev->use_count > 1) {
@@ -1407,17 +1414,29 @@ static int _regulator_disable(struct regulator_dev *rdev)
 int regulator_disable(struct regulator *regulator)
 {
        struct regulator_dev *rdev = regulator->rdev;
+       struct regulator_dev *supply_rdev = NULL;
        int ret = 0;
 
        mutex_lock(&rdev->mutex);
-       ret = _regulator_disable(rdev);
+       ret = _regulator_disable(rdev, &supply_rdev);
        mutex_unlock(&rdev->mutex);
+
+       /* decrease our supplies ref count and disable if required */
+       while (supply_rdev != NULL) {
+               rdev = supply_rdev;
+
+               mutex_lock(&rdev->mutex);
+               _regulator_disable(rdev, &supply_rdev);
+               mutex_unlock(&rdev->mutex);
+       }
+
        return ret;
 }
 EXPORT_SYMBOL_GPL(regulator_disable);
 
 /* locks held by regulator_force_disable() */
-static int _regulator_force_disable(struct regulator_dev *rdev)
+static int _regulator_force_disable(struct regulator_dev *rdev,
+               struct regulator_dev **supply_rdev_ptr)
 {
        int ret = 0;
 
@@ -1436,8 +1455,7 @@ static int _regulator_force_disable(struct regulator_dev *rdev)
        }
 
        /* decrease our supplies ref count and disable if required */
-       if (rdev->supply)
-               _regulator_disable(rdev->supply);
+       *supply_rdev_ptr = rdev->supply;
 
        rdev->use_count = 0;
        return ret;
@@ -1454,12 +1472,17 @@ static int _regulator_force_disable(struct regulator_dev *rdev)
  */
 int regulator_force_disable(struct regulator *regulator)
 {
+       struct regulator_dev *supply_rdev = NULL;
        int ret;
 
        mutex_lock(&regulator->rdev->mutex);
        regulator->uA_load = 0;
-       ret = _regulator_force_disable(regulator->rdev);
+       ret = _regulator_force_disable(regulator->rdev, &supply_rdev);
        mutex_unlock(&regulator->rdev->mutex);
+
+       if (supply_rdev)
+               regulator_disable(get_device_regulator(rdev_get_dev(supply_rdev)));
+
        return ret;
 }
 EXPORT_SYMBOL_GPL(regulator_force_disable);
@@ -2462,6 +2485,22 @@ void regulator_has_full_constraints(void)
 }
 EXPORT_SYMBOL_GPL(regulator_has_full_constraints);
 
+/**
+ * regulator_use_dummy_regulator - Provide a dummy regulator when none is found
+ *
+ * Calling this function will cause the regulator API to provide a
+ * dummy regulator to consumers if no physical regulator is found,
+ * allowing most consumers to proceed as though a regulator were
+ * configured.  This allows systems such as those with software
+ * controllable regulators for the CPU core only to be brought up more
+ * readily.
+ */
+void regulator_use_dummy_regulator(void)
+{
+       board_wants_dummy_regulator = true;
+}
+EXPORT_SYMBOL_GPL(regulator_use_dummy_regulator);
+
 /**
  * rdev_get_drvdata - get rdev regulator driver data
  * @rdev: regulator
index 3921c0e..97a11b7 100644 (file)
@@ -22,10 +22,6 @@ struct regulator_dev;
 
 extern struct regulator_dev *dummy_regulator_rdev;
 
-#ifdef CONFIG_REGULATOR_DUMMY
 void __init regulator_dummy_init(void);
-#else
-static inline void regulator_dummy_init(void) { }
-#endif
 
 #endif
diff --git a/drivers/regulator/lp3972.c b/drivers/regulator/lp3972.c
new file mode 100644 (file)
index 0000000..e07062f
--- /dev/null
@@ -0,0 +1,660 @@
+/*
+ * Regulator driver for National Semiconductors LP3972 PMIC chip
+ *
+ * Based on lp3971.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/bug.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/kernel.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/lp3972.h>
+#include <linux/slab.h>
+
+struct lp3972 {
+       struct device *dev;
+       struct mutex io_lock;
+       struct i2c_client *i2c;
+       int num_regulators;
+       struct regulator_dev **rdev;
+};
+
+/* LP3972 Control Registers */
+#define LP3972_SCR_REG         0x07
+#define LP3972_OVER1_REG       0x10
+#define LP3972_OVSR1_REG       0x11
+#define LP3972_OVER2_REG       0x12
+#define LP3972_OVSR2_REG       0x13
+#define LP3972_VCC1_REG                0x20
+#define LP3972_ADTV1_REG       0x23
+#define LP3972_ADTV2_REG       0x24
+#define LP3972_AVRC_REG                0x25
+#define LP3972_CDTC1_REG       0x26
+#define LP3972_CDTC2_REG       0x27
+#define LP3972_SDTV1_REG       0x29
+#define LP3972_SDTV2_REG       0x2A
+#define LP3972_MDTV1_REG       0x32
+#define LP3972_MDTV2_REG       0x33
+#define LP3972_L2VCR_REG       0x39
+#define LP3972_L34VCR_REG      0x3A
+#define LP3972_SCR1_REG                0x80
+#define LP3972_SCR2_REG                0x81
+#define LP3972_OEN3_REG                0x82
+#define LP3972_OSR3_REG                0x83
+#define LP3972_LOER4_REG       0x84
+#define LP3972_B2TV_REG                0x85
+#define LP3972_B3TV_REG                0x86
+#define LP3972_B32RC_REG       0x87
+#define LP3972_ISRA_REG                0x88
+#define LP3972_BCCR_REG                0x89
+#define LP3972_II1RR_REG       0x8E
+#define LP3972_II2RR_REG       0x8F
+
+#define LP3972_SYS_CONTROL1_REG                LP3972_SCR1_REG
+/* System control register 1 initial value,
+ * bits 5, 6 and 7 are EPROM programmable */
+#define SYS_CONTROL1_INIT_VAL          0x02
+#define SYS_CONTROL1_INIT_MASK         0x1F
+
+#define LP3972_VOL_CHANGE_REG          LP3972_VCC1_REG
+#define LP3972_VOL_CHANGE_FLAG_GO      0x01
+#define LP3972_VOL_CHANGE_FLAG_MASK    0x03
+
+/* LDO output enable mask */
+#define LP3972_OEN3_L1EN       BIT(0)
+#define LP3972_OVER2_LDO2_EN   BIT(2)
+#define LP3972_OVER2_LDO3_EN   BIT(3)
+#define LP3972_OVER2_LDO4_EN   BIT(4)
+#define LP3972_OVER1_S_EN      BIT(2)
+
+static const int ldo1_voltage_map[] = {
+       1700, 1725, 1750, 1775, 1800, 1825, 1850, 1875,
+       1900, 1925, 1950, 1975, 2000,
+};
+
+static const int ldo23_voltage_map[] = {
+       1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500,
+       2600, 2700, 2800, 2900, 3000, 3100, 3200, 3300,
+};
+
+static const int ldo4_voltage_map[] = {
+       1000, 1050, 1100, 1150, 1200, 1250, 1300, 1350,
+       1400, 1500, 1800, 1900, 2500, 2800, 3000, 3300,
+};
+
+static const int ldo5_voltage_map[] = {
+          0,    0,    0,    0,    0,  850,  875,  900,
+        925,  950,  975, 1000, 1025, 1050, 1075, 1100,
+       1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
+       1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
+};
+
+static const int buck1_voltage_map[] = {
+        725,  750,  775,  800,  825,  850,  875,  900,
+        925,  950,  975, 1000, 1025, 1050, 1075, 1100,
+       1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
+       1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
+};
+
+static const int buck23_voltage_map[] = {
+          0,  800,  850,  900,  950, 1000, 1050, 1100,
+       1150, 1200, 1250, 1300, 1350, 1400, 1450, 1500,
+       1550, 1600, 1650, 1700, 1800, 1900, 2500, 2800,
+       3000, 3300,
+};
+
+static const int *ldo_voltage_map[] = {
+       ldo1_voltage_map,
+       ldo23_voltage_map,
+       ldo23_voltage_map,
+       ldo4_voltage_map,
+       ldo5_voltage_map,
+};
+
+static const int *buck_voltage_map[] = {
+       buck1_voltage_map,
+       buck23_voltage_map,
+       buck23_voltage_map,
+};
+
+static const int ldo_output_enable_mask[] = {
+       LP3972_OEN3_L1EN,
+       LP3972_OVER2_LDO2_EN,
+       LP3972_OVER2_LDO3_EN,
+       LP3972_OVER2_LDO4_EN,
+       LP3972_OVER1_S_EN,
+};
+
+static const int ldo_output_enable_addr[] = {
+       LP3972_OEN3_REG,
+       LP3972_OVER2_REG,
+       LP3972_OVER2_REG,
+       LP3972_OVER2_REG,
+       LP3972_OVER1_REG,
+};
+
+static const int ldo_vol_ctl_addr[] = {
+       LP3972_MDTV1_REG,
+       LP3972_L2VCR_REG,
+       LP3972_L34VCR_REG,
+       LP3972_L34VCR_REG,
+       LP3972_SDTV1_REG,
+};
+
+static const int buck_vol_enable_addr[] = {
+       LP3972_OVER1_REG,
+       LP3972_OEN3_REG,
+       LP3972_OEN3_REG,
+};
+
+static const int buck_base_addr[] = {
+       LP3972_ADTV1_REG,
+       LP3972_B2TV_REG,
+       LP3972_B3TV_REG,
+};
+
+#define LP3972_LDO_VOL_VALUE_MAP(x) (ldo_voltage_map[x])
+#define LP3972_LDO_OUTPUT_ENABLE_MASK(x) (ldo_output_enable_mask[x])
+#define LP3972_LDO_OUTPUT_ENABLE_REG(x) (ldo_output_enable_addr[x])
+
+/*     LDO voltage control registers shift:
+       LP3972_LDO1 -> 0, LP3972_LDO2 -> 4
+       LP3972_LDO3 -> 0, LP3972_LDO4 -> 4
+       LP3972_LDO5 -> 0
+*/
+#define LP3972_LDO_VOL_CONTR_SHIFT(x) (((x) & 1) << 2)
+#define LP3972_LDO_VOL_CONTR_REG(x) (ldo_vol_ctl_addr[x])
+#define LP3972_LDO_VOL_CHANGE_SHIFT(x) ((x) ? 4 : 6)
+
+#define LP3972_LDO_VOL_MASK(x) (((x) % 4) ? 0x0f : 0x1f)
+#define LP3972_LDO_VOL_MIN_IDX(x) (((x) == 4) ? 0x05 : 0x00)
+#define LP3972_LDO_VOL_MAX_IDX(x) ((x) ? (((x) == 4) ? 0x1f : 0x0f) : 0x0c)
+
+#define LP3972_BUCK_VOL_VALUE_MAP(x) (buck_voltage_map[x])
+#define LP3972_BUCK_VOL_ENABLE_REG(x) (buck_vol_enable_addr[x])
+#define LP3972_BUCK_VOL1_REG(x) (buck_base_addr[x])
+#define LP3972_BUCK_VOL_MASK 0x1f
+#define LP3972_BUCK_VOL_MIN_IDX(x) ((x) ? 0x01 : 0x00)
+#define LP3972_BUCK_VOL_MAX_IDX(x) ((x) ? 0x19 : 0x1f)
+
+static int lp3972_i2c_read(struct i2c_client *i2c, char reg, int count,
+       u16 *dest)
+{
+       int ret;
+
+       if (count != 1)
+               return -EIO;
+       ret = i2c_smbus_read_byte_data(i2c, reg);
+       if (ret < 0)
+               return ret;
+
+       *dest = ret;
+       return 0;
+}
+
+static int lp3972_i2c_write(struct i2c_client *i2c, char reg, int count,
+       const u16 *src)
+{
+       if (count != 1)
+               return -EIO;
+       return i2c_smbus_write_byte_data(i2c, reg, *src);
+}
+
+static u8 lp3972_reg_read(struct lp3972 *lp3972, u8 reg)
+{
+       u16 val = 0;
+
+       mutex_lock(&lp3972->io_lock);
+
+       lp3972_i2c_read(lp3972->i2c, reg, 1, &val);
+
+       dev_dbg(lp3972->dev, "reg read 0x%02x -> 0x%02x\n", (int)reg,
+               (unsigned)val & 0xff);
+
+       mutex_unlock(&lp3972->io_lock);
+
+       return val & 0xff;
+}
+
+static int lp3972_set_bits(struct lp3972 *lp3972, u8 reg, u16 mask, u16 val)
+{
+       u16 tmp;
+       int ret;
+
+       mutex_lock(&lp3972->io_lock);
+
+       ret = lp3972_i2c_read(lp3972->i2c, reg, 1, &tmp);
+       tmp = (tmp & ~mask) | val;
+       if (ret == 0) {
+               ret = lp3972_i2c_write(lp3972->i2c, reg, 1, &tmp);
+               dev_dbg(lp3972->dev, "reg write 0x%02x -> 0x%02x\n", (int)reg,
+                       (unsigned)val & 0xff);
+       }
+       mutex_unlock(&lp3972->io_lock);
+
+       return ret;
+}
+
+static int lp3972_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
+{
+       int ldo = rdev_get_id(dev) - LP3972_LDO1;
+       return 1000 * LP3972_LDO_VOL_VALUE_MAP(ldo)[index];
+}
+
+static int lp3972_ldo_is_enabled(struct regulator_dev *dev)
+{
+       struct lp3972 *lp3972 = rdev_get_drvdata(dev);
+       int ldo = rdev_get_id(dev) - LP3972_LDO1;
+       u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
+       u16 val;
+
+       val = lp3972_reg_read(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo));
+       return !!(val & mask);
+}
+
+static int lp3972_ldo_enable(struct regulator_dev *dev)
+{
+       struct lp3972 *lp3972 = rdev_get_drvdata(dev);
+       int ldo = rdev_get_id(dev) - LP3972_LDO1;
+       u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
+
+       return lp3972_set_bits(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo),
+                               mask, mask);
+}
+
+static int lp3972_ldo_disable(struct regulator_dev *dev)
+{
+       struct lp3972 *lp3972 = rdev_get_drvdata(dev);
+       int ldo = rdev_get_id(dev) - LP3972_LDO1;
+       u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
+
+       return lp3972_set_bits(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo),
+                               mask, 0);
+}
+
+static int lp3972_ldo_get_voltage(struct regulator_dev *dev)
+{
+       struct lp3972 *lp3972 = rdev_get_drvdata(dev);
+       int ldo = rdev_get_id(dev) - LP3972_LDO1;
+       u16 mask = LP3972_LDO_VOL_MASK(ldo);
+       u16 val, reg;
+
+       reg = lp3972_reg_read(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo));
+       val = (reg >> LP3972_LDO_VOL_CONTR_SHIFT(ldo)) & mask;
+
+       return 1000 * LP3972_LDO_VOL_VALUE_MAP(ldo)[val];
+}
+
+static int lp3972_ldo_set_voltage(struct regulator_dev *dev,
+                                 int min_uV, int max_uV)
+{
+       struct lp3972 *lp3972 = rdev_get_drvdata(dev);
+       int ldo = rdev_get_id(dev) - LP3972_LDO1;
+       int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
+       const int *vol_map = LP3972_LDO_VOL_VALUE_MAP(ldo);
+       u16 val;
+       int shift, ret;
+
+       if (min_vol < vol_map[LP3972_LDO_VOL_MIN_IDX(ldo)] ||
+           min_vol > vol_map[LP3972_LDO_VOL_MAX_IDX(ldo)])
+               return -EINVAL;
+
+       for (val = LP3972_LDO_VOL_MIN_IDX(ldo);
+               val <= LP3972_LDO_VOL_MAX_IDX(ldo); val++)
+               if (vol_map[val] >= min_vol)
+                       break;
+
+       if (val > LP3972_LDO_VOL_MAX_IDX(ldo) || vol_map[val] > max_vol)
+               return -EINVAL;
+
+       shift = LP3972_LDO_VOL_CONTR_SHIFT(ldo);
+       ret = lp3972_set_bits(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo),
+               LP3972_LDO_VOL_MASK(ldo) << shift, val << shift);
+
+       if (ret)
+               return ret;
+
+       /*
+        * LDO1 and LDO5 support voltage control by either target voltage1
+        * or target voltage2 register.
+        * We use target voltage1 register for LDO1 and LDO5 in this driver.
+        * We need to update voltage change control register(0x20) to enable
+        * LDO1 and LDO5 to change to their programmed target values.
+        */
+       switch (ldo) {
+       case LP3972_LDO1:
+       case LP3972_LDO5:
+               shift = LP3972_LDO_VOL_CHANGE_SHIFT(ldo);
+               ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
+                       LP3972_VOL_CHANGE_FLAG_MASK << shift,
+                       LP3972_VOL_CHANGE_FLAG_GO << shift);
+               if (ret)
+                       return ret;
+
+               ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
+                       LP3972_VOL_CHANGE_FLAG_MASK << shift, 0);
+               break;
+       }
+
+       return ret;
+}
+
+static struct regulator_ops lp3972_ldo_ops = {
+       .list_voltage = lp3972_ldo_list_voltage,
+       .is_enabled = lp3972_ldo_is_enabled,
+       .enable = lp3972_ldo_enable,
+       .disable = lp3972_ldo_disable,
+       .get_voltage = lp3972_ldo_get_voltage,
+       .set_voltage = lp3972_ldo_set_voltage,
+};
+
+static int lp3972_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
+{
+       int buck = rdev_get_id(dev) - LP3972_DCDC1;
+       return 1000 * buck_voltage_map[buck][index];
+}
+
+static int lp3972_dcdc_is_enabled(struct regulator_dev *dev)
+{
+       struct lp3972 *lp3972 = rdev_get_drvdata(dev);
+       int buck = rdev_get_id(dev) - LP3972_DCDC1;
+       u16 mask = 1 << (buck * 2);
+       u16 val;
+
+       val = lp3972_reg_read(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck));
+       return !!(val & mask);
+}
+
+static int lp3972_dcdc_enable(struct regulator_dev *dev)
+{
+       struct lp3972 *lp3972 = rdev_get_drvdata(dev);
+       int buck = rdev_get_id(dev) - LP3972_DCDC1;
+       u16 mask = 1 << (buck * 2);
+       u16 val;
+
+       val = lp3972_set_bits(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck),
+                               mask, mask);
+       return val;
+}
+
+static int lp3972_dcdc_disable(struct regulator_dev *dev)
+{
+       struct lp3972 *lp3972 = rdev_get_drvdata(dev);
+       int buck = rdev_get_id(dev) - LP3972_DCDC1;
+       u16 mask = 1 << (buck * 2);
+       u16 val;
+
+       val = lp3972_set_bits(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck),
+                               mask, 0);
+       return val;
+}
+
+static int lp3972_dcdc_get_voltage(struct regulator_dev *dev)
+{
+       struct lp3972 *lp3972 = rdev_get_drvdata(dev);
+       int buck = rdev_get_id(dev) - LP3972_DCDC1;
+       u16 reg;
+       int val;
+
+       reg = lp3972_reg_read(lp3972, LP3972_BUCK_VOL1_REG(buck));
+       reg &= LP3972_BUCK_VOL_MASK;
+       if (reg <= LP3972_BUCK_VOL_MAX_IDX(buck))
+               val = 1000 * buck_voltage_map[buck][reg];
+       else {
+               val = 0;
+               dev_warn(&dev->dev, "chip reported incorrect voltage value."
+                                   " reg = %d\n", reg);
+       }
+
+       return val;
+}
+
+static int lp3972_dcdc_set_voltage(struct regulator_dev *dev,
+                                 int min_uV, int max_uV)
+{
+       struct lp3972 *lp3972 = rdev_get_drvdata(dev);
+       int buck = rdev_get_id(dev) - LP3972_DCDC1;
+       int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
+       const int *vol_map = buck_voltage_map[buck];
+       u16 val;
+       int ret;
+
+       if (min_vol < vol_map[LP3972_BUCK_VOL_MIN_IDX(buck)] ||
+           min_vol > vol_map[LP3972_BUCK_VOL_MAX_IDX(buck)])
+               return -EINVAL;
+
+       for (val = LP3972_BUCK_VOL_MIN_IDX(buck);
+               val <= LP3972_BUCK_VOL_MAX_IDX(buck); val++)
+               if (vol_map[val] >= min_vol)
+                       break;
+
+       if (val > LP3972_BUCK_VOL_MAX_IDX(buck) ||
+           vol_map[val] > max_vol)
+               return -EINVAL;
+
+       ret = lp3972_set_bits(lp3972, LP3972_BUCK_VOL1_REG(buck),
+                               LP3972_BUCK_VOL_MASK, val);
+       if (ret)
+               return ret;
+
+       if (buck != 0)
+               return ret;
+
+       ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
+               LP3972_VOL_CHANGE_FLAG_MASK, LP3972_VOL_CHANGE_FLAG_GO);
+       if (ret)
+               return ret;
+
+       return lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
+                               LP3972_VOL_CHANGE_FLAG_MASK, 0);
+}
+
+static struct regulator_ops lp3972_dcdc_ops = {
+       .list_voltage = lp3972_dcdc_list_voltage,
+       .is_enabled = lp3972_dcdc_is_enabled,
+       .enable = lp3972_dcdc_enable,
+       .disable = lp3972_dcdc_disable,
+       .get_voltage = lp3972_dcdc_get_voltage,
+       .set_voltage = lp3972_dcdc_set_voltage,
+};
+
+static struct regulator_desc regulators[] = {
+       {
+               .name = "LDO1",
+               .id = LP3972_LDO1,
+               .ops = &lp3972_ldo_ops,
+               .n_voltages = ARRAY_SIZE(ldo1_voltage_map),
+               .type = REGULATOR_VOLTAGE,
+               .owner = THIS_MODULE,
+       },
+       {
+               .name = "LDO2",
+               .id = LP3972_LDO2,
+               .ops = &lp3972_ldo_ops,
+               .n_voltages = ARRAY_SIZE(ldo23_voltage_map),
+               .type = REGULATOR_VOLTAGE,
+               .owner = THIS_MODULE,
+       },
+       {
+               .name = "LDO3",
+               .id = LP3972_LDO3,
+               .ops = &lp3972_ldo_ops,
+               .n_voltages = ARRAY_SIZE(ldo23_voltage_map),
+               .type = REGULATOR_VOLTAGE,
+               .owner = THIS_MODULE,
+       },
+       {
+               .name = "LDO4",
+               .id = LP3972_LDO4,
+               .ops = &lp3972_ldo_ops,
+               .n_voltages = ARRAY_SIZE(ldo4_voltage_map),
+               .type = REGULATOR_VOLTAGE,
+               .owner = THIS_MODULE,
+       },
+       {
+               .name = "LDO5",
+               .id = LP3972_LDO5,
+               .ops = &lp3972_ldo_ops,
+               .n_voltages = ARRAY_SIZE(ldo5_voltage_map),
+               .type = REGULATOR_VOLTAGE,
+               .owner = THIS_MODULE,
+       },
+       {
+               .name = "DCDC1",
+               .id = LP3972_DCDC1,
+               .ops = &lp3972_dcdc_ops,
+               .n_voltages = ARRAY_SIZE(buck1_voltage_map),
+               .type = REGULATOR_VOLTAGE,
+               .owner = THIS_MODULE,
+       },
+       {
+               .name = "DCDC2",
+               .id = LP3972_DCDC2,
+               .ops = &lp3972_dcdc_ops,
+               .n_voltages = ARRAY_SIZE(buck23_voltage_map),
+               .type = REGULATOR_VOLTAGE,
+               .owner = THIS_MODULE,
+       },
+       {
+               .name = "DCDC3",
+               .id = LP3972_DCDC3,
+               .ops = &lp3972_dcdc_ops,
+               .n_voltages = ARRAY_SIZE(buck23_voltage_map),
+               .type = REGULATOR_VOLTAGE,
+               .owner = THIS_MODULE,
+       },
+};
+
+static int __devinit setup_regulators(struct lp3972 *lp3972,
+       struct lp3972_platform_data *pdata)
+{
+       int i, err;
+
+       lp3972->num_regulators = pdata->num_regulators;
+       lp3972->rdev = kcalloc(pdata->num_regulators,
+                               sizeof(struct regulator_dev *), GFP_KERNEL);
+       if (!lp3972->rdev) {
+               err = -ENOMEM;
+               goto err_nomem;
+       }
+
+       /* Instantiate the regulators */
+       for (i = 0; i < pdata->num_regulators; i++) {
+               struct lp3972_regulator_subdev *reg = &pdata->regulators[i];
+               lp3972->rdev[i] = regulator_register(&regulators[reg->id],
+                                       lp3972->dev, reg->initdata, lp3972);
+
+               if (IS_ERR(lp3972->rdev[i])) {
+                       err = PTR_ERR(lp3972->rdev[i]);
+                       dev_err(lp3972->dev, "regulator init failed: %d\n",
+                               err);
+                       goto error;
+               }
+       }
+
+       return 0;
+error:
+       while (--i >= 0)
+               regulator_unregister(lp3972->rdev[i]);
+       kfree(lp3972->rdev);
+       lp3972->rdev = NULL;
+err_nomem:
+       return err;
+}
+
+static int __devinit lp3972_i2c_probe(struct i2c_client *i2c,
+                           const struct i2c_device_id *id)
+{
+       struct lp3972 *lp3972;
+       struct lp3972_platform_data *pdata = i2c->dev.platform_data;
+       int ret;
+       u16 val;
+
+       if (!pdata) {
+               dev_dbg(&i2c->dev, "No platform init data supplied\n");
+               return -ENODEV;
+       }
+
+       lp3972 = kzalloc(sizeof(struct lp3972), GFP_KERNEL);
+       if (!lp3972)
+               return -ENOMEM;
+
+       lp3972->i2c = i2c;
+       lp3972->dev = &i2c->dev;
+
+       mutex_init(&lp3972->io_lock);
+
+       /* Detect LP3972 */
+       ret = lp3972_i2c_read(i2c, LP3972_SYS_CONTROL1_REG, 1, &val);
+       if (ret == 0 &&
+               (val & SYS_CONTROL1_INIT_MASK) != SYS_CONTROL1_INIT_VAL) {
+               ret = -ENODEV;
+               dev_err(&i2c->dev, "chip reported: val = 0x%x\n", val);
+       }
+       if (ret < 0) {
+               dev_err(&i2c->dev, "failed to detect device. ret = %d\n", ret);
+               goto err_detect;
+       }
+
+       ret = setup_regulators(lp3972, pdata);
+       if (ret < 0)
+               goto err_detect;
+
+       i2c_set_clientdata(i2c, lp3972);
+       return 0;
+
+err_detect:
+       kfree(lp3972);
+       return ret;
+}
+
+static int __devexit lp3972_i2c_remove(struct i2c_client *i2c)
+{
+       struct lp3972 *lp3972 = i2c_get_clientdata(i2c);
+       int i;
+
+       for (i = 0; i < lp3972->num_regulators; i++)
+               regulator_unregister(lp3972->rdev[i]);
+       kfree(lp3972->rdev);
+       kfree(lp3972);
+
+       return 0;
+}
+
+static const struct i2c_device_id lp3972_i2c_id[] = {
+       { "lp3972", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, lp3972_i2c_id);
+
+static struct i2c_driver lp3972_i2c_driver = {
+       .driver = {
+               .name = "lp3972",
+               .owner = THIS_MODULE,
+       },
+       .probe    = lp3972_i2c_probe,
+       .remove   = __devexit_p(lp3972_i2c_remove),
+       .id_table = lp3972_i2c_id,
+};
+
+static int __init lp3972_module_init(void)
+{
+       return i2c_add_driver(&lp3972_i2c_driver);
+}
+subsys_initcall(lp3972_module_init);
+
+static void __exit lp3972_module_exit(void)
+{
+       i2c_del_driver(&lp3972_i2c_driver);
+}
+module_exit(lp3972_module_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Axel Lin <axel.lin@gmail.com>");
+MODULE_DESCRIPTION("LP3972 PMIC driver");
diff --git a/drivers/regulator/max8952.c b/drivers/regulator/max8952.c
new file mode 100644 (file)
index 0000000..0d5dda4
--- /dev/null
@@ -0,0 +1,366 @@
+/*
+ * max8952.c - Voltage and current regulation for the Maxim 8952
+ *
+ * Copyright (C) 2010 Samsung Electronics
+ * MyungJoo Ham <myungjoo.ham@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/max8952.h>
+#include <linux/mutex.h>
+#include <linux/gpio.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+
+/* Registers */
+enum {
+       MAX8952_REG_MODE0,
+       MAX8952_REG_MODE1,
+       MAX8952_REG_MODE2,
+       MAX8952_REG_MODE3,
+       MAX8952_REG_CONTROL,
+       MAX8952_REG_SYNC,
+       MAX8952_REG_RAMP,
+       MAX8952_REG_CHIP_ID1,
+       MAX8952_REG_CHIP_ID2,
+};
+
+struct max8952_data {
+       struct i2c_client       *client;
+       struct device           *dev;
+       struct mutex            mutex;
+       struct max8952_platform_data *pdata;
+       struct regulator_dev    *rdev;
+
+       bool vid0;
+       bool vid1;
+       bool en;
+};
+
+static int max8952_read_reg(struct max8952_data *max8952, u8 reg)
+{
+       int ret = i2c_smbus_read_byte_data(max8952->client, reg);
+       if (ret > 0)
+               ret &= 0xff;
+
+       return ret;
+}
+
+static int max8952_write_reg(struct max8952_data *max8952,
+               u8 reg, u8 value)
+{
+       return i2c_smbus_write_byte_data(max8952->client, reg, value);
+}
+
+static int max8952_voltage(struct max8952_data *max8952, u8 mode)
+{
+       return (max8952->pdata->dvs_mode[mode] * 10 + 770) * 1000;
+}
+
+static int max8952_list_voltage(struct regulator_dev *rdev,
+               unsigned int selector)
+{
+       struct max8952_data *max8952 = rdev_get_drvdata(rdev);
+
+       if (rdev_get_id(rdev) != 0)
+               return -EINVAL;
+
+       return max8952_voltage(max8952, selector);
+}
+
+static int max8952_is_enabled(struct regulator_dev *rdev)
+{
+       struct max8952_data *max8952 = rdev_get_drvdata(rdev);
+       return max8952->en;
+}
+
+static int max8952_enable(struct regulator_dev *rdev)
+{
+       struct max8952_data *max8952 = rdev_get_drvdata(rdev);
+
+       /* If not valid, assume "ALWAYS_HIGH" */
+       if (gpio_is_valid(max8952->pdata->gpio_en))
+               gpio_set_value(max8952->pdata->gpio_en, 1);
+
+       max8952->en = true;
+       return 0;
+}
+
+static int max8952_disable(struct regulator_dev *rdev)
+{
+       struct max8952_data *max8952 = rdev_get_drvdata(rdev);
+
+       /* If not valid, assume "ALWAYS_HIGH" -> not permitted */
+       if (gpio_is_valid(max8952->pdata->gpio_en))
+               gpio_set_value(max8952->pdata->gpio_en, 0);
+       else
+               return -EPERM;
+
+       max8952->en = false;
+       return 0;
+}
+
+static int max8952_get_voltage(struct regulator_dev *rdev)
+{
+       struct max8952_data *max8952 = rdev_get_drvdata(rdev);
+       u8 vid = 0;
+
+       if (max8952->vid0)
+               vid += 1;
+       if (max8952->vid1)
+               vid += 2;
+
+       return max8952_voltage(max8952, vid);
+}
+
+static int max8952_set_voltage(struct regulator_dev *rdev,
+                               int min_uV, int max_uV)
+{
+       struct max8952_data *max8952 = rdev_get_drvdata(rdev);
+       s8 vid = -1, i;
+
+       if (!gpio_is_valid(max8952->pdata->gpio_vid0) ||
+                       !gpio_is_valid(max8952->pdata->gpio_vid0)) {
+               /* DVS not supported */
+               return -EPERM;
+       }
+
+       for (i = 0; i < MAX8952_NUM_DVS_MODE; i++) {
+               int volt = max8952_voltage(max8952, i);
+
+               /* Set the voltage as low as possible within the range */
+               if (volt <= max_uV && volt >= min_uV)
+                       if (vid == -1 || max8952_voltage(max8952, vid) > volt)
+                               vid = i;
+       }
+
+       if (vid >= 0 && vid < MAX8952_NUM_DVS_MODE) {
+               max8952->vid0 = (vid % 2 == 1);
+               max8952->vid1 = (((vid >> 1) % 2) == 1);
+               gpio_set_value(max8952->pdata->gpio_vid0, max8952->vid0);
+               gpio_set_value(max8952->pdata->gpio_vid1, max8952->vid1);
+       } else
+               return -EINVAL;
+
+       return 0;
+}
+
+static struct regulator_ops max8952_ops = {
+       .list_voltage           = max8952_list_voltage,
+       .is_enabled             = max8952_is_enabled,
+       .enable                 = max8952_enable,
+       .disable                = max8952_disable,
+       .get_voltage            = max8952_get_voltage,
+       .set_voltage            = max8952_set_voltage,
+       .set_suspend_disable    = max8952_disable,
+};
+
+static struct regulator_desc regulator = {
+       .name           = "MAX8952_VOUT",
+       .id             = 0,
+       .n_voltages     = MAX8952_NUM_DVS_MODE,
+       .ops            = &max8952_ops,
+       .type           = REGULATOR_VOLTAGE,
+       .owner          = THIS_MODULE,
+};
+
+static int __devinit max8952_pmic_probe(struct i2c_client *client,
+               const struct i2c_device_id *i2c_id)
+{
+       struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+       struct max8952_platform_data *pdata = client->dev.platform_data;
+       struct max8952_data *max8952;
+
+       int ret = 0, err = 0;
+
+       if (!pdata) {
+               dev_err(&client->dev, "Require the platform data\n");
+               return -EINVAL;
+       }
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
+               return -EIO;
+
+       max8952 = kzalloc(sizeof(struct max8952_data), GFP_KERNEL);
+       if (!max8952)
+               return -ENOMEM;
+
+       max8952->client = client;
+       max8952->dev = &client->dev;
+       max8952->pdata = pdata;
+       mutex_init(&max8952->mutex);
+
+       max8952->rdev = regulator_register(&regulator, max8952->dev,
+                       &pdata->reg_data, max8952);
+
+       if (IS_ERR(max8952->rdev)) {
+               ret = PTR_ERR(max8952->rdev);
+               dev_err(max8952->dev, "regulator init failed (%d)\n", ret);
+               goto err_reg;
+       }
+
+       max8952->en = !!(pdata->reg_data.constraints.boot_on);
+       max8952->vid0 = (pdata->default_mode % 2) == 1;
+       max8952->vid1 = ((pdata->default_mode >> 1) % 2) == 1;
+
+       if (gpio_is_valid(pdata->gpio_en)) {
+               if (!gpio_request(pdata->gpio_en, "MAX8952 EN"))
+                       gpio_direction_output(pdata->gpio_en, max8952->en);
+               else
+                       err = 1;
+       } else
+               err = 2;
+
+       if (err) {
+               dev_info(max8952->dev, "EN gpio invalid: assume that EN"
+                               "is always High\n");
+               max8952->en = 1;
+               pdata->gpio_en = -1; /* Mark invalid */
+       }
+
+       err = 0;
+
+       if (gpio_is_valid(pdata->gpio_vid0) &&
+                       gpio_is_valid(pdata->gpio_vid1)) {
+               if (!gpio_request(pdata->gpio_vid0, "MAX8952 VID0"))
+                       gpio_direction_output(pdata->gpio_vid0,
+                                       (pdata->default_mode) % 2);
+               else
+                       err = 1;
+
+               if (!gpio_request(pdata->gpio_vid1, "MAX8952 VID1"))
+                       gpio_direction_output(pdata->gpio_vid1,
+                               (pdata->default_mode >> 1) % 2);
+               else {
+                       if (!err)
+                               gpio_free(pdata->gpio_vid0);
+                       err = 2;
+               }
+
+       } else
+               err = 3;
+
+       if (err) {
+               dev_warn(max8952->dev, "VID0/1 gpio invalid: "
+                               "DVS not avilable.\n");
+               max8952->vid0 = 0;
+               max8952->vid1 = 0;
+               /* Mark invalid */
+               pdata->gpio_vid0 = -1;
+               pdata->gpio_vid1 = -1;
+
+               /* Disable Pulldown of EN only */
+               max8952_write_reg(max8952, MAX8952_REG_CONTROL, 0x60);
+
+               dev_err(max8952->dev, "DVS modes disabled because VID0 and VID1"
+                               " do not have proper controls.\n");
+       } else {
+               /*
+                * Disable Pulldown on EN, VID0, VID1 to reduce
+                * leakage current of MAX8952 assuming that MAX8952
+                * is turned on (EN==1). Note that without having VID0/1
+                * properly connected, turning pulldown off can be
+                * problematic. Thus, turn this off only when they are
+                * controllable by GPIO.
+                */
+               max8952_write_reg(max8952, MAX8952_REG_CONTROL, 0x0);
+       }
+
+       max8952_write_reg(max8952, MAX8952_REG_MODE0,
+                       (max8952_read_reg(max8952,
+                                         MAX8952_REG_MODE0) & 0xC0) |
+                       (pdata->dvs_mode[0] & 0x3F));
+       max8952_write_reg(max8952, MAX8952_REG_MODE1,
+                       (max8952_read_reg(max8952,
+                                         MAX8952_REG_MODE1) & 0xC0) |
+                       (pdata->dvs_mode[1] & 0x3F));
+       max8952_write_reg(max8952, MAX8952_REG_MODE2,
+                       (max8952_read_reg(max8952,
+                                         MAX8952_REG_MODE2) & 0xC0) |
+                       (pdata->dvs_mode[2] & 0x3F));
+       max8952_write_reg(max8952, MAX8952_REG_MODE3,
+                       (max8952_read_reg(max8952,
+                                         MAX8952_REG_MODE3) & 0xC0) |
+                       (pdata->dvs_mode[3] & 0x3F));
+
+       max8952_write_reg(max8952, MAX8952_REG_SYNC,
+                       (max8952_read_reg(max8952, MAX8952_REG_SYNC) & 0x3F) |
+                       ((pdata->sync_freq & 0x3) << 6));
+       max8952_write_reg(max8952, MAX8952_REG_RAMP,
+                       (max8952_read_reg(max8952, MAX8952_REG_RAMP) & 0x1F) |
+                       ((pdata->ramp_speed & 0x7) << 5));
+
+       i2c_set_clientdata(client, max8952);
+
+       return 0;
+
+err_reg:
+       kfree(max8952);
+       return ret;
+}
+
+static int __devexit max8952_pmic_remove(struct i2c_client *client)
+{
+       struct max8952_data *max8952 = i2c_get_clientdata(client);
+       struct max8952_platform_data *pdata = max8952->pdata;
+       struct regulator_dev *rdev = max8952->rdev;
+
+       regulator_unregister(rdev);
+
+       gpio_free(pdata->gpio_vid0);
+       gpio_free(pdata->gpio_vid1);
+       gpio_free(pdata->gpio_en);
+
+       kfree(max8952);
+       return 0;
+}
+
+static const struct i2c_device_id max8952_ids[] = {
+       { "max8952", 0 },
+       { },
+};
+MODULE_DEVICE_TABLE(i2c, max8952_ids);
+
+static struct i2c_driver max8952_pmic_driver = {
+       .probe          = max8952_pmic_probe,
+       .remove         = __devexit_p(max8952_pmic_remove),
+       .driver         = {
+               .name   = "max8952",
+       },
+       .id_table       = max8952_ids,
+};
+
+static int __init max8952_pmic_init(void)
+{
+       return i2c_add_driver(&max8952_pmic_driver);
+}
+subsys_initcall(max8952_pmic_init);
+
+static void __exit max8952_pmic_exit(void)
+{
+       i2c_del_driver(&max8952_pmic_driver);
+}
+module_exit(max8952_pmic_exit);
+
+MODULE_DESCRIPTION("MAXIM 8952 voltage regulator driver");
+MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
+MODULE_LICENSE("GPL");
index 2d6c6c8..1916164 100644 (file)
@@ -2718,7 +2718,7 @@ static int ext4_writepage(struct page *page,
         * try to create them using __block_write_begin.  If this
         * fails, redirty the page and move on.
         */
-       if (!page_buffers(page)) {
+       if (!page_has_buffers(page)) {
                if (__block_write_begin(page, 0, len,
                                        noalloc_get_block_write)) {
                redirty_page:
@@ -2732,12 +2732,10 @@ static int ext4_writepage(struct page *page,
        if (walk_page_buffers(NULL, page_bufs, 0, len, NULL,
                              ext4_bh_delay_or_unwritten)) {
                /*
-                * We don't want to do block allocation So redirty the
-                * page and return We may reach here when we do a
-                * journal commit via
-                * journal_submit_inode_data_buffers.  If we don't
-                * have mapping block we just ignore them. We can also
-                * reach here via shrink_page_list
+                * We don't want to do block allocation, so redirty
+                * the page and return.  We may reach here when we do
+                * a journal commit via journal_submit_inode_data_buffers.
+                * We can also reach here via shrink_page_list
                 */
                goto redirty_page;
        }
index 064a809..84d3c8b 100644 (file)
@@ -873,7 +873,7 @@ static ssize_t nfs_direct_write(struct kiocb *iocb, const struct iovec *iov,
        dreq->inode = inode;
        dreq->ctx = get_nfs_open_context(nfs_file_open_context(iocb->ki_filp));
        dreq->l_ctx = nfs_get_lock_context(dreq->ctx);
-       if (dreq->l_ctx != NULL)
+       if (dreq->l_ctx == NULL)
                goto out_release;
        if (!is_sync_kiocb(iocb))
                dreq->iocb = iocb;
index dec47ed..4e2d9b6 100644 (file)
@@ -123,7 +123,7 @@ static ssize_t nfs_idmap_get_desc(const char *name, size_t namelen,
        size_t desclen = typelen + namelen + 2;
 
        *desc = kmalloc(desclen, GFP_KERNEL);
-       if (!desc)
+       if (!*desc)
                return -ENOMEM;
 
        cp = *desc;
index 32c8758..0f24cdf 100644 (file)
@@ -429,7 +429,7 @@ static int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *
                 * returned NFS4ERR_DELAY as per Section 2.10.6.2
                 * of RFC5661.
                 */
-               dprintk("%s: slot=%ld seq=%d: Operation in progress\n",
+               dprintk("%s: slot=%td seq=%d: Operation in progress\n",
                        __func__,
                        res->sr_slot - res->sr_session->fc_slot_table.slots,
                        res->sr_slot->seq_nr);
@@ -573,7 +573,7 @@ int nfs4_setup_sequence(const struct nfs_server *server,
                goto out;
        }
 
-       dprintk("--> %s clp %p session %p sr_slot %ld\n",
+       dprintk("--> %s clp %p session %p sr_slot %td\n",
                __func__, session->clp, session, res->sr_slot ?
                        res->sr_slot - session->fc_slot_table.slots : -1);
 
index 9194902..137b549 100644 (file)
@@ -65,6 +65,13 @@ nfs_create_request(struct nfs_open_context *ctx, struct inode *inode,
        if (req == NULL)
                return ERR_PTR(-ENOMEM);
 
+       /* get lock context early so we can deal with alloc failures */
+       req->wb_lock_context = nfs_get_lock_context(ctx);
+       if (req->wb_lock_context == NULL) {
+               nfs_page_free(req);
+               return ERR_PTR(-ENOMEM);
+       }
+
        /* Initialize the request struct. Initially, we assume a
         * long write-back delay. This will be adjusted in
         * update_nfs_request below if the region is not locked. */
@@ -79,7 +86,6 @@ nfs_create_request(struct nfs_open_context *ctx, struct inode *inode,
        req->wb_pgbase  = offset;
        req->wb_bytes   = count;
        req->wb_context = get_nfs_open_context(ctx);
-       req->wb_lock_context = nfs_get_lock_context(ctx);
        kref_init(&req->wb_kref);
        return req;
 }
index 2c0fc10..bd69d79 100644 (file)
        . = ALIGN(4);                                                   \
        VMLINUX_SYMBOL(__initramfs_start) = .;                          \
        *(.init.ramfs)                                                  \
-       VMLINUX_SYMBOL(__initramfs_end) = .;
+       . = ALIGN(8);                                                   \
+       *(.init.ramfs.info)
 #else
 #define INIT_RAM_FS
 #endif
diff --git a/include/linux/regulator/lp3972.h b/include/linux/regulator/lp3972.h
new file mode 100644 (file)
index 0000000..9bb7389
--- /dev/null
@@ -0,0 +1,48 @@
+/*
+ * National Semiconductors LP3972 PMIC chip client interface
+ *
+ * Based on lp3971.h
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __LINUX_REGULATOR_LP3972_H
+#define __LINUX_REGULATOR_LP3972_H
+
+#include <linux/regulator/machine.h>
+
+#define LP3972_LDO1  0
+#define LP3972_LDO2  1
+#define LP3972_LDO3  2
+#define LP3972_LDO4  3
+#define LP3972_LDO5  4
+
+#define LP3972_DCDC1 5
+#define LP3972_DCDC2 6
+#define LP3972_DCDC3 7
+
+#define LP3972_NUM_REGULATORS 8
+
+struct lp3972_regulator_subdev {
+       int id;
+       struct regulator_init_data *initdata;
+};
+
+struct lp3972_platform_data {
+       int num_regulators;
+       struct lp3972_regulator_subdev *regulators;
+};
+
+#endif
index e298028..761c745 100644 (file)
@@ -189,10 +189,15 @@ int regulator_suspend_prepare(suspend_state_t state);
 
 #ifdef CONFIG_REGULATOR
 void regulator_has_full_constraints(void);
+void regulator_use_dummy_regulator(void);
 #else
 static inline void regulator_has_full_constraints(void)
 {
 }
+
+static inline void regulator_use_dummy_regulator(void)
+{
+}
 #endif
 
 #endif
diff --git a/include/linux/regulator/max8952.h b/include/linux/regulator/max8952.h
new file mode 100644 (file)
index 0000000..45e4285
--- /dev/null
@@ -0,0 +1,135 @@
+/*
+ * max8952.h - Voltage regulation for the Maxim 8952
+ *
+ *  Copyright (C) 2010 Samsung Electrnoics
+ *  MyungJoo Ham <myungjoo.ham@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef REGULATOR_MAX8952
+#define REGULATOR_MAX8952
+
+#include <linux/regulator/machine.h>
+
+enum {
+       MAX8952_DVS_MODE0,
+       MAX8952_DVS_MODE1,
+       MAX8952_DVS_MODE2,
+       MAX8952_DVS_MODE3,
+};
+
+enum {
+       MAX8952_DVS_770mV = 0,
+       MAX8952_DVS_780mV,
+       MAX8952_DVS_790mV,
+       MAX8952_DVS_800mV,
+       MAX8952_DVS_810mV,
+       MAX8952_DVS_820mV,
+       MAX8952_DVS_830mV,
+       MAX8952_DVS_840mV,
+       MAX8952_DVS_850mV,
+       MAX8952_DVS_860mV,
+       MAX8952_DVS_870mV,
+       MAX8952_DVS_880mV,
+       MAX8952_DVS_890mV,
+       MAX8952_DVS_900mV,
+       MAX8952_DVS_910mV,
+       MAX8952_DVS_920mV,
+       MAX8952_DVS_930mV,
+       MAX8952_DVS_940mV,
+       MAX8952_DVS_950mV,
+       MAX8952_DVS_960mV,
+       MAX8952_DVS_970mV,
+       MAX8952_DVS_980mV,
+       MAX8952_DVS_990mV,
+       MAX8952_DVS_1000mV,
+       MAX8952_DVS_1010mV,
+       MAX8952_DVS_1020mV,
+       MAX8952_DVS_1030mV,
+       MAX8952_DVS_1040mV,
+       MAX8952_DVS_1050mV,
+       MAX8952_DVS_1060mV,
+       MAX8952_DVS_1070mV,
+       MAX8952_DVS_1080mV,
+       MAX8952_DVS_1090mV,
+       MAX8952_DVS_1100mV,
+       MAX8952_DVS_1110mV,
+       MAX8952_DVS_1120mV,
+       MAX8952_DVS_1130mV,
+       MAX8952_DVS_1140mV,
+       MAX8952_DVS_1150mV,
+       MAX8952_DVS_1160mV,
+       MAX8952_DVS_1170mV,
+       MAX8952_DVS_1180mV,
+       MAX8952_DVS_1190mV,
+       MAX8952_DVS_1200mV,
+       MAX8952_DVS_1210mV,
+       MAX8952_DVS_1220mV,
+       MAX8952_DVS_1230mV,
+       MAX8952_DVS_1240mV,
+       MAX8952_DVS_1250mV,
+       MAX8952_DVS_1260mV,
+       MAX8952_DVS_1270mV,
+       MAX8952_DVS_1280mV,
+       MAX8952_DVS_1290mV,
+       MAX8952_DVS_1300mV,
+       MAX8952_DVS_1310mV,
+       MAX8952_DVS_1320mV,
+       MAX8952_DVS_1330mV,
+       MAX8952_DVS_1340mV,
+       MAX8952_DVS_1350mV,
+       MAX8952_DVS_1360mV,
+       MAX8952_DVS_1370mV,
+       MAX8952_DVS_1380mV,
+       MAX8952_DVS_1390mV,
+       MAX8952_DVS_1400mV,
+};
+
+enum {
+       MAX8952_SYNC_FREQ_26MHZ, /* Default */
+       MAX8952_SYNC_FREQ_13MHZ,
+       MAX8952_SYNC_FREQ_19_2MHZ,
+};
+
+enum {
+       MAX8952_RAMP_32mV_us = 0, /* Default */
+       MAX8952_RAMP_16mV_us,
+       MAX8952_RAMP_8mV_us,
+       MAX8952_RAMP_4mV_us,
+       MAX8952_RAMP_2mV_us,
+       MAX8952_RAMP_1mV_us,
+       MAX8952_RAMP_0_5mV_us,
+       MAX8952_RAMP_0_25mV_us,
+};
+
+#define MAX8952_NUM_DVS_MODE   4
+
+struct max8952_platform_data {
+       int gpio_vid0;
+       int gpio_vid1;
+       int gpio_en;
+
+       u8 default_mode;
+       u8 dvs_mode[MAX8952_NUM_DVS_MODE]; /* MAX8952_DVS_MODEx_XXXXmV */
+
+       u8 sync_freq;
+       u8 ramp_speed;
+
+       struct regulator_init_data reg_data;
+};
+
+
+#endif /* REGULATOR_MAX8952 */
index d9c6e78..2531811 100644 (file)
@@ -483,7 +483,8 @@ static int __init retain_initrd_param(char *str)
 }
 __setup("retain_initrd", retain_initrd_param);
 
-extern char __initramfs_start[], __initramfs_end[];
+extern char __initramfs_start[];
+extern unsigned long __initramfs_size;
 #include <linux/initrd.h>
 #include <linux/kexec.h>
 
@@ -570,8 +571,7 @@ static void __init clean_rootfs(void)
 
 static int __init populate_rootfs(void)
 {
-       char *err = unpack_to_rootfs(__initramfs_start,
-                        __initramfs_end - __initramfs_start);
+       char *err = unpack_to_rootfs(__initramfs_start, __initramfs_size);
        if (err)
                panic(err);     /* Failed to decompress INTERNAL initramfs */
        if (initrd_start) {
@@ -585,8 +585,7 @@ static int __init populate_rootfs(void)
                        return 0;
                } else {
                        clean_rootfs();
-                       unpack_to_rootfs(__initramfs_start,
-                                __initramfs_end - __initramfs_start);
+                       unpack_to_rootfs(__initramfs_start, __initramfs_size);
                }
                printk(KERN_INFO "rootfs image is not initramfs (%s)"
                                "; looks like an initrd\n", err);
index 6f89fbb..686cb0d 100644 (file)
@@ -45,6 +45,8 @@ __clean-files := $(extra-y) $(always)                  \
                   $(host-progs)                         \
                   $(hostprogs-y) $(hostprogs-m) $(hostprogs-)
 
+__clean-files   := $(filter-out $(no-clean-files), $(__clean-files))
+
 # as clean-files is given relative to the current directory, this adds
 # a $(obj) prefix, except for absolute paths
 
index 7bfcf1a..4c72c11 100644 (file)
@@ -120,7 +120,9 @@ _c_flags += $(if $(patsubst n%,, \
 endif
 
 ifdef CONFIG_SYMBOL_PREFIX
-_cpp_flags += -DSYMBOL_PREFIX=$(patsubst "%",%,$(CONFIG_SYMBOL_PREFIX))
+_sym_flags = -DSYMBOL_PREFIX=$(patsubst "%",%,$(CONFIG_SYMBOL_PREFIX))
+_cpp_flags += $(_sym_flags)
+_a_flags += $(_sym_flags)
 endif
 
 
index e3902fb..60dd3eb 100644 (file)
@@ -107,12 +107,8 @@ static int read_symbol(FILE *in, struct sym_entry *s)
 
        rc = fscanf(in, "%llx %c %499s\n", &s->addr, &stype, str);
        if (rc != 3) {
-               if (rc != EOF) {
-                       /* skip line. sym is used as dummy to
-                        * shut of "warn_unused_result" warning.
-                        */
-                       sym = fgets(str, 500, in);
-               }
+               if (rc != EOF && fgets(str, 500, in) == NULL)
+                       fprintf(stderr, "Read error or end of file.\n");
                return -1;
        }
 
index 1ec7158..33122ca 100644 (file)
@@ -1208,6 +1208,9 @@ static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
  * .cpuinit.data => __cpudata
  * .memexitconst => __memconst
  * etc.
+ *
+ * The memory of returned value has been allocated on a heap. The user of this
+ * method should free it after usage.
 */
 static char *sec2annotation(const char *s)
 {
@@ -1230,7 +1233,7 @@ static char *sec2annotation(const char *s)
                        strcat(p, "data ");
                else
                        strcat(p, " ");
-               return r; /* we leak her but we do not care */
+               return r;
        } else {
                return strdup("");
        }
index 057b6b3..ef8729f 100755 (executable)
@@ -160,8 +160,10 @@ if test "$CONFIG_LOCALVERSION_AUTO" = "y"; then
        # full scm version string
        res="$res$(scm_version)"
 else
-       # apped a plus sign if the repository is not in a clean tagged
-       # state and  LOCALVERSION= is not specified
+       # append a plus sign if the repository is not in a clean
+       # annotated or signed tagged state (as git describe only
+       # looks at signed or annotated tags - git tag -a/-s) and
+       # LOCALVERSION= is not specified
        if test "${LOCALVERSION+set}" != "set"; then
                scm=$(scm_version --short)
                res="$res${scm:++}"
index 6b4b6da..6faa444 100644 (file)
@@ -18,13 +18,15 @@ suffix_$(CONFIG_INITRAMFS_COMPRESSION_LZMA)   = .lzma
 # Lzo
 suffix_$(CONFIG_INITRAMFS_COMPRESSION_LZO)   = .lzo
 
+AFLAGS_initramfs_data.o += -DINITRAMFS_IMAGE="usr/initramfs_data.cpio$(suffix_y)"
+
 # Generate builtin.o based on initramfs_data.o
-obj-$(CONFIG_BLK_DEV_INITRD) := initramfs_data$(suffix_y).o
+obj-$(CONFIG_BLK_DEV_INITRD) := initramfs_data.o
 
 # initramfs_data.o contains the compressed initramfs_data.cpio image.
 # The image is included using .incbin, a dependency which is not
 # tracked automatically.
-$(obj)/initramfs_data$(suffix_y).o: $(obj)/initramfs_data.cpio$(suffix_y) FORCE
+$(obj)/initramfs_data.o: $(obj)/initramfs_data.cpio$(suffix_y) FORCE
 
 #####
 # Generate the initramfs cpio archive
index 7c6973d..b9efed5 100644 (file)
   -T initramfs_data.scr initramfs_data.cpio.gz -o initramfs_data.o
    ld -m elf_i386  -r -o built-in.o initramfs_data.o
 
-  initramfs_data.scr looks like this:
-SECTIONS
-{
-       .init.ramfs : { *(.data) }
-}
+  For including the .init.ramfs sections, see include/asm-generic/vmlinux.lds.
 
   The above example is for i386 - the parameters vary from architectures.
   Eventually look up LDFLAGS_BLOB in an older version of the
@@ -25,6 +21,17 @@ SECTIONS
   in the ELF header, as required by certain architectures.
 */
 
-.section .init.ramfs,"a"
-.incbin "usr/initramfs_data.cpio"
+#include <linux/stringify.h>
 
+.section .init.ramfs,"a"
+__irf_start:
+.incbin __stringify(INITRAMFS_IMAGE)
+__irf_end:
+.section .init.ramfs.info,"a"
+.globl __initramfs_size
+__initramfs_size:
+#ifdef CONFIG_32BIT
+       .long __irf_end - __irf_start
+#else
+       .quad __irf_end - __irf_start
+#endif
diff --git a/usr/initramfs_data.bz2.S b/usr/initramfs_data.bz2.S
deleted file mode 100644 (file)
index bc54d09..0000000
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-  initramfs_data includes the compressed binary that is the
-  filesystem used for early user space.
-  Note: Older versions of "as" (prior to binutils 2.11.90.0.23
-  released on 2001-07-14) dit not support .incbin.
-  If you are forced to use older binutils than that then the
-  following trick can be applied to create the resulting binary:
-
-
-  ld -m elf_i386  --format binary --oformat elf32-i386 -r \
-  -T initramfs_data.scr initramfs_data.cpio.gz -o initramfs_data.o
-   ld -m elf_i386  -r -o built-in.o initramfs_data.o
-
-  initramfs_data.scr looks like this:
-SECTIONS
-{
-       .init.ramfs : { *(.data) }
-}
-
-  The above example is for i386 - the parameters vary from architectures.
-  Eventually look up LDFLAGS_BLOB in an older version of the
-  arch/$(ARCH)/Makefile to see the flags used before .incbin was introduced.
-
-  Using .incbin has the advantage over ld that the correct flags are set
-  in the ELF header, as required by certain architectures.
-*/
-
-.section .init.ramfs,"a"
-.incbin "usr/initramfs_data.cpio.bz2"
diff --git a/usr/initramfs_data.gz.S b/usr/initramfs_data.gz.S
deleted file mode 100644 (file)
index 890c8dd..0000000
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-  initramfs_data includes the compressed binary that is the
-  filesystem used for early user space.
-  Note: Older versions of "as" (prior to binutils 2.11.90.0.23
-  released on 2001-07-14) dit not support .incbin.
-  If you are forced to use older binutils than that then the
-  following trick can be applied to create the resulting binary:
-
-
-  ld -m elf_i386  --format binary --oformat elf32-i386 -r \
-  -T initramfs_data.scr initramfs_data.cpio.gz -o initramfs_data.o
-   ld -m elf_i386  -r -o built-in.o initramfs_data.o
-
-  initramfs_data.scr looks like this:
-SECTIONS
-{
-       .init.ramfs : { *(.data) }
-}
-
-  The above example is for i386 - the parameters vary from architectures.
-  Eventually look up LDFLAGS_BLOB in an older version of the
-  arch/$(ARCH)/Makefile to see the flags used before .incbin was introduced.
-
-  Using .incbin has the advantage over ld that the correct flags are set
-  in the ELF header, as required by certain architectures.
-*/
-
-.section .init.ramfs,"a"
-.incbin "usr/initramfs_data.cpio.gz"
diff --git a/usr/initramfs_data.lzma.S b/usr/initramfs_data.lzma.S
deleted file mode 100644 (file)
index e11469e..0000000
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-  initramfs_data includes the compressed binary that is the
-  filesystem used for early user space.
-  Note: Older versions of "as" (prior to binutils 2.11.90.0.23
-  released on 2001-07-14) dit not support .incbin.
-  If you are forced to use older binutils than that then the
-  following trick can be applied to create the resulting binary:
-
-
-  ld -m elf_i386  --format binary --oformat elf32-i386 -r \
-  -T initramfs_data.scr initramfs_data.cpio.gz -o initramfs_data.o
-   ld -m elf_i386  -r -o built-in.o initramfs_data.o
-
-  initramfs_data.scr looks like this:
-SECTIONS
-{
-       .init.ramfs : { *(.data) }
-}
-
-  The above example is for i386 - the parameters vary from architectures.
-  Eventually look up LDFLAGS_BLOB in an older version of the
-  arch/$(ARCH)/Makefile to see the flags used before .incbin was introduced.
-
-  Using .incbin has the advantage over ld that the correct flags are set
-  in the ELF header, as required by certain architectures.
-*/
-
-.section .init.ramfs,"a"
-.incbin "usr/initramfs_data.cpio.lzma"
diff --git a/usr/initramfs_data.lzo.S b/usr/initramfs_data.lzo.S
deleted file mode 100644 (file)
index 5921190..0000000
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-  initramfs_data includes the compressed binary that is the
-  filesystem used for early user space.
-  Note: Older versions of "as" (prior to binutils 2.11.90.0.23
-  released on 2001-07-14) dit not support .incbin.
-  If you are forced to use older binutils than that then the
-  following trick can be applied to create the resulting binary:
-
-
-  ld -m elf_i386  --format binary --oformat elf32-i386 -r \
-  -T initramfs_data.scr initramfs_data.cpio.gz -o initramfs_data.o
-   ld -m elf_i386  -r -o built-in.o initramfs_data.o
-
-  initramfs_data.scr looks like this:
-SECTIONS
-{
-       .init.ramfs : { *(.data) }
-}
-
-  The above example is for i386 - the parameters vary from architectures.
-  Eventually look up LDFLAGS_BLOB in an older version of the
-  arch/$(ARCH)/Makefile to see the flags used before .incbin was introduced.
-
-  Using .incbin has the advantage over ld that the correct flags are set
-  in the ELF header, as required by certain architectures.
-*/
-
-.section .init.ramfs,"a"
-.incbin "usr/initramfs_data.cpio.lzo"