Merge remote branch 'remotes/backfire/master' into xburst

target/linux/generic-2.6/config-2.6.30

@@ -336,6 +336,7 @@ CONFIG_COMPAT_NET_DEV_OPS=y
 # CONFIG_CPU_FREQ is not set
 # CONFIG_CPU_IDLE is not set
 # CONFIG_CRAMFS is not set
+CONFIG_CRASHLOG=y
 # CONFIG_CRASH_DUMP is not set
 # CONFIG_CRC16 is not set
 CONFIG_CRC32=y
@@ -1008,6 +1009,7 @@ CONFIG_IPW2200_MONITOR=y
 # CONFIG_ISCSI_TCP is not set
 CONFIG_ISDN=y
 # CONFIG_ISDN_AUDIO is not set
+# CONFIG_ISDN_CAPI is not set
 # CONFIG_ISDN_CAPI_CAPIDRV is not set
 # CONFIG_ISDN_DIVERSION is not set
 # CONFIG_ISDN_DRV_ACT2000 is not set
@@ -1019,6 +1021,7 @@ CONFIG_ISDN=y
 # CONFIG_ISDN_DRV_PCBIT is not set
 # CONFIG_ISDN_DRV_SC is not set
 # CONFIG_ISDN_DRV_TPAM is not set
+# CONFIG_ISDN_I4L is not set
 # CONFIG_ISDN_WITH_ABC is not set
 # CONFIG_ISL29003 is not set
 # CONFIG_ISO9660_FS is not set
@@ -1054,6 +1057,7 @@ CONFIG_JFFS2_ZLIB=y
 # CONFIG_JFS_STATISTICS is not set
 # CONFIG_JME is not set
 CONFIG_JOLIET=y
+# CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
 # CONFIG_KALLSYMS is not set
 # CONFIG_KARMA_PARTITION is not set
@@ -2229,6 +2233,7 @@ CONFIG_TEXTSEARCH=y
 CONFIG_TICK_ONESHOT=y
 # CONFIG_TIFM_CORE is not set
 # CONFIG_TIGON3 is not set
+# CONFIG_TIMER_STATS is not set
 CONFIG_TIMERFD=y
 # CONFIG_TINY_SHMEM is not set
 # CONFIG_TIPC is not set

target/linux/generic-2.6/config-2.6.32

@@ -351,6 +351,7 @@ CONFIG_CONSTRUCTORS=y
 # CONFIG_CPU_FREQ is not set
 # CONFIG_CPU_IDLE is not set
 # CONFIG_CRAMFS is not set
+CONFIG_CRASHLOG=y
 # CONFIG_CRASH_DUMP is not set
 # CONFIG_CRC16 is not set
 CONFIG_CRC32=y
@@ -1059,6 +1060,7 @@ CONFIG_IPW2200_MONITOR=y
 # CONFIG_ISCSI_TCP is not set
 CONFIG_ISDN=y
 # CONFIG_ISDN_AUDIO is not set
+# CONFIG_ISDN_CAPI is not set
 # CONFIG_ISDN_CAPI_CAPIDRV is not set
 # CONFIG_ISDN_DIVERSION is not set
 # CONFIG_ISDN_DRV_ACT2000 is not set
@@ -1070,6 +1072,7 @@ CONFIG_ISDN=y
 # CONFIG_ISDN_DRV_PCBIT is not set
 # CONFIG_ISDN_DRV_SC is not set
 # CONFIG_ISDN_DRV_TPAM is not set
+# CONFIG_ISDN_I4L is not set
 # CONFIG_ISDN_WITH_ABC is not set
 # CONFIG_ISL29003 is not set
 # CONFIG_ISO9660_FS is not set
@@ -1105,6 +1108,7 @@ CONFIG_JFFS2_ZLIB=y
 # CONFIG_JFS_STATISTICS is not set
 # CONFIG_JME is not set
 CONFIG_JOLIET=y
+# CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
 # CONFIG_KALLSYMS is not set
 # CONFIG_KARMA_PARTITION is not set
@@ -2350,6 +2354,7 @@ CONFIG_TEXTSEARCH=y
 CONFIG_TICK_ONESHOT=y
 # CONFIG_TIFM_CORE is not set
 # CONFIG_TIGON3 is not set
+# CONFIG_TIMER_STATS is not set
 CONFIG_TIMERFD=y
 # CONFIG_TINY_SHMEM is not set
 # CONFIG_TIPC is not set

target/linux/generic-2.6/files/drivers/net/phy/rtl8366_smi.c

@@ -14,6 +14,11 @@
 #include <linux/delay.h>
 #include <linux/gpio.h>
 #include <linux/spinlock.h>
+#include <linux/skbuff.h>
+
+#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
+#include <linux/debugfs.h>
+#endif
 
 #include "rtl8366_smi.h"
 
@@ -265,6 +270,477 @@ int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
 }
 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg);
 
