Ticket #3371: old-new.diff

File old-new.diff, 130.4 KB (added by matteo, 9 years ago)

diff against the old and new build tree

  • arch/arm/mach-at91/Kconfig

    diff -urN avr32-old/arch/arm/mach-at91/Kconfig avr32-new/arch/arm/mach-at91/Kconfig
    old new  
    219219          Select this if you need to program one or more of the PCK0..PCK3 
    220220          programmable clock outputs. 
    221221 
     222choice 
     223        prompt "Select a UART for early kernel messages" 
     224 
     225config AT91_EARLY_DBGU 
     226        bool "DBGU" 
     227 
     228config AT91_EARLY_USART0 
     229        bool "USART0" 
     230 
     231config AT91_EARLY_USART1 
     232        bool "USART1" 
     233 
     234config AT91_EARLY_USART2 
     235        bool "USART2" 
     236        depends on ! ARCH_AT91X40 
     237 
     238config AT91_EARLY_USART3 
     239        bool "USART3" 
     240        depends on (ARCH_AT91RM9200 || ARCH_AT91SAM9RL || ARCH_AT91SAM9260) 
     241 
     242config AT91_EARLY_USART4 
     243        bool "USART4" 
     244        depends on ARCH_AT91SAM9260 
     245 
     246config AT91_EARLY_USART5 
     247        bool "USART5" 
     248        depends on ARCH_AT91SAM9260 
     249 
     250endchoice 
     251 
    222252endmenu 
    223253 
    224254endif 
  • arch/avr32/boards/atngw100/setup.c

    diff -urN avr32-old/arch/avr32/boards/atngw100/setup.c avr32-new/arch/avr32/boards/atngw100/setup.c
    old new  
    3737static struct spi_board_info spi0_board_info[] __initdata = { 
    3838        { 
    3939                .modalias       = "mtd_dataflash", 
    40                 .max_speed_hz   = 10000000, 
     40                .max_speed_hz   = 8000000, 
    4141                .chip_select    = 0, 
    4242        }, 
    4343}; 
     
    180180                AT32_GPIOF_MULTIDRV | AT32_GPIOF_OUTPUT | AT32_GPIOF_HIGH); 
    181181        platform_device_register(&i2c_gpio_device); 
    182182#else 
    183         at32_add_device_twi(0); 
     183        at32_add_device_twi(0, NULL, 0); 
    184184#endif 
    185185 
    186186        return 0; 
  • arch/avr32/boards/atstk1000/atstk1002.c

    diff -urN avr32-old/arch/avr32/boards/atstk1000/atstk1002.c avr32-new/arch/avr32/boards/atstk1000/atstk1002.c
    old new  
    241241#ifdef CONFIG_BOARD_ATSTK100X_SPI1 
    242242        at32_add_device_spi(1, spi1_board_info, ARRAY_SIZE(spi1_board_info)); 
    243243#endif 
    244         at32_add_device_twi(0); 
     244        at32_add_device_twi(0, NULL, 0); 
    245245#ifndef CONFIG_BOARD_ATSTK100X_SW2_CUSTOM 
    246246        at32_add_device_mci(0, NULL); 
    247247#endif 
     
    261261        at32_add_device_ssc(0, ATMEL_SSC_TX); 
    262262#endif 
    263263        at32_add_device_cf(0, 2, &cf0_data); 
     264#ifdef CONFIG_BOARD_ATSTK100X_ENABLE_PSIF 
     265        at32_add_device_psif(0); 
     266        at32_add_device_psif(1); 
     267#endif 
    264268 
    265269        atstk1000_setup_j2_leds(); 
    266270        atstk1002_setup_extdac(); 
  • arch/avr32/boards/atstk1000/atstk1003.c

    diff -urN avr32-old/arch/avr32/boards/atstk1000/atstk1003.c avr32-new/arch/avr32/boards/atstk1000/atstk1003.c
    old new  
    172172        at32_add_device_ssc(0, ATMEL_SSC_TX); 
    173173#endif 
    174174        at32_add_device_cf(0, 2, &cf0_data); 
     175#ifdef CONFIG_BOARD_ATSTK100X_ENABLE_PSIF 
     176        at32_add_device_psif(0); 
     177        at32_add_device_psif(1); 
     178#endif 
    175179 
    176180        atstk1000_setup_j2_leds(); 
    177181        atstk1003_setup_extdac(); 
  • arch/avr32/boards/atstk1000/atstk1004.c

    diff -urN avr32-old/arch/avr32/boards/atstk1000/atstk1004.c avr32-new/arch/avr32/boards/atstk1000/atstk1004.c
    old new  
    143143#ifndef CONFIG_BOARD_ATSTK100X_SW3_CUSTOM 
    144144        at32_add_device_ssc(0, ATMEL_SSC_TX); 
    145145#endif 
     146#ifdef CONFIG_BOARD_ATSTK100X_ENABLE_PSIF 
     147        at32_add_device_psif(0); 
     148        at32_add_device_psif(1); 
     149#endif 
    146150 
    147151        atstk1000_setup_j2_leds(); 
    148152        atstk1004_setup_extdac(); 
  • arch/avr32/boards/atstk1000/Kconfig

    diff -urN avr32-old/arch/avr32/boards/atstk1000/Kconfig avr32-new/arch/avr32/boards/atstk1000/Kconfig
    old new  
    145145 
    146146          The default is 0x3e, which is pin 30 on PIOB, aka GPIO15. 
    147147 
     148config BOARD_ATSTK100X_ENABLE_PSIF 
     149        bool "Enable PSIF peripheral (PS/2 support)" 
     150        default n 
     151        help 
     152          Select this if you want to use the PSIF peripheral to hook up PS/2 
     153          devices to your STK1000. This will require a hardware modification to 
     154          work correctly, since PS/2 devices require 5 volt power and signals, 
     155          while the STK1000 only provides 3.3 volt. 
     156 
     157          Say N if you have not modified the hardware to boost the voltage, say 
     158          Y if you have level convertion hardware or a PS/2 device capable of 
     159          operating on 3.3 volt. 
     160 
    148161endif   # stk 1000 
  • arch/avr32/configs/atngw100_defconfig

    diff -urN avr32-old/arch/avr32/configs/atngw100_defconfig avr32-new/arch/avr32/configs/atngw100_defconfig
    old new  
    11# 
    22# Automatically generated make config: don't edit 
    33# Linux kernel version: 2.6.24 
    4 # Tue Feb  5 16:37:27 2008 
     4# Thu Mar  6 12:49:54 2008 
    55# 
    66CONFIG_AVR32=y 
    77CONFIG_GENERIC_GPIO=y 
     
    1313CONFIG_GENERIC_IRQ_PROBE=y 
    1414CONFIG_RWSEM_GENERIC_SPINLOCK=y 
    1515CONFIG_GENERIC_TIME=y 
     16CONFIG_GENERIC_CLOCKEVENTS=y 
    1617# CONFIG_RWSEM_XCHGADD_ALGORITHM is not set 
    1718# CONFIG_ARCH_HAS_ILOG2_U32 is not set 
    1819# CONFIG_ARCH_HAS_ILOG2_U64 is not set 
     
    105106# 
    106107# System Type and features 
    107108# 
     109CONFIG_TICK_ONESHOT=y 
     110CONFIG_NO_HZ=y 
     111CONFIG_HIGH_RES_TIMERS=y 
     112CONFIG_GENERIC_CLOCKEVENTS_BUILD=y 
    108113CONFIG_SUBARCH_AVR32B=y 
    109114CONFIG_MMU=y 
    110115CONFIG_PERFORMANCE_COUNTERS=y 
     
    538543CONFIG_BLK_DEV_RAM_BLOCKSIZE=1024 
    539544# CONFIG_CDROM_PKTCDVD is not set 
    540545# CONFIG_ATA_OVER_ETH is not set 
    541 # CONFIG_MISC_DEVICES is not set 
     546CONFIG_MISC_DEVICES=y 
     547# CONFIG_ATMEL_PWM is not set 
     548CONFIG_ATMEL_TCLIB=y 
     549CONFIG_ATMEL_TCB_CLKSRC=y 
     550CONFIG_ATMEL_TCB_CLKSRC_BLOCK=0 
     551# CONFIG_EEPROM_93CX6 is not set 
     552# CONFIG_ATMEL_SSC is not set 
    542553# CONFIG_IDE is not set 
    543554 
    544555# 
  • arch/avr32/configs/atstk1002_defconfig

    diff -urN avr32-old/arch/avr32/configs/atstk1002_defconfig avr32-new/arch/avr32/configs/atstk1002_defconfig
    old new  
    11# 
    22# Automatically generated make config: don't edit 
    33# Linux kernel version: 2.6.24 
    4 # Tue Feb  5 18:00:06 2008 
     4# Thu Mar  6 12:49:17 2008 
    55# 
    66CONFIG_AVR32=y 
    77CONFIG_GENERIC_GPIO=y 
     
    1313CONFIG_GENERIC_IRQ_PROBE=y 
    1414CONFIG_RWSEM_GENERIC_SPINLOCK=y 
    1515CONFIG_GENERIC_TIME=y 
     16CONFIG_GENERIC_CLOCKEVENTS=y 
    1617# CONFIG_RWSEM_XCHGADD_ALGORITHM is not set 
    1718# CONFIG_ARCH_HAS_ILOG2_U32 is not set 
    1819# CONFIG_ARCH_HAS_ILOG2_U64 is not set 
     
    102103# 
    103104# System Type and features 
    104105# 
     106CONFIG_TICK_ONESHOT=y 
     107CONFIG_NO_HZ=y 
     108CONFIG_HIGH_RES_TIMERS=y 
     109CONFIG_GENERIC_CLOCKEVENTS_BUILD=y 
    105110CONFIG_SUBARCH_AVR32B=y 
    106111CONFIG_MMU=y 
    107112CONFIG_PERFORMANCE_COUNTERS=y 
     
    121126CONFIG_BOARD_ATSTK1000_EXTDAC=y 
    122127# CONFIG_BOARD_ATSTK100X_ENABLE_AC97 is not set 
    123128# CONFIG_BOARD_ATSTK1000_CF_HACKS is not set 
     129# CONFIG_BOARD_ATSTK100X_ENABLE_PSIF is not set 
    124130CONFIG_LOADER_U_BOOT=y 
    125131 
    126132# 
     
    405411# CONFIG_ATA_OVER_ETH is not set 
    406412CONFIG_MISC_DEVICES=y 
    407413CONFIG_ATMEL_PWM=m 
     414CONFIG_ATMEL_TCLIB=y 
     415CONFIG_ATMEL_TCB_CLKSRC=y 
     416CONFIG_ATMEL_TCB_CLKSRC_BLOCK=0 
    408417# CONFIG_EEPROM_93CX6 is not set 
    409418CONFIG_ATMEL_SSC=m 
    410419# CONFIG_IDE is not set 
  • arch/avr32/configs/atstk1003_defconfig

    diff -urN avr32-old/arch/avr32/configs/atstk1003_defconfig avr32-new/arch/avr32/configs/atstk1003_defconfig
    old new  
    11# 
    22# Automatically generated make config: don't edit 
    33# Linux kernel version: 2.6.24 
    4 # Tue Feb  5 18:08:36 2008 
     4# Thu Mar  6 12:50:27 2008 
    55# 
    66CONFIG_AVR32=y 
    77CONFIG_GENERIC_GPIO=y 
     
    1313CONFIG_GENERIC_IRQ_PROBE=y 
    1414CONFIG_RWSEM_GENERIC_SPINLOCK=y 
    1515CONFIG_GENERIC_TIME=y 
     16CONFIG_GENERIC_CLOCKEVENTS=y 
    1617# CONFIG_RWSEM_XCHGADD_ALGORITHM is not set 
    1718# CONFIG_ARCH_HAS_ILOG2_U32 is not set 
    1819# CONFIG_ARCH_HAS_ILOG2_U64 is not set 
     
    107108# 
    108109# System Type and features 
    109110# 
     111CONFIG_TICK_ONESHOT=y 
     112CONFIG_NO_HZ=y 
     113CONFIG_HIGH_RES_TIMERS=y 
     114CONFIG_GENERIC_CLOCKEVENTS_BUILD=y 
    110115CONFIG_SUBARCH_AVR32B=y 
    111116CONFIG_MMU=y 
    112117CONFIG_PERFORMANCE_COUNTERS=y 
     
    126131CONFIG_BOARD_ATSTK1000_EXTDAC=y 
    127132# CONFIG_BOARD_ATSTK100X_ENABLE_AC97 is not set 
    128133# CONFIG_BOARD_ATSTK1000_CF_HACKS is not set 
     134# CONFIG_BOARD_ATSTK100X_ENABLE_PSIF is not set 
    129135CONFIG_LOADER_U_BOOT=y 
    130136 
    131137# 
     
    386392# CONFIG_ATA_OVER_ETH is not set 
    387393CONFIG_MISC_DEVICES=y 
    388394CONFIG_ATMEL_PWM=m 
     395CONFIG_ATMEL_TCLIB=y 
     396CONFIG_ATMEL_TCB_CLKSRC=y 
     397CONFIG_ATMEL_TCB_CLKSRC_BLOCK=0 
    389398# CONFIG_EEPROM_93CX6 is not set 
    390399CONFIG_ATMEL_SSC=m 
    391400# CONFIG_IDE is not set 
  • arch/avr32/configs/atstk1004_defconfig

    diff -urN avr32-old/arch/avr32/configs/atstk1004_defconfig avr32-new/arch/avr32/configs/atstk1004_defconfig
    old new  
    11# 
    22# Automatically generated make config: don't edit 
    33# Linux kernel version: 2.6.24 
    4 # Tue Feb  5 18:13:33 2008 
     4# Thu Mar  6 12:51:05 2008 
    55# 
    66CONFIG_AVR32=y 
    77CONFIG_GENERIC_GPIO=y 
     
    1313CONFIG_GENERIC_IRQ_PROBE=y 
    1414CONFIG_RWSEM_GENERIC_SPINLOCK=y 
    1515CONFIG_GENERIC_TIME=y 
     16CONFIG_GENERIC_CLOCKEVENTS=y 
    1617# CONFIG_RWSEM_XCHGADD_ALGORITHM is not set 
    1718# CONFIG_ARCH_HAS_ILOG2_U32 is not set 
    1819# CONFIG_ARCH_HAS_ILOG2_U64 is not set 
     
    7273# 
    7374# System Type and features 
    7475# 
     76CONFIG_TICK_ONESHOT=y 
     77CONFIG_NO_HZ=y 
     78CONFIG_HIGH_RES_TIMERS=y 
     79CONFIG_GENERIC_CLOCKEVENTS_BUILD=y 
    7580CONFIG_SUBARCH_AVR32B=y 
    7681CONFIG_MMU=y 
    7782CONFIG_PERFORMANCE_COUNTERS=y 
     
    8994CONFIG_BOARD_ATSTK1000_EXTDAC=y 
    9095# CONFIG_BOARD_ATSTK100X_ENABLE_AC97 is not set 
    9196# CONFIG_BOARD_ATSTK1000_CF_HACKS is not set 
     97# CONFIG_BOARD_ATSTK100X_ENABLE_PSIF is not set 
    9298CONFIG_LOADER_U_BOOT=y 
    9399 
    94100# 
     
    325331# 
    326332# CONFIG_MTD_UBI is not set 
    327333# CONFIG_PARPORT is not set 
    328 # CONFIG_MISC_DEVICES is not set 
     334CONFIG_MISC_DEVICES=y 
     335# CONFIG_ATMEL_PWM is not set 
     336CONFIG_ATMEL_TCLIB=y 
     337CONFIG_ATMEL_TCB_CLKSRC=y 
     338CONFIG_ATMEL_TCB_CLKSRC_BLOCK=0 
     339# CONFIG_EEPROM_93CX6 is not set 
     340# CONFIG_ATMEL_SSC is not set 
    329341 
    330342# 
    331343# SCSI device support 
  • arch/avr32/Kconfig

    diff -urN avr32-old/arch/avr32/Kconfig avr32-new/arch/avr32/Kconfig
    old new  
    4545config GENERIC_TIME 
    4646        def_bool y 
    4747 
     48config GENERIC_CLOCKEVENTS 
     49        def_bool y 
     50 
    4851config RWSEM_XCHGADD_ALGORITHM 
    4952        def_bool n 
    5053 
     
    7174 
    7275menu "System Type and features" 
    7376 
     77source "kernel/time/Kconfig" 
     78 
    7479config SUBARCH_AVR32B 
    7580        bool 
    7681config MMU 
  • arch/avr32/kernel/entry-avr32b.S

    diff -urN avr32-old/arch/avr32/kernel/entry-avr32b.S avr32-new/arch/avr32/kernel/entry-avr32b.S
    old new  
    741741 
    742742        .section .irq.text,"ax",@progbits 
    743743 
    744 .global cpu_idle_sleep 
    745 cpu_idle_sleep: 
    746         mask_interrupts 
    747         get_thread_info r8 
    748         ld.w    r9, r8[TI_flags] 
    749         bld     r9, TIF_NEED_RESCHED 
    750         brcs    cpu_idle_enable_int_and_exit 
    751         sbr     r9, TIF_CPU_GOING_TO_SLEEP 
    752         st.w    r8[TI_flags], r9 
    753         unmask_interrupts 
    754         sleep 0 
    755 cpu_idle_skip_sleep: 
    756         mask_interrupts 
    757         ld.w    r9, r8[TI_flags] 
    758         cbr     r9, TIF_CPU_GOING_TO_SLEEP 
    759         st.w    r8[TI_flags], r9 
    760 cpu_idle_enable_int_and_exit: 
    761         unmask_interrupts 
    762         retal   r12 
    763  
    764744        .global irq_level0 
    765745        .global irq_level1 
    766746        .global irq_level2 
  • arch/avr32/kernel/process.c

    diff -urN avr32-old/arch/avr32/kernel/process.c avr32-new/arch/avr32/kernel/process.c
    old new  
    1111#include <linux/fs.h> 
    1212#include <linux/ptrace.h> 
    1313#include <linux/reboot.h> 
     14#include <linux/tick.h> 
    1415#include <linux/uaccess.h> 
    1516#include <linux/unistd.h> 
    1617 
    1718#include <asm/sysreg.h> 
    1819#include <asm/ocd.h> 
    1920 
     21#include <asm/arch/pm.h> 
     22 
    2023void (*pm_power_off)(void) = NULL; 
    2124EXPORT_SYMBOL(pm_power_off); 
    2225 
    23 extern void cpu_idle_sleep(void); 
    24  
    2526/* 
    2627 * This file handles the architecture-dependent parts of process handling.. 
    2728 */ 
     
    3031{ 
    3132        /* endless idle loop with no priority at all */ 
    3233        while (1) { 
     34                tick_nohz_stop_sched_tick(); 
    3335                while (!need_resched()) 
    3436                        cpu_idle_sleep(); 
     37                tick_nohz_restart_sched_tick(); 
    3538                preempt_enable_no_resched(); 
    3639                schedule(); 
    3740                preempt_disable(); 
     
    345348        p->thread.cpu_context.ksp = (unsigned long)childregs; 
    346349        p->thread.cpu_context.pc = (unsigned long)ret_from_fork; 
    347350 
     351        clear_tsk_thread_flag(p, TIF_DEBUG); 
    348352        if ((clone_flags & CLONE_PTRACE) && test_thread_flag(TIF_DEBUG)) 
    349353                ocd_enable(p); 
    350354 
  • arch/avr32/kernel/time.c

    diff -urN avr32-old/arch/avr32/kernel/time.c avr32-new/arch/avr32/kernel/time.c
    old new  
    11/* 
    22 * Copyright (C) 2004-2007 Atmel Corporation 
    33 * 
    4  * Based on MIPS implementation arch/mips/kernel/time.c 
    5  *   Copyright 2001 MontaVista Software Inc. 
    6  * 
    74 * This program is free software; you can redistribute it and/or modify 
    85 * it under the terms of the GNU General Public License version 2 as 
    96 * published by the Free Software Foundation. 
    107 */ 
    11  
    128#include <linux/clk.h> 
    13 #include <linux/clocksource.h> 
     9#include <linux/clockchips.h> 
    1410#include <linux/time.h> 
    1511#include <linux/module.h> 
    1612#include <linux/interrupt.h> 
     
    2723#include <asm/io.h> 
    2824#include <asm/sections.h> 
    2925 
    30 /* how many counter cycles in a jiffy? */ 
    31 static u32 cycles_per_jiffy; 
     26#include <asm/arch/pm.h> 
    3227 
    33 /* the count value for the next timer interrupt */ 
    34 static u32 expirelo; 
    3528 
    36 cycle_t __weak read_cycle_count(void) 
     29static cycle_t read_cycle_count(void) 
    3730{ 
    3831        return (cycle_t)sysreg_read(COUNT); 
    3932} 
    4033 
    41 struct clocksource __weak clocksource_avr32 = { 
    42         .name           = "avr32", 
    43         .rating         = 350, 
     34/* 
     35 * The architectural cycle count registers are a fine clocksource unless 
     36 * the system idle loop use sleep states like "idle":  the CPU cycles 
     37 * measured by COUNT (and COMPARE) don't happen during sleep states. 
     38 * Their duration also changes if cpufreq changes the CPU clock rate. 
     39 * So we rate the clocksource using COUNT as very low quality. 
     40 */ 
     41static struct clocksource counter = { 
     42        .name           = "avr32_counter", 
     43        .rating         = 50, 
    4444        .read           = read_cycle_count, 
    4545        .mask           = CLOCKSOURCE_MASK(32), 
    4646        .shift          = 16, 
    4747        .flags          = CLOCK_SOURCE_IS_CONTINUOUS, 
    4848}; 
    4949 
    50 irqreturn_t __weak timer_interrupt(int irq, void *dev_id); 
    51  
    52 struct irqaction timer_irqaction = { 
    53         .handler        = timer_interrupt, 
    54         .flags          = IRQF_DISABLED, 
    55         .name           = "timer", 
    56 }; 
    57  
    58 /* 
    59  * By default we provide the null RTC ops 
    60  */ 
    61 static unsigned long null_rtc_get_time(void) 
     50static irqreturn_t timer_interrupt(int irq, void *dev_id) 
    6251{ 
    63         return mktime(2007, 1, 1, 0, 0, 0); 
    64 } 
    65  
    66 static int null_rtc_set_time(unsigned long sec) 
    67 { 
    68         return 0; 
    69 } 
     52        struct clock_event_device *evdev = dev_id; 
    7053 
    71 static unsigned long (*rtc_get_time)(void) = null_rtc_get_time; 
    72 static int (*rtc_set_time)(unsigned long) = null_rtc_set_time; 
    73  
    74 static void avr32_timer_ack(void) 
    75 { 
    76         u32 count; 
    77  
    78         /* Ack this timer interrupt and set the next one */ 
    79         expirelo += cycles_per_jiffy; 
    80         /* setting COMPARE to 0 stops the COUNT-COMPARE */ 
    81         if (expirelo == 0) { 
    82                 sysreg_write(COMPARE, expirelo + 1); 
    83         } else { 
    84                 sysreg_write(COMPARE, expirelo); 
    85         } 
     54        /* 
     55         * Disable the interrupt until the clockevent subsystem 
     56         * reprograms it. 
     57         */ 
     58        sysreg_write(COMPARE, 0); 
    8659 
    87         /* Check to see if we have missed any timer interrupts */ 
    88         count = sysreg_read(COUNT); 
    89         if ((count - expirelo) < 0x7fffffff) { 
    90                 expirelo = count + cycles_per_jiffy; 
    91                 sysreg_write(COMPARE, expirelo); 
    92         } 
     60        evdev->event_handler(evdev); 
     61        return IRQ_HANDLED; 
    9362} 
    9463 
    95 int __weak avr32_hpt_init(void) 
    96 { 
    97         int ret; 
    98         unsigned long mult, shift, count_hz; 
    99  
    100         count_hz = clk_get_rate(boot_cpu_data.clk); 
    101         shift = clocksource_avr32.shift; 
    102         mult = clocksource_hz2mult(count_hz, shift); 
    103         clocksource_avr32.mult = mult; 
    104  
    105         { 
    106                 u64 tmp; 
    107  
    108                 tmp = TICK_NSEC; 
    109                 tmp <<= shift; 
    110                 tmp += mult / 2; 
    111                 do_div(tmp, mult); 
    112  
    113                 cycles_per_jiffy = tmp; 
    114         } 
     64static struct irqaction timer_irqaction = { 
     65        .handler        = timer_interrupt, 
     66        .flags          = IRQF_TIMER | IRQF_DISABLED, 
     67        .name           = "avr32_comparator", 
     68}; 
    11569 
    116         ret = setup_irq(0, &timer_irqaction); 
    117         if (ret) { 
    118                 pr_debug("timer: could not request IRQ 0: %d\n", ret); 
    119                 return -ENODEV; 
    120         } 
     70static int comparator_next_event(unsigned long delta, 
     71                struct clock_event_device *evdev) 
     72{ 
     73        unsigned long   flags; 
    12174 
    122         printk(KERN_INFO "timer: AT32AP COUNT-COMPARE at irq 0, " 
    123                         "%lu.%03lu MHz\n", 
    124                         ((count_hz + 500) / 1000) / 1000, 
    125                         ((count_hz + 500) / 1000) % 1000); 
     75        raw_local_irq_save(flags); 
    12676 
    127         return 0; 
    128 } 
     77        /* The time to read COUNT then update COMPARE must be less 
     78         * than the min_delta_ns value for this clockevent source. 
     79         */ 
     80        sysreg_write(COMPARE, (sysreg_read(COUNT) + delta) ? : 1); 
    12981 
    130 /* 
    131  * Taken from MIPS c0_hpt_timer_init(). 
    132  * 
    133  * The reason COUNT is written twice is probably to make sure we don't get any 
    134  * timer interrupts while we are messing with the counter. 
    135  */ 
    136 int __weak avr32_hpt_start(void) 
    137 { 
    138         u32 count = sysreg_read(COUNT); 
    139         expirelo = (count / cycles_per_jiffy + 1) * cycles_per_jiffy; 
    140         sysreg_write(COUNT, expirelo - cycles_per_jiffy); 
    141         sysreg_write(COMPARE, expirelo); 
    142         sysreg_write(COUNT, count); 
     82        raw_local_irq_restore(flags); 
    14383 
    14484        return 0; 
    14585} 
    14686 
    147 /* 
    148  * local_timer_interrupt() does profiling and process accounting on a 
    149  * per-CPU basis. 
    150  * 
    151  * In UP mode, it is invoked from the (global) timer_interrupt. 
    152  */ 
    153 void local_timer_interrupt(int irq, void *dev_id) 
     87static void comparator_mode(enum clock_event_mode mode, 
     88                struct clock_event_device *evdev) 
    15489{ 
    155         if (current->pid) 
    156                 profile_tick(CPU_PROFILING); 
    157         update_process_times(user_mode(get_irq_regs())); 
     90        switch (mode) { 
     91        case CLOCK_EVT_MODE_ONESHOT: 
     92                pr_debug("%s: start\n", evdev->name); 
     93                /* FALLTHROUGH */ 
     94        case CLOCK_EVT_MODE_RESUME: 
     95                cpu_disable_idle_sleep(); 
     96                break; 
     97        case CLOCK_EVT_MODE_UNUSED: 
     98        case CLOCK_EVT_MODE_SHUTDOWN: 
     99                sysreg_write(COMPARE, 0); 
     100                pr_debug("%s: stop\n", evdev->name); 
     101                cpu_enable_idle_sleep(); 
     102                break; 
     103        default: 
     104                BUG(); 
     105        } 
    158106} 
    159107 
    160 irqreturn_t __weak timer_interrupt(int irq, void *dev_id) 
    161 { 
    162         /* ack timer interrupt and try to set next interrupt */ 
    163         avr32_timer_ack(); 
    164  
    165         /* 
    166          * Call the generic timer interrupt handler 
    167          */ 
    168         write_seqlock(&xtime_lock); 
    169         do_timer(1); 
    170         write_sequnlock(&xtime_lock); 
    171  
    172         /* 
    173          * In UP mode, we call local_timer_interrupt() to do profiling 
    174          * and process accounting. 
    175          * 
    176          * SMP is not supported yet. 
    177          */ 
    178         local_timer_interrupt(irq, dev_id); 
    179  
    180         return IRQ_HANDLED; 
    181 } 
     108static struct clock_event_device comparator = { 
     109        .name           = "avr32_comparator", 
     110        .features       = CLOCK_EVT_FEAT_ONESHOT, 
     111        .shift          = 16, 
     112        .rating         = 50, 
     113        .cpumask        = CPU_MASK_CPU0, 
     114        .set_next_event = comparator_next_event, 
     115        .set_mode       = comparator_mode, 
     116}; 
    182117 
    183118void __init time_init(void) 
    184119{ 
     120        unsigned long counter_hz; 
    185121        int ret; 
    186122 
    187         /* 
    188          * Make sure we don't get any COMPARE interrupts before we can 
    189          * handle them. 
    190          */ 
    191         sysreg_write(COMPARE, 0); 
    192  
    193         xtime.tv_sec = rtc_get_time(); 
     123        xtime.tv_sec = mktime(2007, 1, 1, 0, 0, 0); 
    194124        xtime.tv_nsec = 0; 
    195125 
    196126        set_normalized_timespec(&wall_to_monotonic, 
    197127                                -xtime.tv_sec, -xtime.tv_nsec); 
    198128 
    199         ret = avr32_hpt_init(); 
    200         if (ret) { 
    201                 pr_debug("timer: failed setup: %d\n", ret); 
    202                 return; 
    203         } 
     129        /* figure rate for counter */ 
     130        counter_hz = clk_get_rate(boot_cpu_data.clk); 
     131        counter.mult = clocksource_hz2mult(counter_hz, counter.shift); 
    204132 
    205         ret = clocksource_register(&clocksource_avr32); 
     133        ret = clocksource_register(&counter); 
    206134        if (ret) 
    207135                pr_debug("timer: could not register clocksource: %d\n", ret); 
    208136 
    209         ret = avr32_hpt_start(); 
    210         if (ret) { 
    211                 pr_debug("timer: failed starting: %d\n", ret); 
    212                 return; 
    213         } 
    214 } 
     137        /* setup COMPARE clockevent */ 
     138        comparator.mult = div_sc(counter_hz, NSEC_PER_SEC, comparator.shift); 
     139        comparator.max_delta_ns = clockevent_delta2ns((u32)~0, &comparator); 
     140        comparator.min_delta_ns = clockevent_delta2ns(50, &comparator) + 1; 
    215141 
    216 static struct sysdev_class timer_class = { 
    217         set_kset_name("timer"), 
    218 }; 
     142        sysreg_write(COMPARE, 0); 
     143        timer_irqaction.dev_id = &comparator; 
    219144 
    220 static struct sys_device timer_device = { 
    221         .id     = 0, 
    222         .cls    = &timer_class, 
    223 }; 
     145        ret = setup_irq(0, &timer_irqaction); 
     146        if (ret) 
     147                pr_debug("timer: could not request IRQ 0: %d\n", ret); 
     148        else { 
     149                clockevents_register_device(&comparator); 
    224150 
    225 static int __init init_timer_sysfs(void) 
    226 { 
    227         int err = sysdev_class_register(&timer_class); 
    228         if (!err) 
    229                 err = sysdev_register(&timer_device); 
    230         return err; 
     151                pr_info("%s: irq 0, %lu.%03lu MHz\n", comparator.name, 
     152                                ((counter_hz + 500) / 1000) / 1000, 
     153                                ((counter_hz + 500) / 1000) % 1000); 
     154        } 
    231155} 
    232  
    233 device_initcall(init_timer_sysfs); 
  • arch/avr32/mach-at32ap/at32ap700x.c

    diff -urN avr32-old/arch/avr32/mach-at32ap/at32ap700x.c avr32-new/arch/avr32/mach-at32ap/at32ap700x.c
    old new  
    1111#include <linux/platform_device.h> 
    1212#include <linux/dma-mapping.h> 
    1313#include <linux/spi/spi.h> 
     14#include <linux/usb/atmel_usba_udc.h> 
    1415 
    1516#include <asm/io.h> 
    1617#include <asm/irq.h> 
     
    605606} 
    606607 
    607608/* -------------------------------------------------------------------- 
    608  *  System Timer/Counter (TC) 
     609 *  Timer/Counter (TC) 
    609610 * -------------------------------------------------------------------- */ 
    610 static struct resource at32_systc0_resource[] = { 
     611 
     612static struct resource at32_tcb0_resource[] = { 
    611613        PBMEM(0xfff00c00), 
    612614        IRQ(22), 
    613615}; 
    614 struct platform_device at32_systc0_device = { 
    615         .name           = "systc", 
     616static struct platform_device at32_tcb0_device = { 
     617        .name           = "atmel_tcb", 
    616618        .id             = 0, 
    617         .resource       = at32_systc0_resource, 
    618         .num_resources  = ARRAY_SIZE(at32_systc0_resource), 
     619        .resource       = at32_tcb0_resource, 
     620        .num_resources  = ARRAY_SIZE(at32_tcb0_resource), 
     621}; 
     622DEV_CLK(t0_clk, at32_tcb0, pbb, 3); 
     623 
     624static struct resource at32_tcb1_resource[] = { 
     625        PBMEM(0xfff01000), 
     626        IRQ(23), 
     627}; 
     628static struct platform_device at32_tcb1_device = { 
     629        .name           = "atmel_tcb", 
     630        .id             = 1, 
     631        .resource       = at32_tcb1_resource, 
     632        .num_resources  = ARRAY_SIZE(at32_tcb1_resource), 
    619633}; 
    620 DEV_CLK(pclk, at32_systc0, pbb, 3); 
     634DEV_CLK(t0_clk, at32_tcb1, pbb, 4); 
    621635 
    622636/* -------------------------------------------------------------------- 
    623637 *  PIO 
     
    669683        platform_device_register(&pdc_device); 
    670684        platform_device_register(&dmaca0_device); 
    671685 
    672         platform_device_register(&at32_systc0_device); 
     686        platform_device_register(&at32_tcb0_device); 
     687        platform_device_register(&at32_tcb1_device); 
    673688 
    674689        platform_device_register(&pio0_device); 
    675690        platform_device_register(&pio1_device); 
     
    679694} 
    680695 
    681696/* -------------------------------------------------------------------- 
     697 *  PSIF 
     698 * -------------------------------------------------------------------- */ 
     699static struct resource atmel_psif0_resource[] __initdata = { 
     700        { 
     701                .start  = 0xffe03c00, 
     702                .end    = 0xffe03cff, 
     703                .flags  = IORESOURCE_MEM, 
     704        }, 
     705        IRQ(18), 
     706}; 
     707static struct clk atmel_psif0_pclk = { 
     708        .name           = "pclk", 
     709        .parent         = &pba_clk, 
     710        .mode           = pba_clk_mode, 
     711        .get_rate       = pba_clk_get_rate, 
     712        .index          = 15, 
     713}; 
     714 
     715static struct resource atmel_psif1_resource[] __initdata = { 
     716        { 
     717                .start  = 0xffe03d00, 
     718                .end    = 0xffe03dff, 
     719                .flags  = IORESOURCE_MEM, 
     720        }, 
     721        IRQ(18), 
     722}; 
     723static struct clk atmel_psif1_pclk = { 
     724        .name           = "pclk", 
     725        .parent         = &pba_clk, 
     726        .mode           = pba_clk_mode, 
     727        .get_rate       = pba_clk_get_rate, 
     728        .index          = 15, 
     729}; 
     730 
     731struct platform_device *__init at32_add_device_psif(unsigned int id) 
     732{ 
     733        struct platform_device *pdev; 
     734 
     735        if (!(id == 0 || id == 1)) 
     736                return NULL; 
     737 
     738        pdev = platform_device_alloc("atmel_psif", id); 
     739        if (!pdev) 
     740                return NULL; 
     741 
     742        switch (id) { 
     743        case 0: 
     744                if (platform_device_add_resources(pdev, atmel_psif0_resource, 
     745                                        ARRAY_SIZE(atmel_psif0_resource))) 
     746                        goto err_add_resources; 
     747                atmel_psif0_pclk.dev = &pdev->dev; 
     748                select_peripheral(PA(8), PERIPH_A, 0); /* CLOCK */ 
     749                select_peripheral(PA(9), PERIPH_A, 0); /* DATA  */ 
     750                break; 
     751        case 1: 
     752                if (platform_device_add_resources(pdev, atmel_psif1_resource, 
     753                                        ARRAY_SIZE(atmel_psif1_resource))) 
     754                        goto err_add_resources; 
     755                atmel_psif1_pclk.dev = &pdev->dev; 
     756                select_peripheral(PB(11), PERIPH_A, 0); /* CLOCK */ 
     757                select_peripheral(PB(12), PERIPH_A, 0); /* DATA  */ 
     758                break; 
     759        default: 
     760                return NULL; 
     761        } 
     762 
     763        platform_device_add(pdev); 
     764        return pdev; 
     765 
     766err_add_resources: 
     767        platform_device_put(pdev); 
     768        return NULL; 
     769} 
     770 
     771/* -------------------------------------------------------------------- 
    682772 *  USART 
    683773 * -------------------------------------------------------------------- */ 
    684774 
     
    9891079        .index          = 2, 
    9901080}; 
    9911081 
    992 struct platform_device *__init at32_add_device_twi(unsigned int id) 
     1082struct platform_device *__init at32_add_device_twi(unsigned int id, 
     1083                                                    struct i2c_board_info *b, 
     1084                                                    unsigned int n) 
    9931085{ 
    9941086        struct platform_device *pdev; 
    9951087 
     
    10091101 
    10101102        atmel_twi0_pclk.dev = &pdev->dev; 
    10111103 
     1104        if (b) 
     1105                i2c_register_board_info(id, b, n); 
     1106 
    10121107        platform_device_add(pdev); 
    10131108        return pdev; 
    10141109 
     
    13631458        .index          = 6, 
    13641459}; 
    13651460 
     1461#define EP(nam, idx, maxpkt, maxbk, dma, isoc)                  \ 
     1462        [idx] = {                                               \ 
     1463                .name           = nam,                          \ 
     1464                .index          = idx,                          \ 
     1465                .fifo_size      = maxpkt,                       \ 
     1466                .nr_banks       = maxbk,                        \ 
     1467                .can_dma        = dma,                          \ 
     1468                .can_isoc       = isoc,                         \ 
     1469        } 
     1470 
     1471static struct usba_ep_data at32_usba_ep[] __initdata = { 
     1472        EP("ep0",     0,   64, 1, 0, 0), 
     1473        EP("ep1",     1,  512, 2, 1, 1), 
     1474        EP("ep2",     2,  512, 2, 1, 1), 
     1475        EP("ep3-int", 3,   64, 3, 1, 0), 
     1476        EP("ep4-int", 4,   64, 3, 1, 0), 
     1477        EP("ep5",     5, 1024, 3, 1, 1), 
     1478        EP("ep6",     6, 1024, 3, 1, 1), 
     1479}; 
     1480 
     1481#undef EP 
     1482 
    13661483struct platform_device *__init 
    13671484at32_add_device_usba(unsigned int id, struct usba_platform_data *data) 
    13681485{ 
     1486        /* 
     1487         * pdata doesn't have room for any endpoints, so we need to 
     1488         * append room for the ones we need right after it. 
     1489         */ 
     1490        struct { 
     1491                struct usba_platform_data pdata; 
     1492                struct usba_ep_data ep[7]; 
     1493        } usba_data; 
    13691494        struct platform_device *pdev; 
    13701495 
    13711496        if (id != 0) 
     
    13791504                                          ARRAY_SIZE(usba0_resource))) 
    13801505                goto out_free_pdev; 
    13811506 
    1382         if (data) { 
    1383                 if (platform_device_add_data(pdev, data, sizeof(*data))) 
    1384                         goto out_free_pdev; 
     1507        if (data) 
     1508                usba_data.pdata.vbus_pin = data->vbus_pin; 
     1509        else 
     1510                usba_data.pdata.vbus_pin = -EINVAL; 
    13851511 
    1386                 if (data->vbus_pin != GPIO_PIN_NONE) 
    1387                         at32_select_gpio(data->vbus_pin, 0); 
    1388         } 
     1512        data = &usba_data.pdata; 
     1513        data->num_ep = ARRAY_SIZE(at32_usba_ep); 
     1514        memcpy(data->ep, at32_usba_ep, sizeof(at32_usba_ep)); 
     1515 
     1516        if (platform_device_add_data(pdev, data, sizeof(usba_data))) 
     1517                goto out_free_pdev; 
     1518 
     1519        if (data->vbus_pin >= 0) 
     1520                at32_select_gpio(data->vbus_pin, 0); 
    13891521 
    13901522        usba0_pclk.dev = &pdev->dev; 
    13911523        usba0_hclk.dev = &pdev->dev; 
     
    17061838        &pio2_mck, 
    17071839        &pio3_mck, 
    17081840        &pio4_mck, 
    1709         &at32_systc0_pclk, 
     1841        &at32_tcb0_t0_clk, 
     1842        &at32_tcb1_t0_clk, 
     1843        &atmel_psif0_pclk, 
     1844        &atmel_psif1_pclk, 
    17101845        &atmel_usart0_usart, 
    17111846        &atmel_usart1_usart, 
    17121847        &atmel_usart2_usart, 
  • arch/avr32/mach-at32ap/intc.c

    diff -urN avr32-old/arch/avr32/mach-at32ap/intc.c avr32-new/arch/avr32/mach-at32ap/intc.c
    old new  
    1313#include <linux/irq.h> 
    1414#include <linux/platform_device.h> 
    1515 
    16 #include <asm/intc.h> 
    1716#include <asm/io.h> 
    1817 
    1918#include "intc.h" 
  • arch/avr32/mach-at32ap/Makefile

    diff -urN avr32-old/arch/avr32/mach-at32ap/Makefile avr32-new/arch/avr32/mach-at32ap/Makefile
    old new  
    11obj-y                           += at32ap.o clock.o intc.o extint.o pio.o hsmc.o 
    2 obj-$(CONFIG_CPU_AT32AP700X)    += at32ap700x.o 
    3 obj-$(CONFIG_CPU_AT32AP700X)    += time-tc.o 
     2obj-$(CONFIG_CPU_AT32AP700X)    += at32ap700x.o pm-at32ap700x.o 
    43obj-$(CONFIG_CPU_FREQ_AT32AP)   += cpufreq.o 
    54obj-$(CONFIG_GPIO_DEV)          += gpio-dev.o 
  • arch/avr32/mach-at32ap/pm-at32ap700x.S

    diff -urN avr32-old/arch/avr32/mach-at32ap/pm-at32ap700x.S avr32-new/arch/avr32/mach-at32ap/pm-at32ap700x.S
    old new  
     1/* 
     2 * Low-level Power Management code. 
     3 * 
     4 * Copyright (C) 2008 Atmel Corporation 
     5 * 
     6 * This program is free software; you can redistribute it and/or modify 
     7 * it under the terms of the GNU General Public License version 2 as 
     8 * published by the Free Software Foundation. 
     9 */ 
     10#include <asm/asm.h> 
     11#include <asm/asm-offsets.h> 
     12#include <asm/thread_info.h> 
     13#include <asm/arch/pm.h> 
     14 
     15        .section .bss, "wa", @nobits 
     16        .global disable_idle_sleep 
     17        .type   disable_idle_sleep, @object 
     18disable_idle_sleep: 
     19        .int    4 
     20        .size   disable_idle_sleep, . - disable_idle_sleep 
     21 
     22        /* Keep this close to the irq handlers */ 
     23        .section .irq.text, "ax", @progbits 
     24 
     25        /* 
     26         * void cpu_enter_idle(void) 
     27         * 
     28         * Put the CPU into "idle" mode, in which it will consume 
     29         * significantly less power. 
     30         * 
     31         * If an interrupt comes along in the window between 
     32         * unmask_interrupts and the sleep instruction below, the 
     33         * interrupt code will adjust the return address so that we 
     34         * never execute the sleep instruction. This is required 
     35         * because the AP7000 doesn't unmask interrupts when entering 
     36         * sleep modes; later CPUs may not need this workaround. 
     37         */ 
     38        .global cpu_enter_idle 
     39        .type   cpu_enter_idle, @function 
     40cpu_enter_idle: 
     41        mask_interrupts 
     42        get_thread_info r8 
     43        ld.w    r9, r8[TI_flags] 
     44        bld     r9, TIF_NEED_RESCHED 
     45        brcs    .Lret_from_sleep 
     46        sbr     r9, TIF_CPU_GOING_TO_SLEEP 
     47        st.w    r8[TI_flags], r9 
     48        unmask_interrupts 
     49        sleep   CPU_SLEEP_IDLE 
     50        .size   cpu_idle_sleep, . - cpu_idle_sleep 
     51 
     52        /* 
     53         * Common return path for PM functions that don't run from 
     54         * SRAM. 
     55         */ 
     56        .global cpu_idle_skip_sleep 
     57        .type   cpu_idle_skip_sleep, @function 
     58cpu_idle_skip_sleep: 
     59        mask_interrupts 
     60        ld.w    r9, r8[TI_flags] 
     61        cbr     r9, TIF_CPU_GOING_TO_SLEEP 
     62        st.w    r8[TI_flags], r9 
     63.Lret_from_sleep: 
     64        unmask_interrupts 
     65        retal   r12 
     66        .size   cpu_idle_skip_sleep, . - cpu_idle_skip_sleep 
  • arch/avr32/mach-at32ap/time-tc.c

    diff -urN avr32-old/arch/avr32/mach-at32ap/time-tc.c avr32-new/arch/avr32/mach-at32ap/time-tc.c
    old new  
    1 /* 
    2  * Copyright (C) 2004-2007 Atmel Corporation 
    3  * 
    4  * Based on MIPS implementation arch/mips/kernel/time.c 
    5  *   Copyright 2001 MontaVista Software Inc. 
    6  * 
    7  * This program is free software; you can redistribute it and/or modify 
    8  * it under the terms of the GNU General Public License version 2 as 
    9  * published by the Free Software Foundation. 
    10  */ 
    11  
    12 #include <linux/clk.h> 
    13 #include <linux/clocksource.h> 
    14 #include <linux/time.h> 
    15 #include <linux/module.h> 
    16 #include <linux/interrupt.h> 
    17 #include <linux/irq.h> 
    18 #include <linux/kernel_stat.h> 
    19 #include <linux/errno.h> 
    20 #include <linux/init.h> 
    21 #include <linux/profile.h> 
    22 #include <linux/sysdev.h> 
    23 #include <linux/err.h> 
    24  
    25 #include <asm/div64.h> 
    26 #include <asm/sysreg.h> 
    27 #include <asm/io.h> 
    28 #include <asm/sections.h> 
    29  
    30 #include <asm/arch/time.h> 
    31  
    32 /* how many counter cycles in a jiffy? */ 
    33 static u32 cycles_per_jiffy; 
    34  
    35 /* the count value for the next timer interrupt */ 
    36 static u32 expirelo; 
    37  
    38 /* the I/O registers of the TC module */ 
    39 static void __iomem *ioregs; 
    40  
    41 cycle_t read_cycle_count(void) 
    42 { 
    43         return (cycle_t)timer_read(ioregs, 0, CV); 
    44 } 
    45  
    46 struct clocksource clocksource_avr32 = { 
    47         .name           = "avr32", 
    48         .rating         = 342, 
    49         .read           = read_cycle_count, 
    50         .mask           = CLOCKSOURCE_MASK(16), 
    51         .shift          = 16, 
    52         .flags          = CLOCK_SOURCE_IS_CONTINUOUS, 
    53 }; 
    54  
    55 static void avr32_timer_ack(void) 
    56 { 
    57         u16 count = expirelo; 
    58  
    59         /* Ack this timer interrupt and set the next one, use a u16 
    60          * variable so it will wrap around correctly */ 
    61         count += cycles_per_jiffy; 
    62         expirelo = count; 
    63         timer_write(ioregs, 0, RC, expirelo); 
    64  
    65         /* Check to see if we have missed any timer interrupts */ 
    66         count = timer_read(ioregs, 0, CV); 
    67         if ((count - expirelo) < 0x7fff) { 
    68                 expirelo = count + cycles_per_jiffy; 
    69                 timer_write(ioregs, 0, RC, expirelo); 
    70         } 
    71 } 
    72  
    73 u32 avr32_hpt_read(void) 
    74 { 
    75         return timer_read(ioregs, 0, CV); 
    76 } 
    77  
    78 static int avr32_timer_calc_div_and_set_jiffies(struct clk *pclk) 
    79 { 
    80         unsigned int cycles_max = (clocksource_avr32.mask + 1) / 2; 
    81         unsigned int divs[] = { 4, 8, 16, 32 }; 
    82         int divs_size = ARRAY_SIZE(divs); 
    83         int i = 0; 
    84         unsigned long count_hz; 
    85         unsigned long shift; 
    86         unsigned long mult; 
    87         int clock_div = -1; 
    88         u64 tmp; 
    89  
    90         shift = clocksource_avr32.shift; 
    91  
    92         do { 
    93                 count_hz = clk_get_rate(pclk) / divs[i]; 
    94                 mult = clocksource_hz2mult(count_hz, shift); 
    95                 clocksource_avr32.mult = mult; 
    96  
    97                 tmp = TICK_NSEC; 
    98                 tmp <<= shift; 
    99                 tmp += mult / 2; 
    100                 do_div(tmp, mult); 
    101  
    102                 cycles_per_jiffy = tmp; 
    103         } while (cycles_per_jiffy > cycles_max && ++i < divs_size); 
    104  
    105         clock_div = i + 1; 
    106  
    107         if (clock_div > divs_size) { 
    108                 pr_debug("timer: could not calculate clock divider\n"); 
    109                 return -EFAULT; 
    110         } 
    111  
    112         /* Set the clock divider */ 
    113         timer_write(ioregs, 0, CMR, TIMER_BF(CMR_TCCLKS, clock_div)); 
    114  
    115         return 0; 
    116 } 
    117  
    118 int avr32_hpt_init(unsigned int count) 
    119 { 
    120         struct resource *regs; 
    121         struct clk *pclk; 
    122         int irq = -1; 
    123         int ret = 0; 
    124  
    125         ret = -ENXIO; 
    126  
    127         irq = platform_get_irq(&at32_systc0_device, 0); 
    128         if (irq < 0) { 
    129                 pr_debug("timer: could not get irq\n"); 
    130                 goto out_error; 
    131         } 
    132  
    133         pclk = clk_get(&at32_systc0_device.dev, "pclk"); 
    134         if (IS_ERR(pclk)) { 
    135                 pr_debug("timer: could not get clk: %ld\n", PTR_ERR(pclk)); 
    136                 goto out_error; 
    137         } 
    138         clk_enable(pclk); 
    139  
    140         regs = platform_get_resource(&at32_systc0_device, IORESOURCE_MEM, 0); 
    141         if (!regs) { 
    142                 pr_debug("timer: could not get resource\n"); 
    143                 goto out_error_clk; 
    144         } 
    145  
    146         ioregs = ioremap(regs->start, regs->end - regs->start + 1); 
    147         if (!ioregs) { 
    148                 pr_debug("timer: could not get ioregs\n"); 
    149                 goto out_error_clk; 
    150         } 
    151  
    152         ret = avr32_timer_calc_div_and_set_jiffies(pclk); 
    153         if (ret) 
    154                 goto out_error_io; 
    155  
    156         ret = setup_irq(irq, &timer_irqaction); 
    157         if (ret) { 
    158                 pr_debug("timer: could not request irq %d: %d\n", 
    159                                 irq, ret); 
    160                 goto out_error_io; 
    161         } 
    162  
    163         expirelo = (timer_read(ioregs, 0, CV) / cycles_per_jiffy + 1) 
    164                 * cycles_per_jiffy; 
    165  
    166         /* Enable clock and interrupts on RC compare */ 
    167         timer_write(ioregs, 0, CCR, TIMER_BIT(CCR_CLKEN)); 
    168         timer_write(ioregs, 0, IER, TIMER_BIT(IER_CPCS)); 
    169         /* Set cycles to first interrupt */ 
    170         timer_write(ioregs, 0,  RC, expirelo); 
    171  
    172         printk(KERN_INFO "timer: AT32AP system timer/counter at 0x%p irq %d\n", 
    173                         ioregs, irq); 
    174  
    175         return 0; 
    176  
    177 out_error_io: 
    178         iounmap(ioregs); 
    179 out_error_clk: 
    180         clk_put(pclk); 
    181 out_error: 
    182         return ret; 
    183 } 
    184  
    185 int avr32_hpt_start(void) 
    186 { 
    187         timer_write(ioregs, 0, CCR, TIMER_BIT(CCR_SWTRG)); 
    188         return 0; 
    189 } 
    190  
    191 irqreturn_t timer_interrupt(int irq, void *dev_id) 
    192 { 
    193         unsigned int sr = timer_read(ioregs, 0, SR); 
    194  
    195         if (sr & TIMER_BIT(SR_CPCS)) { 
    196                 /* ack timer interrupt and try to set next interrupt */ 
    197                 avr32_timer_ack(); 
    198  
    199                 /* 
    200                  * Call the generic timer interrupt handler 
    201                  */ 
    202                 write_seqlock(&xtime_lock); 
    203                 do_timer(1); 
    204                 write_sequnlock(&xtime_lock); 
    205  
    206                 /* 
    207                  * In UP mode, we call local_timer_interrupt() to do profiling 
    208                  * and process accounting. 
    209                  * 
    210                  * SMP is not supported yet. 
    211                  */ 
    212                 local_timer_interrupt(irq, dev_id); 
    213  
    214                 return IRQ_HANDLED; 
    215         } 
    216  
    217         return IRQ_NONE; 
    218 } 
  • arch/avr32/mm/fault.c

    diff -urN avr32-old/arch/avr32/mm/fault.c avr32-new/arch/avr32/mm/fault.c
    old new  
    189189 
    190190        page = sysreg_read(PTBR); 
    191191        printk(KERN_ALERT "ptbr = %08lx", page); 
     192        if (address >= TASK_SIZE) 
     193                page = (unsigned long)swapper_pg_dir; 
    192194        if (page) { 
    193195                page = ((unsigned long *)page)[address >> 22]; 
    194196                printk(" pgd = %08lx", page); 
  • arch/avr32/oprofile/op_model_avr32.c

    diff -urN avr32-old/arch/avr32/oprofile/op_model_avr32.c avr32-new/arch/avr32/oprofile/op_model_avr32.c
    old new  
    1616#include <linux/sched.h> 
    1717#include <linux/types.h> 
    1818 
    19 #include <asm/intc.h> 
    2019#include <asm/sysreg.h> 
    2120#include <asm/system.h> 
    2221 
  • drivers/clocksource/Makefile

    diff -urN avr32-old/drivers/clocksource/Makefile avr32-new/drivers/clocksource/Makefile
    old new  
     1obj-$(CONFIG_ATMEL_TCB_CLKSRC)  += tcb_clksrc.o 
    12obj-$(CONFIG_X86_CYCLONE_TIMER) += cyclone.o 
    23obj-$(CONFIG_X86_PM_TIMER)      += acpi_pm.o 
    34obj-$(CONFIG_SCx200HR_TIMER)    += scx200_hrt.o 
  • drivers/clocksource/tcb_clksrc.c

    diff -urN avr32-old/drivers/clocksource/tcb_clksrc.c avr32-new/drivers/clocksource/tcb_clksrc.c
    old new  
     1#include <linux/init.h> 
     2#include <linux/clocksource.h> 
     3#include <linux/clockchips.h> 
     4#include <linux/interrupt.h> 
     5#include <linux/irq.h> 
     6 
     7#include <linux/clk.h> 
     8#include <linux/err.h> 
     9#include <linux/ioport.h> 
     10#include <linux/io.h> 
     11#include <linux/platform_device.h> 
     12#include <linux/atmel_tc.h> 
     13 
     14 
     15/* 
     16 * We're configured to use a specific TC block, one that's not hooked 
     17 * up to external hardware, to provide a time solution: 
     18 * 
     19 *   - Two channels combine to create a free-running 32 bit counter 
     20 *     with a base rate of 5+ MHz, packaged as a clocksource (with 
     21 *     resolution better than 200 nsec). 
     22 * 
     23 *   - The third channel may be used to provide a 16-bit clockevent 
     24 *     source, used in either periodic or oneshot mode.  This runs 
     25 *     at 32 KiHZ, and can handle delays of up to two seconds. 
     26 * 
     27 * A boot clocksource and clockevent source are also currently needed, 
     28 * unless the relevant platforms (ARM/AT91, AVR32/AT32) are changed so 
     29 * this code can be used when init_timers() is called, well before most 
     30 * devices are set up.  (Some low end AT91 parts, which can run uClinux, 
     31 * have only the timers in one TC block... they currently don't support 
     32 * the tclib code, because of that initialization issue.) 
     33 * 
     34 * REVISIT behavior during system suspend states... we should disable 
     35 * all clocks and save the power.  Easily done for clockevent devices, 
     36 * but clocksources won't necessarily get the needed notifications. 
     37 * For deeper system sleep states, this will be mandatory... 
     38 */ 
     39 
     40static void __iomem *tcaddr; 
     41 
     42static cycle_t tc_get_cycles(void) 
     43{ 
     44        unsigned long   flags; 
     45        u32             lower, upper; 
     46 
     47        raw_local_irq_save(flags); 
     48        do { 
     49                upper = __raw_readl(tcaddr + ATMEL_TC_REG(1, CV)); 
     50                lower = __raw_readl(tcaddr + ATMEL_TC_REG(0, CV)); 
     51        } while (upper != __raw_readl(tcaddr + ATMEL_TC_REG(1, CV))); 
     52 
     53        raw_local_irq_restore(flags); 
     54        return (upper << 16) | lower; 
     55} 
     56 
     57static struct clocksource clksrc = { 
     58        .name           = "tcb_clksrc", 
     59        .rating         = 200, 
     60        .read           = tc_get_cycles, 
     61        .mask           = CLOCKSOURCE_MASK(32), 
     62        .shift          = 18, 
     63        .flags          = CLOCK_SOURCE_IS_CONTINUOUS, 
     64}; 
     65 
     66#ifdef CONFIG_GENERIC_CLOCKEVENTS 
     67 
     68struct tc_clkevt_device { 
     69        struct clock_event_device       clkevt; 
     70        struct clk                      *clk; 
     71        void __iomem                    *regs; 
     72}; 
     73 
     74static struct tc_clkevt_device *to_tc_clkevt(struct clock_event_device *clkevt) 
     75{ 
     76        return container_of(clkevt, struct tc_clkevt_device, clkevt); 
     77} 
     78 
     79/* For now, we always use the 32K clock ... this optimizes for NO_HZ, 
     80 * because using one of the divided clocks would usually mean the 
     81 * tick rate can never be less than several dozen Hz (vs 0.5 Hz). 
     82 * 
     83 * A divided clock could be good for high resolution timers, since 
     84 * 30.5 usec resolution can seem "low". 
     85 */ 
     86static u32 timer_clock; 
     87 
     88static void tc_mode(enum clock_event_mode m, struct clock_event_device *d) 
     89{ 
     90        struct tc_clkevt_device *tcd = to_tc_clkevt(d); 
     91        void __iomem            *regs = tcd->regs; 
     92 
     93        if (tcd->clkevt.mode == CLOCK_EVT_MODE_PERIODIC 
     94                        || tcd->clkevt.mode == CLOCK_EVT_MODE_ONESHOT) { 
     95                __raw_writel(0xff, regs + ATMEL_TC_REG(2, IDR)); 
     96                __raw_writel(ATMEL_TC_CLKDIS, regs + ATMEL_TC_REG(2, CCR)); 
     97                clk_disable(tcd->clk); 
     98        } 
     99 
     100        switch (m) { 
     101 
     102        /* By not making the gentime core emulate periodic mode on top 
     103         * of oneshot, we get lower overhead and improved accuracy. 
     104         */ 
     105        case CLOCK_EVT_MODE_PERIODIC: 
     106                clk_enable(tcd->clk); 
     107 
     108                /* slow clock, count up to RC, then irq and restart */ 
     109                __raw_writel(timer_clock 
     110                                | ATMEL_TC_WAVE | ATMEL_TC_WAVESEL_UP_AUTO, 
     111                                regs + ATMEL_TC_REG(2, CMR)); 
     112                __raw_writel((32768 + HZ/2) / HZ, tcaddr + ATMEL_TC_REG(2, RC)); 
     113 
     114                /* Enable clock and interrupts on RC compare */ 
     115                __raw_writel(ATMEL_TC_CPCS, regs + ATMEL_TC_REG(2, IER)); 
     116 
     117                /* go go gadget! */ 
     118                __raw_writel(ATMEL_TC_CLKEN | ATMEL_TC_SWTRG, 
     119                                regs + ATMEL_TC_REG(2, CCR)); 
     120                break; 
     121 
     122        case CLOCK_EVT_MODE_ONESHOT: 
     123                clk_enable(tcd->clk); 
     124 
     125                /* slow clock, count up to RC, then irq and stop */ 
     126                __raw_writel(timer_clock | ATMEL_TC_CPCSTOP 
     127                                | ATMEL_TC_WAVE | ATMEL_TC_WAVESEL_UP_AUTO, 
     128                                regs + ATMEL_TC_REG(2, CMR)); 
     129                __raw_writel(ATMEL_TC_CPCS, regs + ATMEL_TC_REG(2, IER)); 
     130 
     131                /* set_next_event() configures and starts the timer */ 
     132                break; 
     133 
     134        default: 
     135                break; 
     136        } 
     137} 
     138 
     139static int tc_next_event(unsigned long delta, struct clock_event_device *d) 
     140{ 
     141        __raw_writel(delta, tcaddr + ATMEL_TC_REG(2, RC)); 
     142 
     143        /* go go gadget! */ 
     144        __raw_writel(ATMEL_TC_CLKEN | ATMEL_TC_SWTRG, 
     145                        tcaddr + ATMEL_TC_REG(2, CCR)); 
     146        return 0; 
     147} 
     148 
     149static struct tc_clkevt_device clkevt = { 
     150        .clkevt = { 
     151                .name           = "tc_clkevt", 
     152                .features       = CLOCK_EVT_FEAT_PERIODIC 
     153                                        | CLOCK_EVT_FEAT_ONESHOT, 
     154                .shift          = 32, 
     155                /* Should be lower than at91rm9200's system timer */ 
     156                .rating         = 125, 
     157                .cpumask        = CPU_MASK_CPU0, 
     158                .set_next_event = tc_next_event, 
     159                .set_mode       = tc_mode, 
     160        }, 
     161}; 
     162 
     163static irqreturn_t ch2_irq(int irq, void *handle) 
     164{ 
     165        struct tc_clkevt_device *dev = handle; 
     166        unsigned int            sr; 
     167 
     168        sr = __raw_readl(dev->regs + ATMEL_TC_REG(2, SR)); 
     169        if (sr & ATMEL_TC_CPCS) { 
     170                dev->clkevt.event_handler(&dev->clkevt); 
     171                return IRQ_HANDLED; 
     172        } 
     173 
     174        return IRQ_NONE; 
     175} 
     176 
     177static struct irqaction tc_irqaction = { 
     178        .name           = "tc_clkevt", 
     179        .flags          = IRQF_TIMER | IRQF_DISABLED, 
     180        .handler        = ch2_irq, 
     181}; 
     182 
     183static void __init setup_clkevents(struct atmel_tc *tc, 
     184                struct clk *t0_clk, int clk32k_divisor_idx) 
     185{ 
     186        struct platform_device *pdev = tc->pdev; 
     187        struct clk *t2_clk = tc->clk[2]; 
     188        int irq = tc->irq[2]; 
     189 
     190        clkevt.regs = tc->regs; 
     191        clkevt.clk = t2_clk; 
     192        tc_irqaction.dev_id = &clkevt; 
     193 
     194        timer_clock = clk32k_divisor_idx; 
     195 
     196        clkevt.clkevt.mult = div_sc(32768, NSEC_PER_SEC, clkevt.clkevt.shift); 
     197        clkevt.clkevt.max_delta_ns 
     198                = clockevent_delta2ns(0xffff, &clkevt.clkevt); 
     199        clkevt.clkevt.min_delta_ns = clockevent_delta2ns(1, &clkevt.clkevt) + 1; 
     200 
     201        setup_irq(irq, &tc_irqaction); 
     202 
     203        clockevents_register_device(&clkevt.clkevt); 
     204} 
     205 
     206#else /* !CONFIG_GENERIC_CLOCKEVENTS */ 
     207 
     208static void __init setup_clkevents(struct atmel_tc *tc, 
     209                struct clk *t0_clk, int clk32k_divisor_idx) 
     210{ 
     211        /* NOTHING */ 
     212} 
     213 
     214#endif 
     215 
     216static int __init tcb_clksrc_init(void) 
     217{ 
     218        static char bootinfo[] __initdata 
     219                = KERN_DEBUG "%s: tc%d at %d.%03d MHz\n"; 
     220 
     221        struct platform_device *pdev; 
     222        struct atmel_tc *tc; 
     223        struct clk *t0_clk, *t1_clk; 
     224        u32 rate, divided_rate = 0; 
     225        int best_divisor_idx = -1; 
     226        int clk32k_divisor_idx = -1; 
     227        int i; 
     228 
     229        tc = atmel_tc_alloc(CONFIG_ATMEL_TCB_CLKSRC_BLOCK, clksrc.name); 
     230        if (!tc) { 
     231                pr_debug("can't alloc TC for clocksource\n"); 
     232                return -ENODEV; 
     233        } 
     234        tcaddr = tc->regs; 
     235        pdev = tc->pdev; 
     236 
     237        t0_clk = tc->clk[0]; 
     238        clk_enable(t0_clk); 
     239 
     240        /* How fast will we be counting?  Pick something over 5 MHz.  */ 
     241        rate = (u32) clk_get_rate(t0_clk); 
     242        for (i = 0; i < 5; i++) { 
     243                unsigned divisor = atmel_tc_divisors[i]; 
     244                unsigned tmp; 
     245 
     246                /* remember 32 KiHz clock for later */ 
     247                if (!divisor) { 
     248                        clk32k_divisor_idx = i; 
     249                        continue; 
     250                } 
     251 
     252                tmp = rate / divisor; 
     253                pr_debug("TC: %u / %-3u [%d] --> %u\n", rate, divisor, i, tmp); 
     254                if (best_divisor_idx > 0) { 
     255                        if (tmp < 5 * 1000 * 1000) 
     256                                continue; 
     257                } 
     258                divided_rate = tmp; 
     259                best_divisor_idx = i; 
     260        } 
     261 
     262        clksrc.mult = clocksource_hz2mult(divided_rate, clksrc.shift); 
     263 
     264        printk(bootinfo, clksrc.name, CONFIG_ATMEL_TCB_CLKSRC_BLOCK, 
     265                        divided_rate / 1000000, 
     266                        ((divided_rate + 500000) % 1000000) / 1000); 
     267 
     268        /* tclib will give us three clocks no matter what the 
     269         * underlying platform supports. 
     270         */ 
     271        clk_enable(tc->clk[1]); 
     272 
     273        /* channel 0:  waveform mode, input mclk/8, clock TIOA0 on overflow */ 
     274        __raw_writel(best_divisor_idx                   /* likely divide-by-8 */ 
     275                        | ATMEL_TC_WAVE 
     276                        | ATMEL_TC_WAVESEL_UP           /* free-run */ 
     277                        | ATMEL_TC_ACPA_SET             /* TIOA0 rises at 0 */ 
     278                        | ATMEL_TC_ACPC_CLEAR,          /* (duty cycle 50%) */ 
     279                        tcaddr + ATMEL_TC_REG(0, CMR)); 
     280        __raw_writel(0x0000, tcaddr + ATMEL_TC_REG(0, RA)); 
     281        __raw_writel(0x8000, tcaddr + ATMEL_TC_REG(0, RC)); 
     282        __raw_writel(0xff, tcaddr + ATMEL_TC_REG(0, IDR));      /* no irqs */ 
     283        __raw_writel(ATMEL_TC_CLKEN, tcaddr + ATMEL_TC_REG(0, CCR)); 
     284 
     285        /* channel 1:  waveform mode, input TIOA0 */ 
     286        __raw_writel(ATMEL_TC_XC1                       /* input: TIOA0 */ 
     287                        | ATMEL_TC_WAVE 
     288                        | ATMEL_TC_WAVESEL_UP,          /* free-run */ 
     289                        tcaddr + ATMEL_TC_REG(1, CMR)); 
     290        __raw_writel(0xff, tcaddr + ATMEL_TC_REG(1, IDR));      /* no irqs */ 
     291        __raw_writel(ATMEL_TC_CLKEN, tcaddr + ATMEL_TC_REG(1, CCR)); 
     292 
     293        /* chain channel 0 to channel 1, then reset all the timers */ 
     294        __raw_writel(ATMEL_TC_TC1XC1S_TIOA0, tcaddr + ATMEL_TC_BMR); 
     295        __raw_writel(ATMEL_TC_SYNC, tcaddr + ATMEL_TC_BCR); 
     296 
     297        /* and away we go! */ 
     298        clocksource_register(&clksrc); 
     299 
     300        /* channel 2:  periodic and oneshot timer support */ 
     301        setup_clkevents(tc, t0_clk, clk32k_divisor_idx); 
     302 
     303        return 0; 
     304} 
     305arch_initcall(tcb_clksrc_init); 
  • drivers/i2c/busses/i2c-atmeltwi.c

    diff -urN avr32-old/drivers/i2c/busses/i2c-atmeltwi.c avr32-new/drivers/i2c/busses/i2c-atmeltwi.c
    old new  
    238238 
    239239                } else if (status & TWI_BIT(TXRDY)) { 
    240240                        if (twi->acks_left > 0) { 
    241                                 twi->acks_left--; 
    242241                                twi_writel(twi, THR, 
    243242                                        twi->buf[twi->len - twi->acks_left]); 
     243                                twi->acks_left--; 
    244244                        } else 
    245245                                twi_writel(twi, CR, TWI_BIT(STOP)); 
    246246                } 
  • drivers/input/serio/at32psif.c

    diff -urN avr32-old/drivers/input/serio/at32psif.c avr32-new/drivers/input/serio/at32psif.c
    old new  
     1/* 
     2 * Copyright (C) 2007 Atmel Corporation 
     3 * 
     4 * Driver for the AT32AP700X PS/2 controller (PSIF). 
     5 * 
     6 * This program is free software; you can redistribute it and/or modify it 
     7 * under the terms of the GNU General Public License version 2 as published 
     8 * by the Free Software Foundation. 
     9 */ 
     10#include <linux/kernel.h> 
     11#include <linux/module.h> 
     12#include <linux/device.h> 
     13#include <linux/init.h> 
     14#include <linux/serio.h> 
     15#include <linux/timer.h> 
     16#include <linux/interrupt.h> 
     17#include <linux/err.h> 
     18#include <linux/io.h> 
     19#include <linux/clk.h> 
     20#include <linux/platform_device.h> 
     21 
     22#include "at32psif.h" 
     23 
     24#define PSIF_BUF_SIZE           16 
     25 
     26#define ring_is_empty(_psif)    (_psif->head == _psif->tail) 
     27#define ring_next_head(_psif)   ((_psif->head + 1) & (PSIF_BUF_SIZE - 1)) 
     28#define ring_next_tail(_psif)   ((_psif->tail + 1) & (PSIF_BUF_SIZE - 1)) 
     29 
     30struct psif { 
     31        struct platform_device  *pdev; 
     32        struct clk              *pclk; 
     33        struct serio            *io; 
     34        struct timer_list       tx_timer; 
     35        void __iomem            *regs; 
     36        unsigned int            irq; 
     37        unsigned int            open; 
     38        /* Prevent concurrent writes to circular buffer. */ 
     39        spinlock_t              lock; 
     40        unsigned int            head; 
     41        unsigned int            tail; 
     42        unsigned char           buffer[PSIF_BUF_SIZE]; 
     43}; 
     44 
     45static irqreturn_t psif_interrupt(int irq, void *_ptr) 
     46{ 
     47        struct psif *psif = _ptr; 
     48        int retval = IRQ_NONE; 
     49        unsigned int io_flags = 0; 
     50        unsigned long status; 
     51 
     52        status = psif_readl(psif, SR); 
     53 
     54        if (status & PSIF_BIT(RXRDY)) { 
     55                unsigned char val = (unsigned char) psif_readl(psif, RHR); 
     56 
     57                if (status & PSIF_BIT(PARITY)) 
     58                        io_flags |= SERIO_PARITY; 
     59                if (status & PSIF_BIT(OVRUN)) 
     60                        dev_err(&psif->pdev->dev, "overrun read error\n"); 
     61 
     62                serio_interrupt(psif->io, val, io_flags); 
     63 
     64                retval = IRQ_HANDLED; 
     65        } 
     66 
     67        spin_lock(&psif->lock); 
     68 
     69        if (status & PSIF_BIT(TXEMPTY)) { 
     70                if (status & PSIF_BIT(NACK)) 
     71                        dev_err(&psif->pdev->dev, "NACK error\n"); 
     72 
     73                psif_writel(psif, IDR, PSIF_BIT(TXEMPTY)); 
     74 
     75                if (!ring_is_empty(psif)) 
     76                        mod_timer(&psif->tx_timer, 
     77                                        jiffies + msecs_to_jiffies(1)); 
     78 
     79                retval = IRQ_HANDLED; 
     80        } 
     81 
     82        spin_unlock(&psif->lock); 
     83 
     84        return retval; 
     85} 
     86 
     87static void psif_transmit_data(unsigned long data) 
     88{ 
     89        struct psif *psif = (struct psif *)data; 
     90        unsigned long flags; 
     91 
     92        spin_lock_irqsave(&psif->lock, flags); 
     93 
     94        psif_writel(psif, THR, psif->buffer[psif->tail]); 
     95        psif->tail = ring_next_tail(psif); 
     96 
     97        if (!ring_is_empty(psif)) 
     98                psif_writel(psif, IER, PSIF_BIT(TXEMPTY)); 
     99 
     100        spin_unlock_irqrestore(&psif->lock, flags); 
     101} 
     102 
     103static int psif_write(struct serio *io, unsigned char val) 
     104{ 
     105        struct psif *psif = io->port_data; 
     106        unsigned long flags; 
     107        unsigned int head; 
     108 
     109        spin_lock_irqsave(&psif->lock, flags); 
     110 
     111        head = ring_next_head(psif); 
     112 
     113        if (head != psif->tail) { 
     114                psif->buffer[psif->head] = val; 
     115                psif->head = head; 
     116        } else { 
     117                dev_err(&psif->pdev->dev, "underrun write error\n"); 
     118        } 
     119 
     120        spin_unlock_irqrestore(&psif->lock, flags); 
     121 
     122        /* Make sure TXEMPTY interrupt is enabled. */ 
     123        psif_writel(psif, IER, PSIF_BIT(TXEMPTY)); 
     124 
     125        return 0; 
     126} 
     127 
     128static int psif_open(struct serio *io) 
     129{ 
     130        struct psif *psif = io->port_data; 
     131        int retval; 
     132 
     133        retval = clk_enable(psif->pclk); 
     134        if (retval) 
     135                goto out; 
     136 
     137        psif_writel(psif, CR, PSIF_BIT(CR_TXEN) | PSIF_BIT(CR_RXEN)); 
     138        psif_writel(psif, IER, PSIF_BIT(RXRDY)); 
     139 
     140        psif->open = 1; 
     141out: 
     142        return retval; 
     143} 
     144 
     145static void psif_close(struct serio *io) 
     146{ 
     147        struct psif *psif = io->port_data; 
     148 
     149        psif->open = 0; 
     150 
     151        psif_writel(psif, IDR, ~0UL); 
     152        psif_writel(psif, CR, PSIF_BIT(CR_TXDIS) | PSIF_BIT(CR_RXDIS)); 
     153 
     154        clk_disable(psif->pclk); 
     155} 
     156 
     157static void psif_set_prescaler(struct psif *psif) 
     158{ 
     159        unsigned long prscv; 
     160        unsigned long rate = clk_get_rate(psif->pclk); 
     161 
     162        /* PRSCV = Pulse length (100 us) * PSIF module frequency. */ 
     163        prscv = 100 * (rate / 1000000UL); 
     164 
     165        if (prscv > ((1<<PSIF_PSR_PRSCV_SIZE) - 1)) { 
     166                prscv = (1<<PSIF_PSR_PRSCV_SIZE) - 1; 
     167                dev_dbg(&psif->pdev->dev, "pclk too fast, " 
     168                                "prescaler set to max\n"); 
     169        } 
     170 
     171        clk_enable(psif->pclk); 
     172        psif_writel(psif, PSR, prscv); 
     173        clk_disable(psif->pclk); 
     174} 
     175 
     176static int __init psif_probe(struct platform_device *pdev) 
     177{ 
     178        struct resource *regs; 
     179        struct psif *psif; 
     180        struct serio *io; 
     181        struct clk *pclk; 
     182        int irq; 
     183        int ret; 
     184 
     185        psif = kzalloc(sizeof(struct psif), GFP_KERNEL); 
     186        if (!psif) { 
     187                dev_dbg(&pdev->dev, "out of memory\n"); 
     188                ret = -ENOMEM; 
     189                goto out; 
     190        } 
     191        psif->pdev = pdev; 
     192 
     193        io = kzalloc(sizeof(struct serio), GFP_KERNEL); 
     194        if (!io) { 
     195                dev_dbg(&pdev->dev, "out of memory\n"); 
     196                ret = -ENOMEM; 
     197                goto out_free_psif; 
     198        } 
     199        psif->io = io; 
     200 
     201        regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
     202        if (!regs) { 
     203                dev_dbg(&pdev->dev, "no mmio resources defined\n"); 
     204                ret = -ENOMEM; 
     205                goto out_free_io; 
     206        } 
     207 
     208        psif->regs = ioremap(regs->start, regs->end - regs->start + 1); 
     209        if (!psif->regs) { 
     210                ret = -ENOMEM; 
     211                dev_dbg(&pdev->dev, "could not map I/O memory\n"); 
     212                goto out_free_io; 
     213        } 
     214 
     215        pclk = clk_get(&pdev->dev, "pclk"); 
     216        if (IS_ERR(pclk)) { 
     217                dev_dbg(&pdev->dev, "could not get peripheral clock\n"); 
     218                ret = PTR_ERR(pclk); 
     219                goto out_iounmap; 
     220        } 
     221        psif->pclk = pclk; 
     222 
     223        /* Reset the PSIF to enter at a known state. */ 
     224        ret = clk_enable(pclk); 
     225        if (ret) { 
     226                dev_dbg(&pdev->dev, "could not enable pclk\n"); 
     227                goto out_put_clk; 
     228        } 
     229        psif_writel(psif, CR, PSIF_BIT(CR_SWRST)); 
     230        clk_disable(pclk); 
     231 
     232        setup_timer(&psif->tx_timer, psif_transmit_data, (unsigned long)psif); 
     233 
     234        irq = platform_get_irq(pdev, 0); 
     235        if (irq < 0) { 
     236                dev_dbg(&pdev->dev, "could not get irq\n"); 
     237                ret = -ENXIO; 
     238                goto out_put_clk; 
     239        } 
     240        ret = request_irq(irq, psif_interrupt, IRQF_SHARED, "at32psif", psif); 
     241        if (ret) { 
     242                dev_dbg(&pdev->dev, "could not request irq %d\n", irq); 
     243                goto out_put_clk; 
     244        } 
     245        psif->irq = irq; 
     246 
     247        io->id.type     = SERIO_8042; 
     248        io->write       = psif_write; 
     249        io->open        = psif_open; 
     250        io->close       = psif_close; 
     251        strlcpy(io->name, pdev->dev.bus_id, sizeof(io->name)); 
     252        strlcpy(io->phys, pdev->dev.bus_id, sizeof(io->phys)); 
     253        io->port_data   = psif; 
     254        io->dev.parent  = &pdev->dev; 
     255 
     256        psif_set_prescaler(psif); 
     257 
     258        spin_lock_init(&psif->lock); 
     259        serio_register_port(psif->io); 
     260        platform_set_drvdata(pdev, psif); 
     261 
     262        dev_info(&pdev->dev, "Atmel AVR32 PSIF PS/2 driver on 0x%08x irq %d\n", 
     263                        (int)psif->regs, psif->irq); 
     264 
     265        return 0; 
     266 
     267out_put_clk: 
     268        clk_put(psif->pclk); 
     269out_iounmap: 
     270        iounmap(psif->regs); 
     271out_free_io: 
     272        kfree(io); 
     273out_free_psif: 
     274        kfree(psif); 
     275out: 
     276        return ret; 
     277} 
     278 
     279static int __exit psif_remove(struct platform_device *pdev) 
     280{ 
     281        struct psif *psif = platform_get_drvdata(pdev); 
     282 
     283        psif_writel(psif, IDR, ~0UL); 
     284        psif_writel(psif, CR, PSIF_BIT(CR_TXDIS) | PSIF_BIT(CR_RXDIS)); 
     285 
     286        serio_unregister_port(psif->io); 
     287        iounmap(psif->regs); 
     288        free_irq(psif->irq, psif); 
     289        clk_put(psif->pclk); 
     290        kfree(psif); 
     291 
     292        platform_set_drvdata(pdev, NULL); 
     293 
     294        return 0; 
     295} 
     296 
     297#ifdef CONFIG_PM 
     298static int psif_suspend(struct platform_device *pdev, pm_message_t state) 
     299{ 
     300        struct psif *psif = platform_get_drvdata(pdev); 
     301 
     302        if (psif->open) { 
     303                psif_writel(psif, CR, PSIF_BIT(CR_RXDIS) | PSIF_BIT(CR_TXDIS)); 
     304                clk_disable(psif->pclk); 
     305        } 
     306 
     307        return 0; 
     308} 
     309 
     310static int psif_resume(struct platform_device *pdev) 
     311{ 
     312        struct psif *psif = platform_get_drvdata(pdev); 
     313 
     314        if (psif->open) { 
     315                clk_enable(psif->pclk); 
     316                psif_set_prescaler(psif); 
     317                psif_writel(psif, CR, PSIF_BIT(CR_RXEN) | PSIF_BIT(CR_TXEN)); 
     318        } 
     319 
     320        return 0; 
     321} 
     322#else 
     323#define psif_suspend    NULL 
     324#define psif_resume     NULL 
     325#endif 
     326 
     327static struct platform_driver psif_driver = { 
     328        .remove         = __exit_p(psif_remove), 
     329        .driver         = { 
     330                .name   = "atmel_psif", 
     331        }, 
     332        .suspend        = psif_suspend, 
     333        .resume         = psif_resume, 
     334}; 
     335 
     336static int __init psif_init(void) 
     337{ 
     338        return platform_driver_probe(&psif_driver, psif_probe); 
     339} 
     340 
     341static void __exit psif_exit(void) 
     342{ 
     343        platform_driver_unregister(&psif_driver); 
     344} 
     345 
     346module_init(psif_init); 
     347module_exit(psif_exit); 
     348 
     349MODULE_AUTHOR("Hans-Christian Egtvedt <hcegtvedt@atmel.com>"); 
     350MODULE_DESCRIPTION("Atmel AVR32 PSIF PS/2 driver"); 
     351MODULE_LICENSE("GPL"); 
  • drivers/input/serio/at32psif.h

    diff -urN avr32-old/drivers/input/serio/at32psif.h avr32-new/drivers/input/serio/at32psif.h
    old new  
     1/* 
     2 * Copyright (C) 2007 Atmel Corporation 
     3 * 
     4 * Driver for the AT32AP700X PS/2 controller (PSIF). 
     5 * 
     6 * This program is free software; you can redistribute it and/or modify it 
     7 * under the terms of the GNU General Public License version 2 as published 
     8 * by the Free Software Foundation. 
     9 */ 
     10 
     11#ifndef _AT32PSIF_H 
     12#define _AT32PSIF_H 
     13 
     14/* PSIF register offsets */ 
     15#define PSIF_CR                         0x00 
     16#define PSIF_RHR                        0x04 
     17#define PSIF_THR                        0x08 
     18#define PSIF_SR                         0x10 
     19#define PSIF_IER                        0x14 
     20#define PSIF_IDR                        0x18 
     21#define PSIF_IMR                        0x1c 
     22#define PSIF_PSR                        0x24 
     23 
     24/* Bitfields in control register. */ 
     25#define PSIF_CR_RXDIS_OFFSET            1 
     26#define PSIF_CR_RXDIS_SIZE              1 
     27#define PSIF_CR_RXEN_OFFSET             0 
     28#define PSIF_CR_RXEN_SIZE               1 
     29#define PSIF_CR_SWRST_OFFSET            15 
     30#define PSIF_CR_SWRST_SIZE              1 
     31#define PSIF_CR_TXDIS_OFFSET            9 
     32#define PSIF_CR_TXDIS_SIZE              1 
     33#define PSIF_CR_TXEN_OFFSET             8 
     34#define PSIF_CR_TXEN_SIZE               1 
     35 
     36/* Bitfields in interrupt disable, enable, mask and status register. */ 
     37#define PSIF_NACK_OFFSET                8 
     38#define PSIF_NACK_SIZE                  1 
     39#define PSIF_OVRUN_OFFSET               5 
     40#define PSIF_OVRUN_SIZE                 1 
     41#define PSIF_PARITY_OFFSET              9 
     42#define PSIF_PARITY_SIZE                1 
     43#define PSIF_RXRDY_OFFSET               4 
     44#define PSIF_RXRDY_SIZE                 1 
     45#define PSIF_TXEMPTY_OFFSET             1 
     46#define PSIF_TXEMPTY_SIZE               1 
     47#define PSIF_TXRDY_OFFSET               0 
     48#define PSIF_TXRDY_SIZE                 1 
     49 
     50/* Bitfields in prescale register. */ 
     51#define PSIF_PSR_PRSCV_OFFSET           0 
     52#define PSIF_PSR_PRSCV_SIZE             12 
     53 
     54/* Bitfields in receive hold register. */ 
     55#define PSIF_RHR_RXDATA_OFFSET          0 
     56#define PSIF_RHR_RXDATA_SIZE            8 
     57 
     58/* Bitfields in transmit hold register. */ 
     59#define PSIF_THR_TXDATA_OFFSET          0 
     60#define PSIF_THR_TXDATA_SIZE            8 
     61 
     62/* Bit manipulation macros */ 
     63#define PSIF_BIT(name)                                  \ 
     64        (1 << PSIF_##name##_OFFSET) 
     65#define PSIF_BF(name, value)                            \ 
     66        (((value) & ((1 << PSIF_##name##_SIZE) - 1))    \ 
     67         << PSIF_##name##_OFFSET) 
     68#define PSIF_BFEXT(name, value)\ 
     69        (((value) >> PSIF_##name##_OFFSET)              \ 
     70         & ((1 << PSIF_##name##_SIZE) - 1)) 
     71#define PSIF_BFINS(name, value, old)                    \ 
     72        (((old) & ~(((1 << PSIF_##name##_SIZE) - 1)     \ 
     73                    << PSIF_##name##_OFFSET))           \ 
     74         | PSIF_BF(name, value)) 
     75 
     76/* Register access macros */ 
     77#define psif_readl(port, reg)                           \ 
     78        __raw_readl((port)->regs + PSIF_##reg) 
     79#define psif_writel(port, reg, value)                   \ 
     80        __raw_writel((value), (port)->regs + PSIF_##reg) 
     81 
     82#endif /* _AT32PSIF_H */ 
  • drivers/input/serio/Kconfig

    diff -urN avr32-old/drivers/input/serio/Kconfig avr32-new/drivers/input/serio/Kconfig
    old new  
    8888          To compile this driver as a module, choose M here: the 
    8989          module will be called rpckbd. 
    9090 
     91config SERIO_AT32PSIF 
     92        tristate "AVR32 PSIF PS/2 keyboard and mouse controller" 
     93        depends on AVR32 
     94        default n 
     95        help 
     96          Say Y here if you want to use the PSIF peripheral on AVR32 devices 
     97          and connect a PS/2 keyboard and/or mouse to it. 
     98 
     99          To compile this driver as a module, choose M here: the module will 
     100          be called at32psif. 
     101 
    91102config SERIO_AMBAKMI 
    92103        tristate "AMBA KMI keyboard controller" 
    93104        depends on ARM_AMBA 
  • drivers/input/serio/Makefile

    diff -urN avr32-old/drivers/input/serio/Makefile avr32-new/drivers/input/serio/Makefile
    old new  
    1212obj-$(CONFIG_SERIO_RPCKBD)      += rpckbd.o 
    1313obj-$(CONFIG_SERIO_SA1111)      += sa1111ps2.o 
    1414obj-$(CONFIG_SERIO_AMBAKMI)     += ambakmi.o 
     15obj-$(CONFIG_SERIO_AT32PSIF)    += at32psif.o 
    1516obj-$(CONFIG_SERIO_Q40KBD)      += q40kbd.o 
    1617obj-$(CONFIG_SERIO_GSCPS2)      += gscps2.o 
    1718obj-$(CONFIG_HP_SDC)            += hp_sdc.o 
  • drivers/misc/atmel_tclib.c

    diff -urN avr32-old/drivers/misc/atmel_tclib.c avr32-new/drivers/misc/atmel_tclib.c
    old new  
     1#include <linux/atmel_tc.h> 
     2#include <linux/clk.h> 
     3#include <linux/err.h> 
     4#include <linux/init.h> 
     5#include <linux/io.h> 
     6#include <linux/ioport.h> 
     7#include <linux/kernel.h> 
     8#include <linux/platform_device.h> 
     9 
     10/* Number of bytes to reserve for the iomem resource */ 
     11#define ATMEL_TC_IOMEM_SIZE     256 
     12 
     13 
     14/* 
     15 * This is a thin library to solve the problem of how to portably allocate 
     16 * one of the TC blocks.  For simplicity, it doesn't currently expect to 
     17 * share individual timers between different drivers. 
     18 */ 
     19 
     20#if defined(CONFIG_AVR32) 
     21/* AVR32 has these divide PBB */ 
     22const u8 atmel_tc_divisors[5] = { 0, 4, 8, 16, 32, }; 
     23EXPORT_SYMBOL(atmel_tc_divisors); 
     24 
     25#elif defined(CONFIG_ARCH_AT91) 
     26/* AT91 has these divide MCK */ 
     27const u8 atmel_tc_divisors[5] = { 2, 8, 32, 128, 0, }; 
     28EXPORT_SYMBOL(atmel_tc_divisors); 
     29 
     30#endif 
     31 
     32static DEFINE_SPINLOCK(tc_list_lock); 
     33static LIST_HEAD(tc_list); 
     34 
     35/** 
     36 * atmel_tc_alloc - allocate a specified TC block 
     37 * @block: which block to allocate 
     38 * @name: name to be associated with the iomem resource 
     39 * 
     40 * Caller allocates a block.  If it is available, a pointer to a 
     41 * pre-initialized struct atmel_tc is returned. The caller can access 
     42 * the registers directly through the "regs" field. 
     43 */ 
     44struct atmel_tc *atmel_tc_alloc(unsigned block, const char *name) 
     45{ 
     46        struct atmel_tc         *tc; 
     47        struct platform_device  *pdev = NULL; 
     48        struct resource         *r; 
     49 
     50        spin_lock(&tc_list_lock); 
     51        list_for_each_entry(tc, &tc_list, node) { 
     52                if (tc->pdev->id == block) { 
     53                        pdev = tc->pdev; 
     54                        break; 
     55                } 
     56        } 
     57 
     58        if (!pdev || tc->iomem) 
     59                goto fail; 
     60 
     61        r = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
     62        r = request_mem_region(r->start, ATMEL_TC_IOMEM_SIZE, name); 
     63        if (!r) 
     64                goto fail; 
     65 
     66        tc->regs = ioremap(r->start, ATMEL_TC_IOMEM_SIZE); 
     67        if (!tc->regs) 
     68                goto fail_ioremap; 
     69 
     70        tc->iomem = r; 
     71 
     72out: 
     73        spin_unlock(&tc_list_lock); 
     74        return tc; 
     75 
     76fail_ioremap: 
     77        release_resource(r); 
     78fail: 
     79        tc = NULL; 
     80        goto out; 
     81} 
     82EXPORT_SYMBOL_GPL(atmel_tc_alloc); 
     83 
     84/** 
     85 * atmel_tc_free - release a specified TC block 
     86 * @tc: Timer/counter block that was returned by atmel_tc_alloc() 
     87 * 
     88 * This reverses the effect of atmel_tc_alloc(), unmapping the I/O 
     89 * registers, invalidating the resource returned by that routine and 
     90 * making the TC available to other drivers. 
     91 */ 
     92void atmel_tc_free(struct atmel_tc *tc) 
     93{ 
     94        spin_lock(&tc_list_lock); 
     95        if (tc->regs) { 
     96                iounmap(tc->regs); 
     97                release_resource(tc->iomem); 
     98                tc->regs = NULL; 
     99                tc->iomem = NULL; 
     100        } 
     101        spin_unlock(&tc_list_lock); 
     102} 
     103EXPORT_SYMBOL_GPL(atmel_tc_free); 
     104 
     105static int __init tc_probe(struct platform_device *pdev) 
     106{ 
     107        struct atmel_tc *tc; 
     108        struct clk      *clk; 
     109        int             irq; 
     110 
     111        if (!platform_get_resource(pdev, IORESOURCE_MEM, 0)) 
     112                return -EINVAL; 
     113 
     114        irq = platform_get_irq(pdev, 0); 
     115        if (irq < 0) 
     116                return -EINVAL; 
     117 
     118        tc = kzalloc(sizeof(struct atmel_tc), GFP_KERNEL); 
     119        if (!tc) 
     120                return -ENOMEM; 
     121 
     122        tc->pdev = pdev; 
     123 
     124        clk = clk_get(&pdev->dev, "t0_clk"); 
     125        if (IS_ERR(clk)) { 
     126                kfree(tc); 
     127                return -EINVAL; 
     128        } 
     129 
     130        tc->clk[0] = clk; 
     131        tc->clk[1] = clk_get(&pdev->dev, "t1_clk"); 
     132        if (IS_ERR(tc->clk[1])) 
     133                tc->clk[1] = clk; 
     134        tc->clk[2] = clk_get(&pdev->dev, "t2_clk"); 
     135        if (IS_ERR(tc->clk[2])) 
     136                tc->clk[2] = clk; 
     137 
     138        tc->irq[0] = irq; 
     139        tc->irq[1] = platform_get_irq(pdev, 1); 
     140        if (tc->irq[1] < 0) 
     141                tc->irq[1] = irq; 
     142        tc->irq[2] = platform_get_irq(pdev, 2); 
     143        if (tc->irq[2] < 0) 
     144                tc->irq[2] = irq; 
     145 
     146        spin_lock(&tc_list_lock); 
     147        list_add_tail(&tc->node, &tc_list); 
     148        spin_unlock(&tc_list_lock); 
     149 
     150        return 0; 
     151} 
     152 
     153static struct platform_driver tc_driver = { 
     154        .driver.name    = "atmel_tcb", 
     155}; 
     156 
     157static int __init tc_init(void) 
     158{ 
     159        return platform_driver_probe(&tc_driver, tc_probe); 
     160} 
     161arch_initcall(tc_init); 
  • drivers/misc/Kconfig

    diff -urN avr32-old/drivers/misc/Kconfig avr32-new/drivers/misc/Kconfig
    old new  
    2222          purposes including software controlled power-efficent backlights 
    2323          on LCD displays, motor control, and waveform generation. 
    2424 
     25config ATMEL_TCLIB 
     26        bool "Atmel AT32/AT91 Timer/Counter Library" 
     27        depends on (AVR32 || ARCH_AT91) 
     28        help 
     29          Select this if you want a library to allocate the Timer/Counter 
     30          blocks found on many Atmel processors.  This facilitates using 
     31          these blocks by different drivers despite processor differences. 
     32 
     33config ATMEL_TCB_CLKSRC 
     34        bool "TC Block Clocksource" 
     35        depends on ATMEL_TCLIB && GENERIC_TIME 
     36        default y 
     37        help 
     38          Select this to get a high precision clocksource based on a 
     39          TC block with a 5+ MHz base clock rate.  Two timer channels 
     40          are combined to make a single 32-bit timer. 
     41 
     42          When GENERIC_CLOCKEVENTS is defined, the third timer channel 
     43          may be used as a clock event device supporting oneshot mode 
     44          (delays of up to two seconds) based on the 32 KiHz clock. 
     45 
     46config ATMEL_TCB_CLKSRC_BLOCK 
     47        int 
     48        depends on ATMEL_TCB_CLKSRC 
     49        prompt "TC Block" if ARCH_AT91RM9200 || ARCH_AT91SAM9260 || CPU_AT32AP700X 
     50        default 0 
     51        range 0 1 
     52        help 
     53          Some chips provide more than one TC block, so you have the 
     54          choice of which one to use for the clock framework.  The other 
     55          TC can be used for other purposes, such as PWM generation and 
     56          interval timing. 
     57 
    2558config IBM_ASM 
    2659        tristate "Device driver for IBM RSA service processor" 
    2760        depends on X86 && PCI && INPUT && EXPERIMENTAL 
  • drivers/misc/Makefile

    diff -urN avr32-old/drivers/misc/Makefile avr32-new/drivers/misc/Makefile
    old new  
    99obj-$(CONFIG_ASUS_LAPTOP)     += asus-laptop.o 
    1010obj-$(CONFIG_ATMEL_PWM)         += atmel_pwm.o 
    1111obj-$(CONFIG_ATMEL_SSC)         += atmel-ssc.o 
     12obj-$(CONFIG_ATMEL_TCLIB)       += atmel_tclib.o 
    1213obj-$(CONFIG_LKDTM)             += lkdtm.o 
    1314obj-$(CONFIG_TIFM_CORE)         += tifm_core.o 
    1415obj-$(CONFIG_TIFM_7XX1)         += tifm_7xx1.o 
  • drivers/mmc/host/atmel-mci.c

    diff -urN avr32-old/drivers/mmc/host/atmel-mci.c avr32-new/drivers/mmc/host/atmel-mci.c
    old new  
    3939        EVENT_STOP_COMPLETE, 
    4040        EVENT_DMA_COMPLETE, 
    4141        EVENT_DMA_ERROR, 
    42         EVENT_CARD_DETECT, 
    4342}; 
    4443 
    4544struct atmel_mci_dma { 
     
    7069        int                     detect_pin; 
    7170        int                     wp_pin; 
    7271 
     72        /* For detect pin debouncing */ 
     73        struct timer_list       detect_timer; 
     74 
    7375        unsigned long           bus_hz; 
    7476        unsigned long           mapbase; 
    7577        struct clk              *mck; 
     
    108110        test_bit(EVENT_DMA_COMPLETE, &host->completed_events) 
    109111#define mci_dma_error_is_complete(host)                 \ 
    110112        test_bit(EVENT_DMA_ERROR, &host->completed_events) 
    111 #define mci_card_detect_is_complete(host)                       \ 
    112         test_bit(EVENT_CARD_DETECT, &host->completed_events) 
    113113 
    114114/* Test and clear bit macros for pending events */ 
    115115#define mci_clear_cmd_is_pending(host)                  \ 
     
    124124        test_and_clear_bit(EVENT_STOP_COMPLETE, &host->pending_events) 
    125125#define mci_clear_dma_error_is_pending(host)            \ 
    126126        test_and_clear_bit(EVENT_DMA_ERROR, &host->pending_events) 
    127 #define mci_clear_card_detect_is_pending(host)          \ 
    128         test_and_clear_bit(EVENT_CARD_DETECT, &host->pending_events) 
    129127 
    130128/* Test and set bit macros for completed events */ 
    131129#define mci_set_cmd_is_completed(host)                  \ 
     
    140138        test_and_set_bit(EVENT_STOP_COMPLETE, &host->completed_events) 
    141139#define mci_set_dma_error_is_completed(host)            \ 
    142140        test_and_set_bit(EVENT_DMA_ERROR, &host->completed_events) 
    143 #define mci_set_card_detect_is_completed(host)          \ 
    144         test_and_set_bit(EVENT_CARD_DETECT, &host->completed_events) 
    145141 
    146142/* Set bit macros for completed events */ 
    147143#define mci_set_cmd_complete(host)                      \ 
     
    158154        set_bit(EVENT_DMA_COMPLETE, &host->completed_events) 
    159155#define mci_set_dma_error_complete(host)                \ 
    160156        set_bit(EVENT_DMA_ERROR, &host->completed_events) 
    161 #define mci_set_card_detect_complete(host)              \ 
    162         set_bit(EVENT_CARD_DETECT, &host->completed_events) 
    163157 
    164158/* Set bit macros for pending events */ 
    165159#define mci_set_cmd_pending(host)                       \ 
     
    174168        set_bit(EVENT_STOP_COMPLETE, &host->pending_events) 
    175169#define mci_set_dma_error_pending(host)                 \ 
    176170        set_bit(EVENT_DMA_ERROR, &host->pending_events) 
    177 #define mci_set_card_detect_pending(host)               \ 
    178         set_bit(EVENT_CARD_DETECT, &host->pending_events) 
    179171 
    180172/* Clear bit macros for pending events */ 
    181173#define mci_clear_cmd_pending(host)                     \ 
     
    190182        clear_bit(EVENT_STOP_COMPLETE, &host->pending_events) 
    191183#define mci_clear_dma_error_pending(host)               \ 
    192184        clear_bit(EVENT_DMA_ERROR, &host->pending_events) 
    193 #define mci_clear_card_detect_pending(host)             \ 
    194         clear_bit(EVENT_CARD_DETECT, &host->pending_events) 
    195185 
    196186 
    197187#ifdef CONFIG_DEBUG_FS 
     
    560550                                mci_readl(host, IMR)); 
    561551 
    562552        WARN_ON(host->mrq != NULL); 
     553 
     554        /* 
     555         * We may "know" the card is gone even though there's still an 
     556         * electrical connection. If so, we really need to communicate 
     557         * this to the MMC core since there won't be any more 
     558         * interrupts as the card is completely removed. Otherwise, 
     559         * the MMC core might believe the card is still there even 
     560         * though the card was just removed very slowly. 
     561         */ 
     562        if (!host->present) { 
     563                mrq->cmd->error = -ENOMEDIUM; 
     564                mmc_request_done(mmc, mrq); 
     565                return; 
     566        } 
     567 
    563568        host->mrq = mrq; 
    564569        host->pending_events = 0; 
    565570        host->completed_events = 0; 
     
    597602                u32 clkdiv; 
    598603 
    599604                /* Set clock rate */ 
    600                 clkdiv = host->bus_hz / (2 * ios->clock) - 1; 
     605                clkdiv = DIV_ROUND_UP(host->bus_hz, 2 * ios->clock) - 1; 
    601606                if (clkdiv > 255) { 
    602607                        dev_warn(&mmc->class_dev, 
    603608                                "clock %u too slow; using %lu\n", 
     
    729734        } 
    730735} 
    731736 
     737static void atmci_detect_change(unsigned long data) 
     738{ 
     739        struct atmel_mci *host = (struct atmel_mci *)data; 
     740        struct mmc_request *mrq = host->mrq; 
     741        int present; 
     742 
     743        /* 
     744         * atmci_remove() sets detect_pin to -1 before freeing the 
     745         * interrupt. We must not re-enable the interrupt if it has 
     746         * been freed. 
     747         */ 
     748        smp_rmb(); 
     749        if (host->detect_pin < 0) 
     750                return; 
     751 
     752        enable_irq(gpio_to_irq(host->detect_pin)); 
     753        present = !gpio_get_value(host->detect_pin); 
     754 
     755        dev_vdbg(&host->pdev->dev, "detect change: %d (was %d)\n", 
     756                        present, host->present); 
     757 
     758        if (present != host->present) { 
     759                dev_dbg(&host->mmc->class_dev, "card %s\n", 
     760                        present ? "inserted" : "removed"); 
     761                host->present = present; 
     762 
     763                /* Reset controller if card is gone */ 
     764                if (!present) { 
     765                        mci_writel(host, CR, MCI_BIT(SWRST)); 
     766                        mci_writel(host, IDR, ~0UL); 
     767                        mci_writel(host, CR, MCI_BIT(MCIEN)); 
     768                } 
     769 
     770                /* Clean up queue if present */ 
     771                if (mrq) { 
     772                        if (!mci_cmd_is_complete(host)) 
     773                                mrq->cmd->error = -ENOMEDIUM; 
     774                        if (mrq->data && !mci_data_is_complete(host) 
     775                            && !mci_data_error_is_complete(host)) { 
     776                                dma_stop_request(host->dma.req.req.dmac, 
     777                                                host->dma.req.req.channel); 
     778                                host->data->error = -ENOMEDIUM; 
     779                                atmci_data_complete(host, host->data); 
     780                        } 
     781                        if (mrq->stop && !mci_stop_is_complete(host)) 
     782                                mrq->stop->error = -ENOMEDIUM; 
     783 
     784                        host->cmd = NULL; 
     785                        atmci_request_end(host->mmc, mrq); 
     786                } 
     787 
     788                mmc_detect_change(host->mmc, 0); 
     789        } 
     790} 
     791 
    732792static void atmci_tasklet_func(unsigned long priv) 
    733793{ 
    734794        struct mmc_host *mmc = (struct mmc_host *)priv; 
     
    806866                data->bytes_xfered = data->blocks * data->blksz; 
    807867                atmci_data_complete(host, data); 
    808868        } 
    809         if (mci_clear_card_detect_is_pending(host)) { 
    810                 /* Reset controller if card is gone */ 
    811                 if (!host->present) { 
    812                         mci_writel(host, CR, MCI_BIT(SWRST)); 
    813                         mci_writel(host, IDR, ~0UL); 
    814                         mci_writel(host, CR, MCI_BIT(MCIEN)); 
    815                 } 
    816  
    817                 /* Clean up queue if present */ 
    818                 if (mrq) { 
    819                         if (!mci_cmd_is_complete(host)) 
    820                                 mrq->cmd->error = -ETIMEDOUT; 
    821                         if (mrq->data && !mci_data_is_complete(host) 
    822                             && !mci_data_error_is_complete(host)) { 
    823                                 dma_stop_request(host->dma.req.req.dmac, 
    824                                                 host->dma.req.req.channel); 
    825                                 host->data->error = -ETIMEDOUT; 
    826                                 atmci_data_complete(host, data); 
    827                         } 
    828                         if (mrq->stop && !mci_stop_is_complete(host)) 
    829                                 mrq->stop->error = -ETIMEDOUT; 
    830  
    831                         host->cmd = NULL; 
    832                         atmci_request_end(mmc, mrq); 
    833                 } 
    834                 mmc_detect_change(host->mmc, msecs_to_jiffies(100)); 
    835         } 
    836869} 
    837870 
    838871static void atmci_cmd_interrupt(struct mmc_host *mmc, u32 status) 
     
    856889                host->stop_status = status; 
    857890                mci_set_stop_pending(host); 
    858891        } else { 
    859                 if (host->mrq->stop && mci_dma_is_complete(host) 
     892                struct mmc_request *mrq = host->mrq; 
     893 
     894                if (mrq->stop && mci_dma_is_complete(host) 
    860895                                && !mci_set_stop_sent_is_completed(host)) 
    861                         send_stop_cmd(host->mmc, host->data, 0); 
     896                        send_stop_cmd(host->mmc, mrq->data, 0); 
    862897                host->cmd_status = status; 
    863898                mci_set_cmd_pending(host); 
    864899        } 
     
    955990        return IRQ_HANDLED; 
    956991} 
    957992 
    958 static irqreturn_t atmci_detect_change(int irq, void *dev_id) 
     993static irqreturn_t atmci_detect_interrupt(int irq, void *dev_id) 
    959994{ 
    960995        struct mmc_host *mmc = dev_id; 
    961996        struct atmel_mci *host = mmc_priv(mmc); 
    962997 
    963         int present = !gpio_get_value(irq_to_gpio(irq)); 
     998        /* 
     999         * Disable interrupts until the pin has stabilized and check 
     1000         * the state then. Use mod_timer() since we may be in the 
     1001         * middle of the timer routine when this interrupt triggers. 
     1002         */ 
     1003        disable_irq_nosync(irq); 
     1004        mod_timer(&host->detect_timer, jiffies + msecs_to_jiffies(20)); 
    9641005 
    965         if (present != host->present) { 
    966                 dev_dbg(&mmc->class_dev, "card %s\n", 
    967                         present ? "inserted" : "removed"); 
    968                 host->present = present; 
    969                 mci_set_card_detect_pending(host); 
    970                 tasklet_schedule(&host->tasklet); 
    971         } 
    9721006        return IRQ_HANDLED; 
    9731007} 
    9741008 
     
    10021036                host->wp_pin = board->wp_pin; 
    10031037        } else { 
    10041038                host->detect_pin = -1; 
    1005                 host->detect_pin = -1; 
     1039                host->wp_pin = -1; 
    10061040        } 
    10071041 
    10081042        host->mck = clk_get(&pdev->dev, "mci_clk"); 
     
    10771111        mmc_add_host(mmc); 
    10781112 
    10791113        if (host->detect_pin >= 0) { 
     1114                setup_timer(&host->detect_timer, atmci_detect_change, 
     1115                                (unsigned long)host); 
     1116 
    10801117                ret = request_irq(gpio_to_irq(host->detect_pin), 
    1081                                   atmci_detect_change, 
     1118                                  atmci_detect_interrupt, 
    10821119                                  IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, 
    10831120                                  DRIVER_NAME, mmc); 
    10841121                if (ret) { 
     
    11231160                atmci_cleanup_debugfs(host); 
    11241161 
    11251162                if (host->detect_pin >= 0) { 
    1126                         free_irq(gpio_to_irq(host->detect_pin), host->mmc); 
     1163                        int pin = host->detect_pin; 
     1164 
     1165                        /* Make sure our timer doesn't enable the interrupt */ 
     1166                        host->detect_pin = -1; 
     1167                        smp_wmb(); 
     1168 
     1169                        free_irq(gpio_to_irq(pin), host->mmc); 
     1170                        del_timer_sync(&host->detect_timer); 
    11271171                        cancel_delayed_work(&host->mmc->detect); 
    1128                         gpio_free(host->detect_pin); 
     1172                        gpio_free(pin); 
    11291173                } 
    11301174 
    11311175                mmc_remove_host(host->mmc); 
  • drivers/net/macb.c

    diff -urN avr32-old/drivers/net/macb.c avr32-new/drivers/net/macb.c
    old new  
    148148 
    149149                        if (phydev->duplex) 
    150150                                reg |= MACB_BIT(FD); 
    151                         if (phydev->speed) 
     151                        if (phydev->speed == SPEED_100) 
    152152                                reg |= MACB_BIT(SPD); 
    153153 
    154154                        macb_writel(bp, NCFGR, reg); 
  • drivers/serial/atmel_serial.c

    diff -urN avr32-old/drivers/serial/atmel_serial.c avr32-new/drivers/serial/atmel_serial.c
    old new  
    3737#include <linux/platform_device.h> 
    3838#include <linux/dma-mapping.h> 
    3939#include <linux/atmel_pdc.h> 
     40#include <linux/atmel_serial.h> 
    4041 
    4142#include <asm/io.h> 
    4243 
     
    4849#include <asm/arch/gpio.h> 
    4950#endif 
    5051 
    51 #include "atmel_serial.h" 
    52  
    5352#define PDC_BUFFER_SIZE         512 
    5453/* Revisit: We should calculate this based on the actual port settings */ 
    5554#define PDC_RX_TIMEOUT          (3 * 10)                /* 3 bytes */ 
  • drivers/serial/atmel_serial.h

    diff -urN avr32-old/drivers/serial/atmel_serial.h avr32-new/drivers/serial/atmel_serial.h
    old new  
    1 /* 
    2  * drivers/serial/atmel_serial.h 
    3  * 
    4  * Copyright (C) 2005 Ivan Kokshaysky 
    5  * Copyright (C) SAN People 
    6  * 
    7  * USART registers. 
    8  * Based on AT91RM9200 datasheet revision E. 
    9  * 
    10  * This program is free software; you can redistribute it and/or modify 
    11  * it under the terms of the GNU General Public License as published by 
    12  * the Free Software Foundation; either version 2 of the License, or 
    13  * (at your option) any later version. 
    14  */ 
    15  
    16 #ifndef ATMEL_SERIAL_H 
    17 #define ATMEL_SERIAL_H 
    18  
    19 #define ATMEL_US_CR             0x00                    /* Control Register */ 
    20 #define         ATMEL_US_RSTRX          (1 <<  2)               /* Reset Receiver */ 
    21 #define         ATMEL_US_RSTTX          (1 <<  3)               /* Reset Transmitter */ 
    22 #define         ATMEL_US_RXEN           (1 <<  4)               /* Receiver Enable */ 
    23 #define         ATMEL_US_RXDIS          (1 <<  5)               /* Receiver Disable */ 
    24 #define         ATMEL_US_TXEN           (1 <<  6)               /* Transmitter Enable */ 
    25 #define         ATMEL_US_TXDIS          (1 <<  7)               /* Transmitter Disable */ 
    26 #define         ATMEL_US_RSTSTA         (1 <<  8)               /* Reset Status Bits */ 
    27 #define         ATMEL_US_STTBRK         (1 <<  9)               /* Start Break */ 
    28 #define         ATMEL_US_STPBRK         (1 << 10)               /* Stop Break */ 
    29 #define         ATMEL_US_STTTO          (1 << 11)               /* Start Time-out */ 
    30 #define         ATMEL_US_SENDA          (1 << 12)               /* Send Address */ 
    31 #define         ATMEL_US_RSTIT          (1 << 13)               /* Reset Iterations */ 
    32 #define         ATMEL_US_RSTNACK        (1 << 14)               /* Reset Non Acknowledge */ 
    33 #define         ATMEL_US_RETTO          (1 << 15)               /* Rearm Time-out */ 
    34 #define         ATMEL_US_DTREN          (1 << 16)               /* Data Terminal Ready Enable [AT91RM9200 only] */ 
    35 #define         ATMEL_US_DTRDIS         (1 << 17)               /* Data Terminal Ready Disable [AT91RM9200 only] */ 
    36 #define         ATMEL_US_RTSEN          (1 << 18)               /* Request To Send Enable */ 
    37 #define         ATMEL_US_RTSDIS         (1 << 19)               /* Request To Send Disable */ 
    38  
    39 #define ATMEL_US_MR             0x04                    /* Mode Register */ 
    40 #define         ATMEL_US_USMODE         (0xf <<  0)             /* Mode of the USART */ 
    41 #define                 ATMEL_US_USMODE_NORMAL          0 
    42 #define                 ATMEL_US_USMODE_RS485           1 
    43 #define                 ATMEL_US_USMODE_HWHS            2 
    44 #define                 ATMEL_US_USMODE_MODEM           3 
    45 #define                 ATMEL_US_USMODE_ISO7816_T0      4 
    46 #define                 ATMEL_US_USMODE_ISO7816_T1      6 
    47 #define                 ATMEL_US_USMODE_IRDA            8 
    48 #define         ATMEL_US_USCLKS         (3   <<  4)             /* Clock Selection */ 
    49 #define                 ATMEL_US_USCLKS_MCK             (0 <<  4) 
    50 #define                 ATMEL_US_USCLKS_MCK_DIV8        (1 <<  4) 
    51 #define                 ATMEL_US_USCLKS_SCK             (3 <<  4) 
    52 #define         ATMEL_US_CHRL           (3   <<  6)             /* Character Length */ 
    53 #define                 ATMEL_US_CHRL_5                 (0 <<  6) 
    54 #define                 ATMEL_US_CHRL_6                 (1 <<  6) 
    55 #define                 ATMEL_US_CHRL_7                 (2 <<  6) 
    56 #define                 ATMEL_US_CHRL_8                 (3 <<  6) 
    57 #define         ATMEL_US_SYNC           (1 <<  8)               /* Synchronous Mode Select */ 
    58 #define         ATMEL_US_PAR            (7 <<  9)               /* Parity Type */ 
    59 #define                 ATMEL_US_PAR_EVEN               (0 <<  9) 
    60 #define                 ATMEL_US_PAR_ODD                (1 <<  9) 
    61 #define                 ATMEL_US_PAR_SPACE              (2 <<  9) 
    62 #define                 ATMEL_US_PAR_MARK               (3 <<  9) 
    63 #define                 ATMEL_US_PAR_NONE               (4 <<  9) 
    64 #define                 ATMEL_US_PAR_MULTI_DROP         (6 <<  9) 
    65 #define         ATMEL_US_NBSTOP         (3 << 12)               /* Number of Stop Bits */ 
    66 #define                 ATMEL_US_NBSTOP_1               (0 << 12) 
    67 #define                 ATMEL_US_NBSTOP_1_5             (1 << 12) 
    68 #define                 ATMEL_US_NBSTOP_2               (2 << 12) 
    69 #define         ATMEL_US_CHMODE         (3 << 14)               /* Channel Mode */ 
    70 #define                 ATMEL_US_CHMODE_NORMAL          (0 << 14) 
    71 #define                 ATMEL_US_CHMODE_ECHO            (1 << 14) 
    72 #define                 ATMEL_US_CHMODE_LOC_LOOP        (2 << 14) 
    73 #define                 ATMEL_US_CHMODE_REM_LOOP        (3 << 14) 
    74 #define         ATMEL_US_MSBF           (1 << 16)               /* Bit Order */ 
    75 #define         ATMEL_US_MODE9          (1 << 17)               /* 9-bit Character Length */ 
    76 #define         ATMEL_US_CLKO           (1 << 18)               /* Clock Output Select */ 
    77 #define         ATMEL_US_OVER           (1 << 19)               /* Oversampling Mode */ 
    78 #define         ATMEL_US_INACK          (1 << 20)               /* Inhibit Non Acknowledge */ 
    79 #define         ATMEL_US_DSNACK         (1 << 21)               /* Disable Successive NACK */ 
    80 #define         ATMEL_US_MAX_ITER       (7 << 24)               /* Max Iterations */ 
    81 #define         ATMEL_US_FILTER         (1 << 28)               /* Infrared Receive Line Filter */ 
    82  
    83 #define ATMEL_US_IER            0x08                    /* Interrupt Enable Register */ 
    84 #define         ATMEL_US_RXRDY          (1 <<  0)               /* Receiver Ready */ 
    85 #define         ATMEL_US_TXRDY          (1 <<  1)               /* Transmitter Ready */ 
    86 #define         ATMEL_US_RXBRK          (1 <<  2)               /* Break Received / End of Break */ 
    87 #define         ATMEL_US_ENDRX          (1 <<  3)               /* End of Receiver Transfer */ 
    88 #define         ATMEL_US_ENDTX          (1 <<  4)               /* End of Transmitter Transfer */ 
    89 #define         ATMEL_US_OVRE           (1 <<  5)               /* Overrun Error */ 
    90 #define         ATMEL_US_FRAME          (1 <<  6)               /* Framing Error */ 
    91 #define         ATMEL_US_PARE           (1 <<  7)               /* Parity Error */ 
    92 #define         ATMEL_US_TIMEOUT        (1 <<  8)               /* Receiver Time-out */ 
    93 #define         ATMEL_US_TXEMPTY        (1 <<  9)               /* Transmitter Empty */ 
    94 #define         ATMEL_US_ITERATION      (1 << 10)               /* Max number of Repetitions Reached */ 
    95 #define         ATMEL_US_TXBUFE         (1 << 11)               /* Transmission Buffer Empty */ 
    96 #define         ATMEL_US_RXBUFF         (1 << 12)               /* Reception Buffer Full */ 
    97 #define         ATMEL_US_NACK           (1 << 13)               /* Non Acknowledge */ 
    98 #define         ATMEL_US_RIIC           (1 << 16)               /* Ring Indicator Input Change [AT91RM9200 only] */ 
    99 #define         ATMEL_US_DSRIC          (1 << 17)               /* Data Set Ready Input Change [AT91RM9200 only] */ 
    100 #define         ATMEL_US_DCDIC          (1 << 18)               /* Data Carrier Detect Input Change [AT91RM9200 only] */ 
    101 #define         ATMEL_US_CTSIC          (1 << 19)               /* Clear to Send Input Change */ 
    102 #define         ATMEL_US_RI             (1 << 20)               /* RI */ 
    103 #define         ATMEL_US_DSR            (1 << 21)               /* DSR */ 
    104 #define         ATMEL_US_DCD            (1 << 22)               /* DCD */ 
    105 #define         ATMEL_US_CTS            (1 << 23)               /* CTS */ 
    106  
    107 #define ATMEL_US_IDR            0x0c                    /* Interrupt Disable Register */ 
    108 #define ATMEL_US_IMR            0x10                    /* Interrupt Mask Register */ 
    109 #define ATMEL_US_CSR            0x14                    /* Channel Status Register */ 
    110 #define ATMEL_US_RHR            0x18                    /* Receiver Holding Register */ 
    111 #define ATMEL_US_THR            0x1c                    /* Transmitter Holding Register */ 
    112 #define         ATMEL_US_SYNH           (1 << 15)               /* Transmit/Receive Sync [AT91SAM9261 only] */ 
    113  
    114 #define ATMEL_US_BRGR           0x20                    /* Baud Rate Generator Register */ 
    115 #define         ATMEL_US_CD             (0xffff << 0)           /* Clock Divider */ 
    116  
    117 #define ATMEL_US_RTOR           0x24                    /* Receiver Time-out Register */ 
    118 #define         ATMEL_US_TO             (0xffff << 0)           /* Time-out Value */ 
    119  
    120 #define ATMEL_US_TTGR           0x28                    /* Transmitter Timeguard Register */ 
    121 #define         ATMEL_US_TG             (0xff << 0)             /* Timeguard Value */ 
    122  
    123 #define ATMEL_US_FIDI           0x40                    /* FI DI Ratio Register */ 
    124 #define ATMEL_US_NER            0x44                    /* Number of Errors Register */ 
    125 #define ATMEL_US_IF             0x4c                    /* IrDA Filter Register */ 
    126  
    127 #endif 
  • drivers/spi/atmel_spi.c

    diff -urN avr32-old/drivers/spi/atmel_spi.c avr32-new/drivers/spi/atmel_spi.c
    old new  
    8787        unsigned gpio = (unsigned) spi->controller_data; 
    8888        unsigned active = spi->mode & SPI_CS_HIGH; 
    8989        u32 mr; 
     90        int i; 
     91        u32 csr; 
     92        u32 cpol = (spi->mode & SPI_CPOL) ? SPI_BIT(CPOL) : 0; 
     93 
     94        /* Make sure clock polarity is correct */ 
     95        for (i = 0; i < spi->master->num_chipselect; i++) { 
     96                csr = spi_readl(as, CSR0 + 4 * i); 
     97                if ((csr ^ cpol) & SPI_BIT(CPOL)) 
     98                        spi_writel(as, CSR0 + 4 * i, csr ^ SPI_BIT(CPOL)); 
     99        } 
    90100 
    91101        mr = spi_readl(as, MR); 
    92102        mr = SPI_BFINS(PCS, ~(1 << spi->chip_select), mr); 
  • drivers/usb/gadget/atmel_usba_udc.c

    diff -urN avr32-old/drivers/usb/gadget/atmel_usba_udc.c avr32-new/drivers/usb/gadget/atmel_usba_udc.c
    old new  
    1818#include <linux/platform_device.h> 
    1919#include <linux/usb/ch9.h> 
    2020#include <linux/usb/gadget.h> 
     21#include <linux/usb/atmel_usba_udc.h> 
    2122#include <linux/delay.h> 
    2223 
    2324#include <asm/gpio.h> 
     
    2728 
    2829 
    2930static struct usba_udc the_udc; 
     31static struct usba_ep *usba_ep; 
    3032 
    3133#ifdef CONFIG_USB_GADGET_DEBUG_FS 
    3234#include <linux/debugfs.h> 
     
    324326        return 1; 
    325327} 
    326328 
    327 static void copy_to_fifo(void __iomem *fifo, const void *buf, int len) 
    328 { 
    329         unsigned long tmp; 
    330  
    331         DBG(DBG_FIFO, "copy to FIFO (len %d):\n", len); 
    332         for (; len > 0; len -= 4, buf += 4, fifo += 4) { 
    333                 tmp = *(unsigned long *)buf; 
    334                 if (len >= 4) { 
    335                         DBG(DBG_FIFO, "  -> %08lx\n", tmp); 
    336                         __raw_writel(tmp, fifo); 
    337                 } else { 
    338                         do { 
    339                                 DBG(DBG_FIFO, "  -> %02lx\n", tmp >> 24); 
    340                                 __raw_writeb(tmp >> 24, fifo); 
    341                                 fifo++; 
    342                                 tmp <<= 8; 
    343                         } while (--len); 
    344                         break; 
    345                 } 
    346         } 
    347 } 
    348  
    349 static void copy_from_fifo(void *buf, void __iomem *fifo, int len) 
    350 { 
    351         union { 
    352                 unsigned long *w; 
    353                 unsigned char *b; 
    354         } p; 
    355         unsigned long tmp; 
    356  
    357         DBG(DBG_FIFO, "copy from FIFO (len %d):\n", len); 
    358         for (p.w = buf; len > 0; len -= 4, p.w++, fifo += 4) { 
    359                 if (len >= 4) { 
    360                         tmp = __raw_readl(fifo); 
    361                         *p.w = tmp; 
    362                         DBG(DBG_FIFO, "  -> %08lx\n", tmp); 
    363                 } else { 
    364                         do { 
    365                                 tmp = __raw_readb(fifo); 
    366                                 *p.b = tmp; 
    367                                 DBG(DBG_FIFO, " -> %02lx\n", tmp); 
    368                                 fifo++, p.b++; 
    369                         } while (--len); 
    370                 } 
    371         } 
    372 } 
    373  
    374329static void next_fifo_transaction(struct usba_ep *ep, struct usba_request *req) 
    375330{ 
    376331        unsigned int transaction_len; 
     
    387342                ep->ep.name, req, transaction_len, 
    388343                req->last_transaction ? ", done" : ""); 
    389344 
    390         copy_to_fifo(ep->fifo, req->req.buf + req->req.actual, transaction_len); 
     345        memcpy_toio(ep->fifo, req->req.buf + req->req.actual, transaction_len); 
    391346        usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY); 
    392347        req->req.actual += transaction_len; 
    393348} 
     
    476431                        bytecount = req->req.length - req->req.actual; 
    477432                } 
    478433 
    479                 copy_from_fifo(req->req.buf + req->req.actual, 
     434                memcpy_fromio(req->req.buf + req->req.actual, 
    480435                                ep->fifo, bytecount); 
    481436                req->req.actual += bytecount; 
    482437 
     
    1029984        .set_selfpowered        = usba_udc_set_selfpowered, 
    1030985}; 
    1031986 
    1032 #define EP(nam, idx, maxpkt, maxbk, dma, isoc)                  \ 
    1033 {                                                               \ 
    1034         .ep     = {                                             \ 
    1035                 .ops            = &usba_ep_ops,                 \ 
    1036                 .name           = nam,                          \ 
    1037                 .maxpacket      = maxpkt,                       \ 
    1038         },                                                      \ 
    1039         .udc            = &the_udc,                             \ 
    1040         .queue          = LIST_HEAD_INIT(usba_ep[idx].queue),   \ 
    1041         .fifo_size      = maxpkt,                               \ 
    1042         .nr_banks       = maxbk,                                \ 
    1043         .index          = idx,                                  \ 
    1044         .can_dma        = dma,                                  \ 
    1045         .can_isoc       = isoc,                                 \ 
    1046 } 
    1047  
    1048 static struct usba_ep usba_ep[] = { 
    1049         EP("ep0", 0, 64, 1, 0, 0), 
    1050         EP("ep1in-bulk", 1, 512, 2, 1, 1), 
    1051         EP("ep2out-bulk", 2, 512, 2, 1, 1), 
    1052         EP("ep3in-int", 3, 64, 3, 1, 0), 
    1053         EP("ep4out-int", 4, 64, 3, 1, 0), 
    1054         EP("ep5in-iso", 5, 1024, 3, 1, 1), 
    1055         EP("ep6out-iso", 6, 1024, 3, 1, 1), 
    1056 }; 
    1057 #undef EP 
    1058  
    1059987static struct usb_endpoint_descriptor usba_ep0_desc = { 
    1060988        .bLength = USB_DT_ENDPOINT_SIZE, 
    1061989        .bDescriptorType = USB_DT_ENDPOINT, 
     
    10741002static struct usba_udc the_udc = { 
    10751003        .gadget = { 
    10761004                .ops            = &usba_udc_ops, 
    1077                 .ep0            = &usba_ep[0].ep, 
    10781005                .ep_list        = LIST_HEAD_INIT(the_udc.gadget.ep_list), 
    10791006                .is_dualspeed   = 1, 
    10801007                .name           = "atmel_usba_udc", 
     
    12311158                } else { 
    12321159                        usba_ep_writel(ep, CTL_ENB, USBA_EPT_ENABLE); 
    12331160                        usba_writel(udc, TST, USBA_TST_PKT_MODE); 
    1234                         copy_to_fifo(ep->fifo, test_packet_buffer, 
     1161                        memcpy_toio(ep->fifo, test_packet_buffer, 
    12351162                                        sizeof(test_packet_buffer)); 
    12361163                        usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY); 
    12371164                        dev_info(dev, "Entering Test_Packet mode...\n"); 
     
    15391466                } 
    15401467 
    15411468                DBG(DBG_FIFO, "Copying ctrl request from 0x%p:\n", ep->fifo); 
    1542                 copy_from_fifo(crq.data, ep->fifo, sizeof(crq)); 
     1469                memcpy_fromio(crq.data, ep->fifo, sizeof(crq)); 
    15431470 
    15441471                /* Free up one bank in the FIFO so that we can 
    15451472                 * generate or receive a reply right away. */ 
     
    19111838 
    19121839        regs = platform_get_resource(pdev, IORESOURCE_MEM, CTRL_IOMEM_ID); 
    19131840        fifo = platform_get_resource(pdev, IORESOURCE_MEM, FIFO_IOMEM_ID); 
    1914         if (!regs || !fifo) 
     1841        if (!regs || !fifo || !pdata) 
    19151842                return -ENXIO; 
    19161843 
    19171844        irq = platform_get_irq(pdev, 0); 
     
    19591886        usba_writel(udc, CTRL, 0); 
    19601887        clk_disable(pclk); 
    19611888 
     1889        usba_ep = kmalloc(sizeof(struct usba_ep) * pdata->num_ep, 
     1890                          GFP_KERNEL); 
     1891        if (!usba_ep) 
     1892                goto err_alloc_ep; 
     1893 
     1894        the_udc.gadget.ep0 = &usba_ep[0].ep; 
     1895 
    19621896        INIT_LIST_HEAD(&usba_ep[0].ep.ep_list); 
    19631897        usba_ep[0].ep_regs = udc->regs + USBA_EPT_BASE(0); 
    19641898        usba_ep[0].dma_regs = udc->regs + USBA_DMA_BASE(0); 
    19651899        usba_ep[0].fifo = udc->fifo + USBA_FIFO_BASE(0); 
    1966         for (i = 1; i < ARRAY_SIZE(usba_ep); i++) { 
     1900        usba_ep[0].ep.ops = &usba_ep_ops; 
     1901        usba_ep[0].ep.name = pdata->ep[0].name; 
     1902        usba_ep[0].ep.maxpacket = pdata->ep[0].fifo_size; 
     1903        usba_ep[0].udc = &the_udc; 
     1904        INIT_LIST_HEAD(&usba_ep[0].queue); 
     1905        usba_ep[0].fifo_size = pdata->ep[0].fifo_size; 
     1906        usba_ep[0].nr_banks = pdata->ep[0].nr_banks; 
     1907        usba_ep[0].index = pdata->ep[0].index; 
     1908        usba_ep[0].can_dma = pdata->ep[0].can_dma; 
     1909        usba_ep[0].can_isoc = pdata->ep[0].can_isoc; 
     1910 
     1911        for (i = 1; i < pdata->num_ep; i++) { 
    19671912                struct usba_ep *ep = &usba_ep[i]; 
    19681913 
    19691914                ep->ep_regs = udc->regs + USBA_EPT_BASE(i); 
    19701915                ep->dma_regs = udc->regs + USBA_DMA_BASE(i); 
    19711916                ep->fifo = udc->fifo + USBA_FIFO_BASE(i); 
     1917                ep->ep.ops = &usba_ep_ops; 
     1918                ep->ep.name = pdata->ep[i].name; 
     1919                ep->ep.maxpacket = pdata->ep[i].fifo_size; 
     1920                ep->udc = &the_udc; 
     1921                INIT_LIST_HEAD(&ep->queue); 
     1922                ep->fifo_size = pdata->ep[i].fifo_size; 
     1923                ep->nr_banks = pdata->ep[i].nr_banks; 
     1924                ep->index = pdata->ep[i].index; 
     1925                ep->can_dma = pdata->ep[i].can_dma; 
     1926                ep->can_isoc = pdata->ep[i].can_isoc; 
    19721927 
    19731928                list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list); 
    19741929        } 
     
    19871942                goto err_device_add; 
    19881943        } 
    19891944 
    1990         if (pdata && pdata->vbus_pin != GPIO_PIN_NONE) { 
     1945        if (pdata->vbus_pin >= 0) { 
    19911946                if (!gpio_request(pdata->vbus_pin, "atmel_usba_udc")) { 
    19921947                        udc->vbus_pin = pdata->vbus_pin; 
    19931948 
     
    20071962        } 
    20081963 
    20091964        usba_init_debugfs(udc); 
    2010         for (i = 1; i < ARRAY_SIZE(usba_ep); i++) 
     1965        for (i = 1; i < pdata->num_ep; i++) 
    20111966                usba_ep_init_debugfs(udc, &usba_ep[i]); 
    20121967 
    20131968        return 0; 
     
    20151970err_device_add: 
    20161971        free_irq(irq, udc); 
    20171972err_request_irq: 
     1973        kfree(usba_ep); 
     1974err_alloc_ep: 
    20181975        iounmap(udc->fifo); 
    20191976err_map_fifo: 
    20201977        iounmap(udc->regs); 
     
    20321989{ 
    20331990        struct usba_udc *udc; 
    20341991        int i; 
     1992        struct usba_platform_data *pdata = pdev->dev.platform_data; 
    20351993 
    20361994        udc = platform_get_drvdata(pdev); 
    20371995 
    2038         for (i = 1; i < ARRAY_SIZE(usba_ep); i++) 
     1996        for (i = 1; i < pdata->num_ep; i++) 
    20391997                usba_ep_cleanup_debugfs(&usba_ep[i]); 
    20401998        usba_cleanup_debugfs(udc); 
    20411999 
  • include/asm-arm/arch-at91/at91rm9200.h

    diff -urN avr32-old/include/asm-arm/arch-at91/at91rm9200.h avr32-new/include/asm-arm/arch-at91/at91rm9200.h
    old new  
    9393#define AT91_RTC        (0xfffffe00 - AT91_BASE_SYS)    /* Real-Time Clock */ 
    9494#define AT91_MC         (0xffffff00 - AT91_BASE_SYS)    /* Memory Controllers */ 
    9595 
     96#define AT91_USART0     AT91RM9200_BASE_US0 
     97#define AT91_USART1     AT91RM9200_BASE_US1 
     98#define AT91_USART2     AT91RM9200_BASE_US2 
     99#define AT91_USART3     AT91RM9200_BASE_US3 
     100 
    96101#define AT91_MATRIX     0       /* not supported */ 
    97102 
    98103/* 
  • include/asm-arm/arch-at91/at91sam9260.h

    diff -urN avr32-old/include/asm-arm/arch-at91/at91sam9260.h avr32-new/include/asm-arm/arch-at91/at91sam9260.h
    old new  
    9999#define AT91_WDT        (0xfffffd40 - AT91_BASE_SYS) 
    100100#define AT91_GPBR       (0xfffffd50 - AT91_BASE_SYS) 
    101101 
     102#define AT91_USART0     AT91SAM9260_BASE_US0 
     103#define AT91_USART1     AT91SAM9260_BASE_US1 
     104#define AT91_USART2     AT91SAM9260_BASE_US2 
     105#define AT91_USART3     AT91SAM9260_BASE_US3 
     106#define AT91_USART4     AT91SAM9260_BASE_US4 
     107#define AT91_USART5     AT91SAM9260_BASE_US5 
     108 
    102109 
    103110/* 
    104111 * Internal Memory. 
  • include/asm-arm/arch-at91/at91sam9261.h

    diff -urN avr32-old/include/asm-arm/arch-at91/at91sam9261.h avr32-new/include/asm-arm/arch-at91/at91sam9261.h
    old new  
    8484#define AT91_WDT        (0xfffffd40 - AT91_BASE_SYS) 
    8585#define AT91_GPBR       (0xfffffd50 - AT91_BASE_SYS) 
    8686 
     87#define AT91_USART0     AT91SAM9261_BASE_US0 
     88#define AT91_USART1     AT91SAM9261_BASE_US1 
     89#define AT91_USART2     AT91SAM9261_BASE_US2 
     90 
    8791 
    8892/* 
    8993 * Internal Memory. 
  • include/asm-arm/arch-at91/at91sam9263.h

    diff -urN avr32-old/include/asm-arm/arch-at91/at91sam9263.h avr32-new/include/asm-arm/arch-at91/at91sam9263.h
    old new  
    101101#define AT91_RTT1       (0xfffffd50 - AT91_BASE_SYS) 
    102102#define AT91_GPBR       (0xfffffd60 - AT91_BASE_SYS) 
    103103 
     104#define AT91_USART0     AT91SAM9263_BASE_US0 
     105#define AT91_USART1     AT91SAM9263_BASE_US1 
     106#define AT91_USART2     AT91SAM9263_BASE_US2 
     107 
    104108#define AT91_SMC        AT91_SMC0 
    105109 
    106110/* 
  • include/asm-arm/arch-at91/at91sam9rl.h

    diff -urN avr32-old/include/asm-arm/arch-at91/at91sam9rl.h avr32-new/include/asm-arm/arch-at91/at91sam9rl.h
    old new  
    9494#define AT91_GPBR       (0xfffffd60 - AT91_BASE_SYS) 
    9595#define AT91_RTC        (0xfffffe00 - AT91_BASE_SYS) 
    9696 
     97#define AT91_USART0     AT91SAM9RL_BASE_US0 
     98#define AT91_USART1     AT91SAM9RL_BASE_US1 
     99#define AT91_USART2     AT91SAM9RL_BASE_US2 
     100#define AT91_USART3     AT91SAM9RL_BASE_US3 
     101 
    97102 
    98103/* 
    99104 * Internal Memory. 
  • include/asm-arm/arch-at91/uncompress.h

    diff -urN avr32-old/include/asm-arm/arch-at91/uncompress.h avr32-new/include/asm-arm/arch-at91/uncompress.h
    old new  
    2222#define __ASM_ARCH_UNCOMPRESS_H 
    2323 
    2424#include <asm/io.h> 
    25 #include <asm/arch/at91_dbgu.h> 
     25#include <linux/atmel_serial.h> 
     26 
     27#if defined(CONFIG_AT91_EARLY_DBGU) 
     28#define UART_OFFSET (AT91_DBGU + AT91_BASE_SYS) 
     29#elif defined(CONFIG_AT91_EARLY_USART0) 
     30#define UART_OFFSET AT91_USART0 
     31#elif defined(CONFIG_AT91_EARLY_USART1) 
     32#define UART_OFFSET AT91_USART1 
     33#elif defined(CONFIG_AT91_EARLY_USART2) 
     34#define UART_OFFSET AT91_USART2 
     35#elif defined(CONFIG_AT91_EARLY_USART3) 
     36#define UART_OFFSET AT91_USART3 
     37#elif defined(CONFIG_AT91_EARLY_USART4) 
     38#define UART_OFFSET AT91_USART4 
     39#elif defined(CONFIG_AT91_EARLY_USART5) 
     40#define UART_OFFSET AT91_USART5 
     41#endif 
    2642 
    2743/* 
    2844 * The following code assumes the serial port has already been 
     
    3349 */ 
    3450static void putc(int c) 
    3551{ 
    36 #ifdef AT91_DBGU 
    37         void __iomem *sys = (void __iomem *) AT91_BASE_SYS;     /* physical address */ 
     52#ifdef UART_OFFSET 
     53        void __iomem *sys = (void __iomem *) UART_OFFSET;       /* physical address */ 
    3854 
    39         while (!(__raw_readl(sys + AT91_DBGU_SR) & AT91_DBGU_TXRDY)) 
     55        while (!(__raw_readl(sys + ATMEL_US_CSR) & ATMEL_US_TXRDY)) 
    4056                barrier(); 
    41         __raw_writel(c, sys + AT91_DBGU_THR); 
     57        __raw_writel(c, sys + ATMEL_US_THR); 
    4258#endif 
    4359} 
    4460 
    4561static inline void flush(void) 
    4662{ 
    47 #ifdef AT91_DBGU 
    48         void __iomem *sys = (void __iomem *) AT91_BASE_SYS;     /* physical address */ 
     63#ifdef UART_OFFSET 
     64        void __iomem *sys = (void __iomem *) UART_OFFSET;       /* physical address */ 
    4965 
    5066        /* wait for transmission to complete */ 
    51         while (!(__raw_readl(sys + AT91_DBGU_SR) & AT91_DBGU_TXEMPTY)) 
     67        while (!(__raw_readl(sys + ATMEL_US_CSR) & ATMEL_US_TXEMPTY)) 
    5268                barrier(); 
    5369#endif 
    5470} 
  • include/asm-avr32/arch/board.h

    diff -urN avr32-old/include/asm-avr32/arch/board.h avr32-new/include/asm-avr32/arch/board.h
    old new  
    3838at32_add_device_lcdc(unsigned int id, struct atmel_lcdfb_info *data, 
    3939                     unsigned long fbmem_start, unsigned long fbmem_len); 
    4040 
    41 struct usba_platform_data { 
    42         int vbus_pin; 
    43 }; 
     41struct usba_platform_data; 
    4442struct platform_device * 
    4543at32_add_device_usba(unsigned int id, struct usba_platform_data *data); 
    4644 
     
    6866struct platform_device * 
    6967at32_add_device_ssc(unsigned int id, unsigned int flags); 
    7068 
    71 struct platform_device *at32_add_device_twi(unsigned int id); 
     69struct i2c_board_info; 
     70struct platform_device *at32_add_device_twi(unsigned int id, 
     71                                             struct i2c_board_info *b, 
     72                                             unsigned int n); 
    7273 
    7374struct mci_platform_data { 
    7475        int detect_pin; 
     
    9091at32_add_device_cf(unsigned int id, unsigned int extint, 
    9192                struct cf_platform_data *data); 
    9293 
     94struct platform_device * 
     95at32_add_device_psif(unsigned int id); 
     96 
    9397#endif /* __ASM_ARCH_BOARD_H */ 
  • include/asm-avr32/arch/pm.h

    diff -urN avr32-old/include/asm-avr32/arch/pm.h avr32-new/include/asm-avr32/arch/pm.h
    old new  
     1/* 
     2 * AVR32 AP Power Management. 
     3 * 
     4 * Copyright (C) 2008 Atmel Corporation 
     5 * 
     6 * This program is free software; you can redistribute it and/or modify 
     7 * it under the terms of the GNU General Public License version 2 as 
     8 * published by the Free Software Foundation. 
     9 */ 
     10#ifndef __ASM_AVR32_ARCH_PM_H 
     11#define __ASM_AVR32_ARCH_PM_H 
     12 
     13/* Possible arguments to the "sleep" instruction */ 
     14#define CPU_SLEEP_IDLE          0 
     15#define CPU_SLEEP_FROZEN        1 
     16#define CPU_SLEEP_STANDBY       2 
     17#define CPU_SLEEP_STOP          3 
     18#define CPU_SLEEP_STATIC        5 
     19 
     20#ifndef __ASSEMBLY__ 
     21extern void cpu_enter_idle(void); 
     22 
     23extern bool disable_idle_sleep; 
     24 
     25static inline void cpu_disable_idle_sleep(void) 
     26{ 
     27        disable_idle_sleep = true; 
     28} 
     29 
     30static inline void cpu_enable_idle_sleep(void) 
     31{ 
     32        disable_idle_sleep = false; 
     33} 
     34 
     35static inline void cpu_idle_sleep(void) 
     36{ 
     37        /* 
     38         * If we're using the COUNT and COMPARE registers for 
     39         * timekeeping, we can't use the IDLE state. 
     40         */ 
     41        if (disable_idle_sleep) 
     42                cpu_relax(); 
     43        else 
     44                cpu_enter_idle(); 
     45} 
     46#endif 
     47 
     48#endif /* __ASM_AVR32_ARCH_PM_H */ 
  • include/asm-avr32/arch/time.h

    diff -urN avr32-old/include/asm-avr32/arch/time.h avr32-new/include/asm-avr32/arch/time.h
    old new  
    1 /* 
    2  * Copyright (C) 2007 Atmel Corporation 
    3  * 
    4  * This program is free software; you can redistribute it and/or modify 
    5  * it under the terms of the GNU General Public License version 2 as 
    6  * published by the Free Software Foundation. 
    7  */ 
    8  
    9 #ifndef _ASM_AVR32_ARCH_AT32AP_TIME_H 
    10 #define _ASM_AVR32_ARCH_AT32AP_TIME_H 
    11  
    12 #include <linux/platform_device.h> 
    13  
    14 extern struct irqaction timer_irqaction; 
    15 extern struct platform_device at32_systc0_device; 
    16 extern void local_timer_interrupt(int irq, void *dev_id); 
    17  
    18 #define TIMER_BCR                                       0x000000c0 
    19 #define TIMER_BCR_SYNC                                           0 
    20 #define TIMER_BMR                                       0x000000c4 
    21 #define TIMER_BMR_TC0XC0S                                        0 
    22 #define TIMER_BMR_TC1XC1S                                        2 
    23 #define TIMER_BMR_TC2XC2S                                        4 
    24 #define TIMER_CCR                                       0x00000000 
    25 #define TIMER_CCR_CLKDIS                                         1 
    26 #define TIMER_CCR_CLKEN                                          0 
    27 #define TIMER_CCR_SWTRG                                          2 
    28 #define TIMER_CMR                                       0x00000004 
    29 #define TIMER_CMR_ABETRG                                        10 
    30 #define TIMER_CMR_ACPA                                          16 
    31 #define TIMER_CMR_ACPC                                          18 
    32 #define TIMER_CMR_AEEVT                                         20 
    33 #define TIMER_CMR_ASWTRG                                        22 
    34 #define TIMER_CMR_BCPB                                          24 
    35 #define TIMER_CMR_BCPC                                          26 
    36 #define TIMER_CMR_BEEVT                                         28 
    37 #define TIMER_CMR_BSWTRG                                        30 
    38 #define TIMER_CMR_BURST                                          4 
    39 #define TIMER_CMR_CLKI                                           3 
    40 #define TIMER_CMR_CPCDIS                                         7 
    41 #define TIMER_CMR_CPCSTOP                                        6 
    42 #define TIMER_CMR_CPCTRG                                        14 
    43 #define TIMER_CMR_EEVT                                          10 
    44 #define TIMER_CMR_EEVTEDG                                        8 
    45 #define TIMER_CMR_ENETRG                                        12 
    46 #define TIMER_CMR_ETRGEDG                                        8 
    47 #define TIMER_CMR_LDBDIS                                         7 
    48 #define TIMER_CMR_LDBSTOP                                        6 
    49 #define TIMER_CMR_LDRA                                          16 
    50 #define TIMER_CMR_LDRB                                          18 
    51 #define TIMER_CMR_TCCLKS                                         0 
    52 #define TIMER_CMR_WAVE                                          15 
    53 #define TIMER_CMR_WAVSEL                                        13 
    54 #define TIMER_CV                                        0x00000010 
    55 #define TIMER_CV_CV                                              0 
    56 #define TIMER_IDR                                       0x00000028 
    57 #define TIMER_IDR_COVFS                                          0 
    58 #define TIMER_IDR_CPAS                                           2 
    59 #define TIMER_IDR_CPBS                                           3 
    60 #define TIMER_IDR_CPCS                                           4 
    61 #define TIMER_IDR_ETRGS                                          7 
    62 #define TIMER_IDR_LDRAS                                          5 
    63 #define TIMER_IDR_LDRBS                                          6 
    64 #define TIMER_IDR_LOVRS                                          1 
    65 #define TIMER_IER                                       0x00000024 
    66 #define TIMER_IER_COVFS                                          0 
    67 #define TIMER_IER_CPAS                                           2 
    68 #define TIMER_IER_CPBS                                           3 
    69 #define TIMER_IER_CPCS                                           4 
    70 #define TIMER_IER_ETRGS                                          7 
    71 #define TIMER_IER_LDRAS                                          5 
    72 #define TIMER_IER_LDRBS                                          6 
    73 #define TIMER_IER_LOVRS                                          1 
    74 #define TIMER_IMR                                       0x0000002c 
    75 #define TIMER_IMR_COVFS                                          0 
    76 #define TIMER_IMR_CPAS                                           2 
    77 #define TIMER_IMR_CPBS                                           3 
    78 #define TIMER_IMR_CPCS                                           4 
    79 #define TIMER_IMR_ETRGS                                          7 
    80 #define TIMER_IMR_LDRAS                                          5 
    81 #define TIMER_IMR_LDRBS                                          6 
    82 #define TIMER_IMR_LOVRS                                          1 
    83 #define TIMER_RA                                        0x00000014 
    84 #define TIMER_RA_RA                                              0 
    85 #define TIMER_RB                                        0x00000018 
    86 #define TIMER_RB_RB                                              0 
    87 #define TIMER_RC                                        0x0000001c 
    88 #define TIMER_RC_RC                                              0 
    89 #define TIMER_SR                                        0x00000020 
    90 #define TIMER_SR_CLKSTA                                         16 
    91 #define TIMER_SR_COVFS                                           0 
    92 #define TIMER_SR_CPAS                                            2 
    93 #define TIMER_SR_CPBS                                            3 
    94 #define TIMER_SR_CPCS                                            4 
    95 #define TIMER_SR_ETRGS                                           7 
    96 #define TIMER_SR_LDRAS                                           5 
    97 #define TIMER_SR_LDRBS                                           6 
    98 #define TIMER_SR_LOVRS                                           1 
    99 #define TIMER_SR_MTIOA                                          17 
    100 #define TIMER_SR_MTIOB                                          18 
    101  
    102 /* Bit manipulation macros */ 
    103 #define TIMER_BIT(name)         (1 << TIMER_##name) 
    104 #define TIMER_BF(name,value)    ((value) << TIMER_##name) 
    105  
    106 /* Register access macros */ 
    107 #define timer_read(port,instance,reg) \ 
    108         __raw_readl(port + (0x40 * instance) + TIMER_##reg) 
    109 #define timer_write(port,instance,reg,value) \ 
    110         __raw_writel((value), port + (0x40 * instance) + TIMER_##reg) 
    111  
    112 #endif /* _ASM_AVR32_ARCH_AT32AP_TIME_H */ 
  • include/asm-avr32/arch-at32ap/board.h

    diff -urN avr32-old/include/asm-avr32/arch-at32ap/board.h avr32-new/include/asm-avr32/arch-at32ap/board.h
    old new  
    3838at32_add_device_lcdc(unsigned int id, struct atmel_lcdfb_info *data, 
    3939                     unsigned long fbmem_start, unsigned long fbmem_len); 
    4040 
    41 struct usba_platform_data { 
    42         int vbus_pin; 
    43 }; 
     41struct usba_platform_data; 
    4442struct platform_device * 
    4543at32_add_device_usba(unsigned int id, struct usba_platform_data *data); 
    4644 
     
    6866struct platform_device * 
    6967at32_add_device_ssc(unsigned int id, unsigned int flags); 
    7068 
    71 struct platform_device *at32_add_device_twi(unsigned int id); 
     69struct i2c_board_info; 
     70struct platform_device *at32_add_device_twi(unsigned int id, 
     71                                             struct i2c_board_info *b, 
     72                                             unsigned int n); 
    7273 
    7374struct mci_platform_data { 
    7475        int detect_pin; 
     
    9091at32_add_device_cf(unsigned int id, unsigned int extint, 
    9192                struct cf_platform_data *data); 
    9293 
     94struct platform_device * 
     95at32_add_device_psif(unsigned int id); 
     96 
    9397#endif /* __ASM_ARCH_BOARD_H */ 
  • include/asm-avr32/arch-at32ap/pm.h

    diff -urN avr32-old/include/asm-avr32/arch-at32ap/pm.h avr32-new/include/asm-avr32/arch-at32ap/pm.h
    old new  
     1/* 
     2 * AVR32 AP Power Management. 
     3 * 
     4 * Copyright (C) 2008 Atmel Corporation 
     5 * 
     6 * This program is free software; you can redistribute it and/or modify 
     7 * it under the terms of the GNU General Public License version 2 as 
     8 * published by the Free Software Foundation. 
     9 */ 
     10#ifndef __ASM_AVR32_ARCH_PM_H 
     11#define __ASM_AVR32_ARCH_PM_H 
     12 
     13/* Possible arguments to the "sleep" instruction */ 
     14#define CPU_SLEEP_IDLE          0 
     15#define CPU_SLEEP_FROZEN        1 
     16#define CPU_SLEEP_STANDBY       2 
     17#define CPU_SLEEP_STOP          3 
     18#define CPU_SLEEP_STATIC        5 
     19 
     20#ifndef __ASSEMBLY__ 
     21extern void cpu_enter_idle(void); 
     22 
     23extern bool disable_idle_sleep; 
     24 
     25static inline void cpu_disable_idle_sleep(void) 
     26{ 
     27        disable_idle_sleep = true; 
     28} 
     29 
     30static inline void cpu_enable_idle_sleep(void) 
     31{ 
     32        disable_idle_sleep = false; 
     33} 
     34 
     35static inline void cpu_idle_sleep(void) 
     36{ 
     37        /* 
     38         * If we're using the COUNT and COMPARE registers for 
     39         * timekeeping, we can't use the IDLE state. 
     40         */ 
     41        if (disable_idle_sleep) 
     42                cpu_relax(); 
     43        else 
     44                cpu_enter_idle(); 
     45} 
     46#endif 
     47 
     48#endif /* __ASM_AVR32_ARCH_PM_H */ 
  • include/asm-avr32/arch-at32ap/time.h

    diff -urN avr32-old/include/asm-avr32/arch-at32ap/time.h avr32-new/include/asm-avr32/arch-at32ap/time.h
    old new  
    1 /* 
    2  * Copyright (C) 2007 Atmel Corporation 
    3  * 
    4  * This program is free software; you can redistribute it and/or modify 
    5  * it under the terms of the GNU General Public License version 2 as 
    6  * published by the Free Software Foundation. 
    7  */ 
    8  
    9 #ifndef _ASM_AVR32_ARCH_AT32AP_TIME_H 
    10 #define _ASM_AVR32_ARCH_AT32AP_TIME_H 
    11  
    12 #include <linux/platform_device.h> 
    13  
    14 extern struct irqaction timer_irqaction; 
    15 extern struct platform_device at32_systc0_device; 
    16 extern void local_timer_interrupt(int irq, void *dev_id); 
    17  
    18 #define TIMER_BCR                                       0x000000c0 
    19 #define TIMER_BCR_SYNC                                           0 
    20 #define TIMER_BMR                                       0x000000c4 
    21 #define TIMER_BMR_TC0XC0S                                        0 
    22 #define TIMER_BMR_TC1XC1S                                        2 
    23 #define TIMER_BMR_TC2XC2S                                        4 
    24 #define TIMER_CCR                                       0x00000000 
    25 #define TIMER_CCR_CLKDIS                                         1 
    26 #define TIMER_CCR_CLKEN                                          0 
    27 #define TIMER_CCR_SWTRG                                          2 
    28 #define TIMER_CMR                                       0x00000004 
    29 #define TIMER_CMR_ABETRG                                        10 
    30 #define TIMER_CMR_ACPA                                          16 
    31 #define TIMER_CMR_ACPC                                          18 
    32 #define TIMER_CMR_AEEVT                                         20 
    33 #define TIMER_CMR_ASWTRG                                        22 
    34 #define TIMER_CMR_BCPB                                          24 
    35 #define TIMER_CMR_BCPC                                          26 
    36 #define TIMER_CMR_BEEVT                                         28 
    37 #define TIMER_CMR_BSWTRG                                        30 
    38 #define TIMER_CMR_BURST                                          4 
    39 #define TIMER_CMR_CLKI                                           3 
    40 #define TIMER_CMR_CPCDIS                                         7 
    41 #define TIMER_CMR_CPCSTOP                                        6 
    42 #define TIMER_CMR_CPCTRG                                        14 
    43 #define TIMER_CMR_EEVT                                          10 
    44 #define TIMER_CMR_EEVTEDG                                        8 
    45 #define TIMER_CMR_ENETRG                                        12 
    46 #define TIMER_CMR_ETRGEDG                                        8 
    47 #define TIMER_CMR_LDBDIS                                         7 
    48 #define TIMER_CMR_LDBSTOP                                        6 
    49 #define TIMER_CMR_LDRA                                          16 
    50 #define TIMER_CMR_LDRB                                          18 
    51 #define TIMER_CMR_TCCLKS                                         0 
    52 #define TIMER_CMR_WAVE                                          15 
    53 #define TIMER_CMR_WAVSEL                                        13 
    54 #define TIMER_CV                                        0x00000010 
    55 #define TIMER_CV_CV                                              0 
    56 #define TIMER_IDR                                       0x00000028 
    57 #define TIMER_IDR_COVFS                                          0 
    58 #define TIMER_IDR_CPAS                                           2 
    59 #define TIMER_IDR_CPBS                                           3 
    60 #define TIMER_IDR_CPCS                                           4 
    61 #define TIMER_IDR_ETRGS                                          7 
    62 #define TIMER_IDR_LDRAS                                          5 
    63 #define TIMER_IDR_LDRBS                                          6 
    64 #define TIMER_IDR_LOVRS                                          1 
    65 #define TIMER_IER                                       0x00000024 
    66 #define TIMER_IER_COVFS                                          0 
    67 #define TIMER_IER_CPAS                                           2 
    68 #define TIMER_IER_CPBS                                           3 
    69 #define TIMER_IER_CPCS                                           4 
    70 #define TIMER_IER_ETRGS                                          7 
    71 #define TIMER_IER_LDRAS                                          5 
    72 #define TIMER_IER_LDRBS                                          6 
    73 #define TIMER_IER_LOVRS                                          1 
    74 #define TIMER_IMR                                       0x0000002c 
    75 #define TIMER_IMR_COVFS                                          0 
    76 #define TIMER_IMR_CPAS                                           2 
    77 #define TIMER_IMR_CPBS                                           3 
    78 #define TIMER_IMR_CPCS                                           4 
    79 #define TIMER_IMR_ETRGS                                          7 
    80 #define TIMER_IMR_LDRAS                                          5 
    81 #define TIMER_IMR_LDRBS                                          6 
    82 #define TIMER_IMR_LOVRS                                          1 
    83 #define TIMER_RA                                        0x00000014 
    84 #define TIMER_RA_RA                                              0 
    85 #define TIMER_RB                                        0x00000018 
    86 #define TIMER_RB_RB                                              0 
    87 #define TIMER_RC                                        0x0000001c 
    88 #define TIMER_RC_RC                                              0 
    89 #define TIMER_SR                                        0x00000020 
    90 #define TIMER_SR_CLKSTA                                         16 
    91 #define TIMER_SR_COVFS                                           0 
    92 #define TIMER_SR_CPAS                                            2 
    93 #define TIMER_SR_CPBS                                            3 
    94 #define TIMER_SR_CPCS                                            4 
    95 #define TIMER_SR_ETRGS                                           7 
    96 #define TIMER_SR_LDRAS                                           5 
    97 #define TIMER_SR_LDRBS                                           6 
    98 #define TIMER_SR_LOVRS                                           1 
    99 #define TIMER_SR_MTIOA                                          17 
    100 #define TIMER_SR_MTIOB                                          18 
    101  
    102 /* Bit manipulation macros */ 
    103 #define TIMER_BIT(name)         (1 << TIMER_##name) 
    104 #define TIMER_BF(name,value)    ((value) << TIMER_##name) 
    105  
    106 /* Register access macros */ 
    107 #define timer_read(port,instance,reg) \ 
    108         __raw_readl(port + (0x40 * instance) + TIMER_##reg) 
    109 #define timer_write(port,instance,reg,value) \ 
    110         __raw_writel((value), port + (0x40 * instance) + TIMER_##reg) 
    111  
    112 #endif /* _ASM_AVR32_ARCH_AT32AP_TIME_H */ 
  • include/asm-avr32/asm.h

    diff -urN avr32-old/include/asm-avr32/asm.h avr32-new/include/asm-avr32/asm.h
    old new  
    1212#include <asm/asm-offsets.h> 
    1313#include <asm/thread_info.h> 
    1414 
    15 #define mask_interrupts         ssrf    SR_GM_BIT 
    16 #define mask_exceptions         ssrf    SR_EM_BIT 
    17 #define unmask_interrupts       csrf    SR_GM_BIT 
    18 #define unmask_exceptions       csrf    SR_EM_BIT 
     15#define mask_interrupts         ssrf    SYSREG_GM_OFFSET 
     16#define mask_exceptions         ssrf    SYSREG_EM_OFFSET 
     17#define unmask_interrupts       csrf    SYSREG_GM_OFFSET 
     18#define unmask_exceptions       csrf    SYSREG_EM_OFFSET 
    1919 
    2020#ifdef CONFIG_FRAME_POINTER 
    2121        .macro  save_fp 
  • include/asm-avr32/byteorder.h

    diff -urN avr32-old/include/asm-avr32/byteorder.h avr32-new/include/asm-avr32/byteorder.h
    old new  
    1212extern unsigned short __builtin_bswap_16(unsigned short x); 
    1313#endif 
    1414 
     15#if 0 
    1516#define __arch__swab32(x) __builtin_bswap_32(x) 
    1617#define __arch__swab16(x) __builtin_bswap_16(x) 
     18#endif 
    1719 
    1820#if !defined(__STRICT_ANSI__) || defined(__KERNEL__) 
    1921# define __BYTEORDER_HAS_U64__ 
  • include/asm-avr32/intc.h

    diff -urN avr32-old/include/asm-avr32/intc.h avr32-new/include/asm-avr32/intc.h
    old new  
    1 #ifndef __ASM_AVR32_INTC_H 
    2 #define __ASM_AVR32_INTC_H 
    3  
    4 #include <linux/sysdev.h> 
    5 #include <linux/interrupt.h> 
    6  
    7 struct irq_controller; 
    8 struct irqaction; 
    9 struct pt_regs; 
    10  
    11 struct platform_device; 
    12  
    13 /* Information about the internal interrupt controller */ 
    14 struct intc_device { 
    15         /* ioremapped address of configuration block */ 
    16         void __iomem *regs; 
    17  
    18         /* the physical device */ 
    19         struct platform_device *pdev; 
    20  
    21         /* Number of interrupt lines per group. */ 
    22         unsigned int irqs_per_group; 
    23  
    24         /* The highest group ID + 1 */ 
    25         unsigned int nr_groups; 
    26  
    27         /* 
    28          * Bitfield indicating which groups are actually in use.  The 
    29          * size of the array is 
    30          * ceil(group_max / (8 * sizeof(unsigned int))). 
    31          */ 
    32         unsigned int group_mask[]; 
    33 }; 
    34  
    35 struct irq_controller_class { 
    36         /* 
    37          * A short name identifying this kind of controller. 
    38          */ 
    39         const char *typename; 
    40         /* 
    41          * Handle the IRQ.  Must do any necessary acking and masking. 
    42          */ 
    43         irqreturn_t (*handle)(int irq, void *dev_id, struct pt_regs *regs); 
    44         /* 
    45          * Register a new IRQ handler. 
    46          */ 
    47         int (*setup)(struct irq_controller *ctrl, unsigned int irq, 
    48                      struct irqaction *action); 
    49         /* 
    50          * Unregister a IRQ handler. 
    51          */ 
    52         void (*free)(struct irq_controller *ctrl, unsigned int irq, 
    53                      void *dev_id); 
    54         /* 
    55          * Mask the IRQ in the interrupt controller. 
    56          */ 
    57         void (*mask)(struct irq_controller *ctrl, unsigned int irq); 
    58         /* 
    59          * Unmask the IRQ in the interrupt controller. 
    60          */ 
    61         void (*unmask)(struct irq_controller *ctrl, unsigned int irq); 
    62         /* 
    63          * Set the type of the IRQ. See below for possible types. 
    64          * Return -EINVAL if a given type is not supported 
    65          */ 
    66         int (*set_type)(struct irq_controller *ctrl, unsigned int irq, 
    67                         unsigned int type); 
    68         /* 
    69          * Return the IRQ type currently set 
    70          */ 
    71         unsigned int (*get_type)(struct irq_controller *ctrl, unsigned int irq); 
    72 }; 
    73  
    74 struct irq_controller { 
    75         struct irq_controller_class *class; 
    76         unsigned int irq_group; 
    77         unsigned int first_irq; 
    78         unsigned int nr_irqs; 
    79         struct list_head list; 
    80 }; 
    81  
    82 struct intc_group_desc { 
    83         struct irq_controller *ctrl; 
    84         irqreturn_t (*handle)(int, void *, struct pt_regs *); 
    85         unsigned long flags; 
    86         void *dev_id; 
    87         const char *devname; 
    88 }; 
    89  
    90 /* 
    91  * The internal interrupt controller.  Defined in board/part-specific 
    92  * devices.c. 
    93  * TODO: Should probably be defined per-cpu. 
    94  */ 
    95 extern struct intc_device intc; 
    96  
    97 extern int request_internal_irq(unsigned int irq, 
    98                                 irqreturn_t (*handler)(int, void *, struct pt_regs *), 
    99                                 unsigned long irqflags, 
    100                                 const char *devname, void *dev_id); 
    101 extern void free_internal_irq(unsigned int irq); 
    102  
    103 /* Only used by time_init() */ 
    104 extern int setup_internal_irq(unsigned int irq, struct intc_group_desc *desc); 
    105  
    106 /* 
    107  * Set interrupt priority for a given group. `group' can be found by 
    108  * using irq_to_group(irq). Priority can be from 0 (lowest) to 3 
    109  * (highest). Higher-priority interrupts will preempt lower-priority 
    110  * interrupts (unless interrupts are masked globally). 
    111  * 
    112  * This function does not check for conflicts within a group. 
    113  */ 
    114 extern int intc_set_priority(unsigned int group, 
    115                              unsigned int priority); 
    116  
    117 /* 
    118  * Returns a bitmask of pending interrupts in a group. 
    119  */ 
    120 extern unsigned long intc_get_pending(unsigned int group); 
    121  
    122 /* 
    123  * Register a new external interrupt controller.  Returns the first 
    124  * external IRQ number that is assigned to the new controller. 
    125  */ 
    126 extern int intc_register_controller(struct irq_controller *ctrl); 
    127  
    128 #endif /* __ASM_AVR32_INTC_H */ 
  • include/asm-avr32/irq.h

    diff -urN avr32-old/include/asm-avr32/irq.h avr32-new/include/asm-avr32/irq.h
    old new  
    1414#ifndef __ASSEMBLER__ 
    1515int nmi_enable(void); 
    1616void nmi_disable(void); 
     17 
     18/* 
     19 * Returns a bitmask of pending interrupts in a group. 
     20 */ 
     21extern unsigned long intc_get_pending(unsigned int group); 
    1722#endif 
    1823 
    1924#endif /* __ASM_AVR32_IOCTLS_H */ 
  • include/asm-avr32/pgtable.h

    diff -urN avr32-old/include/asm-avr32/pgtable.h avr32-new/include/asm-avr32/pgtable.h
    old new  
    157157#define _PAGE_S(x)      _PAGE_NORMAL(x) 
    158158 
    159159#define PAGE_COPY       _PAGE_P(PAGE_WRITE | PAGE_READ) 
     160#define PAGE_SHARED     _PAGE_S(PAGE_WRITE | PAGE_READ) 
    160161 
    161162#ifndef __ASSEMBLY__ 
    162163/* 
  • include/linux/atmel_serial.h

    diff -urN avr32-old/include/linux/atmel_serial.h avr32-new/include/linux/atmel_serial.h
    old new  
     1/* 
     2 * include/linux/atmel_serial.h 
     3 * 
     4 * Copyright (C) 2005 Ivan Kokshaysky 
     5 * Copyright (C) SAN People 
     6 * 
     7 * USART registers. 
     8 * Based on AT91RM9200 datasheet revision E. 
     9 * 
     10 * This program is free software; you can redistribute it and/or modify 
     11 * it under the terms of the GNU General Public License as published by 
     12 * the Free Software Foundation; either version 2 of the License, or 
     13 * (at your option) any later version. 
     14 */ 
     15 
     16#ifndef ATMEL_SERIAL_H 
     17#define ATMEL_SERIAL_H 
     18 
     19#define ATMEL_US_CR             0x00                    /* Control Register */ 
     20#define         ATMEL_US_RSTRX          (1 <<  2)               /* Reset Receiver */ 
     21#define         ATMEL_US_RSTTX          (1 <<  3)               /* Reset Transmitter */ 
     22#define         ATMEL_US_RXEN           (1 <<  4)               /* Receiver Enable */ 
     23#define         ATMEL_US_RXDIS          (1 <<  5)               /* Receiver Disable */ 
     24#define         ATMEL_US_TXEN           (1 <<  6)               /* Transmitter Enable */ 
     25#define         ATMEL_US_TXDIS          (1 <<  7)               /* Transmitter Disable */ 
     26#define         ATMEL_US_RSTSTA         (1 <<  8)               /* Reset Status Bits */ 
     27#define         ATMEL_US_STTBRK         (1 <<  9)               /* Start Break */ 
     28#define         ATMEL_US_STPBRK         (1 << 10)               /* Stop Break */ 
     29#define         ATMEL_US_STTTO          (1 << 11)               /* Start Time-out */ 
     30#define         ATMEL_US_SENDA          (1 << 12)               /* Send Address */ 
     31#define         ATMEL_US_RSTIT          (1 << 13)               /* Reset Iterations */ 
     32#define         ATMEL_US_RSTNACK        (1 << 14)               /* Reset Non Acknowledge */ 
     33#define         ATMEL_US_RETTO          (1 << 15)               /* Rearm Time-out */ 
     34#define         ATMEL_US_DTREN          (1 << 16)               /* Data Terminal Ready Enable [AT91RM9200 only] */ 
     35#define         ATMEL_US_DTRDIS         (1 << 17)               /* Data Terminal Ready Disable [AT91RM9200 only] */ 
     36#define         ATMEL_US_RTSEN          (1 << 18)               /* Request To Send Enable */ 
     37#define         ATMEL_US_RTSDIS         (1 << 19)               /* Request To Send Disable */ 
     38 
     39#define ATMEL_US_MR             0x04                    /* Mode Register */ 
     40#define         ATMEL_US_USMODE         (0xf <<  0)             /* Mode of the USART */ 
     41#define                 ATMEL_US_USMODE_NORMAL          0 
     42#define                 ATMEL_US_USMODE_RS485           1 
     43#define                 ATMEL_US_USMODE_HWHS            2 
     44#define                 ATMEL_US_USMODE_MODEM           3 
     45#define                 ATMEL_US_USMODE_ISO7816_T0      4 
     46#define                 ATMEL_US_USMODE_ISO7816_T1      6 
     47#define                 ATMEL_US_USMODE_IRDA            8 
     48#define         ATMEL_US_USCLKS         (3   <<  4)             /* Clock Selection */ 
     49#define                 ATMEL_US_USCLKS_MCK             (0 <<  4) 
     50#define                 ATMEL_US_USCLKS_MCK_DIV8        (1 <<  4) 
     51#define                 ATMEL_US_USCLKS_SCK             (3 <<  4) 
     52#define         ATMEL_US_CHRL           (3   <<  6)             /* Character Length */ 
     53#define                 ATMEL_US_CHRL_5                 (0 <<  6) 
     54#define                 ATMEL_US_CHRL_6                 (1 <<  6) 
     55#define                 ATMEL_US_CHRL_7                 (2 <<  6) 
     56#define                 ATMEL_US_CHRL_8                 (3 <<  6) 
     57#define         ATMEL_US_SYNC           (1 <<  8)               /* Synchronous Mode Select */ 
     58#define         ATMEL_US_PAR            (7 <<  9)               /* Parity Type */ 
     59#define                 ATMEL_US_PAR_EVEN               (0 <<  9) 
     60#define                 ATMEL_US_PAR_ODD                (1 <<  9) 
     61#define                 ATMEL_US_PAR_SPACE              (2 <<  9) 
     62#define                 ATMEL_US_PAR_MARK               (3 <<  9) 
     63#define                 ATMEL_US_PAR_NONE               (4 <<  9) 
     64#define                 ATMEL_US_PAR_MULTI_DROP         (6 <<  9) 
     65#define         ATMEL_US_NBSTOP         (3 << 12)               /* Number of Stop Bits */ 
     66#define                 ATMEL_US_NBSTOP_1               (0 << 12) 
     67#define                 ATMEL_US_NBSTOP_1_5             (1 << 12) 
     68#define                 ATMEL_US_NBSTOP_2               (2 << 12) 
     69#define         ATMEL_US_CHMODE         (3 << 14)               /* Channel Mode */ 
     70#define                 ATMEL_US_CHMODE_NORMAL          (0 << 14) 
     71#define                 ATMEL_US_CHMODE_ECHO            (1 << 14) 
     72#define                 ATMEL_US_CHMODE_LOC_LOOP        (2 << 14) 
     73#define                 ATMEL_US_CHMODE_REM_LOOP        (3 << 14) 
     74#define         ATMEL_US_MSBF           (1 << 16)               /* Bit Order */ 
     75#define         ATMEL_US_MODE9          (1 << 17)               /* 9-bit Character Length */ 
     76#define         ATMEL_US_CLKO           (1 << 18)               /* Clock Output Select */ 
     77#define         ATMEL_US_OVER           (1 << 19)               /* Oversampling Mode */ 
     78#define         ATMEL_US_INACK          (1 << 20)               /* Inhibit Non Acknowledge */ 
     79#define         ATMEL_US_DSNACK         (1 << 21)               /* Disable Successive NACK */ 
     80#define         ATMEL_US_MAX_ITER       (7 << 24)               /* Max Iterations */ 
     81#define         ATMEL_US_FILTER         (1 << 28)               /* Infrared Receive Line Filter */ 
     82 
     83#define ATMEL_US_IER            0x08                    /* Interrupt Enable Register */ 
     84#define         ATMEL_US_RXRDY          (1 <<  0)               /* Receiver Ready */ 
     85#define         ATMEL_US_TXRDY          (1 <<  1)               /* Transmitter Ready */ 
     86#define         ATMEL_US_RXBRK          (1 <<  2)               /* Break Received / End of Break */ 
     87#define         ATMEL_US_ENDRX          (1 <<  3)               /* End of Receiver Transfer */ 
     88#define         ATMEL_US_ENDTX          (1 <<  4)               /* End of Transmitter Transfer */ 
     89#define         ATMEL_US_OVRE           (1 <<  5)               /* Overrun Error */ 
     90#define         ATMEL_US_FRAME          (1 <<  6)               /* Framing Error */ 
     91#define         ATMEL_US_PARE           (1 <<  7)               /* Parity Error */ 
     92#define         ATMEL_US_TIMEOUT        (1 <<  8)               /* Receiver Time-out */ 
     93#define         ATMEL_US_TXEMPTY        (1 <<  9)               /* Transmitter Empty */ 
     94#define         ATMEL_US_ITERATION      (1 << 10)               /* Max number of Repetitions Reached */ 
     95#define         ATMEL_US_TXBUFE         (1 << 11)               /* Transmission Buffer Empty */ 
     96#define         ATMEL_US_RXBUFF         (1 << 12)               /* Reception Buffer Full */ 
     97#define         ATMEL_US_NACK           (1 << 13)               /* Non Acknowledge */ 
     98#define         ATMEL_US_RIIC           (1 << 16)               /* Ring Indicator Input Change [AT91RM9200 only] */ 
     99#define         ATMEL_US_DSRIC          (1 << 17)               /* Data Set Ready Input Change [AT91RM9200 only] */ 
     100#define         ATMEL_US_DCDIC          (1 << 18)               /* Data Carrier Detect Input Change [AT91RM9200 only] */ 
     101#define         ATMEL_US_CTSIC          (1 << 19)               /* Clear to Send Input Change */ 
     102#define         ATMEL_US_RI             (1 << 20)               /* RI */ 
     103#define         ATMEL_US_DSR            (1 << 21)               /* DSR */ 
     104#define         ATMEL_US_DCD            (1 << 22)               /* DCD */ 
     105#define         ATMEL_US_CTS            (1 << 23)               /* CTS */ 
     106 
     107#define ATMEL_US_IDR            0x0c                    /* Interrupt Disable Register */ 
     108#define ATMEL_US_IMR            0x10                    /* Interrupt Mask Register */ 
     109#define ATMEL_US_CSR            0x14                    /* Channel Status Register */ 
     110#define ATMEL_US_RHR            0x18                    /* Receiver Holding Register */ 
     111#define ATMEL_US_THR            0x1c                    /* Transmitter Holding Register */ 
     112#define         ATMEL_US_SYNH           (1 << 15)               /* Transmit/Receive Sync [AT91SAM9261 only] */ 
     113 
     114#define ATMEL_US_BRGR           0x20                    /* Baud Rate Generator Register */ 
     115#define         ATMEL_US_CD             (0xffff << 0)           /* Clock Divider */ 
     116 
     117#define ATMEL_US_RTOR           0x24                    /* Receiver Time-out Register */ 
     118#define         ATMEL_US_TO             (0xffff << 0)           /* Time-out Value */ 
     119 
     120#define ATMEL_US_TTGR           0x28                    /* Transmitter Timeguard Register */ 
     121#define         ATMEL_US_TG             (0xff << 0)             /* Timeguard Value */ 
     122 
     123#define ATMEL_US_FIDI           0x40                    /* FI DI Ratio Register */ 
     124#define ATMEL_US_NER            0x44                    /* Number of Errors Register */ 
     125#define ATMEL_US_IF             0x4c                    /* IrDA Filter Register */ 
     126 
     127#endif 
  • include/linux/atmel_tc.h

    diff -urN avr32-old/include/linux/atmel_tc.h avr32-new/include/linux/atmel_tc.h
    old new  
     1/* 
     2 * Timer/Counter Unit (TC) registers. 
     3 * 
     4 * This program is free software; you can redistribute it and/or modify 
     5 * it under the terms of the GNU General Public License as published by 
     6 * the Free Software Foundation; either version 2 of the License, or 
     7 * (at your option) any later version. 
     8 */ 
     9 
     10#ifndef ATMEL_TC_H 
     11#define ATMEL_TC_H 
     12 
     13#include <linux/compiler.h> 
     14#include <linux/list.h> 
     15 
     16/* 
     17 * Many 32-bit Atmel SOCs include one or more TC blocks, each of which holds 
     18 * three general-purpose 16-bit timers.  These timers share one register bank. 
     19 * Depending on the SOC, each timer may have its own clock and IRQ, or those 
     20 * may be shared by the whole TC block. 
     21 * 
     22 * These TC blocks may have up to nine external pins:  TCLK0..2 signals for 
     23 * clocks or clock gates, and per-timer TIOA and TIOB signals used for PWM 
     24 * or triggering.  Those pins need to be set up for use with the TC block, 
     25 * else they will be used as GPIOs or for a different controller. 
     26 * 
     27 * Although we expect each TC block to have a platform_device node, those 
     28 * nodes are not what drivers bind to.  Instead, they ask for a specific 
     29 * TC block, by number ... which is a common approach on systems with many 
     30 * timers.  Then they use clk_get() and platform_get_irq() to get clock and 
     31 * IRQ resources. 
     32 */ 
     33 
     34struct clk; 
     35 
     36/** 
     37 * struct atmel_tc - information about a Timer/Counter Block 
     38 * @pdev: physical device 
     39 * @iomem: resource associated with the I/O register 
     40 * @regs: mapping through which the I/O registers can be accessed 
     41 * @irq: irq for each of the three channels 
     42 * @clk: internal clock source for each of the three channels 
     43 * @node: list node, for tclib internal use 
     44 * 
     45 * On some platforms, each TC channel has its own clocks and IRQs, 
     46 * while on others, all TC channels share the same clock and IRQ. 
     47 * Drivers should clk_enable() all the clocks they need even though 
     48 * all the entries in @clk may point to the same physical clock. 
     49 * Likewise, drivers should request irqs independently for each 
     50 * channel, but they must use IRQF_SHARED in case some of the entries 
     51 * in @irq are actually the same IRQ. 
     52 */ 
     53struct atmel_tc { 
     54        struct platform_device  *pdev; 
     55        struct resource         *iomem; 
     56        void __iomem            *regs; 
     57        int                     irq[3]; 
     58        struct clk              *clk[3]; 
     59        struct list_head        node; 
     60}; 
     61 
     62extern struct atmel_tc *atmel_tc_alloc(unsigned block, const char *name); 
     63extern void atmel_tc_free(struct atmel_tc *tc); 
     64 
     65/* platform-specific ATMEL_TC_TIMER_CLOCKx divisors (0 means 32KiHz) */ 
     66extern const u8 atmel_tc_divisors[5]; 
     67 
     68 
     69/* 
     70 * Two registers have block-wide controls.  These are: configuring the three 
     71 * "external" clocks (or event sources) used by the timer channels; and 
     72 * synchronizing the timers by resetting them all at once. 
     73 * 
     74 * "External" can mean "external to chip" using the TCLK0, TCLK1, or TCLK2 
     75 * signals.  Or, it can mean "external to timer", using the TIOA output from 
     76 * one of the other two timers that's being run in waveform mode. 
     77 */ 
     78 
     79#define ATMEL_TC_BCR    0xc0            /* TC Block Control Register */ 
     80#define     ATMEL_TC_SYNC       (1 << 0)        /* synchronize timers */ 
     81 
     82#define ATMEL_TC_BMR    0xc4            /* TC Block Mode Register */ 
     83#define     ATMEL_TC_TC0XC0S    (3 << 0)        /* external clock 0 source */ 
     84#define        ATMEL_TC_TC0XC0S_TCLK0   (0 << 0) 
     85#define        ATMEL_TC_TC0XC0S_NONE    (1 << 0) 
     86#define        ATMEL_TC_TC0XC0S_TIOA1   (2 << 0) 
     87#define        ATMEL_TC_TC0XC0S_TIOA2   (3 << 0) 
     88#define     ATMEL_TC_TC1XC1S    (3 << 2)        /* external clock 1 source */ 
     89#define        ATMEL_TC_TC1XC1S_TCLK1   (0 << 2) 
     90#define        ATMEL_TC_TC1XC1S_NONE    (1 << 2) 
     91#define        ATMEL_TC_TC1XC1S_TIOA0   (2 << 2) 
     92#define        ATMEL_TC_TC1XC1S_TIOA2   (3 << 2) 
     93#define     ATMEL_TC_TC2XC2S    (3 << 4)        /* external clock 2 source */ 
     94#define        ATMEL_TC_TC2XC2S_TCLK2   (0 << 4) 
     95#define        ATMEL_TC_TC2XC2S_NONE    (1 << 4) 
     96#define        ATMEL_TC_TC2XC2S_TIOA0   (2 << 4) 
     97#define        ATMEL_TC_TC2XC2S_TIOA1   (3 << 4) 
     98 
     99 
     100/* 
     101 * Each TC block has three "channels", each with one counter and controls. 
     102 * 
     103 * Note that the semantics of ATMEL_TC_TIMER_CLOCKx (input clock selection 
     104 * when it's not "external") is silicon-specific.  AT91 platforms use one 
     105 * set of definitions; AVR32 platforms use a different set.  Don't hard-wire 
     106 * such knowledge into your code, use the global "atmel_tc_divisors" ... 
     107 * where index N is the divisor for clock N+1, else zero to indicate it uses 
     108 * the 32 KiHz clock. 
     109 * 
     110 * The timers can be chained in various ways, and operated in "waveform" 
     111 * generation mode (including PWM) or "capture" mode (to time events).  In 
     112 * both modes, behavior can be configured in many ways. 
     113 * 
     114 * Each timer has two I/O pins, TIOA and TIOB.  Waveform mode uses TIOA as a 
     115 * PWM output, and TIOB as either another PWM or as a trigger.  Capture mode 
     116 * uses them only as inputs. 
     117 */ 
     118#define ATMEL_TC_CHAN(idx)      ((idx)*0x40) 
     119#define ATMEL_TC_REG(idx, reg)  (ATMEL_TC_CHAN(idx) + ATMEL_TC_ ## reg) 
     120 
     121#define ATMEL_TC_CCR    0x00            /* Channel Control Register */ 
     122#define     ATMEL_TC_CLKEN      (1 << 0)        /* clock enable */ 
     123#define     ATMEL_TC_CLKDIS     (1 << 1)        /* clock disable */ 
     124#define     ATMEL_TC_SWTRG      (1 << 2)        /* software trigger */ 
     125 
     126#define ATMEL_TC_CMR    0x04            /* Channel Mode Register */ 
     127 
     128/* Both modes share some CMR bits */ 
     129#define     ATMEL_TC_TCCLKS     (7 << 0)        /* clock source */ 
     130#define        ATMEL_TC_TIMER_CLOCK1    (0 << 0) 
     131#define        ATMEL_TC_TIMER_CLOCK2    (1 << 0) 
     132#define        ATMEL_TC_TIMER_CLOCK3    (2 << 0) 
     133#define        ATMEL_TC_TIMER_CLOCK4    (3 << 0) 
     134#define        ATMEL_TC_TIMER_CLOCK5    (4 << 0) 
     135#define        ATMEL_TC_XC0             (5 << 0) 
     136#define        ATMEL_TC_XC1             (6 << 0) 
     137#define        ATMEL_TC_XC2             (7 << 0) 
     138#define     ATMEL_TC_CLKI       (1 << 3)        /* clock invert */ 
     139#define     ATMEL_TC_BURST      (3 << 4)        /* clock gating */ 
     140#define        ATMEL_TC_GATE_NONE       (0 << 4) 
     141#define        ATMEL_TC_GATE_XC0        (1 << 4) 
     142#define        ATMEL_TC_GATE_XC1        (2 << 4) 
     143#define        ATMEL_TC_GATE_XC2        (3 << 4) 
     144#define     ATMEL_TC_WAVE       (1 << 15)       /* true = Waveform mode */ 
     145 
     146/* CAPTURE mode CMR bits */ 
     147#define     ATMEL_TC_LDBSTOP    (1 << 6)        /* counter stops on RB load */ 
     148#define     ATMEL_TC_LDBDIS     (1 << 7)        /* counter disable on RB load */ 
     149#define     ATMEL_TC_ETRGEDG    (3 << 8)        /* external trigger edge */ 
     150#define        ATMEL_TC_ETRGEDG_NONE    (0 << 8) 
     151#define        ATMEL_TC_ETRGEDG_RISING  (1 << 8) 
     152#define        ATMEL_TC_ETRGEDG_FALLING (2 << 8) 
     153#define        ATMEL_TC_ETRGEDG_BOTH    (3 << 8) 
     154#define     ATMEL_TC_ABETRG     (1 << 10)       /* external trigger is TIOA? */ 
     155#define     ATMEL_TC_CPCTRG     (1 << 14)       /* RC compare trigger enable */ 
     156#define     ATMEL_TC_LDRA       (3 << 16)       /* RA loading edge (of TIOA) */ 
     157#define        ATMEL_TC_LDRA_NONE       (0 << 16) 
     158#define        ATMEL_TC_LDRA_RISING     (1 << 16) 
     159#define        ATMEL_TC_LDRA_FALLING    (2 << 16) 
     160#define        ATMEL_TC_LDRA_BOTH       (3 << 16) 
     161#define     ATMEL_TC_LDRB       (3 << 18)       /* RB loading edge (of TIOA) */ 
     162#define        ATMEL_TC_LDRB_NONE       (0 << 18) 
     163#define        ATMEL_TC_LDRB_RISING     (1 << 18) 
     164#define        ATMEL_TC_LDRB_FALLING    (2 << 18) 
     165#define        ATMEL_TC_LDRB_BOTH       (3 << 18) 
     166 
     167/* WAVEFORM mode CMR bits */ 
     168#define     ATMEL_TC_CPCSTOP    (1 <<  6)       /* RC compare stops counter */ 
     169#define     ATMEL_TC_CPCDIS     (1 <<  7)       /* RC compare disables counter */ 
     170#define     ATMEL_TC_EEVTEDG    (3 <<  8)       /* external event edge */ 
     171#define        ATMEL_TC_EEVTEDG_NONE    (0 << 8) 
     172#define        ATMEL_TC_EEVTEDG_RISING  (1 << 8) 
     173#define        ATMEL_TC_EEVTEDG_FALLING (2 << 8) 
     174#define        ATMEL_TC_EEVTEDG_BOTH    (3 << 8) 
     175#define     ATMEL_TC_EEVT       (3 << 10)       /* external event source */ 
     176#define        ATMEL_TC_EEVT_TIOB       (0 << 10) 
     177#define        ATMEL_TC_EEVT_XC0        (1 << 10) 
     178#define        ATMEL_TC_EEVT_XC1        (2 << 10) 
     179#define        ATMEL_TC_EEVT_XC2        (3 << 10) 
     180#define     ATMEL_TC_ENETRG     (1 << 12)       /* external event is trigger */ 
     181#define     ATMEL_TC_WAVESEL    (3 << 13)       /* waveform type */ 
     182#define        ATMEL_TC_WAVESEL_UP      (0 << 13) 
     183#define        ATMEL_TC_WAVESEL_UPDOWN  (1 << 13) 
     184#define        ATMEL_TC_WAVESEL_UP_AUTO (2 << 13) 
     185#define        ATMEL_TC_WAVESEL_UPDOWN_AUTO (3 << 13) 
     186#define     ATMEL_TC_ACPA       (3 << 16)       /* RA compare changes TIOA */ 
     187#define        ATMEL_TC_ACPA_NONE       (0 << 16) 
     188#define        ATMEL_TC_ACPA_SET        (1 << 16) 
     189#define        ATMEL_TC_ACPA_CLEAR      (2 << 16) 
     190#define        ATMEL_TC_ACPA_TOGGLE     (3 << 16) 
     191#define     ATMEL_TC_ACPC       (3 << 18)       /* RC compare changes TIOA */ 
     192#define        ATMEL_TC_ACPC_NONE       (0 << 18) 
     193#define        ATMEL_TC_ACPC_SET        (1 << 18) 
     194#define        ATMEL_TC_ACPC_CLEAR      (2 << 18) 
     195#define        ATMEL_TC_ACPC_TOGGLE     (3 << 18) 
     196#define     ATMEL_TC_AEEVT      (3 << 20)       /* external event changes TIOA */ 
     197#define        ATMEL_TC_AEEVT_NONE      (0 << 20) 
     198#define        ATMEL_TC_AEEVT_SET       (1 << 20) 
     199#define        ATMEL_TC_AEEVT_CLEAR     (2 << 20) 
     200#define        ATMEL_TC_AEEVT_TOGGLE    (3 << 20) 
     201#define     ATMEL_TC_ASWTRG     (3 << 22)       /* software trigger changes TIOA */ 
     202#define        ATMEL_TC_ASWTRG_NONE     (0 << 22) 
     203#define        ATMEL_TC_ASWTRG_SET      (1 << 22) 
     204#define        ATMEL_TC_ASWTRG_CLEAR    (2 << 22) 
     205#define        ATMEL_TC_ASWTRG_TOGGLE   (3 << 22) 
     206#define     ATMEL_TC_BCPB       (3 << 24)       /* RB compare changes TIOB */ 
     207#define        ATMEL_TC_BCPB_NONE       (0 << 24) 
     208#define        ATMEL_TC_BCPB_SET        (1 << 24) 
     209#define        ATMEL_TC_BCPB_CLEAR      (2 << 24) 
     210#define        ATMEL_TC_BCPB_TOGGLE     (3 << 24) 
     211#define     ATMEL_TC_BCPC       (3 << 26)       /* RC compare changes TIOB */ 
     212#define        ATMEL_TC_BCPC_NONE       (0 << 26) 
     213#define        ATMEL_TC_BCPC_SET        (1 << 26) 
     214#define        ATMEL_TC_BCPC_CLEAR      (2 << 26) 
     215#define        ATMEL_TC_BCPC_TOGGLE     (3 << 26) 
     216#define     ATMEL_TC_BEEVT      (3 << 28)       /* external event changes TIOB */ 
     217#define        ATMEL_TC_BEEVT_NONE      (0 << 28) 
     218#define        ATMEL_TC_BEEVT_SET       (1 << 28) 
     219#define        ATMEL_TC_BEEVT_CLEAR     (2 << 28) 
     220#define        ATMEL_TC_BEEVT_TOGGLE    (3 << 28) 
     221#define     ATMEL_TC_BSWTRG     (3 << 30)       /* software trigger changes TIOB */ 
     222#define        ATMEL_TC_BSWTRG_NONE     (0 << 30) 
     223#define        ATMEL_TC_BSWTRG_SET      (1 << 30) 
     224#define        ATMEL_TC_BSWTRG_CLEAR    (2 << 30) 
     225#define        ATMEL_TC_BSWTRG_TOGGLE   (3 << 30) 
     226 
     227#define ATMEL_TC_CV     0x10            /* counter Value */ 
     228#define ATMEL_TC_RA     0x14            /* register A */ 
     229#define ATMEL_TC_RB     0x18            /* register B */ 
     230#define ATMEL_TC_RC     0x1c            /* register C */ 
     231 
     232#define ATMEL_TC_SR     0x20            /* status (read-only) */ 
     233/* Status-only flags */ 
     234#define     ATMEL_TC_CLKSTA     (1 << 16)       /* clock enabled */ 
     235#define     ATMEL_TC_MTIOA      (1 << 17)       /* TIOA mirror */ 
     236#define     ATMEL_TC_MTIOB      (1 << 18)       /* TIOB mirror */ 
     237 
     238#define ATMEL_TC_IER    0x24            /* interrupt enable (write-only) */ 
     239#define ATMEL_TC_IDR    0x28            /* interrupt disable (write-only) */ 
     240#define ATMEL_TC_IMR    0x2c            /* interrupt mask (read-only) */ 
     241 
     242/* Status and IRQ flags */ 
     243#define     ATMEL_TC_COVFS      (1 <<  0)       /* counter overflow */ 
     244#define     ATMEL_TC_LOVRS      (1 <<  1)       /* load overrun */ 
     245#define     ATMEL_TC_CPAS       (1 <<  2)       /* RA compare */ 
     246#define     ATMEL_TC_CPBS       (1 <<  3)       /* RB compare */ 
     247#define     ATMEL_TC_CPCS       (1 <<  4)       /* RC compare */ 
     248#define     ATMEL_TC_LDRAS      (1 <<  5)       /* RA loading */ 
     249#define     ATMEL_TC_LDRBS      (1 <<  6)       /* RB loading */ 
     250#define     ATMEL_TC_ETRGS      (1 <<  7)       /* external trigger */ 
     251 
     252#endif 
  • include/linux/usb/atmel_usba_udc.h

    diff -urN avr32-old/include/linux/usb/atmel_usba_udc.h avr32-new/include/linux/usb/atmel_usba_udc.h
    old new  
     1/* 
     2 * Platform data definitions for Atmel USBA gadget driver. 
     3 */ 
     4#ifndef __LINUX_USB_USBA_H 
     5#define __LINUX_USB_USBA_H 
     6 
     7struct usba_ep_data { 
     8        char    *name; 
     9        int     index; 
     10        int     fifo_size; 
     11        int     nr_banks; 
     12        int     can_dma; 
     13        int     can_isoc; 
     14}; 
     15 
     16struct usba_platform_data { 
     17        int                     vbus_pin; 
     18        int                     num_ep; 
     19        struct usba_ep_data     ep[0]; 
     20}; 
     21 
     22#endif /* __LINUX_USB_USBA_H */ 
  • init/do_mounts.c

    diff -urN avr32-old/init/do_mounts.c avr32-new/init/do_mounts.c
    old new  
    219219 
    220220static int __init rootwait_setup(char *str) 
    221221{ 
    222         if (*str) 
     222        if (*str && *str != '=') 
    223223                return 0; 
     224 
     225        if (*str) 
     226                printk(KERN_WARNING 
     227                        "WARNING: \"rootwait=1\" is deprecated, " 
     228                        "use \"rootwait\" instead.\n"); 
     229 
    224230        root_wait = 1; 
    225231        return 1; 
    226232} 
  • localversion-atmel

    diff -urN avr32-old/localversion-atmel avr32-new/localversion-atmel
    old new  
     1.atmel.3 
  • sound/spi/at73c213.c

    diff -urN avr32-old/sound/spi/at73c213.c avr32-new/sound/spi/at73c213.c
    old new  
    744744/* 
    745745 * Device functions 
    746746 */ 
    747 static int snd_at73c213_ssc_init(struct snd_at73c213 *chip) 
     747static int __devinit snd_at73c213_ssc_init(struct snd_at73c213 *chip) 
    748748{ 
    749749        /* 
    750750         * Continuous clock output. 
     
    774774        return 0; 
    775775} 
    776776 
    777 static int snd_at73c213_chip_init(struct snd_at73c213 *chip) 
     777static int __devinit snd_at73c213_chip_init(struct snd_at73c213 *chip) 
    778778{ 
    779779        int retval; 
    780780        unsigned char dac_ctrl = 0; 
     
    939939        return retval; 
    940940} 
    941941 
    942 static int snd_at73c213_probe(struct spi_device *spi) 
     942static int __devinit snd_at73c213_probe(struct spi_device *spi) 
    943943{ 
    944944        struct snd_card                 *card; 
    945945        struct snd_at73c213             *chip;