microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

CRIS port changes for 3.19 

-----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1.4.12 (GNU/Linux)
 
 iEYEABECAAYFAlSUsNsACgkQ31LbvUHyf1dsUwCfULNbSfkEkrP+EMA/17CLLN9G
 DjcAn2H/lIG/MJyxd0QiuIxpeEPAU9pY
 =Qy8J
 -----END PGP SIGNATURE-----

Merge tag 'cris-changes-for-3.19' of git://git.kernel.org/pub/scm/linux/kernel/git/jesper/cris

Pull arch/chris updates from Jesper Nilsson:
 "Mostly cleanup and build fixes for CRISv32 allmodconfig

  God Jul och Gott Nytt år!"

* tag 'cris-changes-for-3.19' of git://git.kernel.org/pub/scm/linux/kernel/git/jesper/cris:
  CRISv32: Remove last remnants of ETRAX_SPI_MMC_BOARD
  CRISv32: ETRAXFS: Fix recursive spinlock
  CRISv32: Select MTDRAM for axisflashmap
  CRISv32: Implement early console
  CRIS: Use KALLSYMs if available in call stack dump
  CRISv32: Fix declaration mismatch
  CRISv32: Rewrite of synchronous serial port driver
  CRIS: Update init memory handling
  CRISv32: Better handling of watchdog bite
  CRIS: Export missing function symbols
  CRIS: Export ioremap_nocache
  CRIS: Fix headers_install
  CRISv32: Add missing include for mm.h
  CRISv32: Drop obsolete file for SPI driver
This commit is contained in:
Linus Torvalds 2014-12-19 17:08:14 -08:00
Родитель acab1f8857 8bcabff058
Коммит 971d9e07e1
17 изменённых файлов: 1049 добавлений и 826 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

14
arch/cris/arch-v10/lib/usercopy.c
Просмотреть файл

