Merge remote-tracking branch 'origin' into spi/merge
This commit is contained in:
commit
b6336ca298
2
Makefile
2
Makefile
|
@ -1,7 +1,7 @@
|
|||
VERSION = 3
|
||||
PATCHLEVEL = 0
|
||||
SUBLEVEL = 0
|
||||
EXTRAVERSION = -rc1
|
||||
EXTRAVERSION = -rc2
|
||||
NAME = Sneaky Weasel
|
||||
|
||||
# *DOCUMENTATION*
|
||||
|
|
|
@ -249,6 +249,29 @@ static int slot_cn7_get_cd(struct platform_device *pdev)
|
|||
{
|
||||
return !gpio_get_value(GPIO_PORT41);
|
||||
}
|
||||
/* MERAM */
|
||||
static struct sh_mobile_meram_info meram_info = {
|
||||
.addr_mode = SH_MOBILE_MERAM_MODE1,
|
||||
};
|
||||
|
||||
static struct resource meram_resources[] = {
|
||||
[0] = {
|
||||
.name = "MERAM",
|
||||
.start = 0xe8000000,
|
||||
.end = 0xe81fffff,
|
||||
.flags = IORESOURCE_MEM,
|
||||
},
|
||||
};
|
||||
|
||||
static struct platform_device meram_device = {
|
||||
.name = "sh_mobile_meram",
|
||||
.id = 0,
|
||||
.num_resources = ARRAY_SIZE(meram_resources),
|
||||
.resource = meram_resources,
|
||||
.dev = {
|
||||
.platform_data = &meram_info,
|
||||
},
|
||||
};
|
||||
|
||||
/* SH_MMCIF */
|
||||
static struct resource sh_mmcif_resources[] = {
|
||||
|
@ -447,13 +470,29 @@ const static struct fb_videomode ap4evb_lcdc_modes[] = {
|
|||
#endif
|
||||
},
|
||||
};
|
||||
static struct sh_mobile_meram_cfg lcd_meram_cfg = {
|
||||
.icb[0] = {
|
||||
.marker_icb = 28,
|
||||
.cache_icb = 24,
|
||||
.meram_offset = 0x0,
|
||||
.meram_size = 0x40,
|
||||
},
|
||||
.icb[1] = {
|
||||
.marker_icb = 29,
|
||||
.cache_icb = 25,
|
||||
.meram_offset = 0x40,
|
||||
.meram_size = 0x40,
|
||||
},
|
||||
};
|
||||
|
||||
static struct sh_mobile_lcdc_info lcdc_info = {
|
||||
.meram_dev = &meram_info,
|
||||
.ch[0] = {
|
||||
.chan = LCDC_CHAN_MAINLCD,
|
||||
.bpp = 16,
|
||||
.lcd_cfg = ap4evb_lcdc_modes,
|
||||
.num_cfg = ARRAY_SIZE(ap4evb_lcdc_modes),
|
||||
.meram_cfg = &lcd_meram_cfg,
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -724,15 +763,31 @@ static struct platform_device fsi_device = {
|
|||
static struct platform_device fsi_ak4643_device = {
|
||||
.name = "sh_fsi2_a_ak4643",
|
||||
};
|
||||
static struct sh_mobile_meram_cfg hdmi_meram_cfg = {
|
||||
.icb[0] = {
|
||||
.marker_icb = 30,
|
||||
.cache_icb = 26,
|
||||
.meram_offset = 0x80,
|
||||
.meram_size = 0x100,
|
||||
},
|
||||
.icb[1] = {
|
||||
.marker_icb = 31,
|
||||
.cache_icb = 27,
|
||||
.meram_offset = 0x180,
|
||||
.meram_size = 0x100,
|
||||
},
|
||||
};
|
||||
|
||||
static struct sh_mobile_lcdc_info sh_mobile_lcdc1_info = {
|
||||
.clock_source = LCDC_CLK_EXTERNAL,
|
||||
.meram_dev = &meram_info,
|
||||
.ch[0] = {
|
||||
.chan = LCDC_CHAN_MAINLCD,
|
||||
.bpp = 16,
|
||||
.interface_type = RGB24,
|
||||
.clock_divider = 1,
|
||||
.flags = LCDC_FLAGS_DWPOL,
|
||||
.meram_cfg = &hdmi_meram_cfg,
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -961,6 +1016,7 @@ static struct platform_device *ap4evb_devices[] __initdata = {
|
|||
&csi2_device,
|
||||
&ceu_device,
|
||||
&ap4evb_camera,
|
||||
&meram_device,
|
||||
};
|
||||
|
||||
static void __init hdmi_init_pm_clock(void)
|
||||
|
|
|
@ -39,6 +39,7 @@
|
|||
#include <linux/mtd/mtd.h>
|
||||
#include <linux/mtd/partitions.h>
|
||||
#include <linux/mtd/physmap.h>
|
||||
#include <linux/pm_runtime.h>
|
||||
#include <linux/smsc911x.h>
|
||||
#include <linux/sh_intc.h>
|
||||
#include <linux/tca6416_keypad.h>
|
||||
|
@ -314,6 +315,30 @@ static struct platform_device smc911x_device = {
|
|||
},
|
||||
};
|
||||
|
||||
/* MERAM */
|
||||
static struct sh_mobile_meram_info mackerel_meram_info = {
|
||||
.addr_mode = SH_MOBILE_MERAM_MODE1,
|
||||
};
|
||||
|
||||
static struct resource meram_resources[] = {
|
||||
[0] = {
|
||||
.name = "MERAM",
|
||||
.start = 0xe8000000,
|
||||
.end = 0xe81fffff,
|
||||
.flags = IORESOURCE_MEM,
|
||||
},
|
||||
};
|
||||
|
||||
static struct platform_device meram_device = {
|
||||
.name = "sh_mobile_meram",
|
||||
.id = 0,
|
||||
.num_resources = ARRAY_SIZE(meram_resources),
|
||||
.resource = meram_resources,
|
||||
.dev = {
|
||||
.platform_data = &mackerel_meram_info,
|
||||
},
|
||||
};
|
||||
|
||||
/* LCDC */
|
||||
static struct fb_videomode mackerel_lcdc_modes[] = {
|
||||
{
|
||||
|
@ -342,7 +367,23 @@ static int mackerel_get_brightness(void *board_data)
|
|||
return gpio_get_value(GPIO_PORT31);
|
||||
}
|
||||
|
||||
static struct sh_mobile_meram_cfg lcd_meram_cfg = {
|
||||
.icb[0] = {
|
||||
.marker_icb = 28,
|
||||
.cache_icb = 24,
|
||||
.meram_offset = 0x0,
|
||||
.meram_size = 0x40,
|
||||
},
|
||||
.icb[1] = {
|
||||
.marker_icb = 29,
|
||||
.cache_icb = 25,
|
||||
.meram_offset = 0x40,
|
||||
.meram_size = 0x40,
|
||||
},
|
||||
};
|
||||
|
||||
static struct sh_mobile_lcdc_info lcdc_info = {
|
||||
.meram_dev = &mackerel_meram_info,
|
||||
.clock_source = LCDC_CLK_BUS,
|
||||
.ch[0] = {
|
||||
.chan = LCDC_CHAN_MAINLCD,
|
||||
|
@ -362,6 +403,7 @@ static struct sh_mobile_lcdc_info lcdc_info = {
|
|||
.name = "sh_mobile_lcdc_bl",
|
||||
.max_brightness = 1,
|
||||
},
|
||||
.meram_cfg = &lcd_meram_cfg,
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -388,8 +430,23 @@ static struct platform_device lcdc_device = {
|
|||
},
|
||||
};
|
||||
|
||||
static struct sh_mobile_meram_cfg hdmi_meram_cfg = {
|
||||
.icb[0] = {
|
||||
.marker_icb = 30,
|
||||
.cache_icb = 26,
|
||||
.meram_offset = 0x80,
|
||||
.meram_size = 0x100,
|
||||
},
|
||||
.icb[1] = {
|
||||
.marker_icb = 31,
|
||||
.cache_icb = 27,
|
||||
.meram_offset = 0x180,
|
||||
.meram_size = 0x100,
|
||||
},
|
||||
};
|
||||
/* HDMI */
|
||||
static struct sh_mobile_lcdc_info hdmi_lcdc_info = {
|
||||
.meram_dev = &mackerel_meram_info,
|
||||
.clock_source = LCDC_CLK_EXTERNAL,
|
||||
.ch[0] = {
|
||||
.chan = LCDC_CHAN_MAINLCD,
|
||||
|
@ -397,6 +454,7 @@ static struct sh_mobile_lcdc_info hdmi_lcdc_info = {
|
|||
.interface_type = RGB24,
|
||||
.clock_divider = 1,
|
||||
.flags = LCDC_FLAGS_DWPOL,
|
||||
.meram_cfg = &hdmi_meram_cfg,
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -856,6 +914,17 @@ static int slot_cn7_get_cd(struct platform_device *pdev)
|
|||
}
|
||||
|
||||
/* SDHI0 */
|
||||
static irqreturn_t mackerel_sdhi0_gpio_cd(int irq, void *arg)
|
||||
{
|
||||
struct device *dev = arg;
|
||||
struct sh_mobile_sdhi_info *info = dev->platform_data;
|
||||
struct tmio_mmc_data *pdata = info->pdata;
|
||||
|
||||
tmio_mmc_cd_wakeup(pdata);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static struct sh_mobile_sdhi_info sdhi0_info = {
|
||||
.dma_slave_tx = SHDMA_SLAVE_SDHI0_TX,
|
||||
.dma_slave_rx = SHDMA_SLAVE_SDHI0_RX,
|
||||
|
@ -1150,6 +1219,7 @@ static struct platform_device *mackerel_devices[] __initdata = {
|
|||
&mackerel_camera,
|
||||
&hdmi_lcdc_device,
|
||||
&hdmi_device,
|
||||
&meram_device,
|
||||
};
|
||||
|
||||
/* Keypad Initialization */
|
||||
|
@ -1238,6 +1308,7 @@ static void __init mackerel_init(void)
|
|||
{
|
||||
u32 srcr4;
|
||||
struct clk *clk;
|
||||
int ret;
|
||||
|
||||
sh7372_pinmux_init();
|
||||
|
||||
|
@ -1343,6 +1414,13 @@ static void __init mackerel_init(void)
|
|||
gpio_request(GPIO_FN_SDHID0_1, NULL);
|
||||
gpio_request(GPIO_FN_SDHID0_0, NULL);
|
||||
|
||||
ret = request_irq(evt2irq(0x3340), mackerel_sdhi0_gpio_cd,
|
||||
IRQF_TRIGGER_FALLING, "sdhi0 cd", &sdhi0_device.dev);
|
||||
if (!ret)
|
||||
sdhi0_info.tmio_flags |= TMIO_MMC_HAS_COLD_CD;
|
||||
else
|
||||
pr_err("Cannot get IRQ #%d: %d\n", evt2irq(0x3340), ret);
|
||||
|
||||
#if !defined(CONFIG_MMC_SH_MMCIF) && !defined(CONFIG_MMC_SH_MMCIF_MODULE)
|
||||
/* enable SDHI1 */
|
||||
gpio_request(GPIO_FN_SDHICMD1, NULL);
|
||||
|
|
|
@ -509,6 +509,7 @@ enum { MSTP001,
|
|||
MSTP118, MSTP117, MSTP116, MSTP113,
|
||||
MSTP106, MSTP101, MSTP100,
|
||||
MSTP223,
|
||||
MSTP218, MSTP217, MSTP216,
|
||||
MSTP207, MSTP206, MSTP204, MSTP203, MSTP202, MSTP201, MSTP200,
|
||||
MSTP329, MSTP328, MSTP323, MSTP322, MSTP314, MSTP313, MSTP312,
|
||||
MSTP423, MSTP415, MSTP413, MSTP411, MSTP410, MSTP406, MSTP403,
|
||||
|
@ -534,6 +535,9 @@ static struct clk mstp_clks[MSTP_NR] = {
|
|||
[MSTP101] = MSTP(&div4_clks[DIV4_M1], SMSTPCR1, 1, 0), /* VPU */
|
||||
[MSTP100] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 0, 0), /* LCDC0 */
|
||||
[MSTP223] = MSTP(&div6_clks[DIV6_SPU], SMSTPCR2, 23, 0), /* SPU2 */
|
||||
[MSTP218] = MSTP(&div4_clks[DIV4_HP], SMSTPCR2, 18, 0), /* DMAC1 */
|
||||
[MSTP217] = MSTP(&div4_clks[DIV4_HP], SMSTPCR2, 17, 0), /* DMAC2 */
|
||||
[MSTP216] = MSTP(&div4_clks[DIV4_HP], SMSTPCR2, 16, 0), /* DMAC3 */
|
||||
[MSTP207] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 7, 0), /* SCIFA5 */
|
||||
[MSTP206] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 6, 0), /* SCIFB */
|
||||
[MSTP204] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 4, 0), /* SCIFA0 */
|
||||
|
@ -626,6 +630,9 @@ static struct clk_lookup lookups[] = {
|
|||
CLKDEV_DEV_ID("sh_mobile_lcdc_fb.0", &mstp_clks[MSTP100]), /* LCDC0 */
|
||||
CLKDEV_DEV_ID("uio_pdrv_genirq.6", &mstp_clks[MSTP223]), /* SPU2DSP0 */
|
||||
CLKDEV_DEV_ID("uio_pdrv_genirq.7", &mstp_clks[MSTP223]), /* SPU2DSP1 */
|
||||
CLKDEV_DEV_ID("sh-dma-engine.0", &mstp_clks[MSTP218]), /* DMAC1 */
|
||||
CLKDEV_DEV_ID("sh-dma-engine.1", &mstp_clks[MSTP217]), /* DMAC2 */
|
||||
CLKDEV_DEV_ID("sh-dma-engine.2", &mstp_clks[MSTP216]), /* DMAC3 */
|
||||
CLKDEV_DEV_ID("sh-sci.5", &mstp_clks[MSTP207]), /* SCIFA5 */
|
||||
CLKDEV_DEV_ID("sh-sci.6", &mstp_clks[MSTP206]), /* SCIFB */
|
||||
CLKDEV_DEV_ID("sh-sci.0", &mstp_clks[MSTP204]), /* SCIFA0 */
|
||||
|
|
|
@ -24,6 +24,8 @@
|
|||
|
||||
#include <mach/irqs.h>
|
||||
|
||||
#include "board-harmony.h"
|
||||
|
||||
#define PMC_CTRL 0x0
|
||||
#define PMC_CTRL_INTR_LOW (1 << 17)
|
||||
|
||||
|
@ -98,7 +100,7 @@ static struct tps6586x_platform_data tps_platform = {
|
|||
.irq_base = TEGRA_NR_IRQS,
|
||||
.num_subdevs = ARRAY_SIZE(tps_devs),
|
||||
.subdevs = tps_devs,
|
||||
.gpio_base = TEGRA_NR_GPIOS,
|
||||
.gpio_base = HARMONY_GPIO_TPS6586X(0),
|
||||
};
|
||||
|
||||
static struct i2c_board_info __initdata harmony_regulators[] = {
|
||||
|
|
|
@ -17,7 +17,8 @@
|
|||
#ifndef _MACH_TEGRA_BOARD_HARMONY_H
|
||||
#define _MACH_TEGRA_BOARD_HARMONY_H
|
||||
|
||||
#define HARMONY_GPIO_WM8903(_x_) (TEGRA_NR_GPIOS + (_x_))
|
||||
#define HARMONY_GPIO_TPS6586X(_x_) (TEGRA_NR_GPIOS + (_x_))
|
||||
#define HARMONY_GPIO_WM8903(_x_) (HARMONY_GPIO_TPS6586X(4) + (_x_))
|
||||
|
||||
#define TEGRA_GPIO_SD2_CD TEGRA_GPIO_PI5
|
||||
#define TEGRA_GPIO_SD2_WP TEGRA_GPIO_PH1
|
||||
|
|
|
@ -25,7 +25,7 @@
|
|||
|
||||
ENTRY(_strncpy)
|
||||
CC = R2 == 0;
|
||||
if CC JUMP 4f;
|
||||
if CC JUMP 6f;
|
||||
|
||||
P2 = R2 ; /* size */
|
||||
P0 = R0 ; /* dst*/
|
||||
|
|
|
@ -161,7 +161,7 @@ config ARCH_HAS_CPU_IDLE_WAIT
|
|||
|
||||
config NO_IOPORT
|
||||
def_bool !PCI
|
||||
depends on !SH_CAYMAN && !SH_SH4202_MICRODEV
|
||||
depends on !SH_CAYMAN && !SH_SH4202_MICRODEV && !SH_SHMIN
|
||||
|
||||
config IO_TRAPPED
|
||||
bool
|
||||
|
|
|
@ -359,37 +359,31 @@ static struct soc_camera_link camera_link = {
|
|||
.priv = &camera_info,
|
||||
};
|
||||
|
||||
static void dummy_release(struct device *dev)
|
||||
{
|
||||
}
|
||||
static struct platform_device *camera_device;
|
||||
|
||||
static struct platform_device camera_device = {
|
||||
.name = "soc_camera_platform",
|
||||
.dev = {
|
||||
.platform_data = &camera_info,
|
||||
.release = dummy_release,
|
||||
},
|
||||
};
|
||||
static void ap325rxa_camera_release(struct device *dev)
|
||||
{
|
||||
soc_camera_platform_release(&camera_device);
|
||||
}
|
||||
|
||||
static int ap325rxa_camera_add(struct soc_camera_link *icl,
|
||||
struct device *dev)
|
||||
{
|
||||
if (icl != &camera_link || camera_probe() <= 0)
|
||||
return -ENODEV;
|
||||
int ret = soc_camera_platform_add(icl, dev, &camera_device, &camera_link,
|
||||
ap325rxa_camera_release, 0);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
camera_info.dev = dev;
|
||||
ret = camera_probe();
|
||||
if (ret < 0)
|
||||
soc_camera_platform_del(icl, camera_device, &camera_link);
|
||||
|
||||
return platform_device_register(&camera_device);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void ap325rxa_camera_del(struct soc_camera_link *icl)
|
||||
{
|
||||
if (icl != &camera_link)
|
||||
return;
|
||||
|
||||
platform_device_unregister(&camera_device);
|
||||
memset(&camera_device.dev.kobj, 0,
|
||||
sizeof(camera_device.dev.kobj));
|
||||
soc_camera_platform_del(icl, camera_device, &camera_link);
|
||||
}
|
||||
#endif /* CONFIG_I2C */
|
||||
|
||||
|
|
|
@ -885,6 +885,9 @@ static struct platform_device sh_mmcif_device = {
|
|||
},
|
||||
.num_resources = ARRAY_SIZE(sh_mmcif_resources),
|
||||
.resource = sh_mmcif_resources,
|
||||
.archdata = {
|
||||
.hwblk_id = HWBLK_MMC,
|
||||
},
|
||||
};
|
||||
#endif
|
||||
|
||||
|
|
|
@ -18,6 +18,7 @@
|
|||
#include <asm/pgtable-2level.h>
|
||||
#endif
|
||||
#include <asm/page.h>
|
||||
#include <asm/mmu.h>
|
||||
|
||||
#ifndef __ASSEMBLY__
|
||||
#include <asm/addrspace.h>
|
||||
|
|
|
@ -41,7 +41,9 @@
|
|||
|
||||
#define user_mode(regs) (((regs)->sr & 0x40000000)==0)
|
||||
#define kernel_stack_pointer(_regs) ((unsigned long)(_regs)->regs[15])
|
||||
#define GET_USP(regs) ((regs)->regs[15])
|
||||
|
||||
#define GET_FP(regs) ((regs)->regs[14])
|
||||
#define GET_USP(regs) ((regs)->regs[15])
|
||||
|
||||
extern void show_regs(struct pt_regs *);
|
||||
|
||||
|
@ -131,7 +133,7 @@ extern void ptrace_triggered(struct perf_event *bp, int nmi,
|
|||
|
||||
static inline unsigned long profile_pc(struct pt_regs *regs)
|
||||
{
|
||||
unsigned long pc = instruction_pointer(regs);
|
||||
unsigned long pc = regs->pc;
|
||||
|
||||
if (virt_addr_uncached(pc))
|
||||
return CAC_ADDR(pc);
|
||||
|
|
|
@ -9,6 +9,7 @@
|
|||
#include <linux/pagemap.h>
|
||||
|
||||
#ifdef CONFIG_MMU
|
||||
#include <linux/swap.h>
|
||||
#include <asm/pgalloc.h>
|
||||
#include <asm/tlbflush.h>
|
||||
#include <asm/mmu_context.h>
|
||||
|
|
|
@ -236,6 +236,7 @@ enum {
|
|||
};
|
||||
|
||||
enum {
|
||||
SHDMA_SLAVE_INVALID,
|
||||
SHDMA_SLAVE_SCIF0_TX,
|
||||
SHDMA_SLAVE_SCIF0_RX,
|
||||
SHDMA_SLAVE_SCIF1_TX,
|
||||
|
|
|
@ -285,6 +285,7 @@ enum {
|
|||
};
|
||||
|
||||
enum {
|
||||
SHDMA_SLAVE_INVALID,
|
||||
SHDMA_SLAVE_SCIF0_TX,
|
||||
SHDMA_SLAVE_SCIF0_RX,
|
||||
SHDMA_SLAVE_SCIF1_TX,
|
||||
|
|
|
@ -252,6 +252,7 @@ enum {
|
|||
};
|
||||
|
||||
enum {
|
||||
SHDMA_SLAVE_INVALID,
|
||||
SHDMA_SLAVE_SDHI_TX,
|
||||
SHDMA_SLAVE_SDHI_RX,
|
||||
SHDMA_SLAVE_MMCIF_TX,
|
||||
|
|
|
@ -21,6 +21,7 @@
|
|||
#include <linux/fs.h>
|
||||
#include <linux/ftrace.h>
|
||||
#include <linux/hw_breakpoint.h>
|
||||
#include <linux/prefetch.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/mmu_context.h>
|
||||
#include <asm/system.h>
|
||||
|
|
|
@ -82,7 +82,7 @@ void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
|
|||
void *addr;
|
||||
|
||||
addr = __in_29bit_mode() ?
|
||||
(void *)P1SEGADDR((unsigned long)vaddr) : vaddr;
|
||||
(void *)CAC_ADDR((unsigned long)vaddr) : vaddr;
|
||||
|
||||
switch (direction) {
|
||||
case DMA_FROM_DEVICE: /* invalidate only */
|
||||
|
|
|
@ -21,7 +21,7 @@ static void cfq_dtor(struct io_context *ioc)
|
|||
if (!hlist_empty(&ioc->cic_list)) {
|
||||
struct cfq_io_context *cic;
|
||||
|
||||
cic = list_entry(ioc->cic_list.first, struct cfq_io_context,
|
||||
cic = hlist_entry(ioc->cic_list.first, struct cfq_io_context,
|
||||
cic_list);
|
||||
cic->dtor(ioc);
|
||||
}
|
||||
|
@ -57,7 +57,7 @@ static void cfq_exit(struct io_context *ioc)
|
|||
if (!hlist_empty(&ioc->cic_list)) {
|
||||
struct cfq_io_context *cic;
|
||||
|
||||
cic = list_entry(ioc->cic_list.first, struct cfq_io_context,
|
||||
cic = hlist_entry(ioc->cic_list.first, struct cfq_io_context,
|
||||
cic_list);
|
||||
cic->exit(ioc);
|
||||
}
|
||||
|
|
|
@ -185,7 +185,7 @@ struct cfq_group {
|
|||
int nr_cfqq;
|
||||
|
||||
/*
|
||||
* Per group busy queus average. Useful for workload slice calc. We
|
||||
* Per group busy queues average. Useful for workload slice calc. We
|
||||
* create the array for each prio class but at run time it is used
|
||||
* only for RT and BE class and slot for IDLE class remains unused.
|
||||
* This is primarily done to avoid confusion and a gcc warning.
|
||||
|
@ -369,16 +369,16 @@ CFQ_CFQQ_FNS(wait_busy);
|
|||
#define cfq_log_cfqq(cfqd, cfqq, fmt, args...) \
|
||||
blk_add_trace_msg((cfqd)->queue, "cfq%d%c %s " fmt, (cfqq)->pid, \
|
||||
cfq_cfqq_sync((cfqq)) ? 'S' : 'A', \
|
||||
blkg_path(&(cfqq)->cfqg->blkg), ##args);
|
||||
blkg_path(&(cfqq)->cfqg->blkg), ##args)
|
||||
|
||||
#define cfq_log_cfqg(cfqd, cfqg, fmt, args...) \
|
||||
blk_add_trace_msg((cfqd)->queue, "%s " fmt, \
|
||||
blkg_path(&(cfqg)->blkg), ##args); \
|
||||
blkg_path(&(cfqg)->blkg), ##args) \
|
||||
|
||||
#else
|
||||
#define cfq_log_cfqq(cfqd, cfqq, fmt, args...) \
|
||||
blk_add_trace_msg((cfqd)->queue, "cfq%d " fmt, (cfqq)->pid, ##args)
|
||||
#define cfq_log_cfqg(cfqd, cfqg, fmt, args...) do {} while (0);
|
||||
#define cfq_log_cfqg(cfqd, cfqg, fmt, args...) do {} while (0)
|
||||
#endif
|
||||
#define cfq_log(cfqd, fmt, args...) \
|
||||
blk_add_trace_msg((cfqd)->queue, "cfq " fmt, ##args)
|
||||
|
@ -3786,9 +3786,6 @@ new_queue:
|
|||
return 0;
|
||||
|
||||
queue_fail:
|
||||
if (cic)
|
||||
put_io_context(cic->ioc);
|
||||
|
||||
cfq_schedule_dispatch(cfqd);
|
||||
spin_unlock_irqrestore(q->queue_lock, flags);
|
||||
cfq_log(cfqd, "set_request fail");
|
||||
|
|
|
@ -192,7 +192,8 @@ static int sock_xmit(struct nbd_device *lo, int send, void *buf, int size,
|
|||
if (lo->xmit_timeout)
|
||||
del_timer_sync(&ti);
|
||||
} else
|
||||
result = kernel_recvmsg(sock, &msg, &iov, 1, size, 0);
|
||||
result = kernel_recvmsg(sock, &msg, &iov, 1, size,
|
||||
msg.msg_flags);
|
||||
|
||||
if (signal_pending(current)) {
|
||||
siginfo_t info;
|
||||
|
@ -753,9 +754,26 @@ static int __init nbd_init(void)
|
|||
return -ENOMEM;
|
||||
|
||||
part_shift = 0;
|
||||
if (max_part > 0)
|
||||
if (max_part > 0) {
|
||||
part_shift = fls(max_part);
|
||||
|
||||
/*
|
||||
* Adjust max_part according to part_shift as it is exported
|
||||
* to user space so that user can know the max number of
|
||||
* partition kernel should be able to manage.
|
||||
*
|
||||
* Note that -1 is required because partition 0 is reserved
|
||||
* for the whole disk.
|
||||
*/
|
||||
max_part = (1UL << part_shift) - 1;
|
||||
}
|
||||
|
||||
if ((1UL << part_shift) > DISK_MAX_PARTS)
|
||||
return -EINVAL;
|
||||
|
||||
if (nbds_max > 1UL << (MINORBITS - part_shift))
|
||||
return -EINVAL;
|
||||
|
||||
for (i = 0; i < nbds_max; i++) {
|
||||
struct gendisk *disk = alloc_disk(1 << part_shift);
|
||||
if (!disk)
|
||||
|
|
|
@ -809,11 +809,13 @@ static int __init xen_blkif_init(void)
|
|||
failed_init:
|
||||
kfree(blkbk->pending_reqs);
|
||||
kfree(blkbk->pending_grant_handles);
|
||||
for (i = 0; i < mmap_pages; i++) {
|
||||
if (blkbk->pending_pages[i])
|
||||
__free_page(blkbk->pending_pages[i]);
|
||||
if (blkbk->pending_pages) {
|
||||
for (i = 0; i < mmap_pages; i++) {
|
||||
if (blkbk->pending_pages[i])
|
||||
__free_page(blkbk->pending_pages[i]);
|
||||
}
|
||||
kfree(blkbk->pending_pages);
|
||||
}
|
||||
kfree(blkbk->pending_pages);
|
||||
kfree(blkbk);
|
||||
blkbk = NULL;
|
||||
return rc;
|
||||
|
|
|
@ -357,14 +357,13 @@ static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle,
|
|||
}
|
||||
|
||||
vbd->bdev = bdev;
|
||||
vbd->size = vbd_sz(vbd);
|
||||
|
||||
if (vbd->bdev->bd_disk == NULL) {
|
||||
DPRINTK("xen_vbd_create: device %08x doesn't exist.\n",
|
||||
vbd->pdevice);
|
||||
xen_vbd_free(vbd);
|
||||
return -ENOENT;
|
||||
}
|
||||
vbd->size = vbd_sz(vbd);
|
||||
|
||||
if (vbd->bdev->bd_disk->flags & GENHD_FL_CD || cdrom)
|
||||
vbd->type |= VDISK_CDROM;
|
||||
|
|
|
@ -355,29 +355,24 @@ static void hci_uart_tty_wakeup(struct tty_struct *tty)
|
|||
* flags pointer to flags for data
|
||||
* count count of received data in bytes
|
||||
*
|
||||
* Return Value: Number of bytes received
|
||||
* Return Value: None
|
||||
*/
|
||||
static unsigned int hci_uart_tty_receive(struct tty_struct *tty,
|
||||
const u8 *data, char *flags, int count)
|
||||
static void hci_uart_tty_receive(struct tty_struct *tty, const u8 *data, char *flags, int count)
|
||||
{
|
||||
struct hci_uart *hu = (void *)tty->disc_data;
|
||||
int received;
|
||||
|
||||
if (!hu || tty != hu->tty)
|
||||
return -ENODEV;
|
||||
return;
|
||||
|
||||
if (!test_bit(HCI_UART_PROTO_SET, &hu->flags))
|
||||
return -EINVAL;
|
||||
return;
|
||||
|
||||
spin_lock(&hu->rx_lock);
|
||||
received = hu->proto->recv(hu, (void *) data, count);
|
||||
if (received > 0)
|
||||
hu->hdev->stat.byte_rx += received;
|
||||
hu->proto->recv(hu, (void *) data, count);
|
||||
hu->hdev->stat.byte_rx += count;
|
||||
spin_unlock(&hu->rx_lock);
|
||||
|
||||
tty_unthrottle(tty);
|
||||
|
||||
return received;
|
||||
}
|
||||
|
||||
static int hci_uart_register_dev(struct hci_uart *hu)
|
||||
|
|
|
@ -24,7 +24,6 @@
|
|||
#include <linux/ioport.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/clk.h>
|
||||
#include <linux/pm_runtime.h>
|
||||
#include <linux/irq.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/clocksource.h>
|
||||
|
@ -153,12 +152,10 @@ static int sh_cmt_enable(struct sh_cmt_priv *p, unsigned long *rate)
|
|||
{
|
||||
int ret;
|
||||
|
||||
/* wake up device and enable clock */
|
||||
pm_runtime_get_sync(&p->pdev->dev);
|
||||
/* enable clock */
|
||||
ret = clk_enable(p->clk);
|
||||
if (ret) {
|
||||
dev_err(&p->pdev->dev, "cannot enable clock\n");
|
||||
pm_runtime_put_sync(&p->pdev->dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -190,9 +187,8 @@ static void sh_cmt_disable(struct sh_cmt_priv *p)
|
|||
/* disable interrupts in CMT block */
|
||||
sh_cmt_write(p, CMCSR, 0);
|
||||
|
||||
/* stop clock and mark device as idle */
|
||||
/* stop clock */
|
||||
clk_disable(p->clk);
|
||||
pm_runtime_put_sync(&p->pdev->dev);
|
||||
}
|
||||
|
||||
/* private flags */
|
||||
|
@ -664,7 +660,6 @@ static int __devinit sh_cmt_probe(struct platform_device *pdev)
|
|||
|
||||
if (p) {
|
||||
dev_info(&pdev->dev, "kept as earlytimer\n");
|
||||
pm_runtime_enable(&pdev->dev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -679,9 +674,6 @@ static int __devinit sh_cmt_probe(struct platform_device *pdev)
|
|||
kfree(p);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
}
|
||||
|
||||
if (!is_early_platform_device(pdev))
|
||||
pm_runtime_enable(&pdev->dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -25,7 +25,6 @@
|
|||
#include <linux/delay.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/clk.h>
|
||||
#include <linux/pm_runtime.h>
|
||||
#include <linux/irq.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/clocksource.h>
|
||||
|
@ -110,12 +109,10 @@ static int sh_tmu_enable(struct sh_tmu_priv *p)
|
|||
{
|
||||
int ret;
|
||||
|
||||
/* wake up device and enable clock */
|
||||
pm_runtime_get_sync(&p->pdev->dev);
|
||||
/* enable clock */
|
||||
ret = clk_enable(p->clk);
|
||||
if (ret) {
|
||||
dev_err(&p->pdev->dev, "cannot enable clock\n");
|
||||
pm_runtime_put_sync(&p->pdev->dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -144,9 +141,8 @@ static void sh_tmu_disable(struct sh_tmu_priv *p)
|
|||
/* disable interrupts in TMU block */
|
||||
sh_tmu_write(p, TCR, 0x0000);
|
||||
|
||||
/* stop clock and mark device as idle */
|
||||
/* stop clock */
|
||||
clk_disable(p->clk);
|
||||
pm_runtime_put_sync(&p->pdev->dev);
|
||||
}
|
||||
|
||||
static void sh_tmu_set_next(struct sh_tmu_priv *p, unsigned long delta,
|
||||
|
@ -415,7 +411,6 @@ static int __devinit sh_tmu_probe(struct platform_device *pdev)
|
|||
|
||||
if (p) {
|
||||
dev_info(&pdev->dev, "kept as earlytimer\n");
|
||||
pm_runtime_enable(&pdev->dev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -430,9 +425,6 @@ static int __devinit sh_tmu_probe(struct platform_device *pdev)
|
|||
kfree(p);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
}
|
||||
|
||||
if (!is_early_platform_device(pdev))
|
||||
pm_runtime_enable(&pdev->dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -343,7 +343,7 @@ static int sh_dmae_alloc_chan_resources(struct dma_chan *chan)
|
|||
|
||||
dmae_set_dmars(sh_chan, cfg->mid_rid);
|
||||
dmae_set_chcr(sh_chan, cfg->chcr);
|
||||
} else if ((sh_dmae_readl(sh_chan, CHCR) & 0xf00) != 0x400) {
|
||||
} else {
|
||||
dmae_init(sh_chan);
|
||||
}
|
||||
|
||||
|
@ -1144,6 +1144,8 @@ static int __init sh_dmae_probe(struct platform_device *pdev)
|
|||
/* platform data */
|
||||
shdev->pdata = pdata;
|
||||
|
||||
platform_set_drvdata(pdev, shdev);
|
||||
|
||||
pm_runtime_enable(&pdev->dev);
|
||||
pm_runtime_get_sync(&pdev->dev);
|
||||
|
||||
|
@ -1256,7 +1258,6 @@ static int __init sh_dmae_probe(struct platform_device *pdev)
|
|||
|
||||
pm_runtime_put(&pdev->dev);
|
||||
|
||||
platform_set_drvdata(pdev, shdev);
|
||||
dma_async_device_register(&shdev->common);
|
||||
|
||||
return err;
|
||||
|
@ -1278,6 +1279,8 @@ rst_err:
|
|||
|
||||
if (dmars)
|
||||
iounmap(shdev->dmars);
|
||||
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
emapdmars:
|
||||
iounmap(shdev->chan_reg);
|
||||
synchronize_rcu();
|
||||
|
@ -1316,6 +1319,8 @@ static int __exit sh_dmae_remove(struct platform_device *pdev)
|
|||
iounmap(shdev->dmars);
|
||||
iounmap(shdev->chan_reg);
|
||||
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
synchronize_rcu();
|
||||
kfree(shdev);
|
||||
|
||||
|
|
|
@ -296,7 +296,7 @@ static int get_tjmax(struct cpuinfo_x86 *c, u32 id, struct device *dev)
|
|||
* If the TjMax is not plausible, an assumption
|
||||
* will be used
|
||||
*/
|
||||
if (val > 80 && val < 120) {
|
||||
if (val) {
|
||||
dev_info(dev, "TjMax is %d C.\n", val);
|
||||
return val * 1000;
|
||||
}
|
||||
|
@ -304,24 +304,9 @@ static int get_tjmax(struct cpuinfo_x86 *c, u32 id, struct device *dev)
|
|||
|
||||
/*
|
||||
* An assumption is made for early CPUs and unreadable MSR.
|
||||
* NOTE: the given value may not be correct.
|
||||
* NOTE: the calculated value may not be correct.
|
||||
*/
|
||||
|
||||
switch (c->x86_model) {
|
||||
case 0xe:
|
||||
case 0xf:
|
||||
case 0x16:
|
||||
case 0x1a:
|
||||
dev_warn(dev, "TjMax is assumed as 100 C!\n");
|
||||
return 100000;
|
||||
case 0x17:
|
||||
case 0x1c: /* Atom CPUs */
|
||||
return adjust_tjmax(c, id, dev);
|
||||
default:
|
||||
dev_warn(dev, "CPU (model=0x%x) is not supported yet,"
|
||||
" using default TjMax of 100C.\n", c->x86_model);
|
||||
return 100000;
|
||||
}
|
||||
return adjust_tjmax(c, id, dev);
|
||||
}
|
||||
|
||||
static void __devinit get_ucode_rev_on_cpu(void *edx)
|
||||
|
@ -341,7 +326,7 @@ static int get_pkg_tjmax(unsigned int cpu, struct device *dev)
|
|||
err = rdmsr_safe_on_cpu(cpu, MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
|
||||
if (!err) {
|
||||
val = (eax >> 16) & 0xff;
|
||||
if (val > 80 && val < 120)
|
||||
if (val)
|
||||
return val * 1000;
|
||||
}
|
||||
dev_warn(dev, "Unable to read Pkg-TjMax from CPU:%u\n", cpu);
|
||||
|
|
|
@ -136,15 +136,29 @@ static int max6642_detect(struct i2c_client *client,
|
|||
if (man_id != 0x4D)
|
||||
return -ENODEV;
|
||||
|
||||
/* sanity check */
|
||||
if (i2c_smbus_read_byte_data(client, 0x04) != 0x4D
|
||||
|| i2c_smbus_read_byte_data(client, 0x06) != 0x4D
|
||||
|| i2c_smbus_read_byte_data(client, 0xff) != 0x4D)
|
||||
return -ENODEV;
|
||||
|
||||
/*
|
||||
* We read the config and status register, the 4 lower bits in the
|
||||
* config register should be zero and bit 5, 3, 1 and 0 should be
|
||||
* zero in the status register.
|
||||
*/
|
||||
reg_config = i2c_smbus_read_byte_data(client, MAX6642_REG_R_CONFIG);
|
||||
if ((reg_config & 0x0f) != 0x00)
|
||||
return -ENODEV;
|
||||
|
||||
/* in between, another round of sanity checks */
|
||||
if (i2c_smbus_read_byte_data(client, 0x04) != reg_config
|
||||
|| i2c_smbus_read_byte_data(client, 0x06) != reg_config
|
||||
|| i2c_smbus_read_byte_data(client, 0xff) != reg_config)
|
||||
return -ENODEV;
|
||||
|
||||
reg_status = i2c_smbus_read_byte_data(client, MAX6642_REG_R_STATUS);
|
||||
if (((reg_config & 0x0f) != 0x00) ||
|
||||
((reg_status & 0x2b) != 0x00))
|
||||
if ((reg_status & 0x2b) != 0x00)
|
||||
return -ENODEV;
|
||||
|
||||
strlcpy(info->type, "max6642", I2C_NAME_SIZE);
|
||||
|
@ -246,7 +260,7 @@ static SENSOR_DEVICE_ATTR_2(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
|
|||
set_temp_max, 0, MAX6642_REG_W_LOCAL_HIGH);
|
||||
static SENSOR_DEVICE_ATTR_2(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
|
||||
set_temp_max, 1, MAX6642_REG_W_REMOTE_HIGH);
|
||||
static SENSOR_DEVICE_ATTR(temp_fault, S_IRUGO, show_alarm, NULL, 2);
|
||||
static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
|
||||
static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
|
||||
static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
|
||||
|
||||
|
@ -256,7 +270,7 @@ static struct attribute *max6642_attributes[] = {
|
|||
&sensor_dev_attr_temp1_max.dev_attr.attr,
|
||||
&sensor_dev_attr_temp2_max.dev_attr.attr,
|
||||
|
||||
&sensor_dev_attr_temp_fault.dev_attr.attr,
|
||||
&sensor_dev_attr_temp2_fault.dev_attr.attr,
|
||||
&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
|
||||
&sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
|
||||
NULL
|
||||
|
|
|
@ -120,21 +120,17 @@ static void serport_ldisc_close(struct tty_struct *tty)
|
|||
* 'interrupt' routine.
|
||||
*/
|
||||
|
||||
static unsigned int serport_ldisc_receive(struct tty_struct *tty,
|
||||
const unsigned char *cp, char *fp, int count)
|
||||
static void serport_ldisc_receive(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
|
||||
{
|
||||
struct serport *serport = (struct serport*) tty->disc_data;
|
||||
unsigned long flags;
|
||||
unsigned int ch_flags;
|
||||
int ret = 0;
|
||||
int i;
|
||||
|
||||
spin_lock_irqsave(&serport->lock, flags);
|
||||
|
||||
if (!test_bit(SERPORT_ACTIVE, &serport->flags)) {
|
||||
ret = -EINVAL;
|
||||
if (!test_bit(SERPORT_ACTIVE, &serport->flags))
|
||||
goto out;
|
||||
}
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
switch (fp[i]) {
|
||||
|
@ -156,8 +152,6 @@ static unsigned int serport_ldisc_receive(struct tty_struct *tty,
|
|||
|
||||
out:
|
||||
spin_unlock_irqrestore(&serport->lock, flags);
|
||||
|
||||
return ret == 0 ? count : ret;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -674,7 +674,7 @@ gigaset_tty_ioctl(struct tty_struct *tty, struct file *file,
|
|||
* cflags buffer containing error flags for received characters (ignored)
|
||||
* count number of received characters
|
||||
*/
|
||||
static unsigned int
|
||||
static void
|
||||
gigaset_tty_receive(struct tty_struct *tty, const unsigned char *buf,
|
||||
char *cflags, int count)
|
||||
{
|
||||
|
@ -683,12 +683,12 @@ gigaset_tty_receive(struct tty_struct *tty, const unsigned char *buf,
|
|||
struct inbuf_t *inbuf;
|
||||
|
||||
if (!cs)
|
||||
return -ENODEV;
|
||||
return;
|
||||
inbuf = cs->inbuf;
|
||||
if (!inbuf) {
|
||||
dev_err(cs->dev, "%s: no inbuf\n", __func__);
|
||||
cs_put(cs);
|
||||
return -EINVAL;
|
||||
return;
|
||||
}
|
||||
|
||||
tail = inbuf->tail;
|
||||
|
@ -725,8 +725,6 @@ gigaset_tty_receive(struct tty_struct *tty, const unsigned char *buf,
|
|||
gig_dbg(DEBUG_INTR, "%s-->BH", __func__);
|
||||
gigaset_schedule_event(cs);
|
||||
cs_put(cs);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -747,8 +747,8 @@ static void st_tty_close(struct tty_struct *tty)
|
|||
pr_debug("%s: done ", __func__);
|
||||
}
|
||||
|
||||
static unsigned int st_tty_receive(struct tty_struct *tty,
|
||||
const unsigned char *data, char *tty_flags, int count)
|
||||
static void st_tty_receive(struct tty_struct *tty, const unsigned char *data,
|
||||
char *tty_flags, int count)
|
||||
{
|
||||
#ifdef VERBOSE
|
||||
print_hex_dump(KERN_DEBUG, ">in>", DUMP_PREFIX_NONE,
|
||||
|
@ -761,8 +761,6 @@ static unsigned int st_tty_receive(struct tty_struct *tty,
|
|||
*/
|
||||
st_recv(tty->disc_data, data, count);
|
||||
pr_debug("done %s", __func__);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
/* wake-up function called in from the TTY layer
|
||||
|
|
|
@ -185,7 +185,7 @@ static int max_interrupt_work = 10;
|
|||
static int nopnp;
|
||||
#endif
|
||||
|
||||
static int el3_common_init(struct net_device *dev);
|
||||
static int __devinit el3_common_init(struct net_device *dev);
|
||||
static void el3_common_remove(struct net_device *dev);
|
||||
static ushort id_read_eeprom(int index);
|
||||
static ushort read_eeprom(int ioaddr, int index);
|
||||
|
@ -395,7 +395,7 @@ static struct isa_driver el3_isa_driver = {
|
|||
static int isa_registered;
|
||||
|
||||
#ifdef CONFIG_PNP
|
||||
static const struct pnp_device_id el3_pnp_ids[] __devinitconst = {
|
||||
static struct pnp_device_id el3_pnp_ids[] = {
|
||||
{ .id = "TCM5090" }, /* 3Com Etherlink III (TP) */
|
||||
{ .id = "TCM5091" }, /* 3Com Etherlink III */
|
||||
{ .id = "TCM5094" }, /* 3Com Etherlink III (combo) */
|
||||
|
@ -478,7 +478,7 @@ static int pnp_registered;
|
|||
#endif /* CONFIG_PNP */
|
||||
|
||||
#ifdef CONFIG_EISA
|
||||
static const struct eisa_device_id el3_eisa_ids[] __devinitconst = {
|
||||
static struct eisa_device_id el3_eisa_ids[] = {
|
||||
{ "TCM5090" },
|
||||
{ "TCM5091" },
|
||||
{ "TCM5092" },
|
||||
|
@ -508,7 +508,7 @@ static int eisa_registered;
|
|||
#ifdef CONFIG_MCA
|
||||
static int el3_mca_probe(struct device *dev);
|
||||
|
||||
static const short el3_mca_adapter_ids[] __devinitconst = {
|
||||
static short el3_mca_adapter_ids[] __initdata = {
|
||||
0x627c,
|
||||
0x627d,
|
||||
0x62db,
|
||||
|
@ -517,7 +517,7 @@ static const short el3_mca_adapter_ids[] __devinitconst = {
|
|||
0x0000
|
||||
};
|
||||
|
||||
static const char *const el3_mca_adapter_names[] __devinitconst = {
|
||||
static char *el3_mca_adapter_names[] __initdata = {
|
||||
"3Com 3c529 EtherLink III (10base2)",
|
||||
"3Com 3c529 EtherLink III (10baseT)",
|
||||
"3Com 3c529 EtherLink III (test mode)",
|
||||
|
@ -601,7 +601,7 @@ static void el3_common_remove (struct net_device *dev)
|
|||
}
|
||||
|
||||
#ifdef CONFIG_MCA
|
||||
static int __devinit el3_mca_probe(struct device *device)
|
||||
static int __init el3_mca_probe(struct device *device)
|
||||
{
|
||||
/* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
|
||||
* heavily modified by Chris Beauregard
|
||||
|
@ -671,7 +671,7 @@ static int __devinit el3_mca_probe(struct device *device)
|
|||
#endif /* CONFIG_MCA */
|
||||
|
||||
#ifdef CONFIG_EISA
|
||||
static int __devinit el3_eisa_probe (struct device *device)
|
||||
static int __init el3_eisa_probe (struct device *device)
|
||||
{
|
||||
short i;
|
||||
int ioaddr, irq, if_port;
|
||||
|
|
|
@ -901,14 +901,14 @@ static const struct dev_pm_ops vortex_pm_ops = {
|
|||
#endif /* !CONFIG_PM */
|
||||
|
||||
#ifdef CONFIG_EISA
|
||||
static const struct eisa_device_id vortex_eisa_ids[] __devinitconst = {
|
||||
static struct eisa_device_id vortex_eisa_ids[] = {
|
||||
{ "TCM5920", CH_3C592 },
|
||||
{ "TCM5970", CH_3C597 },
|
||||
{ "" }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(eisa, vortex_eisa_ids);
|
||||
|
||||
static int __devinit vortex_eisa_probe(struct device *device)
|
||||
static int __init vortex_eisa_probe(struct device *device)
|
||||
{
|
||||
void __iomem *ioaddr;
|
||||
struct eisa_device *edev;
|
||||
|
|
|
@ -167,8 +167,8 @@ static inline void debugfs_tx(struct ser_device *ser, const u8 *data, int size)
|
|||
|
||||
#endif
|
||||
|
||||
static unsigned int ldisc_receive(struct tty_struct *tty,
|
||||
const u8 *data, char *flags, int count)
|
||||
static void ldisc_receive(struct tty_struct *tty, const u8 *data,
|
||||
char *flags, int count)
|
||||
{
|
||||
struct sk_buff *skb = NULL;
|
||||
struct ser_device *ser;
|
||||
|
@ -215,8 +215,6 @@ static unsigned int ldisc_receive(struct tty_struct *tty,
|
|||
} else
|
||||
++ser->dev->stats.rx_dropped;
|
||||
update_tty_status(ser);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
static int handle_tx(struct ser_device *ser)
|
||||
|
|
|
@ -923,7 +923,7 @@ static int __devinit flexcan_probe(struct platform_device *pdev)
|
|||
mem_size = resource_size(mem);
|
||||
if (!request_mem_region(mem->start, mem_size, pdev->name)) {
|
||||
err = -EBUSY;
|
||||
goto failed_req;
|
||||
goto failed_get;
|
||||
}
|
||||
|
||||
base = ioremap(mem->start, mem_size);
|
||||
|
@ -977,9 +977,8 @@ static int __devinit flexcan_probe(struct platform_device *pdev)
|
|||
iounmap(base);
|
||||
failed_map:
|
||||
release_mem_region(mem->start, mem_size);
|
||||
failed_req:
|
||||
clk_put(clk);
|
||||
failed_get:
|
||||
clk_put(clk);
|
||||
failed_clock:
|
||||
return err;
|
||||
}
|
||||
|
|
|
@ -425,17 +425,16 @@ static void slc_setup(struct net_device *dev)
|
|||
* in parallel
|
||||
*/
|
||||
|
||||
static unsigned int slcan_receive_buf(struct tty_struct *tty,
|
||||
static void slcan_receive_buf(struct tty_struct *tty,
|
||||
const unsigned char *cp, char *fp, int count)
|
||||
{
|
||||
struct slcan *sl = (struct slcan *) tty->disc_data;
|
||||
int bytes = count;
|
||||
|
||||
if (!sl || sl->magic != SLCAN_MAGIC || !netif_running(sl->dev))
|
||||
return -ENODEV;
|
||||
return;
|
||||
|
||||
/* Read the characters out of the buffer */
|
||||
while (bytes--) {
|
||||
while (count--) {
|
||||
if (fp && *fp++) {
|
||||
if (!test_and_set_bit(SLF_ERROR, &sl->flags))
|
||||
sl->dev->stats.rx_errors++;
|
||||
|
@ -444,8 +443,6 @@ static unsigned int slcan_receive_buf(struct tty_struct *tty,
|
|||
}
|
||||
slcan_unesc(sl, *cp++);
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
/************************************
|
||||
|
|
|
@ -1781,8 +1781,8 @@ static int __devinit davinci_emac_probe(struct platform_device *pdev)
|
|||
ndev = alloc_etherdev(sizeof(struct emac_priv));
|
||||
if (!ndev) {
|
||||
dev_err(&pdev->dev, "error allocating net_device\n");
|
||||
clk_put(emac_clk);
|
||||
return -ENOMEM;
|
||||
rc = -ENOMEM;
|
||||
goto free_clk;
|
||||
}
|
||||
|
||||
platform_set_drvdata(pdev, ndev);
|
||||
|
@ -1796,7 +1796,8 @@ static int __devinit davinci_emac_probe(struct platform_device *pdev)
|
|||
pdata = pdev->dev.platform_data;
|
||||
if (!pdata) {
|
||||
dev_err(&pdev->dev, "no platform data\n");
|
||||
return -ENODEV;
|
||||
rc = -ENODEV;
|
||||
goto probe_quit;
|
||||
}
|
||||
|
||||
/* MAC addr and PHY mask , RMII enable info from platform_data */
|
||||
|
@ -1929,8 +1930,9 @@ no_dma:
|
|||
iounmap(priv->remap_addr);
|
||||
|
||||
probe_quit:
|
||||
clk_put(emac_clk);
|
||||
free_netdev(ndev);
|
||||
free_clk:
|
||||
clk_put(emac_clk);
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
|
|
@ -331,18 +331,18 @@ static struct {
|
|||
"DE422",\
|
||||
""}
|
||||
|
||||
static const char* const depca_signature[] __devinitconst = DEPCA_SIGNATURE;
|
||||
static char* __initdata depca_signature[] = DEPCA_SIGNATURE;
|
||||
|
||||
enum depca_type {
|
||||
DEPCA, de100, de101, de200, de201, de202, de210, de212, de422, unknown
|
||||
};
|
||||
|
||||
static const char depca_string[] = "depca";
|
||||
static char depca_string[] = "depca";
|
||||
|
||||
static int depca_device_remove (struct device *device);
|
||||
|
||||
#ifdef CONFIG_EISA
|
||||
static const struct eisa_device_id depca_eisa_ids[] __devinitconst = {
|
||||
static struct eisa_device_id depca_eisa_ids[] = {
|
||||
{ "DEC4220", de422 },
|
||||
{ "" }
|
||||
};
|
||||
|
@ -367,19 +367,19 @@ static struct eisa_driver depca_eisa_driver = {
|
|||
#define DE210_ID 0x628d
|
||||
#define DE212_ID 0x6def
|
||||
|
||||
static const short depca_mca_adapter_ids[] __devinitconst = {
|
||||
static short depca_mca_adapter_ids[] = {
|
||||
DE210_ID,
|
||||
DE212_ID,
|
||||
0x0000
|
||||
};
|
||||
|
||||
static const char *depca_mca_adapter_name[] = {
|
||||
static char *depca_mca_adapter_name[] = {
|
||||
"DEC EtherWORKS MC Adapter (DE210)",
|
||||
"DEC EtherWORKS MC Adapter (DE212)",
|
||||
NULL
|
||||
};
|
||||
|
||||
static const enum depca_type depca_mca_adapter_type[] = {
|
||||
static enum depca_type depca_mca_adapter_type[] = {
|
||||
de210,
|
||||
de212,
|
||||
0
|
||||
|
@ -541,9 +541,10 @@ static void SetMulticastFilter(struct net_device *dev);
|
|||
static int load_packet(struct net_device *dev, struct sk_buff *skb);
|
||||
static void depca_dbg_open(struct net_device *dev);
|
||||
|
||||
static const u_char de1xx_irq[] __devinitconst = { 2, 3, 4, 5, 7, 9, 0 };
|
||||
static const u_char de2xx_irq[] __devinitconst = { 5, 9, 10, 11, 15, 0 };
|
||||
static const u_char de422_irq[] __devinitconst = { 5, 9, 10, 11, 0 };
|
||||
static u_char de1xx_irq[] __initdata = { 2, 3, 4, 5, 7, 9, 0 };
|
||||
static u_char de2xx_irq[] __initdata = { 5, 9, 10, 11, 15, 0 };
|
||||
static u_char de422_irq[] __initdata = { 5, 9, 10, 11, 0 };
|
||||
static u_char *depca_irq;
|
||||
|
||||
static int irq;
|
||||
static int io;
|
||||
|
@ -579,7 +580,7 @@ static const struct net_device_ops depca_netdev_ops = {
|
|||
.ndo_validate_addr = eth_validate_addr,
|
||||
};
|
||||
|
||||
static int __devinit depca_hw_init (struct net_device *dev, struct device *device)
|
||||
static int __init depca_hw_init (struct net_device *dev, struct device *device)
|
||||
{
|
||||
struct depca_private *lp;
|
||||
int i, j, offset, netRAM, mem_len, status = 0;
|
||||
|
@ -747,7 +748,6 @@ static int __devinit depca_hw_init (struct net_device *dev, struct device *devic
|
|||
if (dev->irq < 2) {
|
||||
unsigned char irqnum;
|
||||
unsigned long irq_mask, delay;
|
||||
const u_char *depca_irq;
|
||||
|
||||
irq_mask = probe_irq_on();
|
||||
|
||||
|
@ -770,7 +770,6 @@ static int __devinit depca_hw_init (struct net_device *dev, struct device *devic
|
|||
break;
|
||||
|
||||
default:
|
||||
depca_irq = NULL;
|
||||
break; /* Not reached */
|
||||
}
|
||||
|
||||
|
@ -1303,7 +1302,7 @@ static void SetMulticastFilter(struct net_device *dev)
|
|||
}
|
||||
}
|
||||
|
||||
static int __devinit depca_common_init (u_long ioaddr, struct net_device **devp)
|
||||
static int __init depca_common_init (u_long ioaddr, struct net_device **devp)
|
||||
{
|
||||
int status = 0;
|
||||
|
||||
|
@ -1334,7 +1333,7 @@ static int __devinit depca_common_init (u_long ioaddr, struct net_device **devp)
|
|||
/*
|
||||
** Microchannel bus I/O device probe
|
||||
*/
|
||||
static int __devinit depca_mca_probe(struct device *device)
|
||||
static int __init depca_mca_probe(struct device *device)
|
||||
{
|
||||
unsigned char pos[2];
|
||||
unsigned char where;
|
||||
|
@ -1458,7 +1457,7 @@ static int __devinit depca_mca_probe(struct device *device)
|
|||
** ISA bus I/O device probe
|
||||
*/
|
||||
|
||||
static void __devinit depca_platform_probe (void)
|
||||
static void __init depca_platform_probe (void)
|
||||
{
|
||||
int i;
|
||||
struct platform_device *pldev;
|
||||
|
@ -1498,7 +1497,7 @@ static void __devinit depca_platform_probe (void)
|
|||
}
|
||||
}
|
||||
|
||||
static enum depca_type __devinit depca_shmem_probe (ulong *mem_start)
|
||||
static enum depca_type __init depca_shmem_probe (ulong *mem_start)
|
||||
{
|
||||
u_long mem_base[] = DEPCA_RAM_BASE_ADDRESSES;
|
||||
enum depca_type adapter = unknown;
|
||||
|
@ -1559,7 +1558,7 @@ static int __devinit depca_isa_probe (struct platform_device *device)
|
|||
*/
|
||||
|
||||
#ifdef CONFIG_EISA
|
||||
static int __devinit depca_eisa_probe (struct device *device)
|
||||
static int __init depca_eisa_probe (struct device *device)
|
||||
{
|
||||
enum depca_type adapter = unknown;
|
||||
struct eisa_device *edev;
|
||||
|
@ -1630,7 +1629,7 @@ static int __devexit depca_device_remove (struct device *device)
|
|||
** and Boot (readb) ROM. This will also give us a clue to the network RAM
|
||||
** base address.
|
||||
*/
|
||||
static int __devinit DepcaSignature(char *name, u_long base_addr)
|
||||
static int __init DepcaSignature(char *name, u_long base_addr)
|
||||
{
|
||||
u_int i, j, k;
|
||||
void __iomem *ptr;
|
||||
|
|
|
@ -1157,9 +1157,6 @@ dm9000_open(struct net_device *dev)
|
|||
|
||||
irqflags |= IRQF_SHARED;
|
||||
|
||||
if (request_irq(dev->irq, dm9000_interrupt, irqflags, dev->name, dev))
|
||||
return -EAGAIN;
|
||||
|
||||
/* GPIO0 on pre-activate PHY, Reg 1F is not set by reset */
|
||||
iow(db, DM9000_GPR, 0); /* REG_1F bit0 activate phyxcer */
|
||||
mdelay(1); /* delay needs by DM9000B */
|
||||
|
@ -1168,6 +1165,9 @@ dm9000_open(struct net_device *dev)
|
|||
dm9000_reset(db);
|
||||
dm9000_init_dm9000(dev);
|
||||
|
||||
if (request_irq(dev->irq, dm9000_interrupt, irqflags, dev->name, dev))
|
||||
return -EAGAIN;
|
||||
|
||||
/* Init driver variable */
|
||||
db->dbug_cnt = 0;
|
||||
|
||||
|
|
|
@ -456,7 +456,7 @@ out:
|
|||
* a block of 6pack data has been received, which can now be decapsulated
|
||||
* and sent on to some IP layer for further processing.
|
||||
*/
|
||||
static unsigned int sixpack_receive_buf(struct tty_struct *tty,
|
||||
static void sixpack_receive_buf(struct tty_struct *tty,
|
||||
const unsigned char *cp, char *fp, int count)
|
||||
{
|
||||
struct sixpack *sp;
|
||||
|
@ -464,11 +464,11 @@ static unsigned int sixpack_receive_buf(struct tty_struct *tty,
|
|||
int count1;
|
||||
|
||||
if (!count)
|
||||
return 0;
|
||||
return;
|
||||
|
||||
sp = sp_get(tty);
|
||||
if (!sp)
|
||||
return -ENODEV;
|
||||
return;
|
||||
|
||||
memcpy(buf, cp, count < sizeof(buf) ? count : sizeof(buf));
|
||||
|
||||
|
@ -487,8 +487,6 @@ static unsigned int sixpack_receive_buf(struct tty_struct *tty,
|
|||
|
||||
sp_put(sp);
|
||||
tty_unthrottle(tty);
|
||||
|
||||
return count1;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -923,14 +923,13 @@ static long mkiss_compat_ioctl(struct tty_struct *tty, struct file *file,
|
|||
* a block of data has been received, which can now be decapsulated
|
||||
* and sent on to the AX.25 layer for further processing.
|
||||
*/
|
||||
static unsigned int mkiss_receive_buf(struct tty_struct *tty,
|
||||
const unsigned char *cp, char *fp, int count)
|
||||
static void mkiss_receive_buf(struct tty_struct *tty, const unsigned char *cp,
|
||||
char *fp, int count)
|
||||
{
|
||||
struct mkiss *ax = mkiss_get(tty);
|
||||
int bytes = count;
|
||||
|
||||
if (!ax)
|
||||
return -ENODEV;
|
||||
return;
|
||||
|
||||
/*
|
||||
* Argh! mtu change time! - costs us the packet part received
|
||||
|
@ -940,7 +939,7 @@ static unsigned int mkiss_receive_buf(struct tty_struct *tty,
|
|||
ax_changedmtu(ax);
|
||||
|
||||
/* Read the characters out of the buffer */
|
||||
while (bytes--) {
|
||||
while (count--) {
|
||||
if (fp != NULL && *fp++) {
|
||||
if (!test_and_set_bit(AXF_ERROR, &ax->flags))
|
||||
ax->dev->stats.rx_errors++;
|
||||
|
@ -953,8 +952,6 @@ static unsigned int mkiss_receive_buf(struct tty_struct *tty,
|
|||
|
||||
mkiss_put(ax);
|
||||
tty_unthrottle(tty);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -188,14 +188,14 @@ struct hp100_private {
|
|||
* variables
|
||||
*/
|
||||
#ifdef CONFIG_ISA
|
||||
static const char *const hp100_isa_tbl[] __devinitconst = {
|
||||
static const char *hp100_isa_tbl[] = {
|
||||
"HWPF150", /* HP J2573 rev A */
|
||||
"HWP1950", /* HP J2573 */
|
||||
};
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_EISA
|
||||
static const struct eisa_device_id hp100_eisa_tbl[] __devinitconst = {
|
||||
static struct eisa_device_id hp100_eisa_tbl[] = {
|
||||
{ "HWPF180" }, /* HP J2577 rev A */
|
||||
{ "HWP1920" }, /* HP 27248B */
|
||||
{ "HWP1940" }, /* HP J2577 */
|
||||
|
@ -336,7 +336,7 @@ static __devinit const char *hp100_read_id(int ioaddr)
|
|||
}
|
||||
|
||||
#ifdef CONFIG_ISA
|
||||
static __devinit int hp100_isa_probe1(struct net_device *dev, int ioaddr)
|
||||
static __init int hp100_isa_probe1(struct net_device *dev, int ioaddr)
|
||||
{
|
||||
const char *sig;
|
||||
int i;
|
||||
|
@ -372,7 +372,7 @@ static __devinit int hp100_isa_probe1(struct net_device *dev, int ioaddr)
|
|||
* EISA and PCI are handled by device infrastructure.
|
||||
*/
|
||||
|
||||
static int __devinit hp100_isa_probe(struct net_device *dev, int addr)
|
||||
static int __init hp100_isa_probe(struct net_device *dev, int addr)
|
||||
{
|
||||
int err = -ENODEV;
|
||||
|
||||
|
@ -396,7 +396,7 @@ static int __devinit hp100_isa_probe(struct net_device *dev, int addr)
|
|||
#endif /* CONFIG_ISA */
|
||||
|
||||
#if !defined(MODULE) && defined(CONFIG_ISA)
|
||||
struct net_device * __devinit hp100_probe(int unit)
|
||||
struct net_device * __init hp100_probe(int unit)
|
||||
{
|
||||
struct net_device *dev = alloc_etherdev(sizeof(struct hp100_private));
|
||||
int err;
|
||||
|
@ -2843,7 +2843,7 @@ static void cleanup_dev(struct net_device *d)
|
|||
}
|
||||
|
||||
#ifdef CONFIG_EISA
|
||||
static int __devinit hp100_eisa_probe (struct device *gendev)
|
||||
static int __init hp100_eisa_probe (struct device *gendev)
|
||||
{
|
||||
struct net_device *dev = alloc_etherdev(sizeof(struct hp100_private));
|
||||
struct eisa_device *edev = to_eisa_device(gendev);
|
||||
|
|
|
@ -895,12 +895,12 @@ static int ibmlana_irq;
|
|||
static int ibmlana_io;
|
||||
static int startslot; /* counts through slots when probing multiple devices */
|
||||
|
||||
static const short ibmlana_adapter_ids[] __devinitconst = {
|
||||
static short ibmlana_adapter_ids[] __initdata = {
|
||||
IBM_LANA_ID,
|
||||
0x0000
|
||||
};
|
||||
|
||||
static const char *const ibmlana_adapter_names[] __devinitconst = {
|
||||
static char *ibmlana_adapter_names[] __devinitdata = {
|
||||
"IBM LAN Adapter/A",
|
||||
NULL
|
||||
};
|
||||
|
|
|
@ -216,23 +216,23 @@ static int irtty_do_write(struct sir_dev *dev, const unsigned char *ptr, size_t
|
|||
* usbserial: urb-complete-interrupt / softint
|
||||
*/
|
||||
|
||||
static unsigned int irtty_receive_buf(struct tty_struct *tty,
|
||||
const unsigned char *cp, char *fp, int count)
|
||||
static void irtty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
|
||||
char *fp, int count)
|
||||
{
|
||||
struct sir_dev *dev;
|
||||
struct sirtty_cb *priv = tty->disc_data;
|
||||
int i;
|
||||
|
||||
IRDA_ASSERT(priv != NULL, return -ENODEV;);
|
||||
IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -EINVAL;);
|
||||
IRDA_ASSERT(priv != NULL, return;);
|
||||
IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
|
||||
|
||||
if (unlikely(count==0)) /* yes, this happens */
|
||||
return 0;
|
||||
return;
|
||||
|
||||
dev = priv->dev;
|
||||
if (!dev) {
|
||||
IRDA_WARNING("%s(), not ready yet!\n", __func__);
|
||||
return -ENODEV;
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
|
@ -242,13 +242,11 @@ static unsigned int irtty_receive_buf(struct tty_struct *tty,
|
|||
if (fp && *fp++) {
|
||||
IRDA_DEBUG(0, "Framing or parity error!\n");
|
||||
sirdev_receive(dev, NULL, 0); /* notify sir_dev (updating stats) */
|
||||
return -EINVAL;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
sirdev_receive(dev, cp, count);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -222,19 +222,19 @@ static void smsc_ircc_set_transceiver_for_speed(struct smsc_ircc_cb *self, u32 s
|
|||
static void smsc_ircc_sir_wait_hw_transmitter_finish(struct smsc_ircc_cb *self);
|
||||
|
||||
/* Probing */
|
||||
static int smsc_ircc_look_for_chips(void);
|
||||
static const struct smsc_chip * smsc_ircc_probe(unsigned short cfg_base, u8 reg, const struct smsc_chip *chip, char *type);
|
||||
static int smsc_superio_flat(const struct smsc_chip *chips, unsigned short cfg_base, char *type);
|
||||
static int smsc_superio_paged(const struct smsc_chip *chips, unsigned short cfg_base, char *type);
|
||||
static int smsc_superio_fdc(unsigned short cfg_base);
|
||||
static int smsc_superio_lpc(unsigned short cfg_base);
|
||||
static int __init smsc_ircc_look_for_chips(void);
|
||||
static const struct smsc_chip * __init smsc_ircc_probe(unsigned short cfg_base, u8 reg, const struct smsc_chip *chip, char *type);
|
||||
static int __init smsc_superio_flat(const struct smsc_chip *chips, unsigned short cfg_base, char *type);
|
||||
static int __init smsc_superio_paged(const struct smsc_chip *chips, unsigned short cfg_base, char *type);
|
||||
static int __init smsc_superio_fdc(unsigned short cfg_base);
|
||||
static int __init smsc_superio_lpc(unsigned short cfg_base);
|
||||
#ifdef CONFIG_PCI
|
||||
static int preconfigure_smsc_chip(struct smsc_ircc_subsystem_configuration *conf);
|
||||
static int preconfigure_through_82801(struct pci_dev *dev, struct smsc_ircc_subsystem_configuration *conf);
|
||||
static void preconfigure_ali_port(struct pci_dev *dev,
|
||||
static int __init preconfigure_smsc_chip(struct smsc_ircc_subsystem_configuration *conf);
|
||||
static int __init preconfigure_through_82801(struct pci_dev *dev, struct smsc_ircc_subsystem_configuration *conf);
|
||||
static void __init preconfigure_ali_port(struct pci_dev *dev,
|
||||
unsigned short port);
|
||||
static int preconfigure_through_ali(struct pci_dev *dev, struct smsc_ircc_subsystem_configuration *conf);
|
||||
static int smsc_ircc_preconfigure_subsystems(unsigned short ircc_cfg,
|
||||
static int __init preconfigure_through_ali(struct pci_dev *dev, struct smsc_ircc_subsystem_configuration *conf);
|
||||
static int __init smsc_ircc_preconfigure_subsystems(unsigned short ircc_cfg,
|
||||
unsigned short ircc_fir,
|
||||
unsigned short ircc_sir,
|
||||
unsigned char ircc_dma,
|
||||
|
@ -366,7 +366,7 @@ static inline void register_bank(int iobase, int bank)
|
|||
}
|
||||
|
||||
/* PNP hotplug support */
|
||||
static const struct pnp_device_id smsc_ircc_pnp_table[] __devinitconst = {
|
||||
static const struct pnp_device_id smsc_ircc_pnp_table[] = {
|
||||
{ .id = "SMCf010", .driver_data = 0 },
|
||||
/* and presumably others */
|
||||
{ }
|
||||
|
@ -515,7 +515,7 @@ static const struct net_device_ops smsc_ircc_netdev_ops = {
|
|||
* Try to open driver instance
|
||||
*
|
||||
*/
|
||||
static int __devinit smsc_ircc_open(unsigned int fir_base, unsigned int sir_base, u8 dma, u8 irq)
|
||||
static int __init smsc_ircc_open(unsigned int fir_base, unsigned int sir_base, u8 dma, u8 irq)
|
||||
{
|
||||
struct smsc_ircc_cb *self;
|
||||
struct net_device *dev;
|
||||
|
@ -2273,7 +2273,7 @@ static int __init smsc_superio_paged(const struct smsc_chip *chips, unsigned sho
|
|||
}
|
||||
|
||||
|
||||
static int __devinit smsc_access(unsigned short cfg_base, unsigned char reg)
|
||||
static int __init smsc_access(unsigned short cfg_base, unsigned char reg)
|
||||
{
|
||||
IRDA_DEBUG(1, "%s\n", __func__);
|
||||
|
||||
|
@ -2281,7 +2281,7 @@ static int __devinit smsc_access(unsigned short cfg_base, unsigned char reg)
|
|||
return inb(cfg_base) != reg ? -1 : 0;
|
||||
}
|
||||
|
||||
static const struct smsc_chip * __devinit smsc_ircc_probe(unsigned short cfg_base, u8 reg, const struct smsc_chip *chip, char *type)
|
||||
static const struct smsc_chip * __init smsc_ircc_probe(unsigned short cfg_base, u8 reg, const struct smsc_chip *chip, char *type)
|
||||
{
|
||||
u8 devid, xdevid, rev;
|
||||
|
||||
|
@ -2406,7 +2406,7 @@ static int __init smsc_superio_lpc(unsigned short cfg_base)
|
|||
#ifdef CONFIG_PCI
|
||||
#define PCIID_VENDOR_INTEL 0x8086
|
||||
#define PCIID_VENDOR_ALI 0x10b9
|
||||
static const struct smsc_ircc_subsystem_configuration subsystem_configurations[] __devinitconst = {
|
||||
static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __initdata = {
|
||||
/*
|
||||
* Subsystems needing entries:
|
||||
* 0x10b9:0x1533 0x103c:0x0850 HP nx9010 family
|
||||
|
@ -2532,7 +2532,7 @@ static const struct smsc_ircc_subsystem_configuration subsystem_configurations[]
|
|||
* (FIR port, SIR port, FIR DMA, FIR IRQ)
|
||||
* through the chip configuration port.
|
||||
*/
|
||||
static int __devinit preconfigure_smsc_chip(struct
|
||||
static int __init preconfigure_smsc_chip(struct
|
||||
smsc_ircc_subsystem_configuration
|
||||
*conf)
|
||||
{
|
||||
|
@ -2633,7 +2633,7 @@ static int __devinit preconfigure_smsc_chip(struct
|
|||
* or Intel 82801DB/DBL (ICH4/ICH4-L) LPC Interface Bridge.
|
||||
* They all work the same way!
|
||||
*/
|
||||
static int __devinit preconfigure_through_82801(struct pci_dev *dev,
|
||||
static int __init preconfigure_through_82801(struct pci_dev *dev,
|
||||
struct
|
||||
smsc_ircc_subsystem_configuration
|
||||
*conf)
|
||||
|
@ -2786,7 +2786,7 @@ static int __devinit preconfigure_through_82801(struct pci_dev *dev,
|
|||
* This is based on reverse-engineering since ALi does not
|
||||
* provide any data sheet for the 1533 chip.
|
||||
*/
|
||||
static void __devinit preconfigure_ali_port(struct pci_dev *dev,
|
||||
static void __init preconfigure_ali_port(struct pci_dev *dev,
|
||||
unsigned short port)
|
||||
{
|
||||
unsigned char reg;
|
||||
|
@ -2824,7 +2824,7 @@ static void __devinit preconfigure_ali_port(struct pci_dev *dev,
|
|||
IRDA_MESSAGE("Activated ALi 1533 ISA bridge port 0x%04x.\n", port);
|
||||
}
|
||||
|
||||
static int __devinit preconfigure_through_ali(struct pci_dev *dev,
|
||||
static int __init preconfigure_through_ali(struct pci_dev *dev,
|
||||
struct
|
||||
smsc_ircc_subsystem_configuration
|
||||
*conf)
|
||||
|
@ -2837,7 +2837,7 @@ static int __devinit preconfigure_through_ali(struct pci_dev *dev,
|
|||
return preconfigure_smsc_chip(conf);
|
||||
}
|
||||
|
||||
static int __devinit smsc_ircc_preconfigure_subsystems(unsigned short ircc_cfg,
|
||||
static int __init smsc_ircc_preconfigure_subsystems(unsigned short ircc_cfg,
|
||||
unsigned short ircc_fir,
|
||||
unsigned short ircc_sir,
|
||||
unsigned char ircc_dma,
|
||||
|
@ -2849,7 +2849,7 @@ static int __devinit smsc_ircc_preconfigure_subsystems(unsigned short ircc_cfg,
|
|||
int ret = 0;
|
||||
|
||||
for_each_pci_dev(dev) {
|
||||
const struct smsc_ircc_subsystem_configuration *conf;
|
||||
struct smsc_ircc_subsystem_configuration *conf;
|
||||
|
||||
/*
|
||||
* Cache the subsystem vendor/device:
|
||||
|
|
|
@ -661,7 +661,7 @@ static void ks8842_rx_frame(struct net_device *netdev,
|
|||
|
||||
/* check the status */
|
||||
if ((status & RXSR_VALID) && !(status & RXSR_ERROR)) {
|
||||
struct sk_buff *skb = netdev_alloc_skb_ip_align(netdev, len);
|
||||
struct sk_buff *skb = netdev_alloc_skb_ip_align(netdev, len + 3);
|
||||
|
||||
if (skb) {
|
||||
|
||||
|
|
|
@ -80,20 +80,17 @@ static void ne3210_block_output(struct net_device *dev, int count, const unsigne
|
|||
|
||||
#define NE3210_DEBUG 0x0
|
||||
|
||||
static const unsigned char irq_map[] __devinitconst =
|
||||
{ 15, 12, 11, 10, 9, 7, 5, 3 };
|
||||
static const unsigned int shmem_map[] __devinitconst =
|
||||
{ 0xff0, 0xfe0, 0xfff0, 0xd8, 0xffe0, 0xffc0, 0xd0, 0x0 };
|
||||
static const char *const ifmap[] __devinitconst =
|
||||
{ "UTP", "?", "BNC", "AUI" };
|
||||
static const int ifmap_val[] __devinitconst = {
|
||||
static unsigned char irq_map[] __initdata = {15, 12, 11, 10, 9, 7, 5, 3};
|
||||
static unsigned int shmem_map[] __initdata = {0xff0, 0xfe0, 0xfff0, 0xd8, 0xffe0, 0xffc0, 0xd0, 0x0};
|
||||
static const char *ifmap[] __initdata = {"UTP", "?", "BNC", "AUI"};
|
||||
static int ifmap_val[] __initdata = {
|
||||
IF_PORT_10BASET,
|
||||
IF_PORT_UNKNOWN,
|
||||
IF_PORT_10BASE2,
|
||||
IF_PORT_AUI,
|
||||
};
|
||||
|
||||
static int __devinit ne3210_eisa_probe (struct device *device)
|
||||
static int __init ne3210_eisa_probe (struct device *device)
|
||||
{
|
||||
unsigned long ioaddr, phys_mem;
|
||||
int i, retval, port_index;
|
||||
|
@ -316,7 +313,7 @@ static void ne3210_block_output(struct net_device *dev, int count,
|
|||
memcpy_toio(shmem, buf, count);
|
||||
}
|
||||
|
||||
static const struct eisa_device_id ne3210_ids[] __devinitconst = {
|
||||
static struct eisa_device_id ne3210_ids[] = {
|
||||
{ "EGL0101" },
|
||||
{ "NVL1801" },
|
||||
{ "" },
|
||||
|
|
|
@ -340,7 +340,7 @@ ppp_asynctty_poll(struct tty_struct *tty, struct file *file, poll_table *wait)
|
|||
}
|
||||
|
||||
/* May sleep, don't call from interrupt level or with interrupts disabled */
|
||||
static unsigned int
|
||||
static void
|
||||
ppp_asynctty_receive(struct tty_struct *tty, const unsigned char *buf,
|
||||
char *cflags, int count)
|
||||
{
|
||||
|
@ -348,7 +348,7 @@ ppp_asynctty_receive(struct tty_struct *tty, const unsigned char *buf,
|
|||
unsigned long flags;
|
||||
|
||||
if (!ap)
|
||||
return -ENODEV;
|
||||
return;
|
||||
spin_lock_irqsave(&ap->recv_lock, flags);
|
||||
ppp_async_input(ap, buf, cflags, count);
|
||||
spin_unlock_irqrestore(&ap->recv_lock, flags);
|
||||
|
@ -356,8 +356,6 @@ ppp_asynctty_receive(struct tty_struct *tty, const unsigned char *buf,
|
|||
tasklet_schedule(&ap->tsk);
|
||||
ap_put(ap);
|
||||
tty_unthrottle(tty);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
|
@ -381,7 +381,7 @@ ppp_sync_poll(struct tty_struct *tty, struct file *file, poll_table *wait)
|
|||
}
|
||||
|
||||
/* May sleep, don't call from interrupt level or with interrupts disabled */
|
||||
static unsigned int
|
||||
static void
|
||||
ppp_sync_receive(struct tty_struct *tty, const unsigned char *buf,
|
||||
char *cflags, int count)
|
||||
{
|
||||
|
@ -389,7 +389,7 @@ ppp_sync_receive(struct tty_struct *tty, const unsigned char *buf,
|
|||
unsigned long flags;
|
||||
|
||||
if (!ap)
|
||||
return -ENODEV;
|
||||
return;
|
||||
spin_lock_irqsave(&ap->recv_lock, flags);
|
||||
ppp_sync_input(ap, buf, cflags, count);
|
||||
spin_unlock_irqrestore(&ap->recv_lock, flags);
|
||||
|
@ -397,8 +397,6 @@ ppp_sync_receive(struct tty_struct *tty, const unsigned char *buf,
|
|||
tasklet_schedule(&ap->tsk);
|
||||
sp_put(ap);
|
||||
tty_unthrottle(tty);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
|
@ -670,17 +670,16 @@ static void sl_setup(struct net_device *dev)
|
|||
* in parallel
|
||||
*/
|
||||
|
||||
static unsigned int slip_receive_buf(struct tty_struct *tty,
|
||||
const unsigned char *cp, char *fp, int count)
|
||||
static void slip_receive_buf(struct tty_struct *tty, const unsigned char *cp,
|
||||
char *fp, int count)
|
||||
{
|
||||
struct slip *sl = tty->disc_data;
|
||||
int bytes = count;
|
||||
|
||||
if (!sl || sl->magic != SLIP_MAGIC || !netif_running(sl->dev))
|
||||
return -ENODEV;
|
||||
return;
|
||||
|
||||
/* Read the characters out of the buffer */
|
||||
while (bytes--) {
|
||||
while (count--) {
|
||||
if (fp && *fp++) {
|
||||
if (!test_and_set_bit(SLF_ERROR, &sl->flags))
|
||||
sl->dev->stats.rx_errors++;
|
||||
|
@ -694,8 +693,6 @@ static unsigned int slip_receive_buf(struct tty_struct *tty,
|
|||
#endif
|
||||
slip_unesc(sl, *cp++);
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
/************************************
|
||||
|
|
|
@ -156,7 +156,7 @@ static const struct {
|
|||
{ 14, 15 }
|
||||
};
|
||||
|
||||
static const short smc_mca_adapter_ids[] __devinitconst = {
|
||||
static short smc_mca_adapter_ids[] __initdata = {
|
||||
0x61c8,
|
||||
0x61c9,
|
||||
0x6fc0,
|
||||
|
@ -168,7 +168,7 @@ static const short smc_mca_adapter_ids[] __devinitconst = {
|
|||
0x0000
|
||||
};
|
||||
|
||||
static const char *const smc_mca_adapter_names[] __devinitconst = {
|
||||
static char *smc_mca_adapter_names[] __initdata = {
|
||||
"SMC Ethercard PLUS Elite/A BNC/AUI (WD8013EP/A)",
|
||||
"SMC Ethercard PLUS Elite/A UTP/AUI (WD8013WP/A)",
|
||||
"WD Ethercard PLUS/A (WD8003E/A or WD8003ET/A)",
|
||||
|
@ -199,7 +199,7 @@ static const struct net_device_ops ultramca_netdev_ops = {
|
|||
#endif
|
||||
};
|
||||
|
||||
static int __devinit ultramca_probe(struct device *gen_dev)
|
||||
static int __init ultramca_probe(struct device *gen_dev)
|
||||
{
|
||||
unsigned short ioaddr;
|
||||
struct net_device *dev;
|
||||
|
|
|
@ -5774,7 +5774,7 @@ static void tg3_skb_error_unmap(struct tg3_napi *tnapi,
|
|||
dma_unmap_addr(txb, mapping),
|
||||
skb_headlen(skb),
|
||||
PCI_DMA_TODEVICE);
|
||||
for (i = 0; i <= last; i++) {
|
||||
for (i = 0; i < last; i++) {
|
||||
skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
|
||||
|
||||
entry = NEXT_TX(entry);
|
||||
|
|
|
@ -727,7 +727,7 @@ static int __devexit madgemc_remove(struct device *device)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static const short madgemc_adapter_ids[] __devinitconst = {
|
||||
static short madgemc_adapter_ids[] __initdata = {
|
||||
0x002d,
|
||||
0x0000
|
||||
};
|
||||
|
|
|
@ -1995,7 +1995,7 @@ SetMulticastFilter(struct net_device *dev)
|
|||
|
||||
static u_char de4x5_irq[] = EISA_ALLOWED_IRQ_LIST;
|
||||
|
||||
static int __devinit de4x5_eisa_probe (struct device *gendev)
|
||||
static int __init de4x5_eisa_probe (struct device *gendev)
|
||||
{
|
||||
struct eisa_device *edev;
|
||||
u_long iobase;
|
||||
|
@ -2097,7 +2097,7 @@ static int __devexit de4x5_eisa_remove (struct device *device)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static const struct eisa_device_id de4x5_eisa_ids[] __devinitconst = {
|
||||
static struct eisa_device_id de4x5_eisa_ids[] = {
|
||||
{ "DEC4250", 0 }, /* 0 is the board name index... */
|
||||
{ "" }
|
||||
};
|
||||
|
|
|
@ -495,7 +495,7 @@ static void catc_ctrl_run(struct catc *catc)
|
|||
if (!q->dir && q->buf && q->len)
|
||||
memcpy(catc->ctrl_buf, q->buf, q->len);
|
||||
|
||||
if ((status = usb_submit_urb(catc->ctrl_urb, GFP_KERNEL)))
|
||||
if ((status = usb_submit_urb(catc->ctrl_urb, GFP_ATOMIC)))
|
||||
err("submit(ctrl_urb) status %d", status);
|
||||
}
|
||||
|
||||
|
|
|
@ -54,7 +54,7 @@
|
|||
#include <linux/usb/usbnet.h>
|
||||
#include <linux/usb/cdc.h>
|
||||
|
||||
#define DRIVER_VERSION "24-May-2011"
|
||||
#define DRIVER_VERSION "01-June-2011"
|
||||
|
||||
/* CDC NCM subclass 3.2.1 */
|
||||
#define USB_CDC_NCM_NDP16_LENGTH_MIN 0x10
|
||||
|
@ -1234,6 +1234,7 @@ static struct usb_driver cdc_ncm_driver = {
|
|||
.disconnect = cdc_ncm_disconnect,
|
||||
.suspend = usbnet_suspend,
|
||||
.resume = usbnet_resume,
|
||||
.reset_resume = usbnet_resume,
|
||||
.supports_autosuspend = 1,
|
||||
};
|
||||
|
||||
|
|
|
@ -517,18 +517,17 @@ static int x25_asy_close(struct net_device *dev)
|
|||
* and sent on to some IP layer for further processing.
|
||||
*/
|
||||
|
||||
static unsigned int x25_asy_receive_buf(struct tty_struct *tty,
|
||||
static void x25_asy_receive_buf(struct tty_struct *tty,
|
||||
const unsigned char *cp, char *fp, int count)
|
||||
{
|
||||
struct x25_asy *sl = tty->disc_data;
|
||||
int bytes = count;
|
||||
|
||||
if (!sl || sl->magic != X25_ASY_MAGIC || !netif_running(sl->dev))
|
||||
return;
|
||||
|
||||
|
||||
/* Read the characters out of the buffer */
|
||||
while (bytes--) {
|
||||
while (count--) {
|
||||
if (fp && *fp++) {
|
||||
if (!test_and_set_bit(SLF_ERROR, &sl->flags))
|
||||
sl->dev->stats.rx_errors++;
|
||||
|
@ -537,8 +536,6 @@ static unsigned int x25_asy_receive_buf(struct tty_struct *tty,
|
|||
}
|
||||
x25_asy_unesc(sl, *cp++);
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -26,7 +26,6 @@ config ATH9K
|
|||
config ATH9K_PCI
|
||||
bool "Atheros ath9k PCI/PCIe bus support"
|
||||
depends on ATH9K && PCI
|
||||
default PCI
|
||||
---help---
|
||||
This option enables the PCI bus support in ath9k.
|
||||
|
||||
|
|
|
@ -829,7 +829,7 @@ static bool ar9002_hw_init_cal(struct ath_hw *ah, struct ath9k_channel *chan)
|
|||
if (AR_SREV_9271(ah)) {
|
||||
if (!ar9285_hw_cl_cal(ah, chan))
|
||||
return false;
|
||||
} else if (AR_SREV_9285_12_OR_LATER(ah)) {
|
||||
} else if (AR_SREV_9285(ah) && AR_SREV_9285_12_OR_LATER(ah)) {
|
||||
if (!ar9285_hw_clc(ah, chan))
|
||||
return false;
|
||||
} else {
|
||||
|
|
|
@ -4645,10 +4645,16 @@ static void ar9003_hw_set_power_per_rate_table(struct ath_hw *ah,
|
|||
case 1:
|
||||
break;
|
||||
case 2:
|
||||
scaledPower -= REDUCE_SCALED_POWER_BY_TWO_CHAIN;
|
||||
if (scaledPower > REDUCE_SCALED_POWER_BY_TWO_CHAIN)
|
||||
scaledPower -= REDUCE_SCALED_POWER_BY_TWO_CHAIN;
|
||||
else
|
||||
scaledPower = 0;
|
||||
break;
|
||||
case 3:
|
||||
scaledPower -= REDUCE_SCALED_POWER_BY_THREE_CHAIN;
|
||||
if (scaledPower > REDUCE_SCALED_POWER_BY_THREE_CHAIN)
|
||||
scaledPower -= REDUCE_SCALED_POWER_BY_THREE_CHAIN;
|
||||
else
|
||||
scaledPower = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
|
@ -1381,3 +1381,25 @@ void ar9003_hw_bb_watchdog_dbg_info(struct ath_hw *ah)
|
|||
"==== BB update: done ====\n\n");
|
||||
}
|
||||
EXPORT_SYMBOL(ar9003_hw_bb_watchdog_dbg_info);
|
||||
|
||||
void ar9003_hw_disable_phy_restart(struct ath_hw *ah)
|
||||
{
|
||||
u32 val;
|
||||
|
||||
/* While receiving unsupported rate frame rx state machine
|
||||
* gets into a state 0xb and if phy_restart happens in that
|
||||
* state, BB would go hang. If RXSM is in 0xb state after
|
||||
* first bb panic, ensure to disable the phy_restart.
|
||||
*/
|
||||
if (!((MS(ah->bb_watchdog_last_status,
|
||||
AR_PHY_WATCHDOG_RX_OFDM_SM) == 0xb) ||
|
||||
ah->bb_hang_rx_ofdm))
|
||||
return;
|
||||
|
||||
ah->bb_hang_rx_ofdm = true;
|
||||
val = REG_READ(ah, AR_PHY_RESTART);
|
||||
val &= ~AR_PHY_RESTART_ENA;
|
||||
|
||||
REG_WRITE(ah, AR_PHY_RESTART, val);
|
||||
}
|
||||
EXPORT_SYMBOL(ar9003_hw_disable_phy_restart);
|
||||
|
|
|
@ -524,10 +524,16 @@ static void ath9k_hw_set_ar9287_power_per_rate_table(struct ath_hw *ah,
|
|||
case 1:
|
||||
break;
|
||||
case 2:
|
||||
scaledPower -= REDUCE_SCALED_POWER_BY_TWO_CHAIN;
|
||||
if (scaledPower > REDUCE_SCALED_POWER_BY_TWO_CHAIN)
|
||||
scaledPower -= REDUCE_SCALED_POWER_BY_TWO_CHAIN;
|
||||
else
|
||||
scaledPower = 0;
|
||||
break;
|
||||
case 3:
|
||||
scaledPower -= REDUCE_SCALED_POWER_BY_THREE_CHAIN;
|
||||
if (scaledPower > REDUCE_SCALED_POWER_BY_THREE_CHAIN)
|
||||
scaledPower -= REDUCE_SCALED_POWER_BY_THREE_CHAIN;
|
||||
else
|
||||
scaledPower = 0;
|
||||
break;
|
||||
}
|
||||
scaledPower = max((u16)0, scaledPower);
|
||||
|
|
|
@ -1555,9 +1555,12 @@ int ath9k_hw_reset(struct ath_hw *ah, struct ath9k_channel *chan,
|
|||
if (ah->btcoex_hw.enabled)
|
||||
ath9k_hw_btcoex_enable(ah);
|
||||
|
||||
if (AR_SREV_9300_20_OR_LATER(ah))
|
||||
if (AR_SREV_9300_20_OR_LATER(ah)) {
|
||||
ar9003_hw_bb_watchdog_config(ah);
|
||||
|
||||
ar9003_hw_disable_phy_restart(ah);
|
||||
}
|
||||
|
||||
ath9k_hw_apply_gpio_override(ah);
|
||||
|
||||
return 0;
|
||||
|
|
|
@ -842,6 +842,7 @@ struct ath_hw {
|
|||
|
||||
u32 bb_watchdog_last_status;
|
||||
u32 bb_watchdog_timeout_ms; /* in ms, 0 to disable */
|
||||
u8 bb_hang_rx_ofdm; /* true if bb hang due to rx_ofdm */
|
||||
|
||||
unsigned int paprd_target_power;
|
||||
unsigned int paprd_training_power;
|
||||
|
@ -990,6 +991,7 @@ void ar9002_hw_enable_wep_aggregation(struct ath_hw *ah);
|
|||
void ar9003_hw_bb_watchdog_config(struct ath_hw *ah);
|
||||
void ar9003_hw_bb_watchdog_read(struct ath_hw *ah);
|
||||
void ar9003_hw_bb_watchdog_dbg_info(struct ath_hw *ah);
|
||||
void ar9003_hw_disable_phy_restart(struct ath_hw *ah);
|
||||
void ar9003_paprd_enable(struct ath_hw *ah, bool val);
|
||||
void ar9003_paprd_populate_single_table(struct ath_hw *ah,
|
||||
struct ath9k_hw_cal_data *caldata,
|
||||
|
|
|
@ -670,7 +670,8 @@ void ath9k_tasklet(unsigned long data)
|
|||
u32 status = sc->intrstatus;
|
||||
u32 rxmask;
|
||||
|
||||
if (status & ATH9K_INT_FATAL) {
|
||||
if ((status & ATH9K_INT_FATAL) ||
|
||||
(status & ATH9K_INT_BB_WATCHDOG)) {
|
||||
ath_reset(sc, true);
|
||||
return;
|
||||
}
|
||||
|
@ -737,6 +738,7 @@ irqreturn_t ath_isr(int irq, void *dev)
|
|||
{
|
||||
#define SCHED_INTR ( \
|
||||
ATH9K_INT_FATAL | \
|
||||
ATH9K_INT_BB_WATCHDOG | \
|
||||
ATH9K_INT_RXORN | \
|
||||
ATH9K_INT_RXEOL | \
|
||||
ATH9K_INT_RX | \
|
||||
|
|
|
@ -689,7 +689,8 @@ static void ath_rc_rate_set_series(const struct ath_rate_table *rate_table,
|
|||
|
||||
if (WLAN_RC_PHY_HT(rate_table->info[rix].phy)) {
|
||||
rate->flags |= IEEE80211_TX_RC_MCS;
|
||||
if (WLAN_RC_PHY_40(rate_table->info[rix].phy))
|
||||
if (WLAN_RC_PHY_40(rate_table->info[rix].phy) &&
|
||||
conf_is_ht40(&txrc->hw->conf))
|
||||
rate->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
|
||||
if (WLAN_RC_PHY_SGI(rate_table->info[rix].phy))
|
||||
rate->flags |= IEEE80211_TX_RC_SHORT_GI;
|
||||
|
|
|
@ -3093,7 +3093,7 @@ static int b43_nphy_cal_tx_iq_lo(struct b43_wldev *dev,
|
|||
int freq;
|
||||
bool avoid = false;
|
||||
u8 length;
|
||||
u16 tmp, core, type, count, max, numb, last, cmd;
|
||||
u16 tmp, core, type, count, max, numb, last = 0, cmd;
|
||||
const u16 *table;
|
||||
bool phy6or5x;
|
||||
|
||||
|
|
|
@ -628,11 +628,11 @@ void iwl4965_rx_reply_rx(struct iwl_priv *priv,
|
|||
|
||||
/* rx_status carries information about the packet to mac80211 */
|
||||
rx_status.mactime = le64_to_cpu(phy_res->timestamp);
|
||||
rx_status.band = (phy_res->phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ?
|
||||
IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
|
||||
rx_status.freq =
|
||||
ieee80211_channel_to_frequency(le16_to_cpu(phy_res->channel),
|
||||
rx_status.band);
|
||||
rx_status.band = (phy_res->phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ?
|
||||
IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
|
||||
rx_status.rate_idx =
|
||||
iwl4965_hwrate_to_mac80211_idx(rate_n_flags, rx_status.band);
|
||||
rx_status.flag = 0;
|
||||
|
|
|
@ -1543,7 +1543,7 @@ static void iwl4965_temperature_calib(struct iwl_priv *priv)
|
|||
s32 temp;
|
||||
|
||||
temp = iwl4965_hw_get_temperature(priv);
|
||||
if (temp < 0)
|
||||
if (IWL_TX_POWER_TEMPERATURE_OUT_OF_RANGE(temp))
|
||||
return;
|
||||
|
||||
if (priv->temperature != temp) {
|
||||
|
|
|
@ -603,19 +603,27 @@ struct iwl_cfg iwl6050_2abg_cfg = {
|
|||
IWL_DEVICE_6050,
|
||||
};
|
||||
|
||||
#define IWL_DEVICE_6150 \
|
||||
.fw_name_pre = IWL6050_FW_PRE, \
|
||||
.ucode_api_max = IWL6050_UCODE_API_MAX, \
|
||||
.ucode_api_min = IWL6050_UCODE_API_MIN, \
|
||||
.ops = &iwl6150_ops, \
|
||||
.eeprom_ver = EEPROM_6150_EEPROM_VERSION, \
|
||||
.eeprom_calib_ver = EEPROM_6150_TX_POWER_VERSION, \
|
||||
.base_params = &iwl6050_base_params, \
|
||||
.need_dc_calib = true, \
|
||||
.led_mode = IWL_LED_BLINK, \
|
||||
.internal_wimax_coex = true
|
||||
|
||||
struct iwl_cfg iwl6150_bgn_cfg = {
|
||||
.name = "Intel(R) Centrino(R) Wireless-N + WiMAX 6150 BGN",
|
||||
.fw_name_pre = IWL6050_FW_PRE,
|
||||
.ucode_api_max = IWL6050_UCODE_API_MAX,
|
||||
.ucode_api_min = IWL6050_UCODE_API_MIN,
|
||||
.eeprom_ver = EEPROM_6150_EEPROM_VERSION,
|
||||
.eeprom_calib_ver = EEPROM_6150_TX_POWER_VERSION,
|
||||
.ops = &iwl6150_ops,
|
||||
.base_params = &iwl6050_base_params,
|
||||
IWL_DEVICE_6150,
|
||||
.ht_params = &iwl6000_ht_params,
|
||||
.need_dc_calib = true,
|
||||
.led_mode = IWL_LED_RF_STATE,
|
||||
.internal_wimax_coex = true,
|
||||
};
|
||||
|
||||
struct iwl_cfg iwl6150_bg_cfg = {
|
||||
.name = "Intel(R) Centrino(R) Wireless-N + WiMAX 6150 BG",
|
||||
IWL_DEVICE_6150,
|
||||
};
|
||||
|
||||
struct iwl_cfg iwl6000_3agn_cfg = {
|
||||
|
|
|
@ -3831,11 +3831,11 @@ static DEFINE_PCI_DEVICE_TABLE(iwl_hw_card_ids) = {
|
|||
|
||||
/* 6150 WiFi/WiMax Series */
|
||||
{IWL_PCI_DEVICE(0x0885, 0x1305, iwl6150_bgn_cfg)},
|
||||
{IWL_PCI_DEVICE(0x0885, 0x1306, iwl6150_bgn_cfg)},
|
||||
{IWL_PCI_DEVICE(0x0885, 0x1307, iwl6150_bg_cfg)},
|
||||
{IWL_PCI_DEVICE(0x0885, 0x1325, iwl6150_bgn_cfg)},
|
||||
{IWL_PCI_DEVICE(0x0885, 0x1326, iwl6150_bgn_cfg)},
|
||||
{IWL_PCI_DEVICE(0x0885, 0x1327, iwl6150_bg_cfg)},
|
||||
{IWL_PCI_DEVICE(0x0886, 0x1315, iwl6150_bgn_cfg)},
|
||||
{IWL_PCI_DEVICE(0x0886, 0x1316, iwl6150_bgn_cfg)},
|
||||
{IWL_PCI_DEVICE(0x0886, 0x1317, iwl6150_bg_cfg)},
|
||||
|
||||
/* 1000 Series WiFi */
|
||||
{IWL_PCI_DEVICE(0x0083, 0x1205, iwl1000_bgn_cfg)},
|
||||
|
|
|
@ -89,6 +89,7 @@ extern struct iwl_cfg iwl6000_3agn_cfg;
|
|||
extern struct iwl_cfg iwl6050_2agn_cfg;
|
||||
extern struct iwl_cfg iwl6050_2abg_cfg;
|
||||
extern struct iwl_cfg iwl6150_bgn_cfg;
|
||||
extern struct iwl_cfg iwl6150_bg_cfg;
|
||||
extern struct iwl_cfg iwl1000_bgn_cfg;
|
||||
extern struct iwl_cfg iwl1000_bg_cfg;
|
||||
extern struct iwl_cfg iwl100_bgn_cfg;
|
||||
|
|
|
@ -994,6 +994,8 @@ static void lbs_submit_command(struct lbs_private *priv,
|
|||
cmd = cmdnode->cmdbuf;
|
||||
|
||||
spin_lock_irqsave(&priv->driver_lock, flags);
|
||||
priv->seqnum++;
|
||||
cmd->seqnum = cpu_to_le16(priv->seqnum);
|
||||
priv->cur_cmd = cmdnode;
|
||||
spin_unlock_irqrestore(&priv->driver_lock, flags);
|
||||
|
||||
|
@ -1621,11 +1623,9 @@ struct cmd_ctrl_node *__lbs_cmd_async(struct lbs_private *priv,
|
|||
/* Copy the incoming command to the buffer */
|
||||
memcpy(cmdnode->cmdbuf, in_cmd, in_cmd_size);
|
||||
|
||||
/* Set sequence number, clean result, move to buffer */
|
||||
priv->seqnum++;
|
||||
/* Set command, clean result, move to buffer */
|
||||
cmdnode->cmdbuf->command = cpu_to_le16(command);
|
||||
cmdnode->cmdbuf->size = cpu_to_le16(in_cmd_size);
|
||||
cmdnode->cmdbuf->seqnum = cpu_to_le16(priv->seqnum);
|
||||
cmdnode->cmdbuf->result = 0;
|
||||
|
||||
lbs_deb_host("PREP_CMD: command 0x%04x\n", command);
|
||||
|
|
|
@ -167,8 +167,8 @@
|
|||
/* Rx unit register */
|
||||
#define CARD_RX_UNIT_REG 0x63
|
||||
|
||||
/* Event header Len*/
|
||||
#define MWIFIEX_EVENT_HEADER_LEN 8
|
||||
/* Event header len w/o 4 bytes of interface header */
|
||||
#define MWIFIEX_EVENT_HEADER_LEN 4
|
||||
|
||||
/* Max retry number of CMD53 write */
|
||||
#define MAX_WRITE_IOMEM_RETRY 2
|
||||
|
|
|
@ -166,7 +166,6 @@ config RT2800USB_RT35XX
|
|||
config RT2800USB_RT53XX
|
||||
bool "rt2800usb - Include support for rt53xx devices (EXPERIMENTAL)"
|
||||
depends on EXPERIMENTAL
|
||||
default y
|
||||
---help---
|
||||
This adds support for rt53xx wireless chipset family to the
|
||||
rt2800pci driver.
|
||||
|
|
|
@ -669,11 +669,6 @@ static void _rtl_pci_rx_interrupt(struct ieee80211_hw *hw)
|
|||
&rx_status,
|
||||
(u8 *) pdesc, skb);
|
||||
|
||||
pci_unmap_single(rtlpci->pdev,
|
||||
*((dma_addr_t *) skb->cb),
|
||||
rtlpci->rxbuffersize,
|
||||
PCI_DMA_FROMDEVICE);
|
||||
|
||||
skb_put(skb, rtlpriv->cfg->ops->get_desc((u8 *) pdesc,
|
||||
false,
|
||||
HW_DESC_RXPKT_LEN));
|
||||
|
@ -690,6 +685,21 @@ static void _rtl_pci_rx_interrupt(struct ieee80211_hw *hw)
|
|||
hdr = rtl_get_hdr(skb);
|
||||
fc = rtl_get_fc(skb);
|
||||
|
||||
/* try for new buffer - if allocation fails, drop
|
||||
* frame and reuse old buffer
|
||||
*/
|
||||
new_skb = dev_alloc_skb(rtlpci->rxbuffersize);
|
||||
if (unlikely(!new_skb)) {
|
||||
RT_TRACE(rtlpriv, (COMP_INTR | COMP_RECV),
|
||||
DBG_DMESG,
|
||||
("can't alloc skb for rx\n"));
|
||||
goto done;
|
||||
}
|
||||
pci_unmap_single(rtlpci->pdev,
|
||||
*((dma_addr_t *) skb->cb),
|
||||
rtlpci->rxbuffersize,
|
||||
PCI_DMA_FROMDEVICE);
|
||||
|
||||
if (!stats.crc || !stats.hwerror) {
|
||||
memcpy(IEEE80211_SKB_RXCB(skb), &rx_status,
|
||||
sizeof(rx_status));
|
||||
|
@ -758,15 +768,7 @@ static void _rtl_pci_rx_interrupt(struct ieee80211_hw *hw)
|
|||
rtl_lps_leave(hw);
|
||||
}
|
||||
|
||||
new_skb = dev_alloc_skb(rtlpci->rxbuffersize);
|
||||
if (unlikely(!new_skb)) {
|
||||
RT_TRACE(rtlpriv, (COMP_INTR | COMP_RECV),
|
||||
DBG_DMESG,
|
||||
("can't alloc skb for rx\n"));
|
||||
goto done;
|
||||
}
|
||||
skb = new_skb;
|
||||
/*skb->dev = dev; */
|
||||
|
||||
rtlpci->rx_ring[rx_queue_idx].rx_buf[rtlpci->
|
||||
rx_ring
|
||||
|
@ -1113,6 +1115,13 @@ static int _rtl_pci_init_rx_ring(struct ieee80211_hw *hw)
|
|||
|
||||
rtlpci->rx_ring[rx_queue_idx].idx = 0;
|
||||
|
||||
/* If amsdu_8k is disabled, set buffersize to 4096. This
|
||||
* change will reduce memory fragmentation.
|
||||
*/
|
||||
if (rtlpci->rxbuffersize > 4096 &&
|
||||
rtlpriv->rtlhal.disable_amsdu_8k)
|
||||
rtlpci->rxbuffersize = 4096;
|
||||
|
||||
for (i = 0; i < rtlpci->rxringcount; i++) {
|
||||
struct sk_buff *skb =
|
||||
dev_alloc_skb(rtlpci->rxbuffersize);
|
||||
|
|
|
@ -1157,6 +1157,9 @@ struct conf_sched_scan_settings {
|
|||
/* time to wait on the channel for passive scans (in TUs) */
|
||||
u32 dwell_time_passive;
|
||||
|
||||
/* time to wait on the channel for DFS scans (in TUs) */
|
||||
u32 dwell_time_dfs;
|
||||
|
||||
/* number of probe requests to send on each channel in active scans */
|
||||
u8 num_probe_reqs;
|
||||
|
||||
|
|
|
@ -311,6 +311,7 @@ static struct conf_drv_settings default_conf = {
|
|||
.min_dwell_time_active = 8,
|
||||
.max_dwell_time_active = 30,
|
||||
.dwell_time_passive = 100,
|
||||
.dwell_time_dfs = 150,
|
||||
.num_probe_reqs = 2,
|
||||
.rssi_threshold = -90,
|
||||
.snr_threshold = 0,
|
||||
|
|
|
@ -331,16 +331,22 @@ wl1271_scan_get_sched_scan_channels(struct wl1271 *wl,
|
|||
struct conf_sched_scan_settings *c = &wl->conf.sched_scan;
|
||||
int i, j;
|
||||
u32 flags;
|
||||
bool force_passive = !req->n_ssids;
|
||||
|
||||
for (i = 0, j = start;
|
||||
i < req->n_channels && j < MAX_CHANNELS_ALL_BANDS;
|
||||
i++) {
|
||||
flags = req->channels[i]->flags;
|
||||
|
||||
if (!(flags & IEEE80211_CHAN_DISABLED) &&
|
||||
((flags & IEEE80211_CHAN_PASSIVE_SCAN) == passive) &&
|
||||
((flags & IEEE80211_CHAN_RADAR) == radar) &&
|
||||
(req->channels[i]->band == band)) {
|
||||
if (force_passive)
|
||||
flags |= IEEE80211_CHAN_PASSIVE_SCAN;
|
||||
|
||||
if ((req->channels[i]->band == band) &&
|
||||
!(flags & IEEE80211_CHAN_DISABLED) &&
|
||||
(!!(flags & IEEE80211_CHAN_RADAR) == radar) &&
|
||||
/* if radar is set, we ignore the passive flag */
|
||||
(radar ||
|
||||
!!(flags & IEEE80211_CHAN_PASSIVE_SCAN) == passive)) {
|
||||
wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d ",
|
||||
req->channels[i]->band,
|
||||
req->channels[i]->center_freq);
|
||||
|
@ -350,7 +356,12 @@ wl1271_scan_get_sched_scan_channels(struct wl1271 *wl,
|
|||
wl1271_debug(DEBUG_SCAN, "max_power %d",
|
||||
req->channels[i]->max_power);
|
||||
|
||||
if (flags & IEEE80211_CHAN_PASSIVE_SCAN) {
|
||||
if (flags & IEEE80211_CHAN_RADAR) {
|
||||
channels[j].flags |= SCAN_CHANNEL_FLAGS_DFS;
|
||||
channels[j].passive_duration =
|
||||
cpu_to_le16(c->dwell_time_dfs);
|
||||
}
|
||||
else if (flags & IEEE80211_CHAN_PASSIVE_SCAN) {
|
||||
channels[j].passive_duration =
|
||||
cpu_to_le16(c->dwell_time_passive);
|
||||
} else {
|
||||
|
@ -359,7 +370,7 @@ wl1271_scan_get_sched_scan_channels(struct wl1271 *wl,
|
|||
channels[j].max_duration =
|
||||
cpu_to_le16(c->max_dwell_time_active);
|
||||
}
|
||||
channels[j].tx_power_att = req->channels[j]->max_power;
|
||||
channels[j].tx_power_att = req->channels[i]->max_power;
|
||||
channels[j].channel = req->channels[i]->hw_value;
|
||||
|
||||
j++;
|
||||
|
@ -386,7 +397,11 @@ wl1271_scan_sched_scan_channels(struct wl1271 *wl,
|
|||
wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels,
|
||||
IEEE80211_BAND_2GHZ,
|
||||
false, false, idx);
|
||||
idx += cfg->active[0];
|
||||
/*
|
||||
* 5GHz channels always start at position 14, not immediately
|
||||
* after the last 2.4GHz channel
|
||||
*/
|
||||
idx = 14;
|
||||
|
||||
cfg->passive[1] =
|
||||
wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels,
|
||||
|
@ -394,22 +409,23 @@ wl1271_scan_sched_scan_channels(struct wl1271 *wl,
|
|||
false, true, idx);
|
||||
idx += cfg->passive[1];
|
||||
|
||||
cfg->active[1] =
|
||||
wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels,
|
||||
IEEE80211_BAND_5GHZ,
|
||||
false, false, 14);
|
||||
idx += cfg->active[1];
|
||||
|
||||
cfg->dfs =
|
||||
wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels,
|
||||
IEEE80211_BAND_5GHZ,
|
||||
true, false, idx);
|
||||
true, true, idx);
|
||||
idx += cfg->dfs;
|
||||
|
||||
cfg->active[1] =
|
||||
wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels,
|
||||
IEEE80211_BAND_5GHZ,
|
||||
false, false, idx);
|
||||
idx += cfg->active[1];
|
||||
|
||||
wl1271_debug(DEBUG_SCAN, " 2.4GHz: active %d passive %d",
|
||||
cfg->active[0], cfg->passive[0]);
|
||||
wl1271_debug(DEBUG_SCAN, " 5GHz: active %d passive %d",
|
||||
cfg->active[1], cfg->passive[1]);
|
||||
wl1271_debug(DEBUG_SCAN, " DFS: %d", cfg->dfs);
|
||||
|
||||
return idx;
|
||||
}
|
||||
|
@ -421,6 +437,7 @@ int wl1271_scan_sched_scan_config(struct wl1271 *wl,
|
|||
struct wl1271_cmd_sched_scan_config *cfg = NULL;
|
||||
struct conf_sched_scan_settings *c = &wl->conf.sched_scan;
|
||||
int i, total_channels, ret;
|
||||
bool force_passive = !req->n_ssids;
|
||||
|
||||
wl1271_debug(DEBUG_CMD, "cmd sched_scan scan config");
|
||||
|
||||
|
@ -444,7 +461,7 @@ int wl1271_scan_sched_scan_config(struct wl1271 *wl,
|
|||
for (i = 0; i < SCAN_MAX_CYCLE_INTERVALS; i++)
|
||||
cfg->intervals[i] = cpu_to_le32(req->interval);
|
||||
|
||||
if (req->ssids[0].ssid_len && req->ssids[0].ssid) {
|
||||
if (!force_passive && req->ssids[0].ssid_len && req->ssids[0].ssid) {
|
||||
cfg->filter_type = SCAN_SSID_FILTER_SPECIFIC;
|
||||
cfg->ssid_len = req->ssids[0].ssid_len;
|
||||
memcpy(cfg->ssid, req->ssids[0].ssid,
|
||||
|
@ -461,7 +478,7 @@ int wl1271_scan_sched_scan_config(struct wl1271 *wl,
|
|||
goto out;
|
||||
}
|
||||
|
||||
if (cfg->active[0]) {
|
||||
if (!force_passive && cfg->active[0]) {
|
||||
ret = wl1271_cmd_build_probe_req(wl, req->ssids[0].ssid,
|
||||
req->ssids[0].ssid_len,
|
||||
ies->ie[IEEE80211_BAND_2GHZ],
|
||||
|
@ -473,7 +490,7 @@ int wl1271_scan_sched_scan_config(struct wl1271 *wl,
|
|||
}
|
||||
}
|
||||
|
||||
if (cfg->active[1]) {
|
||||
if (!force_passive && cfg->active[1]) {
|
||||
ret = wl1271_cmd_build_probe_req(wl, req->ssids[0].ssid,
|
||||
req->ssids[0].ssid_len,
|
||||
ies->ie[IEEE80211_BAND_5GHZ],
|
||||
|
|
|
@ -137,6 +137,9 @@ enum {
|
|||
SCAN_BSS_TYPE_ANY,
|
||||
};
|
||||
|
||||
#define SCAN_CHANNEL_FLAGS_DFS BIT(0)
|
||||
#define SCAN_CHANNEL_FLAGS_DFS_ENABLED BIT(1)
|
||||
|
||||
struct conn_scan_ch_params {
|
||||
__le16 min_duration;
|
||||
__le16 max_duration;
|
||||
|
|
|
@ -1533,6 +1533,31 @@ static void __exit usb_exit(void)
|
|||
module_init(usb_init);
|
||||
module_exit(usb_exit);
|
||||
|
||||
static int zd_ep_regs_out_msg(struct usb_device *udev, void *data, int len,
|
||||
int *actual_length, int timeout)
|
||||
{
|
||||
/* In USB 2.0 mode EP_REGS_OUT endpoint is interrupt type. However in
|
||||
* USB 1.1 mode endpoint is bulk. Select correct type URB by endpoint
|
||||
* descriptor.
|
||||
*/
|
||||
struct usb_host_endpoint *ep;
|
||||
unsigned int pipe;
|
||||
|
||||
pipe = usb_sndintpipe(udev, EP_REGS_OUT);
|
||||
ep = usb_pipe_endpoint(udev, pipe);
|
||||
if (!ep)
|
||||
return -EINVAL;
|
||||
|
||||
if (usb_endpoint_xfer_int(&ep->desc)) {
|
||||
return usb_interrupt_msg(udev, pipe, data, len,
|
||||
actual_length, timeout);
|
||||
} else {
|
||||
pipe = usb_sndbulkpipe(udev, EP_REGS_OUT);
|
||||
return usb_bulk_msg(udev, pipe, data, len, actual_length,
|
||||
timeout);
|
||||
}
|
||||
}
|
||||
|
||||
static int usb_int_regs_length(unsigned int count)
|
||||
{
|
||||
return sizeof(struct usb_int_regs) + count * sizeof(struct reg_data);
|
||||
|
@ -1648,15 +1673,14 @@ int zd_usb_ioread16v(struct zd_usb *usb, u16 *values,
|
|||
|
||||
udev = zd_usb_to_usbdev(usb);
|
||||
prepare_read_regs_int(usb);
|
||||
r = usb_interrupt_msg(udev, usb_sndintpipe(udev, EP_REGS_OUT),
|
||||
req, req_len, &actual_req_len, 50 /* ms */);
|
||||
r = zd_ep_regs_out_msg(udev, req, req_len, &actual_req_len, 50 /*ms*/);
|
||||
if (r) {
|
||||
dev_dbg_f(zd_usb_dev(usb),
|
||||
"error in usb_interrupt_msg(). Error number %d\n", r);
|
||||
"error in zd_ep_regs_out_msg(). Error number %d\n", r);
|
||||
goto error;
|
||||
}
|
||||
if (req_len != actual_req_len) {
|
||||
dev_dbg_f(zd_usb_dev(usb), "error in usb_interrupt_msg()\n"
|
||||
dev_dbg_f(zd_usb_dev(usb), "error in zd_ep_regs_out_msg()\n"
|
||||
" req_len %d != actual_req_len %d\n",
|
||||
req_len, actual_req_len);
|
||||
r = -EIO;
|
||||
|
@ -1818,9 +1842,17 @@ int zd_usb_iowrite16v_async(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
|
|||
rw->value = cpu_to_le16(ioreqs[i].value);
|
||||
}
|
||||
|
||||
usb_fill_int_urb(urb, udev, usb_sndintpipe(udev, EP_REGS_OUT),
|
||||
req, req_len, iowrite16v_urb_complete, usb,
|
||||
ep->desc.bInterval);
|
||||
/* In USB 2.0 mode endpoint is interrupt type. However in USB 1.1 mode
|
||||
* endpoint is bulk. Select correct type URB by endpoint descriptor.
|
||||
*/
|
||||
if (usb_endpoint_xfer_int(&ep->desc))
|
||||
usb_fill_int_urb(urb, udev, usb_sndintpipe(udev, EP_REGS_OUT),
|
||||
req, req_len, iowrite16v_urb_complete, usb,
|
||||
ep->desc.bInterval);
|
||||
else
|
||||
usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, EP_REGS_OUT),
|
||||
req, req_len, iowrite16v_urb_complete, usb);
|
||||
|
||||
urb->transfer_flags |= URB_FREE_BUFFER;
|
||||
|
||||
/* Submit previous URB */
|
||||
|
@ -1924,15 +1956,14 @@ int zd_usb_rfwrite(struct zd_usb *usb, u32 value, u8 bits)
|
|||
}
|
||||
|
||||
udev = zd_usb_to_usbdev(usb);
|
||||
r = usb_interrupt_msg(udev, usb_sndintpipe(udev, EP_REGS_OUT),
|
||||
req, req_len, &actual_req_len, 50 /* ms */);
|
||||
r = zd_ep_regs_out_msg(udev, req, req_len, &actual_req_len, 50 /*ms*/);
|
||||
if (r) {
|
||||
dev_dbg_f(zd_usb_dev(usb),
|
||||
"error in usb_interrupt_msg(). Error number %d\n", r);
|
||||
"error in zd_ep_regs_out_msg(). Error number %d\n", r);
|
||||
goto out;
|
||||
}
|
||||
if (req_len != actual_req_len) {
|
||||
dev_dbg_f(zd_usb_dev(usb), "error in usb_interrupt_msg()"
|
||||
dev_dbg_f(zd_usb_dev(usb), "error in zd_ep_regs_out_msg()"
|
||||
" req_len %d != actual_req_len %d\n",
|
||||
req_len, actual_req_len);
|
||||
r = -EIO;
|
||||
|
|
|
@ -297,7 +297,7 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
|
|||
kfree(sdev);
|
||||
goto out;
|
||||
}
|
||||
|
||||
blk_get_queue(sdev->request_queue);
|
||||
sdev->request_queue->queuedata = sdev;
|
||||
scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
|
||||
|
||||
|
|
|
@ -322,6 +322,7 @@ static void scsi_device_dev_release_usercontext(struct work_struct *work)
|
|||
kfree(evt);
|
||||
}
|
||||
|
||||
blk_put_queue(sdev->request_queue);
|
||||
/* NULL queue means the device can't be used */
|
||||
sdev->request_queue = NULL;
|
||||
|
||||
|
|
|
@ -2128,8 +2128,8 @@ static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
|
|||
gsm->tty = NULL;
|
||||
}
|
||||
|
||||
static unsigned int gsmld_receive_buf(struct tty_struct *tty,
|
||||
const unsigned char *cp, char *fp, int count)
|
||||
static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
|
||||
char *fp, int count)
|
||||
{
|
||||
struct gsm_mux *gsm = tty->disc_data;
|
||||
const unsigned char *dp;
|
||||
|
@ -2162,8 +2162,6 @@ static unsigned int gsmld_receive_buf(struct tty_struct *tty,
|
|||
}
|
||||
/* FASYNC if needed ? */
|
||||
/* If clogged call tty_throttle(tty); */
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -188,8 +188,8 @@ static unsigned int n_hdlc_tty_poll(struct tty_struct *tty, struct file *filp,
|
|||
poll_table *wait);
|
||||
static int n_hdlc_tty_open(struct tty_struct *tty);
|
||||
static void n_hdlc_tty_close(struct tty_struct *tty);
|
||||
static unsigned int n_hdlc_tty_receive(struct tty_struct *tty,
|
||||
const __u8 *cp, char *fp, int count);
|
||||
static void n_hdlc_tty_receive(struct tty_struct *tty, const __u8 *cp,
|
||||
char *fp, int count);
|
||||
static void n_hdlc_tty_wakeup(struct tty_struct *tty);
|
||||
|
||||
#define bset(p,b) ((p)[(b) >> 5] |= (1 << ((b) & 0x1f)))
|
||||
|
@ -509,8 +509,8 @@ static void n_hdlc_tty_wakeup(struct tty_struct *tty)
|
|||
* Called by tty low level driver when receive data is available. Data is
|
||||
* interpreted as one HDLC frame.
|
||||
*/
|
||||
static unsigned int n_hdlc_tty_receive(struct tty_struct *tty,
|
||||
const __u8 *data, char *flags, int count)
|
||||
static void n_hdlc_tty_receive(struct tty_struct *tty, const __u8 *data,
|
||||
char *flags, int count)
|
||||
{
|
||||
register struct n_hdlc *n_hdlc = tty2n_hdlc (tty);
|
||||
register struct n_hdlc_buf *buf;
|
||||
|
@ -521,20 +521,20 @@ static unsigned int n_hdlc_tty_receive(struct tty_struct *tty,
|
|||
|
||||
/* This can happen if stuff comes in on the backup tty */
|
||||
if (!n_hdlc || tty != n_hdlc->tty)
|
||||
return -ENODEV;
|
||||
return;
|
||||
|
||||
/* verify line is using HDLC discipline */
|
||||
if (n_hdlc->magic != HDLC_MAGIC) {
|
||||
printk("%s(%d) line not using HDLC discipline\n",
|
||||
__FILE__,__LINE__);
|
||||
return -EINVAL;
|
||||
return;
|
||||
}
|
||||
|
||||
if ( count>maxframe ) {
|
||||
if (debuglevel >= DEBUG_LEVEL_INFO)
|
||||
printk("%s(%d) rx count>maxframesize, data discarded\n",
|
||||
__FILE__,__LINE__);
|
||||
return -EINVAL;
|
||||
return;
|
||||
}
|
||||
|
||||
/* get a free HDLC buffer */
|
||||
|
@ -550,7 +550,7 @@ static unsigned int n_hdlc_tty_receive(struct tty_struct *tty,
|
|||
if (debuglevel >= DEBUG_LEVEL_INFO)
|
||||
printk("%s(%d) no more rx buffers, data discarded\n",
|
||||
__FILE__,__LINE__);
|
||||
return -EINVAL;
|
||||
return;
|
||||
}
|
||||
|
||||
/* copy received data to HDLC buffer */
|
||||
|
@ -565,8 +565,6 @@ static unsigned int n_hdlc_tty_receive(struct tty_struct *tty,
|
|||
if (n_hdlc->tty->fasync != NULL)
|
||||
kill_fasync (&n_hdlc->tty->fasync, SIGIO, POLL_IN);
|
||||
|
||||
return count;
|
||||
|
||||
} /* end of n_hdlc_tty_receive() */
|
||||
|
||||
/**
|
||||
|
|
|
@ -139,8 +139,8 @@ static int r3964_ioctl(struct tty_struct *tty, struct file *file,
|
|||
static void r3964_set_termios(struct tty_struct *tty, struct ktermios *old);
|
||||
static unsigned int r3964_poll(struct tty_struct *tty, struct file *file,
|
||||
struct poll_table_struct *wait);
|
||||
static unsigned int r3964_receive_buf(struct tty_struct *tty,
|
||||
const unsigned char *cp, char *fp, int count);
|
||||
static void r3964_receive_buf(struct tty_struct *tty, const unsigned char *cp,
|
||||
char *fp, int count);
|
||||
|
||||
static struct tty_ldisc_ops tty_ldisc_N_R3964 = {
|
||||
.owner = THIS_MODULE,
|
||||
|
@ -1239,8 +1239,8 @@ static unsigned int r3964_poll(struct tty_struct *tty, struct file *file,
|
|||
return result;
|
||||
}
|
||||
|
||||
static unsigned int r3964_receive_buf(struct tty_struct *tty,
|
||||
const unsigned char *cp, char *fp, int count)
|
||||
static void r3964_receive_buf(struct tty_struct *tty, const unsigned char *cp,
|
||||
char *fp, int count)
|
||||
{
|
||||
struct r3964_info *pInfo = tty->disc_data;
|
||||
const unsigned char *p;
|
||||
|
@ -1257,8 +1257,6 @@ static unsigned int r3964_receive_buf(struct tty_struct *tty,
|
|||
}
|
||||
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
|
|
|
@ -81,6 +81,38 @@ static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
|
|||
return put_user(x, ptr);
|
||||
}
|
||||
|
||||
/**
|
||||
* n_tty_set__room - receive space
|
||||
* @tty: terminal
|
||||
*
|
||||
* Called by the driver to find out how much data it is
|
||||
* permitted to feed to the line discipline without any being lost
|
||||
* and thus to manage flow control. Not serialized. Answers for the
|
||||
* "instant".
|
||||
*/
|
||||
|
||||
static void n_tty_set_room(struct tty_struct *tty)
|
||||
{
|
||||
/* tty->read_cnt is not read locked ? */
|
||||
int left = N_TTY_BUF_SIZE - tty->read_cnt - 1;
|
||||
int old_left;
|
||||
|
||||
/*
|
||||
* If we are doing input canonicalization, and there are no
|
||||
* pending newlines, let characters through without limit, so
|
||||
* that erase characters will be handled. Other excess
|
||||
* characters will be beeped.
|
||||
*/
|
||||
if (left <= 0)
|
||||
left = tty->icanon && !tty->canon_data;
|
||||
old_left = tty->receive_room;
|
||||
tty->receive_room = left;
|
||||
|
||||
/* Did this open up the receive buffer? We may need to flip */
|
||||
if (left && !old_left)
|
||||
schedule_work(&tty->buf.work);
|
||||
}
|
||||
|
||||
static void put_tty_queue_nolock(unsigned char c, struct tty_struct *tty)
|
||||
{
|
||||
if (tty->read_cnt < N_TTY_BUF_SIZE) {
|
||||
|
@ -152,6 +184,7 @@ static void reset_buffer_flags(struct tty_struct *tty)
|
|||
|
||||
tty->canon_head = tty->canon_data = tty->erasing = 0;
|
||||
memset(&tty->read_flags, 0, sizeof tty->read_flags);
|
||||
n_tty_set_room(tty);
|
||||
check_unthrottle(tty);
|
||||
}
|
||||
|
||||
|
@ -1327,19 +1360,17 @@ static void n_tty_write_wakeup(struct tty_struct *tty)
|
|||
* calls one at a time and in order (or using flush_to_ldisc)
|
||||
*/
|
||||
|
||||
static unsigned int n_tty_receive_buf(struct tty_struct *tty,
|
||||
const unsigned char *cp, char *fp, int count)
|
||||
static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
|
||||
char *fp, int count)
|
||||
{
|
||||
const unsigned char *p;
|
||||
char *f, flags = TTY_NORMAL;
|
||||
int i;
|
||||
char buf[64];
|
||||
unsigned long cpuflags;
|
||||
int left;
|
||||
int ret = 0;
|
||||
|
||||
if (!tty->read_buf)
|
||||
return 0;
|
||||
return;
|
||||
|
||||
if (tty->real_raw) {
|
||||
spin_lock_irqsave(&tty->read_lock, cpuflags);
|
||||
|
@ -1349,7 +1380,6 @@ static unsigned int n_tty_receive_buf(struct tty_struct *tty,
|
|||
memcpy(tty->read_buf + tty->read_head, cp, i);
|
||||
tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
|
||||
tty->read_cnt += i;
|
||||
ret += i;
|
||||
cp += i;
|
||||
count -= i;
|
||||
|
||||
|
@ -1359,10 +1389,8 @@ static unsigned int n_tty_receive_buf(struct tty_struct *tty,
|
|||
memcpy(tty->read_buf + tty->read_head, cp, i);
|
||||
tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
|
||||
tty->read_cnt += i;
|
||||
ret += i;
|
||||
spin_unlock_irqrestore(&tty->read_lock, cpuflags);
|
||||
} else {
|
||||
ret = count;
|
||||
for (i = count, p = cp, f = fp; i; i--, p++) {
|
||||
if (f)
|
||||
flags = *f++;
|
||||
|
@ -1390,6 +1418,8 @@ static unsigned int n_tty_receive_buf(struct tty_struct *tty,
|
|||
tty->ops->flush_chars(tty);
|
||||
}
|
||||
|
||||
n_tty_set_room(tty);
|
||||
|
||||
if ((!tty->icanon && (tty->read_cnt >= tty->minimum_to_wake)) ||
|
||||
L_EXTPROC(tty)) {
|
||||
kill_fasync(&tty->fasync, SIGIO, POLL_IN);
|
||||
|
@ -1402,12 +1432,8 @@ static unsigned int n_tty_receive_buf(struct tty_struct *tty,
|
|||
* mode. We don't want to throttle the driver if we're in
|
||||
* canonical mode and don't have a newline yet!
|
||||
*/
|
||||
left = N_TTY_BUF_SIZE - tty->read_cnt - 1;
|
||||
|
||||
if (left < TTY_THRESHOLD_THROTTLE)
|
||||
if (tty->receive_room < TTY_THRESHOLD_THROTTLE)
|
||||
tty_throttle(tty);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int is_ignored(int sig)
|
||||
|
@ -1451,6 +1477,7 @@ static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
|
|||
if (test_bit(TTY_HW_COOK_IN, &tty->flags)) {
|
||||
tty->raw = 1;
|
||||
tty->real_raw = 1;
|
||||
n_tty_set_room(tty);
|
||||
return;
|
||||
}
|
||||
if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
|
||||
|
@ -1503,6 +1530,7 @@ static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
|
|||
else
|
||||
tty->real_raw = 0;
|
||||
}
|
||||
n_tty_set_room(tty);
|
||||
/* The termios change make the tty ready for I/O */
|
||||
wake_up_interruptible(&tty->write_wait);
|
||||
wake_up_interruptible(&tty->read_wait);
|
||||
|
@ -1784,6 +1812,8 @@ do_it_again:
|
|||
retval = -ERESTARTSYS;
|
||||
break;
|
||||
}
|
||||
/* FIXME: does n_tty_set_room need locking ? */
|
||||
n_tty_set_room(tty);
|
||||
timeout = schedule_timeout(timeout);
|
||||
continue;
|
||||
}
|
||||
|
@ -1855,8 +1885,10 @@ do_it_again:
|
|||
* longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
|
||||
* we won't get any more characters.
|
||||
*/
|
||||
if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE)
|
||||
if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) {
|
||||
n_tty_set_room(tty);
|
||||
check_unthrottle(tty);
|
||||
}
|
||||
|
||||
if (b - buf >= minimum)
|
||||
break;
|
||||
|
@ -1878,6 +1910,7 @@ do_it_again:
|
|||
} else if (test_and_clear_bit(TTY_PUSH, &tty->flags))
|
||||
goto do_it_again;
|
||||
|
||||
n_tty_set_room(tty);
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
|
|
@ -416,7 +416,6 @@ static void flush_to_ldisc(struct work_struct *work)
|
|||
struct tty_buffer *head, *tail = tty->buf.tail;
|
||||
int seen_tail = 0;
|
||||
while ((head = tty->buf.head) != NULL) {
|
||||
int copied;
|
||||
int count;
|
||||
char *char_buf;
|
||||
unsigned char *flag_buf;
|
||||
|
@ -443,19 +442,17 @@ static void flush_to_ldisc(struct work_struct *work)
|
|||
line discipline as we want to empty the queue */
|
||||
if (test_bit(TTY_FLUSHPENDING, &tty->flags))
|
||||
break;
|
||||
if (!tty->receive_room || seen_tail)
|
||||
break;
|
||||
if (count > tty->receive_room)
|
||||
count = tty->receive_room;
|
||||
char_buf = head->char_buf_ptr + head->read;
|
||||
flag_buf = head->flag_buf_ptr + head->read;
|
||||
head->read += count;
|
||||
spin_unlock_irqrestore(&tty->buf.lock, flags);
|
||||
copied = disc->ops->receive_buf(tty, char_buf,
|
||||
disc->ops->receive_buf(tty, char_buf,
|
||||
flag_buf, count);
|
||||
spin_lock_irqsave(&tty->buf.lock, flags);
|
||||
|
||||
head->read += copied;
|
||||
|
||||
if (copied == 0 || seen_tail) {
|
||||
schedule_work(&tty->buf.work);
|
||||
break;
|
||||
}
|
||||
}
|
||||
clear_bit(TTY_FLUSHING, &tty->flags);
|
||||
}
|
||||
|
|
|
@ -332,7 +332,8 @@ int paste_selection(struct tty_struct *tty)
|
|||
continue;
|
||||
}
|
||||
count = sel_buffer_lth - pasted;
|
||||
count = tty->ldisc->ops->receive_buf(tty, sel_buffer + pasted,
|
||||
count = min(count, tty->receive_room);
|
||||
tty->ldisc->ops->receive_buf(tty, sel_buffer + pasted,
|
||||
NULL, count);
|
||||
pasted += count;
|
||||
}
|
||||
|
|
|
@ -1272,8 +1272,8 @@ int blkdev_get(struct block_device *bdev, fmode_t mode, void *holder)
|
|||
* individual writeable reference is too fragile given the
|
||||
* way @mode is used in blkdev_get/put().
|
||||
*/
|
||||
if ((disk->flags & GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE) &&
|
||||
!res && (mode & FMODE_WRITE) && !bdev->bd_write_holder) {
|
||||
if (!res && (mode & FMODE_WRITE) && !bdev->bd_write_holder &&
|
||||
(disk->flags & GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE)) {
|
||||
bdev->bd_write_holder = true;
|
||||
disk_block_events(disk);
|
||||
}
|
||||
|
|
|
@ -121,9 +121,6 @@ struct btrfs_inode {
|
|||
*/
|
||||
u64 index_cnt;
|
||||
|
||||
/* the start of block group preferred for allocations. */
|
||||
u64 block_group;
|
||||
|
||||
/* the fsync log has some corner cases that mean we have to check
|
||||
* directories to see if any unlinks have been done before
|
||||
* the directory was logged. See tree-log.c for all the
|
||||
|
|
|
@ -43,8 +43,6 @@ struct btrfs_path *btrfs_alloc_path(void)
|
|||
{
|
||||
struct btrfs_path *path;
|
||||
path = kmem_cache_zalloc(btrfs_path_cachep, GFP_NOFS);
|
||||
if (path)
|
||||
path->reada = 1;
|
||||
return path;
|
||||
}
|
||||
|
||||
|
@ -1224,6 +1222,7 @@ static void reada_for_search(struct btrfs_root *root,
|
|||
u64 search;
|
||||
u64 target;
|
||||
u64 nread = 0;
|
||||
u64 gen;
|
||||
int direction = path->reada;
|
||||
struct extent_buffer *eb;
|
||||
u32 nr;
|
||||
|
@ -1251,6 +1250,15 @@ static void reada_for_search(struct btrfs_root *root,
|
|||
nritems = btrfs_header_nritems(node);
|
||||
nr = slot;
|
||||
while (1) {
|
||||
if (!node->map_token) {
|
||||
unsigned long offset = btrfs_node_key_ptr_offset(nr);
|
||||
map_private_extent_buffer(node, offset,
|
||||
sizeof(struct btrfs_key_ptr),
|
||||
&node->map_token,
|
||||
&node->kaddr,
|
||||
&node->map_start,
|
||||
&node->map_len, KM_USER1);
|
||||
}
|
||||
if (direction < 0) {
|
||||
if (nr == 0)
|
||||
break;
|
||||
|
@ -1268,14 +1276,23 @@ static void reada_for_search(struct btrfs_root *root,
|
|||
search = btrfs_node_blockptr(node, nr);
|
||||
if ((search <= target && target - search <= 65536) ||
|
||||
(search > target && search - target <= 65536)) {
|
||||
readahead_tree_block(root, search, blocksize,
|
||||
btrfs_node_ptr_generation(node, nr));
|
||||
gen = btrfs_node_ptr_generation(node, nr);
|
||||
if (node->map_token) {
|
||||
unmap_extent_buffer(node, node->map_token,
|
||||
KM_USER1);
|
||||
node->map_token = NULL;
|
||||
}
|
||||
readahead_tree_block(root, search, blocksize, gen);
|
||||
nread += blocksize;
|
||||
}
|
||||
nscan++;
|
||||
if ((nread > 65536 || nscan > 32))
|
||||
break;
|
||||
}
|
||||
if (node->map_token) {
|
||||
unmap_extent_buffer(node, node->map_token, KM_USER1);
|
||||
node->map_token = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -1648,9 +1665,6 @@ again:
|
|||
}
|
||||
cow_done:
|
||||
BUG_ON(!cow && ins_len);
|
||||
if (level != btrfs_header_level(b))
|
||||
WARN_ON(1);
|
||||
level = btrfs_header_level(b);
|
||||
|
||||
p->nodes[level] = b;
|
||||
if (!p->skip_locking)
|
||||
|
|
|
@ -930,7 +930,6 @@ struct btrfs_fs_info {
|
|||
* is required instead of the faster short fsync log commits
|
||||
*/
|
||||
u64 last_trans_log_full_commit;
|
||||
u64 open_ioctl_trans;
|
||||
unsigned long mount_opt:20;
|
||||
unsigned long compress_type:4;
|
||||
u64 max_inline;
|
||||
|
@ -947,7 +946,6 @@ struct btrfs_fs_info {
|
|||
struct super_block *sb;
|
||||
struct inode *btree_inode;
|
||||
struct backing_dev_info bdi;
|
||||
struct mutex trans_mutex;
|
||||
struct mutex tree_log_mutex;
|
||||
struct mutex transaction_kthread_mutex;
|
||||
struct mutex cleaner_mutex;
|
||||
|
@ -968,6 +966,7 @@ struct btrfs_fs_info {
|
|||
struct rw_semaphore subvol_sem;
|
||||
struct srcu_struct subvol_srcu;
|
||||
|
||||
spinlock_t trans_lock;
|
||||
struct list_head trans_list;
|
||||
struct list_head hashers;
|
||||
struct list_head dead_roots;
|
||||
|
@ -980,6 +979,7 @@ struct btrfs_fs_info {
|
|||
atomic_t async_submit_draining;
|
||||
atomic_t nr_async_bios;
|
||||
atomic_t async_delalloc_pages;
|
||||
atomic_t open_ioctl_trans;
|
||||
|
||||
/*
|
||||
* this is used by the balancing code to wait for all the pending
|
||||
|
@ -1044,6 +1044,7 @@ struct btrfs_fs_info {
|
|||
int closing;
|
||||
int log_root_recovering;
|
||||
int enospc_unlink;
|
||||
int trans_no_join;
|
||||
|
||||
u64 total_pinned;
|
||||
|
||||
|
@ -1065,7 +1066,6 @@ struct btrfs_fs_info {
|
|||
struct reloc_control *reloc_ctl;
|
||||
|
||||
spinlock_t delalloc_lock;
|
||||
spinlock_t new_trans_lock;
|
||||
u64 delalloc_bytes;
|
||||
|
||||
/* data_alloc_cluster is only used in ssd mode */
|
||||
|
@ -1340,6 +1340,7 @@ struct btrfs_ioctl_defrag_range_args {
|
|||
#define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14)
|
||||
#define BTRFS_MOUNT_ENOSPC_DEBUG (1 << 15)
|
||||
#define BTRFS_MOUNT_AUTO_DEFRAG (1 << 16)
|
||||
#define BTRFS_MOUNT_INODE_MAP_CACHE (1 << 17)
|
||||
|
||||
#define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt)
|
||||
#define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt)
|
||||
|
@ -2238,6 +2239,9 @@ int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
|
|||
void btrfs_block_rsv_release(struct btrfs_root *root,
|
||||
struct btrfs_block_rsv *block_rsv,
|
||||
u64 num_bytes);
|
||||
int btrfs_truncate_reserve_metadata(struct btrfs_trans_handle *trans,
|
||||
struct btrfs_root *root,
|
||||
struct btrfs_block_rsv *rsv);
|
||||
int btrfs_set_block_group_ro(struct btrfs_root *root,
|
||||
struct btrfs_block_group_cache *cache);
|
||||
int btrfs_set_block_group_rw(struct btrfs_root *root,
|
||||
|
@ -2350,6 +2354,15 @@ int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
|
|||
struct btrfs_root *root,
|
||||
struct extent_buffer *node,
|
||||
struct extent_buffer *parent);
|
||||
static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info)
|
||||
{
|
||||
/*
|
||||
* Get synced with close_ctree()
|
||||
*/
|
||||
smp_mb();
|
||||
return fs_info->closing;
|
||||
}
|
||||
|
||||
/* root-item.c */
|
||||
int btrfs_find_root_ref(struct btrfs_root *tree_root,
|
||||
struct btrfs_path *path,
|
||||
|
@ -2512,8 +2525,7 @@ int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
|
|||
int btrfs_writepages(struct address_space *mapping,
|
||||
struct writeback_control *wbc);
|
||||
int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
|
||||
struct btrfs_root *new_root,
|
||||
u64 new_dirid, u64 alloc_hint);
|
||||
struct btrfs_root *new_root, u64 new_dirid);
|
||||
int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
|
||||
size_t size, struct bio *bio, unsigned long bio_flags);
|
||||
|
||||
|
|
|
@ -678,6 +678,7 @@ static int btrfs_batch_insert_items(struct btrfs_trans_handle *trans,
|
|||
INIT_LIST_HEAD(&head);
|
||||
|
||||
next = item;
|
||||
nitems = 0;
|
||||
|
||||
/*
|
||||
* count the number of the continuous items that we can insert in batch
|
||||
|
@ -1129,7 +1130,7 @@ static void btrfs_async_run_delayed_node_done(struct btrfs_work *work)
|
|||
delayed_node = async_node->delayed_node;
|
||||
root = delayed_node->root;
|
||||
|
||||
trans = btrfs_join_transaction(root, 0);
|
||||
trans = btrfs_join_transaction(root);
|
||||
if (IS_ERR(trans))
|
||||
goto free_path;
|
||||
|
||||
|
@ -1572,8 +1573,7 @@ static void fill_stack_inode_item(struct btrfs_trans_handle *trans,
|
|||
btrfs_set_stack_inode_transid(inode_item, trans->transid);
|
||||
btrfs_set_stack_inode_rdev(inode_item, inode->i_rdev);
|
||||
btrfs_set_stack_inode_flags(inode_item, BTRFS_I(inode)->flags);
|
||||
btrfs_set_stack_inode_block_group(inode_item,
|
||||
BTRFS_I(inode)->block_group);
|
||||
btrfs_set_stack_inode_block_group(inode_item, 0);
|
||||
|
||||
btrfs_set_stack_timespec_sec(btrfs_inode_atime(inode_item),
|
||||
inode->i_atime.tv_sec);
|
||||
|
@ -1595,7 +1595,7 @@ int btrfs_delayed_update_inode(struct btrfs_trans_handle *trans,
|
|||
struct btrfs_root *root, struct inode *inode)
|
||||
{
|
||||
struct btrfs_delayed_node *delayed_node;
|
||||
int ret;
|
||||
int ret = 0;
|
||||
|
||||
delayed_node = btrfs_get_or_create_delayed_node(inode);
|
||||
if (IS_ERR(delayed_node))
|
||||
|
|
|
@ -1505,24 +1505,24 @@ static int transaction_kthread(void *arg)
|
|||
vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE);
|
||||
mutex_lock(&root->fs_info->transaction_kthread_mutex);
|
||||
|
||||
spin_lock(&root->fs_info->new_trans_lock);
|
||||
spin_lock(&root->fs_info->trans_lock);
|
||||
cur = root->fs_info->running_transaction;
|
||||
if (!cur) {
|
||||
spin_unlock(&root->fs_info->new_trans_lock);
|
||||
spin_unlock(&root->fs_info->trans_lock);
|
||||
goto sleep;
|
||||
}
|
||||
|
||||
now = get_seconds();
|
||||
if (!cur->blocked &&
|
||||
(now < cur->start_time || now - cur->start_time < 30)) {
|
||||
spin_unlock(&root->fs_info->new_trans_lock);
|
||||
spin_unlock(&root->fs_info->trans_lock);
|
||||
delay = HZ * 5;
|
||||
goto sleep;
|
||||
}
|
||||
transid = cur->transid;
|
||||
spin_unlock(&root->fs_info->new_trans_lock);
|
||||
spin_unlock(&root->fs_info->trans_lock);
|
||||
|
||||
trans = btrfs_join_transaction(root, 1);
|
||||
trans = btrfs_join_transaction(root);
|
||||
BUG_ON(IS_ERR(trans));
|
||||
if (transid == trans->transid) {
|
||||
ret = btrfs_commit_transaction(trans, root);
|
||||
|
@ -1613,7 +1613,7 @@ struct btrfs_root *open_ctree(struct super_block *sb,
|
|||
INIT_LIST_HEAD(&fs_info->ordered_operations);
|
||||
INIT_LIST_HEAD(&fs_info->caching_block_groups);
|
||||
spin_lock_init(&fs_info->delalloc_lock);
|
||||
spin_lock_init(&fs_info->new_trans_lock);
|
||||
spin_lock_init(&fs_info->trans_lock);
|
||||
spin_lock_init(&fs_info->ref_cache_lock);
|
||||
spin_lock_init(&fs_info->fs_roots_radix_lock);
|
||||
spin_lock_init(&fs_info->delayed_iput_lock);
|
||||
|
@ -1645,6 +1645,7 @@ struct btrfs_root *open_ctree(struct super_block *sb,
|
|||
fs_info->max_inline = 8192 * 1024;
|
||||
fs_info->metadata_ratio = 0;
|
||||
fs_info->defrag_inodes = RB_ROOT;
|
||||
fs_info->trans_no_join = 0;
|
||||
|
||||
fs_info->thread_pool_size = min_t(unsigned long,
|
||||
num_online_cpus() + 2, 8);
|
||||
|
@ -1709,7 +1710,6 @@ struct btrfs_root *open_ctree(struct super_block *sb,
|
|||
fs_info->do_barriers = 1;
|
||||
|
||||
|
||||
mutex_init(&fs_info->trans_mutex);
|
||||
mutex_init(&fs_info->ordered_operations_mutex);
|
||||
mutex_init(&fs_info->tree_log_mutex);
|
||||
mutex_init(&fs_info->chunk_mutex);
|
||||
|
@ -2479,13 +2479,13 @@ int btrfs_commit_super(struct btrfs_root *root)
|
|||
down_write(&root->fs_info->cleanup_work_sem);
|
||||
up_write(&root->fs_info->cleanup_work_sem);
|
||||
|
||||
trans = btrfs_join_transaction(root, 1);
|
||||
trans = btrfs_join_transaction(root);
|
||||
if (IS_ERR(trans))
|
||||
return PTR_ERR(trans);
|
||||
ret = btrfs_commit_transaction(trans, root);
|
||||
BUG_ON(ret);
|
||||
/* run commit again to drop the original snapshot */
|
||||
trans = btrfs_join_transaction(root, 1);
|
||||
trans = btrfs_join_transaction(root);
|
||||
if (IS_ERR(trans))
|
||||
return PTR_ERR(trans);
|
||||
btrfs_commit_transaction(trans, root);
|
||||
|
@ -3024,10 +3024,13 @@ static int btrfs_cleanup_transaction(struct btrfs_root *root)
|
|||
|
||||
WARN_ON(1);
|
||||
|
||||
mutex_lock(&root->fs_info->trans_mutex);
|
||||
mutex_lock(&root->fs_info->transaction_kthread_mutex);
|
||||
|
||||
spin_lock(&root->fs_info->trans_lock);
|
||||
list_splice_init(&root->fs_info->trans_list, &list);
|
||||
root->fs_info->trans_no_join = 1;
|
||||
spin_unlock(&root->fs_info->trans_lock);
|
||||
|
||||
while (!list_empty(&list)) {
|
||||
t = list_entry(list.next, struct btrfs_transaction, list);
|
||||
if (!t)
|
||||
|
@ -3052,23 +3055,18 @@ static int btrfs_cleanup_transaction(struct btrfs_root *root)
|
|||
t->blocked = 0;
|
||||
if (waitqueue_active(&root->fs_info->transaction_wait))
|
||||
wake_up(&root->fs_info->transaction_wait);
|
||||
mutex_unlock(&root->fs_info->trans_mutex);
|
||||
|
||||
mutex_lock(&root->fs_info->trans_mutex);
|
||||
t->commit_done = 1;
|
||||
if (waitqueue_active(&t->commit_wait))
|
||||
wake_up(&t->commit_wait);
|
||||
mutex_unlock(&root->fs_info->trans_mutex);
|
||||
|
||||
mutex_lock(&root->fs_info->trans_mutex);
|
||||
|
||||
btrfs_destroy_pending_snapshots(t);
|
||||
|
||||
btrfs_destroy_delalloc_inodes(root);
|
||||
|
||||
spin_lock(&root->fs_info->new_trans_lock);
|
||||
spin_lock(&root->fs_info->trans_lock);
|
||||
root->fs_info->running_transaction = NULL;
|
||||
spin_unlock(&root->fs_info->new_trans_lock);
|
||||
spin_unlock(&root->fs_info->trans_lock);
|
||||
|
||||
btrfs_destroy_marked_extents(root, &t->dirty_pages,
|
||||
EXTENT_DIRTY);
|
||||
|
@ -3082,8 +3080,10 @@ static int btrfs_cleanup_transaction(struct btrfs_root *root)
|
|||
kmem_cache_free(btrfs_transaction_cachep, t);
|
||||
}
|
||||
|
||||
spin_lock(&root->fs_info->trans_lock);
|
||||
root->fs_info->trans_no_join = 0;
|
||||
spin_unlock(&root->fs_info->trans_lock);
|
||||
mutex_unlock(&root->fs_info->transaction_kthread_mutex);
|
||||
mutex_unlock(&root->fs_info->trans_mutex);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -348,7 +348,7 @@ static int caching_kthread(void *data)
|
|||
*/
|
||||
path->skip_locking = 1;
|
||||
path->search_commit_root = 1;
|
||||
path->reada = 2;
|
||||
path->reada = 1;
|
||||
|
||||
key.objectid = last;
|
||||
key.offset = 0;
|
||||
|
@ -366,8 +366,7 @@ again:
|
|||
nritems = btrfs_header_nritems(leaf);
|
||||
|
||||
while (1) {
|
||||
smp_mb();
|
||||
if (fs_info->closing > 1) {
|
||||
if (btrfs_fs_closing(fs_info) > 1) {
|
||||
last = (u64)-1;
|
||||
break;
|
||||
}
|
||||
|
@ -379,15 +378,18 @@ again:
|
|||
if (ret)
|
||||
break;
|
||||
|
||||
caching_ctl->progress = last;
|
||||
btrfs_release_path(path);
|
||||
up_read(&fs_info->extent_commit_sem);
|
||||
mutex_unlock(&caching_ctl->mutex);
|
||||
if (btrfs_transaction_in_commit(fs_info))
|
||||
schedule_timeout(1);
|
||||
else
|
||||
if (need_resched() ||
|
||||
btrfs_next_leaf(extent_root, path)) {
|
||||
caching_ctl->progress = last;
|
||||
btrfs_release_path(path);
|
||||
up_read(&fs_info->extent_commit_sem);
|
||||
mutex_unlock(&caching_ctl->mutex);
|
||||
cond_resched();
|
||||
goto again;
|
||||
goto again;
|
||||
}
|
||||
leaf = path->nodes[0];
|
||||
nritems = btrfs_header_nritems(leaf);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (key.objectid < block_group->key.objectid) {
|
||||
|
@ -3065,7 +3067,7 @@ again:
|
|||
spin_unlock(&data_sinfo->lock);
|
||||
alloc:
|
||||
alloc_target = btrfs_get_alloc_profile(root, 1);
|
||||
trans = btrfs_join_transaction(root, 1);
|
||||
trans = btrfs_join_transaction(root);
|
||||
if (IS_ERR(trans))
|
||||
return PTR_ERR(trans);
|
||||
|
||||
|
@ -3091,9 +3093,10 @@ alloc:
|
|||
|
||||
/* commit the current transaction and try again */
|
||||
commit_trans:
|
||||
if (!committed && !root->fs_info->open_ioctl_trans) {
|
||||
if (!committed &&
|
||||
!atomic_read(&root->fs_info->open_ioctl_trans)) {
|
||||
committed = 1;
|
||||
trans = btrfs_join_transaction(root, 1);
|
||||
trans = btrfs_join_transaction(root);
|
||||
if (IS_ERR(trans))
|
||||
return PTR_ERR(trans);
|
||||
ret = btrfs_commit_transaction(trans, root);
|
||||
|
@ -3472,7 +3475,7 @@ again:
|
|||
goto out;
|
||||
|
||||
ret = -ENOSPC;
|
||||
trans = btrfs_join_transaction(root, 1);
|
||||
trans = btrfs_join_transaction(root);
|
||||
if (IS_ERR(trans))
|
||||
goto out;
|
||||
ret = btrfs_commit_transaction(trans, root);
|
||||
|
@ -3699,7 +3702,7 @@ int btrfs_block_rsv_check(struct btrfs_trans_handle *trans,
|
|||
if (trans)
|
||||
return -EAGAIN;
|
||||
|
||||
trans = btrfs_join_transaction(root, 1);
|
||||
trans = btrfs_join_transaction(root);
|
||||
BUG_ON(IS_ERR(trans));
|
||||
ret = btrfs_commit_transaction(trans, root);
|
||||
return 0;
|
||||
|
@ -3837,6 +3840,37 @@ static void release_global_block_rsv(struct btrfs_fs_info *fs_info)
|
|||
WARN_ON(fs_info->chunk_block_rsv.reserved > 0);
|
||||
}
|
||||
|
||||
int btrfs_truncate_reserve_metadata(struct btrfs_trans_handle *trans,
|
||||
struct btrfs_root *root,
|
||||
struct btrfs_block_rsv *rsv)
|
||||
{
|
||||
struct btrfs_block_rsv *trans_rsv = &root->fs_info->trans_block_rsv;
|
||||
u64 num_bytes;
|
||||
int ret;
|
||||
|
||||
/*
|
||||
* Truncate should be freeing data, but give us 2 items just in case it
|
||||
* needs to use some space. We may want to be smarter about this in the
|
||||
* future.
|
||||
*/
|
||||
num_bytes = btrfs_calc_trans_metadata_size(root, 2);
|
||||
|
||||
/* We already have enough bytes, just return */
|
||||
if (rsv->reserved >= num_bytes)
|
||||
return 0;
|
||||
|
||||
num_bytes -= rsv->reserved;
|
||||
|
||||
/*
|
||||
* You should have reserved enough space before hand to do this, so this
|
||||
* should not fail.
|
||||
*/
|
||||
ret = block_rsv_migrate_bytes(trans_rsv, rsv, num_bytes);
|
||||
BUG_ON(ret);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int btrfs_trans_reserve_metadata(struct btrfs_trans_handle *trans,
|
||||
struct btrfs_root *root,
|
||||
int num_items)
|
||||
|
@ -3877,23 +3911,18 @@ int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
|
|||
struct btrfs_block_rsv *dst_rsv = root->orphan_block_rsv;
|
||||
|
||||
/*
|
||||
* one for deleting orphan item, one for updating inode and
|
||||
* two for calling btrfs_truncate_inode_items.
|
||||
*
|
||||
* btrfs_truncate_inode_items is a delete operation, it frees
|
||||
* more space than it uses in most cases. So two units of
|
||||
* metadata space should be enough for calling it many times.
|
||||
* If all of the metadata space is used, we can commit
|
||||
* transaction and use space it freed.
|
||||
* We need to hold space in order to delete our orphan item once we've
|
||||
* added it, so this takes the reservation so we can release it later
|
||||
* when we are truly done with the orphan item.
|
||||
*/
|
||||
u64 num_bytes = btrfs_calc_trans_metadata_size(root, 4);
|
||||
u64 num_bytes = btrfs_calc_trans_metadata_size(root, 1);
|
||||
return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
|
||||
}
|
||||
|
||||
void btrfs_orphan_release_metadata(struct inode *inode)
|
||||
{
|
||||
struct btrfs_root *root = BTRFS_I(inode)->root;
|
||||
u64 num_bytes = btrfs_calc_trans_metadata_size(root, 4);
|
||||
u64 num_bytes = btrfs_calc_trans_metadata_size(root, 1);
|
||||
btrfs_block_rsv_release(root, root->orphan_block_rsv, num_bytes);
|
||||
}
|
||||
|
||||
|
@ -4987,6 +5016,15 @@ have_block_group:
|
|||
if (unlikely(block_group->ro))
|
||||
goto loop;
|
||||
|
||||
spin_lock(&block_group->free_space_ctl->tree_lock);
|
||||
if (cached &&
|
||||
block_group->free_space_ctl->free_space <
|
||||
num_bytes + empty_size) {
|
||||
spin_unlock(&block_group->free_space_ctl->tree_lock);
|
||||
goto loop;
|
||||
}
|
||||
spin_unlock(&block_group->free_space_ctl->tree_lock);
|
||||
|
||||
/*
|
||||
* Ok we want to try and use the cluster allocator, so lets look
|
||||
* there, unless we are on LOOP_NO_EMPTY_SIZE, since we will
|
||||
|
@ -5150,6 +5188,7 @@ checks:
|
|||
btrfs_add_free_space(block_group, offset,
|
||||
search_start - offset);
|
||||
BUG_ON(offset > search_start);
|
||||
btrfs_put_block_group(block_group);
|
||||
break;
|
||||
loop:
|
||||
failed_cluster_refill = false;
|
||||
|
@ -5242,14 +5281,7 @@ loop:
|
|||
ret = -ENOSPC;
|
||||
} else if (!ins->objectid) {
|
||||
ret = -ENOSPC;
|
||||
}
|
||||
|
||||
/* we found what we needed */
|
||||
if (ins->objectid) {
|
||||
if (!(data & BTRFS_BLOCK_GROUP_DATA))
|
||||
trans->block_group = block_group->key.objectid;
|
||||
|
||||
btrfs_put_block_group(block_group);
|
||||
} else if (ins->objectid) {
|
||||
ret = 0;
|
||||
}
|
||||
|
||||
|
@ -6526,7 +6558,7 @@ int btrfs_set_block_group_ro(struct btrfs_root *root,
|
|||
|
||||
BUG_ON(cache->ro);
|
||||
|
||||
trans = btrfs_join_transaction(root, 1);
|
||||
trans = btrfs_join_transaction(root);
|
||||
BUG_ON(IS_ERR(trans));
|
||||
|
||||
alloc_flags = update_block_group_flags(root, cache->flags);
|
||||
|
@ -6882,6 +6914,7 @@ int btrfs_read_block_groups(struct btrfs_root *root)
|
|||
path = btrfs_alloc_path();
|
||||
if (!path)
|
||||
return -ENOMEM;
|
||||
path->reada = 1;
|
||||
|
||||
cache_gen = btrfs_super_cache_generation(&root->fs_info->super_copy);
|
||||
if (cache_gen != 0 &&
|
||||
|
|
|
@ -1476,7 +1476,7 @@ u64 count_range_bits(struct extent_io_tree *tree,
|
|||
if (total_bytes >= max_bytes)
|
||||
break;
|
||||
if (!found) {
|
||||
*start = state->start;
|
||||
*start = max(cur_start, state->start);
|
||||
found = 1;
|
||||
}
|
||||
last = state->end;
|
||||
|
|
|
@ -129,7 +129,7 @@ int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
|
|||
if (!btrfs_test_opt(root, AUTO_DEFRAG))
|
||||
return 0;
|
||||
|
||||
if (root->fs_info->closing)
|
||||
if (btrfs_fs_closing(root->fs_info))
|
||||
return 0;
|
||||
|
||||
if (BTRFS_I(inode)->in_defrag)
|
||||
|
@ -144,7 +144,7 @@ int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
|
|||
if (!defrag)
|
||||
return -ENOMEM;
|
||||
|
||||
defrag->ino = inode->i_ino;
|
||||
defrag->ino = btrfs_ino(inode);
|
||||
defrag->transid = transid;
|
||||
defrag->root = root->root_key.objectid;
|
||||
|
||||
|
@ -229,7 +229,7 @@ int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info)
|
|||
first_ino = defrag->ino + 1;
|
||||
rb_erase(&defrag->rb_node, &fs_info->defrag_inodes);
|
||||
|
||||
if (fs_info->closing)
|
||||
if (btrfs_fs_closing(fs_info))
|
||||
goto next_free;
|
||||
|
||||
spin_unlock(&fs_info->defrag_inodes_lock);
|
||||
|
@ -1480,14 +1480,12 @@ int btrfs_sync_file(struct file *file, int datasync)
|
|||
* the current transaction, we can bail out now without any
|
||||
* syncing
|
||||
*/
|
||||
mutex_lock(&root->fs_info->trans_mutex);
|
||||
smp_mb();
|
||||
if (BTRFS_I(inode)->last_trans <=
|
||||
root->fs_info->last_trans_committed) {
|
||||
BTRFS_I(inode)->last_trans = 0;
|
||||
mutex_unlock(&root->fs_info->trans_mutex);
|
||||
goto out;
|
||||
}
|
||||
mutex_unlock(&root->fs_info->trans_mutex);
|
||||
|
||||
/*
|
||||
* ok we haven't committed the transaction yet, lets do a commit
|
||||
|
|
|
@ -98,7 +98,7 @@ struct inode *lookup_free_space_inode(struct btrfs_root *root,
|
|||
return inode;
|
||||
|
||||
spin_lock(&block_group->lock);
|
||||
if (!root->fs_info->closing) {
|
||||
if (!btrfs_fs_closing(root->fs_info)) {
|
||||
block_group->inode = igrab(inode);
|
||||
block_group->iref = 1;
|
||||
}
|
||||
|
@ -402,7 +402,14 @@ int __load_free_space_cache(struct btrfs_root *root, struct inode *inode,
|
|||
spin_lock(&ctl->tree_lock);
|
||||
ret = link_free_space(ctl, e);
|
||||
spin_unlock(&ctl->tree_lock);
|
||||
BUG_ON(ret);
|
||||
if (ret) {
|
||||
printk(KERN_ERR "Duplicate entries in "
|
||||
"free space cache, dumping\n");
|
||||
kunmap(page);
|
||||
unlock_page(page);
|
||||
page_cache_release(page);
|
||||
goto free_cache;
|
||||
}
|
||||
} else {
|
||||
e->bitmap = kzalloc(PAGE_CACHE_SIZE, GFP_NOFS);
|
||||
if (!e->bitmap) {
|
||||
|
@ -419,6 +426,14 @@ int __load_free_space_cache(struct btrfs_root *root, struct inode *inode,
|
|||
ctl->op->recalc_thresholds(ctl);
|
||||
spin_unlock(&ctl->tree_lock);
|
||||
list_add_tail(&e->list, &bitmaps);
|
||||
if (ret) {
|
||||
printk(KERN_ERR "Duplicate entries in "
|
||||
"free space cache, dumping\n");
|
||||
kunmap(page);
|
||||
unlock_page(page);
|
||||
page_cache_release(page);
|
||||
goto free_cache;
|
||||
}
|
||||
}
|
||||
|
||||
num_entries--;
|
||||
|
@ -478,8 +493,7 @@ int load_free_space_cache(struct btrfs_fs_info *fs_info,
|
|||
* If we're unmounting then just return, since this does a search on the
|
||||
* normal root and not the commit root and we could deadlock.
|
||||
*/
|
||||
smp_mb();
|
||||
if (fs_info->closing)
|
||||
if (btrfs_fs_closing(fs_info))
|
||||
return 0;
|
||||
|
||||
/*
|
||||
|
@ -575,10 +589,25 @@ int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode,
|
|||
|
||||
num_pages = (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>
|
||||
PAGE_CACHE_SHIFT;
|
||||
|
||||
/* Since the first page has all of our checksums and our generation we
|
||||
* need to calculate the offset into the page that we can start writing
|
||||
* our entries.
|
||||
*/
|
||||
first_page_offset = (sizeof(u32) * num_pages) + sizeof(u64);
|
||||
|
||||
filemap_write_and_wait(inode->i_mapping);
|
||||
btrfs_wait_ordered_range(inode, inode->i_size &
|
||||
~(root->sectorsize - 1), (u64)-1);
|
||||
|
||||
/* make sure we don't overflow that first page */
|
||||
if (first_page_offset + sizeof(struct btrfs_free_space_entry) >= PAGE_CACHE_SIZE) {
|
||||
/* this is really the same as running out of space, where we also return 0 */
|
||||
printk(KERN_CRIT "Btrfs: free space cache was too big for the crc page\n");
|
||||
ret = 0;
|
||||
goto out_update;
|
||||
}
|
||||
|
||||
/* We need a checksum per page. */
|
||||
crc = checksums = kzalloc(sizeof(u32) * num_pages, GFP_NOFS);
|
||||
if (!crc)
|
||||
|
@ -590,12 +619,6 @@ int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode,
|
|||
return -1;
|
||||
}
|
||||
|
||||
/* Since the first page has all of our checksums and our generation we
|
||||
* need to calculate the offset into the page that we can start writing
|
||||
* our entries.
|
||||
*/
|
||||
first_page_offset = (sizeof(u32) * num_pages) + sizeof(u64);
|
||||
|
||||
/* Get the cluster for this block_group if it exists */
|
||||
if (block_group && !list_empty(&block_group->cluster_list))
|
||||
cluster = list_entry(block_group->cluster_list.next,
|
||||
|
@ -857,12 +880,14 @@ int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode,
|
|||
ret = 1;
|
||||
|
||||
out_free:
|
||||
kfree(checksums);
|
||||
kfree(pages);
|
||||
|
||||
out_update:
|
||||
if (ret != 1) {
|
||||
invalidate_inode_pages2_range(inode->i_mapping, 0, index);
|
||||
BTRFS_I(inode)->generation = 0;
|
||||
}
|
||||
kfree(checksums);
|
||||
kfree(pages);
|
||||
btrfs_update_inode(trans, root, inode);
|
||||
return ret;
|
||||
}
|
||||
|
@ -963,10 +988,16 @@ static int tree_insert_offset(struct rb_root *root, u64 offset,
|
|||
* logically.
|
||||
*/
|
||||
if (bitmap) {
|
||||
WARN_ON(info->bitmap);
|
||||
if (info->bitmap) {
|
||||
WARN_ON_ONCE(1);
|
||||
return -EEXIST;
|
||||
}
|
||||
p = &(*p)->rb_right;
|
||||
} else {
|
||||
WARN_ON(!info->bitmap);
|
||||
if (!info->bitmap) {
|
||||
WARN_ON_ONCE(1);
|
||||
return -EEXIST;
|
||||
}
|
||||
p = &(*p)->rb_left;
|
||||
}
|
||||
}
|
||||
|
@ -2481,7 +2512,7 @@ struct inode *lookup_free_ino_inode(struct btrfs_root *root,
|
|||
return inode;
|
||||
|
||||
spin_lock(&root->cache_lock);
|
||||
if (!root->fs_info->closing)
|
||||
if (!btrfs_fs_closing(root->fs_info))
|
||||
root->cache_inode = igrab(inode);
|
||||
spin_unlock(&root->cache_lock);
|
||||
|
||||
|
@ -2504,12 +2535,14 @@ int load_free_ino_cache(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
|
|||
int ret = 0;
|
||||
u64 root_gen = btrfs_root_generation(&root->root_item);
|
||||
|
||||
if (!btrfs_test_opt(root, INODE_MAP_CACHE))
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* If we're unmounting then just return, since this does a search on the
|
||||
* normal root and not the commit root and we could deadlock.
|
||||
*/
|
||||
smp_mb();
|
||||
if (fs_info->closing)
|
||||
if (btrfs_fs_closing(fs_info))
|
||||
return 0;
|
||||
|
||||
path = btrfs_alloc_path();
|
||||
|
@ -2543,6 +2576,9 @@ int btrfs_write_out_ino_cache(struct btrfs_root *root,
|
|||
struct inode *inode;
|
||||
int ret;
|
||||
|
||||
if (!btrfs_test_opt(root, INODE_MAP_CACHE))
|
||||
return 0;
|
||||
|
||||
inode = lookup_free_ino_inode(root, path);
|
||||
if (IS_ERR(inode))
|
||||
return 0;
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue