remove 2.6.25 support
SVN-Revision: 24089
This commit is contained in:
parent
d6ea3e24d4
commit
5ea6194ab0
77 changed files with 4 additions and 128848 deletions
|
@ -26,7 +26,6 @@ menu "Target Images"
|
|||
default TARGET_INITRAMFS_COMPRESSION_LZMA if TARGET_ramips
|
||||
default TARGET_INITRAMFS_COMPRESSION_NONE
|
||||
depends TARGET_ROOTFS_INITRAMFS
|
||||
depends !LINUX_2_6_25
|
||||
help
|
||||
Select ramdisk compression.
|
||||
|
||||
|
|
|
@ -44,16 +44,8 @@ ifneq ($(CONFIG_JFFS2_LZMA),y)
|
|||
JFFS2OPTS += -x lzma
|
||||
endif
|
||||
|
||||
ifneq ($(CONFIG_LINUX_2_6_25),)
|
||||
USE_SQUASHFS3 := y
|
||||
endif
|
||||
|
||||
ifneq ($(USE_SQUASHFS3),)
|
||||
MKSQUASHFS_CMD := $(STAGING_DIR_HOST)/bin/mksquashfs-lzma
|
||||
else
|
||||
MKSQUASHFS_CMD := $(STAGING_DIR_HOST)/bin/mksquashfs4
|
||||
SQUASHFS_OPTS := -comp lzma -processors 1
|
||||
endif
|
||||
|
||||
JFFS2_BLOCKSIZE ?= 64k 128k
|
||||
|
||||
|
|
|
@ -60,7 +60,7 @@ PKG_EXTRA_CFLAGS:= \
|
|||
$(patsubst CONFIG_%, -DCONFIG_%=1, $(patsubst %=m,%,$(filter %=m,$(PKG_EXTRA_KCONFIG)))) \
|
||||
$(patsubst CONFIG_%, -DCONFIG_%=1, $(patsubst %=y,%,$(filter %=y,$(PKG_EXTRA_KCONFIG)))) \
|
||||
|
||||
ifneq ($(CONFIG_LINUX_2_6_25)$(CONFIG_LINUX_2_6_30)$(CONFIG_LINUX_2_6_31)$(CONFIG_LINUX_2_6_32),)
|
||||
ifneq ($(CONFIG_LINUX_2_6_30)$(CONFIG_LINUX_2_6_31)$(CONFIG_LINUX_2_6_32),)
|
||||
LINUX_AUTOCONF_FILE:= linux/autoconf.h
|
||||
else
|
||||
LINUX_AUTOCONF_FILE:= generated/autoconf.h
|
||||
|
|
|
@ -391,7 +391,7 @@ define KernelPackage/mvsas
|
|||
TITLE:=Marvell 88SE6440 SAS/SATA driver
|
||||
DEPENDS:=@TARGET_x86 +kmod-libsas
|
||||
KCONFIG:=CONFIG_SCSI_MVSAS
|
||||
ifneq ($(CONFIG_LINUX_2_6_25)$(CONFIG_LINUX_2_6_30),)
|
||||
ifneq ($(CONFIG_LINUX_2_6_30),)
|
||||
FILES:=$(LINUX_DIR)/drivers/scsi/mvsas.ko
|
||||
else
|
||||
FILES:=$(LINUX_DIR)/drivers/scsi/mvsas/mvsas.ko
|
||||
|
|
|
@ -43,7 +43,7 @@ endef
|
|||
define KernelPackage/cfg80211
|
||||
$(call KernelPackage/mac80211/Default)
|
||||
TITLE:=cfg80211 - wireless configuration API
|
||||
DEPENDS+= +wireless-tools +iw @!LINUX_2_6_25 +crda
|
||||
DEPENDS+= +wireless-tools +iw +crda
|
||||
ifeq ($(strip $(call CompareKernelPatchVer,$(KERNEL_PATCHVER),ge,2.6.33)),1)
|
||||
FILES:= \
|
||||
$(PKG_BUILD_DIR)/compat/compat.ko \
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -1,201 +0,0 @@
|
|||
/*
|
||||
* character device wrapper for generic gpio layer
|
||||
*
|
||||
* 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, MA02111-1307USA
|
||||
*
|
||||
* Feedback, Bugs... blogic@openwrt.org
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/init.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/gpio.h>
|
||||
#include <asm/atomic.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/genhd.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/gpio_dev.h>
|
||||
|
||||
#define DRVNAME "gpiodev"
|
||||
#define DEVNAME "gpio"
|
||||
|
||||
static int dev_major;
|
||||
static unsigned int gpio_access_mask;
|
||||
static struct class *gpiodev_class;
|
||||
|
||||
/* Counter is 1, if the device is not opened and zero (or less) if opened. */
|
||||
static atomic_t gpio_open_cnt = ATOMIC_INIT(1);
|
||||
|
||||
static int
|
||||
gpio_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
int retval = 0;
|
||||
|
||||
if (((1 << arg) & gpio_access_mask) != (1 << arg))
|
||||
{
|
||||
retval = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
|
||||
switch (cmd)
|
||||
{
|
||||
case GPIO_GET:
|
||||
retval = gpio_get_value(arg);
|
||||
break;
|
||||
|
||||
case GPIO_SET:
|
||||
gpio_set_value(arg, 1);
|
||||
break;
|
||||
|
||||
case GPIO_CLEAR:
|
||||
gpio_set_value(arg, 0);
|
||||
break;
|
||||
|
||||
case GPIO_DIR_IN:
|
||||
gpio_direction_input(arg);
|
||||
break;
|
||||
|
||||
case GPIO_DIR_OUT:
|
||||
gpio_direction_output(arg, 0);
|
||||
break;
|
||||
|
||||
default:
|
||||
retval = -EINVAL;
|
||||
break;
|
||||
}
|
||||
|
||||
out:
|
||||
return retval;
|
||||
}
|
||||
|
||||
static int
|
||||
gpio_open(struct inode *inode, struct file *file)
|
||||
{
|
||||
int result = 0;
|
||||
unsigned int dev_minor = MINOR(inode->i_rdev);
|
||||
|
||||
if (dev_minor != 0)
|
||||
{
|
||||
printk(KERN_ERR DRVNAME ": trying to access unknown minor device -> %d\n", dev_minor);
|
||||
result = -ENODEV;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* FIXME: We should really allow multiple applications to open the device
|
||||
* at the same time, as long as the apps access different IO pins.
|
||||
* The generic gpio-registration functions can be used for that.
|
||||
* Two new IOCTLs have to be introduced for that. Need to check userspace
|
||||
* compatibility first. --mb */
|
||||
if (!atomic_dec_and_test(&gpio_open_cnt)) {
|
||||
atomic_inc(&gpio_open_cnt);
|
||||
printk(KERN_ERR DRVNAME ": Device with minor ID %d already in use\n", dev_minor);
|
||||
result = -EBUSY;
|
||||
goto out;
|
||||
}
|
||||
|
||||
out:
|
||||
return result;
|
||||
}
|
||||
|
||||
static int
|
||||
gpio_close(struct inode * inode, struct file * file)
|
||||
{
|
||||
smp_mb__before_atomic_inc();
|
||||
atomic_inc(&gpio_open_cnt);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct file_operations gpio_fops = {
|
||||
ioctl: gpio_ioctl,
|
||||
open: gpio_open,
|
||||
release: gpio_close
|
||||
};
|
||||
|
||||
static int
|
||||
gpio_probe(struct platform_device *dev)
|
||||
{
|
||||
int result = 0;
|
||||
|
||||
dev_major = register_chrdev(0, DEVNAME, &gpio_fops);
|
||||
if (!dev_major)
|
||||
{
|
||||
printk(KERN_ERR DRVNAME ": Error whilst opening %s \n", DEVNAME);
|
||||
result = -ENODEV;
|
||||
goto out;
|
||||
}
|
||||
|
||||
gpiodev_class = class_create(THIS_MODULE, DRVNAME);
|
||||
class_device_create(gpiodev_class, NULL, MKDEV(dev_major, 0), NULL, DEVNAME);
|
||||
|
||||
printk(KERN_INFO DRVNAME ": gpio device registered with major %d\n", dev_major);
|
||||
|
||||
if (dev->num_resources != 1)
|
||||
{
|
||||
printk(KERN_ERR DRVNAME ": device may only have 1 resource\n");
|
||||
result = -ENODEV;
|
||||
goto out;
|
||||
}
|
||||
|
||||
gpio_access_mask = dev->resource[0].start;
|
||||
|
||||
printk(KERN_INFO DRVNAME ": gpio platform device registered with access mask %08X\n", gpio_access_mask);
|
||||
out:
|
||||
return result;
|
||||
}
|
||||
|
||||
static int
|
||||
gpio_remove(struct platform_device *dev)
|
||||
{
|
||||
unregister_chrdev(dev_major, DEVNAME);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct
|
||||
platform_driver gpio_driver = {
|
||||
.probe = gpio_probe,
|
||||
.remove = gpio_remove,
|
||||
.driver = {
|
||||
.name = "GPIODEV",
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init
|
||||
gpio_mod_init(void)
|
||||
{
|
||||
int ret = platform_driver_register(&gpio_driver);
|
||||
if (ret)
|
||||
printk(KERN_INFO DRVNAME ": Error registering platfom driver!");
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void __exit
|
||||
gpio_mod_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&gpio_driver);
|
||||
}
|
||||
|
||||
module_init (gpio_mod_init);
|
||||
module_exit (gpio_mod_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_AUTHOR("John Crispin / OpenWrt");
|
||||
MODULE_DESCRIPTION("Character device for for generic gpio api");
|
|
@ -1,209 +0,0 @@
|
|||
/*
|
||||
* Driver for buttons on GPIO lines not capable of generating interrupts
|
||||
*
|
||||
* Copyright (C) 2007,2008 Gabor Juhos <juhosg at openwrt.org>
|
||||
*
|
||||
* This file was based on: /drivers/input/misc/cobalt_btns.c
|
||||
* Copyright (C) 2007 Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
|
||||
*
|
||||
* also was based on: /drivers/input/keyboard/gpio_keys.c
|
||||
* Copyright 2005 Phil Blundell
|
||||
*
|
||||
* 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/kernel.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
|
||||
#include <linux/input.h>
|
||||
#include <linux/input-polldev.h>
|
||||
#include <linux/ioport.h>
|
||||
#include <linux/platform_device.h>
|
||||
|
||||
#include <linux/gpio_buttons.h>
|
||||
|
||||
#include <asm/gpio.h>
|
||||
|
||||
#define DRV_NAME "gpio-buttons"
|
||||
#define DRV_VERSION "0.1.1"
|
||||
#define PFX DRV_NAME ": "
|
||||
|
||||
struct gpio_buttons_dev {
|
||||
struct input_polled_dev *poll_dev;
|
||||
struct gpio_buttons_platform_data *pdata;
|
||||
};
|
||||
|
||||
static void gpio_buttons_poll(struct input_polled_dev *dev)
|
||||
{
|
||||
struct gpio_buttons_dev *bdev = dev->private;
|
||||
struct gpio_buttons_platform_data *pdata = bdev->pdata;
|
||||
struct input_dev *input = dev->input;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < bdev->pdata->nbuttons; i++) {
|
||||
struct gpio_button *button = &pdata->buttons[i];
|
||||
unsigned int type = button->type ?: EV_KEY;
|
||||
int state;
|
||||
|
||||
state = gpio_get_value(button->gpio) ? 1 : 0;
|
||||
state ^= button->active_low;
|
||||
|
||||
if (state) {
|
||||
button->count++;
|
||||
} else {
|
||||
if (button->count >= button->threshold) {
|
||||
input_event(input, type, button->code, 1);
|
||||
input_sync(input);
|
||||
}
|
||||
button->count = 0;
|
||||
}
|
||||
|
||||
if (button->count == button->threshold) {
|
||||
input_event(input, type, button->code, 0);
|
||||
input_sync(input);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int __devinit gpio_buttons_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct gpio_buttons_platform_data *pdata = pdev->dev.platform_data;
|
||||
struct gpio_buttons_dev *bdev;
|
||||
struct input_polled_dev *poll_dev;
|
||||
struct input_dev *input;
|
||||
int error, i;
|
||||
|
||||
|
||||
if (!pdata)
|
||||
return -ENXIO;
|
||||
|
||||
bdev = kzalloc(sizeof(*bdev), GFP_KERNEL);
|
||||
if (!bdev) {
|
||||
printk(KERN_ERR DRV_NAME "no memory for device\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
poll_dev = input_allocate_polled_device();
|
||||
if (!poll_dev) {
|
||||
printk(KERN_ERR DRV_NAME "no memory for polled device\n");
|
||||
error = -ENOMEM;
|
||||
goto err_free_bdev;
|
||||
}
|
||||
|
||||
poll_dev->private = bdev;
|
||||
poll_dev->poll = gpio_buttons_poll;
|
||||
poll_dev->poll_interval = pdata->poll_interval;
|
||||
|
||||
input = poll_dev->input;
|
||||
|
||||
input->evbit[0] = BIT(EV_KEY);
|
||||
input->name = pdev->name;
|
||||
input->phys = "gpio-buttons/input0";
|
||||
input->dev.parent = &pdev->dev;
|
||||
|
||||
input->id.bustype = BUS_HOST;
|
||||
input->id.vendor = 0x0001;
|
||||
input->id.product = 0x0001;
|
||||
input->id.version = 0x0100;
|
||||
|
||||
for (i = 0; i < pdata->nbuttons; i++) {
|
||||
struct gpio_button *button = &pdata->buttons[i];
|
||||
unsigned int gpio = button->gpio;
|
||||
unsigned int type = button->type ?: EV_KEY;
|
||||
|
||||
error = gpio_request(gpio, button->desc ?
|
||||
button->desc : DRV_NAME);
|
||||
if (error) {
|
||||
printk(KERN_ERR PFX "unable to claim gpio %u, "
|
||||
"error %d\n", gpio, error);
|
||||
goto err_free_gpio;
|
||||
}
|
||||
|
||||
error = gpio_direction_input(gpio);
|
||||
if (error) {
|
||||
printk(KERN_ERR PFX "unable to set direction on "
|
||||
"gpio %u, error %d\n", gpio, error);
|
||||
goto err_free_gpio;
|
||||
}
|
||||
|
||||
input_set_capability(input, type, button->code);
|
||||
button->count = 0;
|
||||
}
|
||||
|
||||
bdev->poll_dev = poll_dev;
|
||||
bdev->pdata = pdata;
|
||||
platform_set_drvdata(pdev, bdev);
|
||||
|
||||
error = input_register_polled_device(poll_dev);
|
||||
if (error) {
|
||||
printk(KERN_ERR PFX "unable to register polled device, "
|
||||
"error %d\n", error);
|
||||
goto err_free_gpio;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
err_free_gpio:
|
||||
for (i = i - 1; i >= 0; i--)
|
||||
gpio_free(pdata->buttons[i].gpio);
|
||||
|
||||
input_free_polled_device(poll_dev);
|
||||
|
||||
err_free_bdev:
|
||||
kfree(bdev);
|
||||
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
return error;
|
||||
}
|
||||
|
||||
static int __devexit gpio_buttons_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct gpio_buttons_dev *bdev = platform_get_drvdata(pdev);
|
||||
struct gpio_buttons_platform_data *pdata = bdev->pdata;
|
||||
int i;
|
||||
|
||||
input_unregister_polled_device(bdev->poll_dev);
|
||||
|
||||
for (i = 0; i < pdata->nbuttons; i++)
|
||||
gpio_free(pdata->buttons[i].gpio);
|
||||
|
||||
input_free_polled_device(bdev->poll_dev);
|
||||
|
||||
kfree(bdev);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver gpio_buttons_driver = {
|
||||
.probe = gpio_buttons_probe,
|
||||
.remove = __devexit_p(gpio_buttons_remove),
|
||||
.driver = {
|
||||
.name = DRV_NAME,
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init gpio_buttons_init(void)
|
||||
{
|
||||
printk(KERN_INFO DRV_NAME " driver version " DRV_VERSION "\n");
|
||||
return platform_driver_register(&gpio_buttons_driver);
|
||||
}
|
||||
|
||||
static void __exit gpio_buttons_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&gpio_buttons_driver);
|
||||
}
|
||||
|
||||
module_init(gpio_buttons_init);
|
||||
module_exit(gpio_buttons_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>");
|
||||
MODULE_VERSION(DRV_VERSION);
|
||||
MODULE_DESCRIPTION("Polled buttons driver for CPU GPIOs");
|
||||
|
|
@ -1,45 +0,0 @@
|
|||
/*
|
||||
* LED Kernel Default ON Trigger
|
||||
*
|
||||
* Copyright 2008 Nick Forbes <nick.forbes@incepta.com>
|
||||
*
|
||||
* Based on Richard Purdie's ledtrig-timer.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/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/leds.h>
|
||||
#include "leds.h"
|
||||
|
||||
static void defon_trig_activate(struct led_classdev *led_cdev)
|
||||
{
|
||||
led_set_brightness(led_cdev, LED_FULL);
|
||||
}
|
||||
|
||||
static struct led_trigger defon_led_trigger = {
|
||||
.name = "default-on",
|
||||
.activate = defon_trig_activate,
|
||||
};
|
||||
|
||||
static int __init defon_trig_init(void)
|
||||
{
|
||||
return led_trigger_register(&defon_led_trigger);
|
||||
}
|
||||
|
||||
static void __exit defon_trig_exit(void)
|
||||
{
|
||||
led_trigger_unregister(&defon_led_trigger);
|
||||
}
|
||||
|
||||
module_init(defon_trig_init);
|
||||
module_exit(defon_trig_exit);
|
||||
|
||||
MODULE_AUTHOR("Nick Forbes <nick.forbes@incepta.com>");
|
||||
MODULE_DESCRIPTION("Default-ON LED trigger");
|
||||
MODULE_LICENSE("GPL");
|
|
@ -1,365 +0,0 @@
|
|||
/*
|
||||
* LED Morse Trigger
|
||||
*
|
||||
* Copyright (C) 2007 Gabor Juhos <juhosg at openwrt.org>
|
||||
*
|
||||
* This file was based on: drivers/led/ledtrig-timer.c
|
||||
* Copyright 2005-2006 Openedhand Ltd.
|
||||
* Author: Richard Purdie <rpurdie@openedhand.com>
|
||||
*
|
||||
* also based on the patch '[PATCH] 2.5.59 morse code panics' posted
|
||||
* in the LKML by Tomas Szepe at Thu, 30 Jan 2003
|
||||
* Copyright (C) 2002 Andrew Rodland <arodland@noln.com>
|
||||
* Copyright (C) 2003 Tomas Szepe <szepe@pinerecords.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.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/jiffies.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/sysdev.h>
|
||||
#include <linux/timer.h>
|
||||
#include <linux/ctype.h>
|
||||
#include <linux/leds.h>
|
||||
|
||||
#include "leds.h"
|
||||
|
||||
#define MORSE_DELAY_BASE (HZ/2)
|
||||
|
||||
#define MORSE_STATE_BLINK_START 0
|
||||
#define MORSE_STATE_BLINK_STOP 1
|
||||
|
||||
#define MORSE_DIT_LEN 1
|
||||
#define MORSE_DAH_LEN 3
|
||||
#define MORSE_SPACE_LEN 7
|
||||
|
||||
struct morse_trig_data {
|
||||
unsigned long delay;
|
||||
char *msg;
|
||||
|
||||
unsigned char morse;
|
||||
unsigned char state;
|
||||
char *msgpos;
|
||||
struct timer_list timer;
|
||||
};
|
||||
|
||||
const unsigned char morsetable[] = {
|
||||
0122, 0, 0310, 0, 0, 0163, /* "#$%&' */
|
||||
055, 0155, 0, 0, 0163, 0141, 0152, 0051, /* ()*+,-./ */
|
||||
077, 076, 074, 070, 060, 040, 041, 043, 047, 057, /* 0-9 */
|
||||
0107, 0125, 0, 0061, 0, 0114, 0, /* :;<=>?@ */
|
||||
006, 021, 025, 011, 002, 024, 013, 020, 004, /* A-I */
|
||||
036, 015, 022, 007, 005, 017, 026, 033, 012, /* J-R */
|
||||
010, 003, 014, 030, 016, 031, 035, 023, /* S-Z */
|
||||
0, 0, 0, 0, 0154 /* [\]^_ */
|
||||
};
|
||||
|
||||
static inline unsigned char tomorse(char c) {
|
||||
if (c >= 'a' && c <= 'z')
|
||||
c = c - 'a' + 'A';
|
||||
if (c >= '"' && c <= '_') {
|
||||
return morsetable[c - '"'];
|
||||
} else
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline unsigned long dit_len(struct morse_trig_data *morse_data)
|
||||
{
|
||||
return MORSE_DIT_LEN*morse_data->delay;
|
||||
}
|
||||
|
||||
static inline unsigned long dah_len(struct morse_trig_data *morse_data)
|
||||
{
|
||||
return MORSE_DAH_LEN*morse_data->delay;
|
||||
}
|
||||
|
||||
static inline unsigned long space_len(struct morse_trig_data *morse_data)
|
||||
{
|
||||
return MORSE_SPACE_LEN*morse_data->delay;
|
||||
}
|
||||
|
||||
static void morse_timer_function(unsigned long data)
|
||||
{
|
||||
struct led_classdev *led_cdev = (struct led_classdev *)data;
|
||||
struct morse_trig_data *morse_data = led_cdev->trigger_data;
|
||||
unsigned long brightness = LED_OFF;
|
||||
unsigned long delay = 0;
|
||||
|
||||
if (!morse_data->msg)
|
||||
goto set_led;
|
||||
|
||||
switch (morse_data->state) {
|
||||
case MORSE_STATE_BLINK_START:
|
||||
/* Starting a new blink. We have a valid code in morse. */
|
||||
delay = (morse_data->morse & 001) ? dah_len(morse_data):
|
||||
dit_len(morse_data);
|
||||
brightness = LED_FULL;
|
||||
morse_data->state = MORSE_STATE_BLINK_STOP;
|
||||
morse_data->morse >>= 1;
|
||||
break;
|
||||
case MORSE_STATE_BLINK_STOP:
|
||||
/* Coming off of a blink. */
|
||||
morse_data->state = MORSE_STATE_BLINK_START;
|
||||
|
||||
if (morse_data->morse > 1) {
|
||||
/* Not done yet, just a one-dit pause. */
|
||||
delay = dit_len(morse_data);
|
||||
break;
|
||||
}
|
||||
|
||||
/* Get a new char, figure out how much space. */
|
||||
/* First time through */
|
||||
if (!morse_data->msgpos)
|
||||
morse_data->msgpos = (char *)morse_data->msg;
|
||||
|
||||
if (!*morse_data->msgpos) {
|
||||
/* Repeating */
|
||||
morse_data->msgpos = (char *)morse_data->msg;
|
||||
delay = space_len(morse_data);
|
||||
} else {
|
||||
/* Inter-letter space */
|
||||
delay = dah_len(morse_data);
|
||||
}
|
||||
|
||||
if (!(morse_data->morse = tomorse(*morse_data->msgpos))) {
|
||||
delay = space_len(morse_data);
|
||||
/* And get us back here */
|
||||
morse_data->state = MORSE_STATE_BLINK_STOP;
|
||||
}
|
||||
morse_data->msgpos++;
|
||||
break;
|
||||
}
|
||||
|
||||
mod_timer(&morse_data->timer, jiffies + msecs_to_jiffies(delay));
|
||||
|
||||
set_led:
|
||||
led_set_brightness(led_cdev, brightness);
|
||||
}
|
||||
|
||||
static ssize_t _morse_delay_show(struct led_classdev *led_cdev, char *buf)
|
||||
{
|
||||
struct morse_trig_data *morse_data = led_cdev->trigger_data;
|
||||
|
||||
sprintf(buf, "%lu\n", morse_data->delay);
|
||||
|
||||
return strlen(buf) + 1;
|
||||
}
|
||||
|
||||
static ssize_t _morse_delay_store(struct led_classdev *led_cdev,
|
||||
const char *buf, size_t size)
|
||||
{
|
||||
struct morse_trig_data *morse_data = led_cdev->trigger_data;
|
||||
char *after;
|
||||
unsigned long state = simple_strtoul(buf, &after, 10);
|
||||
size_t count = after - buf;
|
||||
int ret = -EINVAL;
|
||||
|
||||
if (*after && isspace(*after))
|
||||
count++;
|
||||
|
||||
if (count == size) {
|
||||
morse_data->delay = state;
|
||||
mod_timer(&morse_data->timer, jiffies + 1);
|
||||
ret = count;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static ssize_t _morse_msg_show(struct led_classdev *led_cdev, char *buf)
|
||||
{
|
||||
struct morse_trig_data *morse_data = led_cdev->trigger_data;
|
||||
|
||||
if (!morse_data->msg)
|
||||
sprintf(buf, "<none>\n");
|
||||
else
|
||||
sprintf(buf, "%s\n", morse_data->msg);
|
||||
|
||||
return strlen(buf) + 1;
|
||||
}
|
||||
|
||||
static ssize_t _morse_msg_store(struct led_classdev *led_cdev,
|
||||
const char *buf, size_t size)
|
||||
{
|
||||
struct morse_trig_data *morse_data = led_cdev->trigger_data;
|
||||
char *m;
|
||||
|
||||
m = kmalloc(size, GFP_KERNEL);
|
||||
if (!m)
|
||||
return -ENOMEM;
|
||||
|
||||
memcpy(m,buf,size);
|
||||
m[size]='\0';
|
||||
|
||||
if (morse_data->msg)
|
||||
kfree(morse_data->msg);
|
||||
|
||||
morse_data->msg = m;
|
||||
morse_data->msgpos = NULL;
|
||||
morse_data->state = MORSE_STATE_BLINK_STOP;
|
||||
|
||||
mod_timer(&morse_data->timer, jiffies + 1);
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
|
||||
static ssize_t morse_delay_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct led_classdev *led_cdev = dev_get_drvdata(dev);
|
||||
|
||||
return _morse_delay_show(led_cdev, buf);
|
||||
}
|
||||
|
||||
static ssize_t morse_delay_store(struct device *dev,
|
||||
struct device_attribute *attr, const char *buf, size_t size)
|
||||
{
|
||||
struct led_classdev *led_cdev = dev_get_drvdata(dev);
|
||||
|
||||
return _morse_delay_store(led_cdev, buf, size);
|
||||
}
|
||||
|
||||
static ssize_t morse_msg_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct led_classdev *led_cdev = dev_get_drvdata(dev);
|
||||
|
||||
return _morse_msg_show(led_cdev, buf);
|
||||
}
|
||||
|
||||
static ssize_t morse_msg_store(struct device *dev,
|
||||
struct device_attribute *attr, const char *buf, size_t size)
|
||||
{
|
||||
struct led_classdev *led_cdev = dev_get_drvdata(dev);
|
||||
|
||||
return _morse_msg_store(led_cdev, buf, size);
|
||||
}
|
||||
|
||||
static DEVICE_ATTR(delay, 0644, morse_delay_show, morse_delay_store);
|
||||
static DEVICE_ATTR(message, 0644, morse_msg_show, morse_msg_store);
|
||||
|
||||
#define led_device_create_file(leddev, attr) \
|
||||
device_create_file(leddev->dev, &dev_attr_ ## attr)
|
||||
#define led_device_remove_file(leddev, attr) \
|
||||
device_remove_file(leddev->dev, &dev_attr_ ## attr)
|
||||
|
||||
#else
|
||||
static ssize_t morse_delay_show(struct class_device *dev, char *buf)
|
||||
{
|
||||
struct led_classdev *led_cdev = class_get_devdata(dev);
|
||||
|
||||
return _morse_delay_show(led_cdev, buf);
|
||||
}
|
||||
|
||||
static ssize_t morse_delay_store(struct class_device *dev, const char *buf,
|
||||
size_t size)
|
||||
{
|
||||
struct led_classdev *led_cdev = class_get_devdata(dev);
|
||||
|
||||
return _morse_delay_store(led_cdev, buf, size);
|
||||
}
|
||||
|
||||
static ssize_t morse_msg_show(struct class_device *dev, char *buf)
|
||||
{
|
||||
struct led_classdev *led_cdev = class_get_devdata(dev);
|
||||
|
||||
return _morse_msg_show(led_cdev, buf);
|
||||
}
|
||||
|
||||
static ssize_t morse_msg_store(struct class_device *dev, const char *buf,
|
||||
size_t size)
|
||||
{
|
||||
struct led_classdev *led_cdev = class_get_devdata(dev);
|
||||
|
||||
return _morse_msg_store(led_cdev, buf, size);
|
||||
}
|
||||
|
||||
static CLASS_DEVICE_ATTR(delay, 0644, morse_delay_show, morse_delay_store);
|
||||
static CLASS_DEVICE_ATTR(message, 0644, morse_msg_show, morse_msg_store);
|
||||
|
||||
#define led_device_create_file(leddev, attr) \
|
||||
class_device_create_file(leddev->class_dev, &class_device_attr_ ## attr)
|
||||
#define led_device_remove_file(leddev, attr) \
|
||||
class_device_remove_file(leddev->class_dev, &class_device_attr_ ## attr)
|
||||
|
||||
#endif
|
||||
|
||||
static void morse_trig_activate(struct led_classdev *led_cdev)
|
||||
{
|
||||
struct morse_trig_data *morse_data;
|
||||
int rc;
|
||||
|
||||
morse_data = kzalloc(sizeof(*morse_data), GFP_KERNEL);
|
||||
if (!morse_data)
|
||||
return;
|
||||
|
||||
morse_data->delay = MORSE_DELAY_BASE;
|
||||
init_timer(&morse_data->timer);
|
||||
morse_data->timer.function = morse_timer_function;
|
||||
morse_data->timer.data = (unsigned long)led_cdev;
|
||||
|
||||
rc = led_device_create_file(led_cdev, delay);
|
||||
if (rc) goto err;
|
||||
|
||||
rc = led_device_create_file(led_cdev, message);
|
||||
if (rc) goto err_delay;
|
||||
|
||||
led_cdev->trigger_data = morse_data;
|
||||
|
||||
return;
|
||||
|
||||
err_delay:
|
||||
led_device_remove_file(led_cdev, delay);
|
||||
err:
|
||||
kfree(morse_data);
|
||||
}
|
||||
|
||||
static void morse_trig_deactivate(struct led_classdev *led_cdev)
|
||||
{
|
||||
struct morse_trig_data *morse_data = led_cdev->trigger_data;
|
||||
|
||||
if (!morse_data)
|
||||
return;
|
||||
|
||||
led_device_remove_file(led_cdev, message);
|
||||
led_device_remove_file(led_cdev, delay);
|
||||
|
||||
del_timer_sync(&morse_data->timer);
|
||||
if (morse_data->msg)
|
||||
kfree(morse_data->msg);
|
||||
|
||||
kfree(morse_data);
|
||||
}
|
||||
|
||||
static struct led_trigger morse_led_trigger = {
|
||||
.name = "morse",
|
||||
.activate = morse_trig_activate,
|
||||
.deactivate = morse_trig_deactivate,
|
||||
};
|
||||
|
||||
static int __init morse_trig_init(void)
|
||||
{
|
||||
return led_trigger_register(&morse_led_trigger);
|
||||
}
|
||||
|
||||
static void __exit morse_trig_exit(void)
|
||||
{
|
||||
led_trigger_unregister(&morse_led_trigger);
|
||||
}
|
||||
|
||||
module_init(morse_trig_init);
|
||||
module_exit(morse_trig_exit);
|
||||
|
||||
MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>");
|
||||
MODULE_DESCRIPTION("Morse LED trigger");
|
||||
MODULE_LICENSE("GPL");
|
|
@ -1,437 +0,0 @@
|
|||
/*
|
||||
* LED Kernel Netdev Trigger
|
||||
*
|
||||
* Toggles the LED to reflect the link and traffic state of a named net device
|
||||
*
|
||||
* Copyright 2007 Oliver Jowett <oliver@opencloud.com>
|
||||
*
|
||||
* Derived from ledtrig-timer.c which is:
|
||||
* Copyright 2005-2006 Openedhand Ltd.
|
||||
* Author: Richard Purdie <rpurdie@openedhand.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.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/jiffies.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/sysdev.h>
|
||||
#include <linux/netdevice.h>
|
||||
#include <linux/timer.h>
|
||||
#include <linux/ctype.h>
|
||||
#include <linux/leds.h>
|
||||
#include "leds.h"
|
||||
|
||||
/*
|
||||
* Configurable sysfs attributes:
|
||||
*
|
||||
* device_name - network device name to monitor
|
||||
*
|
||||
* interval - duration of LED blink, in milliseconds
|
||||
*
|
||||
* mode - either "none" (LED is off) or a space separated list of one or more of:
|
||||
* link: LED's normal state reflects whether the link is up (has carrier) or not
|
||||
* tx: LED blinks on transmitted data
|
||||
* rx: LED blinks on receive data
|
||||
*
|
||||
* Some suggestions:
|
||||
*
|
||||
* Simple link status LED:
|
||||
* $ echo netdev >someled/trigger
|
||||
* $ echo eth0 >someled/device_name
|
||||
* $ echo link >someled/mode
|
||||
*
|
||||
* Ethernet-style link/activity LED:
|
||||
* $ echo netdev >someled/trigger
|
||||
* $ echo eth0 >someled/device_name
|
||||
* $ echo "link tx rx" >someled/mode
|
||||
*
|
||||
* Modem-style tx/rx LEDs:
|
||||
* $ echo netdev >led1/trigger
|
||||
* $ echo ppp0 >led1/device_name
|
||||
* $ echo tx >led1/mode
|
||||
* $ echo netdev >led2/trigger
|
||||
* $ echo ppp0 >led2/device_name
|
||||
* $ echo rx >led2/mode
|
||||
*
|
||||
*/
|
||||
|
||||
#define MODE_LINK 1
|
||||
#define MODE_TX 2
|
||||
#define MODE_RX 4
|
||||
|
||||
struct led_netdev_data {
|
||||
rwlock_t lock;
|
||||
|
||||
struct timer_list timer;
|
||||
struct notifier_block notifier;
|
||||
|
||||
struct led_classdev *led_cdev;
|
||||
struct net_device *net_dev;
|
||||
|
||||
char device_name[IFNAMSIZ];
|
||||
unsigned interval;
|
||||
unsigned mode;
|
||||
unsigned link_up;
|
||||
unsigned last_activity;
|
||||
};
|
||||
|
||||
static void set_baseline_state(struct led_netdev_data *trigger_data)
|
||||
{
|
||||
if ((trigger_data->mode & MODE_LINK) != 0 && trigger_data->link_up)
|
||||
led_set_brightness(trigger_data->led_cdev, LED_FULL);
|
||||
else
|
||||
led_set_brightness(trigger_data->led_cdev, LED_OFF);
|
||||
|
||||
if ((trigger_data->mode & (MODE_TX | MODE_RX)) != 0 && trigger_data->link_up)
|
||||
mod_timer(&trigger_data->timer, jiffies + trigger_data->interval);
|
||||
else
|
||||
del_timer(&trigger_data->timer);
|
||||
}
|
||||
|
||||
static ssize_t led_device_name_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct led_classdev *led_cdev = dev_get_drvdata(dev);
|
||||
struct led_netdev_data *trigger_data = led_cdev->trigger_data;
|
||||
|
||||
read_lock(&trigger_data->lock);
|
||||
sprintf(buf, "%s\n", trigger_data->device_name);
|
||||
read_unlock(&trigger_data->lock);
|
||||
|
||||
return strlen(buf) + 1;
|
||||
}
|
||||
|
||||
static ssize_t led_device_name_store(struct device *dev,
|
||||
struct device_attribute *attr, const char *buf, size_t size)
|
||||
{
|
||||
struct led_classdev *led_cdev = dev_get_drvdata(dev);
|
||||
struct led_netdev_data *trigger_data = led_cdev->trigger_data;
|
||||
|
||||
if (size < 0 || size >= IFNAMSIZ)
|
||||
return -EINVAL;
|
||||
|
||||
write_lock(&trigger_data->lock);
|
||||
|
||||
strcpy(trigger_data->device_name, buf);
|
||||
if (size > 0 && trigger_data->device_name[size-1] == '\n')
|
||||
trigger_data->device_name[size-1] = 0;
|
||||
|
||||
if (trigger_data->device_name[0] != 0) {
|
||||
/* check for existing device to update from */
|
||||
trigger_data->net_dev = dev_get_by_name(trigger_data->device_name);
|
||||
if (trigger_data->net_dev != NULL)
|
||||
trigger_data->link_up = (dev_get_flags(trigger_data->net_dev) & IFF_LOWER_UP) != 0;
|
||||
set_baseline_state(trigger_data); /* updates LEDs, may start timers */
|
||||
}
|
||||
|
||||
write_unlock(&trigger_data->lock);
|
||||
return size;
|
||||
}
|
||||
|
||||
static DEVICE_ATTR(device_name, 0644, led_device_name_show, led_device_name_store);
|
||||
|
||||
static ssize_t led_mode_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct led_classdev *led_cdev = dev_get_drvdata(dev);
|
||||
struct led_netdev_data *trigger_data = led_cdev->trigger_data;
|
||||
|
||||
read_lock(&trigger_data->lock);
|
||||
|
||||
if (trigger_data->mode == 0) {
|
||||
strcpy(buf, "none\n");
|
||||
} else {
|
||||
if (trigger_data->mode & MODE_LINK)
|
||||
strcat(buf, "link ");
|
||||
if (trigger_data->mode & MODE_TX)
|
||||
strcat(buf, "tx ");
|
||||
if (trigger_data->mode & MODE_RX)
|
||||
strcat(buf, "rx ");
|
||||
strcat(buf, "\n");
|
||||
}
|
||||
|
||||
read_unlock(&trigger_data->lock);
|
||||
|
||||
return strlen(buf)+1;
|
||||
}
|
||||
|
||||
static ssize_t led_mode_store(struct device *dev,
|
||||
struct device_attribute *attr, const char *buf, size_t size)
|
||||
{
|
||||
struct led_classdev *led_cdev = dev_get_drvdata(dev);
|
||||
struct led_netdev_data *trigger_data = led_cdev->trigger_data;
|
||||
char copybuf[1024];
|
||||
int new_mode = -1;
|
||||
char *p, *token;
|
||||
|
||||
/* take a copy since we don't want to trash the inbound buffer when using strsep */
|
||||
strncpy(copybuf, buf, sizeof(copybuf));
|
||||
copybuf[1023] = 0;
|
||||
p = copybuf;
|
||||
|
||||
while ((token = strsep(&p, " \t\n")) != NULL) {
|
||||
if (!*token)
|
||||
continue;
|
||||
|
||||
if (new_mode == -1)
|
||||
new_mode = 0;
|
||||
|
||||
if (!strcmp(token, "none"))
|
||||
new_mode = 0;
|
||||
else if (!strcmp(token, "tx"))
|
||||
new_mode |= MODE_TX;
|
||||
else if (!strcmp(token, "rx"))
|
||||
new_mode |= MODE_RX;
|
||||
else if (!strcmp(token, "link"))
|
||||
new_mode |= MODE_LINK;
|
||||
else
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (new_mode == -1)
|
||||
return -EINVAL;
|
||||
|
||||
write_lock(&trigger_data->lock);
|
||||
trigger_data->mode = new_mode;
|
||||
set_baseline_state(trigger_data);
|
||||
write_unlock(&trigger_data->lock);
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
static DEVICE_ATTR(mode, 0644, led_mode_show, led_mode_store);
|
||||
|
||||
static ssize_t led_interval_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct led_classdev *led_cdev = dev_get_drvdata(dev);
|
||||
struct led_netdev_data *trigger_data = led_cdev->trigger_data;
|
||||
|
||||
read_lock(&trigger_data->lock);
|
||||
sprintf(buf, "%u\n", jiffies_to_msecs(trigger_data->interval));
|
||||
read_unlock(&trigger_data->lock);
|
||||
|
||||
return strlen(buf) + 1;
|
||||
}
|
||||
|
||||
static ssize_t led_interval_store(struct device *dev,
|
||||
struct device_attribute *attr, const char *buf, size_t size)
|
||||
{
|
||||
struct led_classdev *led_cdev = dev_get_drvdata(dev);
|
||||
struct led_netdev_data *trigger_data = led_cdev->trigger_data;
|
||||
int ret = -EINVAL;
|
||||
char *after;
|
||||
unsigned long value = simple_strtoul(buf, &after, 10);
|
||||
size_t count = after - buf;
|
||||
|
||||
if (*after && isspace(*after))
|
||||
count++;
|
||||
|
||||
/* impose some basic bounds on the timer interval */
|
||||
if (count == size && value >= 5 && value <= 10000) {
|
||||
write_lock(&trigger_data->lock);
|
||||
trigger_data->interval = msecs_to_jiffies(value);
|
||||
set_baseline_state(trigger_data); // resets timer
|
||||
write_unlock(&trigger_data->lock);
|
||||
ret = count;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static DEVICE_ATTR(interval, 0644, led_interval_show, led_interval_store);
|
||||
|
||||
static int netdev_trig_notify(struct notifier_block *nb,
|
||||
unsigned long evt,
|
||||
void *dv)
|
||||
{
|
||||
struct net_device *dev = dv;
|
||||
struct led_netdev_data *trigger_data = container_of(nb, struct led_netdev_data, notifier);
|
||||
|
||||
if (evt != NETDEV_UP && evt != NETDEV_DOWN && evt != NETDEV_CHANGE && evt != NETDEV_REGISTER && evt != NETDEV_UNREGISTER)
|
||||
return NOTIFY_DONE;
|
||||
|
||||
write_lock(&trigger_data->lock);
|
||||
|
||||
if (strcmp(dev->name, trigger_data->device_name))
|
||||
goto done;
|
||||
|
||||
if (evt == NETDEV_REGISTER) {
|
||||
if (trigger_data->net_dev != NULL)
|
||||
dev_put(trigger_data->net_dev);
|
||||
dev_hold(dev);
|
||||
trigger_data->net_dev = dev;
|
||||
trigger_data->link_up = 0;
|
||||
goto done;
|
||||
}
|
||||
|
||||
if (evt == NETDEV_UNREGISTER && trigger_data->net_dev != NULL) {
|
||||
dev_put(trigger_data->net_dev);
|
||||
trigger_data->net_dev = NULL;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* UP / DOWN / CHANGE */
|
||||
|
||||
trigger_data->link_up = (evt != NETDEV_DOWN && netif_carrier_ok(dev));
|
||||
set_baseline_state(trigger_data);
|
||||
|
||||
done:
|
||||
write_unlock(&trigger_data->lock);
|
||||
return NOTIFY_DONE;
|
||||
}
|
||||
|
||||
/* here's the real work! */
|
||||
static void netdev_trig_timer(unsigned long arg)
|
||||
{
|
||||
struct led_netdev_data *trigger_data = (struct led_netdev_data *)arg;
|
||||
struct net_device_stats *dev_stats;
|
||||
unsigned new_activity;
|
||||
|
||||
write_lock(&trigger_data->lock);
|
||||
|
||||
if (!trigger_data->link_up || !trigger_data->net_dev || (trigger_data->mode & (MODE_TX | MODE_RX)) == 0) {
|
||||
/* we don't need to do timer work, just reflect link state. */
|
||||
led_set_brightness(trigger_data->led_cdev, ((trigger_data->mode & MODE_LINK) != 0 && trigger_data->link_up) ? LED_FULL : LED_OFF);
|
||||
goto no_restart;
|
||||
}
|
||||
|
||||
dev_stats = trigger_data->net_dev->get_stats(trigger_data->net_dev);
|
||||
new_activity =
|
||||
((trigger_data->mode & MODE_TX) ? dev_stats->tx_packets : 0) +
|
||||
((trigger_data->mode & MODE_RX) ? dev_stats->rx_packets : 0);
|
||||
|
||||
if (trigger_data->mode & MODE_LINK) {
|
||||
/* base state is ON (link present) */
|
||||
/* if there's no link, we don't get this far and the LED is off */
|
||||
|
||||
/* OFF -> ON always */
|
||||
/* ON -> OFF on activity */
|
||||
if (trigger_data->led_cdev->brightness == LED_OFF) {
|
||||
led_set_brightness(trigger_data->led_cdev, LED_FULL);
|
||||
} else if (trigger_data->last_activity != new_activity) {
|
||||
led_set_brightness(trigger_data->led_cdev, LED_OFF);
|
||||
}
|
||||
} else {
|
||||
/* base state is OFF */
|
||||
/* ON -> OFF always */
|
||||
/* OFF -> ON on activity */
|
||||
if (trigger_data->led_cdev->brightness == LED_FULL) {
|
||||
led_set_brightness(trigger_data->led_cdev, LED_OFF);
|
||||
} else if (trigger_data->last_activity != new_activity) {
|
||||
led_set_brightness(trigger_data->led_cdev, LED_FULL);
|
||||
}
|
||||
}
|
||||
|
||||
trigger_data->last_activity = new_activity;
|
||||
mod_timer(&trigger_data->timer, jiffies + trigger_data->interval);
|
||||
|
||||
no_restart:
|
||||
write_unlock(&trigger_data->lock);
|
||||
}
|
||||
|
||||
static void netdev_trig_activate(struct led_classdev *led_cdev)
|
||||
{
|
||||
struct led_netdev_data *trigger_data;
|
||||
int rc;
|
||||
|
||||
trigger_data = kzalloc(sizeof(struct led_netdev_data), GFP_KERNEL);
|
||||
if (!trigger_data)
|
||||
return;
|
||||
|
||||
rwlock_init(&trigger_data->lock);
|
||||
|
||||
trigger_data->notifier.notifier_call = netdev_trig_notify;
|
||||
trigger_data->notifier.priority = 10;
|
||||
|
||||
setup_timer(&trigger_data->timer, netdev_trig_timer, (unsigned long) trigger_data);
|
||||
|
||||
trigger_data->led_cdev = led_cdev;
|
||||
trigger_data->net_dev = NULL;
|
||||
trigger_data->device_name[0] = 0;
|
||||
|
||||
trigger_data->mode = 0;
|
||||
trigger_data->interval = msecs_to_jiffies(50);
|
||||
trigger_data->link_up = 0;
|
||||
trigger_data->last_activity = 0;
|
||||
|
||||
led_cdev->trigger_data = trigger_data;
|
||||
|
||||
rc = device_create_file(led_cdev->dev, &dev_attr_device_name);
|
||||
if (rc)
|
||||
goto err_out;
|
||||
rc = device_create_file(led_cdev->dev, &dev_attr_mode);
|
||||
if (rc)
|
||||
goto err_out_device_name;
|
||||
rc = device_create_file(led_cdev->dev, &dev_attr_interval);
|
||||
if (rc)
|
||||
goto err_out_mode;
|
||||
|
||||
register_netdevice_notifier(&trigger_data->notifier);
|
||||
return;
|
||||
|
||||
err_out_mode:
|
||||
device_remove_file(led_cdev->dev, &dev_attr_mode);
|
||||
err_out_device_name:
|
||||
device_remove_file(led_cdev->dev, &dev_attr_device_name);
|
||||
err_out:
|
||||
led_cdev->trigger_data = NULL;
|
||||
kfree(trigger_data);
|
||||
}
|
||||
|
||||
static void netdev_trig_deactivate(struct led_classdev *led_cdev)
|
||||
{
|
||||
struct led_netdev_data *trigger_data = led_cdev->trigger_data;
|
||||
|
||||
if (trigger_data) {
|
||||
unregister_netdevice_notifier(&trigger_data->notifier);
|
||||
|
||||
device_remove_file(led_cdev->dev, &dev_attr_device_name);
|
||||
device_remove_file(led_cdev->dev, &dev_attr_mode);
|
||||
device_remove_file(led_cdev->dev, &dev_attr_interval);
|
||||
|
||||
write_lock(&trigger_data->lock);
|
||||
|
||||
if (trigger_data->net_dev) {
|
||||
dev_put(trigger_data->net_dev);
|
||||
trigger_data->net_dev = NULL;
|
||||
}
|
||||
|
||||
write_unlock(&trigger_data->lock);
|
||||
|
||||
del_timer_sync(&trigger_data->timer);
|
||||
|
||||
kfree(trigger_data);
|
||||
}
|
||||
}
|
||||
|
||||
static struct led_trigger netdev_led_trigger = {
|
||||
.name = "netdev",
|
||||
.activate = netdev_trig_activate,
|
||||
.deactivate = netdev_trig_deactivate,
|
||||
};
|
||||
|
||||
static int __init netdev_trig_init(void)
|
||||
{
|
||||
return led_trigger_register(&netdev_led_trigger);
|
||||
}
|
||||
|
||||
static void __exit netdev_trig_exit(void)
|
||||
{
|
||||
led_trigger_unregister(&netdev_led_trigger);
|
||||
}
|
||||
|
||||
module_init(netdev_trig_init);
|
||||
module_exit(netdev_trig_exit);
|
||||
|
||||
MODULE_AUTHOR("Oliver Jowett <oliver@opencloud.com>");
|
||||
MODULE_DESCRIPTION("Netdev LED trigger");
|
||||
MODULE_LICENSE("GPL");
|
File diff suppressed because it is too large
Load diff
|
@ -1,780 +0,0 @@
|
|||
--- /dev/null
|
||||
+++ b/include/linux/LzmaDecode.h
|
||||
@@ -0,0 +1,100 @@
|
||||
+/*
|
||||
+ LzmaDecode.h
|
||||
+ LZMA Decoder interface
|
||||
+
|
||||
+ LZMA SDK 4.05 Copyright (c) 1999-2004 Igor Pavlov (2004-08-25)
|
||||
+ http://www.7-zip.org/
|
||||
+
|
||||
+ LZMA SDK is licensed under two licenses:
|
||||
+ 1) GNU Lesser General Public License (GNU LGPL)
|
||||
+ 2) Common Public License (CPL)
|
||||
+ It means that you can select one of these two licenses and
|
||||
+ follow rules of that license.
|
||||
+
|
||||
+ SPECIAL EXCEPTION:
|
||||
+ Igor Pavlov, as the author of this code, expressly permits you to
|
||||
+ statically or dynamically link your code (or bind by name) to the
|
||||
+ interfaces of this file without subjecting your linked code to the
|
||||
+ terms of the CPL or GNU LGPL. Any modifications or additions
|
||||
+ to this file, however, are subject to the LGPL or CPL terms.
|
||||
+*/
|
||||
+
|
||||
+#ifndef __LZMADECODE_H
|
||||
+#define __LZMADECODE_H
|
||||
+
|
||||
+/* #define _LZMA_IN_CB */
|
||||
+/* Use callback for input data */
|
||||
+
|
||||
+/* #define _LZMA_OUT_READ */
|
||||
+/* Use read function for output data */
|
||||
+
|
||||
+/* #define _LZMA_PROB32 */
|
||||
+/* It can increase speed on some 32-bit CPUs,
|
||||
+ but memory usage will be doubled in that case */
|
||||
+
|
||||
+/* #define _LZMA_LOC_OPT */
|
||||
+/* Enable local speed optimizations inside code */
|
||||
+
|
||||
+#ifndef UInt32
|
||||
+#ifdef _LZMA_UINT32_IS_ULONG
|
||||
+#define UInt32 unsigned long
|
||||
+#else
|
||||
+#define UInt32 unsigned int
|
||||
+#endif
|
||||
+#endif
|
||||
+
|
||||
+#ifdef _LZMA_PROB32
|
||||
+#define CProb UInt32
|
||||
+#else
|
||||
+#define CProb unsigned short
|
||||
+#endif
|
||||
+
|
||||
+#define LZMA_RESULT_OK 0
|
||||
+#define LZMA_RESULT_DATA_ERROR 1
|
||||
+#define LZMA_RESULT_NOT_ENOUGH_MEM 2
|
||||
+
|
||||
+#ifdef _LZMA_IN_CB
|
||||
+typedef struct _ILzmaInCallback
|
||||
+{
|
||||
+ int (*Read)(void *object, unsigned char **buffer, UInt32 *bufferSize);
|
||||
+} ILzmaInCallback;
|
||||
+#endif
|
||||
+
|
||||
+#define LZMA_BASE_SIZE 1846
|
||||
+#define LZMA_LIT_SIZE 768
|
||||
+
|
||||
+/*
|
||||
+bufferSize = (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << (lc + lp)))* sizeof(CProb)
|
||||
+bufferSize += 100 in case of _LZMA_OUT_READ
|
||||
+by default CProb is unsigned short,
|
||||
+but if specify _LZMA_PROB_32, CProb will be UInt32(unsigned int)
|
||||
+*/
|
||||
+
|
||||
+#ifdef _LZMA_OUT_READ
|
||||
+int LzmaDecoderInit(
|
||||
+ unsigned char *buffer, UInt32 bufferSize,
|
||||
+ int lc, int lp, int pb,
|
||||
+ unsigned char *dictionary, UInt32 dictionarySize,
|
||||
+ #ifdef _LZMA_IN_CB
|
||||
+ ILzmaInCallback *inCallback
|
||||
+ #else
|
||||
+ unsigned char *inStream, UInt32 inSize
|
||||
+ #endif
|
||||
+);
|
||||
+#endif
|
||||
+
|
||||
+int LzmaDecode(
|
||||
+ unsigned char *buffer,
|
||||
+ #ifndef _LZMA_OUT_READ
|
||||
+ UInt32 bufferSize,
|
||||
+ int lc, int lp, int pb,
|
||||
+ #ifdef _LZMA_IN_CB
|
||||
+ ILzmaInCallback *inCallback,
|
||||
+ #else
|
||||
+ unsigned char *inStream, UInt32 inSize,
|
||||
+ #endif
|
||||
+ #endif
|
||||
+ unsigned char *outStream, UInt32 outSize,
|
||||
+ UInt32 *outSizeProcessed);
|
||||
+
|
||||
+#endif
|
||||
--- /dev/null
|
||||
+++ b/lib/LzmaDecode.c
|
||||
@@ -0,0 +1,663 @@
|
||||
+/*
|
||||
+ LzmaDecode.c
|
||||
+ LZMA Decoder
|
||||
+
|
||||
+ LZMA SDK 4.05 Copyright (c) 1999-2004 Igor Pavlov (2004-08-25)
|
||||
+ http://www.7-zip.org/
|
||||
+
|
||||
+ LZMA SDK is licensed under two licenses:
|
||||
+ 1) GNU Lesser General Public License (GNU LGPL)
|
||||
+ 2) Common Public License (CPL)
|
||||
+ It means that you can select one of these two licenses and
|
||||
+ follow rules of that license.
|
||||
+
|
||||
+ SPECIAL EXCEPTION:
|
||||
+ Igor Pavlov, as the author of this code, expressly permits you to
|
||||
+ statically or dynamically link your code (or bind by name) to the
|
||||
+ interfaces of this file without subjecting your linked code to the
|
||||
+ terms of the CPL or GNU LGPL. Any modifications or additions
|
||||
+ to this file, however, are subject to the LGPL or CPL terms.
|
||||
+*/
|
||||
+
|
||||
+#include <linux/LzmaDecode.h>
|
||||
+
|
||||
+#ifndef Byte
|
||||
+#define Byte unsigned char
|
||||
+#endif
|
||||
+
|
||||
+#define kNumTopBits 24
|
||||
+#define kTopValue ((UInt32)1 << kNumTopBits)
|
||||
+
|
||||
+#define kNumBitModelTotalBits 11
|
||||
+#define kBitModelTotal (1 << kNumBitModelTotalBits)
|
||||
+#define kNumMoveBits 5
|
||||
+
|
||||
+typedef struct _CRangeDecoder
|
||||
+{
|
||||
+ Byte *Buffer;
|
||||
+ Byte *BufferLim;
|
||||
+ UInt32 Range;
|
||||
+ UInt32 Code;
|
||||
+ #ifdef _LZMA_IN_CB
|
||||
+ ILzmaInCallback *InCallback;
|
||||
+ int Result;
|
||||
+ #endif
|
||||
+ int ExtraBytes;
|
||||
+} CRangeDecoder;
|
||||
+
|
||||
+Byte RangeDecoderReadByte(CRangeDecoder *rd)
|
||||
+{
|
||||
+ if (rd->Buffer == rd->BufferLim)
|
||||
+ {
|
||||
+ #ifdef _LZMA_IN_CB
|
||||
+ UInt32 size;
|
||||
+ rd->Result = rd->InCallback->Read(rd->InCallback, &rd->Buffer, &size);
|
||||
+ rd->BufferLim = rd->Buffer + size;
|
||||
+ if (size == 0)
|
||||
+ #endif
|
||||
+ {
|
||||
+ rd->ExtraBytes = 1;
|
||||
+ return 0xFF;
|
||||
+ }
|
||||
+ }
|
||||
+ return (*rd->Buffer++);
|
||||
+}
|
||||
+
|
||||
+/* #define ReadByte (*rd->Buffer++) */
|
||||
+#define ReadByte (RangeDecoderReadByte(rd))
|
||||
+
|
||||
+void RangeDecoderInit(CRangeDecoder *rd,
|
||||
+ #ifdef _LZMA_IN_CB
|
||||
+ ILzmaInCallback *inCallback
|
||||
+ #else
|
||||
+ Byte *stream, UInt32 bufferSize
|
||||
+ #endif
|
||||
+ )
|
||||
+{
|
||||
+ int i;
|
||||
+ #ifdef _LZMA_IN_CB
|
||||
+ rd->InCallback = inCallback;
|
||||
+ rd->Buffer = rd->BufferLim = 0;
|
||||
+ #else
|
||||
+ rd->Buffer = stream;
|
||||
+ rd->BufferLim = stream + bufferSize;
|
||||
+ #endif
|
||||
+ rd->ExtraBytes = 0;
|
||||
+ rd->Code = 0;
|
||||
+ rd->Range = (0xFFFFFFFF);
|
||||
+ for(i = 0; i < 5; i++)
|
||||
+ rd->Code = (rd->Code << 8) | ReadByte;
|
||||
+}
|
||||
+
|
||||
+#define RC_INIT_VAR UInt32 range = rd->Range; UInt32 code = rd->Code;
|
||||
+#define RC_FLUSH_VAR rd->Range = range; rd->Code = code;
|
||||
+#define RC_NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | ReadByte; }
|
||||
+
|
||||
+UInt32 RangeDecoderDecodeDirectBits(CRangeDecoder *rd, int numTotalBits)
|
||||
+{
|
||||
+ RC_INIT_VAR
|
||||
+ UInt32 result = 0;
|
||||
+ int i;
|
||||
+ for (i = numTotalBits; i > 0; i--)
|
||||
+ {
|
||||
+ /* UInt32 t; */
|
||||
+ range >>= 1;
|
||||
+
|
||||
+ result <<= 1;
|
||||
+ if (code >= range)
|
||||
+ {
|
||||
+ code -= range;
|
||||
+ result |= 1;
|
||||
+ }
|
||||
+ /*
|
||||
+ t = (code - range) >> 31;
|
||||
+ t &= 1;
|
||||
+ code -= range & (t - 1);
|
||||
+ result = (result + result) | (1 - t);
|
||||
+ */
|
||||
+ RC_NORMALIZE
|
||||
+ }
|
||||
+ RC_FLUSH_VAR
|
||||
+ return result;
|
||||
+}
|
||||
+
|
||||
+int RangeDecoderBitDecode(CProb *prob, CRangeDecoder *rd)
|
||||
+{
|
||||
+ UInt32 bound = (rd->Range >> kNumBitModelTotalBits) * *prob;
|
||||
+ if (rd->Code < bound)
|
||||
+ {
|
||||
+ rd->Range = bound;
|
||||
+ *prob += (kBitModelTotal - *prob) >> kNumMoveBits;
|
||||
+ if (rd->Range < kTopValue)
|
||||
+ {
|
||||
+ rd->Code = (rd->Code << 8) | ReadByte;
|
||||
+ rd->Range <<= 8;
|
||||
+ }
|
||||
+ return 0;
|
||||
+ }
|
||||
+ else
|
||||
+ {
|
||||
+ rd->Range -= bound;
|
||||
+ rd->Code -= bound;
|
||||
+ *prob -= (*prob) >> kNumMoveBits;
|
||||
+ if (rd->Range < kTopValue)
|
||||
+ {
|
||||
+ rd->Code = (rd->Code << 8) | ReadByte;
|
||||
+ rd->Range <<= 8;
|
||||
+ }
|
||||
+ return 1;
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
+#define RC_GET_BIT2(prob, mi, A0, A1) \
|
||||
+ UInt32 bound = (range >> kNumBitModelTotalBits) * *prob; \
|
||||
+ if (code < bound) \
|
||||
+ { A0; range = bound; *prob += (kBitModelTotal - *prob) >> kNumMoveBits; mi <<= 1; } \
|
||||
+ else \
|
||||
+ { A1; range -= bound; code -= bound; *prob -= (*prob) >> kNumMoveBits; mi = (mi + mi) + 1; } \
|
||||
+ RC_NORMALIZE
|
||||
+
|
||||
+#define RC_GET_BIT(prob, mi) RC_GET_BIT2(prob, mi, ; , ;)
|
||||
+
|
||||
+int RangeDecoderBitTreeDecode(CProb *probs, int numLevels, CRangeDecoder *rd)
|
||||
+{
|
||||
+ int mi = 1;
|
||||
+ int i;
|
||||
+ #ifdef _LZMA_LOC_OPT
|
||||
+ RC_INIT_VAR
|
||||
+ #endif
|
||||
+ for(i = numLevels; i > 0; i--)
|
||||
+ {
|
||||
+ #ifdef _LZMA_LOC_OPT
|
||||
+ CProb *prob = probs + mi;
|
||||
+ RC_GET_BIT(prob, mi)
|
||||
+ #else
|
||||
+ mi = (mi + mi) + RangeDecoderBitDecode(probs + mi, rd);
|
||||
+ #endif
|
||||
+ }
|
||||
+ #ifdef _LZMA_LOC_OPT
|
||||
+ RC_FLUSH_VAR
|
||||
+ #endif
|
||||
+ return mi - (1 << numLevels);
|
||||
+}
|
||||
+
|
||||
+int RangeDecoderReverseBitTreeDecode(CProb *probs, int numLevels, CRangeDecoder *rd)
|
||||
+{
|
||||
+ int mi = 1;
|
||||
+ int i;
|
||||
+ int symbol = 0;
|
||||
+ #ifdef _LZMA_LOC_OPT
|
||||
+ RC_INIT_VAR
|
||||
+ #endif
|
||||
+ for(i = 0; i < numLevels; i++)
|
||||
+ {
|
||||
+ #ifdef _LZMA_LOC_OPT
|
||||
+ CProb *prob = probs + mi;
|
||||
+ RC_GET_BIT2(prob, mi, ; , symbol |= (1 << i))
|
||||
+ #else
|
||||
+ int bit = RangeDecoderBitDecode(probs + mi, rd);
|
||||
+ mi = mi + mi + bit;
|
||||
+ symbol |= (bit << i);
|
||||
+ #endif
|
||||
+ }
|
||||
+ #ifdef _LZMA_LOC_OPT
|
||||
+ RC_FLUSH_VAR
|
||||
+ #endif
|
||||
+ return symbol;
|
||||
+}
|
||||
+
|
||||
+Byte LzmaLiteralDecode(CProb *probs, CRangeDecoder *rd)
|
||||
+{
|
||||
+ int symbol = 1;
|
||||
+ #ifdef _LZMA_LOC_OPT
|
||||
+ RC_INIT_VAR
|
||||
+ #endif
|
||||
+ do
|
||||
+ {
|
||||
+ #ifdef _LZMA_LOC_OPT
|
||||
+ CProb *prob = probs + symbol;
|
||||
+ RC_GET_BIT(prob, symbol)
|
||||
+ #else
|
||||
+ symbol = (symbol + symbol) | RangeDecoderBitDecode(probs + symbol, rd);
|
||||
+ #endif
|
||||
+ }
|
||||
+ while (symbol < 0x100);
|
||||
+ #ifdef _LZMA_LOC_OPT
|
||||
+ RC_FLUSH_VAR
|
||||
+ #endif
|
||||
+ return symbol;
|
||||
+}
|
||||
+
|
||||
+Byte LzmaLiteralDecodeMatch(CProb *probs, CRangeDecoder *rd, Byte matchByte)
|
||||
+{
|
||||
+ int symbol = 1;
|
||||
+ #ifdef _LZMA_LOC_OPT
|
||||
+ RC_INIT_VAR
|
||||
+ #endif
|
||||
+ do
|
||||
+ {
|
||||
+ int bit;
|
||||
+ int matchBit = (matchByte >> 7) & 1;
|
||||
+ matchByte <<= 1;
|
||||
+ #ifdef _LZMA_LOC_OPT
|
||||
+ {
|
||||
+ CProb *prob = probs + ((1 + matchBit) << 8) + symbol;
|
||||
+ RC_GET_BIT2(prob, symbol, bit = 0, bit = 1)
|
||||
+ }
|
||||
+ #else
|
||||
+ bit = RangeDecoderBitDecode(probs + ((1 + matchBit) << 8) + symbol, rd);
|
||||
+ symbol = (symbol << 1) | bit;
|
||||
+ #endif
|
||||
+ if (matchBit != bit)
|
||||
+ {
|
||||
+ while (symbol < 0x100)
|
||||
+ {
|
||||
+ #ifdef _LZMA_LOC_OPT
|
||||
+ CProb *prob = probs + symbol;
|
||||
+ RC_GET_BIT(prob, symbol)
|
||||
+ #else
|
||||
+ symbol = (symbol + symbol) | RangeDecoderBitDecode(probs + symbol, rd);
|
||||
+ #endif
|
||||
+ }
|
||||
+ break;
|
||||
+ }
|
||||
+ }
|
||||
+ while (symbol < 0x100);
|
||||
+ #ifdef _LZMA_LOC_OPT
|
||||
+ RC_FLUSH_VAR
|
||||
+ #endif
|
||||
+ return symbol;
|
||||
+}
|
||||
+
|
||||
+#define kNumPosBitsMax 4
|
||||
+#define kNumPosStatesMax (1 << kNumPosBitsMax)
|
||||
+
|
||||
+#define kLenNumLowBits 3
|
||||
+#define kLenNumLowSymbols (1 << kLenNumLowBits)
|
||||
+#define kLenNumMidBits 3
|
||||
+#define kLenNumMidSymbols (1 << kLenNumMidBits)
|
||||
+#define kLenNumHighBits 8
|
||||
+#define kLenNumHighSymbols (1 << kLenNumHighBits)
|
||||
+
|
||||
+#define LenChoice 0
|
||||
+#define LenChoice2 (LenChoice + 1)
|
||||
+#define LenLow (LenChoice2 + 1)
|
||||
+#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))
|
||||
+#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))
|
||||
+#define kNumLenProbs (LenHigh + kLenNumHighSymbols)
|
||||
+
|
||||
+int LzmaLenDecode(CProb *p, CRangeDecoder *rd, int posState)
|
||||
+{
|
||||
+ if(RangeDecoderBitDecode(p + LenChoice, rd) == 0)
|
||||
+ return RangeDecoderBitTreeDecode(p + LenLow +
|
||||
+ (posState << kLenNumLowBits), kLenNumLowBits, rd);
|
||||
+ if(RangeDecoderBitDecode(p + LenChoice2, rd) == 0)
|
||||
+ return kLenNumLowSymbols + RangeDecoderBitTreeDecode(p + LenMid +
|
||||
+ (posState << kLenNumMidBits), kLenNumMidBits, rd);
|
||||
+ return kLenNumLowSymbols + kLenNumMidSymbols +
|
||||
+ RangeDecoderBitTreeDecode(p + LenHigh, kLenNumHighBits, rd);
|
||||
+}
|
||||
+
|
||||
+#define kNumStates 12
|
||||
+
|
||||
+#define kStartPosModelIndex 4
|
||||
+#define kEndPosModelIndex 14
|
||||
+#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
|
||||
+
|
||||
+#define kNumPosSlotBits 6
|
||||
+#define kNumLenToPosStates 4
|
||||
+
|
||||
+#define kNumAlignBits 4
|
||||
+#define kAlignTableSize (1 << kNumAlignBits)
|
||||
+
|
||||
+#define kMatchMinLen 2
|
||||
+
|
||||
+#define IsMatch 0
|
||||
+#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))
|
||||
+#define IsRepG0 (IsRep + kNumStates)
|
||||
+#define IsRepG1 (IsRepG0 + kNumStates)
|
||||
+#define IsRepG2 (IsRepG1 + kNumStates)
|
||||
+#define IsRep0Long (IsRepG2 + kNumStates)
|
||||
+#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))
|
||||
+#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
|
||||
+#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)
|
||||
+#define LenCoder (Align + kAlignTableSize)
|
||||
+#define RepLenCoder (LenCoder + kNumLenProbs)
|
||||
+#define Literal (RepLenCoder + kNumLenProbs)
|
||||
+
|
||||
+#if Literal != LZMA_BASE_SIZE
|
||||
+StopCompilingDueBUG
|
||||
+#endif
|
||||
+
|
||||
+#ifdef _LZMA_OUT_READ
|
||||
+
|
||||
+typedef struct _LzmaVarState
|
||||
+{
|
||||
+ CRangeDecoder RangeDecoder;
|
||||
+ Byte *Dictionary;
|
||||
+ UInt32 DictionarySize;
|
||||
+ UInt32 DictionaryPos;
|
||||
+ UInt32 GlobalPos;
|
||||
+ UInt32 Reps[4];
|
||||
+ int lc;
|
||||
+ int lp;
|
||||
+ int pb;
|
||||
+ int State;
|
||||
+ int PreviousIsMatch;
|
||||
+ int RemainLen;
|
||||
+} LzmaVarState;
|
||||
+
|
||||
+int LzmaDecoderInit(
|
||||
+ unsigned char *buffer, UInt32 bufferSize,
|
||||
+ int lc, int lp, int pb,
|
||||
+ unsigned char *dictionary, UInt32 dictionarySize,
|
||||
+ #ifdef _LZMA_IN_CB
|
||||
+ ILzmaInCallback *inCallback
|
||||
+ #else
|
||||
+ unsigned char *inStream, UInt32 inSize
|
||||
+ #endif
|
||||
+ )
|
||||
+{
|
||||
+ LzmaVarState *vs = (LzmaVarState *)buffer;
|
||||
+ CProb *p = (CProb *)(buffer + sizeof(LzmaVarState));
|
||||
+ UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + lp));
|
||||
+ UInt32 i;
|
||||
+ if (bufferSize < numProbs * sizeof(CProb) + sizeof(LzmaVarState))
|
||||
+ return LZMA_RESULT_NOT_ENOUGH_MEM;
|
||||
+ vs->Dictionary = dictionary;
|
||||
+ vs->DictionarySize = dictionarySize;
|
||||
+ vs->DictionaryPos = 0;
|
||||
+ vs->GlobalPos = 0;
|
||||
+ vs->Reps[0] = vs->Reps[1] = vs->Reps[2] = vs->Reps[3] = 1;
|
||||
+ vs->lc = lc;
|
||||
+ vs->lp = lp;
|
||||
+ vs->pb = pb;
|
||||
+ vs->State = 0;
|
||||
+ vs->PreviousIsMatch = 0;
|
||||
+ vs->RemainLen = 0;
|
||||
+ dictionary[dictionarySize - 1] = 0;
|
||||
+ for (i = 0; i < numProbs; i++)
|
||||
+ p[i] = kBitModelTotal >> 1;
|
||||
+ RangeDecoderInit(&vs->RangeDecoder,
|
||||
+ #ifdef _LZMA_IN_CB
|
||||
+ inCallback
|
||||
+ #else
|
||||
+ inStream, inSize
|
||||
+ #endif
|
||||
+ );
|
||||
+ return LZMA_RESULT_OK;
|
||||
+}
|
||||
+
|
||||
+int LzmaDecode(unsigned char *buffer,
|
||||
+ unsigned char *outStream, UInt32 outSize,
|
||||
+ UInt32 *outSizeProcessed)
|
||||
+{
|
||||
+ LzmaVarState *vs = (LzmaVarState *)buffer;
|
||||
+ CProb *p = (CProb *)(buffer + sizeof(LzmaVarState));
|
||||
+ CRangeDecoder rd = vs->RangeDecoder;
|
||||
+ int state = vs->State;
|
||||
+ int previousIsMatch = vs->PreviousIsMatch;
|
||||
+ Byte previousByte;
|
||||
+ UInt32 rep0 = vs->Reps[0], rep1 = vs->Reps[1], rep2 = vs->Reps[2], rep3 = vs->Reps[3];
|
||||
+ UInt32 nowPos = 0;
|
||||
+ UInt32 posStateMask = (1 << (vs->pb)) - 1;
|
||||
+ UInt32 literalPosMask = (1 << (vs->lp)) - 1;
|
||||
+ int lc = vs->lc;
|
||||
+ int len = vs->RemainLen;
|
||||
+ UInt32 globalPos = vs->GlobalPos;
|
||||
+
|
||||
+ Byte *dictionary = vs->Dictionary;
|
||||
+ UInt32 dictionarySize = vs->DictionarySize;
|
||||
+ UInt32 dictionaryPos = vs->DictionaryPos;
|
||||
+
|
||||
+ if (len == -1)
|
||||
+ {
|
||||
+ *outSizeProcessed = 0;
|
||||
+ return LZMA_RESULT_OK;
|
||||
+ }
|
||||
+
|
||||
+ while(len > 0 && nowPos < outSize)
|
||||
+ {
|
||||
+ UInt32 pos = dictionaryPos - rep0;
|
||||
+ if (pos >= dictionarySize)
|
||||
+ pos += dictionarySize;
|
||||
+ outStream[nowPos++] = dictionary[dictionaryPos] = dictionary[pos];
|
||||
+ if (++dictionaryPos == dictionarySize)
|
||||
+ dictionaryPos = 0;
|
||||
+ len--;
|
||||
+ }
|
||||
+ if (dictionaryPos == 0)
|
||||
+ previousByte = dictionary[dictionarySize - 1];
|
||||
+ else
|
||||
+ previousByte = dictionary[dictionaryPos - 1];
|
||||
+#else
|
||||
+
|
||||
+int LzmaDecode(
|
||||
+ Byte *buffer, UInt32 bufferSize,
|
||||
+ int lc, int lp, int pb,
|
||||
+ #ifdef _LZMA_IN_CB
|
||||
+ ILzmaInCallback *inCallback,
|
||||
+ #else
|
||||
+ unsigned char *inStream, UInt32 inSize,
|
||||
+ #endif
|
||||
+ unsigned char *outStream, UInt32 outSize,
|
||||
+ UInt32 *outSizeProcessed)
|
||||
+{
|
||||
+ UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + lp));
|
||||
+ CProb *p = (CProb *)buffer;
|
||||
+ CRangeDecoder rd;
|
||||
+ UInt32 i;
|
||||
+ int state = 0;
|
||||
+ int previousIsMatch = 0;
|
||||
+ Byte previousByte = 0;
|
||||
+ UInt32 rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1;
|
||||
+ UInt32 nowPos = 0;
|
||||
+ UInt32 posStateMask = (1 << pb) - 1;
|
||||
+ UInt32 literalPosMask = (1 << lp) - 1;
|
||||
+ int len = 0;
|
||||
+ if (bufferSize < numProbs * sizeof(CProb))
|
||||
+ return LZMA_RESULT_NOT_ENOUGH_MEM;
|
||||
+ for (i = 0; i < numProbs; i++)
|
||||
+ p[i] = kBitModelTotal >> 1;
|
||||
+ RangeDecoderInit(&rd,
|
||||
+ #ifdef _LZMA_IN_CB
|
||||
+ inCallback
|
||||
+ #else
|
||||
+ inStream, inSize
|
||||
+ #endif
|
||||
+ );
|
||||
+#endif
|
||||
+
|
||||
+ *outSizeProcessed = 0;
|
||||
+ while(nowPos < outSize)
|
||||
+ {
|
||||
+ int posState = (int)(
|
||||
+ (nowPos
|
||||
+ #ifdef _LZMA_OUT_READ
|
||||
+ + globalPos
|
||||
+ #endif
|
||||
+ )
|
||||
+ & posStateMask);
|
||||
+ #ifdef _LZMA_IN_CB
|
||||
+ if (rd.Result != LZMA_RESULT_OK)
|
||||
+ return rd.Result;
|
||||
+ #endif
|
||||
+ if (rd.ExtraBytes != 0)
|
||||
+ return LZMA_RESULT_DATA_ERROR;
|
||||
+ if (RangeDecoderBitDecode(p + IsMatch + (state << kNumPosBitsMax) + posState, &rd) == 0)
|
||||
+ {
|
||||
+ CProb *probs = p + Literal + (LZMA_LIT_SIZE *
|
||||
+ (((
|
||||
+ (nowPos
|
||||
+ #ifdef _LZMA_OUT_READ
|
||||
+ + globalPos
|
||||
+ #endif
|
||||
+ )
|
||||
+ & literalPosMask) << lc) + (previousByte >> (8 - lc))));
|
||||
+
|
||||
+ if (state < 4) state = 0;
|
||||
+ else if (state < 10) state -= 3;
|
||||
+ else state -= 6;
|
||||
+ if (previousIsMatch)
|
||||
+ {
|
||||
+ Byte matchByte;
|
||||
+ #ifdef _LZMA_OUT_READ
|
||||
+ UInt32 pos = dictionaryPos - rep0;
|
||||
+ if (pos >= dictionarySize)
|
||||
+ pos += dictionarySize;
|
||||
+ matchByte = dictionary[pos];
|
||||
+ #else
|
||||
+ matchByte = outStream[nowPos - rep0];
|
||||
+ #endif
|
||||
+ previousByte = LzmaLiteralDecodeMatch(probs, &rd, matchByte);
|
||||
+ previousIsMatch = 0;
|
||||
+ }
|
||||
+ else
|
||||
+ previousByte = LzmaLiteralDecode(probs, &rd);
|
||||
+ outStream[nowPos++] = previousByte;
|
||||
+ #ifdef _LZMA_OUT_READ
|
||||
+ dictionary[dictionaryPos] = previousByte;
|
||||
+ if (++dictionaryPos == dictionarySize)
|
||||
+ dictionaryPos = 0;
|
||||
+ #endif
|
||||
+ }
|
||||
+ else
|
||||
+ {
|
||||
+ previousIsMatch = 1;
|
||||
+ if (RangeDecoderBitDecode(p + IsRep + state, &rd) == 1)
|
||||
+ {
|
||||
+ if (RangeDecoderBitDecode(p + IsRepG0 + state, &rd) == 0)
|
||||
+ {
|
||||
+ if (RangeDecoderBitDecode(p + IsRep0Long + (state << kNumPosBitsMax) + posState, &rd) == 0)
|
||||
+ {
|
||||
+ #ifdef _LZMA_OUT_READ
|
||||
+ UInt32 pos;
|
||||
+ #endif
|
||||
+ if (
|
||||
+ (nowPos
|
||||
+ #ifdef _LZMA_OUT_READ
|
||||
+ + globalPos
|
||||
+ #endif
|
||||
+ )
|
||||
+ == 0)
|
||||
+ return LZMA_RESULT_DATA_ERROR;
|
||||
+ state = state < 7 ? 9 : 11;
|
||||
+ #ifdef _LZMA_OUT_READ
|
||||
+ pos = dictionaryPos - rep0;
|
||||
+ if (pos >= dictionarySize)
|
||||
+ pos += dictionarySize;
|
||||
+ previousByte = dictionary[pos];
|
||||
+ dictionary[dictionaryPos] = previousByte;
|
||||
+ if (++dictionaryPos == dictionarySize)
|
||||
+ dictionaryPos = 0;
|
||||
+ #else
|
||||
+ previousByte = outStream[nowPos - rep0];
|
||||
+ #endif
|
||||
+ outStream[nowPos++] = previousByte;
|
||||
+ continue;
|
||||
+ }
|
||||
+ }
|
||||
+ else
|
||||
+ {
|
||||
+ UInt32 distance;
|
||||
+ if(RangeDecoderBitDecode(p + IsRepG1 + state, &rd) == 0)
|
||||
+ distance = rep1;
|
||||
+ else
|
||||
+ {
|
||||
+ if(RangeDecoderBitDecode(p + IsRepG2 + state, &rd) == 0)
|
||||
+ distance = rep2;
|
||||
+ else
|
||||
+ {
|
||||
+ distance = rep3;
|
||||
+ rep3 = rep2;
|
||||
+ }
|
||||
+ rep2 = rep1;
|
||||
+ }
|
||||
+ rep1 = rep0;
|
||||
+ rep0 = distance;
|
||||
+ }
|
||||
+ len = LzmaLenDecode(p + RepLenCoder, &rd, posState);
|
||||
+ state = state < 7 ? 8 : 11;
|
||||
+ }
|
||||
+ else
|
||||
+ {
|
||||
+ int posSlot;
|
||||
+ rep3 = rep2;
|
||||
+ rep2 = rep1;
|
||||
+ rep1 = rep0;
|
||||
+ state = state < 7 ? 7 : 10;
|
||||
+ len = LzmaLenDecode(p + LenCoder, &rd, posState);
|
||||
+ posSlot = RangeDecoderBitTreeDecode(p + PosSlot +
|
||||
+ ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) <<
|
||||
+ kNumPosSlotBits), kNumPosSlotBits, &rd);
|
||||
+ if (posSlot >= kStartPosModelIndex)
|
||||
+ {
|
||||
+ int numDirectBits = ((posSlot >> 1) - 1);
|
||||
+ rep0 = ((2 | ((UInt32)posSlot & 1)) << numDirectBits);
|
||||
+ if (posSlot < kEndPosModelIndex)
|
||||
+ {
|
||||
+ rep0 += RangeDecoderReverseBitTreeDecode(
|
||||
+ p + SpecPos + rep0 - posSlot - 1, numDirectBits, &rd);
|
||||
+ }
|
||||
+ else
|
||||
+ {
|
||||
+ rep0 += RangeDecoderDecodeDirectBits(&rd,
|
||||
+ numDirectBits - kNumAlignBits) << kNumAlignBits;
|
||||
+ rep0 += RangeDecoderReverseBitTreeDecode(p + Align, kNumAlignBits, &rd);
|
||||
+ }
|
||||
+ }
|
||||
+ else
|
||||
+ rep0 = posSlot;
|
||||
+ rep0++;
|
||||
+ }
|
||||
+ if (rep0 == (UInt32)(0))
|
||||
+ {
|
||||
+ /* it's for stream version */
|
||||
+ len = -1;
|
||||
+ break;
|
||||
+ }
|
||||
+ if (rep0 > nowPos
|
||||
+ #ifdef _LZMA_OUT_READ
|
||||
+ + globalPos
|
||||
+ #endif
|
||||
+ )
|
||||
+ {
|
||||
+ return LZMA_RESULT_DATA_ERROR;
|
||||
+ }
|
||||
+ len += kMatchMinLen;
|
||||
+ do
|
||||
+ {
|
||||
+ #ifdef _LZMA_OUT_READ
|
||||
+ UInt32 pos = dictionaryPos - rep0;
|
||||
+ if (pos >= dictionarySize)
|
||||
+ pos += dictionarySize;
|
||||
+ previousByte = dictionary[pos];
|
||||
+ dictionary[dictionaryPos] = previousByte;
|
||||
+ if (++dictionaryPos == dictionarySize)
|
||||
+ dictionaryPos = 0;
|
||||
+ #else
|
||||
+ previousByte = outStream[nowPos - rep0];
|
||||
+ #endif
|
||||
+ outStream[nowPos++] = previousByte;
|
||||
+ len--;
|
||||
+ }
|
||||
+ while(len > 0 && nowPos < outSize);
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
+ #ifdef _LZMA_OUT_READ
|
||||
+ vs->RangeDecoder = rd;
|
||||
+ vs->DictionaryPos = dictionaryPos;
|
||||
+ vs->GlobalPos = globalPos + nowPos;
|
||||
+ vs->Reps[0] = rep0;
|
||||
+ vs->Reps[1] = rep1;
|
||||
+ vs->Reps[2] = rep2;
|
||||
+ vs->Reps[3] = rep3;
|
||||
+ vs->State = state;
|
||||
+ vs->PreviousIsMatch = previousIsMatch;
|
||||
+ vs->RemainLen = len;
|
||||
+ #endif
|
||||
+
|
||||
+ *outSizeProcessed = nowPos;
|
||||
+ return LZMA_RESULT_OK;
|
||||
+}
|
||||
--- a/lib/Makefile
|
||||
+++ b/lib/Makefile
|
||||
@@ -14,7 +14,7 @@ lib-$(CONFIG_SMP) += cpumask.o
|
||||
lib-y += kobject.o kref.o klist.o
|
||||
|
||||
obj-y += div64.o sort.o parser.o halfmd4.o debug_locks.o random32.o \
|
||||
- bust_spinlocks.o hexdump.o kasprintf.o bitmap.o scatterlist.o
|
||||
+ bust_spinlocks.o hexdump.o kasprintf.o bitmap.o scatterlist.o LzmaDecode.o
|
||||
|
||||
ifeq ($(CONFIG_DEBUG_KOBJECT),y)
|
||||
CFLAGS_kobject.o += -DDEBUG
|
|
@ -1,107 +0,0 @@
|
|||
--- a/fs/squashfs/inode.c
|
||||
+++ b/fs/squashfs/inode.c
|
||||
@@ -4,6 +4,9 @@
|
||||
* Copyright (c) 2002, 2003, 2004, 2005, 2006
|
||||
* Phillip Lougher <phillip@lougher.org.uk>
|
||||
*
|
||||
+ * LZMA decompressor support added by Oleg I. Vdovikin
|
||||
+ * Copyright (c) 2005 Oleg I.Vdovikin <oleg@cs.msu.su>
|
||||
+ *
|
||||
* 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,
|
||||
@@ -21,6 +24,7 @@
|
||||
* inode.c
|
||||
*/
|
||||
|
||||
+#define SQUASHFS_LZMA
|
||||
#include <linux/types.h>
|
||||
#include <linux/squashfs_fs.h>
|
||||
#include <linux/module.h>
|
||||
@@ -44,6 +48,19 @@
|
||||
|
||||
#include "squashfs.h"
|
||||
|
||||
+#ifdef SQUASHFS_LZMA
|
||||
+#include <linux/LzmaDecode.h>
|
||||
+
|
||||
+/* default LZMA settings, should be in sync with mksquashfs */
|
||||
+#define LZMA_LC 3
|
||||
+#define LZMA_LP 0
|
||||
+#define LZMA_PB 2
|
||||
+
|
||||
+#define LZMA_WORKSPACE_SIZE ((LZMA_BASE_SIZE + \
|
||||
+ (LZMA_LIT_SIZE << (LZMA_LC + LZMA_LP))) * sizeof(CProb))
|
||||
+
|
||||
+#endif
|
||||
+
|
||||
static void squashfs_put_super(struct super_block *);
|
||||
static int squashfs_statfs(struct dentry *, struct kstatfs *);
|
||||
static int squashfs_symlink_readpage(struct file *file, struct page *page);
|
||||
@@ -64,7 +81,11 @@ static int squashfs_get_sb(struct file_s
|
||||
const char *, void *, struct vfsmount *);
|
||||
|
||||
|
||||
+#ifdef SQUASHFS_LZMA
|
||||
+static unsigned char lzma_workspace[LZMA_WORKSPACE_SIZE];
|
||||
+#else
|
||||
static z_stream stream;
|
||||
+#endif
|
||||
|
||||
static struct file_system_type squashfs_fs_type = {
|
||||
.owner = THIS_MODULE,
|
||||
@@ -249,6 +270,15 @@ SQSH_EXTERN unsigned int squashfs_read_d
|
||||
if (compressed) {
|
||||
int zlib_err;
|
||||
|
||||
+#ifdef SQUASHFS_LZMA
|
||||
+ if ((zlib_err = LzmaDecode(lzma_workspace,
|
||||
+ LZMA_WORKSPACE_SIZE, LZMA_LC, LZMA_LP, LZMA_PB,
|
||||
+ c_buffer, c_byte, buffer, msblk->read_size, &bytes)) != LZMA_RESULT_OK)
|
||||
+ {
|
||||
+ ERROR("lzma returned unexpected result 0x%x\n", zlib_err);
|
||||
+ bytes = 0;
|
||||
+ }
|
||||
+#else
|
||||
stream.next_in = c_buffer;
|
||||
stream.avail_in = c_byte;
|
||||
stream.next_out = buffer;
|
||||
@@ -263,7 +293,7 @@ SQSH_EXTERN unsigned int squashfs_read_d
|
||||
bytes = 0;
|
||||
} else
|
||||
bytes = stream.total_out;
|
||||
-
|
||||
+#endif
|
||||
up(&msblk->read_data_mutex);
|
||||
}
|
||||
|
||||
@@ -2045,15 +2075,19 @@ static int __init init_squashfs_fs(void)
|
||||
printk(KERN_INFO "squashfs: version 3.0 (2006/03/15) "
|
||||
"Phillip Lougher\n");
|
||||
|
||||
+#ifndef SQUASHFS_LZMA
|
||||
if (!(stream.workspace = vmalloc(zlib_inflate_workspacesize()))) {
|
||||
ERROR("Failed to allocate zlib workspace\n");
|
||||
destroy_inodecache();
|
||||
err = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
+#endif
|
||||
|
||||
if ((err = register_filesystem(&squashfs_fs_type))) {
|
||||
+#ifndef SQUASHFS_LZMA
|
||||
vfree(stream.workspace);
|
||||
+#endif
|
||||
destroy_inodecache();
|
||||
}
|
||||
|
||||
@@ -2064,7 +2098,9 @@ out:
|
||||
|
||||
static void __exit exit_squashfs_fs(void)
|
||||
{
|
||||
+#ifndef SQUASHFS_LZMA
|
||||
vfree(stream.workspace);
|
||||
+#endif
|
||||
unregister_filesystem(&squashfs_fs_type);
|
||||
destroy_inodecache();
|
||||
}
|
|
@ -1,12 +0,0 @@
|
|||
--- a/Makefile
|
||||
+++ b/Makefile
|
||||
@@ -533,6 +533,9 @@ endif
|
||||
NOSTDINC_FLAGS += -nostdinc -isystem $(shell $(CC) -print-file-name=include)
|
||||
CHECKFLAGS += $(NOSTDINC_FLAGS)
|
||||
|
||||
+# improve gcc optimization
|
||||
+CFLAGS += $(call cc-option,-funit-at-a-time,)
|
||||
+
|
||||
# warn about C99 declaration after statement
|
||||
KBUILD_CFLAGS += $(call cc-option,-Wdeclaration-after-statement,)
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
--- a/fs/squashfs/inode.c
|
||||
+++ b/fs/squashfs/inode.c
|
||||
@@ -33,6 +33,7 @@
|
||||
#include <linux/fs.h>
|
||||
#include <linux/smp_lock.h>
|
||||
#include <linux/slab.h>
|
||||
+#include <linux/exportfs.h>
|
||||
#include <linux/squashfs_fs_sb.h>
|
||||
#include <linux/squashfs_fs_i.h>
|
||||
#include <linux/buffer_head.h>
|
||||
@@ -2125,7 +2126,7 @@ static void squashfs_destroy_inode(struc
|
||||
}
|
||||
|
||||
|
||||
-static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
|
||||
+static void init_once(struct kmem_cache * cachep, void *foo)
|
||||
{
|
||||
struct squashfs_inode_info *ei = foo;
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
--- a/include/asm-mips/system.h
|
||||
+++ b/include/asm-mips/system.h
|
||||
@@ -185,7 +185,7 @@ extern __u64 __xchg_u64_unsupported_on_3
|
||||
if something tries to do an invalid xchg(). */
|
||||
extern void __xchg_called_with_bad_pointer(void);
|
||||
|
||||
-static inline unsigned long __xchg(unsigned long x, volatile void * ptr, int size)
|
||||
+static __always_inline unsigned long __xchg(unsigned long x, volatile void * ptr, int size)
|
||||
{
|
||||
switch (size) {
|
||||
case 4:
|
|
@ -1,36 +0,0 @@
|
|||
--- a/drivers/mtd/chips/cfi_cmdset_0002.c
|
||||
+++ b/drivers/mtd/chips/cfi_cmdset_0002.c
|
||||
@@ -51,6 +51,7 @@
|
||||
#define SST49LF040B 0x0050
|
||||
#define SST49LF008A 0x005a
|
||||
#define AT49BV6416 0x00d6
|
||||
+#define MANUFACTURER_SAMSUNG 0x00ec
|
||||
|
||||
static int cfi_amdstd_read (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
|
||||
static int cfi_amdstd_write_words(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
|
||||
@@ -298,12 +299,19 @@ struct mtd_info *cfi_cmdset_0002(struct
|
||||
|
||||
if (extp->MajorVersion != '1' ||
|
||||
(extp->MinorVersion < '0' || extp->MinorVersion > '4')) {
|
||||
- printk(KERN_ERR " Unknown Amd/Fujitsu Extended Query "
|
||||
- "version %c.%c.\n", extp->MajorVersion,
|
||||
- extp->MinorVersion);
|
||||
- kfree(extp);
|
||||
- kfree(mtd);
|
||||
- return NULL;
|
||||
+ if (cfi->mfr == MANUFACTURER_SAMSUNG &&
|
||||
+ (extp->MajorVersion == '3' && extp->MinorVersion == '3')) {
|
||||
+ printk(KERN_NOTICE " Newer Samsung flash detected, "
|
||||
+ "should be compatibile with Amd/Fujitsu.\n");
|
||||
+ }
|
||||
+ else {
|
||||
+ printk(KERN_ERR " Unknown Amd/Fujitsu Extended Query "
|
||||
+ "version %c.%c.\n", extp->MajorVersion,
|
||||
+ extp->MinorVersion);
|
||||
+ kfree(extp);
|
||||
+ kfree(mtd);
|
||||
+ return NULL;
|
||||
+ }
|
||||
}
|
||||
|
||||
/* Install our own private info structure */
|
|
@ -1,169 +0,0 @@
|
|||
--- a/drivers/mtd/chips/cfi_cmdset_0001.c
|
||||
+++ b/drivers/mtd/chips/cfi_cmdset_0001.c
|
||||
@@ -1008,7 +1008,7 @@ static void __xipram xip_enable(struct m
|
||||
|
||||
static int __xipram xip_wait_for_operation(
|
||||
struct map_info *map, struct flchip *chip,
|
||||
- unsigned long adr, unsigned int chip_op_time )
|
||||
+ unsigned long adr, int *chip_op_time )
|
||||
{
|
||||
struct cfi_private *cfi = map->fldrv_priv;
|
||||
struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
|
||||
@@ -1017,7 +1017,7 @@ static int __xipram xip_wait_for_operati
|
||||
flstate_t oldstate, newstate;
|
||||
|
||||
start = xip_currtime();
|
||||
- usec = chip_op_time * 8;
|
||||
+ usec = *chip_op_time * 8;
|
||||
if (usec == 0)
|
||||
usec = 500000;
|
||||
done = 0;
|
||||
@@ -1127,8 +1127,8 @@ static int __xipram xip_wait_for_operati
|
||||
#define XIP_INVAL_CACHED_RANGE(map, from, size) \
|
||||
INVALIDATE_CACHED_RANGE(map, from, size)
|
||||
|
||||
-#define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, usec) \
|
||||
- xip_wait_for_operation(map, chip, cmd_adr, usec)
|
||||
+#define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, p_usec) \
|
||||
+ xip_wait_for_operation(map, chip, cmd_adr, p_usec)
|
||||
|
||||
#else
|
||||
|
||||
@@ -1140,65 +1140,65 @@ static int __xipram xip_wait_for_operati
|
||||
static int inval_cache_and_wait_for_operation(
|
||||
struct map_info *map, struct flchip *chip,
|
||||
unsigned long cmd_adr, unsigned long inval_adr, int inval_len,
|
||||
- unsigned int chip_op_time)
|
||||
+ int *chip_op_time )
|
||||
{
|
||||
struct cfi_private *cfi = map->fldrv_priv;
|
||||
map_word status, status_OK = CMD(0x80);
|
||||
- int chip_state = chip->state;
|
||||
- unsigned int timeo, sleep_time;
|
||||
+ int z, chip_state = chip->state;
|
||||
+ unsigned long timeo;
|
||||
|
||||
spin_unlock(chip->mutex);
|
||||
if (inval_len)
|
||||
INVALIDATE_CACHED_RANGE(map, inval_adr, inval_len);
|
||||
+ if (*chip_op_time)
|
||||
+ cfi_udelay(*chip_op_time);
|
||||
spin_lock(chip->mutex);
|
||||
|
||||
- /* set our timeout to 8 times the expected delay */
|
||||
- timeo = chip_op_time * 8;
|
||||
- if (!timeo)
|
||||
- timeo = 500000;
|
||||
- sleep_time = chip_op_time / 2;
|
||||
+ timeo = *chip_op_time * 8 * HZ / 1000000;
|
||||
+ if (timeo < HZ/2)
|
||||
+ timeo = HZ/2;
|
||||
+ timeo += jiffies;
|
||||
|
||||
+ z = 0;
|
||||
for (;;) {
|
||||
+ if (chip->state != chip_state) {
|
||||
+ /* Someone's suspended the operation: sleep */
|
||||
+ DECLARE_WAITQUEUE(wait, current);
|
||||
+
|
||||
+ set_current_state(TASK_UNINTERRUPTIBLE);
|
||||
+ add_wait_queue(&chip->wq, &wait);
|
||||
+ spin_unlock(chip->mutex);
|
||||
+ schedule();
|
||||
+ remove_wait_queue(&chip->wq, &wait);
|
||||
+ timeo = jiffies + (HZ / 2); /* FIXME */
|
||||
+ spin_lock(chip->mutex);
|
||||
+ continue;
|
||||
+ }
|
||||
+
|
||||
status = map_read(map, cmd_adr);
|
||||
if (map_word_andequal(map, status, status_OK, status_OK))
|
||||
break;
|
||||
|
||||
- if (!timeo) {
|
||||
+ /* OK Still waiting */
|
||||
+ if (time_after(jiffies, timeo)) {
|
||||
map_write(map, CMD(0x70), cmd_adr);
|
||||
chip->state = FL_STATUS;
|
||||
return -ETIME;
|
||||
}
|
||||
|
||||
- /* OK Still waiting. Drop the lock, wait a while and retry. */
|
||||
+ /* Latency issues. Drop the lock, wait a while and retry */
|
||||
+ z++;
|
||||
spin_unlock(chip->mutex);
|
||||
- if (sleep_time >= 1000000/HZ) {
|
||||
- /*
|
||||
- * Half of the normal delay still remaining
|
||||
- * can be performed with a sleeping delay instead
|
||||
- * of busy waiting.
|
||||
- */
|
||||
- msleep(sleep_time/1000);
|
||||
- timeo -= sleep_time;
|
||||
- sleep_time = 1000000/HZ;
|
||||
- } else {
|
||||
- udelay(1);
|
||||
- cond_resched();
|
||||
- timeo--;
|
||||
- }
|
||||
+ cfi_udelay(1);
|
||||
spin_lock(chip->mutex);
|
||||
-
|
||||
- while (chip->state != chip_state) {
|
||||
- /* Someone's suspended the operation: sleep */
|
||||
- DECLARE_WAITQUEUE(wait, current);
|
||||
- set_current_state(TASK_UNINTERRUPTIBLE);
|
||||
- add_wait_queue(&chip->wq, &wait);
|
||||
- spin_unlock(chip->mutex);
|
||||
- schedule();
|
||||
- remove_wait_queue(&chip->wq, &wait);
|
||||
- spin_lock(chip->mutex);
|
||||
- }
|
||||
}
|
||||
|
||||
+ if (!z) {
|
||||
+ if (!--(*chip_op_time))
|
||||
+ *chip_op_time = 1;
|
||||
+ } else if (z > 1)
|
||||
+ ++(*chip_op_time);
|
||||
+
|
||||
/* Done and happy. */
|
||||
chip->state = FL_STATUS;
|
||||
return 0;
|
||||
@@ -1207,7 +1207,8 @@ static int inval_cache_and_wait_for_oper
|
||||
#endif
|
||||
|
||||
#define WAIT_TIMEOUT(map, chip, adr, udelay) \
|
||||
- INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, udelay);
|
||||
+ ({ int __udelay = (udelay); \
|
||||
+ INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, &__udelay); })
|
||||
|
||||
|
||||
static int do_point_onechip (struct map_info *map, struct flchip *chip, loff_t adr, size_t len)
|
||||
@@ -1438,7 +1439,7 @@ static int __xipram do_write_oneword(str
|
||||
|
||||
ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
|
||||
adr, map_bankwidth(map),
|
||||
- chip->word_write_time);
|
||||
+ &chip->word_write_time);
|
||||
if (ret) {
|
||||
xip_enable(map, chip, adr);
|
||||
printk(KERN_ERR "%s: word write error (status timeout)\n", map->name);
|
||||
@@ -1678,7 +1679,7 @@ static int __xipram do_write_buffer(stru
|
||||
|
||||
ret = INVAL_CACHE_AND_WAIT(map, chip, cmd_adr,
|
||||
initial_adr, initial_len,
|
||||
- chip->buffer_write_time);
|
||||
+ &chip->buffer_write_time);
|
||||
if (ret) {
|
||||
map_write(map, CMD(0x70), cmd_adr);
|
||||
chip->state = FL_STATUS;
|
||||
@@ -1813,7 +1814,7 @@ static int __xipram do_erase_oneblock(st
|
||||
|
||||
ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
|
||||
adr, len,
|
||||
- chip->erase_time);
|
||||
+ &chip->erase_time);
|
||||
if (ret) {
|
||||
map_write(map, CMD(0x70), adr);
|
||||
chip->state = FL_STATUS;
|
|
@ -1,19 +0,0 @@
|
|||
--- a/fs/squashfs/Makefile
|
||||
+++ b/fs/squashfs/Makefile
|
||||
@@ -4,4 +4,3 @@
|
||||
|
||||
obj-$(CONFIG_SQUASHFS) += squashfs.o
|
||||
squashfs-y += inode.o
|
||||
-squashfs-y += squashfs2_0.o
|
||||
--- a/fs/squashfs/squashfs.h
|
||||
+++ b/fs/squashfs/squashfs.h
|
||||
@@ -24,6 +24,9 @@
|
||||
#ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY
|
||||
#undef CONFIG_SQUASHFS_1_0_COMPATIBILITY
|
||||
#endif
|
||||
+#ifdef CONFIG_SQUASHFS_2_0_COMPATIBILITY
|
||||
+#undef CONFIG_SQUASHFS_2_0_COMPATIBILITY
|
||||
+#endif
|
||||
|
||||
#ifdef SQUASHFS_TRACE
|
||||
#define TRACE(s, args...) printk(KERN_NOTICE "SQUASHFS: "s, ## args)
|
|
@ -1,11 +0,0 @@
|
|||
--- a/arch/mips/kernel/head.S
|
||||
+++ b/arch/mips/kernel/head.S
|
||||
@@ -120,6 +120,8 @@
|
||||
#endif
|
||||
.endm
|
||||
|
||||
+ j kernel_entry
|
||||
+ nop
|
||||
#ifndef CONFIG_NO_EXCEPT_FILL
|
||||
/*
|
||||
* Reserved space for exception handlers.
|
|
@ -1,11 +0,0 @@
|
|||
--- a/arch/mips/kernel/machine_kexec.c 2010-03-15 15:52:04.000000000 +0000
|
||||
+++ b/arch/mips/kernel/machine_kexec.c 2010-03-29 12:10:37.000000000 +0100
|
||||
@@ -52,7 +52,7 @@
|
||||
reboot_code_buffer =
|
||||
(unsigned long)page_address(image->control_code_page);
|
||||
|
||||
- kexec_start_address = image->start;
|
||||
+ kexec_start_address = (unsigned long) phys_to_virt(image->start);
|
||||
kexec_indirection_page =
|
||||
(unsigned long) phys_to_virt(image->head & PAGE_MASK);
|
||||
|
|
@ -1,155 +0,0 @@
|
|||
MIPS: allow disabling the kernel FPU emulator
|
||||
|
||||
This patch allows turning off the in-kernel Algorithmics
|
||||
FPU emulator support, which allows one to save a couple of
|
||||
precious blocks on an embedded system.
|
||||
|
||||
Signed-off-by: Florian Fainelli <florian@openwrt.org>
|
||||
--
|
||||
--- a/arch/mips/Kconfig
|
||||
+++ b/arch/mips/Kconfig
|
||||
@@ -831,6 +831,17 @@ config I8259
|
||||
config MIPS_BONITO64
|
||||
bool
|
||||
|
||||
+config MIPS_FPU_EMU
|
||||
+ bool "Enable FPU emulation"
|
||||
+ default y
|
||||
+ help
|
||||
+ This option allows building a kernel with or without the Algorithmics
|
||||
+ FPU emulator enabled. Turning off this option results in a kernel which
|
||||
+ does not catch floating operations exceptions. Make sure that your toolchain
|
||||
+ is configured to enable software floating point emulation in that case.
|
||||
+
|
||||
+ If unsure say Y here.
|
||||
+
|
||||
config MIPS_MSC
|
||||
bool
|
||||
|
||||
--- a/arch/mips/math-emu/Makefile
|
||||
+++ b/arch/mips/math-emu/Makefile
|
||||
@@ -2,12 +2,14 @@
|
||||
# Makefile for the Linux/MIPS kernel FPU emulation.
|
||||
#
|
||||
|
||||
-obj-y := cp1emu.o ieee754m.o ieee754d.o ieee754dp.o ieee754sp.o ieee754.o \
|
||||
+obj-y := kernel_linkage.o dsemul.o cp1emu.o
|
||||
+
|
||||
+obj-$(CONFIG_MIPS_FPU_EMU) += ieee754m.o ieee754d.o ieee754dp.o ieee754sp.o ieee754.o \
|
||||
ieee754xcpt.o dp_frexp.o dp_modf.o dp_div.o dp_mul.o dp_sub.o \
|
||||
dp_add.o dp_fsp.o dp_cmp.o dp_logb.o dp_scalb.o dp_simple.o \
|
||||
dp_tint.o dp_fint.o dp_tlong.o dp_flong.o sp_frexp.o sp_modf.o \
|
||||
sp_div.o sp_mul.o sp_sub.o sp_add.o sp_fdp.o sp_cmp.o sp_logb.o \
|
||||
sp_scalb.o sp_simple.o sp_tint.o sp_fint.o sp_tlong.o sp_flong.o \
|
||||
- dp_sqrt.o sp_sqrt.o kernel_linkage.o dsemul.o
|
||||
+ dp_sqrt.o sp_sqrt.o
|
||||
|
||||
EXTRA_CFLAGS += -Werror
|
||||
--- a/arch/mips/math-emu/cp1emu.c
|
||||
+++ b/arch/mips/math-emu/cp1emu.c
|
||||
@@ -57,6 +57,12 @@
|
||||
#endif
|
||||
#define __mips 4
|
||||
|
||||
+/* Further private data for which no space exists in mips_fpu_struct */
|
||||
+
|
||||
+struct mips_fpu_emulator_stats fpuemustats;
|
||||
+
|
||||
+#ifdef CONFIG_MIPS_FPU_EMU
|
||||
+
|
||||
/* Function which emulates a floating point instruction. */
|
||||
|
||||
static int fpu_emu(struct pt_regs *, struct mips_fpu_struct *,
|
||||
@@ -67,10 +73,6 @@ static int fpux_emu(struct pt_regs *,
|
||||
struct mips_fpu_struct *, mips_instruction);
|
||||
#endif
|
||||
|
||||
-/* Further private data for which no space exists in mips_fpu_struct */
|
||||
-
|
||||
-struct mips_fpu_emulator_stats fpuemustats;
|
||||
-
|
||||
/* Control registers */
|
||||
|
||||
#define FPCREG_RID 0 /* $0 = revision id */
|
||||
@@ -1277,6 +1279,13 @@ int fpu_emulator_cop1Handler(struct pt_r
|
||||
|
||||
return sig;
|
||||
}
|
||||
+#else
|
||||
+int fpu_emulator_cop1Handler(struct pt_regs *xcp, struct mips_fpu_struct *ctx,
|
||||
+ int has_fpu)
|
||||
+{
|
||||
+ return 0;
|
||||
+}
|
||||
+#endif /* CONFIG_MIPS_FPU_EMU */
|
||||
|
||||
#ifdef CONFIG_DEBUG_FS
|
||||
extern struct dentry *mips_debugfs_dir;
|
||||
--- a/arch/mips/math-emu/dsemul.c
|
||||
+++ b/arch/mips/math-emu/dsemul.c
|
||||
@@ -110,6 +110,7 @@ int mips_dsemul(struct pt_regs *regs, mi
|
||||
return SIGILL; /* force out of emulation loop */
|
||||
}
|
||||
|
||||
+#ifdef CONFIG_MIPS_FPU_EMU
|
||||
int do_dsemulret(struct pt_regs *xcp)
|
||||
{
|
||||
struct emuframe __user *fr;
|
||||
@@ -166,3 +167,9 @@ int do_dsemulret(struct pt_regs *xcp)
|
||||
|
||||
return 1;
|
||||
}
|
||||
+#else
|
||||
+int do_dsemulret(struct pt_regs *xcp)
|
||||
+{
|
||||
+ return 0;
|
||||
+}
|
||||
+#endif /* CONFIG_MIPS_FPU_EMU */
|
||||
--- a/arch/mips/math-emu/kernel_linkage.c
|
||||
+++ b/arch/mips/math-emu/kernel_linkage.c
|
||||
@@ -28,6 +28,7 @@
|
||||
|
||||
#define SIGNALLING_NAN 0x7ff800007ff80000LL
|
||||
|
||||
+#ifdef CONFIG_MIPS_FPU_EMU
|
||||
void fpu_emulator_init_fpu(void)
|
||||
{
|
||||
static int first = 1;
|
||||
@@ -111,4 +112,36 @@ int fpu_emulator_restore_context32(struc
|
||||
|
||||
return err;
|
||||
}
|
||||
-#endif
|
||||
+#endif /* CONFIG_64BIT */
|
||||
+#else
|
||||
+
|
||||
+void fpu_emulator_init_fpu(void)
|
||||
+{
|
||||
+ printk(KERN_INFO "FPU emulator disabled, make sure your toolchain"
|
||||
+ "was compiled with software floating point support (soft-float)\n");
|
||||
+ return;
|
||||
+}
|
||||
+
|
||||
+int fpu_emulator_save_context(struct sigcontext __user *sc)
|
||||
+{
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+int fpu_emulator_restore_context(struct sigcontext __user *sc)
|
||||
+{
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+#ifdef CONFIG_64BIT
|
||||
+int fpu_emulator_save_context32(struct sigcontext32 __user *sc)
|
||||
+{
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+int fpu_emulator_restore_context32(struct sigcontext32 __user *sc)
|
||||
+{
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+#endif /* CONFIG_64BIT */
|
||||
+#endif /* CONFIG_MIPS_FPU_EMU */
|
|
@ -1,112 +0,0 @@
|
|||
--- a/drivers/mtd/devices/block2mtd.c
|
||||
+++ b/drivers/mtd/devices/block2mtd.c
|
||||
@@ -16,6 +16,7 @@
|
||||
#include <linux/list.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/mtd/mtd.h>
|
||||
+#include <linux/mtd/partitions.h>
|
||||
#include <linux/buffer_head.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/mount.h>
|
||||
@@ -237,10 +238,11 @@ static void block2mtd_free_device(struct
|
||||
|
||||
|
||||
/* FIXME: ensure that mtd->size % erase_size == 0 */
|
||||
-static struct block2mtd_dev *add_device(char *devname, int erase_size)
|
||||
+static struct block2mtd_dev *add_device(char *devname, int erase_size, char *mtdname)
|
||||
{
|
||||
struct block_device *bdev;
|
||||
struct block2mtd_dev *dev;
|
||||
+ struct mtd_partition *part;
|
||||
|
||||
if (!devname)
|
||||
return NULL;
|
||||
@@ -279,14 +281,18 @@ static struct block2mtd_dev *add_device(
|
||||
|
||||
/* Setup the MTD structure */
|
||||
/* make the name contain the block device in */
|
||||
- dev->mtd.name = kmalloc(sizeof("block2mtd: ") + strlen(devname),
|
||||
- GFP_KERNEL);
|
||||
+
|
||||
+ if (!mtdname)
|
||||
+ mtdname = devname;
|
||||
+
|
||||
+ dev->mtd.name = kmalloc(strlen(mtdname) + 1, GFP_KERNEL);
|
||||
+
|
||||
if (!dev->mtd.name)
|
||||
goto devinit_err;
|
||||
+
|
||||
+ strcpy(dev->mtd.name, mtdname);
|
||||
|
||||
- sprintf(dev->mtd.name, "block2mtd: %s", devname);
|
||||
-
|
||||
- dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK;
|
||||
+ dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK & ~(erase_size - 1);
|
||||
dev->mtd.erasesize = erase_size;
|
||||
dev->mtd.writesize = 1;
|
||||
dev->mtd.type = MTD_RAM;
|
||||
@@ -298,15 +304,18 @@ static struct block2mtd_dev *add_device(
|
||||
dev->mtd.read = block2mtd_read;
|
||||
dev->mtd.priv = dev;
|
||||
dev->mtd.owner = THIS_MODULE;
|
||||
-
|
||||
- if (add_mtd_device(&dev->mtd)) {
|
||||
+
|
||||
+ part = kzalloc(sizeof(struct mtd_partition), GFP_KERNEL);
|
||||
+ part->name = dev->mtd.name;
|
||||
+ part->offset = 0;
|
||||
+ part->size = dev->mtd.size;
|
||||
+ if (add_mtd_partitions(&dev->mtd, part, 1)) {
|
||||
/* Device didnt get added, so free the entry */
|
||||
goto devinit_err;
|
||||
}
|
||||
list_add(&dev->list, &blkmtd_device_list);
|
||||
INFO("mtd%d: [%s] erase_size = %dKiB [%d]", dev->mtd.index,
|
||||
- dev->mtd.name + strlen("blkmtd: "),
|
||||
- dev->mtd.erasesize >> 10, dev->mtd.erasesize);
|
||||
+ mtdname, dev->mtd.erasesize >> 10, dev->mtd.erasesize);
|
||||
return dev;
|
||||
|
||||
devinit_err:
|
||||
@@ -379,9 +388,9 @@ static char block2mtd_paramline[80 + 12]
|
||||
|
||||
static int block2mtd_setup2(const char *val)
|
||||
{
|
||||
- char buf[80 + 12]; /* 80 for device, 12 for erase size */
|
||||
+ char buf[80 + 12 + 80]; /* 80 for device, 12 for erase size, 80 for name */
|
||||
char *str = buf;
|
||||
- char *token[2];
|
||||
+ char *token[3];
|
||||
char *name;
|
||||
size_t erase_size = PAGE_SIZE;
|
||||
int i, ret;
|
||||
@@ -392,7 +401,7 @@ static int block2mtd_setup2(const char *
|
||||
strcpy(str, val);
|
||||
kill_final_newline(str);
|
||||
|
||||
- for (i = 0; i < 2; i++)
|
||||
+ for (i = 0; i < 3; i++)
|
||||
token[i] = strsep(&str, ",");
|
||||
|
||||
if (str)
|
||||
@@ -411,8 +420,10 @@ static int block2mtd_setup2(const char *
|
||||
parse_err("illegal erase size");
|
||||
}
|
||||
}
|
||||
+ if (token[2] && (strlen(token[2]) + 1 > 80))
|
||||
+ parse_err("mtd device name too long");
|
||||
|
||||
- add_device(name, erase_size);
|
||||
+ add_device(name, erase_size, token[2]);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -446,7 +457,7 @@ static int block2mtd_setup(const char *v
|
||||
|
||||
|
||||
module_param_call(block2mtd, block2mtd_setup, NULL, NULL, 0200);
|
||||
-MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,<erasesize>]\"");
|
||||
+MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,<erasesize>[,<name>]]\"");
|
||||
|
||||
static int __init block2mtd_init(void)
|
||||
{
|
|
@ -1,951 +0,0 @@
|
|||
--- a/drivers/mtd/Kconfig
|
||||
+++ b/drivers/mtd/Kconfig
|
||||
@@ -47,6 +47,16 @@ config MTD_PARTITIONS
|
||||
devices. Partitioning on NFTL 'devices' is a different - that's the
|
||||
'normal' form of partitioning used on a block device.
|
||||
|
||||
+config MTD_ROOTFS_ROOT_DEV
|
||||
+ bool "Automatically set 'rootfs' partition to be root filesystem"
|
||||
+ depends on MTD_PARTITIONS
|
||||
+ default y
|
||||
+
|
||||
+config MTD_ROOTFS_SPLIT
|
||||
+ bool "Automatically split 'rootfs' partition for squashfs"
|
||||
+ depends on MTD_PARTITIONS
|
||||
+ default y
|
||||
+
|
||||
config MTD_REDBOOT_PARTS
|
||||
tristate "RedBoot partition table parsing"
|
||||
depends on MTD_PARTITIONS
|
||||
--- a/drivers/mtd/mtdpart.c
|
||||
+++ b/drivers/mtd/mtdpart.c
|
||||
@@ -20,6 +20,8 @@
|
||||
#include <linux/mtd/mtd.h>
|
||||
#include <linux/mtd/partitions.h>
|
||||
#include <linux/mtd/compatmac.h>
|
||||
+#include <linux/squashfs_fs.h>
|
||||
+#include <linux/root_dev.h>
|
||||
|
||||
/* Our partition linked list */
|
||||
static LIST_HEAD(mtd_partitions);
|
||||
@@ -39,7 +41,7 @@ struct mtd_part {
|
||||
* the pointer to that structure with this macro.
|
||||
*/
|
||||
#define PART(x) ((struct mtd_part *)(x))
|
||||
-
|
||||
+#define IS_PART(mtd) (mtd->read == part_read)
|
||||
|
||||
/*
|
||||
* MTD methods which simply translate the effective address and pass through
|
||||
@@ -322,6 +324,316 @@ int del_mtd_partitions(struct mtd_info *
|
||||
return 0;
|
||||
}
|
||||
|
||||
+static u_int32_t cur_offset = 0;
|
||||
+static int add_one_partition(struct mtd_info *master, const struct mtd_partition *part,
|
||||
+ int i, struct mtd_part **slp)
|
||||
+{
|
||||
+ struct mtd_part *slave;
|
||||
+
|
||||
+ /* allocate the partition structure */
|
||||
+ slave = kzalloc (sizeof(*slave), GFP_KERNEL);
|
||||
+ if (!slave) {
|
||||
+ printk ("memory allocation error while creating partitions for \"%s\"\n",
|
||||
+ master->name);
|
||||
+ del_mtd_partitions(master);
|
||||
+ return -ENOMEM;
|
||||
+ }
|
||||
+ list_add(&slave->list, &mtd_partitions);
|
||||
+
|
||||
+ /* set up the MTD object for this partition */
|
||||
+ slave->mtd.type = master->type;
|
||||
+ slave->mtd.flags = master->flags & ~part->mask_flags;
|
||||
+ slave->mtd.size = part->size;
|
||||
+ slave->mtd.writesize = master->writesize;
|
||||
+ slave->mtd.oobsize = master->oobsize;
|
||||
+ slave->mtd.oobavail = master->oobavail;
|
||||
+ slave->mtd.subpage_sft = master->subpage_sft;
|
||||
+
|
||||
+ slave->mtd.name = part->name;
|
||||
+ slave->mtd.owner = master->owner;
|
||||
+
|
||||
+ slave->mtd.read = part_read;
|
||||
+ slave->mtd.write = part_write;
|
||||
+
|
||||
+ if (master->panic_write)
|
||||
+ slave->mtd.panic_write = part_panic_write;
|
||||
+
|
||||
+ slave->mtd.refresh_device = part->refresh_partition;
|
||||
+
|
||||
+ if(master->point && master->unpoint){
|
||||
+ slave->mtd.point = part_point;
|
||||
+ slave->mtd.unpoint = part_unpoint;
|
||||
+ }
|
||||
+
|
||||
+ if (master->read_oob)
|
||||
+ slave->mtd.read_oob = part_read_oob;
|
||||
+ if (master->write_oob)
|
||||
+ slave->mtd.write_oob = part_write_oob;
|
||||
+ if(master->read_user_prot_reg)
|
||||
+ slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
|
||||
+ if(master->read_fact_prot_reg)
|
||||
+ slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
|
||||
+ if(master->write_user_prot_reg)
|
||||
+ slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
|
||||
+ if(master->lock_user_prot_reg)
|
||||
+ slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
|
||||
+ if(master->get_user_prot_info)
|
||||
+ slave->mtd.get_user_prot_info = part_get_user_prot_info;
|
||||
+ if(master->get_fact_prot_info)
|
||||
+ slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
|
||||
+ if (master->sync)
|
||||
+ slave->mtd.sync = part_sync;
|
||||
+ if (!i && master->suspend && master->resume) {
|
||||
+ slave->mtd.suspend = part_suspend;
|
||||
+ slave->mtd.resume = part_resume;
|
||||
+ }
|
||||
+ if (master->writev)
|
||||
+ slave->mtd.writev = part_writev;
|
||||
+ if (master->lock)
|
||||
+ slave->mtd.lock = part_lock;
|
||||
+ if (master->unlock)
|
||||
+ slave->mtd.unlock = part_unlock;
|
||||
+ if (master->block_isbad)
|
||||
+ slave->mtd.block_isbad = part_block_isbad;
|
||||
+ if (master->block_markbad)
|
||||
+ slave->mtd.block_markbad = part_block_markbad;
|
||||
+ slave->mtd.erase = part_erase;
|
||||
+ slave->master = master;
|
||||
+ slave->offset = part->offset;
|
||||
+ slave->index = i;
|
||||
+
|
||||
+ if (slave->offset == MTDPART_OFS_APPEND)
|
||||
+ slave->offset = cur_offset;
|
||||
+ if (slave->offset == MTDPART_OFS_NXTBLK) {
|
||||
+ slave->offset = cur_offset;
|
||||
+ if ((cur_offset % master->erasesize) != 0) {
|
||||
+ /* Round up to next erasesize */
|
||||
+ slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize;
|
||||
+ printk(KERN_NOTICE "Moving partition %d: "
|
||||
+ "0x%08x -> 0x%08x\n", i,
|
||||
+ cur_offset, slave->offset);
|
||||
+ }
|
||||
+ }
|
||||
+ if (slave->mtd.size == MTDPART_SIZ_FULL)
|
||||
+ slave->mtd.size = master->size - slave->offset;
|
||||
+ cur_offset = slave->offset + slave->mtd.size;
|
||||
+
|
||||
+ printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset,
|
||||
+ slave->offset + slave->mtd.size, slave->mtd.name);
|
||||
+
|
||||
+ /* let's do some sanity checks */
|
||||
+ if (slave->offset >= master->size) {
|
||||
+ /* let's register it anyway to preserve ordering */
|
||||
+ slave->offset = 0;
|
||||
+ slave->mtd.size = 0;
|
||||
+ printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
|
||||
+ part->name);
|
||||
+ }
|
||||
+ if (slave->offset + slave->mtd.size > master->size) {
|
||||
+ slave->mtd.size = master->size - slave->offset;
|
||||
+ printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
|
||||
+ part->name, master->name, slave->mtd.size);
|
||||
+ }
|
||||
+ if (master->numeraseregions>1) {
|
||||
+ /* Deal with variable erase size stuff */
|
||||
+ int i;
|
||||
+ struct mtd_erase_region_info *regions = master->eraseregions;
|
||||
+
|
||||
+ /* Find the first erase regions which is part of this partition. */
|
||||
+ for (i=0; i < master->numeraseregions && slave->offset >= regions[i].offset; i++)
|
||||
+ ;
|
||||
+
|
||||
+ for (i--; i < master->numeraseregions && slave->offset + slave->mtd.size > regions[i].offset; i++) {
|
||||
+ if (slave->mtd.erasesize < regions[i].erasesize) {
|
||||
+ slave->mtd.erasesize = regions[i].erasesize;
|
||||
+ }
|
||||
+ }
|
||||
+ } else {
|
||||
+ /* Single erase size */
|
||||
+ slave->mtd.erasesize = master->erasesize;
|
||||
+ }
|
||||
+
|
||||
+ if ((slave->mtd.flags & MTD_WRITEABLE) &&
|
||||
+ (slave->offset % slave->mtd.erasesize)) {
|
||||
+ /* Doesn't start on a boundary of major erase size */
|
||||
+ /* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
|
||||
+ slave->mtd.flags &= ~MTD_WRITEABLE;
|
||||
+ printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
|
||||
+ part->name);
|
||||
+ }
|
||||
+ if ((slave->mtd.flags & MTD_WRITEABLE) &&
|
||||
+ (slave->mtd.size % slave->mtd.erasesize)) {
|
||||
+ slave->mtd.flags &= ~MTD_WRITEABLE;
|
||||
+ printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
|
||||
+ part->name);
|
||||
+ }
|
||||
+
|
||||
+ slave->mtd.ecclayout = master->ecclayout;
|
||||
+ if (master->block_isbad) {
|
||||
+ uint32_t offs = 0;
|
||||
+
|
||||
+ while(offs < slave->mtd.size) {
|
||||
+ if (master->block_isbad(master,
|
||||
+ offs + slave->offset))
|
||||
+ slave->mtd.ecc_stats.badblocks++;
|
||||
+ offs += slave->mtd.erasesize;
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
+ if(part->mtdp)
|
||||
+ { /* store the object pointer (caller may or may not register it */
|
||||
+ *part->mtdp = &slave->mtd;
|
||||
+ slave->registered = 0;
|
||||
+ }
|
||||
+ else
|
||||
+ {
|
||||
+ /* register our partition */
|
||||
+ add_mtd_device(&slave->mtd);
|
||||
+ slave->registered = 1;
|
||||
+ }
|
||||
+
|
||||
+ if (slp)
|
||||
+ *slp = slave;
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+#ifdef CONFIG_MTD_ROOTFS_SPLIT
|
||||
+#define ROOTFS_SPLIT_NAME "rootfs_data"
|
||||
+#define ROOTFS_REMOVED_NAME "<removed>"
|
||||
+static int split_squashfs(struct mtd_info *master, int offset, int *split_offset)
|
||||
+{
|
||||
+ char buf[512];
|
||||
+ struct squashfs_super_block *sb = (struct squashfs_super_block *) buf;
|
||||
+ int len, ret;
|
||||
+
|
||||
+ ret = master->read(master, offset, sizeof(*sb), &len, buf);
|
||||
+ if (ret || (len != sizeof(*sb))) {
|
||||
+ printk(KERN_ALERT "split_squashfs: error occured while reading "
|
||||
+ "from \"%s\"\n", master->name);
|
||||
+ return -EINVAL;
|
||||
+ }
|
||||
+
|
||||
+ if (*((u32 *) buf) != SQUASHFS_MAGIC) {
|
||||
+ printk(KERN_ALERT "split_squashfs: no squashfs found in \"%s\"\n",
|
||||
+ master->name);
|
||||
+ *split_offset = 0;
|
||||
+ return 0;
|
||||
+ }
|
||||
+
|
||||
+ if (sb->bytes_used <= 0) {
|
||||
+ printk(KERN_ALERT "split_squashfs: squashfs is empty in \"%s\"\n",
|
||||
+ master->name);
|
||||
+ *split_offset = 0;
|
||||
+ return 0;
|
||||
+ }
|
||||
+
|
||||
+ len = (u32) sb->bytes_used;
|
||||
+ len += (offset & 0x000fffff);
|
||||
+ len += (master->erasesize - 1);
|
||||
+ len &= ~(master->erasesize - 1);
|
||||
+ len -= (offset & 0x000fffff);
|
||||
+ *split_offset = offset + len;
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static int split_rootfs_data(struct mtd_info *master, struct mtd_info *rpart, struct mtd_partition *part,
|
||||
+ int index)
|
||||
+{
|
||||
+ struct mtd_partition *dpart;
|
||||
+ struct mtd_part *slave = NULL;
|
||||
+ int split_offset = 0;
|
||||
+ int ret;
|
||||
+
|
||||
+ ret = split_squashfs(master, part->offset, &split_offset);
|
||||
+ if (ret)
|
||||
+ return ret;
|
||||
+
|
||||
+ if (split_offset <= 0)
|
||||
+ return 0;
|
||||
+
|
||||
+ dpart = kmalloc(sizeof(*part)+sizeof(ROOTFS_SPLIT_NAME)+1, GFP_KERNEL);
|
||||
+ if (dpart == NULL) {
|
||||
+ printk(KERN_INFO "split_squashfs: no memory for partition \"%s\"\n",
|
||||
+ ROOTFS_SPLIT_NAME);
|
||||
+ return -ENOMEM;
|
||||
+ }
|
||||
+
|
||||
+ memcpy(dpart, part, sizeof(*part));
|
||||
+ dpart->name = (unsigned char *)&dpart[1];
|
||||
+ strcpy(dpart->name, ROOTFS_SPLIT_NAME);
|
||||
+
|
||||
+ dpart->size -= split_offset - dpart->offset;
|
||||
+ dpart->offset = split_offset;
|
||||
+
|
||||
+ if (dpart == NULL)
|
||||
+ return 1;
|
||||
+
|
||||
+ printk(KERN_INFO "mtd: partition \"%s\" created automatically, ofs=%X, len=%X \n",
|
||||
+ ROOTFS_SPLIT_NAME, dpart->offset, dpart->size);
|
||||
+
|
||||
+ ret = add_one_partition(master, dpart, index, &slave);
|
||||
+ if (ret)
|
||||
+ kfree(dpart);
|
||||
+ else if (slave)
|
||||
+ rpart->split = &slave->mtd;
|
||||
+
|
||||
+ return ret;
|
||||
+}
|
||||
+
|
||||
+static int refresh_rootfs_split(struct mtd_info *mtd)
|
||||
+{
|
||||
+ struct mtd_partition tpart;
|
||||
+ struct mtd_part *part;
|
||||
+ int index = 0;
|
||||
+ int offset, size;
|
||||
+ int ret;
|
||||
+
|
||||
+ part = PART(mtd);
|
||||
+
|
||||
+ /* check for the new squashfs offset first */
|
||||
+ ret = split_squashfs(part->master, part->offset, &offset);
|
||||
+ if (ret)
|
||||
+ return ret;
|
||||
+
|
||||
+ if ((offset > 0) && !mtd->split) {
|
||||
+ printk(KERN_INFO "%s: creating new split partition for \"%s\"\n", __func__, mtd->name);
|
||||
+ /* if we don't have a rootfs split partition, create a new one */
|
||||
+ tpart.name = mtd->name;
|
||||
+ tpart.size = mtd->size;
|
||||
+ tpart.offset = part->offset;
|
||||
+
|
||||
+ /* find the index of the last partition */
|
||||
+ if (!list_empty(&mtd_partitions))
|
||||
+ index = list_first_entry(&mtd_partitions, struct mtd_part, list)->index + 1;
|
||||
+
|
||||
+ return split_rootfs_data(part->master, &part->mtd, &tpart, index);
|
||||
+ } else if ((offset > 0) && mtd->split) {
|
||||
+ /* update the offsets of the existing partition */
|
||||
+ size = mtd->size + part->offset - offset;
|
||||
+
|
||||
+ part = PART(mtd->split);
|
||||
+ part->offset = offset;
|
||||
+ part->mtd.size = size;
|
||||
+ printk(KERN_INFO "%s: %s partition \"" ROOTFS_SPLIT_NAME "\", offset: 0x%06x (0x%06x)\n",
|
||||
+ __func__, (!strcmp(part->mtd.name, ROOTFS_SPLIT_NAME) ? "updating" : "creating"),
|
||||
+ part->offset, part->mtd.size);
|
||||
+ strcpy(part->mtd.name, ROOTFS_SPLIT_NAME);
|
||||
+ } else if ((offset <= 0) && mtd->split) {
|
||||
+ printk(KERN_INFO "%s: removing partition \"%s\"\n", __func__, mtd->split->name);
|
||||
+
|
||||
+ /* mark existing partition as removed */
|
||||
+ part = PART(mtd->split);
|
||||
+ strcpy(part->mtd.name, ROOTFS_REMOVED_NAME);
|
||||
+ part->offset = 0;
|
||||
+ part->mtd.size = 0;
|
||||
+ }
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+#endif /* CONFIG_MTD_ROOTFS_SPLIT */
|
||||
+
|
||||
/*
|
||||
* This function, given a master MTD object and a partition table, creates
|
||||
* and registers slave MTD objects which are bound to the master according to
|
||||
@@ -334,171 +646,31 @@ int add_mtd_partitions(struct mtd_info *
|
||||
int nbparts)
|
||||
{
|
||||
struct mtd_part *slave;
|
||||
- u_int32_t cur_offset = 0;
|
||||
- int i;
|
||||
+ struct mtd_partition *part;
|
||||
+ int i, j, ret = 0;
|
||||
|
||||
printk (KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name);
|
||||
|
||||
- for (i = 0; i < nbparts; i++) {
|
||||
-
|
||||
- /* allocate the partition structure */
|
||||
- slave = kzalloc (sizeof(*slave), GFP_KERNEL);
|
||||
- if (!slave) {
|
||||
- printk ("memory allocation error while creating partitions for \"%s\"\n",
|
||||
- master->name);
|
||||
- del_mtd_partitions(master);
|
||||
- return -ENOMEM;
|
||||
- }
|
||||
- list_add(&slave->list, &mtd_partitions);
|
||||
-
|
||||
- /* set up the MTD object for this partition */
|
||||
- slave->mtd.type = master->type;
|
||||
- slave->mtd.flags = master->flags & ~parts[i].mask_flags;
|
||||
- slave->mtd.size = parts[i].size;
|
||||
- slave->mtd.writesize = master->writesize;
|
||||
- slave->mtd.oobsize = master->oobsize;
|
||||
- slave->mtd.oobavail = master->oobavail;
|
||||
- slave->mtd.subpage_sft = master->subpage_sft;
|
||||
-
|
||||
- slave->mtd.name = parts[i].name;
|
||||
- slave->mtd.owner = master->owner;
|
||||
-
|
||||
- slave->mtd.read = part_read;
|
||||
- slave->mtd.write = part_write;
|
||||
-
|
||||
- if (master->panic_write)
|
||||
- slave->mtd.panic_write = part_panic_write;
|
||||
-
|
||||
- if(master->point && master->unpoint){
|
||||
- slave->mtd.point = part_point;
|
||||
- slave->mtd.unpoint = part_unpoint;
|
||||
- }
|
||||
-
|
||||
- if (master->read_oob)
|
||||
- slave->mtd.read_oob = part_read_oob;
|
||||
- if (master->write_oob)
|
||||
- slave->mtd.write_oob = part_write_oob;
|
||||
- if(master->read_user_prot_reg)
|
||||
- slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
|
||||
- if(master->read_fact_prot_reg)
|
||||
- slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
|
||||
- if(master->write_user_prot_reg)
|
||||
- slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
|
||||
- if(master->lock_user_prot_reg)
|
||||
- slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
|
||||
- if(master->get_user_prot_info)
|
||||
- slave->mtd.get_user_prot_info = part_get_user_prot_info;
|
||||
- if(master->get_fact_prot_info)
|
||||
- slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
|
||||
- if (master->sync)
|
||||
- slave->mtd.sync = part_sync;
|
||||
- if (!i && master->suspend && master->resume) {
|
||||
- slave->mtd.suspend = part_suspend;
|
||||
- slave->mtd.resume = part_resume;
|
||||
- }
|
||||
- if (master->writev)
|
||||
- slave->mtd.writev = part_writev;
|
||||
- if (master->lock)
|
||||
- slave->mtd.lock = part_lock;
|
||||
- if (master->unlock)
|
||||
- slave->mtd.unlock = part_unlock;
|
||||
- if (master->block_isbad)
|
||||
- slave->mtd.block_isbad = part_block_isbad;
|
||||
- if (master->block_markbad)
|
||||
- slave->mtd.block_markbad = part_block_markbad;
|
||||
- slave->mtd.erase = part_erase;
|
||||
- slave->master = master;
|
||||
- slave->offset = parts[i].offset;
|
||||
- slave->index = i;
|
||||
-
|
||||
- if (slave->offset == MTDPART_OFS_APPEND)
|
||||
- slave->offset = cur_offset;
|
||||
- if (slave->offset == MTDPART_OFS_NXTBLK) {
|
||||
- slave->offset = cur_offset;
|
||||
- if ((cur_offset % master->erasesize) != 0) {
|
||||
- /* Round up to next erasesize */
|
||||
- slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize;
|
||||
- printk(KERN_NOTICE "Moving partition %d: "
|
||||
- "0x%08x -> 0x%08x\n", i,
|
||||
- cur_offset, slave->offset);
|
||||
- }
|
||||
- }
|
||||
- if (slave->mtd.size == MTDPART_SIZ_FULL)
|
||||
- slave->mtd.size = master->size - slave->offset;
|
||||
- cur_offset = slave->offset + slave->mtd.size;
|
||||
-
|
||||
- printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset,
|
||||
- slave->offset + slave->mtd.size, slave->mtd.name);
|
||||
-
|
||||
- /* let's do some sanity checks */
|
||||
- if (slave->offset >= master->size) {
|
||||
- /* let's register it anyway to preserve ordering */
|
||||
- slave->offset = 0;
|
||||
- slave->mtd.size = 0;
|
||||
- printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
|
||||
- parts[i].name);
|
||||
- }
|
||||
- if (slave->offset + slave->mtd.size > master->size) {
|
||||
- slave->mtd.size = master->size - slave->offset;
|
||||
- printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
|
||||
- parts[i].name, master->name, slave->mtd.size);
|
||||
- }
|
||||
- if (master->numeraseregions>1) {
|
||||
- /* Deal with variable erase size stuff */
|
||||
- int i;
|
||||
- struct mtd_erase_region_info *regions = master->eraseregions;
|
||||
-
|
||||
- /* Find the first erase regions which is part of this partition. */
|
||||
- for (i=0; i < master->numeraseregions && slave->offset >= regions[i].offset; i++)
|
||||
- ;
|
||||
-
|
||||
- for (i--; i < master->numeraseregions && slave->offset + slave->mtd.size > regions[i].offset; i++) {
|
||||
- if (slave->mtd.erasesize < regions[i].erasesize) {
|
||||
- slave->mtd.erasesize = regions[i].erasesize;
|
||||
- }
|
||||
+ for (i = 0, j = 0; i < nbparts; i++) {
|
||||
+ part = (struct mtd_partition *) &parts[i];
|
||||
+ ret = add_one_partition(master, part, j, &slave);
|
||||
+ if (ret)
|
||||
+ return ret;
|
||||
+ j++;
|
||||
+
|
||||
+ if (strcmp(part->name, "rootfs") == 0 && slave->registered) {
|
||||
+#ifdef CONFIG_MTD_ROOTFS_ROOT_DEV
|
||||
+ if (ROOT_DEV == 0) {
|
||||
+ printk(KERN_NOTICE "mtd: partition \"rootfs\" "
|
||||
+ "set to be root filesystem\n");
|
||||
+ ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, slave->mtd.index);
|
||||
}
|
||||
- } else {
|
||||
- /* Single erase size */
|
||||
- slave->mtd.erasesize = master->erasesize;
|
||||
- }
|
||||
-
|
||||
- if ((slave->mtd.flags & MTD_WRITEABLE) &&
|
||||
- (slave->offset % slave->mtd.erasesize)) {
|
||||
- /* Doesn't start on a boundary of major erase size */
|
||||
- /* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
|
||||
- slave->mtd.flags &= ~MTD_WRITEABLE;
|
||||
- printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
|
||||
- parts[i].name);
|
||||
- }
|
||||
- if ((slave->mtd.flags & MTD_WRITEABLE) &&
|
||||
- (slave->mtd.size % slave->mtd.erasesize)) {
|
||||
- slave->mtd.flags &= ~MTD_WRITEABLE;
|
||||
- printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
|
||||
- parts[i].name);
|
||||
- }
|
||||
-
|
||||
- slave->mtd.ecclayout = master->ecclayout;
|
||||
- if (master->block_isbad) {
|
||||
- uint32_t offs = 0;
|
||||
-
|
||||
- while(offs < slave->mtd.size) {
|
||||
- if (master->block_isbad(master,
|
||||
- offs + slave->offset))
|
||||
- slave->mtd.ecc_stats.badblocks++;
|
||||
- offs += slave->mtd.erasesize;
|
||||
- }
|
||||
- }
|
||||
-
|
||||
- if(parts[i].mtdp)
|
||||
- { /* store the object pointer (caller may or may not register it */
|
||||
- *parts[i].mtdp = &slave->mtd;
|
||||
- slave->registered = 0;
|
||||
- }
|
||||
- else
|
||||
- {
|
||||
- /* register our partition */
|
||||
- add_mtd_device(&slave->mtd);
|
||||
- slave->registered = 1;
|
||||
+#endif
|
||||
+#ifdef CONFIG_MTD_ROOTFS_SPLIT
|
||||
+ ret = split_rootfs_data(master, &slave->mtd, part, j);
|
||||
+ if (ret == 0)
|
||||
+ j++;
|
||||
+#endif
|
||||
}
|
||||
}
|
||||
|
||||
@@ -574,6 +746,32 @@ int parse_mtd_partitions(struct mtd_info
|
||||
return ret;
|
||||
}
|
||||
|
||||
+int refresh_mtd_partitions(struct mtd_info *mtd)
|
||||
+{
|
||||
+ int ret = 0;
|
||||
+
|
||||
+ if (IS_PART(mtd)) {
|
||||
+ struct mtd_part *part;
|
||||
+ struct mtd_info *master;
|
||||
+
|
||||
+ part = PART(mtd);
|
||||
+ master = part->master;
|
||||
+ if (master->refresh_device)
|
||||
+ ret = master->refresh_device(master);
|
||||
+ }
|
||||
+
|
||||
+ if (!ret && mtd->refresh_device)
|
||||
+ ret = mtd->refresh_device(mtd);
|
||||
+
|
||||
+#ifdef CONFIG_MTD_ROOTFS_SPLIT
|
||||
+ if (!ret && IS_PART(mtd) && !strcmp(mtd->name, "rootfs"))
|
||||
+ refresh_rootfs_split(mtd);
|
||||
+#endif
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
EXPORT_SYMBOL_GPL(parse_mtd_partitions);
|
||||
+EXPORT_SYMBOL_GPL(refresh_mtd_partitions);
|
||||
EXPORT_SYMBOL_GPL(register_mtd_parser);
|
||||
EXPORT_SYMBOL_GPL(deregister_mtd_parser);
|
||||
--- a/drivers/mtd/devices/block2mtd.c
|
||||
+++ b/drivers/mtd/devices/block2mtd.c
|
||||
@@ -34,6 +34,8 @@ struct block2mtd_dev {
|
||||
struct block_device *blkdev;
|
||||
struct mtd_info mtd;
|
||||
struct mutex write_mutex;
|
||||
+ rwlock_t bdev_mutex;
|
||||
+ char devname[0];
|
||||
};
|
||||
|
||||
|
||||
@@ -86,6 +88,12 @@ static int block2mtd_erase(struct mtd_in
|
||||
size_t len = instr->len;
|
||||
int err;
|
||||
|
||||
+ read_lock(&dev->bdev_mutex);
|
||||
+ if (!dev->blkdev) {
|
||||
+ err = -EINVAL;
|
||||
+ goto done;
|
||||
+ }
|
||||
+
|
||||
instr->state = MTD_ERASING;
|
||||
mutex_lock(&dev->write_mutex);
|
||||
err = _block2mtd_erase(dev, from, len);
|
||||
@@ -98,6 +106,10 @@ static int block2mtd_erase(struct mtd_in
|
||||
|
||||
instr->state = MTD_ERASE_DONE;
|
||||
mtd_erase_callback(instr);
|
||||
+
|
||||
+done:
|
||||
+ read_unlock(&dev->bdev_mutex);
|
||||
+
|
||||
return err;
|
||||
}
|
||||
|
||||
@@ -109,10 +121,14 @@ static int block2mtd_read(struct mtd_inf
|
||||
struct page *page;
|
||||
int index = from >> PAGE_SHIFT;
|
||||
int offset = from & (PAGE_SIZE-1);
|
||||
- int cpylen;
|
||||
+ int cpylen, err = 0;
|
||||
+
|
||||
+ read_lock(&dev->bdev_mutex);
|
||||
+ if (!dev->blkdev || (from > mtd->size)) {
|
||||
+ err = -EINVAL;
|
||||
+ goto done;
|
||||
+ }
|
||||
|
||||
- if (from > mtd->size)
|
||||
- return -EINVAL;
|
||||
if (from + len > mtd->size)
|
||||
len = mtd->size - from;
|
||||
|
||||
@@ -127,10 +143,14 @@ static int block2mtd_read(struct mtd_inf
|
||||
len = len - cpylen;
|
||||
|
||||
page = page_read(dev->blkdev->bd_inode->i_mapping, index);
|
||||
- if (!page)
|
||||
- return -ENOMEM;
|
||||
- if (IS_ERR(page))
|
||||
- return PTR_ERR(page);
|
||||
+ if (!page) {
|
||||
+ err = -ENOMEM;
|
||||
+ goto done;
|
||||
+ }
|
||||
+ if (IS_ERR(page)) {
|
||||
+ err = PTR_ERR(page);
|
||||
+ goto done;
|
||||
+ }
|
||||
|
||||
memcpy(buf, page_address(page) + offset, cpylen);
|
||||
page_cache_release(page);
|
||||
@@ -141,7 +161,10 @@ static int block2mtd_read(struct mtd_inf
|
||||
offset = 0;
|
||||
index++;
|
||||
}
|
||||
- return 0;
|
||||
+
|
||||
+done:
|
||||
+ read_unlock(&dev->bdev_mutex);
|
||||
+ return err;
|
||||
}
|
||||
|
||||
|
||||
@@ -193,12 +216,22 @@ static int block2mtd_write(struct mtd_in
|
||||
size_t *retlen, const u_char *buf)
|
||||
{
|
||||
struct block2mtd_dev *dev = mtd->priv;
|
||||
- int err;
|
||||
+ int err = 0;
|
||||
+
|
||||
+ read_lock(&dev->bdev_mutex);
|
||||
+ if (!dev->blkdev) {
|
||||
+ err = -EINVAL;
|
||||
+ goto done;
|
||||
+ }
|
||||
|
||||
if (!len)
|
||||
- return 0;
|
||||
- if (to >= mtd->size)
|
||||
- return -ENOSPC;
|
||||
+ goto done;
|
||||
+
|
||||
+ if (to >= mtd->size) {
|
||||
+ err = -ENOSPC;
|
||||
+ goto done;
|
||||
+ }
|
||||
+
|
||||
if (to + len > mtd->size)
|
||||
len = mtd->size - to;
|
||||
|
||||
@@ -207,6 +240,9 @@ static int block2mtd_write(struct mtd_in
|
||||
mutex_unlock(&dev->write_mutex);
|
||||
if (err > 0)
|
||||
err = 0;
|
||||
+
|
||||
+done:
|
||||
+ read_unlock(&dev->bdev_mutex);
|
||||
return err;
|
||||
}
|
||||
|
||||
@@ -215,51 +251,29 @@ static int block2mtd_write(struct mtd_in
|
||||
static void block2mtd_sync(struct mtd_info *mtd)
|
||||
{
|
||||
struct block2mtd_dev *dev = mtd->priv;
|
||||
- sync_blockdev(dev->blkdev);
|
||||
- return;
|
||||
-}
|
||||
-
|
||||
-
|
||||
-static void block2mtd_free_device(struct block2mtd_dev *dev)
|
||||
-{
|
||||
- if (!dev)
|
||||
- return;
|
||||
-
|
||||
- kfree(dev->mtd.name);
|
||||
|
||||
- if (dev->blkdev) {
|
||||
- invalidate_mapping_pages(dev->blkdev->bd_inode->i_mapping,
|
||||
- 0, -1);
|
||||
- close_bdev_excl(dev->blkdev);
|
||||
- }
|
||||
+ read_lock(&dev->bdev_mutex);
|
||||
+ if (dev->blkdev)
|
||||
+ sync_blockdev(dev->blkdev);
|
||||
+ read_unlock(&dev->bdev_mutex);
|
||||
|
||||
- kfree(dev);
|
||||
+ return;
|
||||
}
|
||||
|
||||
|
||||
-/* FIXME: ensure that mtd->size % erase_size == 0 */
|
||||
-static struct block2mtd_dev *add_device(char *devname, int erase_size, char *mtdname)
|
||||
+static int _open_bdev(struct block2mtd_dev *dev)
|
||||
{
|
||||
struct block_device *bdev;
|
||||
- struct block2mtd_dev *dev;
|
||||
- struct mtd_partition *part;
|
||||
-
|
||||
- if (!devname)
|
||||
- return NULL;
|
||||
-
|
||||
- dev = kzalloc(sizeof(struct block2mtd_dev), GFP_KERNEL);
|
||||
- if (!dev)
|
||||
- return NULL;
|
||||
|
||||
/* Get a handle on the device */
|
||||
- bdev = open_bdev_excl(devname, O_RDWR, NULL);
|
||||
+ bdev = open_bdev_excl(dev->devname, O_RDWR, NULL);
|
||||
#ifndef MODULE
|
||||
if (IS_ERR(bdev)) {
|
||||
|
||||
/* We might not have rootfs mounted at this point. Try
|
||||
to resolve the device name by other means. */
|
||||
|
||||
- dev_t devt = name_to_dev_t(devname);
|
||||
+ dev_t devt = name_to_dev_t(dev->devname);
|
||||
if (devt) {
|
||||
bdev = open_by_devnum(devt, FMODE_WRITE | FMODE_READ);
|
||||
}
|
||||
@@ -267,17 +281,96 @@ static struct block2mtd_dev *add_device(
|
||||
#endif
|
||||
|
||||
if (IS_ERR(bdev)) {
|
||||
- ERROR("error: cannot open device %s", devname);
|
||||
- goto devinit_err;
|
||||
+ ERROR("error: cannot open device %s", dev->devname);
|
||||
+ return 1;
|
||||
}
|
||||
dev->blkdev = bdev;
|
||||
|
||||
if (MAJOR(bdev->bd_dev) == MTD_BLOCK_MAJOR) {
|
||||
ERROR("attempting to use an MTD device as a block device");
|
||||
- goto devinit_err;
|
||||
+ return 1;
|
||||
}
|
||||
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static void _close_bdev(struct block2mtd_dev *dev)
|
||||
+{
|
||||
+ struct block_device *bdev;
|
||||
+
|
||||
+ if (!dev->blkdev)
|
||||
+ return;
|
||||
+
|
||||
+ bdev = dev->blkdev;
|
||||
+ invalidate_mapping_pages(dev->blkdev->bd_inode->i_mapping, 0, -1);
|
||||
+ close_bdev_excl(dev->blkdev);
|
||||
+ dev->blkdev = NULL;
|
||||
+}
|
||||
+
|
||||
+static void block2mtd_free_device(struct block2mtd_dev *dev)
|
||||
+{
|
||||
+ if (!dev)
|
||||
+ return;
|
||||
+
|
||||
+ kfree(dev->mtd.name);
|
||||
+ _close_bdev(dev);
|
||||
+ kfree(dev);
|
||||
+}
|
||||
+
|
||||
+
|
||||
+static int block2mtd_refresh(struct mtd_info *mtd)
|
||||
+{
|
||||
+ struct block2mtd_dev *dev = mtd->priv;
|
||||
+ struct block_device *bdev;
|
||||
+ dev_t devt;
|
||||
+ int err = 0;
|
||||
+
|
||||
+ /* no other mtd function can run at this point */
|
||||
+ write_lock(&dev->bdev_mutex);
|
||||
+
|
||||
+ /* get the device number for the whole disk */
|
||||
+ devt = MKDEV(MAJOR(dev->blkdev->bd_dev), 0);
|
||||
+
|
||||
+ /* close the old block device */
|
||||
+ _close_bdev(dev);
|
||||
+
|
||||
+ /* open the whole disk, issue a partition rescan, then */
|
||||
+ bdev = open_by_devnum(devt, FMODE_WRITE | FMODE_READ);
|
||||
+ if (!bdev || !bdev->bd_disk)
|
||||
+ err = -EINVAL;
|
||||
+ else {
|
||||
+ err = rescan_partitions(bdev->bd_disk, bdev);
|
||||
+ }
|
||||
+ if (bdev)
|
||||
+ close_bdev_excl(bdev);
|
||||
+
|
||||
+ /* try to open the partition block device again */
|
||||
+ _open_bdev(dev);
|
||||
+ write_unlock(&dev->bdev_mutex);
|
||||
+
|
||||
+ return err;
|
||||
+}
|
||||
+
|
||||
+/* FIXME: ensure that mtd->size % erase_size == 0 */
|
||||
+static struct block2mtd_dev *add_device(char *devname, int erase_size, char *mtdname)
|
||||
+{
|
||||
+ struct block2mtd_dev *dev;
|
||||
+ struct mtd_partition *part;
|
||||
+
|
||||
+ if (!devname)
|
||||
+ return NULL;
|
||||
+
|
||||
+ dev = kzalloc(sizeof(struct block2mtd_dev) + strlen(devname) + 1, GFP_KERNEL);
|
||||
+ if (!dev)
|
||||
+ return NULL;
|
||||
+
|
||||
+ strcpy(dev->devname, devname);
|
||||
+
|
||||
+ if (_open_bdev(dev))
|
||||
+ goto devinit_err;
|
||||
+
|
||||
mutex_init(&dev->write_mutex);
|
||||
+ rwlock_init(&dev->bdev_mutex);
|
||||
|
||||
/* Setup the MTD structure */
|
||||
/* make the name contain the block device in */
|
||||
@@ -304,6 +397,7 @@ static struct block2mtd_dev *add_device(
|
||||
dev->mtd.read = block2mtd_read;
|
||||
dev->mtd.priv = dev;
|
||||
dev->mtd.owner = THIS_MODULE;
|
||||
+ dev->mtd.refresh_device = block2mtd_refresh;
|
||||
|
||||
part = kzalloc(sizeof(struct mtd_partition), GFP_KERNEL);
|
||||
part->name = dev->mtd.name;
|
||||
--- a/drivers/mtd/mtdchar.c
|
||||
+++ b/drivers/mtd/mtdchar.c
|
||||
@@ -17,6 +17,7 @@
|
||||
|
||||
#include <linux/mtd/mtd.h>
|
||||
#include <linux/mtd/compatmac.h>
|
||||
+#include <linux/mtd/partitions.h>
|
||||
|
||||
#include <asm/uaccess.h>
|
||||
|
||||
@@ -756,6 +757,13 @@ static int mtd_ioctl(struct inode *inode
|
||||
file->f_pos = 0;
|
||||
break;
|
||||
}
|
||||
+#ifdef CONFIG_MTD_PARTITIONS
|
||||
+ case MTDREFRESH:
|
||||
+ {
|
||||
+ ret = refresh_mtd_partitions(mtd);
|
||||
+ break;
|
||||
+ }
|
||||
+#endif
|
||||
|
||||
default:
|
||||
ret = -ENOTTY;
|
||||
--- a/include/linux/mtd/mtd.h
|
||||
+++ b/include/linux/mtd/mtd.h
|
||||
@@ -98,6 +98,7 @@ struct mtd_oob_ops {
|
||||
uint8_t *oobbuf;
|
||||
};
|
||||
|
||||
+struct mtd_info;
|
||||
struct mtd_info {
|
||||
u_char type;
|
||||
u_int32_t flags;
|
||||
@@ -211,6 +212,9 @@ struct mtd_info {
|
||||
struct module *owner;
|
||||
int usecount;
|
||||
|
||||
+ int (*refresh_device)(struct mtd_info *mtd);
|
||||
+ struct mtd_info *split;
|
||||
+
|
||||
/* If the driver is something smart, like UBI, it may need to maintain
|
||||
* its own reference counting. The below functions are only for driver.
|
||||
* The driver may register its callbacks. These callbacks are not
|
||||
--- a/include/linux/mtd/partitions.h
|
||||
+++ b/include/linux/mtd/partitions.h
|
||||
@@ -36,6 +36,7 @@
|
||||
* erasesize aligned (e.g. use MTDPART_OFS_NEXTBLK).
|
||||
*/
|
||||
|
||||
+struct mtd_partition;
|
||||
struct mtd_partition {
|
||||
char *name; /* identifier string */
|
||||
u_int32_t size; /* partition size */
|
||||
@@ -43,6 +44,7 @@ struct mtd_partition {
|
||||
u_int32_t mask_flags; /* master MTD flags to mask out for this partition */
|
||||
struct nand_ecclayout *ecclayout; /* out of band layout for this partition (NAND only)*/
|
||||
struct mtd_info **mtdp; /* pointer to store the MTD object */
|
||||
+ int (*refresh_partition)(struct mtd_info *);
|
||||
};
|
||||
|
||||
#define MTDPART_OFS_NXTBLK (-2)
|
||||
@@ -52,6 +54,7 @@ struct mtd_partition {
|
||||
|
||||
int add_mtd_partitions(struct mtd_info *, const struct mtd_partition *, int);
|
||||
int del_mtd_partitions(struct mtd_info *);
|
||||
+int refresh_mtd_partitions(struct mtd_info *);
|
||||
|
||||
/*
|
||||
* Functions dealing with the various ways of partitioning the space
|
||||
--- a/include/mtd/mtd-abi.h
|
||||
+++ b/include/mtd/mtd-abi.h
|
||||
@@ -95,6 +95,7 @@ struct otp_info {
|
||||
#define ECCGETLAYOUT _IOR('M', 17, struct nand_ecclayout)
|
||||
#define ECCGETSTATS _IOR('M', 18, struct mtd_ecc_stats)
|
||||
#define MTDFILEMODE _IO('M', 19)
|
||||
+#define MTDREFRESH _IO('M', 23)
|
||||
|
||||
/*
|
||||
* Obsolete legacy interface. Keep it in order not to break userspace
|
|
@ -1,30 +0,0 @@
|
|||
--- a/drivers/mtd/redboot.c
|
||||
+++ b/drivers/mtd/redboot.c
|
||||
@@ -251,14 +251,21 @@ static int parse_redboot_partitions(stru
|
||||
#endif
|
||||
names += strlen(names)+1;
|
||||
|
||||
-#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
|
||||
if(fl->next && fl->img->flash_base + fl->img->size + master->erasesize <= fl->next->img->flash_base) {
|
||||
- i++;
|
||||
- parts[i].offset = parts[i-1].size + parts[i-1].offset;
|
||||
- parts[i].size = fl->next->img->flash_base - parts[i].offset;
|
||||
- parts[i].name = nullname;
|
||||
- }
|
||||
+ if (!strcmp(parts[i].name, "rootfs")) {
|
||||
+ parts[i].size = fl->next->img->flash_base;
|
||||
+ parts[i].size &= ~(master->erasesize - 1);
|
||||
+ parts[i].size -= parts[i].offset;
|
||||
+#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
|
||||
+ nrparts--;
|
||||
+ } else {
|
||||
+ i++;
|
||||
+ parts[i].offset = parts[i-1].size + parts[i-1].offset;
|
||||
+ parts[i].size = fl->next->img->flash_base - parts[i].offset;
|
||||
+ parts[i].name = nullname;
|
||||
#endif
|
||||
+ }
|
||||
+ }
|
||||
tmp_fl = fl;
|
||||
fl = fl->next;
|
||||
kfree(tmp_fl);
|
|
@ -1,32 +0,0 @@
|
|||
--- a/include/linux/mtd/nand.h
|
||||
+++ b/include/linux/mtd/nand.h
|
||||
@@ -573,6 +573,7 @@ struct platform_nand_chip {
|
||||
int chip_delay;
|
||||
unsigned int options;
|
||||
const char **part_probe_types;
|
||||
+ int (*chip_fixup)(struct mtd_info *mtd);
|
||||
void *priv;
|
||||
};
|
||||
|
||||
--- a/drivers/mtd/nand/plat_nand.c
|
||||
+++ b/drivers/mtd/nand/plat_nand.c
|
||||
@@ -70,7 +70,18 @@ static int __init plat_nand_probe(struct
|
||||
platform_set_drvdata(pdev, data);
|
||||
|
||||
/* Scan to find existance of the device */
|
||||
- if (nand_scan(&data->mtd, 1)) {
|
||||
+ if (nand_scan_ident(&data->mtd, 1)) {
|
||||
+ res = -ENXIO;
|
||||
+ goto out;
|
||||
+ }
|
||||
+
|
||||
+ if (pdata->chip.chip_fixup) {
|
||||
+ res = pdata->chip.chip_fixup(&data->mtd);
|
||||
+ if (res)
|
||||
+ goto out;
|
||||
+ }
|
||||
+
|
||||
+ if (nand_scan_tail(&data->mtd)) {
|
||||
res = -ENXIO;
|
||||
goto out;
|
||||
}
|
File diff suppressed because it is too large
Load diff
|
@ -1,110 +0,0 @@
|
|||
--- a/include/linux/netfilter/xt_layer7.h
|
||||
+++ b/include/linux/netfilter/xt_layer7.h
|
||||
@@ -8,6 +8,7 @@ struct xt_layer7_info {
|
||||
char protocol[MAX_PROTOCOL_LEN];
|
||||
char pattern[MAX_PATTERN_LEN];
|
||||
u_int8_t invert;
|
||||
+ u_int8_t pkt;
|
||||
};
|
||||
|
||||
#endif /* _XT_LAYER7_H */
|
||||
--- a/net/netfilter/xt_layer7.c
|
||||
+++ b/net/netfilter/xt_layer7.c
|
||||
@@ -314,34 +314,36 @@ static int match_no_append(struct nf_con
|
||||
}
|
||||
|
||||
/* add the new app data to the conntrack. Return number of bytes added. */
|
||||
-static int add_data(struct nf_conn * master_conntrack,
|
||||
- char * app_data, int appdatalen)
|
||||
+static int add_datastr(char *target, int offset, char *app_data, int len)
|
||||
{
|
||||
int length = 0, i;
|
||||
- int oldlength = master_conntrack->layer7.app_data_len;
|
||||
-
|
||||
- /* This is a fix for a race condition by Deti Fliegl. However, I'm not
|
||||
- clear on whether the race condition exists or whether this really
|
||||
- fixes it. I might just be being dense... Anyway, if it's not really
|
||||
- a fix, all it does is waste a very small amount of time. */
|
||||
- if(!master_conntrack->layer7.app_data) return 0;
|
||||
+
|
||||
+ if (!target) return 0;
|
||||
|
||||
/* Strip nulls. Make everything lower case (our regex lib doesn't
|
||||
do case insensitivity). Add it to the end of the current data. */
|
||||
- for(i = 0; i < maxdatalen-oldlength-1 &&
|
||||
- i < appdatalen; i++) {
|
||||
+ for(i = 0; i < maxdatalen-offset-1 && i < len; i++) {
|
||||
if(app_data[i] != '\0') {
|
||||
/* the kernel version of tolower mungs 'upper ascii' */
|
||||
- master_conntrack->layer7.app_data[length+oldlength] =
|
||||
+ target[length+offset] =
|
||||
isascii(app_data[i])?
|
||||
tolower(app_data[i]) : app_data[i];
|
||||
length++;
|
||||
}
|
||||
}
|
||||
+ target[length+offset] = '\0';
|
||||
+
|
||||
+ return length;
|
||||
+}
|
||||
|
||||
- master_conntrack->layer7.app_data[length+oldlength] = '\0';
|
||||
- master_conntrack->layer7.app_data_len = length + oldlength;
|
||||
+/* add the new app data to the conntrack. Return number of bytes added. */
|
||||
+static int add_data(struct nf_conn * master_conntrack,
|
||||
+ char * app_data, int appdatalen)
|
||||
+{
|
||||
+ int length;
|
||||
|
||||
+ length = add_datastr(master_conntrack->layer7.app_data, master_conntrack->layer7.app_data_len, app_data, appdatalen);
|
||||
+ master_conntrack->layer7.app_data_len += length;
|
||||
return length;
|
||||
}
|
||||
|
||||
@@ -438,7 +440,7 @@ match(const struct sk_buff *skbin,
|
||||
|
||||
enum ip_conntrack_info master_ctinfo, ctinfo;
|
||||
struct nf_conn *master_conntrack, *conntrack;
|
||||
- unsigned char * app_data;
|
||||
+ unsigned char *app_data, *tmp_data;
|
||||
unsigned int pattern_result, appdatalen;
|
||||
regexp * comppattern;
|
||||
|
||||
@@ -466,9 +468,8 @@ match(const struct sk_buff *skbin,
|
||||
master_conntrack = master_ct(master_conntrack);
|
||||
|
||||
/* if we've classified it or seen too many packets */
|
||||
- if(total_acct_packets(master_conntrack) > num_packets ||
|
||||
- master_conntrack->layer7.app_proto) {
|
||||
-
|
||||
+ if(!info->pkt && (total_acct_packets(master_conntrack) > num_packets ||
|
||||
+ master_conntrack->layer7.app_proto)) {
|
||||
pattern_result = match_no_append(conntrack, master_conntrack,
|
||||
ctinfo, master_ctinfo, info);
|
||||
|
||||
@@ -500,6 +501,25 @@ match(const struct sk_buff *skbin,
|
||||
/* the return value gets checked later, when we're ready to use it */
|
||||
comppattern = compile_and_cache(info->pattern, info->protocol);
|
||||
|
||||
+ if (info->pkt) {
|
||||
+ tmp_data = kmalloc(maxdatalen, GFP_ATOMIC);
|
||||
+ if(!tmp_data){
|
||||
+ if (net_ratelimit())
|
||||
+ printk(KERN_ERR "layer7: out of memory in match, bailing.\n");
|
||||
+ return info->invert;
|
||||
+ }
|
||||
+
|
||||
+ tmp_data[0] = '\0';
|
||||
+ add_datastr(tmp_data, 0, app_data, appdatalen);
|
||||
+ pattern_result = ((comppattern && regexec(comppattern, tmp_data)) ? 1 : 0);
|
||||
+
|
||||
+ kfree(tmp_data);
|
||||
+ tmp_data = NULL;
|
||||
+ spin_unlock_bh(&l7_lock);
|
||||
+
|
||||
+ return (pattern_result ^ info->invert);
|
||||
+ }
|
||||
+
|
||||
/* On the first packet of a connection, allocate space for app data */
|
||||
if(total_acct_packets(master_conntrack) == 1 && !skb->cb[0] &&
|
||||
!master_conntrack->layer7.app_data){
|
|
@ -1,80 +0,0 @@
|
|||
commit c8942f1f0a7e2160ebf2e51ba89e50ee5895a1e7
|
||||
Author: Patrick McHardy <kaber@trash.net>
|
||||
Date: Wed May 21 14:08:38 2008 -0700
|
||||
|
||||
netfilter: Move linux/types.h inclusions outside of #ifdef __KERNEL__
|
||||
|
||||
Greg Steuck <greg@nest.cx> points out that some of the netfilter
|
||||
headers can't be used in userspace without including linux/types.h
|
||||
first. The headers include their own linux/types.h include statements,
|
||||
these are stripped by make headers-install because they are inside
|
||||
#ifdef __KERNEL__ however. Move them out to fix this.
|
||||
|
||||
Reported and Tested by Greg Steuck.
|
||||
|
||||
Signed-off-by: Patrick McHardy <kaber@trash.net>
|
||||
Signed-off-by: David S. Miller <davem@davemloft.net>
|
||||
|
||||
--- a/include/linux/netfilter.h
|
||||
+++ b/include/linux/netfilter.h
|
||||
@@ -3,7 +3,6 @@
|
||||
|
||||
#ifdef __KERNEL__
|
||||
#include <linux/init.h>
|
||||
-#include <linux/types.h>
|
||||
#include <linux/skbuff.h>
|
||||
#include <linux/net.h>
|
||||
#include <linux/if.h>
|
||||
@@ -12,6 +11,7 @@
|
||||
#include <linux/wait.h>
|
||||
#include <linux/list.h>
|
||||
#endif
|
||||
+#include <linux/types.h>
|
||||
#include <linux/compiler.h>
|
||||
|
||||
/* Responses from hook functions. */
|
||||
--- a/include/linux/netfilter_arp/arp_tables.h
|
||||
+++ b/include/linux/netfilter_arp/arp_tables.h
|
||||
@@ -11,11 +11,11 @@
|
||||
|
||||
#ifdef __KERNEL__
|
||||
#include <linux/if.h>
|
||||
-#include <linux/types.h>
|
||||
#include <linux/in.h>
|
||||
#include <linux/if_arp.h>
|
||||
#include <linux/skbuff.h>
|
||||
#endif
|
||||
+#include <linux/types.h>
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/netfilter_arp.h>
|
||||
|
||||
--- a/include/linux/netfilter_ipv4/ip_tables.h
|
||||
+++ b/include/linux/netfilter_ipv4/ip_tables.h
|
||||
@@ -17,11 +17,11 @@
|
||||
|
||||
#ifdef __KERNEL__
|
||||
#include <linux/if.h>
|
||||
-#include <linux/types.h>
|
||||
#include <linux/in.h>
|
||||
#include <linux/ip.h>
|
||||
#include <linux/skbuff.h>
|
||||
#endif
|
||||
+#include <linux/types.h>
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/netfilter_ipv4.h>
|
||||
|
||||
--- a/include/linux/netfilter_ipv6/ip6_tables.h
|
||||
+++ b/include/linux/netfilter_ipv6/ip6_tables.h
|
||||
@@ -17,11 +17,11 @@
|
||||
|
||||
#ifdef __KERNEL__
|
||||
#include <linux/if.h>
|
||||
-#include <linux/types.h>
|
||||
#include <linux/in6.h>
|
||||
#include <linux/ipv6.h>
|
||||
#include <linux/skbuff.h>
|
||||
#endif
|
||||
+#include <linux/types.h>
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/netfilter_ipv6.h>
|
||||
|
|
@ -1,914 +0,0 @@
|
|||
--- /dev/null
|
||||
+++ b/drivers/net/imq.c
|
||||
@@ -0,0 +1,474 @@
|
||||
+/*
|
||||
+ * Pseudo-driver for the intermediate queue device.
|
||||
+ *
|
||||
+ * 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.
|
||||
+ *
|
||||
+ * Authors: Patrick McHardy, <kaber@trash.net>
|
||||
+ *
|
||||
+ * The first version was written by Martin Devera, <devik@cdi.cz>
|
||||
+ *
|
||||
+ * Credits: Jan Rafaj <imq2t@cedric.vabo.cz>
|
||||
+ * - Update patch to 2.4.21
|
||||
+ * Sebastian Strollo <sstrollo@nortelnetworks.com>
|
||||
+ * - Fix "Dead-loop on netdevice imq"-issue
|
||||
+ * Marcel Sebek <sebek64@post.cz>
|
||||
+ * - Update to 2.6.2-rc1
|
||||
+ *
|
||||
+ * After some time of inactivity there is a group taking care
|
||||
+ * of IMQ again: http://www.linuximq.net
|
||||
+ *
|
||||
+ *
|
||||
+ * 2004/06/30 - New version of IMQ patch to kernels <=2.6.7
|
||||
+ * including the following changes:
|
||||
+ *
|
||||
+ * - Correction of ipv6 support "+"s issue (Hasso Tepper)
|
||||
+ * - Correction of imq_init_devs() issue that resulted in
|
||||
+ * kernel OOPS unloading IMQ as module (Norbert Buchmuller)
|
||||
+ * - Addition of functionality to choose number of IMQ devices
|
||||
+ * during kernel config (Andre Correa)
|
||||
+ * - Addition of functionality to choose how IMQ hooks on
|
||||
+ * PRE and POSTROUTING (after or before NAT) (Andre Correa)
|
||||
+ * - Cosmetic corrections (Norbert Buchmuller) (Andre Correa)
|
||||
+ *
|
||||
+ *
|
||||
+ * 2005/12/16 - IMQ versions between 2.6.7 and 2.6.13 were
|
||||
+ * released with almost no problems. 2.6.14-x was released
|
||||
+ * with some important changes: nfcache was removed; After
|
||||
+ * some weeks of trouble we figured out that some IMQ fields
|
||||
+ * in skb were missing in skbuff.c - skb_clone and copy_skb_header.
|
||||
+ * These functions are correctly patched by this new patch version.
|
||||
+ *
|
||||
+ * Thanks for all who helped to figure out all the problems with
|
||||
+ * 2.6.14.x: Patrick McHardy, Rune Kock, VeNoMouS, Max CtRiX,
|
||||
+ * Kevin Shanahan, Richard Lucassen, Valery Dachev (hopefully
|
||||
+ * I didn't forget anybody). I apologize again for my lack of time.
|
||||
+ *
|
||||
+ *
|
||||
+ * 2008/06/17 - 2.6.25 - Changed imq.c to use qdisc_run() instead
|
||||
+ * of qdisc_restart() and moved qdisc_run() to tasklet to avoid
|
||||
+ * recursive locking. New initialization routines to fix 'rmmod' not
|
||||
+ * working anymore. Used code from ifb.c. (Jussi Kivilinna)
|
||||
+ *
|
||||
+ * Also, many thanks to pablo Sebastian Greco for making the initial
|
||||
+ * patch and to those who helped the testing.
|
||||
+ *
|
||||
+ * More info at: http://www.linuximq.net/ (Andre Correa)
|
||||
+ */
|
||||
+
|
||||
+#include <linux/module.h>
|
||||
+#include <linux/kernel.h>
|
||||
+#include <linux/moduleparam.h>
|
||||
+#include <linux/skbuff.h>
|
||||
+#include <linux/netdevice.h>
|
||||
+#include <linux/rtnetlink.h>
|
||||
+#include <linux/if_arp.h>
|
||||
+#include <linux/netfilter.h>
|
||||
+#include <linux/netfilter_ipv4.h>
|
||||
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
|
||||
+ #include <linux/netfilter_ipv6.h>
|
||||
+#endif
|
||||
+#include <linux/imq.h>
|
||||
+#include <net/pkt_sched.h>
|
||||
+#include <net/netfilter/nf_queue.h>
|
||||
+
|
||||
+struct imq_private {
|
||||
+ struct tasklet_struct tasklet;
|
||||
+ unsigned long tasklet_pending;
|
||||
+};
|
||||
+
|
||||
+static nf_hookfn imq_nf_hook;
|
||||
+
|
||||
+static struct nf_hook_ops imq_ingress_ipv4 = {
|
||||
+ .hook = imq_nf_hook,
|
||||
+ .owner = THIS_MODULE,
|
||||
+ .pf = PF_INET,
|
||||
+ .hooknum = NF_INET_PRE_ROUTING,
|
||||
+#if defined(CONFIG_IMQ_BEHAVIOR_BA) || defined(CONFIG_IMQ_BEHAVIOR_BB)
|
||||
+ .priority = NF_IP_PRI_MANGLE + 1
|
||||
+#else
|
||||
+ .priority = NF_IP_PRI_NAT_DST + 1
|
||||
+#endif
|
||||
+};
|
||||
+
|
||||
+static struct nf_hook_ops imq_egress_ipv4 = {
|
||||
+ .hook = imq_nf_hook,
|
||||
+ .owner = THIS_MODULE,
|
||||
+ .pf = PF_INET,
|
||||
+ .hooknum = NF_INET_POST_ROUTING,
|
||||
+#if defined(CONFIG_IMQ_BEHAVIOR_AA) || defined(CONFIG_IMQ_BEHAVIOR_BA)
|
||||
+ .priority = NF_IP_PRI_LAST
|
||||
+#else
|
||||
+ .priority = NF_IP_PRI_NAT_SRC - 1
|
||||
+#endif
|
||||
+};
|
||||
+
|
||||
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
|
||||
+static struct nf_hook_ops imq_ingress_ipv6 = {
|
||||
+ .hook = imq_nf_hook,
|
||||
+ .owner = THIS_MODULE,
|
||||
+ .pf = PF_INET6,
|
||||
+ .hooknum = NF_INET_PRE_ROUTING,
|
||||
+#if defined(CONFIG_IMQ_BEHAVIOR_BA) || defined(CONFIG_IMQ_BEHAVIOR_BB)
|
||||
+ .priority = NF_IP6_PRI_MANGLE + 1
|
||||
+#else
|
||||
+ .priority = NF_IP6_PRI_NAT_DST + 1
|
||||
+#endif
|
||||
+};
|
||||
+
|
||||
+static struct nf_hook_ops imq_egress_ipv6 = {
|
||||
+ .hook = imq_nf_hook,
|
||||
+ .owner = THIS_MODULE,
|
||||
+ .pf = PF_INET6,
|
||||
+ .hooknum = NF_INET_POST_ROUTING,
|
||||
+#if defined(CONFIG_IMQ_BEHAVIOR_AA) || defined(CONFIG_IMQ_BEHAVIOR_BA)
|
||||
+ .priority = NF_IP6_PRI_LAST
|
||||
+#else
|
||||
+ .priority = NF_IP6_PRI_NAT_SRC - 1
|
||||
+#endif
|
||||
+};
|
||||
+#endif
|
||||
+
|
||||
+#if defined(CONFIG_IMQ_NUM_DEVS)
|
||||
+static unsigned int numdevs = CONFIG_IMQ_NUM_DEVS;
|
||||
+#else
|
||||
+static unsigned int numdevs = IMQ_MAX_DEVS;
|
||||
+#endif
|
||||
+
|
||||
+static struct net_device *imq_devs_cache[IMQ_MAX_DEVS];
|
||||
+
|
||||
+static struct net_device_stats *imq_get_stats(struct net_device *dev)
|
||||
+{
|
||||
+ return &dev->stats;
|
||||
+}
|
||||
+
|
||||
+/* called for packets kfree'd in qdiscs at places other than enqueue */
|
||||
+static void imq_skb_destructor(struct sk_buff *skb)
|
||||
+{
|
||||
+ struct nf_queue_entry *entry = skb->nf_queue_entry;
|
||||
+
|
||||
+ if (entry) {
|
||||
+ if (entry->indev)
|
||||
+ dev_put(entry->indev);
|
||||
+ if (entry->outdev)
|
||||
+ dev_put(entry->outdev);
|
||||
+ kfree(entry);
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
+static int imq_dev_xmit(struct sk_buff *skb, struct net_device *dev)
|
||||
+{
|
||||
+ dev->stats.tx_bytes += skb->len;
|
||||
+ dev->stats.tx_packets++;
|
||||
+
|
||||
+ skb->imq_flags = 0;
|
||||
+ skb->destructor = NULL;
|
||||
+
|
||||
+ dev->trans_start = jiffies;
|
||||
+ nf_reinject(skb->nf_queue_entry, NF_ACCEPT);
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static int imq_nf_queue(struct nf_queue_entry *entry, unsigned queue_num)
|
||||
+{
|
||||
+ struct net_device *dev;
|
||||
+ struct imq_private *priv;
|
||||
+ struct sk_buff *skb2 = NULL;
|
||||
+ struct Qdisc *q;
|
||||
+ unsigned int index = entry->skb->imq_flags & IMQ_F_IFMASK;
|
||||
+ int ret = -1;
|
||||
+
|
||||
+ if (index > numdevs)
|
||||
+ return -1;
|
||||
+
|
||||
+ /* check for imq device by index from cache */
|
||||
+ dev = imq_devs_cache[index];
|
||||
+ if (!dev) {
|
||||
+ char buf[8];
|
||||
+
|
||||
+ /* get device by name and cache result */
|
||||
+ snprintf(buf, sizeof(buf), "imq%d", index);
|
||||
+ dev = dev_get_by_name(&init_net, buf);
|
||||
+ if (!dev) {
|
||||
+ /* not found ?!*/
|
||||
+ BUG();
|
||||
+ return -1;
|
||||
+ }
|
||||
+
|
||||
+ imq_devs_cache[index] = dev;
|
||||
+ }
|
||||
+
|
||||
+ priv = netdev_priv(dev);
|
||||
+ if (!(dev->flags & IFF_UP)) {
|
||||
+ entry->skb->imq_flags = 0;
|
||||
+ nf_reinject(entry, NF_ACCEPT);
|
||||
+ return 0;
|
||||
+ }
|
||||
+ dev->last_rx = jiffies;
|
||||
+
|
||||
+ if (entry->skb->destructor) {
|
||||
+ skb2 = entry->skb;
|
||||
+ entry->skb = skb_clone(entry->skb, GFP_ATOMIC);
|
||||
+ if (!entry->skb)
|
||||
+ return -1;
|
||||
+ }
|
||||
+ entry->skb->nf_queue_entry = entry;
|
||||
+
|
||||
+ dev->stats.rx_bytes += entry->skb->len;
|
||||
+ dev->stats.rx_packets++;
|
||||
+
|
||||
+ spin_lock_bh(&dev->queue_lock);
|
||||
+ q = dev->qdisc;
|
||||
+ if (q->enqueue) {
|
||||
+ q->enqueue(skb_get(entry->skb), q);
|
||||
+ if (skb_shared(entry->skb)) {
|
||||
+ entry->skb->destructor = imq_skb_destructor;
|
||||
+ kfree_skb(entry->skb);
|
||||
+ ret = 0;
|
||||
+ }
|
||||
+ }
|
||||
+ if (!test_and_set_bit(1, &priv->tasklet_pending))
|
||||
+ tasklet_schedule(&priv->tasklet);
|
||||
+ spin_unlock_bh(&dev->queue_lock);
|
||||
+
|
||||
+ if (skb2)
|
||||
+ kfree_skb(ret ? entry->skb : skb2);
|
||||
+
|
||||
+ return ret;
|
||||
+}
|
||||
+
|
||||
+static struct nf_queue_handler nfqh = {
|
||||
+ .name = "imq",
|
||||
+ .outfn = imq_nf_queue,
|
||||
+};
|
||||
+
|
||||
+static void qdisc_run_tasklet(unsigned long arg)
|
||||
+{
|
||||
+ struct net_device *dev = (struct net_device *)arg;
|
||||
+ struct imq_private *priv = netdev_priv(dev);
|
||||
+
|
||||
+ spin_lock(&dev->queue_lock);
|
||||
+ qdisc_run(dev);
|
||||
+ clear_bit(1, &priv->tasklet_pending);
|
||||
+ spin_unlock(&dev->queue_lock);
|
||||
+}
|
||||
+
|
||||
+static unsigned int imq_nf_hook(unsigned int hook, struct sk_buff *pskb,
|
||||
+ const struct net_device *indev,
|
||||
+ const struct net_device *outdev,
|
||||
+ int (*okfn)(struct sk_buff *))
|
||||
+{
|
||||
+ if (pskb->imq_flags & IMQ_F_ENQUEUE)
|
||||
+ return NF_QUEUE;
|
||||
+
|
||||
+ return NF_ACCEPT;
|
||||
+}
|
||||
+
|
||||
+static int imq_close(struct net_device *dev)
|
||||
+{
|
||||
+ struct imq_private *priv = netdev_priv(dev);
|
||||
+
|
||||
+ tasklet_kill(&priv->tasklet);
|
||||
+ netif_stop_queue(dev);
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static int imq_open(struct net_device *dev)
|
||||
+{
|
||||
+ struct imq_private *priv = netdev_priv(dev);
|
||||
+
|
||||
+ tasklet_init(&priv->tasklet, qdisc_run_tasklet, (unsigned long)dev);
|
||||
+ netif_start_queue(dev);
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static void imq_setup(struct net_device *dev)
|
||||
+{
|
||||
+ dev->hard_start_xmit = imq_dev_xmit;
|
||||
+ dev->open = imq_open;
|
||||
+ dev->get_stats = imq_get_stats;
|
||||
+ dev->stop = imq_close;
|
||||
+ dev->type = ARPHRD_VOID;
|
||||
+ dev->mtu = 16000;
|
||||
+ dev->tx_queue_len = 11000;
|
||||
+ dev->flags = IFF_NOARP;
|
||||
+}
|
||||
+
|
||||
+static struct rtnl_link_ops imq_link_ops __read_mostly = {
|
||||
+ .kind = "imq",
|
||||
+ .priv_size = sizeof(struct imq_private),
|
||||
+ .setup = imq_setup,
|
||||
+};
|
||||
+
|
||||
+static int __init imq_init_hooks(void)
|
||||
+{
|
||||
+ int err;
|
||||
+
|
||||
+ err = nf_register_queue_handler(PF_INET, &nfqh);
|
||||
+ if (err)
|
||||
+ goto err1;
|
||||
+
|
||||
+ err = nf_register_hook(&imq_ingress_ipv4);
|
||||
+ if (err)
|
||||
+ goto err2;
|
||||
+
|
||||
+ err = nf_register_hook(&imq_egress_ipv4);
|
||||
+ if (err)
|
||||
+ goto err3;
|
||||
+
|
||||
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
|
||||
+ err = nf_register_queue_handler(PF_INET6, &nfqh);
|
||||
+ if (err)
|
||||
+ goto err4;
|
||||
+
|
||||
+ err = nf_register_hook(&imq_ingress_ipv6);
|
||||
+ if (err)
|
||||
+ goto err5;
|
||||
+
|
||||
+ err = nf_register_hook(&imq_egress_ipv6);
|
||||
+ if (err)
|
||||
+ goto err6;
|
||||
+#endif
|
||||
+
|
||||
+ return 0;
|
||||
+
|
||||
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
|
||||
+err6:
|
||||
+ nf_unregister_hook(&imq_ingress_ipv6);
|
||||
+err5:
|
||||
+ nf_unregister_queue_handler(PF_INET6, &nfqh);
|
||||
+err4:
|
||||
+ nf_unregister_hook(&imq_egress_ipv4);
|
||||
+#endif
|
||||
+err3:
|
||||
+ nf_unregister_hook(&imq_ingress_ipv4);
|
||||
+err2:
|
||||
+ nf_unregister_queue_handler(PF_INET, &nfqh);
|
||||
+err1:
|
||||
+ return err;
|
||||
+}
|
||||
+
|
||||
+static int __init imq_init_one(int index)
|
||||
+{
|
||||
+ struct net_device *dev;
|
||||
+ int ret;
|
||||
+
|
||||
+ dev = alloc_netdev(sizeof(struct imq_private), "imq%d", imq_setup);
|
||||
+ if (!dev)
|
||||
+ return -ENOMEM;
|
||||
+
|
||||
+ ret = dev_alloc_name(dev, dev->name);
|
||||
+ if (ret < 0)
|
||||
+ goto fail;
|
||||
+
|
||||
+ dev->rtnl_link_ops = &imq_link_ops;
|
||||
+ ret = register_netdevice(dev);
|
||||
+ if (ret < 0)
|
||||
+ goto fail;
|
||||
+
|
||||
+ return 0;
|
||||
+fail:
|
||||
+ free_netdev(dev);
|
||||
+ return ret;
|
||||
+}
|
||||
+
|
||||
+static int __init imq_init_devs(void)
|
||||
+{
|
||||
+ int err, i;
|
||||
+
|
||||
+ if (!numdevs || numdevs > IMQ_MAX_DEVS) {
|
||||
+ printk(KERN_ERR "IMQ: numdevs has to be betweed 1 and %u\n",
|
||||
+ IMQ_MAX_DEVS);
|
||||
+ return -EINVAL;
|
||||
+ }
|
||||
+
|
||||
+ rtnl_lock();
|
||||
+ err = __rtnl_link_register(&imq_link_ops);
|
||||
+
|
||||
+ for (i = 0; i < numdevs && !err; i++)
|
||||
+ err = imq_init_one(i);
|
||||
+
|
||||
+ if (err) {
|
||||
+ __rtnl_link_unregister(&imq_link_ops);
|
||||
+ memset(imq_devs_cache, 0, sizeof(imq_devs_cache));
|
||||
+ }
|
||||
+ rtnl_unlock();
|
||||
+
|
||||
+ return err;
|
||||
+}
|
||||
+
|
||||
+static int __init imq_init_module(void)
|
||||
+{
|
||||
+ int err;
|
||||
+
|
||||
+ err = imq_init_devs();
|
||||
+ if (err) {
|
||||
+ printk(KERN_ERR "IMQ: Error trying imq_init_devs(net)\n");
|
||||
+ return err;
|
||||
+ }
|
||||
+
|
||||
+ err = imq_init_hooks();
|
||||
+ if (err) {
|
||||
+ printk(KERN_ERR "IMQ: Error trying imq_init_hooks()\n");
|
||||
+ rtnl_link_unregister(&imq_link_ops);
|
||||
+ memset(imq_devs_cache, 0, sizeof(imq_devs_cache));
|
||||
+ return err;
|
||||
+ }
|
||||
+
|
||||
+ printk(KERN_INFO "IMQ driver loaded successfully.\n");
|
||||
+
|
||||
+#if defined(CONFIG_IMQ_BEHAVIOR_BA) || defined(CONFIG_IMQ_BEHAVIOR_BB)
|
||||
+ printk(KERN_INFO "\tHooking IMQ before NAT on PREROUTING.\n");
|
||||
+#else
|
||||
+ printk(KERN_INFO "\tHooking IMQ after NAT on PREROUTING.\n");
|
||||
+#endif
|
||||
+#if defined(CONFIG_IMQ_BEHAVIOR_AB) || defined(CONFIG_IMQ_BEHAVIOR_BB)
|
||||
+ printk(KERN_INFO "\tHooking IMQ before NAT on POSTROUTING.\n");
|
||||
+#else
|
||||
+ printk(KERN_INFO "\tHooking IMQ after NAT on POSTROUTING.\n");
|
||||
+#endif
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static void __exit imq_unhook(void)
|
||||
+{
|
||||
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
|
||||
+ nf_unregister_hook(&imq_ingress_ipv6);
|
||||
+ nf_unregister_hook(&imq_egress_ipv6);
|
||||
+ nf_unregister_queue_handler(PF_INET6, &nfqh);
|
||||
+#endif
|
||||
+ nf_unregister_hook(&imq_ingress_ipv4);
|
||||
+ nf_unregister_hook(&imq_egress_ipv4);
|
||||
+ nf_unregister_queue_handler(PF_INET, &nfqh);
|
||||
+}
|
||||
+
|
||||
+static void __exit imq_cleanup_devs(void)
|
||||
+{
|
||||
+ rtnl_link_unregister(&imq_link_ops);
|
||||
+ memset(imq_devs_cache, 0, sizeof(imq_devs_cache));
|
||||
+}
|
||||
+
|
||||
+static void __exit imq_exit_module(void)
|
||||
+{
|
||||
+ imq_unhook();
|
||||
+ imq_cleanup_devs();
|
||||
+ printk(KERN_INFO "IMQ driver unloaded successfully.\n");
|
||||
+}
|
||||
+
|
||||
+module_init(imq_init_module);
|
||||
+module_exit(imq_exit_module);
|
||||
+
|
||||
+module_param(numdevs, int, 0);
|
||||
+MODULE_PARM_DESC(numdevs, "number of IMQ devices (how many imq* devices will "
|
||||
+ "be created)");
|
||||
+MODULE_AUTHOR("http://www.linuximq.net");
|
||||
+MODULE_DESCRIPTION("Pseudo-driver for the intermediate queue device. See "
|
||||
+ "http://www.linuximq.net/ for more information.");
|
||||
+MODULE_LICENSE("GPL");
|
||||
+MODULE_ALIAS_RTNL_LINK("imq");
|
||||
+
|
||||
--- a/drivers/net/Kconfig
|
||||
+++ b/drivers/net/Kconfig
|
||||
@@ -117,6 +117,129 @@ config EQUALIZER
|
||||
To compile this driver as a module, choose M here: the module
|
||||
will be called eql. If unsure, say N.
|
||||
|
||||
+config IMQ
|
||||
+ tristate "IMQ (intermediate queueing device) support"
|
||||
+ depends on NETDEVICES && NETFILTER
|
||||
+ ---help---
|
||||
+ The IMQ device(s) is used as placeholder for QoS queueing
|
||||
+ disciplines. Every packet entering/leaving the IP stack can be
|
||||
+ directed through the IMQ device where it's enqueued/dequeued to the
|
||||
+ attached qdisc. This allows you to treat network devices as classes
|
||||
+ and distribute bandwidth among them. Iptables is used to specify
|
||||
+ through which IMQ device, if any, packets travel.
|
||||
+
|
||||
+ More information at: http://www.linuximq.net/
|
||||
+
|
||||
+ To compile this driver as a module, choose M here: the module
|
||||
+ will be called imq. If unsure, say N.
|
||||
+
|
||||
+choice
|
||||
+ prompt "IMQ behavior (PRE/POSTROUTING)"
|
||||
+ depends on IMQ
|
||||
+ default IMQ_BEHAVIOR_AB
|
||||
+ help
|
||||
+
|
||||
+ This settings defines how IMQ behaves in respect to its
|
||||
+ hooking in PREROUTING and POSTROUTING.
|
||||
+
|
||||
+ IMQ can work in any of the following ways:
|
||||
+
|
||||
+ PREROUTING | POSTROUTING
|
||||
+ -----------------|-------------------
|
||||
+ #1 After NAT | After NAT
|
||||
+ #2 After NAT | Before NAT
|
||||
+ #3 Before NAT | After NAT
|
||||
+ #4 Before NAT | Before NAT
|
||||
+
|
||||
+ The default behavior is to hook before NAT on PREROUTING
|
||||
+ and after NAT on POSTROUTING (#3).
|
||||
+
|
||||
+ This settings are specially usefull when trying to use IMQ
|
||||
+ to shape NATed clients.
|
||||
+
|
||||
+ More information can be found at: www.linuximq.net
|
||||
+
|
||||
+ If not sure leave the default settings alone.
|
||||
+
|
||||
+config IMQ_BEHAVIOR_AA
|
||||
+ bool "IMQ AA"
|
||||
+ help
|
||||
+ This settings defines how IMQ behaves in respect to its
|
||||
+ hooking in PREROUTING and POSTROUTING.
|
||||
+
|
||||
+ Choosing this option will make IMQ hook like this:
|
||||
+
|
||||
+ PREROUTING: After NAT
|
||||
+ POSTROUTING: After NAT
|
||||
+
|
||||
+ More information can be found at: www.linuximq.net
|
||||
+
|
||||
+ If not sure leave the default settings alone.
|
||||
+
|
||||
+config IMQ_BEHAVIOR_AB
|
||||
+ bool "IMQ AB"
|
||||
+ help
|
||||
+ This settings defines how IMQ behaves in respect to its
|
||||
+ hooking in PREROUTING and POSTROUTING.
|
||||
+
|
||||
+ Choosing this option will make IMQ hook like this:
|
||||
+
|
||||
+ PREROUTING: After NAT
|
||||
+ POSTROUTING: Before NAT
|
||||
+
|
||||
+ More information can be found at: www.linuximq.net
|
||||
+
|
||||
+ If not sure leave the default settings alone.
|
||||
+
|
||||
+config IMQ_BEHAVIOR_BA
|
||||
+ bool "IMQ BA"
|
||||
+ help
|
||||
+ This settings defines how IMQ behaves in respect to its
|
||||
+ hooking in PREROUTING and POSTROUTING.
|
||||
+
|
||||
+ Choosing this option will make IMQ hook like this:
|
||||
+
|
||||
+ PREROUTING: Before NAT
|
||||
+ POSTROUTING: After NAT
|
||||
+
|
||||
+ More information can be found at: www.linuximq.net
|
||||
+
|
||||
+ If not sure leave the default settings alone.
|
||||
+
|
||||
+config IMQ_BEHAVIOR_BB
|
||||
+ bool "IMQ BB"
|
||||
+ help
|
||||
+ This settings defines how IMQ behaves in respect to its
|
||||
+ hooking in PREROUTING and POSTROUTING.
|
||||
+
|
||||
+ Choosing this option will make IMQ hook like this:
|
||||
+
|
||||
+ PREROUTING: Before NAT
|
||||
+ POSTROUTING: Before NAT
|
||||
+
|
||||
+ More information can be found at: www.linuximq.net
|
||||
+
|
||||
+ If not sure leave the default settings alone.
|
||||
+
|
||||
+endchoice
|
||||
+
|
||||
+config IMQ_NUM_DEVS
|
||||
+
|
||||
+ int "Number of IMQ devices"
|
||||
+ range 2 16
|
||||
+ depends on IMQ
|
||||
+ default "16"
|
||||
+ help
|
||||
+
|
||||
+ This settings defines how many IMQ devices will be
|
||||
+ created.
|
||||
+
|
||||
+ The default value is 16.
|
||||
+
|
||||
+ More information can be found at: www.linuximq.net
|
||||
+
|
||||
+ If not sure leave the default settings alone.
|
||||
+
|
||||
config TUN
|
||||
tristate "Universal TUN/TAP device driver support"
|
||||
select CRC32
|
||||
--- a/drivers/net/Makefile
|
||||
+++ b/drivers/net/Makefile
|
||||
@@ -143,6 +143,7 @@ obj-$(CONFIG_SLHC) += slhc.o
|
||||
obj-$(CONFIG_XEN_NETDEV_FRONTEND) += xen-netfront.o
|
||||
|
||||
obj-$(CONFIG_DUMMY) += dummy.o
|
||||
+obj-$(CONFIG_IMQ) += imq.o
|
||||
obj-$(CONFIG_IFB) += ifb.o
|
||||
obj-$(CONFIG_MACVLAN) += macvlan.o
|
||||
obj-$(CONFIG_DE600) += de600.o
|
||||
--- /dev/null
|
||||
+++ b/include/linux/imq.h
|
||||
@@ -0,0 +1,9 @@
|
||||
+#ifndef _IMQ_H
|
||||
+#define _IMQ_H
|
||||
+
|
||||
+#define IMQ_MAX_DEVS 16
|
||||
+
|
||||
+#define IMQ_F_IFMASK 0x7f
|
||||
+#define IMQ_F_ENQUEUE 0x80
|
||||
+
|
||||
+#endif /* _IMQ_H */
|
||||
--- /dev/null
|
||||
+++ b/include/linux/netfilter_ipv4/ipt_IMQ.h
|
||||
@@ -0,0 +1,8 @@
|
||||
+#ifndef _IPT_IMQ_H
|
||||
+#define _IPT_IMQ_H
|
||||
+
|
||||
+struct ipt_imq_info {
|
||||
+ unsigned int todev; /* target imq device */
|
||||
+};
|
||||
+
|
||||
+#endif /* _IPT_IMQ_H */
|
||||
--- /dev/null
|
||||
+++ b/include/linux/netfilter_ipv6/ip6t_IMQ.h
|
||||
@@ -0,0 +1,8 @@
|
||||
+#ifndef _IP6T_IMQ_H
|
||||
+#define _IP6T_IMQ_H
|
||||
+
|
||||
+struct ip6t_imq_info {
|
||||
+ unsigned int todev; /* target imq device */
|
||||
+};
|
||||
+
|
||||
+#endif /* _IP6T_IMQ_H */
|
||||
--- a/include/linux/skbuff.h
|
||||
+++ b/include/linux/skbuff.h
|
||||
@@ -296,6 +296,10 @@ struct sk_buff {
|
||||
struct nf_conntrack *nfct;
|
||||
struct sk_buff *nfct_reasm;
|
||||
#endif
|
||||
+#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE)
|
||||
+ unsigned char imq_flags;
|
||||
+ struct nf_queue_entry *nf_queue_entry;
|
||||
+#endif
|
||||
#ifdef CONFIG_BRIDGE_NETFILTER
|
||||
struct nf_bridge_info *nf_bridge;
|
||||
#endif
|
||||
@@ -1736,6 +1740,10 @@ static inline void __nf_copy(struct sk_b
|
||||
dst->nfct_reasm = src->nfct_reasm;
|
||||
nf_conntrack_get_reasm(src->nfct_reasm);
|
||||
#endif
|
||||
+#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE)
|
||||
+ dst->imq_flags = src->imq_flags;
|
||||
+ dst->nf_queue_entry = src->nf_queue_entry;
|
||||
+#endif
|
||||
#ifdef CONFIG_BRIDGE_NETFILTER
|
||||
dst->nf_bridge = src->nf_bridge;
|
||||
nf_bridge_get(src->nf_bridge);
|
||||
--- a/net/core/dev.c
|
||||
+++ b/net/core/dev.c
|
||||
@@ -95,6 +95,9 @@
|
||||
#include <net/net_namespace.h>
|
||||
#include <net/sock.h>
|
||||
#include <linux/rtnetlink.h>
|
||||
+#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE)
|
||||
+#include <linux/imq.h>
|
||||
+#endif
|
||||
#include <linux/proc_fs.h>
|
||||
#include <linux/seq_file.h>
|
||||
#include <linux/stat.h>
|
||||
@@ -1537,7 +1540,11 @@ static int dev_gso_segment(struct sk_buf
|
||||
int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
|
||||
{
|
||||
if (likely(!skb->next)) {
|
||||
- if (!list_empty(&ptype_all))
|
||||
+ if (!list_empty(&ptype_all)
|
||||
+#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE)
|
||||
+ && !(skb->imq_flags & IMQ_F_ENQUEUE)
|
||||
+#endif
|
||||
+ )
|
||||
dev_queue_xmit_nit(skb, dev);
|
||||
|
||||
if (netif_needs_gso(dev, skb)) {
|
||||
--- /dev/null
|
||||
+++ b/net/ipv4/netfilter/ipt_IMQ.c
|
||||
@@ -0,0 +1,69 @@
|
||||
+/*
|
||||
+ * This target marks packets to be enqueued to an imq device
|
||||
+ */
|
||||
+#include <linux/module.h>
|
||||
+#include <linux/skbuff.h>
|
||||
+#include <linux/netfilter_ipv4/ip_tables.h>
|
||||
+#include <linux/netfilter_ipv4/ipt_IMQ.h>
|
||||
+#include <linux/imq.h>
|
||||
+
|
||||
+static unsigned int imq_target(struct sk_buff *pskb,
|
||||
+ const struct net_device *in,
|
||||
+ const struct net_device *out,
|
||||
+ unsigned int hooknum,
|
||||
+ const struct xt_target *target,
|
||||
+ const void *targinfo)
|
||||
+{
|
||||
+ struct ipt_imq_info *mr = (struct ipt_imq_info *)targinfo;
|
||||
+
|
||||
+ pskb->imq_flags = mr->todev | IMQ_F_ENQUEUE;
|
||||
+
|
||||
+ return XT_CONTINUE;
|
||||
+}
|
||||
+
|
||||
+static bool imq_checkentry(const char *tablename,
|
||||
+ const void *e,
|
||||
+ const struct xt_target *target,
|
||||
+ void *targinfo,
|
||||
+ unsigned int hook_mask)
|
||||
+{
|
||||
+ struct ipt_imq_info *mr;
|
||||
+
|
||||
+ mr = (struct ipt_imq_info *)targinfo;
|
||||
+
|
||||
+ if (mr->todev > IMQ_MAX_DEVS) {
|
||||
+ printk(KERN_WARNING
|
||||
+ "IMQ: invalid device specified, highest is %u\n",
|
||||
+ IMQ_MAX_DEVS);
|
||||
+ return 0;
|
||||
+ }
|
||||
+
|
||||
+ return 1;
|
||||
+}
|
||||
+
|
||||
+static struct xt_target ipt_imq_reg = {
|
||||
+ .name = "IMQ",
|
||||
+ .family = AF_INET,
|
||||
+ .target = imq_target,
|
||||
+ .targetsize = sizeof(struct ipt_imq_info),
|
||||
+ .checkentry = imq_checkentry,
|
||||
+ .me = THIS_MODULE,
|
||||
+ .table = "mangle"
|
||||
+};
|
||||
+
|
||||
+static int __init init(void)
|
||||
+{
|
||||
+ return xt_register_target(&ipt_imq_reg);
|
||||
+}
|
||||
+
|
||||
+static void __exit fini(void)
|
||||
+{
|
||||
+ xt_unregister_target(&ipt_imq_reg);
|
||||
+}
|
||||
+
|
||||
+module_init(init);
|
||||
+module_exit(fini);
|
||||
+
|
||||
+MODULE_AUTHOR("http://www.linuximq.net");
|
||||
+MODULE_DESCRIPTION("Pseudo-driver for the intermediate queue device. See http://www.linuximq.net/ for more information.");
|
||||
+MODULE_LICENSE("GPL");
|
||||
--- a/net/ipv4/netfilter/Kconfig
|
||||
+++ b/net/ipv4/netfilter/Kconfig
|
||||
@@ -123,6 +123,17 @@ config IP_NF_FILTER
|
||||
|
||||
To compile it as a module, choose M here. If unsure, say N.
|
||||
|
||||
+config IP_NF_TARGET_IMQ
|
||||
+ tristate "IMQ target support"
|
||||
+ depends on IP_NF_MANGLE && IMQ
|
||||
+ help
|
||||
+ This option adds a `IMQ' target which is used to specify if and
|
||||
+ to which IMQ device packets should get enqueued/dequeued.
|
||||
+
|
||||
+ For more information visit: http://www.linuximq.net/
|
||||
+
|
||||
+ To compile it as a module, choose M here. If unsure, say N.
|
||||
+
|
||||
config IP_NF_TARGET_REJECT
|
||||
tristate "REJECT target support"
|
||||
depends on IP_NF_FILTER
|
||||
--- a/net/ipv4/netfilter/Makefile
|
||||
+++ b/net/ipv4/netfilter/Makefile
|
||||
@@ -51,6 +51,7 @@ obj-$(CONFIG_IP_NF_MATCH_TTL) += ipt_ttl
|
||||
obj-$(CONFIG_IP_NF_TARGET_CLUSTERIP) += ipt_CLUSTERIP.o
|
||||
obj-$(CONFIG_IP_NF_TARGET_ECN) += ipt_ECN.o
|
||||
obj-$(CONFIG_IP_NF_TARGET_LOG) += ipt_LOG.o
|
||||
+obj-$(CONFIG_IP_NF_TARGET_IMQ) += ipt_IMQ.o
|
||||
obj-$(CONFIG_IP_NF_TARGET_MASQUERADE) += ipt_MASQUERADE.o
|
||||
obj-$(CONFIG_IP_NF_TARGET_NETMAP) += ipt_NETMAP.o
|
||||
obj-$(CONFIG_IP_NF_TARGET_REDIRECT) += ipt_REDIRECT.o
|
||||
--- /dev/null
|
||||
+++ b/net/ipv6/netfilter/ip6t_IMQ.c
|
||||
@@ -0,0 +1,69 @@
|
||||
+/*
|
||||
+ * This target marks packets to be enqueued to an imq device
|
||||
+ */
|
||||
+#include <linux/module.h>
|
||||
+#include <linux/skbuff.h>
|
||||
+#include <linux/netfilter_ipv6/ip6_tables.h>
|
||||
+#include <linux/netfilter_ipv6/ip6t_IMQ.h>
|
||||
+#include <linux/imq.h>
|
||||
+
|
||||
+static unsigned int imq_target(struct sk_buff *pskb,
|
||||
+ const struct net_device *in,
|
||||
+ const struct net_device *out,
|
||||
+ unsigned int hooknum,
|
||||
+ const struct xt_target *target,
|
||||
+ const void *targinfo)
|
||||
+{
|
||||
+ struct ip6t_imq_info *mr = (struct ip6t_imq_info *)targinfo;
|
||||
+
|
||||
+ pskb->imq_flags = mr->todev | IMQ_F_ENQUEUE;
|
||||
+
|
||||
+ return XT_CONTINUE;
|
||||
+}
|
||||
+
|
||||
+static bool imq_checkentry(const char *tablename,
|
||||
+ const void *entry,
|
||||
+ const struct xt_target *target,
|
||||
+ void *targinfo,
|
||||
+ unsigned int hook_mask)
|
||||
+{
|
||||
+ struct ip6t_imq_info *mr;
|
||||
+
|
||||
+ mr = (struct ip6t_imq_info *)targinfo;
|
||||
+
|
||||
+ if (mr->todev > IMQ_MAX_DEVS) {
|
||||
+ printk(KERN_WARNING
|
||||
+ "IMQ: invalid device specified, highest is %u\n",
|
||||
+ IMQ_MAX_DEVS);
|
||||
+ return 0;
|
||||
+ }
|
||||
+
|
||||
+ return 1;
|
||||
+}
|
||||
+
|
||||
+static struct xt_target ip6t_imq_reg = {
|
||||
+ .name = "IMQ",
|
||||
+ .family = AF_INET6,
|
||||
+ .target = imq_target,
|
||||
+ .targetsize = sizeof(struct ip6t_imq_info),
|
||||
+ .table = "mangle",
|
||||
+ .checkentry = imq_checkentry,
|
||||
+ .me = THIS_MODULE
|
||||
+};
|
||||
+
|
||||
+static int __init init(void)
|
||||
+{
|
||||
+ return xt_register_target(&ip6t_imq_reg);
|
||||
+}
|
||||
+
|
||||
+static void __exit fini(void)
|
||||
+{
|
||||
+ xt_unregister_target(&ip6t_imq_reg);
|
||||
+}
|
||||
+
|
||||
+module_init(init);
|
||||
+module_exit(fini);
|
||||
+
|
||||
+MODULE_AUTHOR("http://www.linuximq.net");
|
||||
+MODULE_DESCRIPTION("Pseudo-driver for the intermediate queue device. See http://www.linuximq.net/ for more information.");
|
||||
+MODULE_LICENSE("GPL");
|
||||
--- a/net/ipv6/netfilter/Kconfig
|
||||
+++ b/net/ipv6/netfilter/Kconfig
|
||||
@@ -179,6 +179,15 @@ config IP6_NF_MANGLE
|
||||
|
||||
To compile it as a module, choose M here. If unsure, say N.
|
||||
|
||||
+config IP6_NF_TARGET_IMQ
|
||||
+ tristate "IMQ target support"
|
||||
+ depends on IP6_NF_MANGLE && IMQ
|
||||
+ help
|
||||
+ This option adds a `IMQ' target which is used to specify if and
|
||||
+ to which imq device packets should get enqueued/dequeued.
|
||||
+
|
||||
+ To compile it as a module, choose M here. If unsure, say N.
|
||||
+
|
||||
config IP6_NF_TARGET_HL
|
||||
tristate 'HL (hoplimit) target support'
|
||||
depends on IP6_NF_MANGLE
|
||||
--- a/net/ipv6/netfilter/Makefile
|
||||
+++ b/net/ipv6/netfilter/Makefile
|
||||
@@ -6,6 +6,7 @@
|
||||
obj-$(CONFIG_IP6_NF_IPTABLES) += ip6_tables.o
|
||||
obj-$(CONFIG_IP6_NF_FILTER) += ip6table_filter.o
|
||||
obj-$(CONFIG_IP6_NF_MANGLE) += ip6table_mangle.o
|
||||
+obj-$(CONFIG_IP6_NF_TARGET_IMQ) += ip6t_IMQ.o
|
||||
obj-$(CONFIG_IP6_NF_QUEUE) += ip6_queue.o
|
||||
obj-$(CONFIG_IP6_NF_RAW) += ip6table_raw.o
|
||||
|
||||
--- a/net/sched/sch_generic.c
|
||||
+++ b/net/sched/sch_generic.c
|
||||
@@ -203,6 +203,7 @@ void __qdisc_run(struct net_device *dev)
|
||||
|
||||
clear_bit(__LINK_STATE_QDISC_RUNNING, &dev->state);
|
||||
}
|
||||
+EXPORT_SYMBOL(__qdisc_run);
|
||||
|
||||
static void dev_watchdog(unsigned long arg)
|
||||
{
|
|
@ -1,20 +0,0 @@
|
|||
--- a/net/netfilter/Kconfig
|
||||
+++ b/net/netfilter/Kconfig
|
||||
@@ -145,7 +145,7 @@ config NF_CONNTRACK_FTP
|
||||
|
||||
config NF_CONNTRACK_H323
|
||||
tristate "H.323 protocol support"
|
||||
- depends on NF_CONNTRACK && (IPV6 || IPV6=n)
|
||||
+ depends on NF_CONNTRACK
|
||||
depends on NETFILTER_ADVANCED
|
||||
help
|
||||
H.323 is a VoIP signalling protocol from ITU-T. As one of the most
|
||||
@@ -423,7 +423,7 @@ config NETFILTER_XT_TARGET_CONNSECMARK
|
||||
|
||||
config NETFILTER_XT_TARGET_TCPMSS
|
||||
tristate '"TCPMSS" target support'
|
||||
- depends on NETFILTER_XTABLES && (IPV6 || IPV6=n)
|
||||
+ depends on NETFILTER_XTABLES
|
||||
default m if NETFILTER_ADVANCED=n
|
||||
---help---
|
||||
This option adds a `TCPMSS' target, which allows you to alter the
|
File diff suppressed because it is too large
Load diff
|
@ -1,797 +0,0 @@
|
|||
--- a/include/linux/pkt_sched.h
|
||||
+++ b/include/linux/pkt_sched.h
|
||||
@@ -162,8 +162,37 @@ struct tc_sfq_xstats
|
||||
*
|
||||
* The only reason for this is efficiency, it is possible
|
||||
* to change these parameters in compile time.
|
||||
+ *
|
||||
+ * If you need to play with these values, use esfq instead.
|
||||
*/
|
||||
|
||||
+/* ESFQ section */
|
||||
+
|
||||
+enum
|
||||
+{
|
||||
+ /* traditional */
|
||||
+ TCA_SFQ_HASH_CLASSIC,
|
||||
+ TCA_SFQ_HASH_DST,
|
||||
+ TCA_SFQ_HASH_SRC,
|
||||
+ TCA_SFQ_HASH_FWMARK,
|
||||
+ /* conntrack */
|
||||
+ TCA_SFQ_HASH_CTORIGDST,
|
||||
+ TCA_SFQ_HASH_CTORIGSRC,
|
||||
+ TCA_SFQ_HASH_CTREPLDST,
|
||||
+ TCA_SFQ_HASH_CTREPLSRC,
|
||||
+ TCA_SFQ_HASH_CTNATCHG,
|
||||
+};
|
||||
+
|
||||
+struct tc_esfq_qopt
|
||||
+{
|
||||
+ unsigned quantum; /* Bytes per round allocated to flow */
|
||||
+ int perturb_period; /* Period of hash perturbation */
|
||||
+ __u32 limit; /* Maximal packets in queue */
|
||||
+ unsigned divisor; /* Hash divisor */
|
||||
+ unsigned flows; /* Maximal number of flows */
|
||||
+ unsigned hash_kind; /* Hash function to use for flow identification */
|
||||
+};
|
||||
+
|
||||
/* RED section */
|
||||
|
||||
enum
|
||||
--- a/net/sched/Kconfig
|
||||
+++ b/net/sched/Kconfig
|
||||
@@ -139,6 +139,37 @@ config NET_SCH_SFQ
|
||||
To compile this code as a module, choose M here: the
|
||||
module will be called sch_sfq.
|
||||
|
||||
+config NET_SCH_ESFQ
|
||||
+ tristate "Enhanced Stochastic Fairness Queueing (ESFQ)"
|
||||
+ ---help---
|
||||
+ Say Y here if you want to use the Enhanced Stochastic Fairness
|
||||
+ Queueing (ESFQ) packet scheduling algorithm for some of your network
|
||||
+ devices or as a leaf discipline for a classful qdisc such as HTB or
|
||||
+ CBQ (see the top of <file:net/sched/sch_esfq.c> for details and
|
||||
+ references to the SFQ algorithm).
|
||||
+
|
||||
+ This is an enchanced SFQ version which allows you to control some
|
||||
+ hardcoded values in the SFQ scheduler.
|
||||
+
|
||||
+ ESFQ also adds control of the hash function used to identify packet
|
||||
+ flows. The original SFQ discipline hashes by connection; ESFQ add
|
||||
+ several other hashing methods, such as by src IP or by dst IP, which
|
||||
+ can be more fair to users in some networking situations.
|
||||
+
|
||||
+ To compile this code as a module, choose M here: the
|
||||
+ module will be called sch_esfq.
|
||||
+
|
||||
+config NET_SCH_ESFQ_NFCT
|
||||
+ bool "Connection Tracking Hash Types"
|
||||
+ depends on NET_SCH_ESFQ && NF_CONNTRACK
|
||||
+ ---help---
|
||||
+ Say Y here to enable support for hashing based on netfilter connection
|
||||
+ tracking information. This is useful for a router that is also using
|
||||
+ NAT to connect privately-addressed hosts to the Internet. If you want
|
||||
+ to provide fair distribution of upstream bandwidth, ESFQ must use
|
||||
+ connection tracking information, since all outgoing packets will share
|
||||
+ the same source address.
|
||||
+
|
||||
config NET_SCH_TEQL
|
||||
tristate "True Link Equalizer (TEQL)"
|
||||
---help---
|
||||
--- a/net/sched/Makefile
|
||||
+++ b/net/sched/Makefile
|
||||
@@ -23,6 +23,7 @@ obj-$(CONFIG_NET_SCH_GRED) += sch_gred.o
|
||||
obj-$(CONFIG_NET_SCH_INGRESS) += sch_ingress.o
|
||||
obj-$(CONFIG_NET_SCH_DSMARK) += sch_dsmark.o
|
||||
obj-$(CONFIG_NET_SCH_SFQ) += sch_sfq.o
|
||||
+obj-$(CONFIG_NET_SCH_ESFQ) += sch_esfq.o
|
||||
obj-$(CONFIG_NET_SCH_TBF) += sch_tbf.o
|
||||
obj-$(CONFIG_NET_SCH_TEQL) += sch_teql.o
|
||||
obj-$(CONFIG_NET_SCH_PRIO) += sch_prio.o
|
||||
--- /dev/null
|
||||
+++ b/net/sched/sch_esfq.c
|
||||
@@ -0,0 +1,704 @@
|
||||
+/*
|
||||
+ * net/sched/sch_esfq.c Extended Stochastic Fairness Queueing discipline.
|
||||
+ *
|
||||
+ * 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.
|
||||
+ *
|
||||
+ * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
|
||||
+ *
|
||||
+ * Changes: Alexander Atanasov, <alex@ssi.bg>
|
||||
+ * Added dynamic depth,limit,divisor,hash_kind options.
|
||||
+ * Added dst and src hashes.
|
||||
+ *
|
||||
+ * Alexander Clouter, <alex@digriz.org.uk>
|
||||
+ * Ported ESFQ to Linux 2.6.
|
||||
+ *
|
||||
+ * Corey Hickey, <bugfood-c@fatooh.org>
|
||||
+ * Maintenance of the Linux 2.6 port.
|
||||
+ * Added fwmark hash (thanks to Robert Kurjata).
|
||||
+ * Added usage of jhash.
|
||||
+ * Added conntrack support.
|
||||
+ * Added ctnatchg hash (thanks to Ben Pfountz).
|
||||
+ */
|
||||
+
|
||||
+#include <linux/module.h>
|
||||
+#include <asm/uaccess.h>
|
||||
+#include <asm/system.h>
|
||||
+#include <linux/bitops.h>
|
||||
+#include <linux/types.h>
|
||||
+#include <linux/kernel.h>
|
||||
+#include <linux/jiffies.h>
|
||||
+#include <linux/string.h>
|
||||
+#include <linux/mm.h>
|
||||
+#include <linux/socket.h>
|
||||
+#include <linux/sockios.h>
|
||||
+#include <linux/in.h>
|
||||
+#include <linux/errno.h>
|
||||
+#include <linux/interrupt.h>
|
||||
+#include <linux/if_ether.h>
|
||||
+#include <linux/inet.h>
|
||||
+#include <linux/netdevice.h>
|
||||
+#include <linux/etherdevice.h>
|
||||
+#include <linux/notifier.h>
|
||||
+#include <linux/init.h>
|
||||
+#include <net/ip.h>
|
||||
+#include <linux/ipv6.h>
|
||||
+#include <net/route.h>
|
||||
+#include <linux/skbuff.h>
|
||||
+#include <net/sock.h>
|
||||
+#include <net/pkt_sched.h>
|
||||
+#include <linux/jhash.h>
|
||||
+#ifdef CONFIG_NET_SCH_ESFQ_NFCT
|
||||
+#include <net/netfilter/nf_conntrack.h>
|
||||
+#endif
|
||||
+
|
||||
+/* Stochastic Fairness Queuing algorithm.
|
||||
+ For more comments look at sch_sfq.c.
|
||||
+ The difference is that you can change limit, depth,
|
||||
+ hash table size and choose alternate hash types.
|
||||
+
|
||||
+ classic: same as in sch_sfq.c
|
||||
+ dst: destination IP address
|
||||
+ src: source IP address
|
||||
+ fwmark: netfilter mark value
|
||||
+ ctorigdst: original destination IP address
|
||||
+ ctorigsrc: original source IP address
|
||||
+ ctrepldst: reply destination IP address
|
||||
+ ctreplsrc: reply source IP
|
||||
+
|
||||
+*/
|
||||
+
|
||||
+#define ESFQ_HEAD 0
|
||||
+#define ESFQ_TAIL 1
|
||||
+
|
||||
+/* This type should contain at least SFQ_DEPTH*2 values */
|
||||
+typedef unsigned int esfq_index;
|
||||
+
|
||||
+struct esfq_head
|
||||
+{
|
||||
+ esfq_index next;
|
||||
+ esfq_index prev;
|
||||
+};
|
||||
+
|
||||
+struct esfq_sched_data
|
||||
+{
|
||||
+/* Parameters */
|
||||
+ int perturb_period;
|
||||
+ unsigned quantum; /* Allotment per round: MUST BE >= MTU */
|
||||
+ int limit;
|
||||
+ unsigned depth;
|
||||
+ unsigned hash_divisor;
|
||||
+ unsigned hash_kind;
|
||||
+/* Variables */
|
||||
+ struct timer_list perturb_timer;
|
||||
+ int perturbation;
|
||||
+ esfq_index tail; /* Index of current slot in round */
|
||||
+ esfq_index max_depth; /* Maximal depth */
|
||||
+
|
||||
+ esfq_index *ht; /* Hash table */
|
||||
+ esfq_index *next; /* Active slots link */
|
||||
+ short *allot; /* Current allotment per slot */
|
||||
+ unsigned short *hash; /* Hash value indexed by slots */
|
||||
+ struct sk_buff_head *qs; /* Slot queue */
|
||||
+ struct esfq_head *dep; /* Linked list of slots, indexed by depth */
|
||||
+};
|
||||
+
|
||||
+/* This contains the info we will hash. */
|
||||
+struct esfq_packet_info
|
||||
+{
|
||||
+ u32 proto; /* protocol or port */
|
||||
+ u32 src; /* source from packet header */
|
||||
+ u32 dst; /* destination from packet header */
|
||||
+ u32 ctorigsrc; /* original source from conntrack */
|
||||
+ u32 ctorigdst; /* original destination from conntrack */
|
||||
+ u32 ctreplsrc; /* reply source from conntrack */
|
||||
+ u32 ctrepldst; /* reply destination from conntrack */
|
||||
+ u32 mark; /* netfilter mark (fwmark) */
|
||||
+};
|
||||
+
|
||||
+static __inline__ unsigned esfq_jhash_1word(struct esfq_sched_data *q,u32 a)
|
||||
+{
|
||||
+ return jhash_1word(a, q->perturbation) & (q->hash_divisor-1);
|
||||
+}
|
||||
+
|
||||
+static __inline__ unsigned esfq_jhash_2words(struct esfq_sched_data *q, u32 a, u32 b)
|
||||
+{
|
||||
+ return jhash_2words(a, b, q->perturbation) & (q->hash_divisor-1);
|
||||
+}
|
||||
+
|
||||
+static __inline__ unsigned esfq_jhash_3words(struct esfq_sched_data *q, u32 a, u32 b, u32 c)
|
||||
+{
|
||||
+ return jhash_3words(a, b, c, q->perturbation) & (q->hash_divisor-1);
|
||||
+}
|
||||
+
|
||||
+static unsigned esfq_hash(struct esfq_sched_data *q, struct sk_buff *skb)
|
||||
+{
|
||||
+ struct esfq_packet_info info;
|
||||
+#ifdef CONFIG_NET_SCH_ESFQ_NFCT
|
||||
+ enum ip_conntrack_info ctinfo;
|
||||
+ struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
|
||||
+#endif
|
||||
+
|
||||
+ switch (skb->protocol) {
|
||||
+ case __constant_htons(ETH_P_IP):
|
||||
+ {
|
||||
+ struct iphdr *iph = ip_hdr(skb);
|
||||
+ info.dst = iph->daddr;
|
||||
+ info.src = iph->saddr;
|
||||
+ if (!(iph->frag_off&htons(IP_MF|IP_OFFSET)) &&
|
||||
+ (iph->protocol == IPPROTO_TCP ||
|
||||
+ iph->protocol == IPPROTO_UDP ||
|
||||
+ iph->protocol == IPPROTO_SCTP ||
|
||||
+ iph->protocol == IPPROTO_DCCP ||
|
||||
+ iph->protocol == IPPROTO_ESP))
|
||||
+ info.proto = *(((u32*)iph) + iph->ihl);
|
||||
+ else
|
||||
+ info.proto = iph->protocol;
|
||||
+ break;
|
||||
+ }
|
||||
+ case __constant_htons(ETH_P_IPV6):
|
||||
+ {
|
||||
+ struct ipv6hdr *iph = ipv6_hdr(skb);
|
||||
+ /* Hash ipv6 addresses into a u32. This isn't ideal,
|
||||
+ * but the code is simple. */
|
||||
+ info.dst = jhash2(iph->daddr.s6_addr32, 4, q->perturbation);
|
||||
+ info.src = jhash2(iph->saddr.s6_addr32, 4, q->perturbation);
|
||||
+ if (iph->nexthdr == IPPROTO_TCP ||
|
||||
+ iph->nexthdr == IPPROTO_UDP ||
|
||||
+ iph->nexthdr == IPPROTO_SCTP ||
|
||||
+ iph->nexthdr == IPPROTO_DCCP ||
|
||||
+ iph->nexthdr == IPPROTO_ESP)
|
||||
+ info.proto = *(u32*)&iph[1];
|
||||
+ else
|
||||
+ info.proto = iph->nexthdr;
|
||||
+ break;
|
||||
+ }
|
||||
+ default:
|
||||
+ info.dst = (u32)(unsigned long)skb->dst;
|
||||
+ info.src = (u32)(unsigned long)skb->sk;
|
||||
+ info.proto = skb->protocol;
|
||||
+ }
|
||||
+
|
||||
+ info.mark = skb->mark;
|
||||
+
|
||||
+#ifdef CONFIG_NET_SCH_ESFQ_NFCT
|
||||
+ /* defaults if there is no conntrack info */
|
||||
+ info.ctorigsrc = info.src;
|
||||
+ info.ctorigdst = info.dst;
|
||||
+ info.ctreplsrc = info.dst;
|
||||
+ info.ctrepldst = info.src;
|
||||
+ /* collect conntrack info */
|
||||
+ if (ct && ct != &nf_conntrack_untracked) {
|
||||
+ if (skb->protocol == __constant_htons(ETH_P_IP)) {
|
||||
+ info.ctorigsrc = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u3.ip;
|
||||
+ info.ctorigdst = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.u3.ip;
|
||||
+ info.ctreplsrc = ct->tuplehash[IP_CT_DIR_REPLY].tuple.src.u3.ip;
|
||||
+ info.ctrepldst = ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u3.ip;
|
||||
+ }
|
||||
+ else if (skb->protocol == __constant_htons(ETH_P_IPV6)) {
|
||||
+ /* Again, hash ipv6 addresses into a single u32. */
|
||||
+ info.ctorigsrc = jhash2(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u3.ip6, 4, q->perturbation);
|
||||
+ info.ctorigdst = jhash2(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.u3.ip6, 4, q->perturbation);
|
||||
+ info.ctreplsrc = jhash2(ct->tuplehash[IP_CT_DIR_REPLY].tuple.src.u3.ip6, 4, q->perturbation);
|
||||
+ info.ctrepldst = jhash2(ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u3.ip6, 4, q->perturbation);
|
||||
+ }
|
||||
+
|
||||
+ }
|
||||
+#endif
|
||||
+
|
||||
+ switch(q->hash_kind) {
|
||||
+ case TCA_SFQ_HASH_CLASSIC:
|
||||
+ return esfq_jhash_3words(q, info.dst, info.src, info.proto);
|
||||
+ case TCA_SFQ_HASH_DST:
|
||||
+ return esfq_jhash_1word(q, info.dst);
|
||||
+ case TCA_SFQ_HASH_SRC:
|
||||
+ return esfq_jhash_1word(q, info.src);
|
||||
+ case TCA_SFQ_HASH_FWMARK:
|
||||
+ return esfq_jhash_1word(q, info.mark);
|
||||
+#ifdef CONFIG_NET_SCH_ESFQ_NFCT
|
||||
+ case TCA_SFQ_HASH_CTORIGDST:
|
||||
+ return esfq_jhash_1word(q, info.ctorigdst);
|
||||
+ case TCA_SFQ_HASH_CTORIGSRC:
|
||||
+ return esfq_jhash_1word(q, info.ctorigsrc);
|
||||
+ case TCA_SFQ_HASH_CTREPLDST:
|
||||
+ return esfq_jhash_1word(q, info.ctrepldst);
|
||||
+ case TCA_SFQ_HASH_CTREPLSRC:
|
||||
+ return esfq_jhash_1word(q, info.ctreplsrc);
|
||||
+ case TCA_SFQ_HASH_CTNATCHG:
|
||||
+ {
|
||||
+ if (info.ctorigdst == info.ctreplsrc)
|
||||
+ return esfq_jhash_1word(q, info.ctorigsrc);
|
||||
+ return esfq_jhash_1word(q, info.ctreplsrc);
|
||||
+ }
|
||||
+#endif
|
||||
+ default:
|
||||
+ if (net_ratelimit())
|
||||
+ printk(KERN_WARNING "ESFQ: Unknown hash method. Falling back to classic.\n");
|
||||
+ }
|
||||
+ return esfq_jhash_3words(q, info.dst, info.src, info.proto);
|
||||
+}
|
||||
+
|
||||
+static inline void esfq_link(struct esfq_sched_data *q, esfq_index x)
|
||||
+{
|
||||
+ esfq_index p, n;
|
||||
+ int d = q->qs[x].qlen + q->depth;
|
||||
+
|
||||
+ p = d;
|
||||
+ n = q->dep[d].next;
|
||||
+ q->dep[x].next = n;
|
||||
+ q->dep[x].prev = p;
|
||||
+ q->dep[p].next = q->dep[n].prev = x;
|
||||
+}
|
||||
+
|
||||
+static inline void esfq_dec(struct esfq_sched_data *q, esfq_index x)
|
||||
+{
|
||||
+ esfq_index p, n;
|
||||
+
|
||||
+ n = q->dep[x].next;
|
||||
+ p = q->dep[x].prev;
|
||||
+ q->dep[p].next = n;
|
||||
+ q->dep[n].prev = p;
|
||||
+
|
||||
+ if (n == p && q->max_depth == q->qs[x].qlen + 1)
|
||||
+ q->max_depth--;
|
||||
+
|
||||
+ esfq_link(q, x);
|
||||
+}
|
||||
+
|
||||
+static inline void esfq_inc(struct esfq_sched_data *q, esfq_index x)
|
||||
+{
|
||||
+ esfq_index p, n;
|
||||
+ int d;
|
||||
+
|
||||
+ n = q->dep[x].next;
|
||||
+ p = q->dep[x].prev;
|
||||
+ q->dep[p].next = n;
|
||||
+ q->dep[n].prev = p;
|
||||
+ d = q->qs[x].qlen;
|
||||
+ if (q->max_depth < d)
|
||||
+ q->max_depth = d;
|
||||
+
|
||||
+ esfq_link(q, x);
|
||||
+}
|
||||
+
|
||||
+static unsigned int esfq_drop(struct Qdisc *sch)
|
||||
+{
|
||||
+ struct esfq_sched_data *q = qdisc_priv(sch);
|
||||
+ esfq_index d = q->max_depth;
|
||||
+ struct sk_buff *skb;
|
||||
+ unsigned int len;
|
||||
+
|
||||
+ /* Queue is full! Find the longest slot and
|
||||
+ drop a packet from it */
|
||||
+
|
||||
+ if (d > 1) {
|
||||
+ esfq_index x = q->dep[d+q->depth].next;
|
||||
+ skb = q->qs[x].prev;
|
||||
+ len = skb->len;
|
||||
+ __skb_unlink(skb, &q->qs[x]);
|
||||
+ kfree_skb(skb);
|
||||
+ esfq_dec(q, x);
|
||||
+ sch->q.qlen--;
|
||||
+ sch->qstats.drops++;
|
||||
+ sch->qstats.backlog -= len;
|
||||
+ return len;
|
||||
+ }
|
||||
+
|
||||
+ if (d == 1) {
|
||||
+ /* It is difficult to believe, but ALL THE SLOTS HAVE LENGTH 1. */
|
||||
+ d = q->next[q->tail];
|
||||
+ q->next[q->tail] = q->next[d];
|
||||
+ q->allot[q->next[d]] += q->quantum;
|
||||
+ skb = q->qs[d].prev;
|
||||
+ len = skb->len;
|
||||
+ __skb_unlink(skb, &q->qs[d]);
|
||||
+ kfree_skb(skb);
|
||||
+ esfq_dec(q, d);
|
||||
+ sch->q.qlen--;
|
||||
+ q->ht[q->hash[d]] = q->depth;
|
||||
+ sch->qstats.drops++;
|
||||
+ sch->qstats.backlog -= len;
|
||||
+ return len;
|
||||
+ }
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static void esfq_q_enqueue(struct sk_buff *skb, struct esfq_sched_data *q, unsigned int end)
|
||||
+{
|
||||
+ unsigned hash = esfq_hash(q, skb);
|
||||
+ unsigned depth = q->depth;
|
||||
+ esfq_index x;
|
||||
+
|
||||
+ x = q->ht[hash];
|
||||
+ if (x == depth) {
|
||||
+ q->ht[hash] = x = q->dep[depth].next;
|
||||
+ q->hash[x] = hash;
|
||||
+ }
|
||||
+
|
||||
+ if (end == ESFQ_TAIL)
|
||||
+ __skb_queue_tail(&q->qs[x], skb);
|
||||
+ else
|
||||
+ __skb_queue_head(&q->qs[x], skb);
|
||||
+
|
||||
+ esfq_inc(q, x);
|
||||
+ if (q->qs[x].qlen == 1) { /* The flow is new */
|
||||
+ if (q->tail == depth) { /* It is the first flow */
|
||||
+ q->tail = x;
|
||||
+ q->next[x] = x;
|
||||
+ q->allot[x] = q->quantum;
|
||||
+ } else {
|
||||
+ q->next[x] = q->next[q->tail];
|
||||
+ q->next[q->tail] = x;
|
||||
+ q->tail = x;
|
||||
+ }
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
+static int esfq_enqueue(struct sk_buff *skb, struct Qdisc* sch)
|
||||
+{
|
||||
+ struct esfq_sched_data *q = qdisc_priv(sch);
|
||||
+ esfq_q_enqueue(skb, q, ESFQ_TAIL);
|
||||
+ sch->qstats.backlog += skb->len;
|
||||
+ if (++sch->q.qlen < q->limit-1) {
|
||||
+ sch->bstats.bytes += skb->len;
|
||||
+ sch->bstats.packets++;
|
||||
+ return 0;
|
||||
+ }
|
||||
+
|
||||
+ sch->qstats.drops++;
|
||||
+ esfq_drop(sch);
|
||||
+ return NET_XMIT_CN;
|
||||
+}
|
||||
+
|
||||
+
|
||||
+static int esfq_requeue(struct sk_buff *skb, struct Qdisc* sch)
|
||||
+{
|
||||
+ struct esfq_sched_data *q = qdisc_priv(sch);
|
||||
+ esfq_q_enqueue(skb, q, ESFQ_HEAD);
|
||||
+ sch->qstats.backlog += skb->len;
|
||||
+ if (++sch->q.qlen < q->limit - 1) {
|
||||
+ sch->qstats.requeues++;
|
||||
+ return 0;
|
||||
+ }
|
||||
+
|
||||
+ sch->qstats.drops++;
|
||||
+ esfq_drop(sch);
|
||||
+ return NET_XMIT_CN;
|
||||
+}
|
||||
+
|
||||
+static struct sk_buff *esfq_q_dequeue(struct esfq_sched_data *q)
|
||||
+{
|
||||
+ struct sk_buff *skb;
|
||||
+ unsigned depth = q->depth;
|
||||
+ esfq_index a, old_a;
|
||||
+
|
||||
+ /* No active slots */
|
||||
+ if (q->tail == depth)
|
||||
+ return NULL;
|
||||
+
|
||||
+ a = old_a = q->next[q->tail];
|
||||
+
|
||||
+ /* Grab packet */
|
||||
+ skb = __skb_dequeue(&q->qs[a]);
|
||||
+ esfq_dec(q, a);
|
||||
+
|
||||
+ /* Is the slot empty? */
|
||||
+ if (q->qs[a].qlen == 0) {
|
||||
+ q->ht[q->hash[a]] = depth;
|
||||
+ a = q->next[a];
|
||||
+ if (a == old_a) {
|
||||
+ q->tail = depth;
|
||||
+ return skb;
|
||||
+ }
|
||||
+ q->next[q->tail] = a;
|
||||
+ q->allot[a] += q->quantum;
|
||||
+ } else if ((q->allot[a] -= skb->len) <= 0) {
|
||||
+ q->tail = a;
|
||||
+ a = q->next[a];
|
||||
+ q->allot[a] += q->quantum;
|
||||
+ }
|
||||
+
|
||||
+ return skb;
|
||||
+}
|
||||
+
|
||||
+static struct sk_buff *esfq_dequeue(struct Qdisc* sch)
|
||||
+{
|
||||
+ struct esfq_sched_data *q = qdisc_priv(sch);
|
||||
+ struct sk_buff *skb;
|
||||
+
|
||||
+ skb = esfq_q_dequeue(q);
|
||||
+ if (skb == NULL)
|
||||
+ return NULL;
|
||||
+ sch->q.qlen--;
|
||||
+ sch->qstats.backlog -= skb->len;
|
||||
+ return skb;
|
||||
+}
|
||||
+
|
||||
+static void esfq_q_destroy(struct esfq_sched_data *q)
|
||||
+{
|
||||
+ del_timer(&q->perturb_timer);
|
||||
+ if(q->ht)
|
||||
+ kfree(q->ht);
|
||||
+ if(q->dep)
|
||||
+ kfree(q->dep);
|
||||
+ if(q->next)
|
||||
+ kfree(q->next);
|
||||
+ if(q->allot)
|
||||
+ kfree(q->allot);
|
||||
+ if(q->hash)
|
||||
+ kfree(q->hash);
|
||||
+ if(q->qs)
|
||||
+ kfree(q->qs);
|
||||
+}
|
||||
+
|
||||
+static void esfq_destroy(struct Qdisc *sch)
|
||||
+{
|
||||
+ struct esfq_sched_data *q = qdisc_priv(sch);
|
||||
+ esfq_q_destroy(q);
|
||||
+}
|
||||
+
|
||||
+
|
||||
+static void esfq_reset(struct Qdisc* sch)
|
||||
+{
|
||||
+ struct sk_buff *skb;
|
||||
+
|
||||
+ while ((skb = esfq_dequeue(sch)) != NULL)
|
||||
+ kfree_skb(skb);
|
||||
+}
|
||||
+
|
||||
+static void esfq_perturbation(unsigned long arg)
|
||||
+{
|
||||
+ struct Qdisc *sch = (struct Qdisc*)arg;
|
||||
+ struct esfq_sched_data *q = qdisc_priv(sch);
|
||||
+
|
||||
+ q->perturbation = net_random()&0x1F;
|
||||
+
|
||||
+ if (q->perturb_period) {
|
||||
+ q->perturb_timer.expires = jiffies + q->perturb_period;
|
||||
+ add_timer(&q->perturb_timer);
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
+static unsigned int esfq_check_hash(unsigned int kind)
|
||||
+{
|
||||
+ switch (kind) {
|
||||
+ case TCA_SFQ_HASH_CTORIGDST:
|
||||
+ case TCA_SFQ_HASH_CTORIGSRC:
|
||||
+ case TCA_SFQ_HASH_CTREPLDST:
|
||||
+ case TCA_SFQ_HASH_CTREPLSRC:
|
||||
+ case TCA_SFQ_HASH_CTNATCHG:
|
||||
+#ifndef CONFIG_NET_SCH_ESFQ_NFCT
|
||||
+ {
|
||||
+ if (net_ratelimit())
|
||||
+ printk(KERN_WARNING "ESFQ: Conntrack hash types disabled in kernel config. Falling back to classic.\n");
|
||||
+ return TCA_SFQ_HASH_CLASSIC;
|
||||
+ }
|
||||
+#endif
|
||||
+ case TCA_SFQ_HASH_CLASSIC:
|
||||
+ case TCA_SFQ_HASH_DST:
|
||||
+ case TCA_SFQ_HASH_SRC:
|
||||
+ case TCA_SFQ_HASH_FWMARK:
|
||||
+ return kind;
|
||||
+ default:
|
||||
+ {
|
||||
+ if (net_ratelimit())
|
||||
+ printk(KERN_WARNING "ESFQ: Unknown hash type. Falling back to classic.\n");
|
||||
+ return TCA_SFQ_HASH_CLASSIC;
|
||||
+ }
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
+static int esfq_q_init(struct esfq_sched_data *q, struct rtattr *opt)
|
||||
+{
|
||||
+ struct tc_esfq_qopt *ctl = RTA_DATA(opt);
|
||||
+ esfq_index p = ~0U/2;
|
||||
+ int i;
|
||||
+
|
||||
+ if (opt && opt->rta_len < RTA_LENGTH(sizeof(*ctl)))
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ q->perturbation = 0;
|
||||
+ q->hash_kind = TCA_SFQ_HASH_CLASSIC;
|
||||
+ q->max_depth = 0;
|
||||
+ if (opt == NULL) {
|
||||
+ q->perturb_period = 0;
|
||||
+ q->hash_divisor = 1024;
|
||||
+ q->tail = q->limit = q->depth = 128;
|
||||
+
|
||||
+ } else {
|
||||
+ struct tc_esfq_qopt *ctl = RTA_DATA(opt);
|
||||
+ if (ctl->quantum)
|
||||
+ q->quantum = ctl->quantum;
|
||||
+ q->perturb_period = ctl->perturb_period*HZ;
|
||||
+ q->hash_divisor = ctl->divisor ? : 1024;
|
||||
+ q->tail = q->limit = q->depth = ctl->flows ? : 128;
|
||||
+
|
||||
+ if ( q->depth > p - 1 )
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ if (ctl->limit)
|
||||
+ q->limit = min_t(u32, ctl->limit, q->depth);
|
||||
+
|
||||
+ if (ctl->hash_kind) {
|
||||
+ q->hash_kind = esfq_check_hash(ctl->hash_kind);
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
+ q->ht = kmalloc(q->hash_divisor*sizeof(esfq_index), GFP_KERNEL);
|
||||
+ if (!q->ht)
|
||||
+ goto err_case;
|
||||
+ q->dep = kmalloc((1+q->depth*2)*sizeof(struct esfq_head), GFP_KERNEL);
|
||||
+ if (!q->dep)
|
||||
+ goto err_case;
|
||||
+ q->next = kmalloc(q->depth*sizeof(esfq_index), GFP_KERNEL);
|
||||
+ if (!q->next)
|
||||
+ goto err_case;
|
||||
+ q->allot = kmalloc(q->depth*sizeof(short), GFP_KERNEL);
|
||||
+ if (!q->allot)
|
||||
+ goto err_case;
|
||||
+ q->hash = kmalloc(q->depth*sizeof(unsigned short), GFP_KERNEL);
|
||||
+ if (!q->hash)
|
||||
+ goto err_case;
|
||||
+ q->qs = kmalloc(q->depth*sizeof(struct sk_buff_head), GFP_KERNEL);
|
||||
+ if (!q->qs)
|
||||
+ goto err_case;
|
||||
+
|
||||
+ for (i=0; i< q->hash_divisor; i++)
|
||||
+ q->ht[i] = q->depth;
|
||||
+ for (i=0; i<q->depth; i++) {
|
||||
+ skb_queue_head_init(&q->qs[i]);
|
||||
+ q->dep[i+q->depth].next = i+q->depth;
|
||||
+ q->dep[i+q->depth].prev = i+q->depth;
|
||||
+ }
|
||||
+
|
||||
+ for (i=0; i<q->depth; i++)
|
||||
+ esfq_link(q, i);
|
||||
+ return 0;
|
||||
+err_case:
|
||||
+ esfq_q_destroy(q);
|
||||
+ return -ENOBUFS;
|
||||
+}
|
||||
+
|
||||
+static int esfq_init(struct Qdisc *sch, struct rtattr *opt)
|
||||
+{
|
||||
+ struct esfq_sched_data *q = qdisc_priv(sch);
|
||||
+ int err;
|
||||
+
|
||||
+ q->quantum = psched_mtu(sch->dev); /* default */
|
||||
+ if ((err = esfq_q_init(q, opt)))
|
||||
+ return err;
|
||||
+
|
||||
+ init_timer(&q->perturb_timer);
|
||||
+ q->perturb_timer.data = (unsigned long)sch;
|
||||
+ q->perturb_timer.function = esfq_perturbation;
|
||||
+ if (q->perturb_period) {
|
||||
+ q->perturb_timer.expires = jiffies + q->perturb_period;
|
||||
+ add_timer(&q->perturb_timer);
|
||||
+ }
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static int esfq_change(struct Qdisc *sch, struct rtattr *opt)
|
||||
+{
|
||||
+ struct esfq_sched_data *q = qdisc_priv(sch);
|
||||
+ struct esfq_sched_data new;
|
||||
+ struct sk_buff *skb;
|
||||
+ int err;
|
||||
+
|
||||
+ /* set up new queue */
|
||||
+ memset(&new, 0, sizeof(struct esfq_sched_data));
|
||||
+ new.quantum = psched_mtu(sch->dev); /* default */
|
||||
+ if ((err = esfq_q_init(&new, opt)))
|
||||
+ return err;
|
||||
+
|
||||
+ /* copy all packets from the old queue to the new queue */
|
||||
+ sch_tree_lock(sch);
|
||||
+ while ((skb = esfq_q_dequeue(q)) != NULL)
|
||||
+ esfq_q_enqueue(skb, &new, ESFQ_TAIL);
|
||||
+
|
||||
+ /* clean up the old queue */
|
||||
+ esfq_q_destroy(q);
|
||||
+
|
||||
+ /* copy elements of the new queue into the old queue */
|
||||
+ q->perturb_period = new.perturb_period;
|
||||
+ q->quantum = new.quantum;
|
||||
+ q->limit = new.limit;
|
||||
+ q->depth = new.depth;
|
||||
+ q->hash_divisor = new.hash_divisor;
|
||||
+ q->hash_kind = new.hash_kind;
|
||||
+ q->tail = new.tail;
|
||||
+ q->max_depth = new.max_depth;
|
||||
+ q->ht = new.ht;
|
||||
+ q->dep = new.dep;
|
||||
+ q->next = new.next;
|
||||
+ q->allot = new.allot;
|
||||
+ q->hash = new.hash;
|
||||
+ q->qs = new.qs;
|
||||
+
|
||||
+ /* finish up */
|
||||
+ if (q->perturb_period) {
|
||||
+ q->perturb_timer.expires = jiffies + q->perturb_period;
|
||||
+ add_timer(&q->perturb_timer);
|
||||
+ } else {
|
||||
+ q->perturbation = 0;
|
||||
+ }
|
||||
+ sch_tree_unlock(sch);
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static int esfq_dump(struct Qdisc *sch, struct sk_buff *skb)
|
||||
+{
|
||||
+ struct esfq_sched_data *q = qdisc_priv(sch);
|
||||
+ unsigned char *b = skb->tail;
|
||||
+ struct tc_esfq_qopt opt;
|
||||
+
|
||||
+ opt.quantum = q->quantum;
|
||||
+ opt.perturb_period = q->perturb_period/HZ;
|
||||
+
|
||||
+ opt.limit = q->limit;
|
||||
+ opt.divisor = q->hash_divisor;
|
||||
+ opt.flows = q->depth;
|
||||
+ opt.hash_kind = q->hash_kind;
|
||||
+
|
||||
+ RTA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
|
||||
+
|
||||
+ return skb->len;
|
||||
+
|
||||
+rtattr_failure:
|
||||
+ skb_trim(skb, b - skb->data);
|
||||
+ return -1;
|
||||
+}
|
||||
+
|
||||
+static struct Qdisc_ops esfq_qdisc_ops =
|
||||
+{
|
||||
+ .next = NULL,
|
||||
+ .cl_ops = NULL,
|
||||
+ .id = "esfq",
|
||||
+ .priv_size = sizeof(struct esfq_sched_data),
|
||||
+ .enqueue = esfq_enqueue,
|
||||
+ .dequeue = esfq_dequeue,
|
||||
+ .requeue = esfq_requeue,
|
||||
+ .drop = esfq_drop,
|
||||
+ .init = esfq_init,
|
||||
+ .reset = esfq_reset,
|
||||
+ .destroy = esfq_destroy,
|
||||
+ .change = esfq_change,
|
||||
+ .dump = esfq_dump,
|
||||
+ .owner = THIS_MODULE,
|
||||
+};
|
||||
+
|
||||
+static int __init esfq_module_init(void)
|
||||
+{
|
||||
+ return register_qdisc(&esfq_qdisc_ops);
|
||||
+}
|
||||
+static void __exit esfq_module_exit(void)
|
||||
+{
|
||||
+ unregister_qdisc(&esfq_qdisc_ops);
|
||||
+}
|
||||
+module_init(esfq_module_init)
|
||||
+module_exit(esfq_module_exit)
|
||||
+MODULE_LICENSE("GPL");
|
|
@ -1,56 +0,0 @@
|
|||
--- a/fs/jffs2/build.c
|
||||
+++ b/fs/jffs2/build.c
|
||||
@@ -105,6 +105,17 @@ static int jffs2_build_filesystem(struct
|
||||
dbg_fsbuild("scanned flash completely\n");
|
||||
jffs2_dbg_dump_block_lists_nolock(c);
|
||||
|
||||
+ if (c->flags & (1 << 7)) {
|
||||
+ printk("%s(): unlocking the mtd device... ", __func__);
|
||||
+ if (c->mtd->unlock)
|
||||
+ c->mtd->unlock(c->mtd, 0, c->mtd->size);
|
||||
+ printk("done.\n");
|
||||
+
|
||||
+ printk("%s(): erasing all blocks after the end marker... ", __func__);
|
||||
+ jffs2_erase_pending_blocks(c, -1);
|
||||
+ printk("done.\n");
|
||||
+ }
|
||||
+
|
||||
dbg_fsbuild("pass 1 starting\n");
|
||||
c->flags |= JFFS2_SB_FLAG_BUILDING;
|
||||
/* Now scan the directory tree, increasing nlink according to every dirent found. */
|
||||
--- a/fs/jffs2/scan.c
|
||||
+++ b/fs/jffs2/scan.c
|
||||
@@ -142,9 +142,12 @@ int jffs2_scan_medium(struct jffs2_sb_in
|
||||
|
||||
/* reset summary info for next eraseblock scan */
|
||||
jffs2_sum_reset_collected(s);
|
||||
-
|
||||
- ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset),
|
||||
- buf_size, s);
|
||||
+
|
||||
+ if (c->flags & (1 << 7))
|
||||
+ ret = BLK_STATE_ALLFF;
|
||||
+ else
|
||||
+ ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset),
|
||||
+ buf_size, s);
|
||||
|
||||
if (ret < 0)
|
||||
goto out;
|
||||
@@ -545,6 +548,17 @@ static int jffs2_scan_eraseblock (struct
|
||||
return err;
|
||||
}
|
||||
|
||||
+ if ((buf[0] == 0xde) &&
|
||||
+ (buf[1] == 0xad) &&
|
||||
+ (buf[2] == 0xc0) &&
|
||||
+ (buf[3] == 0xde)) {
|
||||
+ /* end of filesystem. erase everything after this point */
|
||||
+ printk("%s(): End of filesystem marker found at 0x%x\n", __func__, jeb->offset);
|
||||
+ c->flags |= (1 << 7);
|
||||
+
|
||||
+ return BLK_STATE_ALLFF;
|
||||
+ }
|
||||
+
|
||||
/* We temporarily use 'ofs' as a pointer into the buffer/jeb */
|
||||
ofs = 0;
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
--- /dev/null
|
||||
+++ b/include/asm-powerpc/segment.h
|
||||
@@ -0,0 +1,6 @@
|
||||
+#ifndef _ASM_SEGMENT_H
|
||||
+#define _ASM_SEGMENT_H
|
||||
+
|
||||
+/* Only here because we have some old header files that expect it.. */
|
||||
+
|
||||
+#endif /* _ASM_SEGMENT_H */
|
|
@ -1,42 +0,0 @@
|
|||
--- a/drivers/net/r8169.c
|
||||
+++ b/drivers/net/r8169.c
|
||||
@@ -1539,7 +1539,7 @@ static const struct rtl_cfg_info {
|
||||
.hw_start = rtl_hw_start_8169,
|
||||
.region = 1,
|
||||
.align = 0,
|
||||
- .intr_event = SYSErr | LinkChg | RxOverflow |
|
||||
+ .intr_event = LinkChg | RxOverflow |
|
||||
RxFIFOOver | TxErr | TxOK | RxOK | RxErr,
|
||||
.napi_event = RxFIFOOver | TxErr | TxOK | RxOK | RxOverflow,
|
||||
.msi = 0
|
||||
@@ -1548,7 +1548,7 @@ static const struct rtl_cfg_info {
|
||||
.hw_start = rtl_hw_start_8168,
|
||||
.region = 2,
|
||||
.align = 8,
|
||||
- .intr_event = SYSErr | LinkChg | RxOverflow |
|
||||
+ .intr_event = LinkChg | RxOverflow |
|
||||
TxErr | TxOK | RxOK | RxErr,
|
||||
.napi_event = TxErr | TxOK | RxOK | RxOverflow,
|
||||
.msi = RTL_FEATURE_MSI
|
||||
@@ -1557,7 +1557,7 @@ static const struct rtl_cfg_info {
|
||||
.hw_start = rtl_hw_start_8101,
|
||||
.region = 2,
|
||||
.align = 8,
|
||||
- .intr_event = SYSErr | LinkChg | RxOverflow | PCSTimeout |
|
||||
+ .intr_event = LinkChg | RxOverflow | PCSTimeout |
|
||||
RxFIFOOver | TxErr | TxOK | RxOK | RxErr,
|
||||
.napi_event = RxFIFOOver | TxErr | TxOK | RxOK | RxOverflow,
|
||||
.msi = RTL_FEATURE_MSI
|
||||
@@ -2905,10 +2905,12 @@ static irqreturn_t rtl8169_interrupt(int
|
||||
break;
|
||||
}
|
||||
|
||||
+#if 0
|
||||
if (unlikely(status & SYSErr)) {
|
||||
rtl8169_pcierr_interrupt(dev);
|
||||
break;
|
||||
}
|
||||
+#endif
|
||||
|
||||
if (status & LinkChg)
|
||||
rtl8169_check_link_status(dev, tp, ioaddr);
|
File diff suppressed because it is too large
Load diff
|
@ -1,143 +0,0 @@
|
|||
--- a/fs/mini_fo/main.c
|
||||
+++ b/fs/mini_fo/main.c
|
||||
@@ -79,6 +79,7 @@ mini_fo_tri_interpose(dentry_t *hidden_d
|
||||
* of the new inode's fields
|
||||
*/
|
||||
|
||||
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
|
||||
/*
|
||||
* original: inode = iget(sb, hidden_inode->i_ino);
|
||||
*/
|
||||
@@ -87,6 +88,13 @@ mini_fo_tri_interpose(dentry_t *hidden_d
|
||||
err = -EACCES; /* should be impossible??? */
|
||||
goto out;
|
||||
}
|
||||
+#else
|
||||
+ inode = mini_fo_iget(sb, iunique(sb, 25));
|
||||
+ if (IS_ERR(inode)) {
|
||||
+ err = PTR_ERR(inode);
|
||||
+ goto out;
|
||||
+ }
|
||||
+#endif
|
||||
|
||||
/*
|
||||
* interpose the inode if not already interposed
|
||||
@@ -184,9 +192,9 @@ mini_fo_parse_options(super_block_t *sb,
|
||||
hidden_root = ERR_PTR(err);
|
||||
goto out;
|
||||
}
|
||||
- hidden_root = nd.dentry;
|
||||
- stopd(sb)->base_dir_dentry = nd.dentry;
|
||||
- stopd(sb)->hidden_mnt = nd.mnt;
|
||||
+ hidden_root = nd_get_dentry(&nd);
|
||||
+ stopd(sb)->base_dir_dentry = nd_get_dentry(&nd);
|
||||
+ stopd(sb)->hidden_mnt = nd_get_mnt(&nd);
|
||||
|
||||
} else if(!strncmp("sto=", options, 4)) {
|
||||
/* parse the storage dir */
|
||||
@@ -204,9 +212,9 @@ mini_fo_parse_options(super_block_t *sb,
|
||||
hidden_root2 = ERR_PTR(err);
|
||||
goto out;
|
||||
}
|
||||
- hidden_root2 = nd2.dentry;
|
||||
- stopd(sb)->storage_dir_dentry = nd2.dentry;
|
||||
- stopd(sb)->hidden_mnt2 = nd2.mnt;
|
||||
+ hidden_root2 = nd_get_dentry(&nd2);
|
||||
+ stopd(sb)->storage_dir_dentry = nd_get_dentry(&nd2);
|
||||
+ stopd(sb)->hidden_mnt2 = nd_get_mnt(&nd2);
|
||||
stohs2(sb) = hidden_root2->d_sb;
|
||||
|
||||
/* validate storage dir, this is done in
|
||||
--- a/fs/mini_fo/mini_fo.h
|
||||
+++ b/fs/mini_fo/mini_fo.h
|
||||
@@ -302,6 +302,10 @@ extern int mini_fo_tri_interpose(dentry_
|
||||
extern int mini_fo_cp_cont(dentry_t *tgt_dentry, struct vfsmount *tgt_mnt,
|
||||
dentry_t *src_dentry, struct vfsmount *src_mnt);
|
||||
|
||||
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
|
||||
+extern struct inode *mini_fo_iget(struct super_block *sb, unsigned long ino);
|
||||
+#endif
|
||||
+
|
||||
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
|
||||
extern int mini_fo_create(inode_t *dir, dentry_t *dentry, int mode, struct nameidata *nd);
|
||||
|
||||
@@ -501,6 +505,29 @@ static inline void double_unlock(struct
|
||||
#endif /* if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) */
|
||||
#endif /* __KERNEL__ */
|
||||
|
||||
+
|
||||
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
|
||||
+static inline dentry_t *nd_get_dentry(struct nameidata *nd)
|
||||
+{
|
||||
+ return (nd->path.dentry);
|
||||
+}
|
||||
+
|
||||
+static inline struct vfsmount *nd_get_mnt(struct nameidata *nd)
|
||||
+{
|
||||
+ return (nd->path.mnt);
|
||||
+}
|
||||
+#else
|
||||
+static inline dentry_t *nd_get_dentry(struct nameidata *nd)
|
||||
+{
|
||||
+ return (nd->dentry);
|
||||
+}
|
||||
+
|
||||
+static inline struct vfsmount *nd_get_mnt(struct nameidata *nd)
|
||||
+{
|
||||
+ return (nd->mnt);
|
||||
+}
|
||||
+#endif
|
||||
+
|
||||
/*
|
||||
* Definitions for user and kernel code
|
||||
*/
|
||||
--- a/fs/mini_fo/super.c
|
||||
+++ b/fs/mini_fo/super.c
|
||||
@@ -262,10 +262,31 @@ mini_fo_umount_begin(super_block_t *sb)
|
||||
}
|
||||
#endif
|
||||
|
||||
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
|
||||
+struct inode *
|
||||
+mini_fo_iget(struct super_block *sb, unsigned long ino)
|
||||
+{
|
||||
+ struct inode *inode;
|
||||
+
|
||||
+ inode = iget_locked(sb, ino);
|
||||
+ if (!inode)
|
||||
+ return ERR_PTR(-ENOMEM);
|
||||
+
|
||||
+ if (!(inode->i_state & I_NEW))
|
||||
+ return inode;
|
||||
+
|
||||
+ mini_fo_read_inode(inode);
|
||||
+
|
||||
+ unlock_new_inode(inode);
|
||||
+ return inode;
|
||||
+}
|
||||
+#endif /* if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25) */
|
||||
|
||||
struct super_operations mini_fo_sops =
|
||||
{
|
||||
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
|
||||
read_inode: mini_fo_read_inode,
|
||||
+#endif
|
||||
#if defined(FIST_DEBUG) || defined(FIST_FILTER_SCA)
|
||||
write_inode: mini_fo_write_inode,
|
||||
#endif /* defined(FIST_DEBUG) || defined(FIST_FILTER_SCA) */
|
||||
--- a/fs/mini_fo/aux.c
|
||||
+++ b/fs/mini_fo/aux.c
|
||||
@@ -164,11 +164,11 @@ dentry_t *bpath_walk(super_block_t *sb,
|
||||
err = vfs_path_lookup(mnt->mnt_root, mnt, bpath+1, 0, &nd);
|
||||
|
||||
/* validate */
|
||||
- if (err || !nd.dentry || !nd.dentry->d_inode) {
|
||||
+ if (err || !nd_get_dentry(&nd) || !nd_get_dentry(&nd)->d_inode) {
|
||||
printk(KERN_CRIT "mini_fo: bpath_walk: path_walk failed.\n");
|
||||
return NULL;
|
||||
}
|
||||
- return nd.dentry;
|
||||
+ return nd_get_dentry(&nd);
|
||||
}
|
||||
|
||||
|
|
@ -1,66 +0,0 @@
|
|||
--- a/fs/mini_fo/meta.c
|
||||
+++ b/fs/mini_fo/meta.c
|
||||
@@ -442,6 +442,11 @@ int meta_write_d_entry(dentry_t *dentry,
|
||||
S_IRUSR | S_IWUSR);
|
||||
#endif
|
||||
}
|
||||
+
|
||||
+ /* $%& err, is this correct? */
|
||||
+ meta_mnt = stopd(dentry->d_inode->i_sb)->hidden_mnt2;
|
||||
+ mntget(meta_mnt);
|
||||
+
|
||||
/* open META-file for writing */
|
||||
meta_file = dentry_open(meta_dentry, meta_mnt, 0x1);
|
||||
if(!meta_file || IS_ERR(meta_file)) {
|
||||
@@ -535,6 +540,11 @@ int meta_write_r_entry(dentry_t *dentry,
|
||||
meta_dentry, S_IRUSR | S_IWUSR);
|
||||
#endif
|
||||
}
|
||||
+
|
||||
+ /* $%& err, is this correct? */
|
||||
+ meta_mnt = stopd(dentry->d_inode->i_sb)->hidden_mnt2;
|
||||
+ mntget(meta_mnt);
|
||||
+
|
||||
/* open META-file for writing */
|
||||
meta_file = dentry_open(meta_dentry, meta_mnt, 0x1);
|
||||
if(!meta_file || IS_ERR(meta_file)) {
|
||||
@@ -671,14 +681,16 @@ int meta_sync_d_list(dentry_t *dentry, i
|
||||
}
|
||||
}
|
||||
|
||||
+ /* $%& err, is this correct? */
|
||||
+ meta_mnt = stopd(dentry->d_inode->i_sb)->hidden_mnt2;
|
||||
+ mntget(meta_mnt);
|
||||
+
|
||||
/* open META-file for writing */
|
||||
meta_file = dentry_open(meta_dentry, meta_mnt, 0x1);
|
||||
if(!meta_file || IS_ERR(meta_file)) {
|
||||
printk(KERN_CRIT "mini_fo: meta_sync_d_list: \
|
||||
ERROR opening meta file.\n");
|
||||
- /* we don't mntget so we dont't mntput (for now)
|
||||
- * mntput(meta_mnt);
|
||||
- */
|
||||
+ mntput(meta_mnt);
|
||||
dput(meta_dentry);
|
||||
err = -1;
|
||||
goto out;
|
||||
@@ -811,14 +823,16 @@ int meta_sync_r_list(dentry_t *dentry, i
|
||||
}
|
||||
}
|
||||
|
||||
+ /* $%& err, is this correct? */
|
||||
+ meta_mnt = stopd(dentry->d_inode->i_sb)->hidden_mnt2;
|
||||
+ mntget(meta_mnt);
|
||||
+
|
||||
/* open META-file for writing */
|
||||
meta_file = dentry_open(meta_dentry, meta_mnt, 0x1);
|
||||
if(!meta_file || IS_ERR(meta_file)) {
|
||||
printk(KERN_CRIT "mini_fo: meta_sync_r_list: \
|
||||
ERROR opening meta file.\n");
|
||||
- /* we don't mntget so we dont't mntput (for now)
|
||||
- * mntput(meta_mnt);
|
||||
- */
|
||||
+ mntput(meta_mnt);
|
||||
dput(meta_dentry);
|
||||
err = -1;
|
||||
goto out;
|
|
@ -1,42 +0,0 @@
|
|||
--- a/lib/kobject_uevent.c
|
||||
+++ b/lib/kobject_uevent.c
|
||||
@@ -27,7 +27,8 @@ u64 uevent_seqnum;
|
||||
char uevent_helper[UEVENT_HELPER_PATH_LEN] = CONFIG_UEVENT_HELPER_PATH;
|
||||
static DEFINE_SPINLOCK(sequence_lock);
|
||||
#if defined(CONFIG_NET)
|
||||
-static struct sock *uevent_sock;
|
||||
+struct sock *uevent_sock = NULL;
|
||||
+EXPORT_SYMBOL_GPL(uevent_sock);
|
||||
#endif
|
||||
|
||||
/* the strings here must match the enum in include/linux/kobject.h */
|
||||
@@ -40,6 +41,18 @@ static const char *kobject_actions[] = {
|
||||
[KOBJ_OFFLINE] = "offline",
|
||||
};
|
||||
|
||||
+u64 uevent_next_seqnum(void)
|
||||
+{
|
||||
+ u64 seq;
|
||||
+
|
||||
+ spin_lock(&sequence_lock);
|
||||
+ seq = ++uevent_seqnum;
|
||||
+ spin_unlock(&sequence_lock);
|
||||
+
|
||||
+ return seq;
|
||||
+}
|
||||
+EXPORT_SYMBOL_GPL(uevent_next_seqnum);
|
||||
+
|
||||
/**
|
||||
* kobject_action_type - translate action string to numeric type
|
||||
*
|
||||
@@ -192,9 +205,7 @@ int kobject_uevent_env(struct kobject *k
|
||||
kobj->state_remove_uevent_sent = 1;
|
||||
|
||||
/* we will send an event, so request a new sequence number */
|
||||
- spin_lock(&sequence_lock);
|
||||
- seq = ++uevent_seqnum;
|
||||
- spin_unlock(&sequence_lock);
|
||||
+ seq = uevent_next_seqnum();
|
||||
retval = add_uevent_var(env, "SEQNUM=%llu", (unsigned long long)seq);
|
||||
if (retval)
|
||||
goto exit;
|
|
@ -1,11 +0,0 @@
|
|||
--- a/sound/core/Kconfig
|
||||
+++ b/sound/core/Kconfig
|
||||
@@ -9,7 +9,7 @@ config SND_PCM
|
||||
depends on SND
|
||||
|
||||
config SND_HWDEP
|
||||
- tristate
|
||||
+ tristate "Sound hardware support"
|
||||
depends on SND
|
||||
|
||||
config SND_RAWMIDI
|
|
@ -1,29 +0,0 @@
|
|||
--- a/scripts/unifdef.c
|
||||
+++ b/scripts/unifdef.c
|
||||
@@ -206,7 +206,7 @@ static void done(void);
|
||||
static void error(const char *);
|
||||
static int findsym(const char *);
|
||||
static void flushline(bool);
|
||||
-static Linetype getline(void);
|
||||
+static Linetype get_line(void);
|
||||
static Linetype ifeval(const char **);
|
||||
static void ignoreoff(void);
|
||||
static void ignoreon(void);
|
||||
@@ -512,7 +512,7 @@ process(void)
|
||||
|
||||
for (;;) {
|
||||
linenum++;
|
||||
- lineval = getline();
|
||||
+ lineval = get_line();
|
||||
trans_table[ifstate[depth]][lineval]();
|
||||
debug("process %s -> %s depth %d",
|
||||
linetype_name[lineval],
|
||||
@@ -526,7 +526,7 @@ process(void)
|
||||
* help from skipcomment().
|
||||
*/
|
||||
static Linetype
|
||||
-getline(void)
|
||||
+get_line(void)
|
||||
{
|
||||
const char *cp;
|
||||
int cursym;
|
|
@ -1,18 +0,0 @@
|
|||
--- a/drivers/leds/Kconfig
|
||||
+++ b/drivers/leds/Kconfig
|
||||
@@ -181,4 +181,8 @@ config LEDS_TRIGGER_HEARTBEAT
|
||||
load average.
|
||||
If unsure, say Y.
|
||||
|
||||
+config LEDS_TRIGGER_MORSE
|
||||
+ tristate "LED Morse Trigger"
|
||||
+ depends on LEDS_TRIGGERS
|
||||
+
|
||||
endif # NEW_LEDS
|
||||
--- a/drivers/leds/Makefile
|
||||
+++ b/drivers/leds/Makefile
|
||||
@@ -26,3 +26,4 @@ obj-$(CONFIG_LEDS_HP6XX) += leds-hp6xx.
|
||||
obj-$(CONFIG_LEDS_TRIGGER_TIMER) += ledtrig-timer.o
|
||||
obj-$(CONFIG_LEDS_TRIGGER_IDE_DISK) += ledtrig-ide-disk.o
|
||||
obj-$(CONFIG_LEDS_TRIGGER_HEARTBEAT) += ledtrig-heartbeat.o
|
||||
+obj-$(CONFIG_LEDS_TRIGGER_MORSE) += ledtrig-morse.o
|
|
@ -1,21 +0,0 @@
|
|||
--- a/drivers/leds/Kconfig
|
||||
+++ b/drivers/leds/Kconfig
|
||||
@@ -185,4 +185,11 @@ config LEDS_TRIGGER_MORSE
|
||||
tristate "LED Morse Trigger"
|
||||
depends on LEDS_TRIGGERS
|
||||
|
||||
+config LEDS_TRIGGER_DEFAULT_ON
|
||||
+ tristate "LED Default ON Trigger"
|
||||
+ depends on LEDS_TRIGGERS
|
||||
+ help
|
||||
+ This allows LEDs to be initialised in the ON state.
|
||||
+ If unsure, say Y.
|
||||
+
|
||||
endif # NEW_LEDS
|
||||
--- a/drivers/leds/Makefile
|
||||
+++ b/drivers/leds/Makefile
|
||||
@@ -27,3 +27,4 @@ obj-$(CONFIG_LEDS_TRIGGER_TIMER) += ledt
|
||||
obj-$(CONFIG_LEDS_TRIGGER_IDE_DISK) += ledtrig-ide-disk.o
|
||||
obj-$(CONFIG_LEDS_TRIGGER_HEARTBEAT) += ledtrig-heartbeat.o
|
||||
obj-$(CONFIG_LEDS_TRIGGER_MORSE) += ledtrig-morse.o
|
||||
+obj-$(CONFIG_LEDS_TRIGGER_DEFAULT_ON) += ledtrig-default-on.o
|
|
@ -1,16 +0,0 @@
|
|||
--- a/drivers/rtc/rtc-ds1672.c
|
||||
+++ b/drivers/rtc/rtc-ds1672.c
|
||||
@@ -13,10 +13,10 @@
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/rtc.h>
|
||||
|
||||
-#define DRV_VERSION "0.3"
|
||||
+#define DRV_VERSION "0.4"
|
||||
|
||||
-/* Addresses to scan: none. This chip cannot be detected. */
|
||||
-static const unsigned short normal_i2c[] = { I2C_CLIENT_END };
|
||||
+/* Addresses to scan: 0x68 */
|
||||
+static const unsigned short normal_i2c[] = { 0x68, I2C_CLIENT_END };
|
||||
|
||||
/* Insmod parameters */
|
||||
I2C_CLIENT_INSMOD;
|
|
@ -1,30 +0,0 @@
|
|||
--- a/drivers/input/misc/Kconfig
|
||||
+++ b/drivers/input/misc/Kconfig
|
||||
@@ -197,4 +197,20 @@ config HP_SDC_RTC
|
||||
Say Y here if you want to support the built-in real time clock
|
||||
of the HP SDC controller.
|
||||
|
||||
+config INPUT_GPIO_BUTTONS
|
||||
+ tristate "Polled GPIO buttons interface"
|
||||
+ depends on GENERIC_GPIO
|
||||
+ select INPUT_POLLDEV
|
||||
+ help
|
||||
+ This driver implements support for buttons connected
|
||||
+ to GPIO pins of various CPUs (and some other chips).
|
||||
+
|
||||
+ Say Y here if your device has buttons connected
|
||||
+ directly to such GPIO pins. Your board-specific
|
||||
+ setup logic must also provide a platform device,
|
||||
+ with configuration data saying which GPIOs are used.
|
||||
+
|
||||
+ To compile this driver as a module, choose M here: the
|
||||
+ module will be called gpio-buttons.
|
||||
+
|
||||
endif
|
||||
--- a/drivers/input/misc/Makefile
|
||||
+++ b/drivers/input/misc/Makefile
|
||||
@@ -19,3 +19,4 @@ obj-$(CONFIG_INPUT_YEALINK) += yealink.
|
||||
obj-$(CONFIG_HP_SDC_RTC) += hp_sdc_rtc.o
|
||||
obj-$(CONFIG_INPUT_UINPUT) += uinput.o
|
||||
obj-$(CONFIG_INPUT_APANEL) += apanel.o
|
||||
+obj-$(CONFIG_INPUT_GPIO_BUTTONS) += gpio_buttons.o
|
|
@ -1,26 +0,0 @@
|
|||
--- a/drivers/char/Kconfig
|
||||
+++ b/drivers/char/Kconfig
|
||||
@@ -955,6 +955,13 @@ config CS5535_GPIO
|
||||
|
||||
If compiled as a module, it will be called cs5535_gpio.
|
||||
|
||||
+config GPIO_DEVICE
|
||||
+ tristate "GPIO device support"
|
||||
+ depends on GENERIC_GPIO
|
||||
+ help
|
||||
+ Say Y to enable Linux GPIO device support. This allows control of
|
||||
+ GPIO pins using a character device
|
||||
+
|
||||
config GPIO_VR41XX
|
||||
tristate "NEC VR4100 series General-purpose I/O Unit support"
|
||||
depends on CPU_VR41XX
|
||||
--- a/drivers/char/Makefile
|
||||
+++ b/drivers/char/Makefile
|
||||
@@ -94,6 +94,7 @@ obj-$(CONFIG_SCx200_GPIO) += scx200_gpio
|
||||
obj-$(CONFIG_PC8736x_GPIO) += pc8736x_gpio.o
|
||||
obj-$(CONFIG_NSC_GPIO) += nsc_gpio.o
|
||||
obj-$(CONFIG_CS5535_GPIO) += cs5535_gpio.o
|
||||
+obj-$(CONFIG_GPIO_DEVICE) += gpio_dev.o
|
||||
obj-$(CONFIG_GPIO_VR41XX) += vr41xx_giu.o
|
||||
obj-$(CONFIG_GPIO_TB0219) += tb0219.o
|
||||
obj-$(CONFIG_TELCLOCK) += tlclk.o
|
|
@ -1,17 +0,0 @@
|
|||
--- a/fs/Kconfig
|
||||
+++ b/fs/Kconfig
|
||||
@@ -421,6 +421,7 @@ config FS_POSIX_ACL
|
||||
|
||||
source "fs/xfs/Kconfig"
|
||||
source "fs/gfs2/Kconfig"
|
||||
+source "fs/yaffs2/Kconfig"
|
||||
|
||||
config OCFS2_FS
|
||||
tristate "OCFS2 file system support"
|
||||
--- a/fs/Makefile
|
||||
+++ b/fs/Makefile
|
||||
@@ -121,3 +121,4 @@ obj-$(CONFIG_HPPFS) += hppfs/
|
||||
obj-$(CONFIG_DEBUG_FS) += debugfs/
|
||||
obj-$(CONFIG_OCFS2_FS) += ocfs2/
|
||||
obj-$(CONFIG_GFS2_FS) += gfs2/
|
||||
+obj-$(CONFIG_YAFFS_FS) += yaffs2/
|
|
@ -1,92 +0,0 @@
|
|||
--- a/fs/yaffs2/yaffs_fs.c
|
||||
+++ b/fs/yaffs2/yaffs_fs.c
|
||||
@@ -181,7 +181,13 @@ static int yaffs_statfs(struct super_blo
|
||||
#else
|
||||
static int yaffs_statfs(struct super_block *sb, struct statfs *buf);
|
||||
#endif
|
||||
+
|
||||
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25))
|
||||
+static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino);
|
||||
+#else
|
||||
static void yaffs_read_inode(struct inode *inode);
|
||||
+#endif
|
||||
+
|
||||
|
||||
static void yaffs_put_inode(struct inode *inode);
|
||||
static void yaffs_delete_inode(struct inode *);
|
||||
@@ -284,7 +290,9 @@ static struct file_operations yaffs_dir_
|
||||
|
||||
static struct super_operations yaffs_super_ops = {
|
||||
.statfs = yaffs_statfs,
|
||||
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25))
|
||||
.read_inode = yaffs_read_inode,
|
||||
+#endif
|
||||
.put_inode = yaffs_put_inode,
|
||||
.put_super = yaffs_put_super,
|
||||
.delete_inode = yaffs_delete_inode,
|
||||
@@ -844,11 +852,17 @@ struct inode *yaffs_get_inode(struct sup
|
||||
T(YAFFS_TRACE_OS,
|
||||
(KERN_DEBUG "yaffs_get_inode for object %d\n", obj->objectId));
|
||||
|
||||
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25))
|
||||
+ inode = yaffs_iget(sb, obj->objectId);
|
||||
+ if (IS_ERR(inode))
|
||||
+ return NULL;
|
||||
+#else
|
||||
inode = iget(sb, obj->objectId);
|
||||
|
||||
/* NB Side effect: iget calls back to yaffs_read_inode(). */
|
||||
/* iget also increments the inode's i_count */
|
||||
/* NB You can't be holding grossLock or deadlock will happen! */
|
||||
+#endif
|
||||
|
||||
return inode;
|
||||
}
|
||||
@@ -1427,6 +1441,39 @@ static int yaffs_sync_fs(struct super_bl
|
||||
}
|
||||
|
||||
|
||||
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25))
|
||||
+static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino)
|
||||
+{
|
||||
+ yaffs_Object *obj;
|
||||
+ yaffs_Device *dev = yaffs_SuperToDevice(sb);
|
||||
+ struct inode *inode;
|
||||
+
|
||||
+ T(YAFFS_TRACE_OS,
|
||||
+ (KERN_DEBUG "yaffs_iget for %lu\n", ino));
|
||||
+
|
||||
+ inode = iget_locked(sb, ino);
|
||||
+ if (!inode)
|
||||
+ return ERR_PTR(-ENOMEM);
|
||||
+ if (!(inode->i_state & I_NEW))
|
||||
+ return inode;
|
||||
+
|
||||
+ /* NB This is called as a side effect of other functions, but
|
||||
+ * we had to release the lock to prevent deadlocks, so
|
||||
+ * need to lock again.
|
||||
+ */
|
||||
+
|
||||
+ yaffs_GrossLock(dev);
|
||||
+
|
||||
+ obj = yaffs_FindObjectByNumber(dev, inode->i_ino);
|
||||
+
|
||||
+ yaffs_FillInodeFromObject(inode, obj);
|
||||
+
|
||||
+ yaffs_GrossUnlock(dev);
|
||||
+
|
||||
+ unlock_new_inode(inode);
|
||||
+ return inode;
|
||||
+}
|
||||
+#else
|
||||
static void yaffs_read_inode(struct inode *inode)
|
||||
{
|
||||
/* NB This is called as a side effect of other functions, but
|
||||
@@ -1448,6 +1495,7 @@ static void yaffs_read_inode(struct inod
|
||||
|
||||
yaffs_GrossUnlock(dev);
|
||||
}
|
||||
+#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)) */
|
||||
|
||||
static LIST_HEAD(yaffs_dev_list);
|
||||
|
|
@ -1,63 +0,0 @@
|
|||
--- a/drivers/net/phy/phy.c
|
||||
+++ b/drivers/net/phy/phy.c
|
||||
@@ -348,6 +348,50 @@ int phy_ethtool_gset(struct phy_device *
|
||||
}
|
||||
EXPORT_SYMBOL(phy_ethtool_gset);
|
||||
|
||||
+int phy_ethtool_ioctl(struct phy_device *phydev, void *useraddr)
|
||||
+{
|
||||
+ u32 cmd;
|
||||
+ int tmp;
|
||||
+ struct ethtool_cmd ecmd = { ETHTOOL_GSET };
|
||||
+ struct ethtool_value edata = { ETHTOOL_GLINK };
|
||||
+
|
||||
+ if (get_user(cmd, (u32 *) useraddr))
|
||||
+ return -EFAULT;
|
||||
+
|
||||
+ switch (cmd) {
|
||||
+ case ETHTOOL_GSET:
|
||||
+ phy_ethtool_gset(phydev, &ecmd);
|
||||
+ if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
|
||||
+ return -EFAULT;
|
||||
+ return 0;
|
||||
+
|
||||
+ case ETHTOOL_SSET:
|
||||
+ if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
|
||||
+ return -EFAULT;
|
||||
+ return phy_ethtool_sset(phydev, &ecmd);
|
||||
+
|
||||
+ case ETHTOOL_NWAY_RST:
|
||||
+ /* if autoneg is off, it's an error */
|
||||
+ tmp = phy_read(phydev, MII_BMCR);
|
||||
+ if (tmp & BMCR_ANENABLE) {
|
||||
+ tmp |= (BMCR_ANRESTART);
|
||||
+ phy_write(phydev, MII_BMCR, tmp);
|
||||
+ return 0;
|
||||
+ }
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ case ETHTOOL_GLINK:
|
||||
+ edata.data = (phy_read(phydev,
|
||||
+ MII_BMSR) & BMSR_LSTATUS) ? 1 : 0;
|
||||
+ if (copy_to_user(useraddr, &edata, sizeof(edata)))
|
||||
+ return -EFAULT;
|
||||
+ return 0;
|
||||
+ }
|
||||
+
|
||||
+ return -EOPNOTSUPP;
|
||||
+}
|
||||
+EXPORT_SYMBOL(phy_ethtool_ioctl);
|
||||
+
|
||||
/**
|
||||
* phy_mii_ioctl - generic PHY MII ioctl interface
|
||||
* @phydev: the phy_device struct
|
||||
--- a/include/linux/phy.h
|
||||
+++ b/include/linux/phy.h
|
||||
@@ -399,6 +399,7 @@ void phy_start_machine(struct phy_device
|
||||
void phy_stop_machine(struct phy_device *phydev);
|
||||
int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd);
|
||||
int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd);
|
||||
+int phy_ethtool_ioctl(struct phy_device *phydev, void *useraddr);
|
||||
int phy_mii_ioctl(struct phy_device *phydev,
|
||||
struct mii_ioctl_data *mii_data, int cmd);
|
||||
int phy_start_interrupts(struct phy_device *phydev);
|
File diff suppressed because it is too large
Load diff
|
@ -1,25 +0,0 @@
|
|||
--- a/drivers/usb/serial/usb-serial.c
|
||||
+++ b/drivers/usb/serial/usb-serial.c
|
||||
@@ -58,6 +58,7 @@ static struct usb_driver usb_serial_driv
|
||||
drivers depend on it.
|
||||
*/
|
||||
|
||||
+static ushort maxSize = 0;
|
||||
static int debug;
|
||||
static struct usb_serial *serial_table[SERIAL_TTY_MINORS]; /* initially all NULL */
|
||||
static DEFINE_MUTEX(table_lock);
|
||||
@@ -903,7 +904,7 @@ int usb_serial_probe(struct usb_interfac
|
||||
dev_err(&interface->dev, "No free urbs available\n");
|
||||
goto probe_error;
|
||||
}
|
||||
- buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
|
||||
+ buffer_size = (endpoint->wMaxPacketSize > maxSize) ? endpoint->wMaxPacketSize : maxSize;
|
||||
port->bulk_in_size = buffer_size;
|
||||
port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
|
||||
port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
|
||||
@@ -1315,3 +1316,5 @@ MODULE_LICENSE("GPL");
|
||||
|
||||
module_param(debug, bool, S_IRUGO | S_IWUSR);
|
||||
MODULE_PARM_DESC(debug, "Debug enabled or not");
|
||||
+module_param(maxSize, ushort,0);
|
||||
+MODULE_PARM_DESC(maxSize,"User specified USB endpoint size");
|
|
@ -1,11 +0,0 @@
|
|||
--- a/init/main.c
|
||||
+++ b/init/main.c
|
||||
@@ -775,7 +775,7 @@ static int noinline init_post(void)
|
||||
numa_default_policy();
|
||||
|
||||
if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
|
||||
- printk(KERN_WARNING "Warning: unable to open an initial console.\n");
|
||||
+ printk(KERN_WARNING "Please be patient, while OpenWrt loads ...\n");
|
||||
|
||||
(void) sys_dup(0);
|
||||
(void) sys_dup(0);
|
|
@ -1,23 +0,0 @@
|
|||
--- a/fs/jffs2/erase.c
|
||||
+++ b/fs/jffs2/erase.c
|
||||
@@ -35,6 +35,8 @@ static void jffs2_erase_block(struct jff
|
||||
{
|
||||
int ret;
|
||||
uint32_t bad_offset;
|
||||
+ static char s[]="|/-\\", *p=s;
|
||||
+
|
||||
#ifdef __ECOS
|
||||
ret = jffs2_flash_erase(c, jeb);
|
||||
if (!ret) {
|
||||
@@ -47,6 +49,11 @@ static void jffs2_erase_block(struct jff
|
||||
|
||||
D1(printk(KERN_DEBUG "jffs2_erase_block(): erase block %#08x (range %#08x-%#08x)\n",
|
||||
jeb->offset, jeb->offset, jeb->offset + c->sector_size));
|
||||
+
|
||||
+ printk("%c\b", *p);
|
||||
+ if (*++p==0)
|
||||
+ p=s;
|
||||
+
|
||||
instr = kmalloc(sizeof(struct erase_info) + sizeof(struct erase_priv_struct), GFP_KERNEL);
|
||||
if (!instr) {
|
||||
printk(KERN_WARNING "kmalloc for struct erase_info in jffs2_erase_block failed. Refiling block for later\n");
|
|
@ -1,46 +0,0 @@
|
|||
--- a/include/linux/time.h
|
||||
+++ b/include/linux/time.h
|
||||
@@ -1,6 +1,10 @@
|
||||
#ifndef _LINUX_TIME_H
|
||||
#define _LINUX_TIME_H
|
||||
|
||||
+#ifndef __KERNEL__
|
||||
+#include <time.h>
|
||||
+#else
|
||||
+
|
||||
#include <linux/types.h>
|
||||
|
||||
#ifdef __KERNEL__
|
||||
@@ -232,4 +236,6 @@ struct itimerval {
|
||||
*/
|
||||
#define TIMER_ABSTIME 0x01
|
||||
|
||||
+#endif /* __KERNEL__ DEBIAN */
|
||||
+
|
||||
#endif
|
||||
--- a/include/linux/types.h
|
||||
+++ b/include/linux/types.h
|
||||
@@ -1,6 +1,14 @@
|
||||
#ifndef _LINUX_TYPES_H
|
||||
#define _LINUX_TYPES_H
|
||||
|
||||
+/* Debian: Use userland types instead. */
|
||||
+#ifndef __KERNEL__
|
||||
+# include <sys/types.h>
|
||||
+/* For other kernel headers. */
|
||||
+# include <linux/posix_types.h>
|
||||
+# include <asm/types.h>
|
||||
+#else
|
||||
+
|
||||
#ifdef __KERNEL__
|
||||
|
||||
#define DECLARE_BITMAP(name,bits) \
|
||||
@@ -161,6 +169,8 @@ typedef unsigned long blkcnt_t;
|
||||
|
||||
#endif /* __KERNEL_STRICT_NAMES */
|
||||
|
||||
+#endif /* __KERNEL__ DEBIAN */
|
||||
+
|
||||
/*
|
||||
* Below are truly Linux-specific types that should never collide with
|
||||
* any application/library that wants linux/types.h.
|
|
@ -1,102 +0,0 @@
|
|||
--- a/scripts/genksyms/parse.c_shipped
|
||||
+++ b/scripts/genksyms/parse.c_shipped
|
||||
@@ -160,7 +160,9 @@
|
||||
|
||||
|
||||
#include <assert.h>
|
||||
+#ifndef __APPLE__
|
||||
#include <malloc.h>
|
||||
+#endif
|
||||
#include "genksyms.h"
|
||||
|
||||
static int is_typedef;
|
||||
--- a/scripts/genksyms/parse.y
|
||||
+++ b/scripts/genksyms/parse.y
|
||||
@@ -24,7 +24,9 @@
|
||||
%{
|
||||
|
||||
#include <assert.h>
|
||||
+#ifndef __APPLE__
|
||||
#include <malloc.h>
|
||||
+#endif
|
||||
#include "genksyms.h"
|
||||
|
||||
static int is_typedef;
|
||||
--- a/scripts/kallsyms.c
|
||||
+++ b/scripts/kallsyms.c
|
||||
@@ -28,6 +28,35 @@
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
+#ifdef __APPLE__
|
||||
+/* Darwin has no memmem implementation, this one is ripped of the uClibc-0.9.28 source */
|
||||
+void *memmem (const void *haystack, size_t haystack_len,
|
||||
+ const void *needle, size_t needle_len)
|
||||
+{
|
||||
+ const char *begin;
|
||||
+ const char *const last_possible
|
||||
+ = (const char *) haystack + haystack_len - needle_len;
|
||||
+
|
||||
+ if (needle_len == 0)
|
||||
+ /* The first occurrence of the empty string is deemed to occur at
|
||||
+ the beginning of the string. */
|
||||
+ return (void *) haystack;
|
||||
+
|
||||
+ /* Sanity check, otherwise the loop might search through the whole
|
||||
+ memory. */
|
||||
+ if (__builtin_expect (haystack_len < needle_len, 0))
|
||||
+ return NULL;
|
||||
+
|
||||
+ for (begin = (const char *) haystack; begin <= last_possible; ++begin)
|
||||
+ if (begin[0] == ((const char *) needle)[0] &&
|
||||
+ !memcmp ((const void *) &begin[1],
|
||||
+ (const void *) ((const char *) needle + 1),
|
||||
+ needle_len - 1))
|
||||
+ return (void *) begin;
|
||||
+
|
||||
+ return NULL;
|
||||
+}
|
||||
+#endif
|
||||
|
||||
#define KSYM_NAME_LEN 128
|
||||
|
||||
--- a/scripts/kconfig/Makefile
|
||||
+++ b/scripts/kconfig/Makefile
|
||||
@@ -93,6 +93,9 @@ check-lxdialog := $(srctree)/$(src)/lxd
|
||||
# we really need to do so. (Do not call gcc as part of make mrproper)
|
||||
HOST_EXTRACFLAGS = $(shell $(CONFIG_SHELL) $(check-lxdialog) -ccflags)
|
||||
HOST_LOADLIBES = $(shell $(CONFIG_SHELL) $(check-lxdialog) -ldflags $(HOSTCC))
|
||||
+ifeq ($(shell uname -s),Darwin)
|
||||
+HOST_LOADLIBES += -lncurses
|
||||
+endif
|
||||
|
||||
HOST_EXTRACFLAGS += -DLOCALE
|
||||
|
||||
--- a/scripts/mod/mk_elfconfig.c
|
||||
+++ b/scripts/mod/mk_elfconfig.c
|
||||
@@ -1,7 +1,11 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
+#ifndef __APPLE__
|
||||
#include <elf.h>
|
||||
+#else
|
||||
+#include "../../../../../tools/sstrip/include/elf.h"
|
||||
+#endif
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
--- a/scripts/mod/modpost.h
|
||||
+++ b/scripts/mod/modpost.h
|
||||
@@ -7,7 +7,11 @@
|
||||
#include <sys/mman.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
+#if !(defined(__APPLE__) || defined(__CYGWIN__))
|
||||
#include <elf.h>
|
||||
+#else
|
||||
+#include "../../../../../tools/sstrip/include/elf.h"
|
||||
+#endif
|
||||
|
||||
#include "elfconfig.h"
|
||||
|
|
@ -1,154 +0,0 @@
|
|||
--- a/drivers/net/wireless/hostap/hostap_ap.c
|
||||
+++ b/drivers/net/wireless/hostap/hostap_ap.c
|
||||
@@ -2397,13 +2397,13 @@ int prism2_ap_get_sta_qual(local_info_t
|
||||
addr[count].sa_family = ARPHRD_ETHER;
|
||||
memcpy(addr[count].sa_data, sta->addr, ETH_ALEN);
|
||||
if (sta->last_rx_silence == 0)
|
||||
- qual[count].qual = sta->last_rx_signal < 27 ?
|
||||
- 0 : (sta->last_rx_signal - 27) * 92 / 127;
|
||||
+ qual[count].qual = (sta->last_rx_signal - 156) == 0 ?
|
||||
+ 0 : (sta->last_rx_signal - 156) * 92 / 64;
|
||||
else
|
||||
- qual[count].qual = sta->last_rx_signal -
|
||||
- sta->last_rx_silence - 35;
|
||||
- qual[count].level = HFA384X_LEVEL_TO_dBm(sta->last_rx_signal);
|
||||
- qual[count].noise = HFA384X_LEVEL_TO_dBm(sta->last_rx_silence);
|
||||
+ qual[count].qual = (sta->last_rx_signal -
|
||||
+ sta->last_rx_silence) * 92 / 64;
|
||||
+ qual[count].level = sta->last_rx_signal;
|
||||
+ qual[count].noise = sta->last_rx_silence;
|
||||
qual[count].updated = sta->last_rx_updated;
|
||||
|
||||
sta->last_rx_updated = IW_QUAL_DBM;
|
||||
@@ -2468,13 +2468,13 @@ int prism2_ap_translate_scan(struct net_
|
||||
memset(&iwe, 0, sizeof(iwe));
|
||||
iwe.cmd = IWEVQUAL;
|
||||
if (sta->last_rx_silence == 0)
|
||||
- iwe.u.qual.qual = sta->last_rx_signal < 27 ?
|
||||
- 0 : (sta->last_rx_signal - 27) * 92 / 127;
|
||||
+ iwe.u.qual.qual = (sta->last_rx_signal -156) == 0 ?
|
||||
+ 0 : (sta->last_rx_signal - 156) * 92 / 64;
|
||||
else
|
||||
- iwe.u.qual.qual = sta->last_rx_signal -
|
||||
- sta->last_rx_silence - 35;
|
||||
- iwe.u.qual.level = HFA384X_LEVEL_TO_dBm(sta->last_rx_signal);
|
||||
- iwe.u.qual.noise = HFA384X_LEVEL_TO_dBm(sta->last_rx_silence);
|
||||
+ iwe.u.qual.qual = (sta->last_rx_signal -
|
||||
+ sta->last_rx_silence) * 92 / 64;
|
||||
+ iwe.u.qual.level = sta->last_rx_signal;
|
||||
+ iwe.u.qual.noise = sta->last_rx_silence;
|
||||
iwe.u.qual.updated = sta->last_rx_updated;
|
||||
iwe.len = IW_EV_QUAL_LEN;
|
||||
current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
|
||||
--- a/drivers/net/wireless/hostap/hostap_config.h
|
||||
+++ b/drivers/net/wireless/hostap/hostap_config.h
|
||||
@@ -45,4 +45,9 @@
|
||||
*/
|
||||
/* #define PRISM2_NO_STATION_MODES */
|
||||
|
||||
+/* Enable TX power Setting functions
|
||||
+ * (min att = -128 , max att = 127)
|
||||
+ */
|
||||
+#define RAW_TXPOWER_SETTING
|
||||
+
|
||||
#endif /* HOSTAP_CONFIG_H */
|
||||
--- a/drivers/net/wireless/hostap/hostap.h
|
||||
+++ b/drivers/net/wireless/hostap/hostap.h
|
||||
@@ -89,6 +89,7 @@ extern const struct iw_handler_def hosta
|
||||
extern const struct ethtool_ops prism2_ethtool_ops;
|
||||
|
||||
int hostap_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
|
||||
+int hostap_restore_power(struct net_device *dev);
|
||||
|
||||
|
||||
#endif /* HOSTAP_H */
|
||||
--- a/drivers/net/wireless/hostap/hostap_hw.c
|
||||
+++ b/drivers/net/wireless/hostap/hostap_hw.c
|
||||
@@ -933,6 +933,7 @@ static int hfa384x_set_rid(struct net_de
|
||||
prism2_hw_reset(dev);
|
||||
}
|
||||
|
||||
+ hostap_restore_power(dev);
|
||||
return res;
|
||||
}
|
||||
|
||||
--- a/drivers/net/wireless/hostap/hostap_info.c
|
||||
+++ b/drivers/net/wireless/hostap/hostap_info.c
|
||||
@@ -434,6 +434,11 @@ static void handle_info_queue_linkstatus
|
||||
}
|
||||
|
||||
/* Get BSSID if we have a valid AP address */
|
||||
+
|
||||
+ if ( val == HFA384X_LINKSTATUS_CONNECTED ||
|
||||
+ val == HFA384X_LINKSTATUS_DISCONNECTED )
|
||||
+ hostap_restore_power(local->dev);
|
||||
+
|
||||
if (connected) {
|
||||
netif_carrier_on(local->dev);
|
||||
netif_carrier_on(local->ddev);
|
||||
--- a/drivers/net/wireless/hostap/hostap_ioctl.c
|
||||
+++ b/drivers/net/wireless/hostap/hostap_ioctl.c
|
||||
@@ -1500,23 +1500,20 @@ static int prism2_txpower_hfa386x_to_dBm
|
||||
val = 255;
|
||||
|
||||
tmp = val;
|
||||
- tmp >>= 2;
|
||||
|
||||
- return -12 - tmp;
|
||||
+ return tmp;
|
||||
}
|
||||
|
||||
static u16 prism2_txpower_dBm_to_hfa386x(int val)
|
||||
{
|
||||
signed char tmp;
|
||||
|
||||
- if (val > 20)
|
||||
- return 128;
|
||||
- else if (val < -43)
|
||||
+ if (val > 127)
|
||||
return 127;
|
||||
+ else if (val < -128)
|
||||
+ return 128;
|
||||
|
||||
tmp = val;
|
||||
- tmp = -12 - tmp;
|
||||
- tmp <<= 2;
|
||||
|
||||
return (unsigned char) tmp;
|
||||
}
|
||||
@@ -4076,3 +4073,35 @@ int hostap_ioctl(struct net_device *dev,
|
||||
|
||||
return ret;
|
||||
}
|
||||
+
|
||||
+/* BUG FIX: Restore power setting value when lost due to F/W bug */
|
||||
+
|
||||
+int hostap_restore_power(struct net_device *dev)
|
||||
+{
|
||||
+ struct hostap_interface *iface = dev->priv;
|
||||
+ local_info_t *local = iface->local;
|
||||
+
|
||||
+ u16 val;
|
||||
+ int ret = 0;
|
||||
+
|
||||
+ if (local->txpower_type == PRISM2_TXPOWER_OFF) {
|
||||
+ val = 0xff; /* use all standby and sleep modes */
|
||||
+ ret = local->func->cmd(dev, HFA384X_CMDCODE_WRITEMIF,
|
||||
+ HFA386X_CR_A_D_TEST_MODES2,
|
||||
+ &val, NULL);
|
||||
+ }
|
||||
+
|
||||
+#ifdef RAW_TXPOWER_SETTING
|
||||
+ if (local->txpower_type == PRISM2_TXPOWER_FIXED) {
|
||||
+ val = HFA384X_TEST_CFG_BIT_ALC;
|
||||
+ local->func->cmd(dev, HFA384X_CMDCODE_TEST |
|
||||
+ (HFA384X_TEST_CFG_BITS << 8), 0, &val, NULL);
|
||||
+ val = prism2_txpower_dBm_to_hfa386x(local->txpower);
|
||||
+ ret = (local->func->cmd(dev, HFA384X_CMDCODE_WRITEMIF,
|
||||
+ HFA386X_CR_MANUAL_TX_POWER, &val, NULL));
|
||||
+ }
|
||||
+#endif /* RAW_TXPOWER_SETTING */
|
||||
+ return (ret ? -EOPNOTSUPP : 0);
|
||||
+}
|
||||
+
|
||||
+EXPORT_SYMBOL(hostap_restore_power);
|
|
@ -1,17 +0,0 @@
|
|||
--- a/include/linux/stddef.h
|
||||
+++ b/include/linux/stddef.h
|
||||
@@ -16,6 +16,7 @@ enum {
|
||||
false = 0,
|
||||
true = 1
|
||||
};
|
||||
+#endif /* __KERNEL__ */
|
||||
|
||||
#undef offsetof
|
||||
#ifdef __compiler_offsetof
|
||||
@@ -23,6 +24,5 @@ enum {
|
||||
#else
|
||||
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
|
||||
#endif
|
||||
-#endif /* __KERNEL__ */
|
||||
|
||||
#endif
|
|
@ -1,20 +0,0 @@
|
|||
--- a/scripts/gen_initramfs_list.sh
|
||||
+++ b/scripts/gen_initramfs_list.sh
|
||||
@@ -125,7 +125,7 @@ parse() {
|
||||
str="${ftype} ${name} ${location} ${str}"
|
||||
;;
|
||||
"nod")
|
||||
- local dev=`LC_ALL=C ls -l "${location}"`
|
||||
+ local dev=`LC_ALL=C ls -l --time-style=locale "${location}"`
|
||||
local maj=`field 5 ${dev}`
|
||||
local min=`field 6 ${dev}`
|
||||
maj=${maj%,}
|
||||
@@ -135,7 +135,7 @@ parse() {
|
||||
str="${ftype} ${name} ${str} ${dev} ${maj} ${min}"
|
||||
;;
|
||||
"slink")
|
||||
- local target=`field 11 $(LC_ALL=C ls -l "${location}")`
|
||||
+ local target=`field 11 $(LC_ALL=C ls -l --time-style=locale "${location}")`
|
||||
str="${ftype} ${name} ${target} ${str}"
|
||||
;;
|
||||
*)
|
|
@ -1,10 +0,0 @@
|
|||
--- a/arch/x86/boot/tools/build.c
|
||||
+++ b/arch/x86/boot/tools/build.c
|
||||
@@ -29,7 +29,6 @@
|
||||
#include <stdarg.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
-#include <sys/sysmacros.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/mman.h>
|
|
@ -1,16 +0,0 @@
|
|||
--- a/include/linux/msdos_fs.h
|
||||
+++ b/include/linux/msdos_fs.h
|
||||
@@ -57,11 +57,13 @@
|
||||
#define MSDOS_DOT ". " /* ".", padded to MSDOS_NAME chars */
|
||||
#define MSDOS_DOTDOT ".. " /* "..", padded to MSDOS_NAME chars */
|
||||
|
||||
+#ifdef __KERNEL__
|
||||
/* media of boot sector */
|
||||
static inline int fat_valid_media(u8 media)
|
||||
{
|
||||
return 0xf8 <= media || media == 0xf0;
|
||||
}
|
||||
+#endif
|
||||
|
||||
#define FAT_FIRST_ENT(s, x) ((MSDOS_SB(s)->fat_bits == 32 ? 0x0FFFFF00 : \
|
||||
MSDOS_SB(s)->fat_bits == 16 ? 0xFF00 : 0xF00) | (x))
|
|
@ -1,16 +0,0 @@
|
|||
--- a/drivers/mtd/devices/m25p80.c
|
||||
+++ b/drivers/mtd/devices/m25p80.c
|
||||
@@ -627,12 +627,10 @@ static int __devinit m25p_probe(struct s
|
||||
struct mtd_partition *parts = NULL;
|
||||
int nr_parts = 0;
|
||||
|
||||
-#ifdef CONFIG_MTD_CMDLINE_PARTS
|
||||
- static const char *part_probes[] = { "cmdlinepart", NULL, };
|
||||
+ static const char *part_probes[] = { "RedBoot", "cmdlinepart", NULL, };
|
||||
|
||||
nr_parts = parse_mtd_partitions(&flash->mtd,
|
||||
part_probes, &parts, 0);
|
||||
-#endif
|
||||
|
||||
if (nr_parts <= 0 && data && data->parts) {
|
||||
parts = data->parts;
|
|
@ -1,359 +0,0 @@
|
|||
--- /dev/null
|
||||
+++ b/include/linux/spi/spi_gpio.h
|
||||
@@ -0,0 +1,72 @@
|
||||
+/*
|
||||
+ * spi_gpio interface to platform code
|
||||
+ *
|
||||
+ * Copyright (c) 2008 Piotr Skamruk
|
||||
+ *
|
||||
+ * 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.
|
||||
+ */
|
||||
+#ifndef _LINUX_SPI_SPI_GPIO
|
||||
+#define _LINUX_SPI_SPI_GPIO
|
||||
+
|
||||
+#include <linux/types.h>
|
||||
+#include <linux/spi/spi.h>
|
||||
+
|
||||
+
|
||||
+/**
|
||||
+ * struct spi_gpio_platform_data - Data definitions for a SPI-GPIO device.
|
||||
+ *
|
||||
+ * This structure holds information about a GPIO-based SPI device.
|
||||
+ *
|
||||
+ * @pin_clk: The GPIO pin number of the CLOCK pin.
|
||||
+ *
|
||||
+ * @pin_miso: The GPIO pin number of the MISO pin.
|
||||
+ *
|
||||
+ * @pin_mosi: The GPIO pin number of the MOSI pin.
|
||||
+ *
|
||||
+ * @pin_cs: The GPIO pin number of the CHIPSELECT pin.
|
||||
+ *
|
||||
+ * @cs_activelow: If true, the chip is selected when the CS line is low.
|
||||
+ *
|
||||
+ * @no_spi_delay: If true, no delay is done in the lowlevel bitbanging.
|
||||
+ * Note that doing no delay is not standards compliant,
|
||||
+ * but it might be needed to speed up transfers on some
|
||||
+ * slow embedded machines.
|
||||
+ *
|
||||
+ * @boardinfo_setup: This callback is called after the
|
||||
+ * SPI master device was registered, but before the
|
||||
+ * device is registered.
|
||||
+ * @boardinfo_setup_data: Data argument passed to boardinfo_setup().
|
||||
+ */
|
||||
+struct spi_gpio_platform_data {
|
||||
+ unsigned int pin_clk;
|
||||
+ unsigned int pin_miso;
|
||||
+ unsigned int pin_mosi;
|
||||
+ unsigned int pin_cs;
|
||||
+ bool cs_activelow;
|
||||
+ bool no_spi_delay;
|
||||
+ int (*boardinfo_setup)(struct spi_board_info *bi,
|
||||
+ struct spi_master *master,
|
||||
+ void *data);
|
||||
+ void *boardinfo_setup_data;
|
||||
+};
|
||||
+
|
||||
+/**
|
||||
+ * SPI_GPIO_PLATDEV_NAME - The platform device name string.
|
||||
+ *
|
||||
+ * The name string that has to be used for platform_device_alloc
|
||||
+ * when allocating a spi-gpio device.
|
||||
+ */
|
||||
+#define SPI_GPIO_PLATDEV_NAME "spi-gpio"
|
||||
+
|
||||
+/**
|
||||
+ * spi_gpio_next_id - Get another platform device ID number.
|
||||
+ *
|
||||
+ * This returns the next platform device ID number that has to be used
|
||||
+ * for platform_device_alloc. The ID is opaque and should not be used for
|
||||
+ * anything else.
|
||||
+ */
|
||||
+int spi_gpio_next_id(void);
|
||||
+
|
||||
+#endif /* _LINUX_SPI_SPI_GPIO */
|
||||
--- /dev/null
|
||||
+++ b/drivers/spi/spi_gpio.c
|
||||
@@ -0,0 +1,249 @@
|
||||
+/*
|
||||
+ * Bitbanging SPI bus driver using GPIO API
|
||||
+ *
|
||||
+ * Copyright (c) 2008 Piotr Skamruk
|
||||
+ *
|
||||
+ * based on spi_s3c2410_gpio.c
|
||||
+ * Copyright (c) 2006 Ben Dooks
|
||||
+ * Copyright (c) 2006 Simtec Electronics
|
||||
+ * and on i2c-gpio.c
|
||||
+ * Copyright (C) 2007 Atmel Corporation
|
||||
+ *
|
||||
+ * 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/kernel.h>
|
||||
+#include <linux/init.h>
|
||||
+#include <linux/delay.h>
|
||||
+#include <linux/spinlock.h>
|
||||
+#include <linux/workqueue.h>
|
||||
+#include <linux/module.h>
|
||||
+#include <linux/platform_device.h>
|
||||
+#include <linux/spi/spi.h>
|
||||
+#include <linux/spi/spi_bitbang.h>
|
||||
+#include <linux/spi/spi_gpio.h>
|
||||
+#include <linux/gpio.h>
|
||||
+#include <asm/atomic.h>
|
||||
+
|
||||
+
|
||||
+struct spi_gpio {
|
||||
+ struct spi_bitbang bitbang;
|
||||
+ struct spi_gpio_platform_data *info;
|
||||
+ struct platform_device *pdev;
|
||||
+ struct spi_board_info bi;
|
||||
+};
|
||||
+
|
||||
+
|
||||
+static inline struct spi_gpio *spidev_to_sg(struct spi_device *dev)
|
||||
+{
|
||||
+ return dev->controller_data;
|
||||
+}
|
||||
+
|
||||
+static inline void setsck(struct spi_device *dev, int val)
|
||||
+{
|
||||
+ struct spi_gpio *sp = spidev_to_sg(dev);
|
||||
+ gpio_set_value(sp->info->pin_clk, val ? 1 : 0);
|
||||
+}
|
||||
+
|
||||
+static inline void setmosi(struct spi_device *dev, int val)
|
||||
+{
|
||||
+ struct spi_gpio *sp = spidev_to_sg(dev);
|
||||
+ gpio_set_value(sp->info->pin_mosi, val ? 1 : 0);
|
||||
+}
|
||||
+
|
||||
+static inline u32 getmiso(struct spi_device *dev)
|
||||
+{
|
||||
+ struct spi_gpio *sp = spidev_to_sg(dev);
|
||||
+ return gpio_get_value(sp->info->pin_miso) ? 1 : 0;
|
||||
+}
|
||||
+
|
||||
+static inline void do_spidelay(struct spi_device *dev, unsigned nsecs)
|
||||
+{
|
||||
+ struct spi_gpio *sp = spidev_to_sg(dev);
|
||||
+
|
||||
+ if (!sp->info->no_spi_delay)
|
||||
+ ndelay(nsecs);
|
||||
+}
|
||||
+
|
||||
+#define spidelay(nsecs) do { \
|
||||
+ /* Steal the spi_device pointer from our caller. \
|
||||
+ * The bitbang-API should probably get fixed here... */ \
|
||||
+ do_spidelay(spi, nsecs); \
|
||||
+ } while (0)
|
||||
+
|
||||
+#define EXPAND_BITBANG_TXRX
|
||||
+#include <linux/spi/spi_bitbang.h>
|
||||
+
|
||||
+static u32 spi_gpio_txrx_mode0(struct spi_device *spi,
|
||||
+ unsigned nsecs, u32 word, u8 bits)
|
||||
+{
|
||||
+ return bitbang_txrx_be_cpha0(spi, nsecs, 0, word, bits);
|
||||
+}
|
||||
+
|
||||
+static u32 spi_gpio_txrx_mode1(struct spi_device *spi,
|
||||
+ unsigned nsecs, u32 word, u8 bits)
|
||||
+{
|
||||
+ return bitbang_txrx_be_cpha1(spi, nsecs, 0, word, bits);
|
||||
+}
|
||||
+
|
||||
+static u32 spi_gpio_txrx_mode2(struct spi_device *spi,
|
||||
+ unsigned nsecs, u32 word, u8 bits)
|
||||
+{
|
||||
+ return bitbang_txrx_be_cpha0(spi, nsecs, 1, word, bits);
|
||||
+}
|
||||
+
|
||||
+static u32 spi_gpio_txrx_mode3(struct spi_device *spi,
|
||||
+ unsigned nsecs, u32 word, u8 bits)
|
||||
+{
|
||||
+ return bitbang_txrx_be_cpha1(spi, nsecs, 1, word, bits);
|
||||
+}
|
||||
+
|
||||
+static void spi_gpio_chipselect(struct spi_device *dev, int on)
|
||||
+{
|
||||
+ struct spi_gpio *sp = spidev_to_sg(dev);
|
||||
+
|
||||
+ if (sp->info->cs_activelow)
|
||||
+ on = !on;
|
||||
+ gpio_set_value(sp->info->pin_cs, on ? 1 : 0);
|
||||
+}
|
||||
+
|
||||
+static int spi_gpio_probe(struct platform_device *pdev)
|
||||
+{
|
||||
+ struct spi_master *master;
|
||||
+ struct spi_gpio_platform_data *pdata;
|
||||
+ struct spi_gpio *sp;
|
||||
+ struct spi_device *spidev;
|
||||
+ int err;
|
||||
+
|
||||
+ pdata = pdev->dev.platform_data;
|
||||
+ if (!pdata)
|
||||
+ return -ENXIO;
|
||||
+
|
||||
+ err = -ENOMEM;
|
||||
+ master = spi_alloc_master(&pdev->dev, sizeof(struct spi_gpio));
|
||||
+ if (!master)
|
||||
+ goto err_alloc_master;
|
||||
+
|
||||
+ sp = spi_master_get_devdata(master);
|
||||
+ platform_set_drvdata(pdev, sp);
|
||||
+ sp->info = pdata;
|
||||
+
|
||||
+ err = gpio_request(pdata->pin_clk, "spi_clock");
|
||||
+ if (err)
|
||||
+ goto err_request_clk;
|
||||
+ err = gpio_request(pdata->pin_mosi, "spi_mosi");
|
||||
+ if (err)
|
||||
+ goto err_request_mosi;
|
||||
+ err = gpio_request(pdata->pin_miso, "spi_miso");
|
||||
+ if (err)
|
||||
+ goto err_request_miso;
|
||||
+ err = gpio_request(pdata->pin_cs, "spi_cs");
|
||||
+ if (err)
|
||||
+ goto err_request_cs;
|
||||
+
|
||||
+ sp->bitbang.master = spi_master_get(master);
|
||||
+ sp->bitbang.master->bus_num = -1;
|
||||
+ sp->bitbang.master->num_chipselect = 1;
|
||||
+ sp->bitbang.chipselect = spi_gpio_chipselect;
|
||||
+ sp->bitbang.txrx_word[SPI_MODE_0] = spi_gpio_txrx_mode0;
|
||||
+ sp->bitbang.txrx_word[SPI_MODE_1] = spi_gpio_txrx_mode1;
|
||||
+ sp->bitbang.txrx_word[SPI_MODE_2] = spi_gpio_txrx_mode2;
|
||||
+ sp->bitbang.txrx_word[SPI_MODE_3] = spi_gpio_txrx_mode3;
|
||||
+
|
||||
+ gpio_direction_output(pdata->pin_clk, 0);
|
||||
+ gpio_direction_output(pdata->pin_mosi, 0);
|
||||
+ gpio_direction_output(pdata->pin_cs,
|
||||
+ pdata->cs_activelow ? 1 : 0);
|
||||
+ gpio_direction_input(pdata->pin_miso);
|
||||
+
|
||||
+ err = spi_bitbang_start(&sp->bitbang);
|
||||
+ if (err)
|
||||
+ goto err_no_bitbang;
|
||||
+ err = pdata->boardinfo_setup(&sp->bi, master,
|
||||
+ pdata->boardinfo_setup_data);
|
||||
+ if (err)
|
||||
+ goto err_bi_setup;
|
||||
+ sp->bi.controller_data = sp;
|
||||
+ spidev = spi_new_device(master, &sp->bi);
|
||||
+ if (!spidev)
|
||||
+ goto err_new_dev;
|
||||
+
|
||||
+ return 0;
|
||||
+
|
||||
+err_new_dev:
|
||||
+err_bi_setup:
|
||||
+ spi_bitbang_stop(&sp->bitbang);
|
||||
+err_no_bitbang:
|
||||
+ spi_master_put(sp->bitbang.master);
|
||||
+ gpio_free(pdata->pin_cs);
|
||||
+err_request_cs:
|
||||
+ gpio_free(pdata->pin_miso);
|
||||
+err_request_miso:
|
||||
+ gpio_free(pdata->pin_mosi);
|
||||
+err_request_mosi:
|
||||
+ gpio_free(pdata->pin_clk);
|
||||
+err_request_clk:
|
||||
+ kfree(master);
|
||||
+
|
||||
+err_alloc_master:
|
||||
+ return err;
|
||||
+}
|
||||
+
|
||||
+static int __devexit spi_gpio_remove(struct platform_device *pdev)
|
||||
+{
|
||||
+ struct spi_gpio *sp;
|
||||
+ struct spi_gpio_platform_data *pdata;
|
||||
+
|
||||
+ pdata = pdev->dev.platform_data;
|
||||
+ sp = platform_get_drvdata(pdev);
|
||||
+
|
||||
+ gpio_free(pdata->pin_clk);
|
||||
+ gpio_free(pdata->pin_mosi);
|
||||
+ gpio_free(pdata->pin_miso);
|
||||
+ gpio_free(pdata->pin_cs);
|
||||
+ spi_bitbang_stop(&sp->bitbang);
|
||||
+ spi_master_put(sp->bitbang.master);
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static struct platform_driver spi_gpio_driver = {
|
||||
+ .driver = {
|
||||
+ .name = SPI_GPIO_PLATDEV_NAME,
|
||||
+ .owner = THIS_MODULE,
|
||||
+ },
|
||||
+ .probe = spi_gpio_probe,
|
||||
+ .remove = __devexit_p(spi_gpio_remove),
|
||||
+};
|
||||
+
|
||||
+int spi_gpio_next_id(void)
|
||||
+{
|
||||
+ static atomic_t counter = ATOMIC_INIT(-1);
|
||||
+
|
||||
+ return atomic_inc_return(&counter);
|
||||
+}
|
||||
+EXPORT_SYMBOL(spi_gpio_next_id);
|
||||
+
|
||||
+static int __init spi_gpio_init(void)
|
||||
+{
|
||||
+ int err;
|
||||
+
|
||||
+ err = platform_driver_register(&spi_gpio_driver);
|
||||
+ if (err)
|
||||
+ printk(KERN_ERR "spi-gpio: register failed: %d\n", err);
|
||||
+
|
||||
+ return err;
|
||||
+}
|
||||
+module_init(spi_gpio_init);
|
||||
+
|
||||
+static void __exit spi_gpio_exit(void)
|
||||
+{
|
||||
+ platform_driver_unregister(&spi_gpio_driver);
|
||||
+}
|
||||
+module_exit(spi_gpio_exit);
|
||||
+
|
||||
+MODULE_AUTHOR("Piot Skamruk <piotr.skamruk at gmail.com>");
|
||||
+MODULE_DESCRIPTION("Platform independent GPIO bitbanging SPI driver");
|
||||
+MODULE_LICENSE("GPL v2");
|
||||
--- a/drivers/spi/Kconfig
|
||||
+++ b/drivers/spi/Kconfig
|
||||
@@ -100,6 +100,19 @@ config SPI_BUTTERFLY
|
||||
inexpensive battery powered microcontroller evaluation board.
|
||||
This same cable can be used to flash new firmware.
|
||||
|
||||
+config SPI_GPIO
|
||||
+ tristate "GPIO API based bitbanging SPI controller"
|
||||
+ depends on SPI_MASTER && GENERIC_GPIO
|
||||
+ select SPI_BITBANG
|
||||
+ help
|
||||
+ This is a platform driver that can be used for bitbanging
|
||||
+ an SPI bus over GPIO pins.
|
||||
+ Select this if you have any SPI device that is connected via
|
||||
+ GPIO pins.
|
||||
+ The module will be called spi_gpio.
|
||||
+
|
||||
+ If unsure, say N.
|
||||
+
|
||||
config SPI_IMX
|
||||
tristate "Freescale iMX SPI controller"
|
||||
depends on SPI_MASTER && ARCH_IMX && EXPERIMENTAL
|
||||
--- a/drivers/spi/Makefile
|
||||
+++ b/drivers/spi/Makefile
|
||||
@@ -16,6 +16,7 @@ obj-$(CONFIG_SPI_BFIN) += spi_bfin5xx.
|
||||
obj-$(CONFIG_SPI_BITBANG) += spi_bitbang.o
|
||||
obj-$(CONFIG_SPI_AU1550) += au1550_spi.o
|
||||
obj-$(CONFIG_SPI_BUTTERFLY) += spi_butterfly.o
|
||||
+obj-$(CONFIG_SPI_GPIO) += spi_gpio.o
|
||||
obj-$(CONFIG_SPI_IMX) += spi_imx.o
|
||||
obj-$(CONFIG_SPI_LM70_LLP) += spi_lm70llp.o
|
||||
obj-$(CONFIG_SPI_PXA2XX) += pxa2xx_spi.o
|
|
@ -1,818 +0,0 @@
|
|||
--- /dev/null
|
||||
+++ b/drivers/mmc/host/gpiommc.c
|
||||
@@ -0,0 +1,605 @@
|
||||
+/*
|
||||
+ * Driver an MMC/SD card on a bitbanging GPIO SPI bus.
|
||||
+ * This module hooks up the mmc_spi and spi_gpio modules and also
|
||||
+ * provides a configfs interface.
|
||||
+ *
|
||||
+ * Licensed under the GNU/GPL. See COPYING for details.
|
||||
+ */
|
||||
+
|
||||
+#include <linux/mmc/gpiommc.h>
|
||||
+#include <linux/platform_device.h>
|
||||
+#include <linux/list.h>
|
||||
+#include <linux/mutex.h>
|
||||
+#include <linux/spi/spi_gpio.h>
|
||||
+#include <linux/configfs.h>
|
||||
+#include <linux/gpio.h>
|
||||
+#include <asm/atomic.h>
|
||||
+
|
||||
+
|
||||
+#define PFX "gpio-mmc: "
|
||||
+
|
||||
+
|
||||
+struct gpiommc_device {
|
||||
+ struct platform_device *pdev;
|
||||
+ struct platform_device *spi_pdev;
|
||||
+ struct spi_board_info boardinfo;
|
||||
+};
|
||||
+
|
||||
+
|
||||
+MODULE_DESCRIPTION("GPIO based MMC driver");
|
||||
+MODULE_LICENSE("GPL");
|
||||
+
|
||||
+
|
||||
+static int gpiommc_boardinfo_setup(struct spi_board_info *bi,
|
||||
+ struct spi_master *master,
|
||||
+ void *data)
|
||||
+{
|
||||
+ struct gpiommc_device *d = data;
|
||||
+ struct gpiommc_platform_data *pdata = d->pdev->dev.platform_data;
|
||||
+
|
||||
+ /* Bind the SPI master to the MMC-SPI host driver. */
|
||||
+ strlcpy(bi->modalias, "mmc_spi", sizeof(bi->modalias));
|
||||
+
|
||||
+ bi->max_speed_hz = pdata->max_bus_speed;
|
||||
+ bi->bus_num = master->bus_num;
|
||||
+ bi->mode = pdata->mode;
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static int gpiommc_probe(struct platform_device *pdev)
|
||||
+{
|
||||
+ struct gpiommc_platform_data *mmc_pdata = pdev->dev.platform_data;
|
||||
+ struct spi_gpio_platform_data spi_pdata;
|
||||
+ struct gpiommc_device *d;
|
||||
+ int err;
|
||||
+
|
||||
+ err = -ENXIO;
|
||||
+ if (!mmc_pdata)
|
||||
+ goto error;
|
||||
+
|
||||
+#ifdef CONFIG_MMC_SPI_MODULE
|
||||
+ err = request_module("mmc_spi");
|
||||
+ if (err) {
|
||||
+ printk(KERN_WARNING PFX
|
||||
+ "Failed to request mmc_spi module.\n");
|
||||
+ }
|
||||
+#endif /* CONFIG_MMC_SPI_MODULE */
|
||||
+
|
||||
+ /* Allocate the GPIO-MMC device */
|
||||
+ err = -ENOMEM;
|
||||
+ d = kzalloc(sizeof(*d), GFP_KERNEL);
|
||||
+ if (!d)
|
||||
+ goto error;
|
||||
+ d->pdev = pdev;
|
||||
+
|
||||
+ /* Create the SPI-GPIO device */
|
||||
+ d->spi_pdev = platform_device_alloc(SPI_GPIO_PLATDEV_NAME,
|
||||
+ spi_gpio_next_id());
|
||||
+ if (!d->spi_pdev)
|
||||
+ goto err_free_d;
|
||||
+
|
||||
+ memset(&spi_pdata, 0, sizeof(spi_pdata));
|
||||
+ spi_pdata.pin_clk = mmc_pdata->pins.gpio_clk;
|
||||
+ spi_pdata.pin_miso = mmc_pdata->pins.gpio_do;
|
||||
+ spi_pdata.pin_mosi = mmc_pdata->pins.gpio_di;
|
||||
+ spi_pdata.pin_cs = mmc_pdata->pins.gpio_cs;
|
||||
+ spi_pdata.cs_activelow = mmc_pdata->pins.cs_activelow;
|
||||
+ spi_pdata.no_spi_delay = mmc_pdata->no_spi_delay;
|
||||
+ spi_pdata.boardinfo_setup = gpiommc_boardinfo_setup;
|
||||
+ spi_pdata.boardinfo_setup_data = d;
|
||||
+
|
||||
+ err = platform_device_add_data(d->spi_pdev, &spi_pdata,
|
||||
+ sizeof(spi_pdata));
|
||||
+ if (err)
|
||||
+ goto err_free_pdev;
|
||||
+ err = platform_device_add(d->spi_pdev);
|
||||
+ if (err)
|
||||
+ goto err_free_pdata;
|
||||
+ platform_set_drvdata(pdev, d);
|
||||
+
|
||||
+ printk(KERN_INFO PFX "MMC-Card \"%s\" "
|
||||
+ "attached to GPIO pins di=%u, do=%u, clk=%u, cs=%u\n",
|
||||
+ mmc_pdata->name, mmc_pdata->pins.gpio_di,
|
||||
+ mmc_pdata->pins.gpio_do,
|
||||
+ mmc_pdata->pins.gpio_clk,
|
||||
+ mmc_pdata->pins.gpio_cs);
|
||||
+
|
||||
+ return 0;
|
||||
+
|
||||
+err_free_pdata:
|
||||
+ kfree(d->spi_pdev->dev.platform_data);
|
||||
+ d->spi_pdev->dev.platform_data = NULL;
|
||||
+err_free_pdev:
|
||||
+ platform_device_put(d->spi_pdev);
|
||||
+err_free_d:
|
||||
+ kfree(d);
|
||||
+error:
|
||||
+ return err;
|
||||
+}
|
||||
+
|
||||
+static int gpiommc_remove(struct platform_device *pdev)
|
||||
+{
|
||||
+ struct gpiommc_device *d = platform_get_drvdata(pdev);
|
||||
+ struct gpiommc_platform_data *pdata = d->pdev->dev.platform_data;
|
||||
+
|
||||
+ platform_device_unregister(d->spi_pdev);
|
||||
+ printk(KERN_INFO PFX "GPIO based MMC-Card \"%s\" removed\n",
|
||||
+ pdata->name);
|
||||
+ platform_device_put(d->spi_pdev);
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+#ifdef CONFIG_GPIOMMC_CONFIGFS
|
||||
+
|
||||
+/* A device that was created through configfs */
|
||||
+struct gpiommc_configfs_device {
|
||||
+ struct config_item item;
|
||||
+ /* The platform device, after registration. */
|
||||
+ struct platform_device *pdev;
|
||||
+ /* The configuration */
|
||||
+ struct gpiommc_platform_data pdata;
|
||||
+};
|
||||
+
|
||||
+#define GPIO_INVALID -1
|
||||
+
|
||||
+static inline bool gpiommc_is_registered(struct gpiommc_configfs_device *dev)
|
||||
+{
|
||||
+ return (dev->pdev != NULL);
|
||||
+}
|
||||
+
|
||||
+static inline struct gpiommc_configfs_device *ci_to_gpiommc(struct config_item *item)
|
||||
+{
|
||||
+ return item ? container_of(item, struct gpiommc_configfs_device, item) : NULL;
|
||||
+}
|
||||
+
|
||||
+static struct configfs_attribute gpiommc_attr_DI = {
|
||||
+ .ca_owner = THIS_MODULE,
|
||||
+ .ca_name = "gpio_data_in",
|
||||
+ .ca_mode = S_IRUGO | S_IWUSR,
|
||||
+};
|
||||
+
|
||||
+static struct configfs_attribute gpiommc_attr_DO = {
|
||||
+ .ca_owner = THIS_MODULE,
|
||||
+ .ca_name = "gpio_data_out",
|
||||
+ .ca_mode = S_IRUGO | S_IWUSR,
|
||||
+};
|
||||
+
|
||||
+static struct configfs_attribute gpiommc_attr_CLK = {
|
||||
+ .ca_owner = THIS_MODULE,
|
||||
+ .ca_name = "gpio_clock",
|
||||
+ .ca_mode = S_IRUGO | S_IWUSR,
|
||||
+};
|
||||
+
|
||||
+static struct configfs_attribute gpiommc_attr_CS = {
|
||||
+ .ca_owner = THIS_MODULE,
|
||||
+ .ca_name = "gpio_chipselect",
|
||||
+ .ca_mode = S_IRUGO | S_IWUSR,
|
||||
+};
|
||||
+
|
||||
+static struct configfs_attribute gpiommc_attr_CS_activelow = {
|
||||
+ .ca_owner = THIS_MODULE,
|
||||
+ .ca_name = "gpio_chipselect_activelow",
|
||||
+ .ca_mode = S_IRUGO | S_IWUSR,
|
||||
+};
|
||||
+
|
||||
+static struct configfs_attribute gpiommc_attr_spimode = {
|
||||
+ .ca_owner = THIS_MODULE,
|
||||
+ .ca_name = "spi_mode",
|
||||
+ .ca_mode = S_IRUGO | S_IWUSR,
|
||||
+};
|
||||
+
|
||||
+static struct configfs_attribute gpiommc_attr_spidelay = {
|
||||
+ .ca_owner = THIS_MODULE,
|
||||
+ .ca_name = "spi_delay",
|
||||
+ .ca_mode = S_IRUGO | S_IWUSR,
|
||||
+};
|
||||
+
|
||||
+static struct configfs_attribute gpiommc_attr_max_bus_speed = {
|
||||
+ .ca_owner = THIS_MODULE,
|
||||
+ .ca_name = "max_bus_speed",
|
||||
+ .ca_mode = S_IRUGO | S_IWUSR,
|
||||
+};
|
||||
+
|
||||
+static struct configfs_attribute gpiommc_attr_register = {
|
||||
+ .ca_owner = THIS_MODULE,
|
||||
+ .ca_name = "register",
|
||||
+ .ca_mode = S_IRUGO | S_IWUSR,
|
||||
+};
|
||||
+
|
||||
+static struct configfs_attribute *gpiommc_config_attrs[] = {
|
||||
+ &gpiommc_attr_DI,
|
||||
+ &gpiommc_attr_DO,
|
||||
+ &gpiommc_attr_CLK,
|
||||
+ &gpiommc_attr_CS,
|
||||
+ &gpiommc_attr_CS_activelow,
|
||||
+ &gpiommc_attr_spimode,
|
||||
+ &gpiommc_attr_spidelay,
|
||||
+ &gpiommc_attr_max_bus_speed,
|
||||
+ &gpiommc_attr_register,
|
||||
+ NULL,
|
||||
+};
|
||||
+
|
||||
+static ssize_t gpiommc_config_attr_show(struct config_item *item,
|
||||
+ struct configfs_attribute *attr,
|
||||
+ char *page)
|
||||
+{
|
||||
+ struct gpiommc_configfs_device *dev = ci_to_gpiommc(item);
|
||||
+ ssize_t count = 0;
|
||||
+ unsigned int gpio;
|
||||
+ int err = 0;
|
||||
+
|
||||
+ if (attr == &gpiommc_attr_DI) {
|
||||
+ gpio = dev->pdata.pins.gpio_di;
|
||||
+ if (gpio == GPIO_INVALID)
|
||||
+ count = snprintf(page, PAGE_SIZE, "not configured\n");
|
||||
+ else
|
||||
+ count = snprintf(page, PAGE_SIZE, "%u\n", gpio);
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_DO) {
|
||||
+ gpio = dev->pdata.pins.gpio_do;
|
||||
+ if (gpio == GPIO_INVALID)
|
||||
+ count = snprintf(page, PAGE_SIZE, "not configured\n");
|
||||
+ else
|
||||
+ count = snprintf(page, PAGE_SIZE, "%u\n", gpio);
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_CLK) {
|
||||
+ gpio = dev->pdata.pins.gpio_clk;
|
||||
+ if (gpio == GPIO_INVALID)
|
||||
+ count = snprintf(page, PAGE_SIZE, "not configured\n");
|
||||
+ else
|
||||
+ count = snprintf(page, PAGE_SIZE, "%u\n", gpio);
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_CS) {
|
||||
+ gpio = dev->pdata.pins.gpio_cs;
|
||||
+ if (gpio == GPIO_INVALID)
|
||||
+ count = snprintf(page, PAGE_SIZE, "not configured\n");
|
||||
+ else
|
||||
+ count = snprintf(page, PAGE_SIZE, "%u\n", gpio);
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_CS_activelow) {
|
||||
+ count = snprintf(page, PAGE_SIZE, "%u\n",
|
||||
+ dev->pdata.pins.cs_activelow);
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_spimode) {
|
||||
+ count = snprintf(page, PAGE_SIZE, "%u\n",
|
||||
+ dev->pdata.mode);
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_spidelay) {
|
||||
+ count = snprintf(page, PAGE_SIZE, "%u\n",
|
||||
+ !dev->pdata.no_spi_delay);
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_max_bus_speed) {
|
||||
+ count = snprintf(page, PAGE_SIZE, "%u\n",
|
||||
+ dev->pdata.max_bus_speed);
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_register) {
|
||||
+ count = snprintf(page, PAGE_SIZE, "%u\n",
|
||||
+ gpiommc_is_registered(dev));
|
||||
+ goto out;
|
||||
+ }
|
||||
+ WARN_ON(1);
|
||||
+ err = -ENOSYS;
|
||||
+out:
|
||||
+ return err ? err : count;
|
||||
+}
|
||||
+
|
||||
+static int gpiommc_do_register(struct gpiommc_configfs_device *dev,
|
||||
+ const char *name)
|
||||
+{
|
||||
+ int err;
|
||||
+
|
||||
+ if (gpiommc_is_registered(dev))
|
||||
+ return 0;
|
||||
+
|
||||
+ if (!gpio_is_valid(dev->pdata.pins.gpio_di) ||
|
||||
+ !gpio_is_valid(dev->pdata.pins.gpio_do) ||
|
||||
+ !gpio_is_valid(dev->pdata.pins.gpio_clk) ||
|
||||
+ !gpio_is_valid(dev->pdata.pins.gpio_cs)) {
|
||||
+ printk(KERN_ERR PFX
|
||||
+ "configfs: Invalid GPIO pin number(s)\n");
|
||||
+ return -EINVAL;
|
||||
+ }
|
||||
+
|
||||
+ strlcpy(dev->pdata.name, name,
|
||||
+ sizeof(dev->pdata.name));
|
||||
+
|
||||
+ dev->pdev = platform_device_alloc(GPIOMMC_PLATDEV_NAME,
|
||||
+ gpiommc_next_id());
|
||||
+ if (!dev->pdev)
|
||||
+ return -ENOMEM;
|
||||
+ err = platform_device_add_data(dev->pdev, &dev->pdata,
|
||||
+ sizeof(dev->pdata));
|
||||
+ if (err) {
|
||||
+ platform_device_put(dev->pdev);
|
||||
+ return err;
|
||||
+ }
|
||||
+ err = platform_device_add(dev->pdev);
|
||||
+ if (err) {
|
||||
+ platform_device_put(dev->pdev);
|
||||
+ return err;
|
||||
+ }
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static void gpiommc_do_unregister(struct gpiommc_configfs_device *dev)
|
||||
+{
|
||||
+ if (!gpiommc_is_registered(dev))
|
||||
+ return;
|
||||
+
|
||||
+ platform_device_unregister(dev->pdev);
|
||||
+ dev->pdev = NULL;
|
||||
+}
|
||||
+
|
||||
+static ssize_t gpiommc_config_attr_store(struct config_item *item,
|
||||
+ struct configfs_attribute *attr,
|
||||
+ const char *page, size_t count)
|
||||
+{
|
||||
+ struct gpiommc_configfs_device *dev = ci_to_gpiommc(item);
|
||||
+ int err = -EINVAL;
|
||||
+ unsigned long data;
|
||||
+
|
||||
+ if (attr == &gpiommc_attr_register) {
|
||||
+ err = strict_strtoul(page, 10, &data);
|
||||
+ if (err)
|
||||
+ goto out;
|
||||
+ err = -EINVAL;
|
||||
+ if (data == 1)
|
||||
+ err = gpiommc_do_register(dev, item->ci_name);
|
||||
+ if (data == 0) {
|
||||
+ gpiommc_do_unregister(dev);
|
||||
+ err = 0;
|
||||
+ }
|
||||
+ goto out;
|
||||
+ }
|
||||
+
|
||||
+ if (gpiommc_is_registered(dev)) {
|
||||
+ /* The rest of the config parameters can only be set
|
||||
+ * as long as the device is not registered, yet. */
|
||||
+ err = -EBUSY;
|
||||
+ goto out;
|
||||
+ }
|
||||
+
|
||||
+ if (attr == &gpiommc_attr_DI) {
|
||||
+ err = strict_strtoul(page, 10, &data);
|
||||
+ if (err)
|
||||
+ goto out;
|
||||
+ err = -EINVAL;
|
||||
+ if (!gpio_is_valid(data))
|
||||
+ goto out;
|
||||
+ dev->pdata.pins.gpio_di = data;
|
||||
+ err = 0;
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_DO) {
|
||||
+ err = strict_strtoul(page, 10, &data);
|
||||
+ if (err)
|
||||
+ goto out;
|
||||
+ err = -EINVAL;
|
||||
+ if (!gpio_is_valid(data))
|
||||
+ goto out;
|
||||
+ dev->pdata.pins.gpio_do = data;
|
||||
+ err = 0;
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_CLK) {
|
||||
+ err = strict_strtoul(page, 10, &data);
|
||||
+ if (err)
|
||||
+ goto out;
|
||||
+ err = -EINVAL;
|
||||
+ if (!gpio_is_valid(data))
|
||||
+ goto out;
|
||||
+ dev->pdata.pins.gpio_clk = data;
|
||||
+ err = 0;
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_CS) {
|
||||
+ err = strict_strtoul(page, 10, &data);
|
||||
+ if (err)
|
||||
+ goto out;
|
||||
+ err = -EINVAL;
|
||||
+ if (!gpio_is_valid(data))
|
||||
+ goto out;
|
||||
+ dev->pdata.pins.gpio_cs = data;
|
||||
+ err = 0;
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_CS_activelow) {
|
||||
+ err = strict_strtoul(page, 10, &data);
|
||||
+ if (err)
|
||||
+ goto out;
|
||||
+ err = -EINVAL;
|
||||
+ if (data != 0 && data != 1)
|
||||
+ goto out;
|
||||
+ dev->pdata.pins.cs_activelow = data;
|
||||
+ err = 0;
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_spimode) {
|
||||
+ err = strict_strtoul(page, 10, &data);
|
||||
+ if (err)
|
||||
+ goto out;
|
||||
+ err = -EINVAL;
|
||||
+ switch (data) {
|
||||
+ case 0:
|
||||
+ dev->pdata.mode = SPI_MODE_0;
|
||||
+ break;
|
||||
+ case 1:
|
||||
+ dev->pdata.mode = SPI_MODE_1;
|
||||
+ break;
|
||||
+ case 2:
|
||||
+ dev->pdata.mode = SPI_MODE_2;
|
||||
+ break;
|
||||
+ case 3:
|
||||
+ dev->pdata.mode = SPI_MODE_3;
|
||||
+ break;
|
||||
+ default:
|
||||
+ goto out;
|
||||
+ }
|
||||
+ err = 0;
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_spidelay) {
|
||||
+ err = strict_strtoul(page, 10, &data);
|
||||
+ if (err)
|
||||
+ goto out;
|
||||
+ err = -EINVAL;
|
||||
+ if (data != 0 && data != 1)
|
||||
+ goto out;
|
||||
+ dev->pdata.no_spi_delay = !data;
|
||||
+ err = 0;
|
||||
+ goto out;
|
||||
+ }
|
||||
+ if (attr == &gpiommc_attr_max_bus_speed) {
|
||||
+ err = strict_strtoul(page, 10, &data);
|
||||
+ if (err)
|
||||
+ goto out;
|
||||
+ err = -EINVAL;
|
||||
+ if (data > UINT_MAX)
|
||||
+ goto out;
|
||||
+ dev->pdata.max_bus_speed = data;
|
||||
+ err = 0;
|
||||
+ goto out;
|
||||
+ }
|
||||
+ WARN_ON(1);
|
||||
+ err = -ENOSYS;
|
||||
+out:
|
||||
+ return err ? err : count;
|
||||
+}
|
||||
+
|
||||
+static void gpiommc_config_item_release(struct config_item *item)
|
||||
+{
|
||||
+ struct gpiommc_configfs_device *dev = ci_to_gpiommc(item);
|
||||
+
|
||||
+ kfree(dev);
|
||||
+}
|
||||
+
|
||||
+static struct configfs_item_operations gpiommc_config_item_ops = {
|
||||
+ .release = gpiommc_config_item_release,
|
||||
+ .show_attribute = gpiommc_config_attr_show,
|
||||
+ .store_attribute = gpiommc_config_attr_store,
|
||||
+};
|
||||
+
|
||||
+static struct config_item_type gpiommc_dev_ci_type = {
|
||||
+ .ct_item_ops = &gpiommc_config_item_ops,
|
||||
+ .ct_attrs = gpiommc_config_attrs,
|
||||
+ .ct_owner = THIS_MODULE,
|
||||
+};
|
||||
+
|
||||
+static struct config_item *gpiommc_make_item(struct config_group *group,
|
||||
+ const char *name)
|
||||
+{
|
||||
+ struct gpiommc_configfs_device *dev;
|
||||
+
|
||||
+ if (strlen(name) > GPIOMMC_MAX_NAMELEN) {
|
||||
+ printk(KERN_ERR PFX "configfs: device name too long\n");
|
||||
+ return NULL;
|
||||
+ }
|
||||
+
|
||||
+ dev = kzalloc(sizeof(*dev), GFP_KERNEL);
|
||||
+ if (!dev)
|
||||
+ return NULL;
|
||||
+
|
||||
+ config_item_init_type_name(&dev->item, name,
|
||||
+ &gpiommc_dev_ci_type);
|
||||
+
|
||||
+ /* Assign default configuration */
|
||||
+ dev->pdata.pins.gpio_di = GPIO_INVALID;
|
||||
+ dev->pdata.pins.gpio_do = GPIO_INVALID;
|
||||
+ dev->pdata.pins.gpio_clk = GPIO_INVALID;
|
||||
+ dev->pdata.pins.gpio_cs = GPIO_INVALID;
|
||||
+ dev->pdata.pins.cs_activelow = 1;
|
||||
+ dev->pdata.mode = SPI_MODE_0;
|
||||
+ dev->pdata.no_spi_delay = 0;
|
||||
+ dev->pdata.max_bus_speed = 5000000; /* 5 MHz */
|
||||
+
|
||||
+ return &(dev->item);
|
||||
+}
|
||||
+
|
||||
+static void gpiommc_drop_item(struct config_group *group,
|
||||
+ struct config_item *item)
|
||||
+{
|
||||
+ struct gpiommc_configfs_device *dev = ci_to_gpiommc(item);
|
||||
+
|
||||
+ gpiommc_do_unregister(dev);
|
||||
+ kfree(dev);
|
||||
+}
|
||||
+
|
||||
+static struct configfs_group_operations gpiommc_ct_group_ops = {
|
||||
+ .make_item = gpiommc_make_item,
|
||||
+ .drop_item = gpiommc_drop_item,
|
||||
+};
|
||||
+
|
||||
+static struct config_item_type gpiommc_ci_type = {
|
||||
+ .ct_group_ops = &gpiommc_ct_group_ops,
|
||||
+ .ct_owner = THIS_MODULE,
|
||||
+};
|
||||
+
|
||||
+static struct configfs_subsystem gpiommc_subsys = {
|
||||
+ .su_group = {
|
||||
+ .cg_item = {
|
||||
+ .ci_namebuf = GPIOMMC_PLATDEV_NAME,
|
||||
+ .ci_type = &gpiommc_ci_type,
|
||||
+ },
|
||||
+ },
|
||||
+ .su_mutex = __MUTEX_INITIALIZER(gpiommc_subsys.su_mutex),
|
||||
+};
|
||||
+
|
||||
+#endif /* CONFIG_GPIOMMC_CONFIGFS */
|
||||
+
|
||||
+static struct platform_driver gpiommc_plat_driver = {
|
||||
+ .probe = gpiommc_probe,
|
||||
+ .remove = gpiommc_remove,
|
||||
+ .driver = {
|
||||
+ .name = GPIOMMC_PLATDEV_NAME,
|
||||
+ .owner = THIS_MODULE,
|
||||
+ },
|
||||
+};
|
||||
+
|
||||
+int gpiommc_next_id(void)
|
||||
+{
|
||||
+ static atomic_t counter = ATOMIC_INIT(-1);
|
||||
+
|
||||
+ return atomic_inc_return(&counter);
|
||||
+}
|
||||
+EXPORT_SYMBOL(gpiommc_next_id);
|
||||
+
|
||||
+static int __init gpiommc_modinit(void)
|
||||
+{
|
||||
+ int err;
|
||||
+
|
||||
+ err = platform_driver_register(&gpiommc_plat_driver);
|
||||
+ if (err)
|
||||
+ return err;
|
||||
+
|
||||
+#ifdef CONFIG_GPIOMMC_CONFIGFS
|
||||
+ config_group_init(&gpiommc_subsys.su_group);
|
||||
+ err = configfs_register_subsystem(&gpiommc_subsys);
|
||||
+ if (err) {
|
||||
+ platform_driver_unregister(&gpiommc_plat_driver);
|
||||
+ return err;
|
||||
+ }
|
||||
+#endif /* CONFIG_GPIOMMC_CONFIGFS */
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+module_init(gpiommc_modinit);
|
||||
+
|
||||
+static void __exit gpiommc_modexit(void)
|
||||
+{
|
||||
+#ifdef CONFIG_GPIOMMC_CONFIGFS
|
||||
+ configfs_unregister_subsystem(&gpiommc_subsys);
|
||||
+#endif
|
||||
+ platform_driver_unregister(&gpiommc_plat_driver);
|
||||
+}
|
||||
+module_exit(gpiommc_modexit);
|
||||
--- a/drivers/mmc/host/Kconfig
|
||||
+++ b/drivers/mmc/host/Kconfig
|
||||
@@ -130,3 +130,27 @@ config MMC_SPI
|
||||
|
||||
If unsure, or if your system has no SPI master driver, say N.
|
||||
|
||||
+config GPIOMMC
|
||||
+ tristate "MMC/SD over GPIO-based SPI"
|
||||
+ depends on MMC && MMC_SPI && SPI_GPIO
|
||||
+ help
|
||||
+ This driver hooks up the mmc_spi and spi_gpio modules so that
|
||||
+ MMC/SD cards can be used on a GPIO based bus by bitbanging
|
||||
+ the SPI protocol in software.
|
||||
+
|
||||
+ This driver provides a configfs interface to dynamically create
|
||||
+ and destroy GPIO-based MMC/SD card devices. It also provides
|
||||
+ a platform device interface API.
|
||||
+ See Documentation/gpiommc.txt for details.
|
||||
+
|
||||
+ The module will be called gpiommc.
|
||||
+
|
||||
+ If unsure, say N.
|
||||
+
|
||||
+config GPIOMMC_CONFIGFS
|
||||
+ bool
|
||||
+ depends on GPIOMMC && CONFIGFS_FS
|
||||
+ default y
|
||||
+ help
|
||||
+ This option automatically enables configfs support for gpiommc
|
||||
+ if configfs is available.
|
||||
--- a/drivers/mmc/host/Makefile
|
||||
+++ b/drivers/mmc/host/Makefile
|
||||
@@ -17,4 +17,4 @@ obj-$(CONFIG_MMC_OMAP) += omap.o
|
||||
obj-$(CONFIG_MMC_AT91) += at91_mci.o
|
||||
obj-$(CONFIG_MMC_TIFM_SD) += tifm_sd.o
|
||||
obj-$(CONFIG_MMC_SPI) += mmc_spi.o
|
||||
-
|
||||
+obj-$(CONFIG_GPIOMMC) += gpiommc.o
|
||||
--- /dev/null
|
||||
+++ b/include/linux/mmc/gpiommc.h
|
||||
@@ -0,0 +1,69 @@
|
||||
+/*
|
||||
+ * Device driver for MMC/SD cards driven over a GPIO bus.
|
||||
+ *
|
||||
+ * Licensed under the GNU/GPL version 2.
|
||||
+ */
|
||||
+#ifndef LINUX_GPIOMMC_H_
|
||||
+#define LINUX_GPIOMMC_H_
|
||||
+
|
||||
+#include <linux/types.h>
|
||||
+
|
||||
+
|
||||
+#define GPIOMMC_MAX_NAMELEN 15
|
||||
+#define GPIOMMC_MAX_NAMELEN_STR __stringify(GPIOMMC_MAX_NAMELEN)
|
||||
+
|
||||
+/**
|
||||
+ * struct gpiommc_pins - Hardware pin assignments
|
||||
+ *
|
||||
+ * @gpio_di: The GPIO number of the DATA IN pin
|
||||
+ * @gpio_do: The GPIO number of the DATA OUT pin
|
||||
+ * @gpio_clk: The GPIO number of the CLOCK pin
|
||||
+ * @gpio_cs: The GPIO number of the CHIPSELECT pin
|
||||
+ * @cs_activelow: If true, the chip is considered selected if @gpio_cs is low.
|
||||
+ */
|
||||
+struct gpiommc_pins {
|
||||
+ unsigned int gpio_di;
|
||||
+ unsigned int gpio_do;
|
||||
+ unsigned int gpio_clk;
|
||||
+ unsigned int gpio_cs;
|
||||
+ bool cs_activelow;
|
||||
+};
|
||||
+
|
||||
+/**
|
||||
+ * struct gpiommc_platform_data - Platform data for a MMC-over-SPI-GPIO device.
|
||||
+ *
|
||||
+ * @name: The unique name string of the device.
|
||||
+ * @pins: The hardware pin assignments.
|
||||
+ * @mode: The hardware mode. This is either SPI_MODE_0,
|
||||
+ * SPI_MODE_1, SPI_MODE_2 or SPI_MODE_3. See the SPI documentation.
|
||||
+ * @no_spi_delay: Do not use delays in the lowlevel SPI bitbanging code.
|
||||
+ * This is not standards compliant, but may be required for some
|
||||
+ * embedded machines to gain reasonable speed.
|
||||
+ * @max_bus_speed: The maximum speed of the SPI bus, in Hertz.
|
||||
+ */
|
||||
+struct gpiommc_platform_data {
|
||||
+ char name[GPIOMMC_MAX_NAMELEN + 1];
|
||||
+ struct gpiommc_pins pins;
|
||||
+ u8 mode;
|
||||
+ bool no_spi_delay;
|
||||
+ unsigned int max_bus_speed;
|
||||
+};
|
||||
+
|
||||
+/**
|
||||
+ * GPIOMMC_PLATDEV_NAME - The platform device name string.
|
||||
+ *
|
||||
+ * The name string that has to be used for platform_device_alloc
|
||||
+ * when allocating a gpiommc device.
|
||||
+ */
|
||||
+#define GPIOMMC_PLATDEV_NAME "gpiommc"
|
||||
+
|
||||
+/**
|
||||
+ * gpiommc_next_id - Get another platform device ID number.
|
||||
+ *
|
||||
+ * This returns the next platform device ID number that has to be used
|
||||
+ * for platform_device_alloc. The ID is opaque and should not be used for
|
||||
+ * anything else.
|
||||
+ */
|
||||
+int gpiommc_next_id(void);
|
||||
+
|
||||
+#endif /* LINUX_GPIOMMC_H_ */
|
||||
--- /dev/null
|
||||
+++ b/Documentation/gpiommc.txt
|
||||
@@ -0,0 +1,97 @@
|
||||
+GPIOMMC - Driver for an MMC/SD card on a bitbanging GPIO SPI bus
|
||||
+================================================================
|
||||
+
|
||||
+The gpiommc module hooks up the mmc_spi and spi_gpio modules for running an
|
||||
+MMC or SD card on GPIO pins.
|
||||
+
|
||||
+Two interfaces for registering a new MMC/SD card device are provided:
|
||||
+A static platform-device based mechanism and a dynamic configfs based interface.
|
||||
+
|
||||
+
|
||||
+Registering devices via platform-device
|
||||
+=======================================
|
||||
+
|
||||
+The platform-device interface is used for registering MMC/SD devices that are
|
||||
+part of the hardware platform. This is most useful only for embedded machines
|
||||
+with MMC/SD devices statically connected to the platform GPIO bus.
|
||||
+
|
||||
+The data structures are declared in <linux/mmc/gpiommc.h>.
|
||||
+
|
||||
+To register a new device, define an instance of struct gpiommc_platform_data.
|
||||
+This structure holds any information about how the device is hooked up to the
|
||||
+GPIO pins and what hardware modes the device supports. See the docbook-style
|
||||
+documentation in the header file for more information on the struct fields.
|
||||
+
|
||||
+Then allocate a new instance of a platform device by doing:
|
||||
+
|
||||
+ pdev = platform_device_alloc(GPIOMMC_PLATDEV_NAME, gpiommc_next_id());
|
||||
+
|
||||
+This will allocate the platform device data structures and hook it up to the
|
||||
+gpiommc driver.
|
||||
+Then add the gpiommc_platform_data to the platform device.
|
||||
+
|
||||
+ err = platform_device_add_data(pdev, pdata, sizeof(struct gpiommc_platform_data));
|
||||
+
|
||||
+You may free the local instance of struct gpiommc_platform_data now. (So the
|
||||
+struct may be allocated on the stack, too).
|
||||
+Now simply register the platform device.
|
||||
+
|
||||
+ err = platform_device_add(pdev);
|
||||
+
|
||||
+Done. The gpiommc probe routine will be invoked now and you should see a kernel
|
||||
+log message for the added device.
|
||||
+
|
||||
+
|
||||
+Registering devices via configfs
|
||||
+================================
|
||||
+
|
||||
+MMC/SD cards connected via GPIO often are a pretty dynamic thing, as for example
|
||||
+selfmade hacks for soldering an MMC/SD card to standard GPIO pins on embedded
|
||||
+hardware are a common situation.
|
||||
+So we provide a dynamic interface to conveniently handle adding and removing
|
||||
+devices from userspace, without the need to recompile the kernel.
|
||||
+
|
||||
+The "gpiommc" subdirectory at the configfs mountpoint is used for handling
|
||||
+the dynamic configuration.
|
||||
+
|
||||
+To create a new device, it must first be allocated with mkdir.
|
||||
+The following command will allocate a device named "my_mmc":
|
||||
+ mkdir /config/gpiommc/my_mmc
|
||||
+
|
||||
+There are several configuration files available in the new
|
||||
+/config/gpiommc/my_mmc/ directory:
|
||||
+
|
||||
+gpio_data_in = The SPI data-IN GPIO pin number.
|
||||
+gpio_data_out = The SPI data-OUT GPIO pin number.
|
||||
+gpio_clock = The SPI Clock GPIO pin number.
|
||||
+gpio_chipselect = The SPI Chipselect GPIO pin number.
|
||||
+gpio_chipselect_activelow = Boolean. If 0, Chipselect is active-HIGH.
|
||||
+ If 1, Chipselect is active-LOW.
|
||||
+spi_mode = The SPI data mode. Can be 0-3.
|
||||
+spi_delay = Enable all delays in the lowlevel bitbanging.
|
||||
+max_bus_speed = The maximum SPI bus speed. In Hertz.
|
||||
+
|
||||
+register = Not a configuration parameter.
|
||||
+ Used to register the configured card
|
||||
+ with the kernel.
|
||||
+
|
||||
+The device must first get configured and then registered by writing "1" to
|
||||
+the "register" file.
|
||||
+The configuration parameters "gpio_data_in", "gpio_data_out", "gpio_clock"
|
||||
+and "gpio_chipselect" are essential and _must_ be configured before writing
|
||||
+"1" to the "register" file. The registration will fail, otherwise.
|
||||
+
|
||||
+The default values for the other parameters are:
|
||||
+gpio_chipselect_activelow = 1 (CS active-LOW)
|
||||
+spi_mode = 0 (SPI_MODE_0)
|
||||
+spi_delay = 1 (enabled)
|
||||
+max_bus_speed = 5000000 (5 Mhz)
|
||||
+
|
||||
+Configuration values can not be changed after registration. To unregister
|
||||
+the device, write a "0" to the "register" file. The configuration can be
|
||||
+changed again after unregistering.
|
||||
+
|
||||
+To completely remove the device, simply rmdir the directory
|
||||
+(/config/gpiommc/my_mmc in this example).
|
||||
+There's no need to first unregister the device before removing it. That will
|
||||
+be done automatically.
|
|
@ -1,58 +0,0 @@
|
|||
The gpiommc configfs context structure needs locking, as configfs
|
||||
does not lock access between files.
|
||||
|
||||
--- a/drivers/mmc/host/gpiommc.c
|
||||
+++ b/drivers/mmc/host/gpiommc.c
|
||||
@@ -140,6 +140,8 @@ struct gpiommc_configfs_device {
|
||||
struct platform_device *pdev;
|
||||
/* The configuration */
|
||||
struct gpiommc_platform_data pdata;
|
||||
+ /* Mutex to protect this structure */
|
||||
+ struct mutex mutex;
|
||||
};
|
||||
|
||||
#define GPIO_INVALID -1
|
||||
@@ -230,6 +232,8 @@ static ssize_t gpiommc_config_attr_show(
|
||||
unsigned int gpio;
|
||||
int err = 0;
|
||||
|
||||
+ mutex_lock(&dev->mutex);
|
||||
+
|
||||
if (attr == &gpiommc_attr_DI) {
|
||||
gpio = dev->pdata.pins.gpio_di;
|
||||
if (gpio == GPIO_INVALID)
|
||||
@@ -290,6 +294,8 @@ static ssize_t gpiommc_config_attr_show(
|
||||
WARN_ON(1);
|
||||
err = -ENOSYS;
|
||||
out:
|
||||
+ mutex_unlock(&dev->mutex);
|
||||
+
|
||||
return err ? err : count;
|
||||
}
|
||||
|
||||
@@ -349,6 +355,8 @@ static ssize_t gpiommc_config_attr_store
|
||||
int err = -EINVAL;
|
||||
unsigned long data;
|
||||
|
||||
+ mutex_lock(&dev->mutex);
|
||||
+
|
||||
if (attr == &gpiommc_attr_register) {
|
||||
err = strict_strtoul(page, 10, &data);
|
||||
if (err)
|
||||
@@ -474,6 +482,8 @@ static ssize_t gpiommc_config_attr_store
|
||||
WARN_ON(1);
|
||||
err = -ENOSYS;
|
||||
out:
|
||||
+ mutex_unlock(&dev->mutex);
|
||||
+
|
||||
return err ? err : count;
|
||||
}
|
||||
|
||||
@@ -510,6 +520,7 @@ static struct config_item *gpiommc_make_
|
||||
if (!dev)
|
||||
return NULL;
|
||||
|
||||
+ mutex_init(&dev->mutex);
|
||||
config_item_init_type_name(&dev->item, name,
|
||||
&gpiommc_dev_ci_type);
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
From a.othieno@bluewin.ch Tue Oct 11 07:50:21 2005
|
||||
From: Arthur Othieno <a.othieno@bluewin.ch>
|
||||
Subject: Big-endian I/O memory accessors.
|
||||
Date: Tue, 11 Oct 2005 07:50:21 +1000
|
||||
X-Patchwork-ID: 2759
|
||||
|
||||
From: Arthur Othieno <a.othieno@bluewin.ch>
|
||||
|
||||
I/O memory accessors. Big endian version. For those busses/devices
|
||||
that do export big-endian I/O memory.
|
||||
|
||||
Of notable relevance/reference:
|
||||
|
||||
http://lwn.net/Articles/132804/
|
||||
http://ozlabs.org/pipermail/linuxppc-embedded/2005-August/019798.html
|
||||
http://ozlabs.org/pipermail/linuxppc-embedded/2005-August/019752.html
|
||||
|
||||
Signed-off-by: Arthur Othieno <a.othieno@bluewin.ch>
|
||||
---
|
||||
|
||||
Paulus,
|
||||
|
||||
A similar patch for ppc64 made it upstream with your big ppc64 merge.
|
||||
This one is still sitting in http://patchwork.ozlabs.org/linuxppc/
|
||||
and didn't make it with the ppc32 equivalent. Thanks.
|
||||
|
||||
|
||||
include/asm-ppc/io.h | 20 ++++++++++++++++++++
|
||||
1 file changed, 20 insertions(+)
|
||||
|
||||
|
||||
---
|
||||
--- a/include/asm-ppc/io.h
|
||||
+++ b/include/asm-ppc/io.h
|
||||
@@ -413,11 +413,21 @@ static inline unsigned int ioread16(void
|
||||
return readw(addr);
|
||||
}
|
||||
|
||||
+static inline unsigned int ioread16be(void __iomem *addr)
|
||||
+{
|
||||
+ return in_be16(addr);
|
||||
+}
|
||||
+
|
||||
static inline unsigned int ioread32(void __iomem *addr)
|
||||
{
|
||||
return readl(addr);
|
||||
}
|
||||
|
||||
+static inline unsigned int ioread32be(void __iomem *addr)
|
||||
+{
|
||||
+ return in_be32(addr);
|
||||
+}
|
||||
+
|
||||
static inline void iowrite8(u8 val, void __iomem *addr)
|
||||
{
|
||||
writeb(val, addr);
|
||||
@@ -428,11 +438,21 @@ static inline void iowrite16(u16 val, vo
|
||||
writew(val, addr);
|
||||
}
|
||||
|
||||
+static inline void iowrite16be(u16 val, void __iomem *addr)
|
||||
+{
|
||||
+ out_be16(addr, val);
|
||||
+}
|
||||
+
|
||||
static inline void iowrite32(u32 val, void __iomem *addr)
|
||||
{
|
||||
writel(val, addr);
|
||||
}
|
||||
|
||||
+static inline void iowrite32be(u32 val, void __iomem *addr)
|
||||
+{
|
||||
+ out_be32(addr, val);
|
||||
+}
|
||||
+
|
||||
static inline void ioread8_rep(void __iomem *addr, void *dst, unsigned long count)
|
||||
{
|
||||
_insb(addr, dst, count);
|
|
@ -1,149 +0,0 @@
|
|||
--- a/arch/arm/tools/mach-types
|
||||
+++ b/arch/arm/tools/mach-types
|
||||
@@ -12,7 +12,7 @@
|
||||
#
|
||||
# http://www.arm.linux.org.uk/developer/machines/?action=new
|
||||
#
|
||||
-# Last update: Sat Jan 26 14:45:34 2008
|
||||
+# Last update: Sat Apr 19 15:13:28 2008
|
||||
#
|
||||
# machine_is_xxx CONFIG_xxxx MACH_TYPE_xxx number
|
||||
#
|
||||
@@ -381,13 +381,13 @@ ks8695p ARCH_KS8695P KS8695P 363
|
||||
se4000 ARCH_SE4000 SE4000 364
|
||||
quadriceps ARCH_QUADRICEPS QUADRICEPS 365
|
||||
bronco ARCH_BRONCO BRONCO 366
|
||||
-esl_wireless_tab ARCH_ESL_WIRELESS_TABLETESL_WIRELESS_TABLET 367
|
||||
+esl_wireless_tab ARCH_ESL_WIRELESS_TAB ESL_WIRELESS_TAB 367
|
||||
esl_sofcomp ARCH_ESL_SOFCOMP ESL_SOFCOMP 368
|
||||
s5c7375 ARCH_S5C7375 S5C7375 369
|
||||
spearhead ARCH_SPEARHEAD SPEARHEAD 370
|
||||
pantera ARCH_PANTERA PANTERA 371
|
||||
prayoglite ARCH_PRAYOGLITE PRAYOGLITE 372
|
||||
-gumstix ARCH_GUMSTIK GUMSTIK 373
|
||||
+gumstix ARCH_GUMSTIX GUMSTIX 373
|
||||
rcube ARCH_RCUBE RCUBE 374
|
||||
rea_olv ARCH_REA_OLV REA_OLV 375
|
||||
pxa_iphone ARCH_PXA_IPHONE PXA_IPHONE 376
|
||||
@@ -1463,7 +1463,7 @@ artemis MACH_ARTEMIS ARTEMIS 1462
|
||||
htctitan MACH_HTCTITAN HTCTITAN 1463
|
||||
qranium MACH_QRANIUM QRANIUM 1464
|
||||
adx_wsc2 MACH_ADX_WSC2 ADX_WSC2 1465
|
||||
-adx_medinet MACH_ADX_MEDINET ADX_MEDINET 1466
|
||||
+adx_medcom MACH_ADX_MEDINET ADX_MEDINET 1466
|
||||
bboard MACH_BBOARD BBOARD 1467
|
||||
cambria MACH_CAMBRIA CAMBRIA 1468
|
||||
mt7xxx MACH_MT7XXX MT7XXX 1469
|
||||
@@ -1611,3 +1611,112 @@ kb9263 MACH_KB9263 KB9263 1612
|
||||
mt7108 MACH_MT7108 MT7108 1613
|
||||
smtr2440 MACH_SMTR2440 SMTR2440 1614
|
||||
manao MACH_MANAO MANAO 1615
|
||||
+cm_x300 MACH_CM_X300 CM_X300 1616
|
||||
+gulfstream_kp MACH_GULFSTREAM_KP GULFSTREAM_KP 1617
|
||||
+lanreadyfn522 MACH_LANREADYFN522 LANREADYFN522 1618
|
||||
+arma37 MACH_ARMA37 ARMA37 1619
|
||||
+mendel MACH_MENDEL MENDEL 1620
|
||||
+pelco_iliad MACH_PELCO_ILIAD PELCO_ILIAD 1621
|
||||
+unit2p MACH_UNIT2P UNIT2P 1622
|
||||
+inc20otter MACH_INC20OTTER INC20OTTER 1623
|
||||
+at91sam9g20ek MACH_AT91SAM9G20EK AT91SAM9G20EK 1624
|
||||
+sc_ge2 MACH_STORCENTER STORCENTER 1625
|
||||
+smdk6410 MACH_SMDK6410 SMDK6410 1626
|
||||
+u300 MACH_U300 U300 1627
|
||||
+u500 MACH_U500 U500 1628
|
||||
+ds9260 MACH_DS9260 DS9260 1629
|
||||
+riverrock MACH_RIVERROCK RIVERROCK 1630
|
||||
+scibath MACH_SCIBATH SCIBATH 1631
|
||||
+at91sam7se MACH_AT91SAM7SE512EK AT91SAM7SE512EK 1632
|
||||
+wrt350n_v2 MACH_WRT350N_V2 WRT350N_V2 1633
|
||||
+multimedia MACH_MULTIMEDIA MULTIMEDIA 1634
|
||||
+marvin MACH_MARVIN MARVIN 1635
|
||||
+x500 MACH_X500 X500 1636
|
||||
+awlug4lcu MACH_AWLUG4LCU AWLUG4LCU 1637
|
||||
+palermoc MACH_PALERMOC PALERMOC 1638
|
||||
+omap_ldp MACH_OMAP_LDP OMAP_LDP 1639
|
||||
+ip500 MACH_IP500 IP500 1640
|
||||
+mx35ads MACH_MACH_MX35ADS MACH_MX35ADS 1641
|
||||
+ase2 MACH_ASE2 ASE2 1642
|
||||
+mx35evb MACH_MX35EVB MX35EVB 1643
|
||||
+aml_m8050 MACH_AML_M8050 AML_M8050 1644
|
||||
+mx35_3ds MACH_MX35_3DS MX35_3DS 1645
|
||||
+mars MACH_MARS MARS 1646
|
||||
+ntosd_644xa MACH_NTOSD_644XA NTOSD_644XA 1647
|
||||
+badger MACH_BADGER BADGER 1648
|
||||
+trizeps4wl MACH_TRIZEPS4WL TRIZEPS4WL 1649
|
||||
+trizeps5 MACH_TRIZEPS5 TRIZEPS5 1650
|
||||
+marlin MACH_MARLIN MARLIN 1651
|
||||
+ts7800 MACH_TS7800 TS7800 1652
|
||||
+hpipaq214 MACH_HPIPAQ214 HPIPAQ214 1653
|
||||
+at572d940dcm MACH_AT572D940DCM AT572D940DCM 1654
|
||||
+ne1board MACH_NE1BOARD NE1BOARD 1655
|
||||
+zante MACH_ZANTE ZANTE 1656
|
||||
+sffsdr MACH_SFFSDR SFFSDR 1657
|
||||
+tw2662 MACH_TW2662 TW2662 1658
|
||||
+vf10xx MACH_VF10XX VF10XX 1659
|
||||
+zoran43xx MACH_ZORAN43XX ZORAN43XX 1660
|
||||
+sonix926 MACH_SONIX926 SONIX926 1661
|
||||
+celestialsemi MACH_CELESTIALSEMI CELESTIALSEMI 1662
|
||||
+cc9m2443 MACH_CC9M2443 CC9M2443 1663
|
||||
+tw5334 MACH_TW5334 TW5334 1664
|
||||
+omap_htcartemis MACH_HTCARTEMIS HTCARTEMIS 1665
|
||||
+nal_hlite MACH_NAL_HLITE NAL_HLITE 1666
|
||||
+htcvogue MACH_HTCVOGUE HTCVOGUE 1667
|
||||
+smartweb MACH_SMARTWEB SMARTWEB 1668
|
||||
+mv86xx MACH_MV86XX MV86XX 1669
|
||||
+mv87xx MACH_MV87XX MV87XX 1670
|
||||
+songyoungho MACH_SONGYOUNGHO SONGYOUNGHO 1671
|
||||
+younghotema MACH_YOUNGHOTEMA YOUNGHOTEMA 1672
|
||||
+pcm037 MACH_PCM037 PCM037 1673
|
||||
+mmvp MACH_MMVP MMVP 1674
|
||||
+mmap MACH_MMAP MMAP 1675
|
||||
+ptid2410 MACH_PTID2410 PTID2410 1676
|
||||
+james_926 MACH_JAMES_926 JAMES_926 1677
|
||||
+fm6000 MACH_FM6000 FM6000 1678
|
||||
+db88f6281_bp MACH_DB88F6281_BP DB88F6281_BP 1680
|
||||
+rd88f6192_nas MACH_RD88F6192_NAS RD88F6192_NAS 1681
|
||||
+rd88f6281 MACH_RD88F6281 RD88F6281 1682
|
||||
+db78x00_bp MACH_DB78X00_BP DB78X00_BP 1683
|
||||
+smdk2416 MACH_SMDK2416 SMDK2416 1685
|
||||
+oce_spider_si MACH_OCE_SPIDER_SI OCE_SPIDER_SI 1686
|
||||
+oce_spider_sk MACH_OCE_SPIDER_SK OCE_SPIDER_SK 1687
|
||||
+rovern6 MACH_ROVERN6 ROVERN6 1688
|
||||
+pelco_evolution MACH_PELCO_EVOLUTION PELCO_EVOLUTION 1689
|
||||
+wbd111 MACH_WBD111 WBD111 1690
|
||||
+elaracpe MACH_ELARACPE ELARACPE 1691
|
||||
+mabv3 MACH_MABV3 MABV3 1692
|
||||
+mv2120 MACH_MV2120 MV2120 1693
|
||||
+csb737 MACH_CSB737 CSB737 1695
|
||||
+mx51_3ds MACH_MX51_3DS MX51_3DS 1696
|
||||
+g900 MACH_G900 G900 1697
|
||||
+apf27 MACH_APF27 APF27 1698
|
||||
+ggus2000 MACH_GGUS2000 GGUS2000 1699
|
||||
+omap_2430_mimic MACH_OMAP_2430_MIMIC OMAP_2430_MIMIC 1700
|
||||
+imx27lite MACH_IMX27LITE IMX27LITE 1701
|
||||
+almex MACH_ALMEX ALMEX 1702
|
||||
+control MACH_CONTROL CONTROL 1703
|
||||
+mba2410 MACH_MBA2410 MBA2410 1704
|
||||
+volcano MACH_VOLCANO VOLCANO 1705
|
||||
+zenith MACH_ZENITH ZENITH 1706
|
||||
+muchip MACH_MUCHIP MUCHIP 1707
|
||||
+magellan MACH_MAGELLAN MAGELLAN 1708
|
||||
+usb_a9260 MACH_USB_A9260 USB_A9260 1709
|
||||
+usb_a9263 MACH_USB_A9263 USB_A9263 1710
|
||||
+qil_a9260 MACH_QIL_A9260 QIL_A9260 1711
|
||||
+cme9210 MACH_CME9210 CME9210 1712
|
||||
+hczh4 MACH_HCZH4 HCZH4 1713
|
||||
+spearbasic MACH_SPEARBASIC SPEARBASIC 1714
|
||||
+dep2440 MACH_DEP2440 DEP2440 1715
|
||||
+hdl_gxr MACH_HDL_GXR HDL_GXR 1716
|
||||
+hdl_gt MACH_HDL_GT HDL_GT 1717
|
||||
+hdl_4g MACH_HDL_4G HDL_4G 1718
|
||||
+s3c6000 MACH_S3C6000 S3C6000 1719
|
||||
+mmsp2_mdk MACH_MMSP2_MDK MMSP2_MDK 1720
|
||||
+mpx220 MACH_MPX220 MPX220 1721
|
||||
+kzm_arm11_01 MACH_KZM_ARM11_01 KZM_ARM11_01 1722
|
||||
+htc_polaris MACH_HTC_POLARIS HTC_POLARIS 1723
|
||||
+htc_kaiser MACH_HTC_KAISER HTC_KAISER 1724
|
||||
+lg_ks20 MACH_LG_KS20 LG_KS20 1725
|
||||
+hhgps MACH_HHGPS HHGPS 1726
|
||||
+nokia_n810_wimax MACH_NOKIA_N810_WIMAX NOKIA_N810_WIMAX 1727
|
|
@ -1,89 +0,0 @@
|
|||
From: Guennadi Liakhovetski <g.liakhovetski@pengutronix.de>
|
||||
Date: Mon, 28 Apr 2008 09:14:44 +0000 (-0700)
|
||||
Subject: gpiolib: better rmmod infrastructure
|
||||
X-Git-Tag: v2.6.26-rc1~851
|
||||
X-Git-Url: http://git.kernel.org/?p=linux%2Fkernel%2Fgit%2Ftorvalds%2Flinux-2.6.git;a=commitdiff_plain;h=438d8908b379b6322fc3b28d45c9ebdddf58bc20
|
||||
|
||||
gpiolib: better rmmod infrastructure
|
||||
|
||||
As long as one or more GPIOs on a gpio chip are used its driver should not be
|
||||
unloaded. The existing mechanism (gpiochip_remove failure) doesn't address
|
||||
that, since rmmod can no longer be made to fail by having the cleanup code
|
||||
report errors. Module usecounts are the solution.
|
||||
|
||||
Assuming standard "initialize struct to zero" policies, this change won't
|
||||
affect SOC platform drivers. However, drivers for external chips (on I2C and
|
||||
SPI busses) should be updated if they can be built as modules.
|
||||
|
||||
Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@pengutronix.de>
|
||||
[ gpio_ensure_requested() needs to update module usecounts too ]
|
||||
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
|
||||
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
|
||||
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
|
||||
---
|
||||
|
||||
--- a/drivers/gpio/gpiolib.c
|
||||
+++ b/drivers/gpio/gpiolib.c
|
||||
@@ -68,6 +68,9 @@ static void gpio_ensure_requested(struct
|
||||
if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
|
||||
pr_warning("GPIO-%d autorequested\n", (int)(desc - gpio_desc));
|
||||
desc_set_label(desc, "[auto]");
|
||||
+ if (!try_module_get(desc->chip->owner))
|
||||
+ pr_err("GPIO-%d: module can't be gotten \n",
|
||||
+ (int)(desc - gpio_desc));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -177,6 +180,9 @@ int gpio_request(unsigned gpio, const ch
|
||||
if (desc->chip == NULL)
|
||||
goto done;
|
||||
|
||||
+ if (!try_module_get(desc->chip->owner))
|
||||
+ goto done;
|
||||
+
|
||||
/* NOTE: gpio_request() can be called in early boot,
|
||||
* before IRQs are enabled.
|
||||
*/
|
||||
@@ -184,8 +190,10 @@ int gpio_request(unsigned gpio, const ch
|
||||
if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
|
||||
desc_set_label(desc, label ? : "?");
|
||||
status = 0;
|
||||
- } else
|
||||
+ } else {
|
||||
status = -EBUSY;
|
||||
+ module_put(desc->chip->owner);
|
||||
+ }
|
||||
|
||||
done:
|
||||
if (status)
|
||||
@@ -209,9 +217,10 @@ void gpio_free(unsigned gpio)
|
||||
spin_lock_irqsave(&gpio_lock, flags);
|
||||
|
||||
desc = &gpio_desc[gpio];
|
||||
- if (desc->chip && test_and_clear_bit(FLAG_REQUESTED, &desc->flags))
|
||||
+ if (desc->chip && test_and_clear_bit(FLAG_REQUESTED, &desc->flags)) {
|
||||
desc_set_label(desc, NULL);
|
||||
- else
|
||||
+ module_put(desc->chip->owner);
|
||||
+ } else
|
||||
WARN_ON(extra_checks);
|
||||
|
||||
spin_unlock_irqrestore(&gpio_lock, flags);
|
||||
--- a/include/asm-generic/gpio.h
|
||||
+++ b/include/asm-generic/gpio.h
|
||||
@@ -17,6 +17,7 @@
|
||||
#endif
|
||||
|
||||
struct seq_file;
|
||||
+struct module;
|
||||
|
||||
/**
|
||||
* struct gpio_chip - abstract a GPIO controller
|
||||
@@ -48,6 +49,7 @@ struct seq_file;
|
||||
*/
|
||||
struct gpio_chip {
|
||||
char *label;
|
||||
+ struct module *owner;
|
||||
|
||||
int (*direction_input)(struct gpio_chip *chip,
|
||||
unsigned offset);
|
|
@ -1,134 +0,0 @@
|
|||
From: Guennadi Liakhovetski <g.liakhovetski@pengutronix.de>
|
||||
Date: Mon, 28 Apr 2008 09:14:46 +0000 (-0700)
|
||||
Subject: gpio: define gpio_is_valid()
|
||||
X-Git-Tag: v2.6.26-rc1~849
|
||||
X-Git-Url: http://git.kernel.org/?p=linux%2Fkernel%2Fgit%2Ftorvalds%2Flinux-2.6.git;a=commitdiff_plain;h=e6de1808f8ebfeb7e49f3c5a30cb8f2032beb287
|
||||
|
||||
gpio: define gpio_is_valid()
|
||||
|
||||
Introduce a gpio_is_valid() predicate; use it in gpiolib.
|
||||
|
||||
Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@pengutronix.de>
|
||||
[ use inline function; follow the gpio_* naming convention;
|
||||
work without gpiolib; all programming interfaces need docs ]
|
||||
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
|
||||
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
|
||||
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
|
||||
---
|
||||
|
||||
--- a/Documentation/gpio.txt
|
||||
+++ b/Documentation/gpio.txt
|
||||
@@ -107,6 +107,16 @@ type of GPIO controller, and on one part
|
||||
The numbers need not be contiguous; either of those platforms could also
|
||||
use numbers 2000-2063 to identify GPIOs in a bank of I2C GPIO expanders.
|
||||
|
||||
+If you want to initialize a structure with an invalid GPIO number, use
|
||||
+some negative number (perhaps "-EINVAL"); that will never be valid. To
|
||||
+test if a number could reference a GPIO, you may use this predicate:
|
||||
+
|
||||
+ int gpio_is_valid(int number);
|
||||
+
|
||||
+A number that's not valid will be rejected by calls which may request
|
||||
+or free GPIOs (see below). Other numbers may also be rejected; for
|
||||
+example, a number might be valid but unused on a given board.
|
||||
+
|
||||
Whether a platform supports multiple GPIO controllers is currently a
|
||||
platform-specific implementation issue.
|
||||
|
||||
--- a/drivers/gpio/gpiolib.c
|
||||
+++ b/drivers/gpio/gpiolib.c
|
||||
@@ -99,7 +99,7 @@ int gpiochip_add(struct gpio_chip *chip)
|
||||
* dynamic allocation. We don't currently support that.
|
||||
*/
|
||||
|
||||
- if (chip->base < 0 || (chip->base + chip->ngpio) >= ARCH_NR_GPIOS) {
|
||||
+ if (chip->base < 0 || !gpio_is_valid(chip->base + chip->ngpio)) {
|
||||
status = -EINVAL;
|
||||
goto fail;
|
||||
}
|
||||
@@ -174,7 +174,7 @@ int gpio_request(unsigned gpio, const ch
|
||||
|
||||
spin_lock_irqsave(&gpio_lock, flags);
|
||||
|
||||
- if (gpio >= ARCH_NR_GPIOS)
|
||||
+ if (!gpio_is_valid(gpio))
|
||||
goto done;
|
||||
desc = &gpio_desc[gpio];
|
||||
if (desc->chip == NULL)
|
||||
@@ -209,7 +209,7 @@ void gpio_free(unsigned gpio)
|
||||
unsigned long flags;
|
||||
struct gpio_desc *desc;
|
||||
|
||||
- if (gpio >= ARCH_NR_GPIOS) {
|
||||
+ if (!gpio_is_valid(gpio)) {
|
||||
WARN_ON(extra_checks);
|
||||
return;
|
||||
}
|
||||
@@ -245,7 +245,7 @@ const char *gpiochip_is_requested(struct
|
||||
{
|
||||
unsigned gpio = chip->base + offset;
|
||||
|
||||
- if (gpio >= ARCH_NR_GPIOS || gpio_desc[gpio].chip != chip)
|
||||
+ if (!gpio_is_valid(gpio) || gpio_desc[gpio].chip != chip)
|
||||
return NULL;
|
||||
if (test_bit(FLAG_REQUESTED, &gpio_desc[gpio].flags) == 0)
|
||||
return NULL;
|
||||
@@ -276,7 +276,7 @@ int gpio_direction_input(unsigned gpio)
|
||||
|
||||
spin_lock_irqsave(&gpio_lock, flags);
|
||||
|
||||
- if (gpio >= ARCH_NR_GPIOS)
|
||||
+ if (!gpio_is_valid(gpio))
|
||||
goto fail;
|
||||
chip = desc->chip;
|
||||
if (!chip || !chip->get || !chip->direction_input)
|
||||
@@ -314,7 +314,7 @@ int gpio_direction_output(unsigned gpio,
|
||||
|
||||
spin_lock_irqsave(&gpio_lock, flags);
|
||||
|
||||
- if (gpio >= ARCH_NR_GPIOS)
|
||||
+ if (!gpio_is_valid(gpio))
|
||||
goto fail;
|
||||
chip = desc->chip;
|
||||
if (!chip || !chip->set || !chip->direction_output)
|
||||
@@ -531,7 +531,7 @@ static int gpiolib_show(struct seq_file
|
||||
|
||||
/* REVISIT this isn't locked against gpio_chip removal ... */
|
||||
|
||||
- for (gpio = 0; gpio < ARCH_NR_GPIOS; gpio++) {
|
||||
+ for (gpio = 0; gpio_is_valid(gpio); gpio++) {
|
||||
if (chip == gpio_desc[gpio].chip)
|
||||
continue;
|
||||
chip = gpio_desc[gpio].chip;
|
||||
--- a/include/asm-generic/gpio.h
|
||||
+++ b/include/asm-generic/gpio.h
|
||||
@@ -16,6 +16,12 @@
|
||||
#define ARCH_NR_GPIOS 256
|
||||
#endif
|
||||
|
||||
+static inline int gpio_is_valid(int number)
|
||||
+{
|
||||
+ /* only some non-negative numbers are valid */
|
||||
+ return ((unsigned)number) < ARCH_NR_GPIOS;
|
||||
+}
|
||||
+
|
||||
struct seq_file;
|
||||
struct module;
|
||||
|
||||
@@ -99,6 +105,16 @@ extern int __gpio_cansleep(unsigned gpio
|
||||
|
||||
#else
|
||||
|
||||
+static inline int __gpio_is_valid(int number)
|
||||
+{
|
||||
+ /* only non-negative numbers are valid */
|
||||
+ return number >= 0;
|
||||
+}
|
||||
+
|
||||
+#ifndef gpio_is_valid
|
||||
+#define gpio_is_valid __gpio_is_valid
|
||||
+#endif
|
||||
+
|
||||
/* platforms that don't directly support access to GPIOs through I2C, SPI,
|
||||
* or other blocking infrastructure can use these wrappers.
|
||||
*/
|
|
@ -1,116 +0,0 @@
|
|||
From: Anton Vorontsov <avorontsov@ru.mvista.com>
|
||||
Date: Mon, 28 Apr 2008 09:14:46 +0000 (-0700)
|
||||
Subject: gpiolib: dynamic gpio number allocation
|
||||
X-Git-Tag: v2.6.26-rc1~848
|
||||
X-Git-Url: http://git.kernel.org/?p=linux%2Fkernel%2Fgit%2Ftorvalds%2Flinux-2.6.git;a=commitdiff_plain;h=8d0aab2f16c4fa170f32e7a74a52cd0122bbafef
|
||||
|
||||
gpiolib: dynamic gpio number allocation
|
||||
|
||||
If gpio_chip->base is negative during registration, gpiolib performs dynamic
|
||||
base allocation. This is useful for devices that aren't always present, such
|
||||
as GPIOs on hotplugged devices rather than mainboards. (This behavior was
|
||||
previously specified but not implemented.)
|
||||
|
||||
To avoid using any numbers that may have been explicitly assigned but not yet
|
||||
registered, this dynamic allocation assigns GPIO numbers from the biggest
|
||||
number on down, instead of from the smallest on up.
|
||||
|
||||
Signed-off-by: Anton Vorontsov <avorontsov@ru.mvista.com>
|
||||
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
|
||||
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
|
||||
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
|
||||
---
|
||||
|
||||
--- a/drivers/gpio/gpiolib.c
|
||||
+++ b/drivers/gpio/gpiolib.c
|
||||
@@ -80,6 +80,33 @@ static inline struct gpio_chip *gpio_to_
|
||||
return gpio_desc[gpio].chip;
|
||||
}
|
||||
|
||||
+/* dynamic allocation of GPIOs, e.g. on a hotplugged device */
|
||||
+static int gpiochip_find_base(int ngpio)
|
||||
+{
|
||||
+ int i;
|
||||
+ int spare = 0;
|
||||
+ int base = -ENOSPC;
|
||||
+
|
||||
+ for (i = ARCH_NR_GPIOS - 1; i >= 0 ; i--) {
|
||||
+ struct gpio_chip *chip = gpio_desc[i].chip;
|
||||
+
|
||||
+ if (!chip) {
|
||||
+ spare++;
|
||||
+ if (spare == ngpio) {
|
||||
+ base = i;
|
||||
+ break;
|
||||
+ }
|
||||
+ } else {
|
||||
+ spare = 0;
|
||||
+ i -= chip->ngpio - 1;
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
+ if (gpio_is_valid(base))
|
||||
+ pr_debug("%s: found new base at %d\n", __func__, base);
|
||||
+ return base;
|
||||
+}
|
||||
+
|
||||
/**
|
||||
* gpiochip_add() - register a gpio_chip
|
||||
* @chip: the chip to register, with chip->base initialized
|
||||
@@ -88,38 +115,49 @@ static inline struct gpio_chip *gpio_to_
|
||||
* Returns a negative errno if the chip can't be registered, such as
|
||||
* because the chip->base is invalid or already associated with a
|
||||
* different chip. Otherwise it returns zero as a success code.
|
||||
+ *
|
||||
+ * If chip->base is negative, this requests dynamic assignment of
|
||||
+ * a range of valid GPIOs.
|
||||
*/
|
||||
int gpiochip_add(struct gpio_chip *chip)
|
||||
{
|
||||
unsigned long flags;
|
||||
int status = 0;
|
||||
unsigned id;
|
||||
+ int base = chip->base;
|
||||
|
||||
- /* NOTE chip->base negative is reserved to mean a request for
|
||||
- * dynamic allocation. We don't currently support that.
|
||||
- */
|
||||
-
|
||||
- if (chip->base < 0 || !gpio_is_valid(chip->base + chip->ngpio)) {
|
||||
+ if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio))
|
||||
+ && base >= 0) {
|
||||
status = -EINVAL;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&gpio_lock, flags);
|
||||
|
||||
+ if (base < 0) {
|
||||
+ base = gpiochip_find_base(chip->ngpio);
|
||||
+ if (base < 0) {
|
||||
+ status = base;
|
||||
+ goto fail_unlock;
|
||||
+ }
|
||||
+ chip->base = base;
|
||||
+ }
|
||||
+
|
||||
/* these GPIO numbers must not be managed by another gpio_chip */
|
||||
- for (id = chip->base; id < chip->base + chip->ngpio; id++) {
|
||||
+ for (id = base; id < base + chip->ngpio; id++) {
|
||||
if (gpio_desc[id].chip != NULL) {
|
||||
status = -EBUSY;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (status == 0) {
|
||||
- for (id = chip->base; id < chip->base + chip->ngpio; id++) {
|
||||
+ for (id = base; id < base + chip->ngpio; id++) {
|
||||
gpio_desc[id].chip = chip;
|
||||
gpio_desc[id].flags = 0;
|
||||
}
|
||||
}
|
||||
|
||||
+fail_unlock:
|
||||
spin_unlock_irqrestore(&gpio_lock, flags);
|
||||
fail:
|
||||
/* failures here can mean systems won't boot... */
|
|
@ -1,112 +0,0 @@
|
|||
From: Anton Vorontsov <avorontsov@ru.mvista.com>
|
||||
Date: Mon, 28 Apr 2008 09:14:47 +0000 (-0700)
|
||||
Subject: gpiochip_reserve()
|
||||
X-Git-Tag: v2.6.26-rc1~847
|
||||
X-Git-Url: http://git.kernel.org/?p=linux%2Fkernel%2Fgit%2Ftorvalds%2Flinux-2.6.git;a=commitdiff_plain;h=169b6a7a6e91e1ea32136681b475cbaf2074bf35
|
||||
|
||||
gpiochip_reserve()
|
||||
|
||||
Add a new function gpiochip_reserve() to reserve ranges of gpios that platform
|
||||
code has pre-allocated. That is, this marks gpio numbers which will be
|
||||
claimed by drivers that haven't yet been loaded, and thus are not available
|
||||
for dynamic gpio number allocation.
|
||||
|
||||
[akpm@linux-foundation.org: remove unneeded __must_check]
|
||||
[david-b@pacbell.net: don't export gpiochip_reserve (section fix)]
|
||||
Signed-off-by: Anton Vorontsov <avorontsov@ru.mvista.com>
|
||||
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
|
||||
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
|
||||
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
|
||||
---
|
||||
|
||||
--- a/drivers/gpio/gpiolib.c
|
||||
+++ b/drivers/gpio/gpiolib.c
|
||||
@@ -43,6 +43,7 @@ struct gpio_desc {
|
||||
/* flag symbols are bit numbers */
|
||||
#define FLAG_REQUESTED 0
|
||||
#define FLAG_IS_OUT 1
|
||||
+#define FLAG_RESERVED 2
|
||||
|
||||
#ifdef CONFIG_DEBUG_FS
|
||||
const char *label;
|
||||
@@ -88,9 +89,10 @@ static int gpiochip_find_base(int ngpio)
|
||||
int base = -ENOSPC;
|
||||
|
||||
for (i = ARCH_NR_GPIOS - 1; i >= 0 ; i--) {
|
||||
- struct gpio_chip *chip = gpio_desc[i].chip;
|
||||
+ struct gpio_desc *desc = &gpio_desc[i];
|
||||
+ struct gpio_chip *chip = desc->chip;
|
||||
|
||||
- if (!chip) {
|
||||
+ if (!chip && !test_bit(FLAG_RESERVED, &desc->flags)) {
|
||||
spare++;
|
||||
if (spare == ngpio) {
|
||||
base = i;
|
||||
@@ -98,7 +100,8 @@ static int gpiochip_find_base(int ngpio)
|
||||
}
|
||||
} else {
|
||||
spare = 0;
|
||||
- i -= chip->ngpio - 1;
|
||||
+ if (chip)
|
||||
+ i -= chip->ngpio - 1;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -108,6 +111,47 @@ static int gpiochip_find_base(int ngpio)
|
||||
}
|
||||
|
||||
/**
|
||||
+ * gpiochip_reserve() - reserve range of gpios to use with platform code only
|
||||
+ * @start: starting gpio number
|
||||
+ * @ngpio: number of gpios to reserve
|
||||
+ * Context: platform init, potentially before irqs or kmalloc will work
|
||||
+ *
|
||||
+ * Returns a negative errno if any gpio within the range is already reserved
|
||||
+ * or registered, else returns zero as a success code. Use this function
|
||||
+ * to mark a range of gpios as unavailable for dynamic gpio number allocation,
|
||||
+ * for example because its driver support is not yet loaded.
|
||||
+ */
|
||||
+int __init gpiochip_reserve(int start, int ngpio)
|
||||
+{
|
||||
+ int ret = 0;
|
||||
+ unsigned long flags;
|
||||
+ int i;
|
||||
+
|
||||
+ if (!gpio_is_valid(start) || !gpio_is_valid(start + ngpio))
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ spin_lock_irqsave(&gpio_lock, flags);
|
||||
+
|
||||
+ for (i = start; i < start + ngpio; i++) {
|
||||
+ struct gpio_desc *desc = &gpio_desc[i];
|
||||
+
|
||||
+ if (desc->chip || test_bit(FLAG_RESERVED, &desc->flags)) {
|
||||
+ ret = -EBUSY;
|
||||
+ goto err;
|
||||
+ }
|
||||
+
|
||||
+ set_bit(FLAG_RESERVED, &desc->flags);
|
||||
+ }
|
||||
+
|
||||
+ pr_debug("%s: reserved gpios from %d to %d\n",
|
||||
+ __func__, start, start + ngpio - 1);
|
||||
+err:
|
||||
+ spin_unlock_irqrestore(&gpio_lock, flags);
|
||||
+
|
||||
+ return ret;
|
||||
+}
|
||||
+
|
||||
+/**
|
||||
* gpiochip_add() - register a gpio_chip
|
||||
* @chip: the chip to register, with chip->base initialized
|
||||
* Context: potentially before irqs or kmalloc will work
|
||||
--- a/include/asm-generic/gpio.h
|
||||
+++ b/include/asm-generic/gpio.h
|
||||
@@ -74,6 +74,7 @@ struct gpio_chip {
|
||||
|
||||
extern const char *gpiochip_is_requested(struct gpio_chip *chip,
|
||||
unsigned offset);
|
||||
+extern int __init __must_check gpiochip_reserve(int start, int ngpio);
|
||||
|
||||
/* add/remove chips */
|
||||
extern int gpiochip_add(struct gpio_chip *chip);
|
|
@ -1,46 +0,0 @@
|
|||
From: Trent Piepho <xyzzy@speakeasy.org>
|
||||
Date: Fri, 23 May 2008 20:04:44 +0000 (-0700)
|
||||
Subject: gpiolib: fix off by one errors
|
||||
X-Git-Tag: v2.6.26-rc4~31
|
||||
X-Git-Url: http://git.kernel.org/?p=linux%2Fkernel%2Fgit%2Ftorvalds%2Flinux-2.6.git;a=commitdiff_plain;h=bff5fda972dc23bd1806a47c2098ae173585d013
|
||||
|
||||
gpiolib: fix off by one errors
|
||||
|
||||
The last gpio belonging to a chip is chip->base + chip->ngpios - 1. Some
|
||||
places in the code, but not all, forgot the critical minus one.
|
||||
|
||||
Signed-off-by: Trent Piepho <xyzzy@speakeasy.org>
|
||||
Acked-by: David Brownell <dbrownell@users.sourceforge.net>
|
||||
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
|
||||
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
|
||||
---
|
||||
|
||||
--- a/drivers/gpio/gpiolib.c
|
||||
+++ b/drivers/gpio/gpiolib.c
|
||||
@@ -127,7 +127,7 @@ int __init gpiochip_reserve(int start, i
|
||||
unsigned long flags;
|
||||
int i;
|
||||
|
||||
- if (!gpio_is_valid(start) || !gpio_is_valid(start + ngpio))
|
||||
+ if (!gpio_is_valid(start) || !gpio_is_valid(start + ngpio - 1))
|
||||
return -EINVAL;
|
||||
|
||||
spin_lock_irqsave(&gpio_lock, flags);
|
||||
@@ -170,7 +170,7 @@ int gpiochip_add(struct gpio_chip *chip)
|
||||
unsigned id;
|
||||
int base = chip->base;
|
||||
|
||||
- if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio))
|
||||
+ if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
|
||||
&& base >= 0) {
|
||||
status = -EINVAL;
|
||||
goto fail;
|
||||
@@ -207,7 +207,7 @@ fail:
|
||||
/* failures here can mean systems won't boot... */
|
||||
if (status)
|
||||
pr_err("gpiochip_add: gpios %d..%d (%s) not registered\n",
|
||||
- chip->base, chip->base + chip->ngpio,
|
||||
+ chip->base, chip->base + chip->ngpio - 1,
|
||||
chip->label ? : "generic");
|
||||
return status;
|
||||
}
|
|
@ -1,170 +0,0 @@
|
|||
--- a/drivers/char/random.c
|
||||
+++ b/drivers/char/random.c
|
||||
@@ -129,6 +129,9 @@
|
||||
* unsigned int value);
|
||||
* void add_interrupt_randomness(int irq);
|
||||
*
|
||||
+ * void random_input_words(__u32 *buf, size_t wordcount, int ent_count)
|
||||
+ * int random_input_wait(void);
|
||||
+ *
|
||||
* add_input_randomness() uses the input layer interrupt timing, as well as
|
||||
* the event type information from the hardware.
|
||||
*
|
||||
@@ -140,6 +143,13 @@
|
||||
* a better measure, since the timing of the disk interrupts are more
|
||||
* unpredictable.
|
||||
*
|
||||
+ * random_input_words() just provides a raw block of entropy to the input
|
||||
+ * pool, such as from a hardware entropy generator.
|
||||
+ *
|
||||
+ * random_input_wait() suspends the caller until such time as the
|
||||
+ * entropy pool falls below the write threshold, and returns a count of how
|
||||
+ * much entropy (in bits) is needed to sustain the pool.
|
||||
+ *
|
||||
* All of these routines try to estimate how many bits of randomness a
|
||||
* particular randomness source. They do this by keeping track of the
|
||||
* first and second order deltas of the event timings.
|
||||
@@ -669,6 +679,61 @@ void add_disk_randomness(struct gendisk
|
||||
}
|
||||
#endif
|
||||
|
||||
+/*
|
||||
+ * random_input_words - add bulk entropy to pool
|
||||
+ *
|
||||
+ * @buf: buffer to add
|
||||
+ * @wordcount: number of __u32 words to add
|
||||
+ * @ent_count: total amount of entropy (in bits) to credit
|
||||
+ *
|
||||
+ * this provides bulk input of entropy to the input pool
|
||||
+ *
|
||||
+ */
|
||||
+void random_input_words(__u32 *buf, size_t wordcount, int ent_count)
|
||||
+{
|
||||
+ mix_pool_bytes(&input_pool, buf, wordcount*4);
|
||||
+
|
||||
+ credit_entropy_bits(&input_pool, ent_count);
|
||||
+
|
||||
+ DEBUG_ENT("crediting %d bits => %d\n",
|
||||
+ ent_count, input_pool.entropy_count);
|
||||
+ /*
|
||||
+ * Wake up waiting processes if we have enough
|
||||
+ * entropy.
|
||||
+ */
|
||||
+ if (input_pool.entropy_count >= random_read_wakeup_thresh)
|
||||
+ wake_up_interruptible(&random_read_wait);
|
||||
+}
|
||||
+EXPORT_SYMBOL(random_input_words);
|
||||
+
|
||||
+/*
|
||||
+ * random_input_wait - wait until random needs entropy
|
||||
+ *
|
||||
+ * this function sleeps until the /dev/random subsystem actually
|
||||
+ * needs more entropy, and then return the amount of entropy
|
||||
+ * that it would be nice to have added to the system.
|
||||
+ */
|
||||
+int random_input_wait(void)
|
||||
+{
|
||||
+ int count;
|
||||
+
|
||||
+ wait_event_interruptible(random_write_wait,
|
||||
+ input_pool.entropy_count < random_write_wakeup_thresh);
|
||||
+
|
||||
+ count = random_write_wakeup_thresh - input_pool.entropy_count;
|
||||
+
|
||||
+ /* likely we got woken up due to a signal */
|
||||
+ if (count <= 0) count = random_read_wakeup_thresh;
|
||||
+
|
||||
+ DEBUG_ENT("requesting %d bits from input_wait()er %d<%d\n",
|
||||
+ count,
|
||||
+ input_pool.entropy_count, random_write_wakeup_thresh);
|
||||
+
|
||||
+ return count;
|
||||
+}
|
||||
+EXPORT_SYMBOL(random_input_wait);
|
||||
+
|
||||
+
|
||||
#define EXTRACT_SIZE 10
|
||||
|
||||
/*********************************************************************
|
||||
--- a/fs/fcntl.c
|
||||
+++ b/fs/fcntl.c
|
||||
@@ -136,6 +136,7 @@ static int dupfd(struct file *file, unsi
|
||||
|
||||
return fd;
|
||||
}
|
||||
+EXPORT_SYMBOL(sys_dup);
|
||||
|
||||
asmlinkage long sys_dup2(unsigned int oldfd, unsigned int newfd)
|
||||
{
|
||||
--- a/include/linux/miscdevice.h
|
||||
+++ b/include/linux/miscdevice.h
|
||||
@@ -12,6 +12,7 @@
|
||||
#define APOLLO_MOUSE_MINOR 7
|
||||
#define PC110PAD_MINOR 9
|
||||
/*#define ADB_MOUSE_MINOR 10 FIXME OBSOLETE */
|
||||
+#define CRYPTODEV_MINOR 70
|
||||
#define WATCHDOG_MINOR 130 /* Watchdog timer */
|
||||
#define TEMP_MINOR 131 /* Temperature Sensor */
|
||||
#define RTC_MINOR 135
|
||||
--- a/include/linux/random.h
|
||||
+++ b/include/linux/random.h
|
||||
@@ -8,6 +8,7 @@
|
||||
#define _LINUX_RANDOM_H
|
||||
|
||||
#include <linux/ioctl.h>
|
||||
+#include <linux/types.h> /* for __u32 in user space */
|
||||
|
||||
/* ioctl()'s for the random number generator */
|
||||
|
||||
@@ -32,6 +33,30 @@
|
||||
/* Clear the entropy pool and associated counters. (Superuser only.) */
|
||||
#define RNDCLEARPOOL _IO( 'R', 0x06 )
|
||||
|
||||
+#ifdef CONFIG_FIPS_RNG
|
||||
+
|
||||
+/* Size of seed value - equal to AES blocksize */
|
||||
+#define AES_BLOCK_SIZE_BYTES 16
|
||||
+#define SEED_SIZE_BYTES AES_BLOCK_SIZE_BYTES
|
||||
+/* Size of AES key */
|
||||
+#define KEY_SIZE_BYTES 16
|
||||
+
|
||||
+/* ioctl() structure used by FIPS 140-2 Tests */
|
||||
+struct rand_fips_test {
|
||||
+ unsigned char key[KEY_SIZE_BYTES]; /* Input */
|
||||
+ unsigned char datetime[SEED_SIZE_BYTES]; /* Input */
|
||||
+ unsigned char seed[SEED_SIZE_BYTES]; /* Input */
|
||||
+ unsigned char result[SEED_SIZE_BYTES]; /* Output */
|
||||
+};
|
||||
+
|
||||
+/* FIPS 140-2 RNG Variable Seed Test. (Superuser only.) */
|
||||
+#define RNDFIPSVST _IOWR('R', 0x10, struct rand_fips_test)
|
||||
+
|
||||
+/* FIPS 140-2 RNG Monte Carlo Test. (Superuser only.) */
|
||||
+#define RNDFIPSMCT _IOWR('R', 0x11, struct rand_fips_test)
|
||||
+
|
||||
+#endif /* #ifdef CONFIG_FIPS_RNG */
|
||||
+
|
||||
struct rand_pool_info {
|
||||
int entropy_count;
|
||||
int buf_size;
|
||||
@@ -48,6 +73,10 @@ extern void add_input_randomness(unsigne
|
||||
unsigned int value);
|
||||
extern void add_interrupt_randomness(int irq);
|
||||
|
||||
+extern void random_input_words(__u32 *buf, size_t wordcount, int ent_count);
|
||||
+extern int random_input_wait(void);
|
||||
+#define HAS_RANDOM_INPUT_WAIT 1
|
||||
+
|
||||
extern void get_random_bytes(void *buf, int nbytes);
|
||||
void generate_random_uuid(unsigned char uuid_out[16]);
|
||||
|
||||
--- a/kernel/pid.c
|
||||
+++ b/kernel/pid.c
|
||||
@@ -377,6 +377,7 @@ struct task_struct *find_task_by_pid_typ
|
||||
{
|
||||
return pid_task(find_pid_ns(nr, ns), type);
|
||||
}
|
||||
+EXPORT_SYMBOL(find_task_by_vpid);
|
||||
|
||||
EXPORT_SYMBOL(find_task_by_pid_type_ns);
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
--- a/drivers/usb/serial/sierra.c
|
||||
+++ b/drivers/usb/serial/sierra.c
|
||||
@@ -166,14 +166,19 @@ static struct usb_device_id id_table []
|
||||
{ USB_DEVICE(0x1199, 0x6815) }, /* Sierra Wireless MC8775 */
|
||||
{ USB_DEVICE(0x03f0, 0x1e1d) }, /* HP hs2300 a.k.a MC8775 */
|
||||
{ USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
|
||||
+ { USB_DEVICE(0x1199, 0x6821) }, /* Sierra Wireless AirCard 875U */
|
||||
{ USB_DEVICE(0x1199, 0x6832) }, /* Sierra Wireless MC8780*/
|
||||
{ USB_DEVICE(0x1199, 0x6833) }, /* Sierra Wireless MC8781*/
|
||||
+ { USB_DEVICE(0x1199, 0x683B), .driver_info = DEVICE_1_PORT }, /* Sierra Wireless MC8785 Composite*/
|
||||
+ { USB_DEVICE(0x1199, 0x683C), .driver_info = DEVICE_1_PORT }, /* Sierra Wireless MC8790 Composite*/
|
||||
{ USB_DEVICE(0x1199, 0x6850) }, /* Sierra Wireless AirCard 880 */
|
||||
{ USB_DEVICE(0x1199, 0x6851) }, /* Sierra Wireless AirCard 881 */
|
||||
{ USB_DEVICE(0x1199, 0x6852) }, /* Sierra Wireless AirCard 880 E */
|
||||
{ USB_DEVICE(0x1199, 0x6853) }, /* Sierra Wireless AirCard 881 E */
|
||||
{ USB_DEVICE(0x1199, 0x6855) }, /* Sierra Wireless AirCard 880 U */
|
||||
{ USB_DEVICE(0x1199, 0x6856) }, /* Sierra Wireless AirCard 881 U */
|
||||
+ { USB_DEVICE(0x1199, 0x6859), .driver_info = DEVICE_1_PORT }, /* Sierra Wireless AirCard 885 E */
|
||||
+ { USB_DEVICE(0x1199, 0x685A), .driver_info = DEVICE_1_PORT }, /* Sierra Wireless AirCard 885 E */
|
||||
|
||||
{ USB_DEVICE(0x1199, 0x6468) }, /* Sierra Wireless MP3G - EVDO */
|
||||
{ USB_DEVICE(0x1199, 0x6469) }, /* Sierra Wireless MP3G - UMTS/HSPA */
|
|
@ -1,14 +0,0 @@
|
|||
--- a/init/main.c
|
||||
+++ b/init/main.c
|
||||
@@ -797,10 +797,7 @@ static int noinline init_post(void)
|
||||
printk(KERN_WARNING "Failed to execute %s. Attempting "
|
||||
"defaults...\n", execute_command);
|
||||
}
|
||||
- run_init_process("/sbin/init");
|
||||
- run_init_process("/etc/init");
|
||||
- run_init_process("/bin/init");
|
||||
- run_init_process("/bin/sh");
|
||||
+ run_init_process("/etc/preinit");
|
||||
|
||||
panic("No init found. Try passing init= option to kernel.");
|
||||
}
|
|
@ -19,12 +19,10 @@ tools-y += sstrip ipkg-utils genext2fs e2fsprogs mtd-utils mkimage
|
|||
tools-y += firmware-utils patch-cmdline quilt yaffs2 flock
|
||||
tools-$(CONFIG_TARGET_orion_generic) += wrt350nv2-builder upslug2
|
||||
tools-$(CONFIG_TARGET_x86) += qemu
|
||||
ifneq ($(CONFIG_LINUX_2_6_25)$(CONFIG_TARGET_ar71xx),)
|
||||
ifneq ($(CONFIG_TARGET_ar71xx),)
|
||||
tools-y += squashfs lzma-old
|
||||
endif
|
||||
ifeq ($(CONFIG_LINUX_2_6_25),)
|
||||
tools-y += squashfs4 lzma
|
||||
endif
|
||||
tools-$(CONFIG_CCACHE) += ccache
|
||||
|
||||
ifdef CONFIG_GCC_USE_GRAPHITE
|
||||
|
|
Loading…
Reference in a new issue