+int rtl8366_smi_rmwr(struct rtl8366_smi *smi, u32 addr, u32 mask, u32 data)
+{
+	u32 t;
+	int err;
+
+	err = rtl8366_smi_read_reg(smi, addr, &t);
+	if (err)
+		return err;
+
+	err = rtl8366_smi_write_reg(smi, addr, (t & ~mask) | data);
+	return err;
+
+}
+EXPORT_SYMBOL_GPL(rtl8366_smi_rmwr);
+
+static int rtl8366_mc_is_used(struct rtl8366_smi *smi, int mc_index, int *used)
+{
+	int err;
+	int i;
+
+	*used = 0;
+	for (i = 0; i < smi->num_ports; i++) {
+		int index = 0;
+
+		err = smi->ops->get_mc_index(smi, i, &index);
+		if (err)
+			return err;
+
+		if (mc_index == index) {
+			*used = 1;
+			break;
+		}
+	}
+
+	return 0;
+}
+
+int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member, u32 untag,
+		     u32 fid)
+{
+	struct rtl8366_vlan_4k vlan4k;
+	int err;
+	int i;
+
+	/* Update the 4K table */
+	err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
+	if (err)
+		return err;
+
+	vlan4k.member = member;
+	vlan4k.untag = untag;
+	vlan4k.fid = fid;
+	err = smi->ops->set_vlan_4k(smi, &vlan4k);
+	if (err)
+		return err;
+
+	/* Try to find an existing MC entry for this VID */
+	for (i = 0; i < smi->num_vlan_mc; i++) {
+		struct rtl8366_vlan_mc vlanmc;
+
+		err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
+		if (err)
+			return err;
+
+		if (vid == vlanmc.vid) {
+			/* update the MC entry */
+			vlanmc.member = member;
+			vlanmc.untag = untag;
+			vlanmc.fid = fid;
+
+			err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
+			break;
+		}
+	}
+
+	return err;
+}
+EXPORT_SYMBOL_GPL(rtl8366_set_vlan);
+
+int rtl8366_reset_vlan(struct rtl8366_smi *smi)
+{
+	struct rtl8366_vlan_mc vlanmc;
+	int err;
+	int i;
+
+	/* clear VLAN member configurations */
+	vlanmc.vid = 0;
+	vlanmc.priority = 0;
+	vlanmc.member = 0;
+	vlanmc.untag = 0;
+	vlanmc.fid = 0;
+	for (i = 0; i < smi->num_vlan_mc; i++) {
+		err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
+		if (err)
+			return err;
+	}
+
+	for (i = 0; i < smi->num_ports; i++) {
+		if (i == smi->cpu_port)
+			continue;
+
+		err = rtl8366_set_vlan(smi, (i + 1),
+					(1 << i) | (1 << smi->cpu_port),
+					(1 << i) | (1 << smi->cpu_port),
+					0);
+		if (err)
+			return err;
+
+		err = rtl8366_set_pvid(smi, i, (i + 1));
+		if (err)
+			return err;
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);
+
+int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val)
+{
+	struct rtl8366_vlan_mc vlanmc;
+	int err;
+	int index;
+
+	err = smi->ops->get_mc_index(smi, port, &index);
+	if (err)
+		return err;
+
+	err = smi->ops->get_vlan_mc(smi, index, &vlanmc);
+	if (err)
+		return err;
+
+	*val = vlanmc.vid;
+	return 0;
+}
+EXPORT_SYMBOL_GPL(rtl8366_get_pvid);
+
+int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port, unsigned vid)
+{
+	struct rtl8366_vlan_mc vlanmc;
+	struct rtl8366_vlan_4k vlan4k;
+	int err;
+	int i;
+
+	/* Try to find an existing MC entry for this VID */
+	for (i = 0; i < smi->num_vlan_mc; i++) {
+		err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
+		if (err)
+			return err;
+
+		if (vid == vlanmc.vid) {
+			err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
+			if (err)
+				return err;
+
+			err = smi->ops->set_mc_index(smi, port, i);
+			return err;
+		}
+	}
+
+	/* We have no MC entry for this VID, try to find an empty one */
+	for (i = 0; i < smi->num_vlan_mc; i++) {
+		err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
+		if (err)
+			return err;
+
+		if (vlanmc.vid == 0 && vlanmc.member == 0) {
+			/* Update the entry from the 4K table */
+			err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
+			if (err)
+				return err;
+
+			vlanmc.vid = vid;
+			vlanmc.member = vlan4k.member;
+			vlanmc.untag = vlan4k.untag;
+			vlanmc.fid = vlan4k.fid;
+			err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
+			if (err)
+				return err;
+
+			err = smi->ops->set_mc_index(smi, port, i);
+			return err;
+		}
+	}
+
+	/* MC table is full, try to find an unused entry and replace it */
+	for (i = 0; i < smi->num_vlan_mc; i++) {
+		int used;
+
+		err = rtl8366_mc_is_used(smi, i, &used);
+		if (err)
+			return err;
+
+		if (!used) {
+			/* Update the entry from the 4K table */
+			err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
+			if (err)
+				return err;
+
+			vlanmc.vid = vid;
+			vlanmc.member = vlan4k.member;
+			vlanmc.untag = vlan4k.untag;
+			vlanmc.fid = vlan4k.fid;
+			err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
+			if (err)
+				return err;
+
+			err = smi->ops->set_mc_index(smi, port, i);
+			return err;
+		}
+	}
+
+	dev_err(smi->parent,
+		"all VLAN member configurations are in use\n");
+
+	return -ENOSPC;
+}
+EXPORT_SYMBOL_GPL(rtl8366_set_pvid);
+
+#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
+int rtl8366_debugfs_open(struct inode *inode, struct file *file)
+{
+	file->private_data = inode->i_private;
+	return 0;
+}
+EXPORT_SYMBOL_GPL(rtl8366_debugfs_open);
+
+static ssize_t rtl8366_read_debugfs_vlan_mc(struct file *file,
+					      char __user *user_buf,
+					      size_t count, loff_t *ppos)
+{
+	struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
+	int i, len = 0;
+	char *buf = smi->buf;
+
+	len += snprintf(buf + len, sizeof(smi->buf) - len,
+			"%2s %6s %4s %6s %6s %3s\n",
+			"id", "vid","prio", "member", "untag", "fid");
+
+	for (i = 0; i < smi->num_vlan_mc; ++i) {
+		struct rtl8366_vlan_mc vlanmc;
+
+		smi->ops->get_vlan_mc(smi, i, &vlanmc);
+
+		len += snprintf(buf + len, sizeof(smi->buf) - len,
+				"%2d %6d %4d 0x%04x 0x%04x %3d\n",
+				i, vlanmc.vid, vlanmc.priority,
+				vlanmc.member, vlanmc.untag, vlanmc.fid);
+	}
+
+	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+}
+
+static ssize_t rtl8366_read_debugfs_reg(struct file *file,
+					 char __user *user_buf,
+					 size_t count, loff_t *ppos)
+{
+	struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
+	u32 t, reg = smi->dbg_reg;
+	int err, len = 0;
+	char *buf = smi->buf;
+
+	memset(buf, '\0', sizeof(smi->buf));
+
+	err = rtl8366_smi_read_reg(smi, reg, &t);
+	if (err) {
+		len += snprintf(buf, sizeof(smi->buf),
+				"Read failed (reg: 0x%04x)\n", reg);
+		return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+	}
+
+	len += snprintf(buf, sizeof(smi->buf), "reg = 0x%04x, val = 0x%04x\n",
+			reg, t);
+
+	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+}
+
+static ssize_t rtl8366_write_debugfs_reg(struct file *file,
+					  const char __user *user_buf,
+					  size_t count, loff_t *ppos)
+{
+	struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
+	unsigned long data;
+	u32 reg = smi->dbg_reg;
+	int err;
+	size_t len;
+	char *buf = smi->buf;
+
+	len = min(count, sizeof(smi->buf) - 1);
+	if (copy_from_user(buf, user_buf, len)) {
+		dev_err(smi->parent, "copy from user failed\n");
+		return -EFAULT;
+	}
+
+	buf[len] = '\0';
+	if (len > 0 && buf[len - 1] == '\n')
+		buf[len - 1] = '\0';
+
+
+	if (strict_strtoul(buf, 16, &data)) {
+		dev_err(smi->parent, "Invalid reg value %s\n", buf);
+	} else {
+		err = rtl8366_smi_write_reg(smi, reg, data);
+		if (err) {
+			dev_err(smi->parent,
+				"writing reg 0x%04x val 0x%04lx failed\n",
+				reg, data);
+		}
+	}
+
+	return count;
+}
+
+static ssize_t rtl8366_read_debugfs_mibs(struct file *file,
+					 char __user *user_buf,
+					 size_t count, loff_t *ppos)
+{
+	struct rtl8366_smi *smi = file->private_data;
+	int i, j, len = 0;
+	char *buf = smi->buf;
+
+	len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s",
+			"Counter");
+
+	for (i = 0; i < smi->num_ports; i++) {
+		char port_buf[10];
+
+		snprintf(port_buf, sizeof(port_buf), "Port %d", i);
+		len += snprintf(buf + len, sizeof(smi->buf) - len, " %12s",
+				port_buf);
+	}
+	len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
+
+	for (i = 0; i < smi->num_mib_counters; i++) {
+		len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s ",
+				smi->mib_counters[i].name);
+		for (j = 0; j < smi->num_ports; j++) {
+			unsigned long long counter = 0;
+
+			if (!smi->ops->get_mib_counter(smi, i, j, &counter))
+				len += snprintf(buf + len,
+						sizeof(smi->buf) - len,
+						"%12llu ", counter);
+			else
+				len += snprintf(buf + len,
+						sizeof(smi->buf) - len,
+						"%12s ", "error");
+		}
+		len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
+	}
+
+	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+}
+
+static const struct file_operations fops_rtl8366_regs = {
+	.read	= rtl8366_read_debugfs_reg,
+	.write	= rtl8366_write_debugfs_reg,
+	.open	= rtl8366_debugfs_open,
+	.owner	= THIS_MODULE
+};
+
+static const struct file_operations fops_rtl8366_vlan_mc = {
+	.read	= rtl8366_read_debugfs_vlan_mc,
+	.open	= rtl8366_debugfs_open,
+	.owner	= THIS_MODULE
+};
+
+static const struct file_operations fops_rtl8366_mibs = {
+	.read = rtl8366_read_debugfs_mibs,
+	.open = rtl8366_debugfs_open,
+	.owner = THIS_MODULE
+};
+
+static void rtl8366_debugfs_init(struct rtl8366_smi *smi)
+{
+	struct dentry *node;
+	struct dentry *root;
+
+	if (!smi->debugfs_root)
+		smi->debugfs_root = debugfs_create_dir(dev_name(smi->parent),
+						       NULL);
+
+	if (!smi->debugfs_root) {
+		dev_err(smi->parent, "Unable to create debugfs dir\n");
+		return;
+	}
+	root = smi->debugfs_root;
+
+	node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root,
+				  &smi->dbg_reg);
+	if (!node) {
+		dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
+			"reg");
+		return;
+	}
+
+	node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, smi,
+				   &fops_rtl8366_regs);
+	if (!node) {
+		dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
+			"val");
+		return;
+	}
+
+	node = debugfs_create_file("vlan_mc", S_IRUSR, root, smi,
+				   &fops_rtl8366_vlan_mc);
+	if (!node) {
+		dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
+			"vlan_mc");
+		return;
+	}
+
+	node = debugfs_create_file("mibs", S_IRUSR, smi->debugfs_root, smi,
+				   &fops_rtl8366_mibs);
+	if (!node)
+		dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
+			"mibs");
+}
+
+static void rtl8366_debugfs_remove(struct rtl8366_smi *smi)
+{
+	if (smi->debugfs_root) {
+		debugfs_remove_recursive(smi->debugfs_root);
+		smi->debugfs_root = NULL;
+	}
+}
+#else
+static inline void rtl8366_debugfs_init(struct rtl8366_smi *smi) {}
+static inline void rtl8366_debugfs_remove(struct rtl8366_smi *smi) {}
+#endif /* CONFIG_RTL8366S_PHY_DEBUG_FS */
+
+static int rtl8366_smi_mii_init(struct rtl8366_smi *smi)
+{
+	int ret;
+	int i;
+
+	smi->mii_bus = mdiobus_alloc();
+	if (smi->mii_bus == NULL) {
+		ret = -ENOMEM;
+		goto err;
+	}
+
+	smi->mii_bus->priv = (void *) smi;
+	smi->mii_bus->name = dev_name(smi->parent);
+	smi->mii_bus->read = smi->ops->mii_read;
+	smi->mii_bus->write = smi->ops->mii_write;
+	snprintf(smi->mii_bus->id, MII_BUS_ID_SIZE, "%s",
+		 dev_name(smi->parent));
+	smi->mii_bus->parent = smi->parent;
+	smi->mii_bus->phy_mask = ~(0x1f);
+	smi->mii_bus->irq = smi->mii_irq;
+	for (i = 0; i < PHY_MAX_ADDR; i++)
+		smi->mii_irq[i] = PHY_POLL;
+
+	ret = mdiobus_register(smi->mii_bus);
+	if (ret)
+		goto err_free;
+
+	return 0;
+
+ err_free:
+	mdiobus_free(smi->mii_bus);
+ err:
+	return ret;
+}
+
+static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi)
+{
+	mdiobus_unregister(smi->mii_bus);
+	mdiobus_free(smi->mii_bus);
+}
+
 int rtl8366_smi_init(struct rtl8366_smi *smi)
 {
 	int err;
@@ -272,6 +748,9 @@ int rtl8366_smi_init(struct rtl8366_smi *smi)
 	if (!smi->parent)
 		return -EINVAL;
 
+	if (!smi->ops)
+		return -EINVAL;
+
 	err = gpio_request(smi->gpio_sda, dev_name(smi->parent));
 	if (err) {
 		dev_err(smi->parent, "gpio_request failed for %u, err=%d\n",
@@ -291,8 +770,22 @@ int rtl8366_smi_init(struct rtl8366_smi *smi)
 	dev_info(smi->parent, "using GPIO pins %u (SDA) and %u (SCK)\n",
 		 smi->gpio_sda, smi->gpio_sck);
 
+	err = smi->ops->detect(smi);
+	if (err) {
+		dev_err(smi->parent, "chip detection failed, err=%d\n", err);
+		goto err_free_sck;
+	}
+
+	err = rtl8366_smi_mii_init(smi);
+	if (err)
+		goto err_free_sck;
+
+	rtl8366_debugfs_init(smi);
+
 	return 0;
 
+ err_free_sck:
+	gpio_free(smi->gpio_sck);
  err_free_sda:
 	gpio_free(smi->gpio_sda);
  err_out:
@@ -302,6 +795,8 @@ EXPORT_SYMBOL_GPL(rtl8366_smi_init);
 
 void rtl8366_smi_cleanup(struct rtl8366_smi *smi)
 {
+	rtl8366_debugfs_remove(smi);
+	rtl8366_smi_mii_cleanup(smi);
 	gpio_free(smi->gpio_sck);
 	gpio_free(smi->gpio_sda);
 }

target/linux/generic-2.6/files/drivers/net/phy/rtl8366_smi.h

@@ -11,16 +11,94 @@
 #ifndef _RTL8366_SMI_H
 #define _RTL8366_SMI_H
 
+#include <linux/phy.h>
+
+struct rtl8366_smi_ops;
+struct rtl8366_vlan_ops;
+struct mii_bus;
+struct dentry;
+struct inode;
+struct file;
+
+struct rtl8366_mib_counter {
+	unsigned	base;
+	unsigned	offset;
+	unsigned	length;
+	const char	*name;
+};
+
 struct rtl8366_smi {
 	struct device		*parent;
 	unsigned int		gpio_sda;
 	unsigned int		gpio_sck;
 	spinlock_t		lock;
+	struct mii_bus		*mii_bus;
+	int			mii_irq[PHY_MAX_ADDR];
+
+	unsigned int		cpu_port;
+	unsigned int		num_ports;
+	unsigned int		num_vlan_mc;
+	unsigned int		num_mib_counters;
+	struct rtl8366_mib_counter *mib_counters;
+
+	struct rtl8366_smi_ops	*ops;
+
+	char			buf[4096];
+#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
+	struct dentry           *debugfs_root;
+	u16			dbg_reg;
+#endif
+};
+
+struct rtl8366_vlan_mc {
+	u16	vid;
+	u8	priority;
+	u8	untag;
+	u8	member;
+	u8	fid;
+};
+
+struct rtl8366_vlan_4k {
+	u16	vid;
+	u8	untag;
+	u8	member;
+	u8	fid;
+};
+
+struct rtl8366_smi_ops {
+	int	(*detect)(struct rtl8366_smi *smi);
+
+	int	(*mii_read)(struct mii_bus *bus, int addr, int reg);
+	int	(*mii_write)(struct mii_bus *bus, int addr, int reg, u16 val);
+
+	int	(*get_vlan_mc)(struct rtl8366_smi *smi, u32 index,
+			       struct rtl8366_vlan_mc *vlanmc);
+	int	(*set_vlan_mc)(struct rtl8366_smi *smi, u32 index,
+			       const struct rtl8366_vlan_mc *vlanmc);
+	int	(*get_vlan_4k)(struct rtl8366_smi *smi, u32 vid,
+			       struct rtl8366_vlan_4k *vlan4k);
+	int	(*set_vlan_4k)(struct rtl8366_smi *smi,
+			       const struct rtl8366_vlan_4k *vlan4k);
+	int	(*get_mc_index)(struct rtl8366_smi *smi, int port, int *val);
+	int	(*set_mc_index)(struct rtl8366_smi *smi, int port, int index);
+	int	(*get_mib_counter)(struct rtl8366_smi *smi, int counter,
+				   int port, unsigned long long *val);
 };
 
 int rtl8366_smi_init(struct rtl8366_smi *smi);
 void rtl8366_smi_cleanup(struct rtl8366_smi *smi);
 int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data);
 int rtl8366_smi_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data);
+int rtl8366_smi_rmwr(struct rtl8366_smi *smi, u32 addr, u32 mask, u32 data);
+
+int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member, u32 untag,
+		     u32 fid);
+int rtl8366_reset_vlan(struct rtl8366_smi *smi);
+int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val);
+int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port, unsigned vid);
+
+#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
+int rtl8366_debugfs_open(struct inode *inode, struct file *file);
+#endif
 
 #endif /*  _RTL8366_SMI_H */