@ -30,8 +30,7 @@
/* Copy to userspace. This is based on the memcpy used for /* Copy to userspace. This is based on the memcpy used for
kernel-to-kernel copying; see "string.c". */ kernel-to-kernel copying; see "string.c". */
unsigned long unsigned long __copy_user(void __user *pdst, const void *psrc, unsigned long pn)
__copy_user (void __user *pdst, const void *psrc, unsigned long pn)
{ {
/* We want the parameters put in special registers. /* We want the parameters put in special registers.
Make sure the compiler is able to make something useful of this. Make sure the compiler is able to make something useful of this.
@ -187,13 +186,14 @@ __copy_user (void __user *pdst, const void *psrc, unsigned long pn)
return retn; return retn;
} }
EXPORT_SYMBOL(__copy_user);
/* Copy from user to kernel, zeroing the bytes that were inaccessible in /* Copy from user to kernel, zeroing the bytes that were inaccessible in
userland. The return-value is the number of bytes that were userland. The return-value is the number of bytes that were
inaccessible. */ inaccessible. */
unsigned long unsigned long __copy_user_zeroing(void *pdst, const void __user *psrc,
__copy_user_zeroing(void *pdst, const void __user *psrc, unsigned long pn) unsigned long pn)
{ {
/* We want the parameters put in special registers. /* We want the parameters put in special registers.
Make sure the compiler is able to make something useful of this. Make sure the compiler is able to make something useful of this.
@ -369,11 +369,10 @@ copy_exception_bytes:
return retn + n; return retn + n;
} }
EXPORT_SYMBOL(__copy_user_zeroing);
/* Zero userspace. */ /* Zero userspace. */
unsigned long __do_clear_user(void __user *pto, unsigned long pn)
unsigned long
__do_clear_user (void __user *pto, unsigned long pn)
{ {
/* We want the parameters put in special registers. /* We want the parameters put in special registers.
Make sure the compiler is able to make something useful of this. Make sure the compiler is able to make something useful of this.
@ -521,3 +520,4 @@ __do_clear_user (void __user *pto, unsigned long pn)
return retn; return retn;
} }
EXPORT_SYMBOL(__do_clear_user);

8
arch/cris/arch-v32/drivers/Kconfig
Просмотреть файл

@ -108,6 +108,7 @@ config ETRAX_AXISFLASHMAP
select MTD_JEDECPROBE select MTD_JEDECPROBE
select MTD_BLOCK select MTD_BLOCK
select MTD_COMPLEX_MAPPINGS select MTD_COMPLEX_MAPPINGS
select MTD_MTDRAM
help help
This option enables MTD mapping of flash devices. Needed to use This option enables MTD mapping of flash devices. Needed to use
flash memories. If unsure, say Y. flash memories. If unsure, say Y.
@ -358,13 +359,6 @@ config ETRAX_SPI_MMC
default MMC default MMC
select SPI select SPI
select MMC_SPI select MMC_SPI
select ETRAX_SPI_MMC_BOARD
# For the parts that can't be a module (due to restrictions in
# framework elsewhere).
config ETRAX_SPI_MMC_BOARD
boolean
default n
# While the board info is MMC_SPI only, the drivers are written to be # While the board info is MMC_SPI only, the drivers are written to be
# independent of MMC_SPI, so we'll keep SPI non-dependent on the # independent of MMC_SPI, so we'll keep SPI non-dependent on the

1
arch/cris/arch-v32/drivers/Makefile
Просмотреть файл

@ -10,4 +10,3 @@ obj-$(CONFIG_ETRAX_IOP_FW_LOAD) += iop_fw_load.o
obj-$(CONFIG_ETRAX_I2C) += i2c.o obj-$(CONFIG_ETRAX_I2C) += i2c.o
obj-$(CONFIG_ETRAX_SYNCHRONOUS_SERIAL) += sync_serial.o obj-$(CONFIG_ETRAX_SYNCHRONOUS_SERIAL) += sync_serial.o
obj-$(CONFIG_PCI) += pci/ obj-$(CONFIG_PCI) += pci/
obj-$(CONFIG_ETRAX_SPI_MMC_BOARD) += board_mmcspi.o

1
arch/cris/arch-v32/drivers/i2c.h
Просмотреть файл

@ -2,7 +2,6 @@
#include <linux/init.h> #include <linux/init.h>
/* High level I2C actions */ /* High level I2C actions */
int __init i2c_init(void);
int i2c_write(unsigned char theSlave, void *data, size_t nbytes); int i2c_write(unsigned char theSlave, void *data, size_t nbytes);
int i2c_read(unsigned char theSlave, void *data, size_t nbytes); int i2c_read(unsigned char theSlave, void *data, size_t nbytes);
int i2c_writereg(unsigned char theSlave, unsigned char theReg, unsigned char theValue); int i2c_writereg(unsigned char theSlave, unsigned char theReg, unsigned char theValue);

1436
arch/cris/arch-v32/drivers/sync_serial.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

82
arch/cris/arch-v32/kernel/debugport.c
Просмотреть файл

@ -3,7 +3,9 @@
*/ */
#include <linux/console.h> #include <linux/console.h>
#include <linux/kernel.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/string.h>
#include <hwregs/reg_rdwr.h> #include <hwregs/reg_rdwr.h>
#include <hwregs/reg_map.h> #include <hwregs/reg_map.h>
#include <hwregs/ser_defs.h> #include <hwregs/ser_defs.h>
@ -65,6 +67,7 @@ struct dbg_port ports[] =
}, },
#endif #endif
}; };
static struct dbg_port *port = static struct dbg_port *port =
#if defined(CONFIG_ETRAX_DEBUG_PORT0) #if defined(CONFIG_ETRAX_DEBUG_PORT0)
&ports[0]; &ports[0];
@ -97,14 +100,19 @@ static struct dbg_port *kgdb_port =
#endif #endif
#endif #endif
static void static void start_port(struct dbg_port *p)
start_port(struct dbg_port* p)
{ {
if (!p) /* Set up serial port registers */
reg_ser_rw_tr_ctrl tr_ctrl = {0};
reg_ser_rw_tr_dma_en tr_dma_en = {0};
reg_ser_rw_rec_ctrl rec_ctrl = {0};
reg_ser_rw_tr_baud_div tr_baud_div = {0};
reg_ser_rw_rec_baud_div rec_baud_div = {0};
if (!p || p->started)
return; return;
if (p->started)
return;
p->started = 1; p->started = 1;
if (p->nbr == 1) if (p->nbr == 1)
@ -118,36 +126,24 @@ start_port(struct dbg_port* p)
crisv32_pinmux_alloc_fixed(pinmux_ser4); crisv32_pinmux_alloc_fixed(pinmux_ser4);
#endif #endif
/* Set up serial port registers */
reg_ser_rw_tr_ctrl tr_ctrl = {0};
reg_ser_rw_tr_dma_en tr_dma_en = {0};
reg_ser_rw_rec_ctrl rec_ctrl = {0};
reg_ser_rw_tr_baud_div tr_baud_div = {0};
reg_ser_rw_rec_baud_div rec_baud_div = {0};
tr_ctrl.base_freq = rec_ctrl.base_freq = regk_ser_f29_493; tr_ctrl.base_freq = rec_ctrl.base_freq = regk_ser_f29_493;
tr_dma_en.en = rec_ctrl.dma_mode = regk_ser_no; tr_dma_en.en = rec_ctrl.dma_mode = regk_ser_no;
tr_baud_div.div = rec_baud_div.div = 29493000 / p->baudrate / 8; tr_baud_div.div = rec_baud_div.div = 29493000 / p->baudrate / 8;
tr_ctrl.en = rec_ctrl.en = 1; tr_ctrl.en = rec_ctrl.en = 1;
if (p->parity == 'O') if (p->parity == 'O') {
{
tr_ctrl.par_en = regk_ser_yes; tr_ctrl.par_en = regk_ser_yes;
tr_ctrl.par = regk_ser_odd; tr_ctrl.par = regk_ser_odd;
rec_ctrl.par_en = regk_ser_yes; rec_ctrl.par_en = regk_ser_yes;
rec_ctrl.par = regk_ser_odd; rec_ctrl.par = regk_ser_odd;
} } else if (p->parity == 'E') {
else if (p->parity == 'E')
{
tr_ctrl.par_en = regk_ser_yes; tr_ctrl.par_en = regk_ser_yes;
tr_ctrl.par = regk_ser_even; tr_ctrl.par = regk_ser_even;
rec_ctrl.par_en = regk_ser_yes; rec_ctrl.par_en = regk_ser_yes;
rec_ctrl.par = regk_ser_odd; rec_ctrl.par = regk_ser_odd;
} }
if (p->bits == 7) if (p->bits == 7) {
{
tr_ctrl.data_bits = regk_ser_bits7; tr_ctrl.data_bits = regk_ser_bits7;
rec_ctrl.data_bits = regk_ser_bits7; rec_ctrl.data_bits = regk_ser_bits7;
} }
@ -161,8 +157,7 @@ start_port(struct dbg_port* p)
#ifdef CONFIG_ETRAX_KGDB #ifdef CONFIG_ETRAX_KGDB
/* Use polling to get a single character from the kernel debug port */ /* Use polling to get a single character from the kernel debug port */
int int getDebugChar(void)
getDebugChar(void)
{ {
reg_ser_rs_stat_din stat; reg_ser_rs_stat_din stat;
reg_ser_rw_ack_intr ack_intr = { 0 }; reg_ser_rw_ack_intr ack_intr = { 0 };
@ -179,8 +174,7 @@ getDebugChar(void)
} }
/* Use polling to put a single character to the kernel debug port */ /* Use polling to put a single character to the kernel debug port */
void void putDebugChar(int val)
putDebugChar(int val)
{ {
reg_ser_r_stat_din stat; reg_ser_r_stat_din stat;
do { do {
@ -190,12 +184,48 @@ putDebugChar(int val)
} }
#endif /* CONFIG_ETRAX_KGDB */ #endif /* CONFIG_ETRAX_KGDB */
static void __init early_putch(int c)
{
reg_ser_r_stat_din stat;
/* Wait until transmitter is ready and send. */
do
stat = REG_RD(ser, port->instance, r_stat_din);
while (!stat.tr_rdy);
REG_WR_INT(ser, port->instance, rw_dout, c);
}
static void __init
early_console_write(struct console *con, const char *s, unsigned n)
{
extern void reset_watchdog(void);
int i;
/* Send data. */
for (i = 0; i < n; i++) {
/* TODO: the '\n' -> '\n\r' translation should be done at the
receiver. Remove it when the serial driver removes it. */
if (s[i] == '\n')
early_putch('\r');
early_putch(s[i]);
reset_watchdog();
}
}
static struct console early_console_dev __initdata = {
.name = "early",
.write = early_console_write,
.flags = CON_PRINTBUFFER | CON_BOOT,
.index = -1
};
/* Register console for printk's, etc. */ /* Register console for printk's, etc. */
int __init int __init init_etrax_debug(void)
init_etrax_debug(void)
{ {
start_port(port); start_port(port);
/* Register an early console if a debug port was chosen. */
register_console(&early_console_dev);
#ifdef CONFIG_ETRAX_KGDB #ifdef CONFIG_ETRAX_KGDB
start_port(kgdb_port); start_port(kgdb_port);
#endif /* CONFIG_ETRAX_KGDB */ #endif /* CONFIG_ETRAX_KGDB */

29
arch/cris/arch-v32/kernel/time.c
Просмотреть файл

@ -14,6 +14,7 @@
#include <linux/init.h> #include <linux/init.h>
#include <linux/threads.h> #include <linux/threads.h>
#include <linux/cpufreq.h> #include <linux/cpufreq.h>
#include <linux/mm.h>
#include <asm/types.h> #include <asm/types.h>
#include <asm/signal.h> #include <asm/signal.h>
#include <asm/io.h> #include <asm/io.h>
@ -56,7 +57,6 @@ static int __init etrax_init_cont_rotime(void)
} }
arch_initcall(etrax_init_cont_rotime); arch_initcall(etrax_init_cont_rotime);
unsigned long timer_regs[NR_CPUS] = unsigned long timer_regs[NR_CPUS] =
{ {
regi_timer0, regi_timer0,
@ -68,9 +68,8 @@ unsigned long timer_regs[NR_CPUS] =
extern int set_rtc_mmss(unsigned long nowtime); extern int set_rtc_mmss(unsigned long nowtime);
#ifdef CONFIG_CPU_FREQ #ifdef CONFIG_CPU_FREQ
static int static int cris_time_freq_notifier(struct notifier_block *nb,
cris_time_freq_notifier(struct notifier_block *nb, unsigned long val, unsigned long val, void *data);
void *data);
static struct notifier_block cris_time_freq_notifier_block = { static struct notifier_block cris_time_freq_notifier_block = {
.notifier_call = cris_time_freq_notifier, .notifier_call = cris_time_freq_notifier,
@ -87,7 +86,6 @@ unsigned long get_ns_in_jiffie(void)
return ns; return ns;
} }
/* From timer MDS describing the hardware watchdog: /* From timer MDS describing the hardware watchdog:
* 4.3.1 Watchdog Operation * 4.3.1 Watchdog Operation
* The watchdog timer is an 8-bit timer with a configurable start value. * The watchdog timer is an 8-bit timer with a configurable start value.
@ -109,11 +107,18 @@ static short int watchdog_key = 42; /* arbitrary 7 bit number */
* is used though, so set this really low. */ * is used though, so set this really low. */
#define WATCHDOG_MIN_FREE_PAGES 8 #define WATCHDOG_MIN_FREE_PAGES 8
/* for reliable NICE_DOGGY behaviour */
static int bite_in_progress;
void reset_watchdog(void) void reset_watchdog(void)
{ {
#if defined(CONFIG_ETRAX_WATCHDOG) #if defined(CONFIG_ETRAX_WATCHDOG)
reg_timer_rw_wd_ctrl wd_ctrl = { 0 }; reg_timer_rw_wd_ctrl wd_ctrl = { 0 };
#if defined(CONFIG_ETRAX_WATCHDOG_NICE_DOGGY)
if (unlikely(bite_in_progress))
return;
#endif
/* Only keep watchdog happy as long as we have memory left! */ /* Only keep watchdog happy as long as we have memory left! */
if(nr_free_pages() > WATCHDOG_MIN_FREE_PAGES) { if(nr_free_pages() > WATCHDOG_MIN_FREE_PAGES) {
/* Reset the watchdog with the inverse of the old key */ /* Reset the watchdog with the inverse of the old key */
@ -148,7 +153,9 @@ void handle_watchdog_bite(struct pt_regs *regs)
#if defined(CONFIG_ETRAX_WATCHDOG) #if defined(CONFIG_ETRAX_WATCHDOG)
extern int cause_of_death; extern int cause_of_death;
nmi_enter();
oops_in_progress = 1; oops_in_progress = 1;
bite_in_progress = 1;
printk(KERN_WARNING "Watchdog bite\n"); printk(KERN_WARNING "Watchdog bite\n");
/* Check if forced restart or unexpected watchdog */ /* Check if forced restart or unexpected watchdog */
@ -170,6 +177,7 @@ void handle_watchdog_bite(struct pt_regs *regs)
printk(KERN_WARNING "Oops: bitten by watchdog\n"); printk(KERN_WARNING "Oops: bitten by watchdog\n");
show_registers(regs); show_registers(regs);
oops_in_progress = 0; oops_in_progress = 0;
printk("\n"); /* Flush mtdoops. */
#ifndef CONFIG_ETRAX_WATCHDOG_NICE_DOGGY #ifndef CONFIG_ETRAX_WATCHDOG_NICE_DOGGY
reset_watchdog(); reset_watchdog();
#endif #endif
@ -202,7 +210,7 @@ static inline irqreturn_t timer_interrupt(int irq, void *dev_id)
/* Reset watchdog otherwise it resets us! */ /* Reset watchdog otherwise it resets us! */
reset_watchdog(); reset_watchdog();
/* Update statistics. */ /* Update statistics. */
update_process_times(user_mode(regs)); update_process_times(user_mode(regs));
cris_do_profile(regs); /* Save profiling information */ cris_do_profile(regs); /* Save profiling information */
@ -213,7 +221,7 @@ static inline irqreturn_t timer_interrupt(int irq, void *dev_id)
/* Call the real timer interrupt handler */ /* Call the real timer interrupt handler */
xtime_update(1); xtime_update(1);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
/* Timer is IRQF_SHARED so drivers can add stuff to the timer irq chain. */ /* Timer is IRQF_SHARED so drivers can add stuff to the timer irq chain. */
@ -293,14 +301,13 @@ void __init time_init(void)
#ifdef CONFIG_CPU_FREQ #ifdef CONFIG_CPU_FREQ
cpufreq_register_notifier(&cris_time_freq_notifier_block, cpufreq_register_notifier(&cris_time_freq_notifier_block,
CPUFREQ_TRANSITION_NOTIFIER); CPUFREQ_TRANSITION_NOTIFIER);
#endif #endif
} }
#ifdef CONFIG_CPU_FREQ #ifdef CONFIG_CPU_FREQ
static int static int cris_time_freq_notifier(struct notifier_block *nb,
cris_time_freq_notifier(struct notifier_block *nb, unsigned long val, unsigned long val, void *data)
void *data)
{ {
struct cpufreq_freqs *freqs = data; struct cpufreq_freqs *freqs = data;
if (val == CPUFREQ_POSTCHANGE) { if (val == CPUFREQ_POSTCHANGE) {

15
arch/cris/arch-v32/lib/usercopy.c
Просмотреть файл

@ -26,8 +26,7 @@
/* Copy to userspace. This is based on the memcpy used for /* Copy to userspace. This is based on the memcpy used for
kernel-to-kernel copying; see "string.c". */ kernel-to-kernel copying; see "string.c". */
unsigned long unsigned long __copy_user(void __user *pdst, const void *psrc, unsigned long pn)
__copy_user (void __user *pdst, const void *psrc, unsigned long pn)
{ {
/* We want the parameters put in special registers. /* We want the parameters put in special registers.
Make sure the compiler is able to make something useful of this. Make sure the compiler is able to make something useful of this.
@ -155,13 +154,13 @@ __copy_user (void __user *pdst, const void *psrc, unsigned long pn)
return retn; return retn;
} }
EXPORT_SYMBOL(__copy_user);
/* Copy from user to kernel, zeroing the bytes that were inaccessible in /* Copy from user to kernel, zeroing the bytes that were inaccessible in
userland. The return-value is the number of bytes that were userland. The return-value is the number of bytes that were
inaccessible. */ inaccessible. */
unsigned long __copy_user_zeroing(void *pdst, const void __user *psrc,
unsigned long unsigned long pn)
__copy_user_zeroing(void *pdst, const void __user *psrc, unsigned long pn)
{ {
/* We want the parameters put in special registers. /* We want the parameters put in special registers.
Make sure the compiler is able to make something useful of this. Make sure the compiler is able to make something useful of this.
@ -321,11 +320,10 @@ copy_exception_bytes:
return retn + n; return retn + n;
} }
EXPORT_SYMBOL(__copy_user_zeroing);
/* Zero userspace. */ /* Zero userspace. */
unsigned long __do_clear_user(void __user *pto, unsigned long pn)
unsigned long
__do_clear_user (void __user *pto, unsigned long pn)
{ {
/* We want the parameters put in special registers. /* We want the parameters put in special registers.
Make sure the compiler is able to make something useful of this. Make sure the compiler is able to make something useful of this.
@ -468,3 +466,4 @@ __do_clear_user (void __user *pto, unsigned long pn)
return retn; return retn;
} }
EXPORT_SYMBOL(__do_clear_user);

166
arch/cris/arch-v32/mach-fs/pinmux.c
Просмотреть файл

@ -26,44 +26,15 @@ static DEFINE_SPINLOCK(pinmux_lock);
static void crisv32_pinmux_set(int port); static void crisv32_pinmux_set(int port);
int crisv32_pinmux_init(void) static int __crisv32_pinmux_alloc(int port, int first_pin, int last_pin,
{ enum pin_mode mode)
static int initialized;
if (!initialized) {
reg_pinmux_rw_pa pa = REG_RD(pinmux, regi_pinmux, rw_pa);
initialized = 1;
REG_WR_INT(pinmux, regi_pinmux, rw_hwprot, 0);
pa.pa0 = pa.pa1 = pa.pa2 = pa.pa3 =
pa.pa4 = pa.pa5 = pa.pa6 = pa.pa7 = regk_pinmux_yes;
REG_WR(pinmux, regi_pinmux, rw_pa, pa);
crisv32_pinmux_alloc(PORT_B, 0, PORT_PINS - 1, pinmux_gpio);
crisv32_pinmux_alloc(PORT_C, 0, PORT_PINS - 1, pinmux_gpio);
crisv32_pinmux_alloc(PORT_D, 0, PORT_PINS - 1, pinmux_gpio);
crisv32_pinmux_alloc(PORT_E, 0, PORT_PINS - 1, pinmux_gpio);
}
return 0;
}
int
crisv32_pinmux_alloc(int port, int first_pin, int last_pin, enum pin_mode mode)
{ {
int i; int i;
unsigned long flags;
crisv32_pinmux_init();
if (port > PORTS || port < 0)
return -EINVAL;
spin_lock_irqsave(&pinmux_lock, flags);
for (i = first_pin; i <= last_pin; i++) { for (i = first_pin; i <= last_pin; i++) {
if ((pins[port][i] != pinmux_none) if ((pins[port][i] != pinmux_none)
&& (pins[port][i] != pinmux_gpio) && (pins[port][i] != pinmux_gpio)
&& (pins[port][i] != mode)) { && (pins[port][i] != mode)) {
spin_unlock_irqrestore(&pinmux_lock, flags);
#ifdef DEBUG #ifdef DEBUG
panic("Pinmux alloc failed!\n"); panic("Pinmux alloc failed!\n");
#endif #endif
@ -75,10 +46,46 @@ crisv32_pinmux_alloc(int port, int first_pin, int last_pin, enum pin_mode mode)
pins[port][i] = mode; pins[port][i] = mode;
crisv32_pinmux_set(port); crisv32_pinmux_set(port);
}
static int crisv32_pinmux_init(void)
{
static int initialized;
if (!initialized) {
reg_pinmux_rw_pa pa = REG_RD(pinmux, regi_pinmux, rw_pa);
initialized = 1;
REG_WR_INT(pinmux, regi_pinmux, rw_hwprot, 0);
pa.pa0 = pa.pa1 = pa.pa2 = pa.pa3 =
pa.pa4 = pa.pa5 = pa.pa6 = pa.pa7 = regk_pinmux_yes;
REG_WR(pinmux, regi_pinmux, rw_pa, pa);
__crisv32_pinmux_alloc(PORT_B, 0, PORT_PINS - 1, pinmux_gpio);
__crisv32_pinmux_alloc(PORT_C, 0, PORT_PINS - 1, pinmux_gpio);
__crisv32_pinmux_alloc(PORT_D, 0, PORT_PINS - 1, pinmux_gpio);
__crisv32_pinmux_alloc(PORT_E, 0, PORT_PINS - 1, pinmux_gpio);
}
return 0;
}
int crisv32_pinmux_alloc(int port, int first_pin, int last_pin,
enum pin_mode mode)
{
unsigned long flags;
int ret;
crisv32_pinmux_init();
if (port > PORTS || port < 0)
return -EINVAL;
spin_lock_irqsave(&pinmux_lock, flags);
ret = __crisv32_pinmux_alloc(port, first_pin, last_pin, mode);
spin_unlock_irqrestore(&pinmux_lock, flags); spin_unlock_irqrestore(&pinmux_lock, flags);
return 0; return ret;
} }
int crisv32_pinmux_alloc_fixed(enum fixed_function function) int crisv32_pinmux_alloc_fixed(enum fixed_function function)
@ -98,58 +105,58 @@ int crisv32_pinmux_alloc_fixed(enum fixed_function function)
switch (function) { switch (function) {
case pinmux_ser1: case pinmux_ser1:
ret = crisv32_pinmux_alloc(PORT_C, 4, 7, pinmux_fixed); ret = __crisv32_pinmux_alloc(PORT_C, 4, 7, pinmux_fixed);
hwprot.ser1 = regk_pinmux_yes; hwprot.ser1 = regk_pinmux_yes;
break; break;
case pinmux_ser2: case pinmux_ser2:
ret = crisv32_pinmux_alloc(PORT_C, 8, 11, pinmux_fixed); ret = __crisv32_pinmux_alloc(PORT_C, 8, 11, pinmux_fixed);
hwprot.ser2 = regk_pinmux_yes; hwprot.ser2 = regk_pinmux_yes;
break; break;
case pinmux_ser3: case pinmux_ser3:
ret = crisv32_pinmux_alloc(PORT_C, 12, 15, pinmux_fixed); ret = __crisv32_pinmux_alloc(PORT_C, 12, 15, pinmux_fixed);
hwprot.ser3 = regk_pinmux_yes; hwprot.ser3 = regk_pinmux_yes;
break; break;
case pinmux_sser0: case pinmux_sser0:
ret = crisv32_pinmux_alloc(PORT_C, 0, 3, pinmux_fixed); ret = __crisv32_pinmux_alloc(PORT_C, 0, 3, pinmux_fixed);
ret |= crisv32_pinmux_alloc(PORT_C, 16, 16, pinmux_fixed); ret |= __crisv32_pinmux_alloc(PORT_C, 16, 16, pinmux_fixed);
hwprot.sser0 = regk_pinmux_yes; hwprot.sser0 = regk_pinmux_yes;
break; break;
case pinmux_sser1: case pinmux_sser1:
ret = crisv32_pinmux_alloc(PORT_D, 0, 4, pinmux_fixed); ret = __crisv32_pinmux_alloc(PORT_D, 0, 4, pinmux_fixed);
hwprot.sser1 = regk_pinmux_yes; hwprot.sser1 = regk_pinmux_yes;
break; break;
case pinmux_ata0: case pinmux_ata0:
ret = crisv32_pinmux_alloc(PORT_D, 5, 7, pinmux_fixed); ret = __crisv32_pinmux_alloc(PORT_D, 5, 7, pinmux_fixed);
ret |= crisv32_pinmux_alloc(PORT_D, 15, 17, pinmux_fixed); ret |= __crisv32_pinmux_alloc(PORT_D, 15, 17, pinmux_fixed);
hwprot.ata0 = regk_pinmux_yes; hwprot.ata0 = regk_pinmux_yes;
break; break;
case pinmux_ata1: case pinmux_ata1:
ret = crisv32_pinmux_alloc(PORT_D, 0, 4, pinmux_fixed); ret = __crisv32_pinmux_alloc(PORT_D, 0, 4, pinmux_fixed);
ret |= crisv32_pinmux_alloc(PORT_E, 17, 17, pinmux_fixed); ret |= __crisv32_pinmux_alloc(PORT_E, 17, 17, pinmux_fixed);
hwprot.ata1 = regk_pinmux_yes; hwprot.ata1 = regk_pinmux_yes;
break; break;
case pinmux_ata2: case pinmux_ata2:
ret = crisv32_pinmux_alloc(PORT_C, 11, 15, pinmux_fixed); ret = __crisv32_pinmux_alloc(PORT_C, 11, 15, pinmux_fixed);
ret |= crisv32_pinmux_alloc(PORT_E, 3, 3, pinmux_fixed); ret |= __crisv32_pinmux_alloc(PORT_E, 3, 3, pinmux_fixed);
hwprot.ata2 = regk_pinmux_yes; hwprot.ata2 = regk_pinmux_yes;
break; break;
case pinmux_ata3: case pinmux_ata3:
ret = crisv32_pinmux_alloc(PORT_C, 8, 10, pinmux_fixed); ret = __crisv32_pinmux_alloc(PORT_C, 8, 10, pinmux_fixed);
ret |= crisv32_pinmux_alloc(PORT_C, 0, 2, pinmux_fixed); ret |= __crisv32_pinmux_alloc(PORT_C, 0, 2, pinmux_fixed);
hwprot.ata2 = regk_pinmux_yes; hwprot.ata2 = regk_pinmux_yes;
break; break;
case pinmux_ata: case pinmux_ata:
ret = crisv32_pinmux_alloc(PORT_B, 0, 15, pinmux_fixed); ret = __crisv32_pinmux_alloc(PORT_B, 0, 15, pinmux_fixed);
ret |= crisv32_pinmux_alloc(PORT_D, 8, 15, pinmux_fixed); ret |= __crisv32_pinmux_alloc(PORT_D, 8, 15, pinmux_fixed);
hwprot.ata = regk_pinmux_yes; hwprot.ata = regk_pinmux_yes;
break; break;
case pinmux_eth1: case pinmux_eth1:
ret = crisv32_pinmux_alloc(PORT_E, 0, 17, pinmux_fixed); ret = __crisv32_pinmux_alloc(PORT_E, 0, 17, pinmux_fixed);
hwprot.eth1 = regk_pinmux_yes; hwprot.eth1 = regk_pinmux_yes;
hwprot.eth1_mgm = regk_pinmux_yes; hwprot.eth1_mgm = regk_pinmux_yes;
break; break;
case pinmux_timer: case pinmux_timer:
ret = crisv32_pinmux_alloc(PORT_C, 16, 16, pinmux_fixed); ret = __crisv32_pinmux_alloc(PORT_C, 16, 16, pinmux_fixed);
hwprot.timer = regk_pinmux_yes; hwprot.timer = regk_pinmux_yes;
spin_unlock_irqrestore(&pinmux_lock, flags); spin_unlock_irqrestore(&pinmux_lock, flags);
return ret; return ret;
@ -188,9 +195,19 @@ void crisv32_pinmux_set(int port)
#endif #endif
} }
int crisv32_pinmux_dealloc(int port, int first_pin, int last_pin) static int __crisv32_pinmux_dealloc(int port, int first_pin, int last_pin)
{ {
int i; int i;
for (i = first_pin; i <= last_pin; i++)
pins[port][i] = pinmux_none;
crisv32_pinmux_set(port);
return 0;
}
int crisv32_pinmux_dealloc(int port, int first_pin, int last_pin)
{
unsigned long flags; unsigned long flags;
crisv32_pinmux_init(); crisv32_pinmux_init();
@ -199,11 +216,7 @@ int crisv32_pinmux_dealloc(int port, int first_pin, int last_pin)
return -EINVAL; return -EINVAL;
spin_lock_irqsave(&pinmux_lock, flags); spin_lock_irqsave(&pinmux_lock, flags);
__crisv32_pinmux_dealloc(port, first_pin, last_pin);
for (i = first_pin; i <= last_pin; i++)
pins[port][i] = pinmux_none;
crisv32_pinmux_set(port);
spin_unlock_irqrestore(&pinmux_lock, flags); spin_unlock_irqrestore(&pinmux_lock, flags);
return 0; return 0;
@ -226,58 +239,58 @@ int crisv32_pinmux_dealloc_fixed(enum fixed_function function)
switch (function) { switch (function) {
case pinmux_ser1: case pinmux_ser1:
ret = crisv32_pinmux_dealloc(PORT_C, 4, 7); ret = __crisv32_pinmux_dealloc(PORT_C, 4, 7);
hwprot.ser1 = regk_pinmux_no; hwprot.ser1 = regk_pinmux_no;
break; break;
case pinmux_ser2: case pinmux_ser2:
ret = crisv32_pinmux_dealloc(PORT_C, 8, 11); ret = __crisv32_pinmux_dealloc(PORT_C, 8, 11);
hwprot.ser2 = regk_pinmux_no; hwprot.ser2 = regk_pinmux_no;
break; break;
case pinmux_ser3: case pinmux_ser3:
ret = crisv32_pinmux_dealloc(PORT_C, 12, 15); ret = __crisv32_pinmux_dealloc(PORT_C, 12, 15);
hwprot.ser3 = regk_pinmux_no; hwprot.ser3 = regk_pinmux_no;
break; break;
case pinmux_sser0: case pinmux_sser0:
ret = crisv32_pinmux_dealloc(PORT_C, 0, 3); ret = __crisv32_pinmux_dealloc(PORT_C, 0, 3);
ret |= crisv32_pinmux_dealloc(PORT_C, 16, 16); ret |= __crisv32_pinmux_dealloc(PORT_C, 16, 16);
hwprot.sser0 = regk_pinmux_no; hwprot.sser0 = regk_pinmux_no;
break; break;
case pinmux_sser1: case pinmux_sser1:
ret = crisv32_pinmux_dealloc(PORT_D, 0, 4); ret = __crisv32_pinmux_dealloc(PORT_D, 0, 4);
hwprot.sser1 = regk_pinmux_no; hwprot.sser1 = regk_pinmux_no;
break; break;
case pinmux_ata0: case pinmux_ata0:
ret = crisv32_pinmux_dealloc(PORT_D, 5, 7); ret = __crisv32_pinmux_dealloc(PORT_D, 5, 7);
ret |= crisv32_pinmux_dealloc(PORT_D, 15, 17); ret |= __crisv32_pinmux_dealloc(PORT_D, 15, 17);
hwprot.ata0 = regk_pinmux_no; hwprot.ata0 = regk_pinmux_no;
break; break;
case pinmux_ata1: case pinmux_ata1:
ret = crisv32_pinmux_dealloc(PORT_D, 0, 4); ret = __crisv32_pinmux_dealloc(PORT_D, 0, 4);
ret |= crisv32_pinmux_dealloc(PORT_E, 17, 17); ret |= __crisv32_pinmux_dealloc(PORT_E, 17, 17);
hwprot.ata1 = regk_pinmux_no; hwprot.ata1 = regk_pinmux_no;
break; break;
case pinmux_ata2: case pinmux_ata2:
ret = crisv32_pinmux_dealloc(PORT_C, 11, 15); ret = __crisv32_pinmux_dealloc(PORT_C, 11, 15);
ret |= crisv32_pinmux_dealloc(PORT_E, 3, 3); ret |= __crisv32_pinmux_dealloc(PORT_E, 3, 3);
hwprot.ata2 = regk_pinmux_no; hwprot.ata2 = regk_pinmux_no;
break; break;
case pinmux_ata3: case pinmux_ata3:
ret = crisv32_pinmux_dealloc(PORT_C, 8, 10); ret = __crisv32_pinmux_dealloc(PORT_C, 8, 10);
ret |= crisv32_pinmux_dealloc(PORT_C, 0, 2); ret |= __crisv32_pinmux_dealloc(PORT_C, 0, 2);
hwprot.ata2 = regk_pinmux_no; hwprot.ata2 = regk_pinmux_no;
break; break;
case pinmux_ata: case pinmux_ata:
ret = crisv32_pinmux_dealloc(PORT_B, 0, 15); ret = __crisv32_pinmux_dealloc(PORT_B, 0, 15);
ret |= crisv32_pinmux_dealloc(PORT_D, 8, 15); ret |= __crisv32_pinmux_dealloc(PORT_D, 8, 15);
hwprot.ata = regk_pinmux_no; hwprot.ata = regk_pinmux_no;
break; break;
case pinmux_eth1: case pinmux_eth1:
ret = crisv32_pinmux_dealloc(PORT_E, 0, 17); ret = __crisv32_pinmux_dealloc(PORT_E, 0, 17);
hwprot.eth1 = regk_pinmux_no; hwprot.eth1 = regk_pinmux_no;
hwprot.eth1_mgm = regk_pinmux_no; hwprot.eth1_mgm = regk_pinmux_no;
break; break;
case pinmux_timer: case pinmux_timer:
ret = crisv32_pinmux_dealloc(PORT_C, 16, 16); ret = __crisv32_pinmux_dealloc(PORT_C, 16, 16);
hwprot.timer = regk_pinmux_no; hwprot.timer = regk_pinmux_no;
spin_unlock_irqrestore(&pinmux_lock, flags); spin_unlock_irqrestore(&pinmux_lock, flags);
return ret; return ret;
@ -293,7 +306,8 @@ int crisv32_pinmux_dealloc_fixed(enum fixed_function function)
return ret; return ret;
} }
void crisv32_pinmux_dump(void) #ifdef DEBUG
static void crisv32_pinmux_dump(void)
{ {
int i, j; int i, j;
@ -305,5 +319,5 @@ void crisv32_pinmux_dump(void)
printk(KERN_DEBUG " Pin %d = %d\n", j, pins[i][j]); printk(KERN_DEBUG " Pin %d = %d\n", j, pins[i][j]);
} }
} }
#endif
__initcall(crisv32_pinmux_init); __initcall(crisv32_pinmux_init);

2
arch/cris/include/arch-v32/mach-fs/mach/pinmux.h
Просмотреть файл

@ -28,11 +28,9 @@ enum fixed_function {
pinmux_timer pinmux_timer
}; };
int crisv32_pinmux_init(void);
int crisv32_pinmux_alloc(int port, int first_pin, int last_pin, enum pin_mode); int crisv32_pinmux_alloc(int port, int first_pin, int last_pin, enum pin_mode);
int crisv32_pinmux_alloc_fixed(enum fixed_function function); int crisv32_pinmux_alloc_fixed(enum fixed_function function);
int crisv32_pinmux_dealloc(int port, int first_pin, int last_pin); int crisv32_pinmux_dealloc(int port, int first_pin, int last_pin);
int crisv32_pinmux_dealloc_fixed(enum fixed_function function); int crisv32_pinmux_dealloc_fixed(enum fixed_function function);
void crisv32_pinmux_dump(void);
#endif #endif

4
arch/cris/include/asm/Kbuild
Просмотреть файл

@ -1,8 +1,4 @@
header-y += arch-v10/
header-y += arch-v32/
generic-y += barrier.h generic-y += barrier.h
generic-y += clkdev.h generic-y += clkdev.h
generic-y += cputime.h generic-y += cputime.h

4
arch/cris/include/uapi/asm/Kbuild
Просмотреть файл

@ -1,8 +1,8 @@
# UAPI Header export list # UAPI Header export list
include include/uapi/asm-generic/Kbuild.asm include include/uapi/asm-generic/Kbuild.asm
header-y += arch-v10/ header-y += ../arch-v10/arch/
header-y += arch-v32/ header-y += ../arch-v32/arch/
header-y += auxvec.h header-y += auxvec.h
header-y += bitsperlong.h header-y += bitsperlong.h
header-y += byteorder.h header-y += byteorder.h

9
arch/cris/kernel/crisksyms.c
Просмотреть файл

@ -47,16 +47,16 @@ EXPORT_SYMBOL(__negdi2);
EXPORT_SYMBOL(__ioremap); EXPORT_SYMBOL(__ioremap);
EXPORT_SYMBOL(iounmap); EXPORT_SYMBOL(iounmap);
/* Userspace access functions */
EXPORT_SYMBOL(__copy_user_zeroing);
EXPORT_SYMBOL(__copy_user);
#undef memcpy #undef memcpy
#undef memset #undef memset
extern void * memset(void *, int, __kernel_size_t); extern void * memset(void *, int, __kernel_size_t);
extern void * memcpy(void *, const void *, __kernel_size_t); extern void * memcpy(void *, const void *, __kernel_size_t);
EXPORT_SYMBOL(memcpy); EXPORT_SYMBOL(memcpy);
EXPORT_SYMBOL(memset); EXPORT_SYMBOL(memset);
#ifdef CONFIG_ETRAX_ARCH_V32
#undef strcmp
EXPORT_SYMBOL(strcmp);
#endif
#ifdef CONFIG_ETRAX_FAST_TIMER #ifdef CONFIG_ETRAX_FAST_TIMER
/* Fast timer functions */ /* Fast timer functions */
@ -66,3 +66,4 @@ EXPORT_SYMBOL(del_fast_timer);
EXPORT_SYMBOL(schedule_usleep); EXPORT_SYMBOL(schedule_usleep);
#endif #endif
EXPORT_SYMBOL(csum_partial); EXPORT_SYMBOL(csum_partial);
EXPORT_SYMBOL(csum_partial_copy_from_user);

61
arch/cris/kernel/traps.c
Просмотреть файл

@ -14,6 +14,10 @@
#include <linux/init.h> #include <linux/init.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/utsname.h>
#ifdef CONFIG_KALLSYMS
#include <linux/kallsyms.h>
#endif
#include <asm/pgtable.h> #include <asm/pgtable.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
@ -34,25 +38,24 @@ static int kstack_depth_to_print = 24;
void (*nmi_handler)(struct pt_regs *); void (*nmi_handler)(struct pt_regs *);
void void show_trace(unsigned long *stack)
show_trace(unsigned long *stack)
{ {
unsigned long addr, module_start, module_end; unsigned long addr, module_start, module_end;
extern char _stext, _etext; extern char _stext, _etext;
int i; int i;
printk("\nCall Trace: "); pr_err("\nCall Trace: ");
i = 1; i = 1;
module_start = VMALLOC_START; module_start = VMALLOC_START;
module_end = VMALLOC_END; module_end = VMALLOC_END;
while (((long)stack & (THREAD_SIZE-1)) != 0) { while (((long)stack & (THREAD_SIZE - 1)) != 0) {
if (__get_user(addr, stack)) { if (__get_user(addr, stack)) {
/* This message matches "failing address" marked /* This message matches "failing address" marked
s390 in ksymoops, so lines containing it will s390 in ksymoops, so lines containing it will
not be filtered out by ksymoops. */ not be filtered out by ksymoops. */
printk("Failing address 0x%lx\n", (unsigned long)stack); pr_err("Failing address 0x%lx\n", (unsigned long)stack);
break; break;
} }
stack++; stack++;
@ -68,10 +71,14 @@ show_trace(unsigned long *stack)
if (((addr >= (unsigned long)&_stext) && if (((addr >= (unsigned long)&_stext) &&
(addr <= (unsigned long)&_etext)) || (addr <= (unsigned long)&_etext)) ||
((addr >= module_start) && (addr <= module_end))) { ((addr >= module_start) && (addr <= module_end))) {
#ifdef CONFIG_KALLSYMS
print_ip_sym(addr);
#else
if (i && ((i % 8) == 0)) if (i && ((i % 8) == 0))
printk("\n "); pr_err("\n ");
printk("[<%08lx>] ", addr); pr_err("[<%08lx>] ", addr);
i++; i++;
#endif
} }
} }
} }
@ -111,21 +118,21 @@ show_stack(struct task_struct *task, unsigned long *sp)
stack = sp; stack = sp;
printk("\nStack from %08lx:\n ", (unsigned long)stack); pr_err("\nStack from %08lx:\n ", (unsigned long)stack);
for (i = 0; i < kstack_depth_to_print; i++) { for (i = 0; i < kstack_depth_to_print; i++) {
if (((long)stack & (THREAD_SIZE-1)) == 0) if (((long)stack & (THREAD_SIZE-1)) == 0)
break; break;
if (i && ((i % 8) == 0)) if (i && ((i % 8) == 0))
printk("\n "); pr_err("\n ");
if (__get_user(addr, stack)) { if (__get_user(addr, stack)) {
/* This message matches "failing address" marked /* This message matches "failing address" marked
s390 in ksymoops, so lines containing it will s390 in ksymoops, so lines containing it will
not be filtered out by ksymoops. */ not be filtered out by ksymoops. */
printk("Failing address 0x%lx\n", (unsigned long)stack); pr_err("Failing address 0x%lx\n", (unsigned long)stack);
break; break;
} }
stack++; stack++;
printk("%08lx ", addr); pr_err("%08lx ", addr);
} }
show_trace(sp); show_trace(sp);
} }
@ -139,33 +146,32 @@ show_stack(void)
unsigned long *sp = (unsigned long *)rdusp(); unsigned long *sp = (unsigned long *)rdusp();
int i; int i;
printk("Stack dump [0x%08lx]:\n", (unsigned long)sp); pr_err("Stack dump [0x%08lx]:\n", (unsigned long)sp);
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
printk("sp + %d: 0x%08lx\n", i*4, sp[i]); pr_err("sp + %d: 0x%08lx\n", i*4, sp[i]);
return 0; return 0;
} }
#endif #endif
void void set_nmi_handler(void (*handler)(struct pt_regs *))
set_nmi_handler(void (*handler)(struct pt_regs *))
{ {
nmi_handler = handler; nmi_handler = handler;
arch_enable_nmi(); arch_enable_nmi();
} }
#ifdef CONFIG_DEBUG_NMI_OOPS #ifdef CONFIG_DEBUG_NMI_OOPS
void void oops_nmi_handler(struct pt_regs *regs)
oops_nmi_handler(struct pt_regs *regs)
{ {
stop_watchdog(); stop_watchdog();
oops_in_progress = 1; oops_in_progress = 1;
printk("NMI!\n"); pr_err("NMI!\n");
show_registers(regs); show_registers(regs);
oops_in_progress = 0; oops_in_progress = 0;
oops_exit();
pr_err("\n"); /* Flush mtdoops. */
} }
static int __init static int __init oops_nmi_register(void)
oops_nmi_register(void)
{ {
set_nmi_handler(oops_nmi_handler); set_nmi_handler(oops_nmi_handler);
return 0; return 0;
@ -180,8 +186,7 @@ __initcall(oops_nmi_register);
* similar to an Oops dump, and if the kernel is configured to be a nice * similar to an Oops dump, and if the kernel is configured to be a nice
* doggy, then halt instead of reboot. * doggy, then halt instead of reboot.
*/ */
void void watchdog_bite_hook(struct pt_regs *regs)
watchdog_bite_hook(struct pt_regs *regs)
{ {
#ifdef CONFIG_ETRAX_WATCHDOG_NICE_DOGGY #ifdef CONFIG_ETRAX_WATCHDOG_NICE_DOGGY
local_irq_disable(); local_irq_disable();
@ -196,8 +201,7 @@ watchdog_bite_hook(struct pt_regs *regs)
} }
/* This is normally the Oops function. */ /* This is normally the Oops function. */
void void die_if_kernel(const char *str, struct pt_regs *regs, long err)
die_if_kernel(const char *str, struct pt_regs *regs, long err)
{ {
if (user_mode(regs)) if (user_mode(regs))
return; return;
@ -211,13 +215,17 @@ die_if_kernel(const char *str, struct pt_regs *regs, long err)
stop_watchdog(); stop_watchdog();
#endif #endif
oops_enter();
handle_BUG(regs); handle_BUG(regs);
printk("%s: %04lx\n", str, err & 0xffff); pr_err("Linux %s %s\n", utsname()->release, utsname()->version);
pr_err("%s: %04lx\n", str, err & 0xffff);
show_registers(regs); show_registers(regs);
oops_exit();
oops_in_progress = 0; oops_in_progress = 0;
pr_err("\n"); /* Flush mtdoops. */
#ifdef CONFIG_ETRAX_WATCHDOG_NICE_DOGGY #ifdef CONFIG_ETRAX_WATCHDOG_NICE_DOGGY
reset_watchdog(); reset_watchdog();
@ -225,8 +233,7 @@ die_if_kernel(const char *str, struct pt_regs *regs, long err)
do_exit(SIGSEGV); do_exit(SIGSEGV);
} }
void __init void __init trap_init(void)
trap_init(void)
{ {
/* Nothing needs to be done */ /* Nothing needs to be done */
} }

38
arch/cris/mm/init.c
Просмотреть файл

@ -11,13 +11,15 @@
#include <linux/gfp.h> #include <linux/gfp.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/bootmem.h> #include <linux/bootmem.h>
#include <linux/proc_fs.h>
#include <linux/kcore.h>
#include <asm/tlb.h> #include <asm/tlb.h>
#include <asm/sections.h> #include <asm/sections.h>
unsigned long empty_zero_page; unsigned long empty_zero_page;
EXPORT_SYMBOL(empty_zero_page);
void __init void __init mem_init(void)
mem_init(void)
{ {
BUG_ON(!mem_map); BUG_ON(!mem_map);
@ -31,10 +33,36 @@ mem_init(void)
mem_init_print_info(NULL); mem_init_print_info(NULL);
} }
/* free the pages occupied by initialization code */ /* Free a range of init pages. Virtual addresses. */
void void free_init_pages(const char *what, unsigned long begin, unsigned long end)
free_initmem(void) {
unsigned long addr;
for (addr = begin; addr < end; addr += PAGE_SIZE) {
ClearPageReserved(virt_to_page(addr));
init_page_count(virt_to_page(addr));
free_page(addr);
totalram_pages++;
}
printk(KERN_INFO "Freeing %s: %ldk freed\n", what, (end - begin) >> 10);
}
/* Free the pages occupied by initialization code. */
void free_initmem(void)
{ {
free_initmem_default(-1); free_initmem_default(-1);
} }
/* Free the pages occupied by initrd code. */
#ifdef CONFIG_BLK_DEV_INITRD
void free_initrd_mem(unsigned long start, unsigned long end)
{
free_init_pages("initrd memory",
start,
end);
}
#endif

3
arch/cris/mm/ioremap.c
Просмотреть файл

@ -76,10 +76,11 @@ void __iomem * __ioremap(unsigned long phys_addr, unsigned long size, unsigned l
* Must be freed with iounmap. * Must be freed with iounmap.
*/ */
void __iomem *ioremap_nocache (unsigned long phys_addr, unsigned long size) void __iomem *ioremap_nocache(unsigned long phys_addr, unsigned long size)
{ {
return __ioremap(phys_addr | MEM_NON_CACHEABLE, size, 0); return __ioremap(phys_addr | MEM_NON_CACHEABLE, size, 0);
} }
EXPORT_SYMBOL(ioremap_nocache);
void iounmap(volatile void __iomem *addr) void iounmap(volatile void __iomem *addr)
{ {

2
scripts/headers.sh
Просмотреть файл

@ -19,8 +19,6 @@ for arch in ${archs}; do
case ${arch} in case ${arch} in
um) # no userspace export um) # no userspace export
;; ;;
cris) # headers export are known broken
;;
*) *)
if [ -d ${srctree}/arch/${arch} ]; then if [ -d ${srctree}/arch/${arch} ]; then
do_command $1 ${arch} do_command $1 ${arch}