target/linux/generic-2.6/files/drivers/net/phy/swconfig.c

@@ -92,7 +92,7 @@ swconfig_set_vlan_ports(struct switch_dev *dev, const struct switch_attr *attr,
 		if (ports[i].id >= dev->ports)
 			return -EINVAL;
 
-		if (dev->set_port_pvid && !(ports[i].flags & SWITCH_PORT_FLAG_TAGGED))
+		if (dev->set_port_pvid && !(ports[i].flags & (1 << SWITCH_PORT_FLAG_TAGGED)))
 			dev->set_port_pvid(dev, ports[i].id, val->port_vlan);
 	}
 
@@ -688,7 +688,7 @@ swconfig_get_attr(struct sk_buff *skb, struct genl_info *info)
 	memset(&val, 0, sizeof(val));
 	attr = swconfig_lookup_attr(dev, info, &val);
 	if (!attr || !attr->get)
-		goto error_dev;
+		goto error;
 
 	if (attr->type == SWITCH_TYPE_PORTS) {
 		val.value.ports = dev->portbuf;
@@ -737,9 +737,8 @@ swconfig_get_attr(struct sk_buff *skb, struct genl_info *info)
 nla_put_failure:
 	if (msg)
 		nlmsg_free(msg);
-error_dev:
-	swconfig_put_dev(dev);
 error:
+	swconfig_put_dev(dev);
 	if (!err)
 		err = -ENOMEM;
 	return err;
@@ -887,6 +886,7 @@ unregister_switch(struct switch_dev *dev)
 	swconfig_lock();
 	list_del(&dev->dev_list);
 	swconfig_unlock();
+	spin_unlock(&dev->lock);
 }
 EXPORT_SYMBOL_GPL(unregister_switch);
 

target/linux/generic-2.6/patches-2.6.30/217-mini_fo_dentry_check.patch

@@ -0,0 +1,48 @@
+--- a/fs/mini_fo/meta.c
++++ b/fs/mini_fo/meta.c
+@@ -48,6 +48,9 @@ int meta_build_lists(dentry_t *dentry)
+ 					     dtohd2(dentry),
+ 					     strlen(META_FILENAME));
+ 		mutex_unlock(&dtohd2(dentry)->d_inode->i_mutex);
++		if (IS_ERR(meta_dentry))
++			goto out_ok;
++
+ 		if(!meta_dentry->d_inode) {
+ 			dput(meta_dentry);
+ 			goto out_ok;
+@@ -433,6 +436,8 @@ int meta_write_d_entry(dentry_t *dentry,
+ 	meta_dentry = lookup_one_len(META_FILENAME,
+ 				     dtohd2(dentry), strlen (META_FILENAME));
+ 	mutex_unlock(&dtohd2(dentry)->d_inode->i_mutex);
++	if (IS_ERR(meta_dentry))
++		return PTR_ERR(meta_dentry);
+ 
+ 	/* We need to create a META-file */
+         if(!meta_dentry->d_inode) {
+@@ -538,6 +543,8 @@ int meta_write_r_entry(dentry_t *dentry,
+ 				     dtohd2(dentry),
+ 				     strlen (META_FILENAME));
+ 	mutex_unlock(&dtohd2(dentry)->d_inode->i_mutex);
++	if (IS_ERR(meta_dentry))
++		return PTR_ERR(meta_dentry);
+ 
+         if(!meta_dentry->d_inode) {
+                 /* We need to create a META-file */
+@@ -656,6 +663,8 @@ int meta_sync_d_list(dentry_t *dentry, i
+ 				     dtohd2(dentry),
+ 				     strlen(META_FILENAME));
+ 	mutex_unlock(&dtohd2(dentry)->d_inode->i_mutex);
++	if (IS_ERR(meta_dentry))
++		return PTR_ERR(meta_dentry);
+ 
+         if(!meta_dentry->d_inode) {
+                 /* We need to create a META-file */
+@@ -803,6 +812,8 @@ int meta_sync_r_list(dentry_t *dentry, i
+ 				     dtohd2(dentry),
+ 				     strlen(META_FILENAME));
+ 	mutex_unlock(&dtohd2(dentry)->d_inode->i_mutex);
++	if (IS_ERR(meta_dentry))
++		return PTR_ERR(meta_dentry);
+ 
+         if(!meta_dentry->d_inode) {
+                 /* We need to create a META-file */

target/linux/generic-2.6/patches-2.6.30/930-kmsg_dump_backport.patch

@@ -0,0 +1,205 @@
+--- /dev/null
++++ b/include/linux/kmsg_dump.h
+@@ -0,0 +1,44 @@
++/*
++ * linux/include/kmsg_dump.h
++ *
++ * Copyright (C) 2009 Net Insight AB
++ *
++ * Author: Simon Kagstrom <simon.kagstrom@netinsight.net>
++ *
++ * This file is subject to the terms and conditions of the GNU General Public
++ * License.  See the file COPYING in the main directory of this archive
++ * for more details.
++ */
++#ifndef _LINUX_KMSG_DUMP_H
++#define _LINUX_KMSG_DUMP_H
++
++#include <linux/list.h>
++
++enum kmsg_dump_reason {
++	KMSG_DUMP_OOPS,
++	KMSG_DUMP_PANIC,
++};
++
++/**
++ * struct kmsg_dumper - kernel crash message dumper structure
++ * @dump:	The callback which gets called on crashes. The buffer is passed
++ * 		as two sections, where s1 (length l1) contains the older
++ * 		messages and s2 (length l2) contains the newer.
++ * @list:	Entry in the dumper list (private)
++ * @registered:	Flag that specifies if this is already registered
++ */
++struct kmsg_dumper {
++	void (*dump)(struct kmsg_dumper *dumper, enum kmsg_dump_reason reason,
++			const char *s1, unsigned long l1,
++			const char *s2, unsigned long l2);
++	struct list_head list;
++	int registered;
++};
++
++void kmsg_dump(enum kmsg_dump_reason reason);
++
++int kmsg_dump_register(struct kmsg_dumper *dumper);
++
++int kmsg_dump_unregister(struct kmsg_dumper *dumper);
++
++#endif /* _LINUX_KMSG_DUMP_H */
+--- a/kernel/panic.c
++++ b/kernel/panic.c
+@@ -10,6 +10,7 @@
+  */
+ #include <linux/debug_locks.h>
+ #include <linux/interrupt.h>
++#include <linux/kmsg_dump.h>
+ #include <linux/kallsyms.h>
+ #include <linux/notifier.h>
+ #include <linux/module.h>
+@@ -74,6 +75,7 @@
+ 	dump_stack();
+ #endif
+ 
++	kmsg_dump(KMSG_DUMP_PANIC);
+ 	/*
+ 	 * If we have crashed and we have a crash kernel loaded let it handle
+ 	 * everything else.
+@@ -337,6 +339,7 @@
+ {
+ 	do_oops_enter_exit();
+ 	print_oops_end_marker();
++	kmsg_dump(KMSG_DUMP_OOPS);
+ }
+ 
+ #ifdef WANT_WARN_ON_SLOWPATH
+--- a/kernel/printk.c
++++ b/kernel/printk.c
+@@ -33,6 +33,7 @@
+ #include <linux/bootmem.h>
+ #include <linux/syscalls.h>
+ #include <linux/kexec.h>
++#include <linux/kmsg_dump.h>
+ 
+ #include <asm/uaccess.h>
+ 
+@@ -1322,3 +1323,121 @@
+ }
+ EXPORT_SYMBOL(printk_timed_ratelimit);
+ #endif
++
++static DEFINE_SPINLOCK(dump_list_lock);
++static LIST_HEAD(dump_list);
++
++/**
++ * kmsg_dump_register - register a kernel log dumper.
++ * @dump: pointer to the kmsg_dumper structure
++ *
++ * Adds a kernel log dumper to the system. The dump callback in the
++ * structure will be called when the kernel oopses or panics and must be
++ * set. Returns zero on success and %-EINVAL or %-EBUSY otherwise.
++ */
++int kmsg_dump_register(struct kmsg_dumper *dumper)
++{
++	unsigned long flags;
++	int err = -EBUSY;
++
++	/* The dump callback needs to be set */
++	if (!dumper->dump)
++		return -EINVAL;
++
++	spin_lock_irqsave(&dump_list_lock, flags);
++	/* Don't allow registering multiple times */
++	if (!dumper->registered) {
++		dumper->registered = 1;
++		list_add_tail(&dumper->list, &dump_list);
++		err = 0;
++	}
++	spin_unlock_irqrestore(&dump_list_lock, flags);
++
++	return err;
++}
++EXPORT_SYMBOL_GPL(kmsg_dump_register);
++
++/**
++ * kmsg_dump_unregister - unregister a kmsg dumper.
++ * @dump: pointer to the kmsg_dumper structure
++ *
++ * Removes a dump device from the system. Returns zero on success and
++ * %-EINVAL otherwise.
++ */
++int kmsg_dump_unregister(struct kmsg_dumper *dumper)
++{
++	unsigned long flags;
++	int err = -EINVAL;
++
++	spin_lock_irqsave(&dump_list_lock, flags);
++	if (dumper->registered) {
++		dumper->registered = 0;
++		list_del(&dumper->list);
++		err = 0;
++	}
++	spin_unlock_irqrestore(&dump_list_lock, flags);
++
++	return err;
++}
++EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
++
++static const char const *kmsg_reasons[] = {
++	[KMSG_DUMP_OOPS]	= "oops",
++	[KMSG_DUMP_PANIC]	= "panic",
++};
++
++static const char *kmsg_to_str(enum kmsg_dump_reason reason)
++{
++	if (reason >= ARRAY_SIZE(kmsg_reasons) || reason < 0)
++		return "unknown";
++
++	return kmsg_reasons[reason];
++}
++
++/**
++ * kmsg_dump - dump kernel log to kernel message dumpers.
++ * @reason: the reason (oops, panic etc) for dumping
++ *
++ * Iterate through each of the dump devices and call the oops/panic
++ * callbacks with the log buffer.
++ */
++void kmsg_dump(enum kmsg_dump_reason reason)
++{
++	unsigned long end;
++	unsigned chars;
++	struct kmsg_dumper *dumper;
++	const char *s1, *s2;
++	unsigned long l1, l2;
++	unsigned long flags;
++
++	/* Theoretically, the log could move on after we do this, but
++	   there's not a lot we can do about that. The new messages
++	   will overwrite the start of what we dump. */
++	spin_lock_irqsave(&logbuf_lock, flags);
++	end = log_end & LOG_BUF_MASK;
++	chars = logged_chars;
++	spin_unlock_irqrestore(&logbuf_lock, flags);
++
++	if (logged_chars > end) {
++		s1 = log_buf + log_buf_len - logged_chars + end;
++		l1 = logged_chars - end;
++
++		s2 = log_buf;
++		l2 = end;
++	} else {
++		s1 = "";
++		l1 = 0;
++
++		s2 = log_buf + end - logged_chars;
++		l2 = logged_chars;
++	}
++
++	if (!spin_trylock_irqsave(&dump_list_lock, flags)) {
++		printk(KERN_ERR "dump_kmsg: dump list lock is held during %s, skipping dump\n",
++				kmsg_to_str(reason));
++		return;
++	}
++	list_for_each_entry(dumper, &dump_list, list)
++		dumper->dump(dumper, reason, s1, l1, s2, l2);
++	spin_unlock_irqrestore(&dump_list_lock, flags);
++}

target/linux/generic-2.6/patches-2.6.30/931-crashlog.patch

@@ -0,0 +1,241 @@
+--- a/init/Kconfig
++++ b/init/Kconfig
+@@ -723,6 +723,9 @@
+ 	  Allow user space to create what appear to be multiple instances
+ 	  of the network stack.
+ 
++config CRASHLOG
++	bool "Crash logging"
++
+ config BLK_DEV_INITRD
+ 	bool "Initial RAM filesystem and RAM disk (initramfs/initrd) support"
+ 	depends on BROKEN || !FRV
+--- a/kernel/Makefile
++++ b/kernel/Makefile
+@@ -95,6 +95,7 @@
+ obj-$(CONFIG_TRACING) += trace/
+ obj-$(CONFIG_SMP) += sched_cpupri.o
+ obj-$(CONFIG_SLOW_WORK) += slow-work.o
++obj-$(CONFIG_CRASHLOG) += crashlog.o
+ 
+ ifneq ($(CONFIG_SCHED_OMIT_FRAME_POINTER),y)
+ # According to Alan Modra <alan@linuxcare.com.au>, the -fno-omit-frame-pointer is
+--- a/mm/bootmem.c
++++ b/mm/bootmem.c
+@@ -12,6 +12,7 @@
+ #include <linux/pfn.h>
+ #include <linux/bootmem.h>
+ #include <linux/module.h>
++#include <linux/crashlog.h>
+ 
+ #include <asm/bug.h>
+ #include <asm/io.h>
+@@ -151,6 +152,7 @@
+ 	if (!bdata->node_bootmem_map)
+ 		return 0;
+ 
++	crashlog_init_mem(bdata);
+ 	start = bdata->node_min_pfn;
+ 	end = bdata->node_low_pfn;
+ 
+--- a/kernel/module.c
++++ b/kernel/module.c
+@@ -71,6 +71,9 @@
+ DEFINE_MUTEX(module_mutex);
+ EXPORT_SYMBOL_GPL(module_mutex);
+ static LIST_HEAD(modules);
++#ifdef CONFIG_CRASHLOG
++struct list_head *crashlog_modules = &modules;
++#endif
+ 
+ /* Waiting for a module to finish initializing? */
+ static DECLARE_WAIT_QUEUE_HEAD(module_wq);
+--- /dev/null
++++ b/include/linux/crashlog.h
+@@ -0,0 +1,12 @@
++#ifndef __CRASHLOG_H
++#define __CRASHLOG_H
++
++#ifdef CONFIG_CRASHLOG
++void __init crashlog_init_mem(struct bootmem_data *bdata);
++#else
++static inline void crashlog_init_mem(struct bootmem_data *bdata)
++{
++}
++#endif
++
++#endif
+--- /dev/null
++++ b/kernel/crashlog.c
+@@ -0,0 +1,171 @@
++/*
++ * Crash information logger
++ * Copyright (C) 2010 Felix Fietkau <nbd@openwrt.org>
++ *
++ * Based on ramoops.c
++ *   Copyright (C) 2010 Marco Stornelli <marco.stornelli@gmail.com>
++ *
++ * 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.
++ *
++ * 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., 51 Franklin St, Fifth Floor, Boston, MA
++ * 02110-1301 USA
++ *
++ */
++
++#include <linux/module.h>
++#include <linux/bootmem.h>
++#include <linux/debugfs.h>
++#include <linux/crashlog.h>
++#include <linux/kmsg_dump.h>
++#include <linux/module.h>
++#include <linux/pfn.h>
++#include <asm/io.h>
++
++#define CRASHLOG_PAGES	4
++#define CRASHLOG_SIZE	(CRASHLOG_PAGES * PAGE_SIZE)
++#define CRASHLOG_MAGIC	0xa1eedead
++
++/*
++ * Start the log at 1M before the end of RAM, as some boot loaders like
++ * to use the end of the RAM for stack usage and other things
++ * If this fails, fall back to using the last part.
++ */
++#define CRASHLOG_OFFSET	(1024 * 1024)
++
++struct crashlog_data {
++	u32 magic;
++	u32 len;
++	u8 data[];
++};
++
++static struct debugfs_blob_wrapper crashlog_blob;
++static unsigned long crashlog_addr = 0;
++static struct crashlog_data *crashlog_buf;
++static struct kmsg_dumper dump;
++static bool first = true;
++
++extern struct list_head *crashlog_modules;
++
++void __init crashlog_init_mem(bootmem_data_t *bdata)
++{
++	unsigned long addr;
++
++	if (crashlog_addr)
++		return;
++
++	addr = PFN_PHYS(bdata->node_low_pfn) - CRASHLOG_OFFSET;
++	if (reserve_bootmem(addr, CRASHLOG_SIZE, BOOTMEM_EXCLUSIVE) < 0) {
++		printk("Crashlog failed to allocate RAM at address 0x%lx\n", addr);
++		bdata->node_low_pfn -= CRASHLOG_PAGES;
++		addr = PFN_PHYS(bdata->node_low_pfn);
++	}
++	crashlog_addr = addr;
++}
++
++static void __init crashlog_copy(void)
++{
++	if (crashlog_buf->magic != CRASHLOG_MAGIC)
++		return;
++
++	if (!crashlog_buf->len || crashlog_buf->len >
++	    CRASHLOG_SIZE - sizeof(*crashlog_buf))
++		return;
++
++	crashlog_blob.size = crashlog_buf->len;
++	crashlog_blob.data = kmemdup(crashlog_buf->data,
++		crashlog_buf->len, GFP_KERNEL);
++
++	debugfs_create_blob("crashlog", 0700, NULL, &crashlog_blob);
++}
++
++static int get_maxlen(void)
++{
++	return CRASHLOG_SIZE - sizeof(*crashlog_buf) - crashlog_buf->len;
++}
++
++static void crashlog_printf(const char *fmt, ...)
++{
++	va_list args;
++	int len = get_maxlen();
++
++	if (!len)
++		return;
++
++	va_start(args, fmt);
++	crashlog_buf->len += vsnprintf(
++		&crashlog_buf->data[crashlog_buf->len],
++		len, fmt, args);
++	va_end(args);
++}
++
++static void crashlog_do_dump(struct kmsg_dumper *dumper,
++		enum kmsg_dump_reason reason, const char *s1, unsigned long l1,
++		const char *s2, unsigned long l2)
++{
++	unsigned long s1_start, s2_start;
++	unsigned long l1_cpy, l2_cpy;
++	struct timeval tv;
++	struct module *m;
++	char *buf;
++	int len;
++
++	if (!first)
++		crashlog_printf("\n===================================\n");
++
++	do_gettimeofday(&tv);
++	crashlog_printf("Time: %lu.%lu\n",
++		(long)tv.tv_sec, (long)tv.tv_usec);
++
++	if (first) {
++		crashlog_printf("Modules:");
++		list_for_each_entry(m, crashlog_modules, list) {
++			crashlog_printf("\t%s@%p+%x", m->name,
++			m->module_core, m->core_size,
++			m->module_init, m->init_size);
++		}
++		crashlog_printf("\n");
++		first = false;
++	}
++
++	buf = (char *)&crashlog_buf->data[crashlog_buf->len];
++	len = get_maxlen();
++
++	l2_cpy = min(l2, (unsigned long)len);
++	l1_cpy = min(l1, (unsigned long)len - l2_cpy);
++
++	s2_start = l2 - l2_cpy;
++	s1_start = l1 - l1_cpy;
++
++	memcpy(buf, s1 + s1_start, l1_cpy);
++	memcpy(buf + l1_cpy, s2 + s2_start, l2_cpy);
++	crashlog_buf->len += l1_cpy + l2_cpy;
++}
++
++
++int __init crashlog_init_fs(void)
++{
++	if (!crashlog_addr)
++		return -ENOMEM;
++
++	crashlog_buf = ioremap(crashlog_addr, CRASHLOG_SIZE);
++
++	crashlog_copy();
++
++	crashlog_buf->magic = CRASHLOG_MAGIC;
++	crashlog_buf->len = 0;
++
++	dump.dump = crashlog_do_dump;
++	kmsg_dump_register(&dump);
++
++	return 0;
++}
++module_init(crashlog_init_fs);

target/linux/generic-2.6/patches-2.6.30/942-ssb_add_dma_dev.patch

@@ -0,0 +1,29 @@
+--- a/drivers/ssb/main.c
++++ b/drivers/ssb/main.c
+@@ -465,6 +465,7 @@ static int ssb_devices_register(struct s
+ #ifdef CONFIG_SSB_PCIHOST
+ 			sdev->irq = bus->host_pci->irq;
+ 			dev->parent = &bus->host_pci->dev;
++			sdev->dma_dev = dev->parent;
+ #endif
+ 			break;
+ 		case SSB_BUSTYPE_PCMCIA:
+@@ -475,6 +476,7 @@ static int ssb_devices_register(struct s
+ 			break;
+ 		case SSB_BUSTYPE_SSB:
+ 			dev->dma_mask = &dev->coherent_dma_mask;
++			sdev->dma_dev = dev;
+ 			break;
+ 		default:
+ 			break;
+--- a/include/linux/ssb/ssb.h
++++ b/include/linux/ssb/ssb.h
+@@ -167,7 +167,7 @@ struct ssb_device {
+ 	 * is an optimization. */
+ 	const struct ssb_bus_ops *ops;
+ 
+-	struct device *dev;
++	struct device *dev, *dma_dev;
+ 
+ 	struct ssb_bus *bus;
+ 	struct ssb_device_id id;

target/linux/generic-2.6/patches-2.6.32/217-mini_fo_dentry_check.patch

@@ -0,0 +1,48 @@
+--- a/fs/mini_fo/meta.c
++++ b/fs/mini_fo/meta.c
+@@ -48,6 +48,9 @@ int meta_build_lists(dentry_t *dentry)
+ 					     dtohd2(dentry),
+ 					     strlen(META_FILENAME));
+ 		mutex_unlock(&dtohd2(dentry)->d_inode->i_mutex);
++		if (IS_ERR(meta_dentry))
++			goto out_ok;
++
+ 		if(!meta_dentry->d_inode) {
+ 			dput(meta_dentry);
+ 			goto out_ok;
+@@ -433,6 +436,8 @@ int meta_write_d_entry(dentry_t *dentry,
+ 	meta_dentry = lookup_one_len(META_FILENAME,
+ 				     dtohd2(dentry), strlen (META_FILENAME));
+ 	mutex_unlock(&dtohd2(dentry)->d_inode->i_mutex);
++	if (IS_ERR(meta_dentry))
++		return PTR_ERR(meta_dentry);
+ 
+ 	/* We need to create a META-file */
+         if(!meta_dentry->d_inode) {
+@@ -538,6 +543,8 @@ int meta_write_r_entry(dentry_t *dentry,
+ 				     dtohd2(dentry),
+ 				     strlen (META_FILENAME));
+ 	mutex_unlock(&dtohd2(dentry)->d_inode->i_mutex);
++	if (IS_ERR(meta_dentry))
++		return PTR_ERR(meta_dentry);
+ 
+         if(!meta_dentry->d_inode) {
+                 /* We need to create a META-file */
+@@ -656,6 +663,8 @@ int meta_sync_d_list(dentry_t *dentry, i
+ 				     dtohd2(dentry),
+ 				     strlen(META_FILENAME));
+ 	mutex_unlock(&dtohd2(dentry)->d_inode->i_mutex);
++	if (IS_ERR(meta_dentry))
++		return PTR_ERR(meta_dentry);
+ 
+         if(!meta_dentry->d_inode) {
+                 /* We need to create a META-file */
+@@ -803,6 +812,8 @@ int meta_sync_r_list(dentry_t *dentry, i
+ 				     dtohd2(dentry),
+ 				     strlen(META_FILENAME));
+ 	mutex_unlock(&dtohd2(dentry)->d_inode->i_mutex);
++	if (IS_ERR(meta_dentry))
++		return PTR_ERR(meta_dentry);
+ 
+         if(!meta_dentry->d_inode) {
+                 /* We need to create a META-file */

target/linux/generic-2.6/patches-2.6.32/930-kmsg_dump_backport.patch

@@ -0,0 +1,205 @@
+--- /dev/null
++++ b/include/linux/kmsg_dump.h
+@@ -0,0 +1,44 @@
++/*
++ * linux/include/kmsg_dump.h
++ *
++ * Copyright (C) 2009 Net Insight AB
++ *
++ * Author: Simon Kagstrom <simon.kagstrom@netinsight.net>
++ *
++ * This file is subject to the terms and conditions of the GNU General Public
++ * License.  See the file COPYING in the main directory of this archive
++ * for more details.
++ */
++#ifndef _LINUX_KMSG_DUMP_H
++#define _LINUX_KMSG_DUMP_H
++
++#include <linux/list.h>
++
++enum kmsg_dump_reason {
++	KMSG_DUMP_OOPS,
++	KMSG_DUMP_PANIC,
++};
++
++/**
++ * struct kmsg_dumper - kernel crash message dumper structure
++ * @dump:	The callback which gets called on crashes. The buffer is passed
++ * 		as two sections, where s1 (length l1) contains the older
++ * 		messages and s2 (length l2) contains the newer.
++ * @list:	Entry in the dumper list (private)
++ * @registered:	Flag that specifies if this is already registered
++ */
++struct kmsg_dumper {
++	void (*dump)(struct kmsg_dumper *dumper, enum kmsg_dump_reason reason,
++			const char *s1, unsigned long l1,
++			const char *s2, unsigned long l2);
++	struct list_head list;
++	int registered;
++};
++
++void kmsg_dump(enum kmsg_dump_reason reason);
++
++int kmsg_dump_register(struct kmsg_dumper *dumper);
++
++int kmsg_dump_unregister(struct kmsg_dumper *dumper);
++
++#endif /* _LINUX_KMSG_DUMP_H */
+--- a/kernel/panic.c
++++ b/kernel/panic.c
+@@ -10,6 +10,7 @@
+  */
+ #include <linux/debug_locks.h>
+ #include <linux/interrupt.h>
++#include <linux/kmsg_dump.h>
+ #include <linux/kallsyms.h>
+ #include <linux/notifier.h>
+ #include <linux/module.h>
+@@ -74,6 +75,7 @@ NORET_TYPE void panic(const char * fmt, 
+ 	dump_stack();
+ #endif
+ 
++	kmsg_dump(KMSG_DUMP_PANIC);
+ 	/*
+ 	 * If we have crashed and we have a crash kernel loaded let it handle
+ 	 * everything else.
+@@ -339,6 +341,7 @@ void oops_exit(void)
+ {
+ 	do_oops_enter_exit();
+ 	print_oops_end_marker();
++	kmsg_dump(KMSG_DUMP_OOPS);
+ }
+ 
+ #ifdef WANT_WARN_ON_SLOWPATH
+--- a/kernel/printk.c
++++ b/kernel/printk.c
+@@ -33,6 +33,7 @@
+ #include <linux/bootmem.h>
+ #include <linux/syscalls.h>
+ #include <linux/kexec.h>
++#include <linux/kmsg_dump.h>
+ 
+ #include <asm/uaccess.h>
+ 
+@@ -1405,3 +1406,121 @@ bool printk_timed_ratelimit(unsigned lon
+ }
+ EXPORT_SYMBOL(printk_timed_ratelimit);
+ #endif
++
++static DEFINE_SPINLOCK(dump_list_lock);
++static LIST_HEAD(dump_list);
++
++/**
++ * kmsg_dump_register - register a kernel log dumper.
++ * @dump: pointer to the kmsg_dumper structure
++ *
++ * Adds a kernel log dumper to the system. The dump callback in the
++ * structure will be called when the kernel oopses or panics and must be
++ * set. Returns zero on success and %-EINVAL or %-EBUSY otherwise.
++ */
++int kmsg_dump_register(struct kmsg_dumper *dumper)
++{
++	unsigned long flags;
++	int err = -EBUSY;
++
++	/* The dump callback needs to be set */
++	if (!dumper->dump)
++		return -EINVAL;
++
++	spin_lock_irqsave(&dump_list_lock, flags);
++	/* Don't allow registering multiple times */
++	if (!dumper->registered) {
++		dumper->registered = 1;
++		list_add_tail(&dumper->list, &dump_list);
++		err = 0;
++	}
++	spin_unlock_irqrestore(&dump_list_lock, flags);
++
++	return err;
++}
++EXPORT_SYMBOL_GPL(kmsg_dump_register);
++
++/**
++ * kmsg_dump_unregister - unregister a kmsg dumper.
++ * @dump: pointer to the kmsg_dumper structure
++ *
++ * Removes a dump device from the system. Returns zero on success and
++ * %-EINVAL otherwise.
++ */
++int kmsg_dump_unregister(struct kmsg_dumper *dumper)
++{
++	unsigned long flags;
++	int err = -EINVAL;
++
++	spin_lock_irqsave(&dump_list_lock, flags);
++	if (dumper->registered) {
++		dumper->registered = 0;
++		list_del(&dumper->list);
++		err = 0;
++	}
++	spin_unlock_irqrestore(&dump_list_lock, flags);
++
++	return err;
++}
++EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
++
++static const char const *kmsg_reasons[] = {
++	[KMSG_DUMP_OOPS]	= "oops",
++	[KMSG_DUMP_PANIC]	= "panic",
++};
++
++static const char *kmsg_to_str(enum kmsg_dump_reason reason)
++{
++	if (reason >= ARRAY_SIZE(kmsg_reasons) || reason < 0)
++		return "unknown";
++
++	return kmsg_reasons[reason];
++}
++
++/**
++ * kmsg_dump - dump kernel log to kernel message dumpers.
++ * @reason: the reason (oops, panic etc) for dumping
++ *
++ * Iterate through each of the dump devices and call the oops/panic
++ * callbacks with the log buffer.
++ */
++void kmsg_dump(enum kmsg_dump_reason reason)
++{
++	unsigned long end;
++	unsigned chars;
++	struct kmsg_dumper *dumper;
++	const char *s1, *s2;
++	unsigned long l1, l2;
++	unsigned long flags;
++
++	/* Theoretically, the log could move on after we do this, but
++	   there's not a lot we can do about that. The new messages
++	   will overwrite the start of what we dump. */
++	spin_lock_irqsave(&logbuf_lock, flags);
++	end = log_end & LOG_BUF_MASK;
++	chars = logged_chars;
++	spin_unlock_irqrestore(&logbuf_lock, flags);
++
++	if (logged_chars > end) {
++		s1 = log_buf + log_buf_len - logged_chars + end;
++		l1 = logged_chars - end;
++
++		s2 = log_buf;
++		l2 = end;
++	} else {
++		s1 = "";
++		l1 = 0;
++
++		s2 = log_buf + end - logged_chars;
++		l2 = logged_chars;
++	}
++
++	if (!spin_trylock_irqsave(&dump_list_lock, flags)) {
++		printk(KERN_ERR "dump_kmsg: dump list lock is held during %s, skipping dump\n",
++				kmsg_to_str(reason));
++		return;
++	}
++	list_for_each_entry(dumper, &dump_list, list)
++		dumper->dump(dumper, reason, s1, l1, s2, l2);
++	spin_unlock_irqrestore(&dump_list_lock, flags);
++}

target/linux/generic-2.6/patches-2.6.32/931-crashlog.patch

@@ -0,0 +1,241 @@
+--- /dev/null
++++ b/include/linux/crashlog.h
+@@ -0,0 +1,12 @@
++#ifndef __CRASHLOG_H
++#define __CRASHLOG_H
++
++#ifdef CONFIG_CRASHLOG
++void __init crashlog_init_mem(struct bootmem_data *bdata);
++#else
++static inline void crashlog_init_mem(struct bootmem_data *bdata)
++{
++}
++#endif
++
++#endif
+--- a/init/Kconfig
++++ b/init/Kconfig
+@@ -710,6 +710,9 @@ config NET_NS
+ 	  Allow user space to create what appear to be multiple instances
+ 	  of the network stack.
+ 
++config CRASHLOG
++	bool "Crash logging"
++
+ config BLK_DEV_INITRD
+ 	bool "Initial RAM filesystem and RAM disk (initramfs/initrd) support"
+ 	depends on BROKEN || !FRV
+--- a/kernel/Makefile
++++ b/kernel/Makefile
+@@ -96,6 +96,7 @@ obj-$(CONFIG_SMP) += sched_cpupri.o
+ obj-$(CONFIG_SLOW_WORK) += slow-work.o
+ obj-$(CONFIG_SLOW_WORK_DEBUG) += slow-work-debugfs.o
+ obj-$(CONFIG_PERF_EVENTS) += perf_event.o
++obj-$(CONFIG_CRASHLOG) += crashlog.o
+ 
+ ifneq ($(CONFIG_SCHED_OMIT_FRAME_POINTER),y)
+ # According to Alan Modra <alan@linuxcare.com.au>, the -fno-omit-frame-pointer is
+--- /dev/null
++++ b/kernel/crashlog.c
+@@ -0,0 +1,171 @@
++/*
++ * Crash information logger
++ * Copyright (C) 2010 Felix Fietkau <nbd@openwrt.org>
++ *
++ * Based on ramoops.c
++ *   Copyright (C) 2010 Marco Stornelli <marco.stornelli@gmail.com>
++ *
++ * 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.
++ *
++ * 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., 51 Franklin St, Fifth Floor, Boston, MA
++ * 02110-1301 USA
++ *
++ */
++
++#include <linux/module.h>
++#include <linux/bootmem.h>
++#include <linux/debugfs.h>
++#include <linux/crashlog.h>
++#include <linux/kmsg_dump.h>
++#include <linux/module.h>
++#include <linux/pfn.h>
++#include <asm/io.h>
++
++#define CRASHLOG_PAGES	4
++#define CRASHLOG_SIZE	(CRASHLOG_PAGES * PAGE_SIZE)
++#define CRASHLOG_MAGIC	0xa1eedead
++
++/*
++ * Start the log at 1M before the end of RAM, as some boot loaders like
++ * to use the end of the RAM for stack usage and other things
++ * If this fails, fall back to using the last part.
++ */
++#define CRASHLOG_OFFSET	(1024 * 1024)
++
++struct crashlog_data {
++	u32 magic;
++	u32 len;
++	u8 data[];
++};
++
++static struct debugfs_blob_wrapper crashlog_blob;
++static unsigned long crashlog_addr = 0;
++static struct crashlog_data *crashlog_buf;
++static struct kmsg_dumper dump;
++static bool first = true;
++
++extern struct list_head *crashlog_modules;
++
++void __init crashlog_init_mem(bootmem_data_t *bdata)
++{
++	unsigned long addr;
++
++	if (crashlog_addr)
++		return;
++
++	addr = PFN_PHYS(bdata->node_low_pfn) - CRASHLOG_OFFSET;
++	if (reserve_bootmem(addr, CRASHLOG_SIZE, BOOTMEM_EXCLUSIVE) < 0) {
++		printk("Crashlog failed to allocate RAM at address 0x%lx\n", addr);
++		bdata->node_low_pfn -= CRASHLOG_PAGES;
++		addr = PFN_PHYS(bdata->node_low_pfn);
++	}
++	crashlog_addr = addr;
++}
++
++static void __init crashlog_copy(void)
++{
++	if (crashlog_buf->magic != CRASHLOG_MAGIC)
++		return;
++
++	if (!crashlog_buf->len || crashlog_buf->len >
++	    CRASHLOG_SIZE - sizeof(*crashlog_buf))
++		return;
++
++	crashlog_blob.size = crashlog_buf->len;
++	crashlog_blob.data = kmemdup(crashlog_buf->data,
++		crashlog_buf->len, GFP_KERNEL);
++
++	debugfs_create_blob("crashlog", 0700, NULL, &crashlog_blob);
++}
++
++static int get_maxlen(void)
++{
++	return CRASHLOG_SIZE - sizeof(*crashlog_buf) - crashlog_buf->len;
++}
++
++static void crashlog_printf(const char *fmt, ...)
++{
++	va_list args;
++	int len = get_maxlen();
++
++	if (!len)
++		return;
++
++	va_start(args, fmt);
++	crashlog_buf->len += vsnprintf(
++		&crashlog_buf->data[crashlog_buf->len],
++		len, fmt, args);
++	va_end(args);
++}
++
++static void crashlog_do_dump(struct kmsg_dumper *dumper,
++		enum kmsg_dump_reason reason, const char *s1, unsigned long l1,
++		const char *s2, unsigned long l2)
++{
++	unsigned long s1_start, s2_start;
++	unsigned long l1_cpy, l2_cpy;
++	struct timeval tv;
++	struct module *m;
++	char *buf;
++	int len;
++
++	if (!first)
++		crashlog_printf("\n===================================\n");
++
++	do_gettimeofday(&tv);
++	crashlog_printf("Time: %lu.%lu\n",
++		(long)tv.tv_sec, (long)tv.tv_usec);
++
++	if (first) {
++		crashlog_printf("Modules:");
++		list_for_each_entry(m, crashlog_modules, list) {
++			crashlog_printf("\t%s@%p+%x", m->name,
++			m->module_core, m->core_size,
++			m->module_init, m->init_size);
++		}
++		crashlog_printf("\n");
++		first = false;
++	}
++
++	buf = (char *)&crashlog_buf->data[crashlog_buf->len];
++	len = get_maxlen();
++
++	l2_cpy = min(l2, (unsigned long)len);
++	l1_cpy = min(l1, (unsigned long)len - l2_cpy);
++
++	s2_start = l2 - l2_cpy;
++	s1_start = l1 - l1_cpy;
++
++	memcpy(buf, s1 + s1_start, l1_cpy);
++	memcpy(buf + l1_cpy, s2 + s2_start, l2_cpy);
++	crashlog_buf->len += l1_cpy + l2_cpy;
++}
++
++
++int __init crashlog_init_fs(void)
++{
++	if (!crashlog_addr)
++		return -ENOMEM;
++
++	crashlog_buf = ioremap(crashlog_addr, CRASHLOG_SIZE);
++
++	crashlog_copy();
++
++	crashlog_buf->magic = CRASHLOG_MAGIC;
++	crashlog_buf->len = 0;
++
++	dump.dump = crashlog_do_dump;
++	kmsg_dump_register(&dump);
++
++	return 0;
++}
++module_init(crashlog_init_fs);
+--- a/mm/bootmem.c
++++ b/mm/bootmem.c
+@@ -13,6 +13,7 @@
+ #include <linux/bootmem.h>
+ #include <linux/module.h>
+ #include <linux/kmemleak.h>
++#include <linux/crashlog.h>
+ 
+ #include <asm/bug.h>
+ #include <asm/io.h>
+@@ -152,6 +153,7 @@ static unsigned long __init free_all_boo
+ 	if (!bdata->node_bootmem_map)
+ 		return 0;
+ 
++	crashlog_init_mem(bdata);
+ 	start = bdata->node_min_pfn;
+ 	end = bdata->node_low_pfn;
+ 
+--- a/kernel/module.c
++++ b/kernel/module.c
+@@ -79,6 +79,9 @@ EXPORT_TRACEPOINT_SYMBOL(module_get);
+ DEFINE_MUTEX(module_mutex);
+ EXPORT_SYMBOL_GPL(module_mutex);
+ static LIST_HEAD(modules);
++#ifdef CONFIG_CRASHLOG
++struct list_head *crashlog_modules = &modules;
++#endif
+ 
+ /* Block module loading/unloading? */
+ int modules_disabled = 0;

target/linux/generic-2.6/patches-2.6.32/976-ssb_add_dma_dev.patch

@@ -0,0 +1,52 @@
+From: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
+
+Add dma_dev, a pointer to struct device, to struct ssb_device.  We pass it
+to the generic DMA API with SSB_BUSTYPE_PCI and SSB_BUSTYPE_SSB. 
+ssb_devices_register() sets up it properly.
+
+This is preparation for replacing the ssb bus specific DMA API (ssb_dma_*)
+with the generic DMA API.
+
+Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
+Acked-by: Michael Buesch <mb@bu3sch.de>
+Cc: Gary Zambrano <zambrano@broadcom.com>
+Cc: Stefano Brivio <stefano.brivio@polimi.it>
+Cc: Larry Finger <Larry.Finger@lwfinger.net>
+Cc: John W. Linville <linville@tuxdriver.com>
+Acked-by: David S. Miller <davem@davemloft.net>
+Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
+---
+
+ drivers/ssb/main.c      |    2 ++
+ include/linux/ssb/ssb.h |    2 +-
+ 2 files changed, 3 insertions(+), 1 deletion(-)
+
+--- a/drivers/ssb/main.c
++++ b/drivers/ssb/main.c
+@@ -486,6 +486,7 @@ static int ssb_devices_register(struct s
+ #ifdef CONFIG_SSB_PCIHOST
+ 			sdev->irq = bus->host_pci->irq;
+ 			dev->parent = &bus->host_pci->dev;
++			sdev->dma_dev = dev->parent;
+ #endif
+ 			break;
+ 		case SSB_BUSTYPE_PCMCIA:
+@@ -501,6 +502,7 @@ static int ssb_devices_register(struct s
+ 			break;
+ 		case SSB_BUSTYPE_SSB:
+ 			dev->dma_mask = &dev->coherent_dma_mask;
++			sdev->dma_dev = dev;
+ 			break;
+ 		}
+ 
+--- a/include/linux/ssb/ssb.h
++++ b/include/linux/ssb/ssb.h
+@@ -167,7 +167,7 @@ struct ssb_device {
+ 	 * is an optimization. */
+ 	const struct ssb_bus_ops *ops;
+ 
+-	struct device *dev;
++	struct device *dev, *dma_dev;
+ 
+ 	struct ssb_bus *bus;
+ 	struct ssb_device_id id;