Changeset 39770


Ignore:
Timestamp:
2014-02-28T21:30:08+01:00 (4 years ago)
Author:
florian
Message:

brcm2708: update against latest rpi-3.10.y branch

Update our copies of the brcm2708 patches to the latest rpi-3.10-y
rebased against linux-3.10.y stable (3.10.32). This should hopefully
make it easier for us in the future to leverage the raspberry/rpi-*
branches.

Signed-off-by: Florian Fainelli <florian@…>

Location:
trunk/target/linux/brcm2708
Files:
163 added
6 deleted
1 edited
10 moved

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/brcm2708/config-3.10

    r37470 r39770  
    202202CONFIG_PROC_PAGE_MONITOR=y 
    203203CONFIG_RAW_DRIVER=y 
     204# CONFIG_RTL8192CU is not set 
    204205CONFIG_SCSI=y 
    205206# CONFIG_SCSI_LOWLEVEL is not set 
  • trunk/target/linux/brcm2708/patches-3.10/0001-Main-bcm2708-linux-port.patch

    r39769 r39770  
     1From 47ecfc09ad3289994f80bd3dcaec876ac536d884 Mon Sep 17 00:00:00 2001 
     2From: popcornmix <popcornmix@gmail.com> 
     3Date: Sun, 12 May 2013 12:24:19 +0100 
     4Subject: [PATCH 001/174] Main bcm2708 linux port 
     5 
     6Signed-off-by: popcornmix <popcornmix@gmail.com> 
     7--- 
     8 arch/arm/Kconfig                                 |   16 + 
     9 arch/arm/Kconfig.debug                           |    8 + 
     10 arch/arm/Makefile                                |    1 + 
     11 arch/arm/configs/bcmrpi_cutdown_defconfig        |  474 +++++++ 
     12 arch/arm/configs/bcmrpi_defconfig                |  510 ++++++++ 
     13 arch/arm/configs/bcmrpi_emergency_defconfig      |  532 ++++++++ 
     14 arch/arm/kernel/process.c                        |    2 +- 
     15 arch/arm/mach-bcm2708/Kconfig                    |   34 + 
     16 arch/arm/mach-bcm2708/Makefile                   |    8 + 
     17 arch/arm/mach-bcm2708/Makefile.boot              |    3 + 
     18 arch/arm/mach-bcm2708/armctrl.c                  |  208 ++++ 
     19 arch/arm/mach-bcm2708/armctrl.h                  |   27 + 
     20 arch/arm/mach-bcm2708/bcm2708.c                  |  695 +++++++++++ 
     21 arch/arm/mach-bcm2708/bcm2708.h                  |   51 + 
     22 arch/arm/mach-bcm2708/bcm2708_gpio.c             |  339 +++++ 
     23 arch/arm/mach-bcm2708/clock.c                    |   61 + 
     24 arch/arm/mach-bcm2708/clock.h                    |   24 + 
     25 arch/arm/mach-bcm2708/dma.c                      |  399 ++++++ 
     26 arch/arm/mach-bcm2708/include/mach/arm_control.h |  419 +++++++ 
     27 arch/arm/mach-bcm2708/include/mach/arm_power.h   |   60 + 
     28 arch/arm/mach-bcm2708/include/mach/clkdev.h      |    7 + 
     29 arch/arm/mach-bcm2708/include/mach/debug-macro.S |   22 + 
     30 arch/arm/mach-bcm2708/include/mach/dma.h         |   86 ++ 
     31 arch/arm/mach-bcm2708/include/mach/entry-macro.S |   69 ++ 
     32 arch/arm/mach-bcm2708/include/mach/frc.h         |   38 + 
     33 arch/arm/mach-bcm2708/include/mach/gpio.h        |   18 + 
     34 arch/arm/mach-bcm2708/include/mach/hardware.h    |   28 + 
     35 arch/arm/mach-bcm2708/include/mach/io.h          |   27 + 
     36 arch/arm/mach-bcm2708/include/mach/irqs.h        |  196 +++ 
     37 arch/arm/mach-bcm2708/include/mach/memory.h      |   57 + 
     38 arch/arm/mach-bcm2708/include/mach/platform.h    |  220 ++++ 
     39 arch/arm/mach-bcm2708/include/mach/power.h       |   26 + 
     40 arch/arm/mach-bcm2708/include/mach/system.h      |   38 + 
     41 arch/arm/mach-bcm2708/include/mach/timex.h       |   23 + 
     42 arch/arm/mach-bcm2708/include/mach/uncompress.h  |   85 ++ 
     43 arch/arm/mach-bcm2708/include/mach/vc_mem.h      |   36 + 
     44 arch/arm/mach-bcm2708/include/mach/vcio.h        |  141 +++ 
     45 arch/arm/mach-bcm2708/include/mach/vmalloc.h     |   20 + 
     46 arch/arm/mach-bcm2708/power.c                    |  194 +++ 
     47 arch/arm/mach-bcm2708/vc_mem.c                   |  462 +++++++ 
     48 arch/arm/mach-bcm2708/vcio.c                     |  474 +++++++ 
     49 arch/arm/mm/Kconfig                              |    2 +- 
     50 arch/arm/mm/proc-v6.S                            |   15 +- 
     51 arch/arm/tools/mach-types                        |    1 + 
     52 drivers/mmc/host/Kconfig                         |   21 + 
     53 drivers/mmc/host/Makefile                        |    1 + 
     54 drivers/mmc/host/sdhci-bcm2708.c                 | 1425 ++++++++++++++++++++++ 
     55 drivers/mmc/host/sdhci.c                         |  209 +++- 
     56 drivers/mmc/host/sdhci.h                         |   37 + 
     57 include/linux/mmc/sdhci.h                        |    2 + 
     58 50 files changed, 7779 insertions(+), 72 deletions(-) 
     59 create mode 100644 arch/arm/configs/bcmrpi_cutdown_defconfig 
     60 create mode 100644 arch/arm/configs/bcmrpi_defconfig 
     61 create mode 100644 arch/arm/configs/bcmrpi_emergency_defconfig 
     62 create mode 100644 arch/arm/mach-bcm2708/Kconfig 
     63 create mode 100644 arch/arm/mach-bcm2708/Makefile 
     64 create mode 100644 arch/arm/mach-bcm2708/Makefile.boot 
     65 create mode 100644 arch/arm/mach-bcm2708/armctrl.c 
     66 create mode 100644 arch/arm/mach-bcm2708/armctrl.h 
     67 create mode 100644 arch/arm/mach-bcm2708/bcm2708.c 
     68 create mode 100644 arch/arm/mach-bcm2708/bcm2708.h 
     69 create mode 100644 arch/arm/mach-bcm2708/bcm2708_gpio.c 
     70 create mode 100644 arch/arm/mach-bcm2708/clock.c 
     71 create mode 100644 arch/arm/mach-bcm2708/clock.h 
     72 create mode 100644 arch/arm/mach-bcm2708/dma.c 
     73 create mode 100644 arch/arm/mach-bcm2708/include/mach/arm_control.h 
     74 create mode 100644 arch/arm/mach-bcm2708/include/mach/arm_power.h 
     75 create mode 100644 arch/arm/mach-bcm2708/include/mach/clkdev.h 
     76 create mode 100644 arch/arm/mach-bcm2708/include/mach/debug-macro.S 
     77 create mode 100644 arch/arm/mach-bcm2708/include/mach/dma.h 
     78 create mode 100644 arch/arm/mach-bcm2708/include/mach/entry-macro.S 
     79 create mode 100644 arch/arm/mach-bcm2708/include/mach/frc.h 
     80 create mode 100644 arch/arm/mach-bcm2708/include/mach/gpio.h 
     81 create mode 100644 arch/arm/mach-bcm2708/include/mach/hardware.h 
     82 create mode 100644 arch/arm/mach-bcm2708/include/mach/io.h 
     83 create mode 100644 arch/arm/mach-bcm2708/include/mach/irqs.h 
     84 create mode 100644 arch/arm/mach-bcm2708/include/mach/memory.h 
     85 create mode 100644 arch/arm/mach-bcm2708/include/mach/platform.h 
     86 create mode 100644 arch/arm/mach-bcm2708/include/mach/power.h 
     87 create mode 100644 arch/arm/mach-bcm2708/include/mach/system.h 
     88 create mode 100644 arch/arm/mach-bcm2708/include/mach/timex.h 
     89 create mode 100644 arch/arm/mach-bcm2708/include/mach/uncompress.h 
     90 create mode 100644 arch/arm/mach-bcm2708/include/mach/vc_mem.h 
     91 create mode 100644 arch/arm/mach-bcm2708/include/mach/vcio.h 
     92 create mode 100644 arch/arm/mach-bcm2708/include/mach/vmalloc.h 
     93 create mode 100644 arch/arm/mach-bcm2708/power.c 
     94 create mode 100644 arch/arm/mach-bcm2708/vc_mem.c 
     95 create mode 100644 arch/arm/mach-bcm2708/vcio.c 
     96 create mode 100644 drivers/mmc/host/sdhci-bcm2708.c 
     97 
     98--- a/arch/arm/Kconfig 
     99+++ b/arch/arm/Kconfig 
     100@@ -361,6 +361,21 @@ config ARCH_AT91 
     101          This enables support for systems based on Atmel 
     102          AT91RM9200 and AT91SAM9* processors. 
     103  
     104+config ARCH_BCM2708 
     105+       bool "Broadcom BCM2708 family" 
     106+       select CPU_V6 
     107+       select ARM_AMBA 
     108+       select HAVE_CLK 
     109+       select HAVE_SCHED_CLOCK 
     110+       select NEED_MACH_MEMORY_H 
     111+       select CLKDEV_LOOKUP 
     112+       select GENERIC_CLOCKEVENTS 
     113+       select ARM_ERRATA_411920 
     114+       select MACH_BCM2708 
     115+       select VC4 
     116+       help 
     117+         This enables support for Broadcom BCM2708 boards. 
     118+ 
     119 config ARCH_CLPS711X 
     120        bool "Cirrus Logic CLPS711x/EP721x/EP731x-based" 
     121        select ARCH_REQUIRE_GPIOLIB 
     122@@ -1025,6 +1040,7 @@ source "arch/arm/mach-virt/Kconfig" 
     123 source "arch/arm/mach-vt8500/Kconfig" 
     124  
     125 source "arch/arm/mach-w90x900/Kconfig" 
     126+source "arch/arm/mach-bcm2708/Kconfig" 
     127  
     128 source "arch/arm/mach-zynq/Kconfig" 
     129  
     130--- a/arch/arm/Kconfig.debug 
     131+++ b/arch/arm/Kconfig.debug 
     132@@ -519,6 +519,14 @@ choice 
     133                  For more details about semihosting, please see 
     134                  chapter 8 of DUI0203I_rvct_developer_guide.pdf from ARM Ltd. 
     135  
     136+       config DEBUG_BCM2708_UART0 
     137+               bool "Broadcom BCM2708 UART0 (PL011)" 
     138+               depends on MACH_BCM2708 
     139+               help 
     140+                 Say Y here if you want the debug print routines to direct 
     141+                 their output to UART 0. The port must have been initialised 
     142+                 by the boot-loader before use. 
     143+ 
     144 endchoice 
     145  
     146 config DEBUG_EXYNOS_UART 
     147--- a/arch/arm/Makefile 
     148+++ b/arch/arm/Makefile 
     149@@ -144,6 +144,7 @@ textofs-$(CONFIG_ARCH_MSM8960) := 0x0020 
     150 # by CONFIG_* macro name. 
     151 machine-$(CONFIG_ARCH_AT91)            += at91 
     152 machine-$(CONFIG_ARCH_BCM)             += bcm 
     153+machine-$(CONFIG_ARCH_BCM2708)         += bcm2708 
     154 machine-$(CONFIG_ARCH_BCM2835)         += bcm2835 
     155 machine-$(CONFIG_ARCH_CLPS711X)                += clps711x 
     156 machine-$(CONFIG_ARCH_CNS3XXX)         += cns3xxx 
    1157--- /dev/null 
    2158+++ b/arch/arm/configs/bcmrpi_cutdown_defconfig 
    3 @@ -0,0 +1,504 @@ 
     159@@ -0,0 +1,474 @@ 
    4160+CONFIG_EXPERIMENTAL=y 
    5161+# CONFIG_LOCALVERSION_AUTO is not set 
     
    212368+# CONFIG_LOGO_LINUX_MONO is not set 
    213369+# CONFIG_LOGO_LINUX_VGA16 is not set 
    214 +CONFIG_SOUND=y 
    215 +CONFIG_SND=m 
    216 +CONFIG_SND_SEQUENCER=m 
    217 +CONFIG_SND_SEQ_DUMMY=m 
    218 +CONFIG_SND_MIXER_OSS=m 
    219 +CONFIG_SND_PCM_OSS=m 
    220 +CONFIG_SND_SEQUENCER_OSS=y 
    221 +CONFIG_SND_HRTIMER=m 
    222 +CONFIG_SND_DUMMY=m 
    223 +CONFIG_SND_ALOOP=m 
    224 +CONFIG_SND_VIRMIDI=m 
    225 +CONFIG_SND_MTPAV=m 
    226 +CONFIG_SND_SERIAL_U16550=m 
    227 +CONFIG_SND_MPU401=m 
    228 +CONFIG_SND_BCM2835=m 
    229 +CONFIG_SND_USB_AUDIO=m 
    230 +CONFIG_SND_USB_UA101=m 
    231 +CONFIG_SND_USB_CAIAQ=m 
    232 +CONFIG_SND_USB_6FIRE=m 
    233 +CONFIG_SOUND_PRIME=m 
    234370+CONFIG_HID_PID=y 
    235371+CONFIG_USB_HIDDEV=y 
     
    496632+CONFIG_CRC_ITU_T=y 
    497633+CONFIG_LIBCRC32C=y 
    498 +CONFIG_I2C=y 
    499 +CONFIG_I2C_BOARDINFO=y 
    500 +CONFIG_I2C_COMPAT=y 
    501 +CONFIG_I2C_CHARDEV=m 
    502 +CONFIG_I2C_HELPER_AUTO=y 
    503 +CONFIG_I2C_BCM2708=m 
    504 +CONFIG_SPI=y 
    505 +CONFIG_SPI_MASTER=y 
    506 +CONFIG_SPI_BCM2708=m 
    507 + 
    508634--- /dev/null 
    509635+++ b/arch/arm/configs/bcmrpi_defconfig 
    510 @@ -0,0 +1,743 @@ 
    511 +# CONFIG_ARM_PATCH_PHYS_VIRT is not set 
     636@@ -0,0 +1,510 @@ 
     637+CONFIG_EXPERIMENTAL=y 
    512638+# CONFIG_LOCALVERSION_AUTO is not set 
    513639+CONFIG_SYSVIPC=y 
    514640+CONFIG_POSIX_MQUEUE=y 
     641+CONFIG_BSD_PROCESS_ACCT=y 
     642+CONFIG_BSD_PROCESS_ACCT_V3=y 
    515643+CONFIG_FHANDLE=y 
    516644+CONFIG_AUDIT=y 
    517 +CONFIG_NO_HZ=y 
    518 +CONFIG_HIGH_RES_TIMERS=y 
    519 +CONFIG_BSD_PROCESS_ACCT=y 
    520 +CONFIG_BSD_PROCESS_ACCT_V3=y 
    521645+CONFIG_IKCONFIG=y 
    522646+CONFIG_IKCONFIG_PROC=y 
     
    540664+# CONFIG_BLK_DEV_BSG is not set 
    541665+CONFIG_BLK_DEV_THROTTLING=y 
    542 +CONFIG_PARTITION_ADVANCED=y 
    543 +CONFIG_MAC_PARTITION=y 
    544666+CONFIG_CFQ_GROUP_IOSCHED=y 
    545667+CONFIG_ARCH_BCM2708=y 
     668+CONFIG_NO_HZ=y 
     669+CONFIG_HIGH_RES_TIMERS=y 
    546670+CONFIG_AEABI=y 
    547671+CONFIG_SECCOMP=y 
     
    551675+CONFIG_CMDLINE="dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 root=/dev/mmcblk0p2 rootfstype=ext3 rootwait" 
    552676+CONFIG_KEXEC=y 
    553 +CONFIG_CPU_FREQ=y 
    554 +CONFIG_CPU_FREQ_STAT=m 
    555 +CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE=y 
    556 +CONFIG_CPU_FREQ_GOV_PERFORMANCE=y 
    557 +CONFIG_CPU_FREQ_GOV_USERSPACE=y 
    558 +CONFIG_CPU_FREQ_GOV_ONDEMAND=y 
    559 +CONFIG_CPU_FREQ_GOV_CONSERVATIVE=y 
    560677+CONFIG_CPU_IDLE=y 
    561678+CONFIG_VFP=y 
     
    572689+CONFIG_IP_PNP_RARP=y 
    573690+CONFIG_SYN_COOKIES=y 
    574 +CONFIG_INET_AH=m 
    575 +CONFIG_INET_ESP=m 
    576 +CONFIG_INET_IPCOMP=m 
    577 +CONFIG_INET_XFRM_MODE_TRANSPORT=m 
    578 +CONFIG_INET_XFRM_MODE_TUNNEL=m 
    579 +CONFIG_INET_XFRM_MODE_BEET=m 
    580 +CONFIG_INET_LRO=m 
    581 +CONFIG_INET_DIAG=m 
    582 +CONFIG_IPV6_PRIVACY=y 
    583 +CONFIG_INET6_AH=m 
    584 +CONFIG_INET6_ESP=m 
    585 +CONFIG_INET6_IPCOMP=m 
    586 +CONFIG_IPV6_MULTIPLE_TABLES=y 
    587 +CONFIG_NETFILTER=y 
    588 +CONFIG_NF_CONNTRACK=m 
    589 +CONFIG_NF_CONNTRACK_ZONES=y 
    590 +CONFIG_NF_CONNTRACK_EVENTS=y 
    591 +CONFIG_NF_CONNTRACK_TIMESTAMP=y 
    592 +CONFIG_NF_CT_PROTO_DCCP=m 
    593 +CONFIG_NF_CT_PROTO_SCTP=m 
    594 +CONFIG_NF_CT_PROTO_UDPLITE=m 
    595 +CONFIG_NF_CONNTRACK_AMANDA=m 
    596 +CONFIG_NF_CONNTRACK_FTP=m 
    597 +CONFIG_NF_CONNTRACK_H323=m 
    598 +CONFIG_NF_CONNTRACK_IRC=m 
    599 +CONFIG_NF_CONNTRACK_NETBIOS_NS=m 
    600 +CONFIG_NF_CONNTRACK_SNMP=m 
    601 +CONFIG_NF_CONNTRACK_PPTP=m 
    602 +CONFIG_NF_CONNTRACK_SANE=m 
    603 +CONFIG_NF_CONNTRACK_SIP=m 
    604 +CONFIG_NF_CONNTRACK_TFTP=m 
    605 +CONFIG_NF_CT_NETLINK=m 
    606 +CONFIG_NETFILTER_TPROXY=m 
    607 +CONFIG_NETFILTER_XT_SET=m 
    608 +CONFIG_NETFILTER_XT_TARGET_AUDIT=m 
    609 +CONFIG_NETFILTER_XT_TARGET_CHECKSUM=m 
    610 +CONFIG_NETFILTER_XT_TARGET_CLASSIFY=m 
    611 +CONFIG_NETFILTER_XT_TARGET_CONNMARK=m 
    612 +CONFIG_NETFILTER_XT_TARGET_DSCP=m 
    613 +CONFIG_NETFILTER_XT_TARGET_IDLETIMER=m 
    614 +CONFIG_NETFILTER_XT_TARGET_MARK=m 
    615 +CONFIG_NETFILTER_XT_TARGET_NFLOG=m 
    616 +CONFIG_NETFILTER_XT_TARGET_NFQUEUE=m 
    617 +CONFIG_NETFILTER_XT_TARGET_NOTRACK=m 
    618 +CONFIG_NETFILTER_XT_TARGET_TEE=m 
    619 +CONFIG_NETFILTER_XT_TARGET_TPROXY=m 
    620 +CONFIG_NETFILTER_XT_TARGET_TRACE=m 
    621 +CONFIG_NETFILTER_XT_TARGET_TCPMSS=m 
    622 +CONFIG_NETFILTER_XT_TARGET_TCPOPTSTRIP=m 
    623 +CONFIG_NETFILTER_XT_MATCH_ADDRTYPE=m 
    624 +CONFIG_NETFILTER_XT_MATCH_CLUSTER=m 
    625 +CONFIG_NETFILTER_XT_MATCH_COMMENT=m 
    626 +CONFIG_NETFILTER_XT_MATCH_CONNBYTES=m 
    627 +CONFIG_NETFILTER_XT_MATCH_CONNLIMIT=m 
    628 +CONFIG_NETFILTER_XT_MATCH_CONNMARK=m 
    629 +CONFIG_NETFILTER_XT_MATCH_CONNTRACK=m 
    630 +CONFIG_NETFILTER_XT_MATCH_CPU=m 
    631 +CONFIG_NETFILTER_XT_MATCH_DCCP=m 
    632 +CONFIG_NETFILTER_XT_MATCH_DEVGROUP=m 
    633 +CONFIG_NETFILTER_XT_MATCH_DSCP=m 
    634 +CONFIG_NETFILTER_XT_MATCH_ESP=m 
    635 +CONFIG_NETFILTER_XT_MATCH_HASHLIMIT=m 
    636 +CONFIG_NETFILTER_XT_MATCH_HELPER=m 
    637 +CONFIG_NETFILTER_XT_MATCH_IPRANGE=m 
    638 +CONFIG_NETFILTER_XT_MATCH_LENGTH=m 
    639 +CONFIG_NETFILTER_XT_MATCH_LIMIT=m 
    640 +CONFIG_NETFILTER_XT_MATCH_MAC=m 
    641 +CONFIG_NETFILTER_XT_MATCH_MARK=m 
    642 +CONFIG_NETFILTER_XT_MATCH_MULTIPORT=m 
    643 +CONFIG_NETFILTER_XT_MATCH_OSF=m 
    644 +CONFIG_NETFILTER_XT_MATCH_OWNER=m 
    645 +CONFIG_NETFILTER_XT_MATCH_POLICY=m 
    646 +CONFIG_NETFILTER_XT_MATCH_PHYSDEV=m 
    647 +CONFIG_NETFILTER_XT_MATCH_PKTTYPE=m 
    648 +CONFIG_NETFILTER_XT_MATCH_QUOTA=m 
    649 +CONFIG_NETFILTER_XT_MATCH_RATEEST=m 
    650 +CONFIG_NETFILTER_XT_MATCH_REALM=m 
    651 +CONFIG_NETFILTER_XT_MATCH_RECENT=m 
    652 +CONFIG_NETFILTER_XT_MATCH_SCTP=m 
    653 +CONFIG_NETFILTER_XT_MATCH_SOCKET=m 
    654 +CONFIG_NETFILTER_XT_MATCH_STATE=m 
    655 +CONFIG_NETFILTER_XT_MATCH_STATISTIC=m 
    656 +CONFIG_NETFILTER_XT_MATCH_STRING=m 
    657 +CONFIG_NETFILTER_XT_MATCH_TCPMSS=m 
    658 +CONFIG_NETFILTER_XT_MATCH_TIME=m 
    659 +CONFIG_NETFILTER_XT_MATCH_U32=m 
    660 +CONFIG_IP_SET=m 
    661 +CONFIG_IP_SET_BITMAP_IP=m 
    662 +CONFIG_IP_SET_BITMAP_IPMAC=m 
    663 +CONFIG_IP_SET_BITMAP_PORT=m 
    664 +CONFIG_IP_SET_HASH_IP=m 
    665 +CONFIG_IP_SET_HASH_IPPORT=m 
    666 +CONFIG_IP_SET_HASH_IPPORTIP=m 
    667 +CONFIG_IP_SET_HASH_IPPORTNET=m 
    668 +CONFIG_IP_SET_HASH_NET=m 
    669 +CONFIG_IP_SET_HASH_NETPORT=m 
    670 +CONFIG_IP_SET_HASH_NETIFACE=m 
    671 +CONFIG_IP_SET_LIST_SET=m 
    672 +CONFIG_NF_CONNTRACK_IPV4=m 
    673 +CONFIG_IP_NF_IPTABLES=m 
    674 +CONFIG_IP_NF_MATCH_AH=m 
    675 +CONFIG_IP_NF_MATCH_ECN=m 
    676 +CONFIG_IP_NF_MATCH_TTL=m 
    677 +CONFIG_IP_NF_FILTER=m 
    678 +CONFIG_IP_NF_TARGET_REJECT=m 
    679 +CONFIG_IP_NF_TARGET_ULOG=m 
    680 +CONFIG_IP_NF_MANGLE=m 
    681 +CONFIG_IP_NF_TARGET_ECN=m 
    682 +CONFIG_IP_NF_TARGET_TTL=m 
    683 +CONFIG_IP_NF_RAW=m 
    684 +CONFIG_IP_NF_ARPTABLES=m 
    685 +CONFIG_IP_NF_ARPFILTER=m 
    686 +CONFIG_IP_NF_ARP_MANGLE=m 
    687 +CONFIG_NF_CONNTRACK_IPV6=m 
    688 +CONFIG_IP6_NF_IPTABLES=m 
    689 +CONFIG_IP6_NF_MATCH_AH=m 
    690 +CONFIG_IP6_NF_MATCH_EUI64=m 
    691 +CONFIG_IP6_NF_MATCH_FRAG=m 
    692 +CONFIG_IP6_NF_MATCH_OPTS=m 
    693 +CONFIG_IP6_NF_MATCH_HL=m 
    694 +CONFIG_IP6_NF_MATCH_IPV6HEADER=m 
    695 +CONFIG_IP6_NF_MATCH_MH=m 
    696 +CONFIG_IP6_NF_MATCH_RT=m 
    697 +CONFIG_IP6_NF_TARGET_HL=m 
    698 +CONFIG_IP6_NF_FILTER=m 
    699 +CONFIG_IP6_NF_TARGET_REJECT=m 
    700 +CONFIG_IP6_NF_MANGLE=m 
    701 +CONFIG_IP6_NF_RAW=m 
    702 +CONFIG_BRIDGE_NF_EBTABLES=m 
    703 +CONFIG_BRIDGE_EBT_BROUTE=m 
    704 +CONFIG_BRIDGE_EBT_T_FILTER=m 
    705 +CONFIG_BRIDGE_EBT_T_NAT=m 
    706 +CONFIG_BRIDGE_EBT_802_3=m 
    707 +CONFIG_BRIDGE_EBT_AMONG=m 
    708 +CONFIG_BRIDGE_EBT_ARP=m 
    709 +CONFIG_BRIDGE_EBT_IP=m 
    710 +CONFIG_BRIDGE_EBT_IP6=m 
    711 +CONFIG_BRIDGE_EBT_LIMIT=m 
    712 +CONFIG_BRIDGE_EBT_MARK=m 
    713 +CONFIG_BRIDGE_EBT_PKTTYPE=m 
    714 +CONFIG_BRIDGE_EBT_STP=m 
    715 +CONFIG_BRIDGE_EBT_VLAN=m 
    716 +CONFIG_BRIDGE_EBT_ARPREPLY=m 
    717 +CONFIG_BRIDGE_EBT_DNAT=m 
    718 +CONFIG_BRIDGE_EBT_MARK_T=m 
    719 +CONFIG_BRIDGE_EBT_REDIRECT=m 
    720 +CONFIG_BRIDGE_EBT_SNAT=m 
    721 +CONFIG_BRIDGE_EBT_LOG=m 
    722 +CONFIG_BRIDGE_EBT_ULOG=m 
    723 +CONFIG_BRIDGE_EBT_NFLOG=m 
    724 +CONFIG_L2TP=m 
    725 +CONFIG_BRIDGE=m 
    726 +CONFIG_VLAN_8021Q=m 
    727 +CONFIG_VLAN_8021Q_GVRP=y 
    728 +CONFIG_NET_SCHED=y 
    729 +CONFIG_NET_SCH_CBQ=m 
    730 +CONFIG_NET_SCH_HTB=m 
    731 +CONFIG_NET_SCH_HFSC=m 
    732 +CONFIG_NET_SCH_PRIO=m 
    733 +CONFIG_NET_SCH_MULTIQ=m 
    734 +CONFIG_NET_SCH_RED=m 
    735 +CONFIG_NET_SCH_SFB=m 
    736 +CONFIG_NET_SCH_SFQ=m 
    737 +CONFIG_NET_SCH_TEQL=m 
    738 +CONFIG_NET_SCH_TBF=m 
    739 +CONFIG_NET_SCH_GRED=m 
    740 +CONFIG_NET_SCH_DSMARK=m 
    741 +CONFIG_NET_SCH_NETEM=m 
    742 +CONFIG_NET_SCH_DRR=m 
    743 +CONFIG_NET_SCH_MQPRIO=m 
    744 +CONFIG_NET_SCH_CHOKE=m 
    745 +CONFIG_NET_SCH_QFQ=m 
    746 +CONFIG_NET_CLS_BASIC=m 
    747 +CONFIG_NET_CLS_TCINDEX=m 
    748 +CONFIG_NET_CLS_ROUTE4=m 
    749 +CONFIG_NET_CLS_FW=m 
    750 +CONFIG_NET_CLS_U32=m 
    751 +CONFIG_CLS_U32_MARK=y 
    752 +CONFIG_NET_CLS_RSVP=m 
    753 +CONFIG_NET_CLS_RSVP6=m 
    754 +CONFIG_NET_CLS_FLOW=m 
    755 +CONFIG_NET_CLS_CGROUP=m 
    756 +CONFIG_NET_EMATCH=y 
    757 +CONFIG_NET_EMATCH_CMP=m 
    758 +CONFIG_NET_EMATCH_NBYTE=m 
    759 +CONFIG_NET_EMATCH_U32=m 
    760 +CONFIG_NET_EMATCH_META=m 
    761 +CONFIG_NET_EMATCH_TEXT=m 
    762 +CONFIG_NET_CLS_ACT=y 
    763 +CONFIG_NET_ACT_POLICE=m 
    764 +CONFIG_NET_ACT_GACT=m 
    765 +CONFIG_GACT_PROB=y 
    766 +CONFIG_NET_ACT_MIRRED=m 
    767 +CONFIG_NET_ACT_IPT=m 
    768 +CONFIG_NET_ACT_NAT=m 
    769 +CONFIG_NET_ACT_PEDIT=m 
    770 +CONFIG_NET_ACT_SIMP=m 
    771 +CONFIG_NET_ACT_SKBEDIT=m 
    772 +CONFIG_NET_ACT_CSUM=m 
     691+# CONFIG_INET_XFRM_MODE_TRANSPORT is not set 
     692+# CONFIG_INET_XFRM_MODE_TUNNEL is not set 
     693+# CONFIG_INET_XFRM_MODE_BEET is not set 
     694+# CONFIG_INET_LRO is not set 
     695+# CONFIG_INET_DIAG is not set 
     696+# CONFIG_IPV6 is not set 
    773697+CONFIG_NET_PKTGEN=m 
    774698+CONFIG_IRDA=m 
     
    786710+CONFIG_MCS_FIR=m 
    787711+CONFIG_BT=m 
     712+CONFIG_BT_L2CAP=y 
     713+CONFIG_BT_SCO=y 
    788714+CONFIG_BT_RFCOMM=m 
    789715+CONFIG_BT_RFCOMM_TTY=y 
     
    809735+CONFIG_NFC_PN533=m 
    810736+CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug" 
    811 +CONFIG_DEVTMPFS=y 
    812 +CONFIG_DEVTMPFS_MOUNT=y 
    813737+CONFIG_BLK_DEV_LOOP=y 
    814738+CONFIG_BLK_DEV_CRYPTOLOOP=m 
    815 +CONFIG_BLK_DEV_DRBD=m 
    816739+CONFIG_BLK_DEV_NBD=m 
    817740+CONFIG_BLK_DEV_RAM=y 
    818741+CONFIG_CDROM_PKTCDVD=m 
     742+CONFIG_MISC_DEVICES=y 
    819743+CONFIG_SCSI=y 
    820744+# CONFIG_SCSI_PROC_FS is not set 
     
    825749+CONFIG_MD=y 
    826750+CONFIG_NETDEVICES=y 
    827 +CONFIG_NETCONSOLE=m 
    828751+CONFIG_TUN=m 
     752+CONFIG_PHYLIB=m 
    829753+CONFIG_MDIO_BITBANG=m 
    830 +CONFIG_PPP=m 
    831 +CONFIG_PPP_BSDCOMP=m 
    832 +CONFIG_PPP_DEFLATE=m 
    833 +CONFIG_PPP_ASYNC=m 
    834 +CONFIG_PPP_SYNC_TTY=m 
    835 +CONFIG_SLIP=m 
    836 +CONFIG_SLIP_COMPRESSED=y 
     754+CONFIG_NET_ETHERNET=y 
     755+# CONFIG_NETDEV_1000 is not set 
     756+# CONFIG_NETDEV_10000 is not set 
     757+CONFIG_LIBERTAS_THINFIRM=m 
     758+CONFIG_LIBERTAS_THINFIRM_USB=m 
     759+CONFIG_AT76C50X_USB=m 
     760+CONFIG_USB_ZD1201=m 
     761+CONFIG_USB_NET_RNDIS_WLAN=m 
     762+CONFIG_RTL8187=m 
     763+CONFIG_MAC80211_HWSIM=m 
     764+CONFIG_ATH_COMMON=m 
     765+CONFIG_ATH9K=m 
     766+CONFIG_ATH9K_HTC=m 
     767+CONFIG_CARL9170=m 
     768+CONFIG_B43=m 
     769+CONFIG_B43LEGACY=m 
     770+CONFIG_HOSTAP=m 
     771+CONFIG_IWM=m 
     772+CONFIG_LIBERTAS=m 
     773+CONFIG_LIBERTAS_USB=m 
     774+CONFIG_LIBERTAS_SDIO=m 
     775+CONFIG_P54_COMMON=m 
     776+CONFIG_P54_USB=m 
     777+CONFIG_RT2X00=m 
     778+CONFIG_RT2500USB=m 
     779+CONFIG_RT73USB=m 
     780+CONFIG_RT2800USB=m 
     781+CONFIG_RT2800USB_RT53XX=y 
     782+CONFIG_RTL8192CU=m 
     783+CONFIG_WL1251=m 
     784+CONFIG_WL12XX_MENU=m 
     785+CONFIG_ZD1211RW=m 
     786+CONFIG_MWIFIEX=m 
     787+CONFIG_MWIFIEX_SDIO=m 
     788+CONFIG_WIMAX_I2400M_USB=m 
    837789+CONFIG_USB_CATC=m 
    838790+CONFIG_USB_KAWETH=m 
     
    861813+CONFIG_USB_SIERRA_NET=m 
    862814+CONFIG_USB_VL600=m 
    863 +CONFIG_LIBERTAS_THINFIRM=m 
    864 +CONFIG_LIBERTAS_THINFIRM_USB=m 
    865 +CONFIG_AT76C50X_USB=m 
    866 +CONFIG_USB_ZD1201=m 
    867 +CONFIG_USB_NET_RNDIS_WLAN=m 
    868 +CONFIG_RTL8187=m 
    869 +CONFIG_MAC80211_HWSIM=m 
    870 +CONFIG_B43=m 
    871 +CONFIG_B43LEGACY=m 
    872 +CONFIG_HOSTAP=m 
    873 +CONFIG_LIBERTAS=m 
    874 +CONFIG_LIBERTAS_USB=m 
    875 +CONFIG_LIBERTAS_SDIO=m 
    876 +CONFIG_P54_COMMON=m 
    877 +CONFIG_P54_USB=m 
    878 +CONFIG_RT2X00=m 
    879 +CONFIG_RT2500USB=m 
    880 +CONFIG_RT73USB=m 
    881 +CONFIG_RT2800USB=m 
    882 +CONFIG_RT2800USB_RT53XX=y 
    883 +CONFIG_RT2800USB_UNKNOWN=y 
    884 +CONFIG_ZD1211RW=m 
    885 +CONFIG_MWIFIEX=m 
    886 +CONFIG_MWIFIEX_SDIO=m 
    887 +CONFIG_WIMAX_I2400M_USB=m 
     815+CONFIG_PPP=m 
     816+CONFIG_PPP_ASYNC=m 
     817+CONFIG_PPP_SYNC_TTY=m 
     818+CONFIG_PPP_DEFLATE=m 
     819+CONFIG_PPP_BSDCOMP=m 
     820+CONFIG_SLIP=m 
     821+CONFIG_SLIP_COMPRESSED=y 
     822+CONFIG_NETCONSOLE=m 
    888823+CONFIG_INPUT_POLLDEV=m 
    889824+# CONFIG_INPUT_MOUSEDEV_PSAUX is not set 
     
    894829+CONFIG_INPUT_MISC=y 
    895830+CONFIG_INPUT_AD714X=m 
     831+CONFIG_INPUT_ATI_REMOTE=m 
    896832+CONFIG_INPUT_ATI_REMOTE2=m 
    897833+CONFIG_INPUT_KEYSPAN_REMOTE=m 
     
    915851+# CONFIG_HW_RANDOM is not set 
    916852+CONFIG_RAW_DRIVER=y 
    917 +CONFIG_I2C=y 
    918 +CONFIG_I2C_CHARDEV=m 
    919 +CONFIG_I2C_BCM2708=m 
    920 +CONFIG_SPI=y 
    921 +CONFIG_SPI_BCM2708=m 
    922 +CONFIG_SPI_SPIDEV=m 
    923853+CONFIG_GPIO_SYSFS=y 
    924854+# CONFIG_HWMON is not set 
    925 +CONFIG_THERMAL=y 
    926 +CONFIG_THERMAL_BCM2835=y 
    927855+CONFIG_WATCHDOG=y 
    928856+CONFIG_BCM2708_WDT=m 
    929 +CONFIG_MEDIA_SUPPORT=m 
     857+# CONFIG_MFD_SUPPORT is not set 
    930858+CONFIG_FB=y 
    931859+CONFIG_FB_BCM2708=y 
     
    934862+# CONFIG_LOGO_LINUX_MONO is not set 
    935863+# CONFIG_LOGO_LINUX_VGA16 is not set 
    936 +CONFIG_SOUND=y 
    937 +CONFIG_SND=m 
    938 +CONFIG_SND_SEQUENCER=m 
    939 +CONFIG_SND_SEQ_DUMMY=m 
    940 +CONFIG_SND_MIXER_OSS=m 
    941 +CONFIG_SND_PCM_OSS=m 
    942 +CONFIG_SND_SEQUENCER_OSS=y 
    943 +CONFIG_SND_HRTIMER=m 
    944 +CONFIG_SND_DUMMY=m 
    945 +CONFIG_SND_ALOOP=m 
    946 +CONFIG_SND_VIRMIDI=m 
    947 +CONFIG_SND_MTPAV=m 
    948 +CONFIG_SND_SERIAL_U16550=m 
    949 +CONFIG_SND_MPU401=m 
    950 +CONFIG_SND_BCM2835=m 
    951 +CONFIG_SND_USB_AUDIO=m 
    952 +CONFIG_SND_USB_UA101=m 
    953 +CONFIG_SND_USB_CAIAQ=m 
    954 +CONFIG_SND_USB_6FIRE=m 
    955 +CONFIG_SOUND_PRIME=m 
     864+CONFIG_HID_PID=y 
     865+CONFIG_USB_HIDDEV=y 
    956866+CONFIG_HID_A4TECH=m 
    957867+CONFIG_HID_ACRUX=m 
     
    984894+CONFIG_HID_PETALYNX=m 
    985895+CONFIG_HID_PICOLCD=m 
     896+CONFIG_HID_QUANTA=m 
    986897+CONFIG_HID_ROCCAT=m 
    987898+CONFIG_HID_SAMSUNG=m 
     
    993904+CONFIG_HID_TOPSEED=m 
    994905+CONFIG_HID_THRUSTMASTER=m 
     906+CONFIG_HID_WACOM=m 
     907+CONFIG_HID_WIIMOTE=m 
    995908+CONFIG_HID_ZEROPLUS=m 
    996909+CONFIG_HID_ZYDACRON=m 
    997 +CONFIG_HID_PID=y 
    998 +CONFIG_USB_HIDDEV=y 
    999910+CONFIG_USB=y 
    1000911+CONFIG_USB_ANNOUNCE_NEW_DEVICES=y 
     
    1015926+CONFIG_USB_STORAGE_CYPRESS_ATACB=m 
    1016927+CONFIG_USB_STORAGE_ENE_UB6250=m 
     928+CONFIG_USB_UAS=m 
     929+CONFIG_USB_LIBUSUAL=y 
    1017930+CONFIG_USB_MDC800=m 
    1018931+CONFIG_USB_MICROTEK=m 
     
    10911004+CONFIG_MMC_SDHCI_BCM2708=y 
    10921005+CONFIG_MMC_SDHCI_BCM2708_DMA=y 
    1093 +CONFIG_RTC_CLASS=y 
    1094 +CONFIG_RTC_DRV_DS1307=m 
    1095 +CONFIG_RTC_DRV_DS1374=m 
    1096 +CONFIG_RTC_DRV_DS1672=m 
    1097 +CONFIG_RTC_DRV_DS3232=m 
    1098 +CONFIG_RTC_DRV_MAX6900=m 
    1099 +CONFIG_RTC_DRV_RS5C372=m 
    1100 +CONFIG_RTC_DRV_ISL1208=m 
    1101 +CONFIG_RTC_DRV_ISL12022=m 
    1102 +CONFIG_RTC_DRV_X1205=m 
    1103 +CONFIG_RTC_DRV_PCF8563=m 
    1104 +CONFIG_RTC_DRV_PCF8583=m 
    1105 +CONFIG_RTC_DRV_M41T80=m 
    1106 +CONFIG_RTC_DRV_BQ32K=m 
    1107 +CONFIG_RTC_DRV_S35390A=m 
    1108 +CONFIG_RTC_DRV_FM3130=m 
    1109 +CONFIG_RTC_DRV_RX8581=m 
    1110 +CONFIG_RTC_DRV_RX8025=m 
    1111 +CONFIG_RTC_DRV_EM3027=m 
    1112 +CONFIG_RTC_DRV_RV3029C2=m 
    1113 +CONFIG_RTC_DRV_M41T93=m 
    1114 +CONFIG_RTC_DRV_M41T94=m 
    1115 +CONFIG_RTC_DRV_DS1305=m 
    1116 +CONFIG_RTC_DRV_DS1390=m 
    1117 +CONFIG_RTC_DRV_MAX6902=m 
    1118 +CONFIG_RTC_DRV_R9701=m 
    1119 +CONFIG_RTC_DRV_RS5C348=m 
    1120 +CONFIG_RTC_DRV_DS3234=m 
    1121 +CONFIG_RTC_DRV_PCF2123=m 
     1006+CONFIG_LEDS_GPIO=y 
     1007+CONFIG_LEDS_TRIGGER_TIMER=m 
     1008+CONFIG_LEDS_TRIGGER_HEARTBEAT=m 
     1009+CONFIG_LEDS_TRIGGER_DEFAULT_ON=m 
    11221010+CONFIG_UIO=m 
    11231011+CONFIG_UIO_PDRV=m 
     
    11681056+CONFIG_SQUASHFS_XZ=y 
    11691057+CONFIG_NFS_FS=y 
     1058+CONFIG_NFS_V3=y 
    11701059+CONFIG_NFS_V3_ACL=y 
    11711060+CONFIG_NFS_V4=y 
    11721061+CONFIG_ROOT_NFS=y 
    11731062+CONFIG_NFS_FSCACHE=y 
    1174 +CONFIG_NFSD=m 
    1175 +CONFIG_NFSD_V3_ACL=y 
    1176 +CONFIG_NFSD_V4=y 
    11771063+CONFIG_CIFS=m 
    11781064+CONFIG_CIFS_WEAK_PW_HASH=y 
     
    11811067+CONFIG_9P_FS=m 
    11821068+CONFIG_9P_FS_POSIX_ACL=y 
     1069+CONFIG_PARTITION_ADVANCED=y 
     1070+CONFIG_MAC_PARTITION=y 
     1071+CONFIG_EFI_PARTITION=y 
    11831072+CONFIG_NLS_DEFAULT="utf8" 
    11841073+CONFIG_NLS_CODEPAGE_437=y 
     
    12281117+CONFIG_BOOT_PRINTK_DELAY=y 
    12291118+CONFIG_LATENCYTOP=y 
     1119+CONFIG_SYSCTL_SYSCALL_CHECK=y 
    12301120+CONFIG_IRQSOFF_TRACER=y 
    12311121+CONFIG_SCHED_TRACER=y 
     
    12371127+CONFIG_KDB_KEYBOARD=y 
    12381128+CONFIG_STRICT_DEVMEM=y 
     1129+CONFIG_CRYPTO_AUTHENC=m 
    12391130+CONFIG_CRYPTO_SEQIV=m 
    12401131+CONFIG_CRYPTO_CBC=y 
     
    12431134+CONFIG_CRYPTO_MD5=y 
    12441135+CONFIG_CRYPTO_SHA1=y 
     1136+CONFIG_CRYPTO_SHA256=m 
    12451137+CONFIG_CRYPTO_SHA512=m 
    12461138+CONFIG_CRYPTO_TGR192=m 
     
    12481140+CONFIG_CRYPTO_CAST5=m 
    12491141+CONFIG_CRYPTO_DES=y 
     1142+CONFIG_CRYPTO_DEFLATE=m 
    12501143+# CONFIG_CRYPTO_ANSI_CPRNG is not set 
    12511144+# CONFIG_CRYPTO_HW is not set 
     
    17871680+CONFIG_CRC_ITU_T=y 
    17881681+CONFIG_LIBCRC32C=y 
     1682--- a/arch/arm/kernel/process.c 
     1683+++ b/arch/arm/kernel/process.c 
     1684@@ -174,7 +174,7 @@ void arch_cpu_idle(void) 
     1685                default_idle(); 
     1686 } 
     1687  
     1688-static char reboot_mode = 'h'; 
     1689+char reboot_mode = 'h'; 
     1690  
     1691 int __init reboot_setup(char *str) 
     1692 { 
    17891693--- /dev/null 
    1790 +++ b/arch/arm/configs/bcmrpi_quick_defconfig 
    1791 @@ -0,0 +1,197 @@ 
    1792 +# CONFIG_ARM_PATCH_PHYS_VIRT is not set 
    1793 +CONFIG_LOCALVERSION="-quick" 
    1794 +# CONFIG_LOCALVERSION_AUTO is not set 
    1795 +# CONFIG_SWAP is not set 
    1796 +CONFIG_SYSVIPC=y 
    1797 +CONFIG_POSIX_MQUEUE=y 
    1798 +CONFIG_NO_HZ=y 
    1799 +CONFIG_HIGH_RES_TIMERS=y 
    1800 +CONFIG_IKCONFIG=y 
    1801 +CONFIG_IKCONFIG_PROC=y 
    1802 +CONFIG_KALLSYMS_ALL=y 
    1803 +CONFIG_EMBEDDED=y 
    1804 +CONFIG_PERF_EVENTS=y 
    1805 +# CONFIG_COMPAT_BRK is not set 
    1806 +CONFIG_SLAB=y 
    1807 +CONFIG_MODULES=y 
    1808 +CONFIG_MODULE_UNLOAD=y 
    1809 +CONFIG_MODVERSIONS=y 
    1810 +CONFIG_MODULE_SRCVERSION_ALL=y 
    1811 +# CONFIG_BLK_DEV_BSG is not set 
    1812 +CONFIG_ARCH_BCM2708=y 
    1813 +CONFIG_PREEMPT=y 
    1814 +CONFIG_AEABI=y 
    1815 +CONFIG_UACCESS_WITH_MEMCPY=y 
    1816 +CONFIG_ZBOOT_ROM_TEXT=0x0 
    1817 +CONFIG_ZBOOT_ROM_BSS=0x0 
    1818 +CONFIG_CMDLINE="dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 root=/dev/mmcblk0p2 rootfstype=ext4 rootwait" 
    1819 +CONFIG_CPU_FREQ=y 
    1820 +CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE=y 
    1821 +CONFIG_CPU_FREQ_GOV_PERFORMANCE=y 
    1822 +CONFIG_CPU_FREQ_GOV_USERSPACE=y 
    1823 +CONFIG_CPU_FREQ_GOV_ONDEMAND=y 
    1824 +CONFIG_CPU_FREQ_GOV_CONSERVATIVE=y 
    1825 +CONFIG_CPU_IDLE=y 
    1826 +CONFIG_VFP=y 
    1827 +CONFIG_BINFMT_MISC=y 
    1828 +CONFIG_NET=y 
    1829 +CONFIG_PACKET=y 
    1830 +CONFIG_UNIX=y 
    1831 +CONFIG_INET=y 
    1832 +CONFIG_IP_MULTICAST=y 
    1833 +CONFIG_IP_PNP=y 
    1834 +CONFIG_IP_PNP_DHCP=y 
    1835 +CONFIG_IP_PNP_RARP=y 
    1836 +CONFIG_SYN_COOKIES=y 
    1837 +# CONFIG_INET_XFRM_MODE_TRANSPORT is not set 
    1838 +# CONFIG_INET_XFRM_MODE_TUNNEL is not set 
    1839 +# CONFIG_INET_XFRM_MODE_BEET is not set 
    1840 +# CONFIG_INET_LRO is not set 
    1841 +# CONFIG_INET_DIAG is not set 
    1842 +# CONFIG_IPV6 is not set 
    1843 +# CONFIG_WIRELESS is not set 
    1844 +CONFIG_DEVTMPFS=y 
    1845 +CONFIG_DEVTMPFS_MOUNT=y 
    1846 +CONFIG_BLK_DEV_LOOP=y 
    1847 +CONFIG_BLK_DEV_RAM=y 
    1848 +CONFIG_SCSI=y 
    1849 +# CONFIG_SCSI_PROC_FS is not set 
    1850 +# CONFIG_SCSI_LOWLEVEL is not set 
    1851 +CONFIG_NETDEVICES=y 
    1852 +# CONFIG_NET_VENDOR_BROADCOM is not set 
    1853 +# CONFIG_NET_VENDOR_CIRRUS is not set 
    1854 +# CONFIG_NET_VENDOR_FARADAY is not set 
    1855 +# CONFIG_NET_VENDOR_INTEL is not set 
    1856 +# CONFIG_NET_VENDOR_MARVELL is not set 
    1857 +# CONFIG_NET_VENDOR_MICREL is not set 
    1858 +# CONFIG_NET_VENDOR_NATSEMI is not set 
    1859 +# CONFIG_NET_VENDOR_SEEQ is not set 
    1860 +# CONFIG_NET_VENDOR_STMICRO is not set 
    1861 +# CONFIG_NET_VENDOR_WIZNET is not set 
    1862 +CONFIG_USB_USBNET=y 
    1863 +# CONFIG_USB_NET_AX8817X is not set 
    1864 +# CONFIG_USB_NET_CDCETHER is not set 
    1865 +# CONFIG_USB_NET_CDC_NCM is not set 
    1866 +CONFIG_USB_NET_SMSC95XX=y 
    1867 +# CONFIG_USB_NET_NET1080 is not set 
    1868 +# CONFIG_USB_NET_CDC_SUBSET is not set 
    1869 +# CONFIG_USB_NET_ZAURUS is not set 
    1870 +# CONFIG_WLAN is not set 
    1871 +# CONFIG_INPUT_MOUSEDEV is not set 
    1872 +CONFIG_INPUT_EVDEV=y 
    1873 +# CONFIG_INPUT_KEYBOARD is not set 
    1874 +# CONFIG_INPUT_MOUSE is not set 
    1875 +# CONFIG_SERIO is not set 
    1876 +CONFIG_VT_HW_CONSOLE_BINDING=y 
    1877 +# CONFIG_LEGACY_PTYS is not set 
    1878 +# CONFIG_DEVKMEM is not set 
    1879 +CONFIG_SERIAL_AMBA_PL011=y 
    1880 +CONFIG_SERIAL_AMBA_PL011_CONSOLE=y 
    1881 +CONFIG_TTY_PRINTK=y 
    1882 +CONFIG_HW_RANDOM=y 
    1883 +CONFIG_HW_RANDOM_BCM2708=y 
    1884 +CONFIG_RAW_DRIVER=y 
    1885 +CONFIG_THERMAL=y 
    1886 +CONFIG_THERMAL_BCM2835=y 
    1887 +CONFIG_WATCHDOG=y 
    1888 +CONFIG_BCM2708_WDT=y 
    1889 +CONFIG_REGULATOR=y 
    1890 +CONFIG_REGULATOR_DEBUG=y 
    1891 +CONFIG_REGULATOR_FIXED_VOLTAGE=y 
    1892 +CONFIG_REGULATOR_VIRTUAL_CONSUMER=y 
    1893 +CONFIG_REGULATOR_USERSPACE_CONSUMER=y 
    1894 +CONFIG_FB=y 
    1895 +CONFIG_FB_BCM2708=y 
    1896 +CONFIG_FRAMEBUFFER_CONSOLE=y 
    1897 +CONFIG_LOGO=y 
    1898 +# CONFIG_LOGO_LINUX_MONO is not set 
    1899 +# CONFIG_LOGO_LINUX_VGA16 is not set 
    1900 +CONFIG_SOUND=y 
    1901 +CONFIG_SND=y 
    1902 +CONFIG_SND_BCM2835=y 
    1903 +# CONFIG_SND_USB is not set 
    1904 +CONFIG_USB=y 
    1905 +CONFIG_USB_ANNOUNCE_NEW_DEVICES=y 
    1906 +CONFIG_USB_DWCOTG=y 
    1907 +CONFIG_MMC=y 
    1908 +CONFIG_MMC_SDHCI=y 
    1909 +CONFIG_MMC_SDHCI_PLTFM=y 
    1910 +CONFIG_MMC_SDHCI_BCM2708=y 
    1911 +CONFIG_MMC_SDHCI_BCM2708_DMA=y 
    1912 +CONFIG_NEW_LEDS=y 
    1913 +CONFIG_LEDS_CLASS=y 
    1914 +CONFIG_LEDS_TRIGGERS=y 
    1915 +# CONFIG_IOMMU_SUPPORT is not set 
    1916 +CONFIG_EXT4_FS=y 
    1917 +CONFIG_EXT4_FS_POSIX_ACL=y 
    1918 +CONFIG_EXT4_FS_SECURITY=y 
    1919 +CONFIG_AUTOFS4_FS=y 
    1920 +CONFIG_FSCACHE=y 
    1921 +CONFIG_CACHEFILES=y 
    1922 +CONFIG_MSDOS_FS=y 
    1923 +CONFIG_VFAT_FS=y 
    1924 +CONFIG_FAT_DEFAULT_IOCHARSET="ascii" 
    1925 +CONFIG_TMPFS=y 
    1926 +CONFIG_TMPFS_POSIX_ACL=y 
    1927 +CONFIG_CONFIGFS_FS=y 
    1928 +# CONFIG_MISC_FILESYSTEMS is not set 
    1929 +CONFIG_NFS_FS=y 
    1930 +CONFIG_NFS_V3_ACL=y 
    1931 +CONFIG_NFS_V4=y 
    1932 +CONFIG_ROOT_NFS=y 
    1933 +CONFIG_NFS_FSCACHE=y 
    1934 +CONFIG_NLS_DEFAULT="utf8" 
    1935 +CONFIG_NLS_CODEPAGE_437=y 
    1936 +CONFIG_NLS_CODEPAGE_737=y 
    1937 +CONFIG_NLS_CODEPAGE_775=y 
    1938 +CONFIG_NLS_CODEPAGE_850=y 
    1939 +CONFIG_NLS_CODEPAGE_852=y 
    1940 +CONFIG_NLS_CODEPAGE_855=y 
    1941 +CONFIG_NLS_CODEPAGE_857=y 
    1942 +CONFIG_NLS_CODEPAGE_860=y 
    1943 +CONFIG_NLS_CODEPAGE_861=y 
    1944 +CONFIG_NLS_CODEPAGE_862=y 
    1945 +CONFIG_NLS_CODEPAGE_863=y 
    1946 +CONFIG_NLS_CODEPAGE_864=y 
    1947 +CONFIG_NLS_CODEPAGE_865=y 
    1948 +CONFIG_NLS_CODEPAGE_866=y 
    1949 +CONFIG_NLS_CODEPAGE_869=y 
    1950 +CONFIG_NLS_CODEPAGE_936=y 
    1951 +CONFIG_NLS_CODEPAGE_950=y 
    1952 +CONFIG_NLS_CODEPAGE_932=y 
    1953 +CONFIG_NLS_CODEPAGE_949=y 
    1954 +CONFIG_NLS_CODEPAGE_874=y 
    1955 +CONFIG_NLS_ISO8859_8=y 
    1956 +CONFIG_NLS_CODEPAGE_1250=y 
    1957 +CONFIG_NLS_CODEPAGE_1251=y 
    1958 +CONFIG_NLS_ASCII=y 
    1959 +CONFIG_NLS_ISO8859_1=y 
    1960 +CONFIG_NLS_ISO8859_2=y 
    1961 +CONFIG_NLS_ISO8859_3=y 
    1962 +CONFIG_NLS_ISO8859_4=y 
    1963 +CONFIG_NLS_ISO8859_5=y 
    1964 +CONFIG_NLS_ISO8859_6=y 
    1965 +CONFIG_NLS_ISO8859_7=y 
    1966 +CONFIG_NLS_ISO8859_9=y 
    1967 +CONFIG_NLS_ISO8859_13=y 
    1968 +CONFIG_NLS_ISO8859_14=y 
    1969 +CONFIG_NLS_ISO8859_15=y 
    1970 +CONFIG_NLS_UTF8=y 
    1971 +CONFIG_PRINTK_TIME=y 
    1972 +CONFIG_DEBUG_FS=y 
    1973 +CONFIG_DETECT_HUNG_TASK=y 
    1974 +# CONFIG_DEBUG_PREEMPT is not set 
    1975 +# CONFIG_DEBUG_BUGVERBOSE is not set 
    1976 +# CONFIG_FTRACE is not set 
    1977 +CONFIG_KGDB=y 
    1978 +CONFIG_KGDB_KDB=y 
    1979 +# CONFIG_ARM_UNWIND is not set 
    1980 +CONFIG_CRYPTO_CBC=y 
    1981 +CONFIG_CRYPTO_HMAC=y 
    1982 +CONFIG_CRYPTO_MD5=y 
    1983 +CONFIG_CRYPTO_SHA1=y 
    1984 +CONFIG_CRYPTO_DES=y 
    1985 +# CONFIG_CRYPTO_ANSI_CPRNG is not set 
    1986 +# CONFIG_CRYPTO_HW is not set 
    1987 +CONFIG_CRC_ITU_T=y 
    1988 +CONFIG_LIBCRC32C=y 
    1989 --- a/arch/arm/include/asm/fiq.h 
    1990 +++ b/arch/arm/include/asm/fiq.h 
    1991 @@ -42,6 +42,7 @@ extern void disable_fiq(int fiq); 
    1992  /* helpers defined in fiqasm.S: */ 
    1993  extern void __set_fiq_regs(unsigned long const *regs); 
    1994  extern void __get_fiq_regs(unsigned long *regs); 
    1995 +extern void __FIQ_Branch(unsigned long *regs); 
    1996   
    1997  static inline void set_fiq_regs(struct pt_regs const *regs) 
    1998  { 
    1999 --- a/arch/arm/Kconfig 
    2000 +++ b/arch/arm/Kconfig 
    2001 @@ -361,6 +361,23 @@ config ARCH_AT91 
    2002           This enables support for systems based on Atmel 
    2003           AT91RM9200 and AT91SAM9* processors. 
    2004   
    2005 +config ARCH_BCM2708 
    2006 +       bool "Broadcom BCM2708 family" 
     1694+++ b/arch/arm/mach-bcm2708/Kconfig 
     1695@@ -0,0 +1,34 @@ 
     1696+menu "Broadcom BCM2708 Implementations" 
     1697+       depends on ARCH_BCM2708 
     1698+ 
     1699+config MACH_BCM2708 
     1700+       bool "Broadcom BCM2708 Development Platform" 
     1701+       select NEED_MACH_MEMORY_H 
     1702+       select NEED_MACH_IO_H 
    20071703+       select CPU_V6 
    2008 +       select ARM_AMBA 
    2009 +       select HAVE_CLK 
    2010 +       select HAVE_SCHED_CLOCK 
    2011 +       select NEED_MACH_MEMORY_H 
    2012 +       select CLKDEV_LOOKUP 
    2013 +       select ARCH_HAS_CPUFREQ 
    2014 +       select GENERIC_CLOCKEVENTS 
    2015 +       select ARM_ERRATA_411920 
    2016 +       select MACH_BCM2708 
    2017 +       select VC4 
    2018 +       select FIQ 
    20191704+       help 
    2020 +         This enables support for Broadcom BCM2708 boards. 
    2021 + 
    2022  config ARCH_CLPS711X 
    2023         bool "Cirrus Logic CLPS711x/EP721x/EP731x-based" 
    2024         select ARCH_REQUIRE_GPIOLIB 
    2025 @@ -1025,6 +1042,7 @@ source "arch/arm/mach-virt/Kconfig" 
    2026  source "arch/arm/mach-vt8500/Kconfig" 
    2027   
    2028  source "arch/arm/mach-w90x900/Kconfig" 
    2029 +source "arch/arm/mach-bcm2708/Kconfig" 
    2030   
    2031  source "arch/arm/mach-zynq/Kconfig" 
    2032   
    2033 --- a/arch/arm/Kconfig.debug 
    2034 +++ b/arch/arm/Kconfig.debug 
    2035 @@ -519,6 +519,14 @@ choice 
    2036                   For more details about semihosting, please see 
    2037                   chapter 8 of DUI0203I_rvct_developer_guide.pdf from ARM Ltd. 
    2038   
    2039 +       config DEBUG_BCM2708_UART0 
    2040 +               bool "Broadcom BCM2708 UART0 (PL011)" 
    2041 +               depends on MACH_BCM2708 
    2042 +               help 
    2043 +                 Say Y here if you want the debug print routines to direct 
    2044 +                 their output to UART 0. The port must have been initialised 
    2045 +                 by the boot-loader before use. 
    2046 + 
    2047  endchoice 
    2048   
    2049  config DEBUG_EXYNOS_UART 
    2050 --- a/arch/arm/kernel/armksyms.c 
    2051 +++ b/arch/arm/kernel/armksyms.c 
    2052 @@ -156,3 +156,7 @@ EXPORT_SYMBOL(__gnu_mcount_nc); 
    2053  #ifdef CONFIG_ARM_PATCH_PHYS_VIRT 
    2054  EXPORT_SYMBOL(__pv_phys_offset); 
    2055  #endif 
    2056 + 
    2057 +extern void v6wbi_flush_kern_tlb_range(void); 
    2058 +EXPORT_SYMBOL(v6wbi_flush_kern_tlb_range); 
    2059 + 
    2060 --- a/arch/arm/kernel/fiqasm.S 
    2061 +++ b/arch/arm/kernel/fiqasm.S 
    2062 @@ -25,6 +25,9 @@ 
    2063  ENTRY(__set_fiq_regs) 
    2064         mov     r2, #PSR_I_BIT | PSR_F_BIT | FIQ_MODE 
    2065         mrs     r1, cpsr 
    2066 +@@@@@@@@@@@@@@@ hack: enable the fiq here to keep usb driver happy 
    2067 +       and     r1, #~PSR_F_BIT 
    2068 +@@@@@@@@@@@@@@@ endhack: (need to find better place for this to happen) 
    2069         msr     cpsr_c, r2      @ select FIQ mode 
    2070         mov     r0, r0          @ avoid hazard prior to ARMv4 
    2071         ldmia   r0!, {r8 - r12} 
    2072 @@ -47,3 +50,7 @@ ENTRY(__get_fiq_regs) 
    2073         mov     r0, r0          @ avoid hazard prior to ARMv4 
    2074         mov     pc, lr 
    2075  ENDPROC(__get_fiq_regs) 
    2076 + 
    2077 +ENTRY(__FIQ_Branch) 
    2078 +       mov pc, r8 
    2079 +ENDPROC(__FIQ_Branch) 
    2080 --- a/arch/arm/kernel/fiq.c 
    2081 +++ b/arch/arm/kernel/fiq.c 
    2082 @@ -141,6 +141,7 @@ void disable_fiq(int fiq) 
    2083  EXPORT_SYMBOL(set_fiq_handler); 
    2084  EXPORT_SYMBOL(__set_fiq_regs); /* defined in fiqasm.S */ 
    2085  EXPORT_SYMBOL(__get_fiq_regs); /* defined in fiqasm.S */ 
    2086 +EXPORT_SYMBOL(__FIQ_Branch);   /* defined in fiqasm.S */ 
    2087  EXPORT_SYMBOL(claim_fiq); 
    2088  EXPORT_SYMBOL(release_fiq); 
    2089  EXPORT_SYMBOL(enable_fiq); 
     1705+         Include support for the Broadcom(R) BCM2708 platform. 
     1706+ 
     1707+config BCM2708_GPIO 
     1708+       bool "BCM2708 gpio support" 
     1709+       depends on MACH_BCM2708 
     1710+       select ARCH_REQUIRE_GPIOLIB 
     1711+        default y 
     1712+       help 
     1713+         Include support for the Broadcom(R) BCM2708 gpio. 
     1714+ 
     1715+config BCM2708_VCMEM 
     1716+       bool "Videocore Memory" 
     1717+       depends on MACH_BCM2708 
     1718+        default y 
     1719+        help 
     1720+          Helper for videocore memory access and total size allocation.            
     1721+ 
     1722+config BCM2708_NOL2CACHE 
     1723+       bool "Videocore L2 cache disable" 
     1724+       depends on MACH_BCM2708 
     1725+        default n 
     1726+        help 
     1727+          Do not allow ARM to use GPU's L2 cache. Requires disable_l2cache in config.txt. 
     1728+ 
     1729+endmenu 
     1730--- /dev/null 
     1731+++ b/arch/arm/mach-bcm2708/Makefile 
     1732@@ -0,0 +1,8 @@ 
     1733+# 
     1734+# Makefile for the linux kernel. 
     1735+# 
     1736+ 
     1737+obj-$(CONFIG_MACH_BCM2708)     += clock.o bcm2708.o armctrl.o vcio.o power.o dma.o 
     1738+obj-$(CONFIG_BCM2708_GPIO)     += bcm2708_gpio.o 
     1739+obj-$(CONFIG_BCM2708_VCMEM)    += vc_mem.o 
     1740+ 
     1741--- /dev/null 
     1742+++ b/arch/arm/mach-bcm2708/Makefile.boot 
     1743@@ -0,0 +1,3 @@ 
     1744+   zreladdr-y  := 0x00008000 
     1745+params_phys-y  := 0x00000100 
     1746+initrd_phys-y  := 0x00800000 
    20901747--- /dev/null 
    20911748+++ b/arch/arm/mach-bcm2708/armctrl.c 
    2092 @@ -0,0 +1,219 @@ 
     1749@@ -0,0 +1,208 @@ 
    20931750+/* 
    20941751+ *  linux/arch/arm/mach-bcm2708/armctrl.c 
     
    21451802+       }; 
    21461803+ 
    2147 +       if (d->irq >= FIQ_START) { 
    2148 +               writel(0, __io_address(ARM_IRQ_FAST)); 
    2149 +       } else { 
    2150 +               unsigned int data = (unsigned int)irq_get_chip_data(d->irq); 
    2151 +               writel(1 << (data & 0x1f), __io_address(disables[(data >> 5) & 0x3])); 
    2152 +       } 
     1804+       unsigned int data = (unsigned int)irq_get_chip_data(d->irq); 
     1805+       writel(1 << (data & 0x1f), __io_address(disables[(data >> 5) & 0x3])); 
    21531806+} 
    21541807+ 
     
    21621815+       }; 
    21631816+ 
    2164 +       if (d->irq >= FIQ_START) { 
    2165 +               unsigned int data = 
    2166 +                   (unsigned int)irq_get_chip_data(d->irq) - FIQ_START; 
    2167 +               writel(0x80 | data, __io_address(ARM_IRQ_FAST)); 
    2168 +       } else { 
    2169 +               unsigned int data = (unsigned int)irq_get_chip_data(d->irq); 
    2170 +               writel(1 << (data & 0x1f), __io_address(enables[(data >> 5) & 0x3])); 
    2171 +       } 
     1817+       unsigned int data = (unsigned int)irq_get_chip_data(d->irq); 
     1818+       writel(1 << (data & 0x1f), __io_address(enables[(data >> 5) & 0x3])); 
    21721819+} 
    21731820+ 
     
    23071954+ 
    23081955+       armctrl_pm_register(base, irq_start, resume_sources); 
    2309 +       init_FIQ(FIQ_START); 
    23101956+       return 0; 
    23111957+} 
     
    23421988--- /dev/null 
    23431989+++ b/arch/arm/mach-bcm2708/bcm2708.c 
    2344 @@ -0,0 +1,885 @@ 
     1990@@ -0,0 +1,695 @@ 
    23451991+/* 
    23461992+ *  linux/arch/arm/mach-bcm2708/bcm2708.c 
     
    23762022+#include <linux/io.h> 
    23772023+#include <linux/module.h> 
    2378 +#include <linux/spi/spi.h> 
    2379 +#include <linux/w1-gpio.h> 
    23802024+ 
    23812025+#include <linux/version.h> 
     
    24052049+#include "clock.h" 
    24062050+ 
    2407 +#ifdef CONFIG_BCM_VC_CMA 
    2408 +#include <linux/broadcom/vc_cma.h> 
    2409 +#endif 
    2410 + 
    2411 + 
    24122051+/* Effectively we have an IOMMU (ARM<->VideoCore map) that is set up to 
    24132052+ * give us IO access only to 64Mbytes of physical memory (26 bits).  We could 
     
    24222061+#define DMA_MASK_BITS_COMMON 32 
    24232062+ 
    2424 +// use GPIO 4 for the one-wire GPIO pin, if enabled 
    2425 +#define W1_GPIO 4 
    2426 + 
    24272063+/* command line parameters */ 
    24282064+static unsigned boardrev, serial; 
    24292065+static unsigned uart_clock; 
     2066+static unsigned reboot_part = 0; 
    24302067+ 
    24312068+static void __init bcm2708_init_led(void); 
     
    25522189+/* warning - the USB needs a clock > 34MHz */ 
    25532190+ 
     2191+#ifdef CONFIG_MMC_BCM2708 
    25542192+static struct clk sdhost_clk = { 
    25552193+#ifdef CONFIG_ARCH_BCM2708_CHIPIT 
     
    25592197+#endif 
    25602198+}; 
     2199+#endif 
    25612200+ 
    25622201+static struct clk_lookup lookups[] = { 
     
    25682207+        .dev_id = "bcm2708_usb", 
    25692208+        .clk = &osc_clk, 
    2570 +        }, {   /* SPI */ 
    2571 +                .dev_id = "bcm2708_spi.0", 
    2572 +                .clk = &sdhost_clk, 
    2573 +        }, {   /* BSC0 */ 
    2574 +                .dev_id = "bcm2708_i2c.0", 
    2575 +                .clk = &sdhost_clk, 
    2576 +        }, {   /* BSC1 */ 
    2577 +                .dev_id = "bcm2708_i2c.1", 
    2578 +                .clk = &sdhost_clk, 
    25792209+        } 
    25802210+}; 
     
    26032233+       .num_resources = ARRAY_SIZE(bcm2708_dmaman_resources), 
    26042234+}; 
    2605 + 
    2606 +#if defined(CONFIG_W1_MASTER_GPIO) || defined(CONFIG_W1_MASTER_GPIO_MODULE) 
    2607 +static struct w1_gpio_platform_data w1_gpio_pdata = { 
    2608 +       .pin = W1_GPIO, 
    2609 +       .is_open_drain = 0, 
    2610 +}; 
    2611 + 
    2612 +static struct platform_device w1_device = { 
    2613 +       .name = "w1-gpio", 
    2614 +       .id = -1, 
    2615 +       .dev.platform_data = &w1_gpio_pdata, 
    2616 +}; 
    2617 +#endif 
    26182235+ 
    26192236+static u64 fb_dmamask = DMA_BIT_MASK(DMA_MASK_BITS_COMMON); 
     
    26582275+              }, 
    26592276+       [1] = { 
    2660 +               .start = MPHI_BASE, 
    2661 +               .end = MPHI_BASE + SZ_4K - 1, 
    2662 +               .flags = IORESOURCE_MEM, 
    2663 +             }, 
    2664 +       [2] = { 
    2665 +              .start = IRQ_HOSTPORT, 
    2666 +              .end = IRQ_HOSTPORT, 
     2277+              .start = IRQ_USB, 
     2278+              .end = IRQ_USB, 
    26672279+              .flags = IORESOURCE_IRQ, 
    26682280+              }, 
    2669 +}; 
    2670 + 
    2671 +bool fiq_fix_enable = true; 
    2672 + 
    2673 +static struct resource bcm2708_usb_resources_no_fiq_fix[] = { 
    2674 +       [0] = { 
    2675 +               .start = USB_BASE, 
    2676 +               .end = USB_BASE + SZ_128K - 1, 
    2677 +               .flags = IORESOURCE_MEM, 
    2678 +               }, 
    2679 +       [1] = { 
    2680 +               .start = IRQ_USB, 
    2681 +               .end = IRQ_USB, 
    2682 +               .flags = IORESOURCE_IRQ, 
    2683 +               }, 
    26842281+}; 
    26852282+ 
     
    28182415+}; 
    28192416+ 
    2820 + 
    2821 +static struct platform_device bcm2708_alsa_devices[] = { 
    2822 +       [0] = { 
    2823 +              .name = "bcm2835_AUD0", 
    2824 +              .id = 0,         /* first audio device */ 
    2825 +              .resource = 0, 
    2826 +              .num_resources = 0, 
    2827 +              }, 
    2828 +       [1] = { 
    2829 +              .name = "bcm2835_AUD1", 
    2830 +              .id = 1,         /* second audio device */ 
    2831 +              .resource = 0, 
    2832 +              .num_resources = 0, 
    2833 +              }, 
    2834 +       [2] = { 
    2835 +              .name = "bcm2835_AUD2", 
    2836 +              .id = 2,         /* third audio device */ 
    2837 +              .resource = 0, 
    2838 +              .num_resources = 0, 
    2839 +              }, 
    2840 +       [3] = { 
    2841 +              .name = "bcm2835_AUD3", 
    2842 +              .id = 3,         /* forth audio device */ 
    2843 +              .resource = 0, 
    2844 +              .num_resources = 0, 
    2845 +              }, 
    2846 +       [4] = { 
    2847 +              .name = "bcm2835_AUD4", 
    2848 +              .id = 4,         /* fifth audio device */ 
    2849 +              .resource = 0, 
    2850 +              .num_resources = 0, 
    2851 +              }, 
    2852 +       [5] = { 
    2853 +              .name = "bcm2835_AUD5", 
    2854 +              .id = 5,         /* sixth audio device */ 
    2855 +              .resource = 0, 
    2856 +              .num_resources = 0, 
    2857 +              }, 
    2858 +       [6] = { 
    2859 +              .name = "bcm2835_AUD6", 
    2860 +              .id = 6,         /* seventh audio device */ 
    2861 +              .resource = 0, 
    2862 +              .num_resources = 0, 
    2863 +              }, 
    2864 +       [7] = { 
    2865 +              .name = "bcm2835_AUD7", 
    2866 +              .id = 7,         /* eighth audio device */ 
    2867 +              .resource = 0, 
    2868 +              .num_resources = 0, 
    2869 +              }, 
    2870 +}; 
    2871 + 
    2872 +static struct resource bcm2708_spi_resources[] = { 
    2873 +       { 
    2874 +               .start = SPI0_BASE, 
    2875 +               .end = SPI0_BASE + SZ_256 - 1, 
    2876 +               .flags = IORESOURCE_MEM, 
    2877 +       }, { 
    2878 +               .start = IRQ_SPI, 
    2879 +               .end = IRQ_SPI, 
    2880 +               .flags = IORESOURCE_IRQ, 
    2881 +       } 
    2882 +}; 
    2883 + 
    2884 + 
    2885 +static struct platform_device bcm2708_spi_device = { 
    2886 +       .name = "bcm2708_spi", 
    2887 +       .id = 0, 
    2888 +       .num_resources = ARRAY_SIZE(bcm2708_spi_resources), 
    2889 +       .resource = bcm2708_spi_resources, 
    2890 +}; 
    2891 + 
    2892 +#ifdef CONFIG_BCM2708_SPIDEV 
    2893 +static struct spi_board_info bcm2708_spi_devices[] = { 
    2894 +#ifdef CONFIG_SPI_SPIDEV 
    2895 +       { 
    2896 +               .modalias = "spidev", 
    2897 +               .max_speed_hz = 500000, 
    2898 +               .bus_num = 0, 
    2899 +               .chip_select = 0, 
    2900 +               .mode = SPI_MODE_0, 
    2901 +       }, { 
    2902 +               .modalias = "spidev", 
    2903 +               .max_speed_hz = 500000, 
    2904 +               .bus_num = 0, 
    2905 +               .chip_select = 1, 
    2906 +               .mode = SPI_MODE_0, 
    2907 +       } 
    2908 +#endif 
    2909 +}; 
    2910 +#endif 
    2911 + 
    2912 +static struct resource bcm2708_bsc0_resources[] = { 
    2913 +       { 
    2914 +               .start = BSC0_BASE, 
    2915 +               .end = BSC0_BASE + SZ_256 - 1, 
    2916 +               .flags = IORESOURCE_MEM, 
    2917 +       }, { 
    2918 +               .start = INTERRUPT_I2C, 
    2919 +               .end = INTERRUPT_I2C, 
    2920 +               .flags = IORESOURCE_IRQ, 
    2921 +       } 
    2922 +}; 
    2923 + 
    2924 +static struct platform_device bcm2708_bsc0_device = { 
    2925 +       .name = "bcm2708_i2c", 
    2926 +       .id = 0, 
    2927 +       .num_resources = ARRAY_SIZE(bcm2708_bsc0_resources), 
    2928 +       .resource = bcm2708_bsc0_resources, 
    2929 +}; 
    2930 + 
    2931 + 
    2932 +static struct resource bcm2708_bsc1_resources[] = { 
    2933 +       { 
    2934 +               .start = BSC1_BASE, 
    2935 +               .end = BSC1_BASE + SZ_256 - 1, 
    2936 +               .flags = IORESOURCE_MEM, 
    2937 +       }, { 
    2938 +               .start = INTERRUPT_I2C, 
    2939 +               .end = INTERRUPT_I2C, 
    2940 +               .flags = IORESOURCE_IRQ, 
    2941 +       } 
    2942 +}; 
    2943 + 
    2944 +static struct platform_device bcm2708_bsc1_device = { 
    2945 +       .name = "bcm2708_i2c", 
    2946 +       .id = 1, 
    2947 +       .num_resources = ARRAY_SIZE(bcm2708_bsc1_resources), 
    2948 +       .resource = bcm2708_bsc1_resources, 
    2949 +}; 
    2950 + 
    2951 +static struct platform_device bcm2835_hwmon_device = { 
    2952 +       .name = "bcm2835_hwmon", 
    2953 +}; 
    2954 + 
    2955 +static struct platform_device bcm2835_thermal_device = { 
    2956 +       .name = "bcm2835_thermal", 
    2957 +}; 
    2958 + 
    29592417+int __init bcm_register_device(struct platform_device *pdev) 
    29602418+{ 
     
    29692427+} 
    29702428+ 
     2429+int calc_rsts(int partition) 
     2430+{ 
     2431+       return PM_PASSWORD | 
     2432+               ((partition & (1 << 0))  << 0) | 
     2433+               ((partition & (1 << 1))  << 1) | 
     2434+               ((partition & (1 << 2))  << 2) | 
     2435+               ((partition & (1 << 3))  << 3) | 
     2436+               ((partition & (1 << 4))  << 4) | 
     2437+               ((partition & (1 << 5))  << 5); 
     2438+} 
     2439+ 
    29712440+static void bcm2708_restart(char mode, const char *cmd) 
    29722441+{ 
    29732442+       uint32_t pm_rstc, pm_wdog; 
    29742443+       uint32_t timeout = 10; 
    2975 + 
    2976 +       /* For quick reset notification add reboot=q to cmdline 
    2977 +        */ 
     2444+       uint32_t pm_rsts = 0; 
     2445+ 
    29782446+       if(mode == 'q') 
    29792447+       { 
    2980 +               uint32_t pm_rsts = readl(__io_address(PM_RSTS)); 
     2448+               // NOOBS < 1.3 booting with reboot=q 
     2449+               pm_rsts = readl(__io_address(PM_RSTS)); 
    29812450+               pm_rsts = PM_PASSWORD | pm_rsts | PM_RSTS_HADWRQ_SET; 
    2982 +               writel(pm_rsts, __io_address(PM_RSTS)); 
    29832451+       } 
     2452+       else if(mode == 'p') 
     2453+       { 
     2454+               // NOOBS < 1.3 halting 
     2455+               pm_rsts = readl(__io_address(PM_RSTS)); 
     2456+               pm_rsts = PM_PASSWORD | pm_rsts | PM_RSTS_HADWRH_SET; 
     2457+       } 
     2458+       else 
     2459+       { 
     2460+               pm_rsts = calc_rsts(reboot_part); 
     2461+       } 
     2462+ 
     2463+       writel(pm_rsts, __io_address(PM_RSTS)); 
    29842464+ 
    29852465+       /* Setup watchdog for reset */ 
     
    29962476+static void bcm2708_power_off(void) 
    29972477+{ 
    2998 +       /* we set the watchdog hard reset bit here to distinguish this reset from the normal (full) reset. bootcode.bin will not reboot after a hard reset */ 
    2999 +       uint32_t pm_rsts = readl(__io_address(PM_RSTS)); 
    3000 +       pm_rsts = PM_PASSWORD | (pm_rsts & PM_RSTC_WRCFG_CLR) | PM_RSTS_HADWRH_SET; 
    3001 +       writel(pm_rsts, __io_address(PM_RSTS)); 
    3002 +       /* continue with normal reset mechanism */ 
    3003 +       bcm2708_restart(0, ""); 
     2478+       extern char reboot_mode; 
     2479+ 
     2480+       if(reboot_mode == 'q') 
     2481+       { 
     2482+               // NOOBS < v1.3 
     2483+               bcm2708_restart('p', ""); 
     2484+       } 
     2485+       else 
     2486+       { 
     2487+               /* partition 63 is special code for HALT the bootloader knows not to boot*/ 
     2488+               reboot_part = 63; 
     2489+               /* continue with normal reset mechanism */ 
     2490+               bcm2708_restart(0, ""); 
     2491+       } 
    30042492+} 
    30052493+ 
     
    30082496+       int i; 
    30092497+ 
    3010 +#if defined(CONFIG_BCM_VC_CMA) 
    3011 +       vc_cma_early_init(); 
    3012 +#endif 
    30132498+       printk("bcm2708.uart_clock = %d\n", uart_clock); 
    30142499+       pm_power_off = bcm2708_power_off; 
     
    30252510+       bcm_register_device(&bcm2708_gpio_device); 
    30262511+#endif 
    3027 +#if defined(CONFIG_W1_MASTER_GPIO) || defined(CONFIG_W1_MASTER_GPIO_MODULE) 
    3028 +       platform_device_register(&w1_device); 
    3029 +#endif 
    30302512+       bcm_register_device(&bcm2708_systemtimer_device); 
    30312513+       bcm_register_device(&bcm2708_fb_device); 
    3032 +       if (!fiq_fix_enable) 
    3033 +       { 
    3034 +               bcm2708_usb_device.resource = bcm2708_usb_resources_no_fiq_fix; 
    3035 +               bcm2708_usb_device.num_resources = ARRAY_SIZE(bcm2708_usb_resources_no_fiq_fix); 
    3036 +       } 
    30372514+       bcm_register_device(&bcm2708_usb_device); 
    30382515+       bcm_register_device(&bcm2708_uart1_device); 
     
    30432520+#endif 
    30442521+       bcm2708_init_led(); 
    3045 +       for (i = 0; i < ARRAY_SIZE(bcm2708_alsa_devices); i++) 
    3046 +               bcm_register_device(&bcm2708_alsa_devices[i]); 
    3047 + 
    3048 +       bcm_register_device(&bcm2708_spi_device); 
    3049 +       bcm_register_device(&bcm2708_bsc0_device); 
    3050 +       bcm_register_device(&bcm2708_bsc1_device); 
    3051 + 
    3052 +       bcm_register_device(&bcm2835_hwmon_device); 
    3053 +       bcm_register_device(&bcm2835_thermal_device); 
    30542522+ 
    30552523+       for (i = 0; i < ARRAY_SIZE(amba_devs); i++) { 
     
    30592527+       system_rev = boardrev; 
    30602528+       system_serial_low = serial; 
    3061 + 
    3062 +#ifdef CONFIG_BCM2708_SPIDEV 
    3063 +       spi_register_board_info(bcm2708_spi_devices, 
    3064 +                       ARRAY_SIZE(bcm2708_spi_devices)); 
    3065 +#endif 
    30662529+} 
    30672530+ 
     
    32072670+} 
    32082671+ 
    3209 +static void __init board_reserve(void) 
    3210 +{ 
    3211 +#if defined(CONFIG_BCM_VC_CMA) 
    3212 +       vc_cma_reserve(); 
    3213 +#endif 
    3214 +} 
    3215 + 
    32162672+MACHINE_START(BCM2708, "BCM2708") 
    32172673+    /* Maintainer: Broadcom Europe Ltd. */ 
     
    32212677+       .init_machine = bcm2708_init, 
    32222678+       .init_early = bcm2708_init_early, 
    3223 +       .reserve = board_reserve, 
    3224 +       .restart        = bcm2708_restart, 
     2679+       .restart = bcm2708_restart, 
    32252680+MACHINE_END 
    32262681+ 
     
    32282683+module_param(serial, uint, 0644); 
    32292684+module_param(uart_clock, uint, 0644); 
    3230 --- /dev/null 
    3231 +++ b/arch/arm/mach-bcm2708/bcm2708_gpio.c 
    3232 @@ -0,0 +1,339 @@ 
    3233 +/* 
    3234 + *  linux/arch/arm/mach-bcm2708/bcm2708_gpio.c 
    3235 + * 
    3236 + *  Copyright (C) 2010 Broadcom 
    3237 + * 
    3238 + * This program is free software; you can redistribute it and/or modify 
    3239 + * it under the terms of the GNU General Public License version 2 as 
    3240 + * published by the Free Software Foundation. 
    3241 + * 
    3242 + */ 
    3243 + 
    3244 +#include <linux/spinlock.h> 
    3245 +#include <linux/module.h> 
    3246 +#include <linux/list.h> 
    3247 +#include <linux/io.h> 
    3248 +#include <linux/irq.h> 
    3249 +#include <linux/interrupt.h> 
    3250 +#include <linux/slab.h> 
    3251 +#include <mach/gpio.h> 
    3252 +#include <linux/gpio.h> 
    3253 +#include <linux/platform_device.h> 
    3254 +#include <mach/platform.h> 
    3255 + 
    3256 +#define BCM_GPIO_DRIVER_NAME "bcm2708_gpio" 
    3257 +#define DRIVER_NAME BCM_GPIO_DRIVER_NAME 
    3258 +#define BCM_GPIO_USE_IRQ 1 
    3259 + 
    3260 +#define GPIOFSEL(x)  (0x00+(x)*4) 
    3261 +#define GPIOSET(x)   (0x1c+(x)*4) 
    3262 +#define GPIOCLR(x)   (0x28+(x)*4) 
    3263 +#define GPIOLEV(x)   (0x34+(x)*4) 
    3264 +#define GPIOEDS(x)   (0x40+(x)*4) 
    3265 +#define GPIOREN(x)   (0x4c+(x)*4) 
    3266 +#define GPIOFEN(x)   (0x58+(x)*4) 
    3267 +#define GPIOHEN(x)   (0x64+(x)*4) 
    3268 +#define GPIOLEN(x)   (0x70+(x)*4) 
    3269 +#define GPIOAREN(x)  (0x7c+(x)*4) 
    3270 +#define GPIOAFEN(x)  (0x88+(x)*4) 
    3271 +#define GPIOUD(x)    (0x94+(x)*4) 
    3272 +#define GPIOUDCLK(x) (0x98+(x)*4) 
    3273 + 
    3274 +enum { GPIO_FSEL_INPUT, GPIO_FSEL_OUTPUT, 
    3275 +       GPIO_FSEL_ALT5, GPIO_FSEL_ALT_4, 
    3276 +       GPIO_FSEL_ALT0, GPIO_FSEL_ALT1, 
    3277 +       GPIO_FSEL_ALT2, GPIO_FSEL_ALT3, 
    3278 +}; 
    3279 + 
    3280 +       /* Each of the two spinlocks protects a different set of hardware 
    3281 +        * regiters and data structurs. This decouples the code of the IRQ from 
    3282 +        * the GPIO code. This also makes the case of a GPIO routine call from 
    3283 +        * the IRQ code simpler. 
    3284 +        */ 
    3285 +static DEFINE_SPINLOCK(lock);  /* GPIO registers */ 
    3286 + 
    3287 +struct bcm2708_gpio { 
    3288 +       struct list_head list; 
    3289 +       void __iomem *base; 
    3290 +       struct gpio_chip gc; 
    3291 +       unsigned long rising; 
    3292 +       unsigned long falling; 
    3293 +}; 
    3294 + 
    3295 +static int bcm2708_set_function(struct gpio_chip *gc, unsigned offset, 
    3296 +                               int function) 
    3297 +{ 
    3298 +       struct bcm2708_gpio *gpio = container_of(gc, struct bcm2708_gpio, gc); 
    3299 +       unsigned long flags; 
    3300 +       unsigned gpiodir; 
    3301 +       unsigned gpio_bank = offset / 10; 
    3302 +       unsigned gpio_field_offset = (offset - 10 * gpio_bank) * 3; 
    3303 + 
    3304 +//printk(KERN_ERR DRIVER_NAME ": bcm2708_gpio_set_function %p (%d,%d)\n", gc, offset, function); 
    3305 +       if (offset >= ARCH_NR_GPIOS) 
    3306 +               return -EINVAL; 
    3307 + 
    3308 +       spin_lock_irqsave(&lock, flags); 
    3309 + 
    3310 +       gpiodir = readl(gpio->base + GPIOFSEL(gpio_bank)); 
    3311 +       gpiodir &= ~(7 << gpio_field_offset); 
    3312 +       gpiodir |= function << gpio_field_offset; 
    3313 +       writel(gpiodir, gpio->base + GPIOFSEL(gpio_bank)); 
    3314 +       spin_unlock_irqrestore(&lock, flags); 
    3315 +       gpiodir = readl(gpio->base + GPIOFSEL(gpio_bank)); 
    3316 + 
    3317 +       return 0; 
    3318 +} 
    3319 + 
    3320 +static int bcm2708_gpio_dir_in(struct gpio_chip *gc, unsigned offset) 
    3321 +{ 
    3322 +       return bcm2708_set_function(gc, offset, GPIO_FSEL_INPUT); 
    3323 +} 
    3324 + 
    3325 +static void bcm2708_gpio_set(struct gpio_chip *gc, unsigned offset, int value); 
    3326 +static int bcm2708_gpio_dir_out(struct gpio_chip *gc, unsigned offset, 
    3327 +                               int value) 
    3328 +{ 
    3329 +       int ret; 
    3330 +       ret = bcm2708_set_function(gc, offset, GPIO_FSEL_OUTPUT); 
    3331 +       if (ret >= 0) 
    3332 +               bcm2708_gpio_set(gc, offset, value); 
    3333 +       return ret; 
    3334 +} 
    3335 + 
    3336 +static int bcm2708_gpio_get(struct gpio_chip *gc, unsigned offset) 
    3337 +{ 
    3338 +       struct bcm2708_gpio *gpio = container_of(gc, struct bcm2708_gpio, gc); 
    3339 +       unsigned gpio_bank = offset / 32; 
    3340 +       unsigned gpio_field_offset = (offset - 32 * gpio_bank); 
    3341 +       unsigned lev; 
    3342 + 
    3343 +       if (offset >= ARCH_NR_GPIOS) 
    3344 +               return 0; 
    3345 +       lev = readl(gpio->base + GPIOLEV(gpio_bank)); 
    3346 +//printk(KERN_ERR DRIVER_NAME ": bcm2708_gpio_get %p (%d)=%d\n", gc, offset, 0x1 & (lev>>gpio_field_offset)); 
    3347 +       return 0x1 & (lev >> gpio_field_offset); 
    3348 +} 
    3349 + 
    3350 +static void bcm2708_gpio_set(struct gpio_chip *gc, unsigned offset, int value) 
    3351 +{ 
    3352 +       struct bcm2708_gpio *gpio = container_of(gc, struct bcm2708_gpio, gc); 
    3353 +       unsigned gpio_bank = offset / 32; 
    3354 +       unsigned gpio_field_offset = (offset - 32 * gpio_bank); 
    3355 +//printk(KERN_ERR DRIVER_NAME ": bcm2708_gpio_set %p (%d=%d)\n", gc, offset, value); 
    3356 +       if (offset >= ARCH_NR_GPIOS) 
    3357 +               return; 
    3358 +       if (value) 
    3359 +               writel(1 << gpio_field_offset, gpio->base + GPIOSET(gpio_bank)); 
    3360 +       else 
    3361 +               writel(1 << gpio_field_offset, gpio->base + GPIOCLR(gpio_bank)); 
    3362 +} 
    3363 + 
    3364 +/************************************************************************************************************************* 
    3365 + * bcm2708 GPIO IRQ 
    3366 + */ 
    3367 + 
    3368 +#if BCM_GPIO_USE_IRQ 
    3369 + 
    3370 +static int bcm2708_gpio_to_irq(struct gpio_chip *chip, unsigned gpio) 
    3371 +{ 
    3372 +       return gpio_to_irq(gpio); 
    3373 +} 
    3374 + 
    3375 +static int bcm2708_gpio_irq_set_type(struct irq_data *d, unsigned type) 
    3376 +{ 
    3377 +       unsigned irq = d->irq; 
    3378 +       struct bcm2708_gpio *gpio = irq_get_chip_data(irq); 
    3379 + 
    3380 +       if (type & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING)) 
    3381 +               return -EINVAL; 
    3382 + 
    3383 +       if (type & IRQ_TYPE_EDGE_RISING) { 
    3384 +               gpio->rising |= (1 << irq_to_gpio(irq)); 
    3385 +       } else { 
    3386 +               gpio->rising &= ~(1 << irq_to_gpio(irq)); 
    3387 +       } 
    3388 + 
    3389 +       if (type & IRQ_TYPE_EDGE_FALLING) { 
    3390 +               gpio->falling |= (1 << irq_to_gpio(irq)); 
    3391 +       } else { 
    3392 +               gpio->falling &= ~(1 << irq_to_gpio(irq)); 
    3393 +       } 
    3394 +       return 0; 
    3395 +} 
    3396 + 
    3397 +static void bcm2708_gpio_irq_mask(struct irq_data *d) 
    3398 +{ 
    3399 +       unsigned irq = d->irq; 
    3400 +       struct bcm2708_gpio *gpio = irq_get_chip_data(irq); 
    3401 +       unsigned gn = irq_to_gpio(irq); 
    3402 +       unsigned gb = gn / 32; 
    3403 +       unsigned long rising = readl(gpio->base + GPIOREN(gb)); 
    3404 +       unsigned long falling = readl(gpio->base + GPIOFEN(gb)); 
    3405 + 
    3406 +       gn = gn % 32; 
    3407 + 
    3408 +       writel(rising & ~(1 << gn), gpio->base + GPIOREN(gb)); 
    3409 +       writel(falling & ~(1 << gn), gpio->base + GPIOFEN(gb)); 
    3410 +} 
    3411 + 
    3412 +static void bcm2708_gpio_irq_unmask(struct irq_data *d) 
    3413 +{ 
    3414 +       unsigned irq = d->irq; 
    3415 +       struct bcm2708_gpio *gpio = irq_get_chip_data(irq); 
    3416 +       unsigned gn = irq_to_gpio(irq); 
    3417 +       unsigned gb = gn / 32; 
    3418 +       unsigned long rising = readl(gpio->base + GPIOREN(gb)); 
    3419 +       unsigned long falling = readl(gpio->base + GPIOFEN(gb)); 
    3420 + 
    3421 +       gn = gn % 32; 
    3422 + 
    3423 +       writel(1 << gn, gpio->base + GPIOEDS(gb)); 
    3424 + 
    3425 +       if (gpio->rising & (1 << gn)) { 
    3426 +               writel(rising | (1 << gn), gpio->base + GPIOREN(gb)); 
    3427 +       } else { 
    3428 +               writel(rising & ~(1 << gn), gpio->base + GPIOREN(gb)); 
    3429 +       } 
    3430 + 
    3431 +       if (gpio->falling & (1 << gn)) { 
    3432 +               writel(falling | (1 << gn), gpio->base + GPIOFEN(gb)); 
    3433 +       } else { 
    3434 +               writel(falling & ~(1 << gn), gpio->base + GPIOFEN(gb)); 
    3435 +       } 
    3436 +} 
    3437 + 
    3438 +static struct irq_chip bcm2708_irqchip = { 
    3439 +       .name = "GPIO", 
    3440 +       .irq_enable = bcm2708_gpio_irq_unmask, 
    3441 +       .irq_disable = bcm2708_gpio_irq_mask, 
    3442 +       .irq_unmask = bcm2708_gpio_irq_unmask, 
    3443 +       .irq_mask = bcm2708_gpio_irq_mask, 
    3444 +       .irq_set_type = bcm2708_gpio_irq_set_type, 
    3445 +}; 
    3446 + 
    3447 +static irqreturn_t bcm2708_gpio_interrupt(int irq, void *dev_id) 
    3448 +{ 
    3449 +       unsigned long edsr; 
    3450 +       unsigned bank; 
    3451 +       int i; 
    3452 +       unsigned gpio; 
    3453 +       for (bank = 0; bank <= 1; bank++) { 
    3454 +               edsr = readl(__io_address(GPIO_BASE) + GPIOEDS(bank)); 
    3455 +               for_each_set_bit(i, &edsr, 32) { 
    3456 +                       gpio = i + bank * 32; 
    3457 +                       generic_handle_irq(gpio_to_irq(gpio)); 
    3458 +               } 
    3459 +               writel(0xffffffff, __io_address(GPIO_BASE) + GPIOEDS(bank)); 
    3460 +       } 
    3461 +       return IRQ_HANDLED; 
    3462 +} 
    3463 + 
    3464 +static struct irqaction bcm2708_gpio_irq = { 
    3465 +       .name = "BCM2708 GPIO catchall handler", 
    3466 +       .flags = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL, 
    3467 +       .handler = bcm2708_gpio_interrupt, 
    3468 +}; 
    3469 + 
    3470 +static void bcm2708_gpio_irq_init(struct bcm2708_gpio *ucb) 
    3471 +{ 
    3472 +       unsigned irq; 
    3473 + 
    3474 +       ucb->gc.to_irq = bcm2708_gpio_to_irq; 
    3475 + 
    3476 +       for (irq = GPIO_IRQ_START; irq < (GPIO_IRQ_START + GPIO_IRQS); irq++) { 
    3477 +               irq_set_chip_data(irq, ucb); 
    3478 +               irq_set_chip(irq, &bcm2708_irqchip); 
    3479 +               set_irq_flags(irq, IRQF_VALID); 
    3480 +       } 
    3481 +       setup_irq(IRQ_GPIO3, &bcm2708_gpio_irq); 
    3482 +} 
    3483 + 
    3484 +#else 
    3485 + 
    3486 +static void bcm2708_gpio_irq_init(struct bcm2708_gpio *ucb) 
    3487 +{ 
    3488 +} 
    3489 + 
    3490 +#endif /* #if BCM_GPIO_USE_IRQ ***************************************************************************************************************** */ 
    3491 + 
    3492 +static int bcm2708_gpio_probe(struct platform_device *dev) 
    3493 +{ 
    3494 +       struct bcm2708_gpio *ucb; 
    3495 +       struct resource *res; 
    3496 +       int err = 0; 
    3497 + 
    3498 +       printk(KERN_INFO DRIVER_NAME ": bcm2708_gpio_probe %p\n", dev); 
    3499 + 
    3500 +       ucb = kzalloc(sizeof(*ucb), GFP_KERNEL); 
    3501 +       if (NULL == ucb) { 
    3502 +               printk(KERN_ERR DRIVER_NAME ": failed to allocate " 
    3503 +                      "mailbox memory\n"); 
    3504 +               err = -ENOMEM; 
    3505 +               goto err; 
    3506 +       } 
    3507 + 
    3508 +       res = platform_get_resource(dev, IORESOURCE_MEM, 0); 
    3509 + 
    3510 +       platform_set_drvdata(dev, ucb); 
    3511 +       ucb->base = __io_address(GPIO_BASE); 
    3512 + 
    3513 +       ucb->gc.label = "bcm2708_gpio"; 
    3514 +       ucb->gc.base = 0; 
    3515 +       ucb->gc.ngpio = ARCH_NR_GPIOS; 
    3516 +       ucb->gc.owner = THIS_MODULE; 
    3517 + 
    3518 +       ucb->gc.direction_input = bcm2708_gpio_dir_in; 
    3519 +       ucb->gc.direction_output = bcm2708_gpio_dir_out; 
    3520 +       ucb->gc.get = bcm2708_gpio_get; 
    3521 +       ucb->gc.set = bcm2708_gpio_set; 
    3522 +       ucb->gc.can_sleep = 0; 
    3523 + 
    3524 +       bcm2708_gpio_irq_init(ucb); 
    3525 + 
    3526 +       err = gpiochip_add(&ucb->gc); 
    3527 +       if (err) 
    3528 +               goto err; 
    3529 + 
    3530 +err: 
    3531 +       return err; 
    3532 + 
    3533 +} 
    3534 + 
    3535 +static int bcm2708_gpio_remove(struct platform_device *dev) 
    3536 +{ 
    3537 +       int err = 0; 
    3538 +       struct bcm2708_gpio *ucb = platform_get_drvdata(dev); 
    3539 + 
    3540 +       printk(KERN_ERR DRIVER_NAME ": bcm2708_gpio_remove %p\n", dev); 
    3541 + 
    3542 +       err = gpiochip_remove(&ucb->gc); 
    3543 + 
    3544 +       platform_set_drvdata(dev, NULL); 
    3545 +       kfree(ucb); 
    3546 + 
    3547 +       return err; 
    3548 +} 
    3549 + 
    3550 +static struct platform_driver bcm2708_gpio_driver = { 
    3551 +       .probe = bcm2708_gpio_probe, 
    3552 +       .remove = bcm2708_gpio_remove, 
    3553 +       .driver = { 
    3554 +                  .name = "bcm2708_gpio"}, 
    3555 +}; 
    3556 + 
    3557 +static int __init bcm2708_gpio_init(void) 
    3558 +{ 
    3559 +       return platform_driver_register(&bcm2708_gpio_driver); 
    3560 +} 
    3561 + 
    3562 +static void __exit bcm2708_gpio_exit(void) 
    3563 +{ 
    3564 +       platform_driver_unregister(&bcm2708_gpio_driver); 
    3565 +} 
    3566 + 
    3567 +module_init(bcm2708_gpio_init); 
    3568 +module_exit(bcm2708_gpio_exit); 
    3569 + 
    3570 +MODULE_DESCRIPTION("Broadcom BCM2708 GPIO driver"); 
    3571 +MODULE_LICENSE("GPL"); 
     2685+module_param(reboot_part, uint, 0644); 
    35722686--- /dev/null 
    35732687+++ b/arch/arm/mach-bcm2708/bcm2708.h 
     
    36242738+ 
    36252739+#endif 
     2740--- /dev/null 
     2741+++ b/arch/arm/mach-bcm2708/bcm2708_gpio.c 
     2742@@ -0,0 +1,339 @@ 
     2743+/* 
     2744+ *  linux/arch/arm/mach-bcm2708/bcm2708_gpio.c 
     2745+ * 
     2746+ *  Copyright (C) 2010 Broadcom 
     2747+ * 
     2748+ * This program is free software; you can redistribute it and/or modify 
     2749+ * it under the terms of the GNU General Public License version 2 as 
     2750+ * published by the Free Software Foundation. 
     2751+ * 
     2752+ */ 
     2753+ 
     2754+#include <linux/spinlock.h> 
     2755+#include <linux/module.h> 
     2756+#include <linux/list.h> 
     2757+#include <linux/io.h> 
     2758+#include <linux/irq.h> 
     2759+#include <linux/interrupt.h> 
     2760+#include <linux/slab.h> 
     2761+#include <mach/gpio.h> 
     2762+#include <linux/gpio.h> 
     2763+#include <linux/platform_device.h> 
     2764+#include <mach/platform.h> 
     2765+ 
     2766+#define BCM_GPIO_DRIVER_NAME "bcm2708_gpio" 
     2767+#define DRIVER_NAME BCM_GPIO_DRIVER_NAME 
     2768+#define BCM_GPIO_USE_IRQ 1 
     2769+ 
     2770+#define GPIOFSEL(x)  (0x00+(x)*4) 
     2771+#define GPIOSET(x)   (0x1c+(x)*4) 
     2772+#define GPIOCLR(x)   (0x28+(x)*4) 
     2773+#define GPIOLEV(x)   (0x34+(x)*4) 
     2774+#define GPIOEDS(x)   (0x40+(x)*4) 
     2775+#define GPIOREN(x)   (0x4c+(x)*4) 
     2776+#define GPIOFEN(x)   (0x58+(x)*4) 
     2777+#define GPIOHEN(x)   (0x64+(x)*4) 
     2778+#define GPIOLEN(x)   (0x70+(x)*4) 
     2779+#define GPIOAREN(x)  (0x7c+(x)*4) 
     2780+#define GPIOAFEN(x)  (0x88+(x)*4) 
     2781+#define GPIOUD(x)    (0x94+(x)*4) 
     2782+#define GPIOUDCLK(x) (0x98+(x)*4) 
     2783+ 
     2784+enum { GPIO_FSEL_INPUT, GPIO_FSEL_OUTPUT, 
     2785+       GPIO_FSEL_ALT5, GPIO_FSEL_ALT_4, 
     2786+       GPIO_FSEL_ALT0, GPIO_FSEL_ALT1, 
     2787+       GPIO_FSEL_ALT2, GPIO_FSEL_ALT3, 
     2788+}; 
     2789+ 
     2790+       /* Each of the two spinlocks protects a different set of hardware 
     2791+        * regiters and data structurs. This decouples the code of the IRQ from 
     2792+        * the GPIO code. This also makes the case of a GPIO routine call from 
     2793+        * the IRQ code simpler. 
     2794+        */ 
     2795+static DEFINE_SPINLOCK(lock);  /* GPIO registers */ 
     2796+ 
     2797+struct bcm2708_gpio { 
     2798+       struct list_head list; 
     2799+       void __iomem *base; 
     2800+       struct gpio_chip gc; 
     2801+       unsigned long rising; 
     2802+       unsigned long falling; 
     2803+}; 
     2804+ 
     2805+static int bcm2708_set_function(struct gpio_chip *gc, unsigned offset, 
     2806+                               int function) 
     2807+{ 
     2808+       struct bcm2708_gpio *gpio = container_of(gc, struct bcm2708_gpio, gc); 
     2809+       unsigned long flags; 
     2810+       unsigned gpiodir; 
     2811+       unsigned gpio_bank = offset / 10; 
     2812+       unsigned gpio_field_offset = (offset - 10 * gpio_bank) * 3; 
     2813+ 
     2814+//printk(KERN_ERR DRIVER_NAME ": bcm2708_gpio_set_function %p (%d,%d)\n", gc, offset, function); 
     2815+       if (offset >= ARCH_NR_GPIOS) 
     2816+               return -EINVAL; 
     2817+ 
     2818+       spin_lock_irqsave(&lock, flags); 
     2819+ 
     2820+       gpiodir = readl(gpio->base + GPIOFSEL(gpio_bank)); 
     2821+       gpiodir &= ~(7 << gpio_field_offset); 
     2822+       gpiodir |= function << gpio_field_offset; 
     2823+       writel(gpiodir, gpio->base + GPIOFSEL(gpio_bank)); 
     2824+       spin_unlock_irqrestore(&lock, flags); 
     2825+       gpiodir = readl(gpio->base + GPIOFSEL(gpio_bank)); 
     2826+ 
     2827+       return 0; 
     2828+} 
     2829+ 
     2830+static int bcm2708_gpio_dir_in(struct gpio_chip *gc, unsigned offset) 
     2831+{ 
     2832+       return bcm2708_set_function(gc, offset, GPIO_FSEL_INPUT); 
     2833+} 
     2834+ 
     2835+static void bcm2708_gpio_set(struct gpio_chip *gc, unsigned offset, int value); 
     2836+static int bcm2708_gpio_dir_out(struct gpio_chip *gc, unsigned offset, 
     2837+                               int value) 
     2838+{ 
     2839+       int ret; 
     2840+       ret = bcm2708_set_function(gc, offset, GPIO_FSEL_OUTPUT); 
     2841+       if (ret >= 0) 
     2842+               bcm2708_gpio_set(gc, offset, value); 
     2843+       return ret; 
     2844+} 
     2845+ 
     2846+static int bcm2708_gpio_get(struct gpio_chip *gc, unsigned offset) 
     2847+{ 
     2848+       struct bcm2708_gpio *gpio = container_of(gc, struct bcm2708_gpio, gc); 
     2849+       unsigned gpio_bank = offset / 32; 
     2850+       unsigned gpio_field_offset = (offset - 32 * gpio_bank); 
     2851+       unsigned lev; 
     2852+ 
     2853+       if (offset >= ARCH_NR_GPIOS) 
     2854+               return 0; 
     2855+       lev = readl(gpio->base + GPIOLEV(gpio_bank)); 
     2856+//printk(KERN_ERR DRIVER_NAME ": bcm2708_gpio_get %p (%d)=%d\n", gc, offset, 0x1 & (lev>>gpio_field_offset)); 
     2857+       return 0x1 & (lev >> gpio_field_offset); 
     2858+} 
     2859+ 
     2860+static void bcm2708_gpio_set(struct gpio_chip *gc, unsigned offset, int value) 
     2861+{ 
     2862+       struct bcm2708_gpio *gpio = container_of(gc, struct bcm2708_gpio, gc); 
     2863+       unsigned gpio_bank = offset / 32; 
     2864+       unsigned gpio_field_offset = (offset - 32 * gpio_bank); 
     2865+//printk(KERN_ERR DRIVER_NAME ": bcm2708_gpio_set %p (%d=%d)\n", gc, offset, value); 
     2866+       if (offset >= ARCH_NR_GPIOS) 
     2867+               return; 
     2868+       if (value) 
     2869+               writel(1 << gpio_field_offset, gpio->base + GPIOSET(gpio_bank)); 
     2870+       else 
     2871+               writel(1 << gpio_field_offset, gpio->base + GPIOCLR(gpio_bank)); 
     2872+} 
     2873+ 
     2874+/************************************************************************************************************************* 
     2875+ * bcm2708 GPIO IRQ 
     2876+ */ 
     2877+ 
     2878+#if BCM_GPIO_USE_IRQ 
     2879+ 
     2880+static int bcm2708_gpio_to_irq(struct gpio_chip *chip, unsigned gpio) 
     2881+{ 
     2882+       return gpio_to_irq(gpio); 
     2883+} 
     2884+ 
     2885+static int bcm2708_gpio_irq_set_type(struct irq_data *d, unsigned type) 
     2886+{ 
     2887+       unsigned irq = d->irq; 
     2888+       struct bcm2708_gpio *gpio = irq_get_chip_data(irq); 
     2889+ 
     2890+       if (type & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING)) 
     2891+               return -EINVAL; 
     2892+ 
     2893+       if (type & IRQ_TYPE_EDGE_RISING) { 
     2894+               gpio->rising |= (1 << irq_to_gpio(irq)); 
     2895+       } else { 
     2896+               gpio->rising &= ~(1 << irq_to_gpio(irq)); 
     2897+       } 
     2898+ 
     2899+       if (type & IRQ_TYPE_EDGE_FALLING) { 
     2900+               gpio->falling |= (1 << irq_to_gpio(irq)); 
     2901+       } else { 
     2902+               gpio->falling &= ~(1 << irq_to_gpio(irq)); 
     2903+       } 
     2904+       return 0; 
     2905+} 
     2906+ 
     2907+static void bcm2708_gpio_irq_mask(struct irq_data *d) 
     2908+{ 
     2909+       unsigned irq = d->irq; 
     2910+       struct bcm2708_gpio *gpio = irq_get_chip_data(irq); 
     2911+       unsigned gn = irq_to_gpio(irq); 
     2912+       unsigned gb = gn / 32; 
     2913+       unsigned long rising = readl(gpio->base + GPIOREN(gb)); 
     2914+       unsigned long falling = readl(gpio->base + GPIOFEN(gb)); 
     2915+ 
     2916+       gn = gn % 32; 
     2917+ 
     2918+       writel(rising & ~(1 << gn), gpio->base + GPIOREN(gb)); 
     2919+       writel(falling & ~(1 << gn), gpio->base + GPIOFEN(gb)); 
     2920+} 
     2921+ 
     2922+static void bcm2708_gpio_irq_unmask(struct irq_data *d) 
     2923+{ 
     2924+       unsigned irq = d->irq; 
     2925+       struct bcm2708_gpio *gpio = irq_get_chip_data(irq); 
     2926+       unsigned gn = irq_to_gpio(irq); 
     2927+       unsigned gb = gn / 32; 
     2928+       unsigned long rising = readl(gpio->base + GPIOREN(gb)); 
     2929+       unsigned long falling = readl(gpio->base + GPIOFEN(gb)); 
     2930+ 
     2931+       gn = gn % 32; 
     2932+ 
     2933+       writel(1 << gn, gpio->base + GPIOEDS(gb)); 
     2934+ 
     2935+       if (gpio->rising & (1 << gn)) { 
     2936+               writel(rising | (1 << gn), gpio->base + GPIOREN(gb)); 
     2937+       } else { 
     2938+               writel(rising & ~(1 << gn), gpio->base + GPIOREN(gb)); 
     2939+       } 
     2940+ 
     2941+       if (gpio->falling & (1 << gn)) { 
     2942+               writel(falling | (1 << gn), gpio->base + GPIOFEN(gb)); 
     2943+       } else { 
     2944+               writel(falling & ~(1 << gn), gpio->base + GPIOFEN(gb)); 
     2945+       } 
     2946+} 
     2947+ 
     2948+static struct irq_chip bcm2708_irqchip = { 
     2949+       .name = "GPIO", 
     2950+       .irq_enable = bcm2708_gpio_irq_unmask, 
     2951+       .irq_disable = bcm2708_gpio_irq_mask, 
     2952+       .irq_unmask = bcm2708_gpio_irq_unmask, 
     2953+       .irq_mask = bcm2708_gpio_irq_mask, 
     2954+       .irq_set_type = bcm2708_gpio_irq_set_type, 
     2955+}; 
     2956+ 
     2957+static irqreturn_t bcm2708_gpio_interrupt(int irq, void *dev_id) 
     2958+{ 
     2959+       unsigned long edsr; 
     2960+       unsigned bank; 
     2961+       int i; 
     2962+       unsigned gpio; 
     2963+       for (bank = 0; bank <= 1; bank++) { 
     2964+               edsr = readl(__io_address(GPIO_BASE) + GPIOEDS(bank)); 
     2965+               for_each_set_bit(i, &edsr, 32) { 
     2966+                       gpio = i + bank * 32; 
     2967+                       generic_handle_irq(gpio_to_irq(gpio)); 
     2968+               } 
     2969+               writel(0xffffffff, __io_address(GPIO_BASE) + GPIOEDS(bank)); 
     2970+       } 
     2971+       return IRQ_HANDLED; 
     2972+} 
     2973+ 
     2974+static struct irqaction bcm2708_gpio_irq = { 
     2975+       .name = "BCM2708 GPIO catchall handler", 
     2976+       .flags = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL, 
     2977+       .handler = bcm2708_gpio_interrupt, 
     2978+}; 
     2979+ 
     2980+static void bcm2708_gpio_irq_init(struct bcm2708_gpio *ucb) 
     2981+{ 
     2982+       unsigned irq; 
     2983+ 
     2984+       ucb->gc.to_irq = bcm2708_gpio_to_irq; 
     2985+ 
     2986+       for (irq = GPIO_IRQ_START; irq < (GPIO_IRQ_START + GPIO_IRQS); irq++) { 
     2987+               irq_set_chip_data(irq, ucb); 
     2988+               irq_set_chip(irq, &bcm2708_irqchip); 
     2989+               set_irq_flags(irq, IRQF_VALID); 
     2990+       } 
     2991+       setup_irq(IRQ_GPIO3, &bcm2708_gpio_irq); 
     2992+} 
     2993+ 
     2994+#else 
     2995+ 
     2996+static void bcm2708_gpio_irq_init(struct bcm2708_gpio *ucb) 
     2997+{ 
     2998+} 
     2999+ 
     3000+#endif /* #if BCM_GPIO_USE_IRQ ***************************************************************************************************************** */ 
     3001+ 
     3002+static int bcm2708_gpio_probe(struct platform_device *dev) 
     3003+{ 
     3004+       struct bcm2708_gpio *ucb; 
     3005+       struct resource *res; 
     3006+       int err = 0; 
     3007+ 
     3008+       printk(KERN_INFO DRIVER_NAME ": bcm2708_gpio_probe %p\n", dev); 
     3009+ 
     3010+       ucb = kzalloc(sizeof(*ucb), GFP_KERNEL); 
     3011+       if (NULL == ucb) { 
     3012+               printk(KERN_ERR DRIVER_NAME ": failed to allocate " 
     3013+                      "mailbox memory\n"); 
     3014+               err = -ENOMEM; 
     3015+               goto err; 
     3016+       } 
     3017+ 
     3018+       res = platform_get_resource(dev, IORESOURCE_MEM, 0); 
     3019+ 
     3020+       platform_set_drvdata(dev, ucb); 
     3021+       ucb->base = __io_address(GPIO_BASE); 
     3022+ 
     3023+       ucb->gc.label = "bcm2708_gpio"; 
     3024+       ucb->gc.base = 0; 
     3025+       ucb->gc.ngpio = ARCH_NR_GPIOS; 
     3026+       ucb->gc.owner = THIS_MODULE; 
     3027+ 
     3028+       ucb->gc.direction_input = bcm2708_gpio_dir_in; 
     3029+       ucb->gc.direction_output = bcm2708_gpio_dir_out; 
     3030+       ucb->gc.get = bcm2708_gpio_get; 
     3031+       ucb->gc.set = bcm2708_gpio_set; 
     3032+       ucb->gc.can_sleep = 0; 
     3033+ 
     3034+       bcm2708_gpio_irq_init(ucb); 
     3035+ 
     3036+       err = gpiochip_add(&ucb->gc); 
     3037+       if (err) 
     3038+               goto err; 
     3039+ 
     3040+err: 
     3041+       return err; 
     3042+ 
     3043+} 
     3044+ 
     3045+static int bcm2708_gpio_remove(struct platform_device *dev) 
     3046+{ 
     3047+       int err = 0; 
     3048+       struct bcm2708_gpio *ucb = platform_get_drvdata(dev); 
     3049+ 
     3050+       printk(KERN_ERR DRIVER_NAME ": bcm2708_gpio_remove %p\n", dev); 
     3051+ 
     3052+       err = gpiochip_remove(&ucb->gc); 
     3053+ 
     3054+       platform_set_drvdata(dev, NULL); 
     3055+       kfree(ucb); 
     3056+ 
     3057+       return err; 
     3058+} 
     3059+ 
     3060+static struct platform_driver bcm2708_gpio_driver = { 
     3061+       .probe = bcm2708_gpio_probe, 
     3062+       .remove = bcm2708_gpio_remove, 
     3063+       .driver = { 
     3064+                  .name = "bcm2708_gpio"}, 
     3065+}; 
     3066+ 
     3067+static int __init bcm2708_gpio_init(void) 
     3068+{ 
     3069+       return platform_driver_register(&bcm2708_gpio_driver); 
     3070+} 
     3071+ 
     3072+static void __exit bcm2708_gpio_exit(void) 
     3073+{ 
     3074+       platform_driver_unregister(&bcm2708_gpio_driver); 
     3075+} 
     3076+ 
     3077+module_init(bcm2708_gpio_init); 
     3078+module_exit(bcm2708_gpio_exit); 
     3079+ 
     3080+MODULE_DESCRIPTION("Broadcom BCM2708 GPIO driver"); 
     3081+MODULE_LICENSE("GPL"); 
    36263082--- /dev/null 
    36273083+++ b/arch/arm/mach-bcm2708/clock.c 
     
    41173573+ 
    41183574+MODULE_PARM_DESC(dmachans, "Bitmap of DMA channels available to the ARM"); 
    4119 --- /dev/null 
    4120 +++ b/arch/arm/mach-bcm2708/dmaer.c 
    4121 @@ -0,0 +1,887 @@ 
    4122 +#include <linux/init.h> 
    4123 +#include <linux/sched.h> 
    4124 +#include <linux/module.h> 
    4125 +#include <linux/types.h> 
    4126 +#include <linux/kdev_t.h> 
    4127 +#include <linux/fs.h> 
    4128 +#include <linux/cdev.h> 
    4129 +#include <linux/mm.h> 
    4130 +#include <linux/slab.h> 
    4131 +#include <linux/pagemap.h> 
    4132 +#include <linux/device.h> 
    4133 +#include <linux/jiffies.h> 
    4134 +#include <linux/timex.h> 
    4135 +#include <linux/dma-mapping.h> 
    4136 + 
    4137 +#include <asm/uaccess.h> 
    4138 +#include <asm/atomic.h> 
    4139 +#include <asm/cacheflush.h> 
    4140 +#include <asm/io.h> 
    4141 + 
    4142 +#include <mach/dma.h> 
    4143 +#include <mach/vc_support.h> 
    4144 + 
    4145 +#ifdef ECLIPSE_IGNORE 
    4146 + 
    4147 +#define __user 
    4148 +#define __init 
    4149 +#define __exit 
    4150 +#define __iomem 
    4151 +#define KERN_DEBUG 
    4152 +#define KERN_ERR 
    4153 +#define KERN_WARNING 
    4154 +#define KERN_INFO 
    4155 +#define _IOWR(a, b, c) b 
    4156 +#define _IOW(a, b, c) b 
    4157 +#define _IO(a, b) b 
    4158 + 
    4159 +#endif 
    4160 + 
    4161 +//#define inline 
    4162 + 
    4163 +#define PRINTK(args...) printk(args) 
    4164 +//#define PRINTK_VERBOSE(args...) printk(args) 
    4165 +//#define PRINTK(args...) 
    4166 +#define PRINTK_VERBOSE(args...) 
    4167 + 
    4168 +/***** TYPES ****/ 
    4169 +#define PAGES_PER_LIST 500 
    4170 +struct PageList 
    4171 +{ 
    4172 +       struct page *m_pPages[PAGES_PER_LIST]; 
    4173 +       unsigned int m_used; 
    4174 +       struct PageList *m_pNext; 
    4175 +}; 
    4176 + 
    4177 +struct VmaPageList 
    4178 +{ 
    4179 +       //each vma has a linked list of pages associated with it 
    4180 +       struct PageList *m_pPageHead; 
    4181 +       struct PageList *m_pPageTail; 
    4182 +       unsigned int m_refCount; 
    4183 +}; 
    4184 + 
    4185 +struct DmaControlBlock 
    4186 +{ 
    4187 +       unsigned int m_transferInfo; 
    4188 +       void __user *m_pSourceAddr; 
    4189 +       void __user *m_pDestAddr; 
    4190 +       unsigned int m_xferLen; 
    4191 +       unsigned int m_tdStride; 
    4192 +       struct DmaControlBlock *m_pNext; 
    4193 +       unsigned int m_blank1, m_blank2; 
    4194 +}; 
    4195 + 
    4196 +/***** DEFINES ******/ 
    4197 +//magic number defining the module 
    4198 +#define DMA_MAGIC              0xdd 
    4199 + 
    4200 +//do user virtual to physical translation of the CB chain 
    4201 +#define DMA_PREPARE            _IOWR(DMA_MAGIC, 0, struct DmaControlBlock *) 
    4202 + 
    4203 +//kick the pre-prepared CB chain 
    4204 +#define DMA_KICK               _IOW(DMA_MAGIC, 1, struct DmaControlBlock *) 
    4205 + 
    4206 +//prepare it, kick it, wait for it 
    4207 +#define DMA_PREPARE_KICK_WAIT  _IOWR(DMA_MAGIC, 2, struct DmaControlBlock *) 
    4208 + 
    4209 +//prepare it, kick it, don't wait for it 
    4210 +#define DMA_PREPARE_KICK       _IOWR(DMA_MAGIC, 3, struct DmaControlBlock *) 
    4211 + 
    4212 +//not currently implemented 
    4213 +#define DMA_WAIT_ONE           _IO(DMA_MAGIC, 4, struct DmaControlBlock *) 
    4214 + 
    4215 +//wait on all kicked CB chains 
    4216 +#define DMA_WAIT_ALL           _IO(DMA_MAGIC, 5) 
    4217 + 
    4218 +//in order to discover the largest AXI burst that should be programmed into the transfer params 
    4219 +#define DMA_MAX_BURST          _IO(DMA_MAGIC, 6) 
    4220 + 
    4221 +//set the address range through which the user address is assumed to already by a physical address 
    4222 +#define DMA_SET_MIN_PHYS       _IOW(DMA_MAGIC, 7, unsigned long) 
    4223 +#define DMA_SET_MAX_PHYS       _IOW(DMA_MAGIC, 8, unsigned long) 
    4224 +#define DMA_SET_PHYS_OFFSET    _IOW(DMA_MAGIC, 9, unsigned long) 
    4225 + 
    4226 +//used to define the size for the CMA-based allocation *in pages*, can only be done once once the file is opened 
    4227 +#define DMA_CMA_SET_SIZE       _IOW(DMA_MAGIC, 10, unsigned long) 
    4228 + 
    4229 +//used to get the version of the module, to test for a capability 
    4230 +#define DMA_GET_VERSION                _IO(DMA_MAGIC, 99) 
    4231 + 
    4232 +#define VERSION_NUMBER 1 
    4233 + 
    4234 +#define VIRT_TO_BUS_CACHE_SIZE 8 
    4235 + 
    4236 +/***** FILE OPS *****/ 
    4237 +static int Open(struct inode *pInode, struct file *pFile); 
    4238 +static int Release(struct inode *pInode, struct file *pFile); 
    4239 +static long Ioctl(struct file *pFile, unsigned int cmd, unsigned long arg); 
    4240 +static ssize_t Read(struct file *pFile, char __user *pUser, size_t count, loff_t *offp); 
    4241 +static int Mmap(struct file *pFile, struct vm_area_struct *pVma); 
    4242 + 
    4243 +/***** VMA OPS ****/ 
    4244 +static void VmaOpen4k(struct vm_area_struct *pVma); 
    4245 +static void VmaClose4k(struct vm_area_struct *pVma); 
    4246 +static int VmaFault4k(struct vm_area_struct *pVma, struct vm_fault *pVmf); 
    4247 + 
    4248 +/**** DMA PROTOTYPES */ 
    4249 +static struct DmaControlBlock __user *DmaPrepare(struct DmaControlBlock __user *pUserCB, int *pError); 
    4250 +static int DmaKick(struct DmaControlBlock __user *pUserCB); 
    4251 +static void DmaWaitAll(void); 
    4252 + 
    4253 +/**** GENERIC ****/ 
    4254 +static int __init dmaer_init(void); 
    4255 +static void __exit dmaer_exit(void); 
    4256 + 
    4257 +/*** OPS ***/ 
    4258 +static struct vm_operations_struct g_vmOps4k = { 
    4259 +       .open = VmaOpen4k, 
    4260 +       .close = VmaClose4k, 
    4261 +       .fault = VmaFault4k, 
    4262 +}; 
    4263 + 
    4264 +static struct file_operations g_fOps = { 
    4265 +       .owner = THIS_MODULE, 
    4266 +       .llseek = 0, 
    4267 +       .read = Read, 
    4268 +       .write = 0, 
    4269 +       .unlocked_ioctl = Ioctl, 
    4270 +       .open = Open, 
    4271 +       .release = Release, 
    4272 +       .mmap = Mmap, 
    4273 +}; 
    4274 + 
    4275 +/***** GLOBALS ******/ 
    4276 +static dev_t g_majorMinor; 
    4277 + 
    4278 +//tracking usage of the two files 
    4279 +static atomic_t g_oneLock4k = ATOMIC_INIT(1); 
    4280 + 
    4281 +//device operations 
    4282 +static struct cdev g_cDev; 
    4283 +static int g_trackedPages = 0; 
    4284 + 
    4285 +//dma control 
    4286 +static unsigned int *g_pDmaChanBase; 
    4287 +static int g_dmaIrq; 
    4288 +static int g_dmaChan; 
    4289 + 
    4290 +//cma allocation 
    4291 +static int g_cmaHandle; 
    4292 + 
    4293 +//user virtual to bus address translation acceleration 
    4294 +static unsigned long g_virtAddr[VIRT_TO_BUS_CACHE_SIZE]; 
    4295 +static unsigned long g_busAddr[VIRT_TO_BUS_CACHE_SIZE]; 
    4296 +static unsigned long g_cbVirtAddr; 
    4297 +static unsigned long g_cbBusAddr; 
    4298 +static int g_cacheInsertAt; 
    4299 +static int g_cacheHit, g_cacheMiss; 
    4300 + 
    4301 +//off by default 
    4302 +static void __user *g_pMinPhys; 
    4303 +static void __user *g_pMaxPhys; 
    4304 +static unsigned long g_physOffset; 
    4305 + 
    4306 +/****** CACHE OPERATIONS ********/ 
    4307 +static inline void FlushAddrCache(void) 
    4308 +{ 
    4309 +       int count = 0; 
    4310 +       for (count = 0; count < VIRT_TO_BUS_CACHE_SIZE; count++) 
    4311 +               g_virtAddr[count] = 0xffffffff;                 //never going to match as we always chop the bottom bits anyway 
    4312 + 
    4313 +       g_cbVirtAddr = 0xffffffff; 
    4314 + 
    4315 +       g_cacheInsertAt = 0; 
    4316 +} 
    4317 + 
    4318 +//translate from a user virtual address to a bus address by mapping the page 
    4319 +//NB this won't lock a page in memory, so to avoid potential paging issues using kernel logical addresses 
    4320 +static inline void __iomem *UserVirtualToBus(void __user *pUser) 
    4321 +{ 
    4322 +       int mapped; 
    4323 +       struct page *pPage; 
    4324 +       void *phys; 
    4325 + 
    4326 +       //map it (requiring that the pointer points to something that does not hang off the page boundary) 
    4327 +       mapped = get_user_pages(current, current->mm, 
    4328 +               (unsigned long)pUser, 1, 
    4329 +               1, 0, 
    4330 +               &pPage, 
    4331 +               0); 
    4332 + 
    4333 +       if (mapped <= 0)                //error 
    4334 +               return 0; 
    4335 + 
    4336 +       PRINTK_VERBOSE(KERN_DEBUG "user virtual %p arm phys %p bus %p\n", 
    4337 +                       pUser, page_address(pPage), (void __iomem *)__virt_to_bus(page_address(pPage))); 
    4338 + 
    4339 +       //get the arm physical address 
    4340 +       phys = page_address(pPage) + offset_in_page(pUser); 
    4341 +       page_cache_release(pPage); 
    4342 + 
    4343 +       //and now the bus address 
    4344 +       return (void __iomem *)__virt_to_bus(phys); 
    4345 +} 
    4346 + 
    4347 +static inline void __iomem *UserVirtualToBusViaCbCache(void __user *pUser) 
    4348 +{ 
    4349 +       unsigned long virtual_page = (unsigned long)pUser & ~4095; 
    4350 +       unsigned long page_offset = (unsigned long)pUser & 4095; 
    4351 +       unsigned long bus_addr; 
    4352 + 
    4353 +       if (g_cbVirtAddr == virtual_page) 
    4354 +       { 
    4355 +               bus_addr = g_cbBusAddr + page_offset; 
    4356 +               g_cacheHit++; 
    4357 +               return (void __iomem *)bus_addr; 
    4358 +       } 
    4359 +       else 
    4360 +       { 
    4361 +               bus_addr = (unsigned long)UserVirtualToBus(pUser); 
    4362 +                
    4363 +               if (!bus_addr) 
    4364 +                       return 0; 
    4365 +                
    4366 +               g_cbVirtAddr = virtual_page; 
    4367 +               g_cbBusAddr = bus_addr & ~4095; 
    4368 +               g_cacheMiss++; 
    4369 + 
    4370 +               return (void __iomem *)bus_addr; 
    4371 +       } 
    4372 +} 
    4373 + 
    4374 +//do the same as above, by query our virt->bus cache 
    4375 +static inline void __iomem *UserVirtualToBusViaCache(void __user *pUser) 
    4376 +{ 
    4377 +       int count; 
    4378 +       //get the page and its offset 
    4379 +       unsigned long virtual_page = (unsigned long)pUser & ~4095; 
    4380 +       unsigned long page_offset = (unsigned long)pUser & 4095; 
    4381 +       unsigned long bus_addr; 
    4382 + 
    4383 +       if (pUser >= g_pMinPhys && pUser < g_pMaxPhys) 
    4384 +       { 
    4385 +               PRINTK_VERBOSE(KERN_DEBUG "user->phys passthrough on %p\n", pUser); 
    4386 +               return (void __iomem *)((unsigned long)pUser + g_physOffset); 
    4387 +       } 
    4388 + 
    4389 +       //check the cache for our entry 
    4390 +       for (count = 0; count < VIRT_TO_BUS_CACHE_SIZE; count++) 
    4391 +               if (g_virtAddr[count] == virtual_page) 
    4392 +               { 
    4393 +                       bus_addr = g_busAddr[count] + page_offset; 
    4394 +                       g_cacheHit++; 
    4395 +                       return (void __iomem *)bus_addr; 
    4396 +               } 
    4397 + 
    4398 +       //not found, look up manually and then insert its page address 
    4399 +       bus_addr = (unsigned long)UserVirtualToBus(pUser); 
    4400 + 
    4401 +       if (!bus_addr) 
    4402 +               return 0; 
    4403 + 
    4404 +       g_virtAddr[g_cacheInsertAt] = virtual_page; 
    4405 +       g_busAddr[g_cacheInsertAt] = bus_addr & ~4095; 
    4406 + 
    4407 +       //round robin 
    4408 +       g_cacheInsertAt++; 
    4409 +       if (g_cacheInsertAt == VIRT_TO_BUS_CACHE_SIZE) 
    4410 +               g_cacheInsertAt = 0; 
    4411 + 
    4412 +       g_cacheMiss++; 
    4413 + 
    4414 +       return (void __iomem *)bus_addr; 
    4415 +} 
    4416 + 
    4417 +/***** FILE OPERATIONS ****/ 
    4418 +static int Open(struct inode *pInode, struct file *pFile) 
    4419 +{ 
    4420 +       PRINTK(KERN_DEBUG "file opening: %d/%d\n", imajor(pInode), iminor(pInode)); 
    4421 +        
    4422 +       //check which device we are 
    4423 +       if (iminor(pInode) == 0)                //4k 
    4424 +       { 
    4425 +               //only one at a time 
    4426 +               if (!atomic_dec_and_test(&g_oneLock4k)) 
    4427 +               { 
    4428 +                       atomic_inc(&g_oneLock4k); 
    4429 +                       return -EBUSY; 
    4430 +               } 
    4431 +       } 
    4432 +       else 
    4433 +               return -EINVAL; 
    4434 +        
    4435 +       //todo there will be trouble if two different processes open the files 
    4436 + 
    4437 +       //reset after any file is opened 
    4438 +       g_pMinPhys = (void __user *)-1; 
    4439 +       g_pMaxPhys = (void __user *)0; 
    4440 +       g_physOffset = 0; 
    4441 +       g_cmaHandle = 0; 
    4442 + 
    4443 +       return 0; 
    4444 +} 
    4445 + 
    4446 +static int Release(struct inode *pInode, struct file *pFile) 
    4447 +{ 
    4448 +       PRINTK(KERN_DEBUG "file closing, %d pages tracked\n", g_trackedPages); 
    4449 +       if (g_trackedPages) 
    4450 +               PRINTK(KERN_ERR "we\'re leaking memory!\n"); 
    4451 +        
    4452 +       //wait for any dmas to finish 
    4453 +       DmaWaitAll(); 
    4454 + 
    4455 +       //free this memory on the application closing the file or it crashing (implicitly closing the file) 
    4456 +       if (g_cmaHandle) 
    4457 +       { 
    4458 +               PRINTK(KERN_DEBUG "unlocking vc memory\n"); 
    4459 +               if (UnlockVcMemory(g_cmaHandle)) 
    4460 +                       PRINTK(KERN_ERR "uh-oh, unable to unlock vc memory!\n"); 
    4461 +               PRINTK(KERN_DEBUG "releasing vc memory\n"); 
    4462 +               if (ReleaseVcMemory(g_cmaHandle)) 
    4463 +                       PRINTK(KERN_ERR "uh-oh, unable to release vc memory!\n"); 
    4464 +       } 
    4465 + 
    4466 +       if (iminor(pInode) == 0) 
    4467 +               atomic_inc(&g_oneLock4k); 
    4468 +       else 
    4469 +               return -EINVAL; 
    4470 + 
    4471 +       return 0; 
    4472 +} 
    4473 + 
    4474 +static struct DmaControlBlock __user *DmaPrepare(struct DmaControlBlock __user *pUserCB, int *pError) 
    4475 +{ 
    4476 +       struct DmaControlBlock kernCB; 
    4477 +       struct DmaControlBlock __user *pUNext; 
    4478 +       void __iomem *pSourceBus, __iomem *pDestBus; 
    4479 +        
    4480 +       //get the control block into kernel memory so we can work on it 
    4481 +       if (copy_from_user(&kernCB, pUserCB, sizeof(struct DmaControlBlock)) != 0) 
    4482 +       { 
    4483 +               PRINTK(KERN_ERR "copy_from_user failed for user cb %p\n", pUserCB); 
    4484 +               *pError = 1; 
    4485 +               return 0; 
    4486 +       } 
    4487 +        
    4488 +       if (kernCB.m_pSourceAddr == 0 || kernCB.m_pDestAddr == 0) 
    4489 +       { 
    4490 +               PRINTK(KERN_ERR "faulty source (%p) dest (%p) addresses for user cb %p\n", 
    4491 +                       kernCB.m_pSourceAddr, kernCB.m_pDestAddr, pUserCB); 
    4492 +               *pError = 1; 
    4493 +               return 0; 
    4494 +       } 
    4495 + 
    4496 +       pSourceBus = UserVirtualToBusViaCache(kernCB.m_pSourceAddr); 
    4497 +       pDestBus = UserVirtualToBusViaCache(kernCB.m_pDestAddr); 
    4498 + 
    4499 +       if (!pSourceBus || !pDestBus) 
    4500 +       { 
    4501 +               PRINTK(KERN_ERR "virtual to bus translation failure for source/dest %p/%p->%p/%p\n", 
    4502 +                               kernCB.m_pSourceAddr, kernCB.m_pDestAddr, 
    4503 +                               pSourceBus, pDestBus); 
    4504 +               *pError = 1; 
    4505 +               return 0; 
    4506 +       } 
    4507 +        
    4508 +       //update the user structure with the new bus addresses 
    4509 +       kernCB.m_pSourceAddr = pSourceBus; 
    4510 +       kernCB.m_pDestAddr = pDestBus; 
    4511 + 
    4512 +       PRINTK_VERBOSE(KERN_DEBUG "final source %p dest %p\n", kernCB.m_pSourceAddr, kernCB.m_pDestAddr); 
    4513 +                
    4514 +       //sort out the bus address for the next block 
    4515 +       pUNext = kernCB.m_pNext; 
    4516 +        
    4517 +       if (kernCB.m_pNext) 
    4518 +       { 
    4519 +               void __iomem *pNextBus; 
    4520 +               pNextBus = UserVirtualToBusViaCbCache(kernCB.m_pNext); 
    4521 + 
    4522 +               if (!pNextBus) 
    4523 +               { 
    4524 +                       PRINTK(KERN_ERR "virtual to bus translation failure for m_pNext\n"); 
    4525 +                       *pError = 1; 
    4526 +                       return 0; 
    4527 +               } 
    4528 + 
    4529 +               //update the pointer with the bus address 
    4530 +               kernCB.m_pNext = pNextBus; 
    4531 +       } 
    4532 +        
    4533 +       //write it back to user space 
    4534 +       if (copy_to_user(pUserCB, &kernCB, sizeof(struct DmaControlBlock)) != 0) 
    4535 +       { 
    4536 +               PRINTK(KERN_ERR "copy_to_user failed for cb %p\n", pUserCB); 
    4537 +               *pError = 1; 
    4538 +               return 0; 
    4539 +       } 
    4540 + 
    4541 +       __cpuc_flush_dcache_area(pUserCB, 32); 
    4542 + 
    4543 +       *pError = 0; 
    4544 +       return pUNext; 
    4545 +} 
    4546 + 
    4547 +static int DmaKick(struct DmaControlBlock __user *pUserCB) 
    4548 +{ 
    4549 +       void __iomem *pBusCB; 
    4550 +        
    4551 +       pBusCB = UserVirtualToBusViaCbCache(pUserCB); 
    4552 +       if (!pBusCB) 
    4553 +       { 
    4554 +               PRINTK(KERN_ERR "virtual to bus translation failure for cb\n"); 
    4555 +               return 1; 
    4556 +       } 
    4557 + 
    4558 +       //flush_cache_all(); 
    4559 + 
    4560 +       bcm_dma_start(g_pDmaChanBase, (dma_addr_t)pBusCB); 
    4561 +        
    4562 +       return 0; 
    4563 +} 
    4564 + 
    4565 +static void DmaWaitAll(void) 
    4566 +{ 
    4567 +       int counter = 0; 
    4568 +       volatile int inner_count; 
    4569 +       volatile unsigned int cs; 
    4570 +       unsigned long time_before, time_after; 
    4571 + 
    4572 +       time_before = jiffies; 
    4573 +       //bcm_dma_wait_idle(g_pDmaChanBase); 
    4574 +       dsb(); 
    4575 +        
    4576 +       cs = readl(g_pDmaChanBase); 
    4577 +        
    4578 +       while ((cs & 1) == 1) 
    4579 +       { 
    4580 +               cs = readl(g_pDmaChanBase); 
    4581 +               counter++; 
    4582 + 
    4583 +               for (inner_count = 0; inner_count < 32; inner_count++); 
    4584 + 
    4585 +               asm volatile ("MCR p15,0,r0,c7,c0,4 \n"); 
    4586 +               //cpu_do_idle(); 
    4587 +               if (counter >= 1000000) 
    4588 +               { 
    4589 +                       PRINTK(KERN_WARNING "DMA failed to finish in a timely fashion\n"); 
    4590 +                       break; 
    4591 +               } 
    4592 +       } 
    4593 +       time_after = jiffies; 
    4594 +       PRINTK_VERBOSE(KERN_DEBUG "done, counter %d, cs %08x", counter, cs); 
    4595 +       PRINTK_VERBOSE(KERN_DEBUG "took %ld jiffies, %d HZ\n", time_after - time_before, HZ); 
    4596 +} 
    4597 + 
    4598 +static long Ioctl(struct file *pFile, unsigned int cmd, unsigned long arg) 
    4599 +{ 
    4600 +       int error = 0; 
    4601 +       PRINTK_VERBOSE(KERN_DEBUG "ioctl cmd %x arg %lx\n", cmd, arg); 
    4602 + 
    4603 +       switch (cmd) 
    4604 +       { 
    4605 +       case DMA_PREPARE: 
    4606 +       case DMA_PREPARE_KICK: 
    4607 +       case DMA_PREPARE_KICK_WAIT: 
    4608 +               { 
    4609 +                       struct DmaControlBlock __user *pUCB = (struct DmaControlBlock *)arg; 
    4610 +                       int steps = 0; 
    4611 +                       unsigned long start_time = jiffies; 
    4612 +                       (void)start_time; 
    4613 + 
    4614 +                       //flush our address cache 
    4615 +                       FlushAddrCache(); 
    4616 + 
    4617 +                       PRINTK_VERBOSE(KERN_DEBUG "dma prepare\n"); 
    4618 + 
    4619 +                       //do virtual to bus translation for each entry 
    4620 +                       do 
    4621 +                       { 
    4622 +                               pUCB = DmaPrepare(pUCB, &error); 
    4623 +                       } while (error == 0 && ++steps && pUCB); 
    4624 +                       PRINTK_VERBOSE(KERN_DEBUG "prepare done in %d steps, %ld\n", steps, jiffies - start_time); 
    4625 + 
    4626 +                       //carry straight on if we want to kick too 
    4627 +                       if (cmd == DMA_PREPARE || error) 
    4628 +                       { 
    4629 +                               PRINTK_VERBOSE(KERN_DEBUG "falling out\n"); 
    4630 +                               return error ? -EINVAL : 0; 
    4631 +                       } 
    4632 +               } 
    4633 +       case DMA_KICK: 
    4634 +               PRINTK_VERBOSE(KERN_DEBUG "dma begin\n"); 
    4635 + 
    4636 +               if (cmd == DMA_KICK) 
    4637 +                       FlushAddrCache(); 
    4638 + 
    4639 +               DmaKick((struct DmaControlBlock __user *)arg); 
    4640 +                
    4641 +               if (cmd != DMA_PREPARE_KICK_WAIT) 
    4642 +                       break; 
    4643 +/*     case DMA_WAIT_ONE: 
    4644 +               //PRINTK(KERN_DEBUG "dma wait one\n"); 
    4645 +               break;*/ 
    4646 +       case DMA_WAIT_ALL: 
    4647 +               //PRINTK(KERN_DEBUG "dma wait all\n"); 
    4648 +               DmaWaitAll(); 
    4649 +               break; 
    4650 +       case DMA_MAX_BURST: 
    4651 +               if (g_dmaChan == 0) 
    4652 +                       return 10; 
    4653 +               else 
    4654 +                       return 5; 
    4655 +       case DMA_SET_MIN_PHYS: 
    4656 +               g_pMinPhys = (void __user *)arg; 
    4657 +               PRINTK(KERN_DEBUG "min/max user/phys bypass set to %p %p\n", g_pMinPhys, g_pMaxPhys); 
    4658 +               break; 
    4659 +       case DMA_SET_MAX_PHYS: 
    4660 +               g_pMaxPhys = (void __user *)arg; 
    4661 +               PRINTK(KERN_DEBUG "min/max user/phys bypass set to %p %p\n", g_pMinPhys, g_pMaxPhys); 
    4662 +               break; 
    4663 +       case DMA_SET_PHYS_OFFSET: 
    4664 +               g_physOffset = arg; 
    4665 +               PRINTK(KERN_DEBUG "user/phys bypass offset set to %ld\n", g_physOffset); 
    4666 +               break; 
    4667 +       case DMA_CMA_SET_SIZE: 
    4668 +       { 
    4669 +               unsigned int pBusAddr; 
    4670 + 
    4671 +               if (g_cmaHandle) 
    4672 +               { 
    4673 +                       PRINTK(KERN_ERR "memory has already been allocated (handle %d)\n", g_cmaHandle); 
    4674 +                       return -EINVAL; 
    4675 +               } 
    4676 + 
    4677 +               PRINTK(KERN_INFO "allocating %ld bytes of VC memory\n", arg * 4096); 
    4678 + 
    4679 +               //get the memory 
    4680 +               if (AllocateVcMemory(&g_cmaHandle, arg * 4096, 4096, MEM_FLAG_L1_NONALLOCATING | MEM_FLAG_NO_INIT | MEM_FLAG_HINT_PERMALOCK)) 
    4681 +               { 
    4682 +                       PRINTK(KERN_ERR "failed to allocate %ld bytes of VC memory\n", arg * 4096); 
    4683 +                       g_cmaHandle = 0; 
    4684 +                       return -EINVAL; 
    4685 +               } 
    4686 + 
    4687 +               //get an address for it 
    4688 +               PRINTK(KERN_INFO "trying to map VC memory\n"); 
    4689 + 
    4690 +               if (LockVcMemory(&pBusAddr, g_cmaHandle)) 
    4691 +               { 
    4692 +                       PRINTK(KERN_ERR "failed to map CMA handle %d, releasing memory\n", g_cmaHandle); 
    4693 +                       ReleaseVcMemory(g_cmaHandle); 
    4694 +                       g_cmaHandle = 0; 
    4695 +               } 
    4696 + 
    4697 +               PRINTK(KERN_INFO "bus address for CMA memory is %x\n", pBusAddr); 
    4698 +               return pBusAddr; 
    4699 +       } 
    4700 +       case DMA_GET_VERSION: 
    4701 +               PRINTK(KERN_DEBUG "returning version number, %d\n", VERSION_NUMBER); 
    4702 +               return VERSION_NUMBER; 
    4703 +       default: 
    4704 +               PRINTK(KERN_DEBUG "unknown ioctl: %d\n", cmd); 
    4705 +               return -EINVAL; 
    4706 +       } 
    4707 + 
    4708 +       return 0; 
    4709 +} 
    4710 + 
    4711 +static ssize_t Read(struct file *pFile, char __user *pUser, size_t count, loff_t *offp) 
    4712 +{ 
    4713 +       return -EIO; 
    4714 +} 
    4715 + 
    4716 +static int Mmap(struct file *pFile, struct vm_area_struct *pVma) 
    4717 +{ 
    4718 +       struct PageList *pPages; 
    4719 +       struct VmaPageList *pVmaList; 
    4720 +        
    4721 +       PRINTK_VERBOSE(KERN_DEBUG "MMAP vma %p, length %ld (%s %d)\n", 
    4722 +               pVma, pVma->vm_end - pVma->vm_start, 
    4723 +               current->comm, current->pid); 
    4724 +       PRINTK_VERBOSE(KERN_DEBUG "MMAP %p %d (tracked %d)\n", pVma, current->pid, g_trackedPages); 
    4725 + 
    4726 +       //make a new page list 
    4727 +       pPages = (struct PageList *)kmalloc(sizeof(struct PageList), GFP_KERNEL); 
    4728 +       if (!pPages) 
    4729 +       { 
    4730 +               PRINTK(KERN_ERR "couldn\'t allocate a new page list (%s %d)\n", 
    4731 +                       current->comm, current->pid); 
    4732 +               return -ENOMEM; 
    4733 +       } 
    4734 + 
    4735 +       //clear the page list 
    4736 +       pPages->m_used = 0; 
    4737 +       pPages->m_pNext = 0; 
    4738 +        
    4739 +       //insert our vma and new page list somewhere 
    4740 +       if (!pVma->vm_private_data) 
    4741 +       { 
    4742 +               struct VmaPageList *pList; 
    4743 + 
    4744 +               PRINTK_VERBOSE(KERN_DEBUG "new vma list, making new one (%s %d)\n", 
    4745 +                       current->comm, current->pid); 
    4746 + 
    4747 +               //make a new vma list 
    4748 +               pList = (struct VmaPageList *)kmalloc(sizeof(struct VmaPageList), GFP_KERNEL); 
    4749 +               if (!pList) 
    4750 +               { 
    4751 +                       PRINTK(KERN_ERR "couldn\'t allocate vma page list (%s %d)\n", 
    4752 +                               current->comm, current->pid); 
    4753 +                       kfree(pPages); 
    4754 +                       return -ENOMEM; 
    4755 +               } 
    4756 + 
    4757 +               //clear this list 
    4758 +               pVma->vm_private_data = (void *)pList; 
    4759 +               pList->m_refCount = 0; 
    4760 +       } 
    4761 + 
    4762 +       pVmaList = (struct VmaPageList *)pVma->vm_private_data; 
    4763 + 
    4764 +       //add it to the vma list 
    4765 +       pVmaList->m_pPageHead = pPages; 
    4766 +       pVmaList->m_pPageTail = pPages; 
    4767 + 
    4768 +       pVma->vm_ops = &g_vmOps4k; 
    4769 +       pVma->vm_flags |= VM_IO; 
    4770 + 
    4771 +       VmaOpen4k(pVma); 
    4772 + 
    4773 +       return 0; 
    4774 +} 
    4775 + 
    4776 +/****** VMA OPERATIONS ******/ 
    4777 + 
    4778 +static void VmaOpen4k(struct vm_area_struct *pVma) 
    4779 +{ 
    4780 +       struct VmaPageList *pVmaList; 
    4781 + 
    4782 +       PRINTK_VERBOSE(KERN_DEBUG "vma open %p private %p (%s %d), %d live pages\n", pVma, pVma->vm_private_data, current->comm, current->pid, g_trackedPages); 
    4783 +       PRINTK_VERBOSE(KERN_DEBUG "OPEN %p %d %ld pages (tracked pages %d)\n", 
    4784 +               pVma, current->pid, (pVma->vm_end - pVma->vm_start) >> 12, 
    4785 +               g_trackedPages); 
    4786 + 
    4787 +       pVmaList = (struct VmaPageList *)pVma->vm_private_data; 
    4788 + 
    4789 +       if (pVmaList) 
    4790 +       { 
    4791 +               pVmaList->m_refCount++; 
    4792 +               PRINTK_VERBOSE(KERN_DEBUG "ref count is now %d\n", pVmaList->m_refCount); 
    4793 +       } 
    4794 +       else 
    4795 +       { 
    4796 +               PRINTK_VERBOSE(KERN_DEBUG "err, open but no vma page list\n"); 
    4797 +       } 
    4798 +} 
    4799 + 
    4800 +static void VmaClose4k(struct vm_area_struct *pVma) 
    4801 +{ 
    4802 +       struct VmaPageList *pVmaList; 
    4803 +       int freed = 0; 
    4804 +        
    4805 +       PRINTK_VERBOSE(KERN_DEBUG "vma close %p private %p (%s %d)\n", pVma, pVma->vm_private_data, current->comm, current->pid); 
    4806 +        
    4807 +       //wait for any dmas to finish 
    4808 +       DmaWaitAll(); 
    4809 + 
    4810 +       //find our vma in the list 
    4811 +       pVmaList = (struct VmaPageList *)pVma->vm_private_data; 
    4812 + 
    4813 +       //may be a fork 
    4814 +       if (pVmaList) 
    4815 +       { 
    4816 +               struct PageList *pPages; 
    4817 +                
    4818 +               pVmaList->m_refCount--; 
    4819 + 
    4820 +               if (pVmaList->m_refCount == 0) 
    4821 +               { 
    4822 +                       PRINTK_VERBOSE(KERN_DEBUG "found vma, freeing pages (%s %d)\n", 
    4823 +                               current->comm, current->pid); 
    4824 + 
    4825 +                       pPages = pVmaList->m_pPageHead; 
    4826 + 
    4827 +                       if (!pPages) 
    4828 +                       { 
    4829 +                               PRINTK(KERN_ERR "no page list (%s %d)!\n", 
    4830 +                                       current->comm, current->pid); 
    4831 +                               return; 
    4832 +                       } 
    4833 + 
    4834 +                       while (pPages) 
    4835 +                       { 
    4836 +                               struct PageList *next; 
    4837 +                               int count; 
    4838 + 
    4839 +                               PRINTK_VERBOSE(KERN_DEBUG "page list (%s %d)\n", 
    4840 +                                       current->comm, current->pid); 
    4841 + 
    4842 +                               next = pPages->m_pNext; 
    4843 +                               for (count = 0; count < pPages->m_used; count++) 
    4844 +                               { 
    4845 +                                       PRINTK_VERBOSE(KERN_DEBUG "freeing page %p (%s %d)\n", 
    4846 +                                               pPages->m_pPages[count], 
    4847 +                                               current->comm, current->pid); 
    4848 +                                       __free_pages(pPages->m_pPages[count], 0); 
    4849 +                                       g_trackedPages--; 
    4850 +                                       freed++; 
    4851 +                               } 
    4852 + 
    4853 +                               PRINTK_VERBOSE(KERN_DEBUG "freeing page list (%s %d)\n", 
    4854 +                                       current->comm, current->pid); 
    4855 +                               kfree(pPages); 
    4856 +                               pPages = next; 
    4857 +                       } 
    4858 +                        
    4859 +                       //remove our vma from the list 
    4860 +                       kfree(pVmaList); 
    4861 +                       pVma->vm_private_data = 0; 
    4862 +               } 
    4863 +               else 
    4864 +               { 
    4865 +                       PRINTK_VERBOSE(KERN_DEBUG "ref count is %d, not closing\n", pVmaList->m_refCount); 
    4866 +               } 
    4867 +       } 
    4868 +       else 
    4869 +       { 
    4870 +               PRINTK_VERBOSE(KERN_ERR "uh-oh, vma %p not found (%s %d)!\n", pVma, current->comm, current->pid); 
    4871 +               PRINTK_VERBOSE(KERN_ERR "CLOSE ERR\n"); 
    4872 +       } 
    4873 + 
    4874 +       PRINTK_VERBOSE(KERN_DEBUG "CLOSE %p %d %d pages (tracked pages %d)", 
    4875 +               pVma, current->pid, freed, g_trackedPages); 
    4876 + 
    4877 +       PRINTK_VERBOSE(KERN_DEBUG "%d pages open\n", g_trackedPages); 
    4878 +} 
    4879 + 
    4880 +static int VmaFault4k(struct vm_area_struct *pVma, struct vm_fault *pVmf) 
    4881 +{ 
    4882 +       PRINTK_VERBOSE(KERN_DEBUG "vma fault for vma %p private %p at offset %ld (%s %d)\n", pVma, pVma->vm_private_data, pVmf->pgoff, 
    4883 +               current->comm, current->pid); 
    4884 +       PRINTK_VERBOSE(KERN_DEBUG "FAULT\n"); 
    4885 +       pVmf->page = alloc_page(GFP_KERNEL); 
    4886 +        
    4887 +       if (pVmf->page) 
    4888 +       { 
    4889 +               PRINTK_VERBOSE(KERN_DEBUG "alloc page virtual %p\n", page_address(pVmf->page)); 
    4890 +       } 
    4891 + 
    4892 +       if (!pVmf->page) 
    4893 +       { 
    4894 +               PRINTK(KERN_ERR "vma fault oom (%s %d)\n", current->comm, current->pid); 
    4895 +               return VM_FAULT_OOM; 
    4896 +       } 
    4897 +       else 
    4898 +       { 
    4899 +               struct VmaPageList *pVmaList; 
    4900 +                
    4901 +               get_page(pVmf->page); 
    4902 +               g_trackedPages++; 
    4903 +                
    4904 +               //find our vma in the list 
    4905 +               pVmaList = (struct VmaPageList *)pVma->vm_private_data; 
    4906 +                
    4907 +               if (pVmaList) 
    4908 +               { 
    4909 +                       PRINTK_VERBOSE(KERN_DEBUG "vma found (%s %d)\n", current->comm, current->pid); 
    4910 + 
    4911 +                       if (pVmaList->m_pPageTail->m_used == PAGES_PER_LIST) 
    4912 +                       { 
    4913 +                               PRINTK_VERBOSE(KERN_DEBUG "making new page list (%s %d)\n", current->comm, current->pid); 
    4914 +                               //making a new page list 
    4915 +                               pVmaList->m_pPageTail->m_pNext = (struct PageList *)kmalloc(sizeof(struct PageList), GFP_KERNEL); 
    4916 +                               if (!pVmaList->m_pPageTail->m_pNext) 
    4917 +                                       return -ENOMEM; 
    4918 +                                
    4919 +                               //update the tail pointer 
    4920 +                               pVmaList->m_pPageTail = pVmaList->m_pPageTail->m_pNext; 
    4921 +                               pVmaList->m_pPageTail->m_used = 0; 
    4922 +                               pVmaList->m_pPageTail->m_pNext = 0; 
    4923 +                       } 
    4924 + 
    4925 +                       PRINTK_VERBOSE(KERN_DEBUG "adding page to list (%s %d)\n", current->comm, current->pid); 
    4926 +                        
    4927 +                       pVmaList->m_pPageTail->m_pPages[pVmaList->m_pPageTail->m_used] = pVmf->page; 
    4928 +                       pVmaList->m_pPageTail->m_used++; 
    4929 +               } 
    4930 +               else 
    4931 +                       PRINTK(KERN_ERR "returned page for vma we don\'t know %p (%s %d)\n", pVma, current->comm, current->pid); 
    4932 +                
    4933 +               return 0; 
    4934 +       } 
    4935 +} 
    4936 + 
    4937 +/****** GENERIC FUNCTIONS ******/ 
    4938 +static int __init dmaer_init(void) 
    4939 +{ 
    4940 +       int result = alloc_chrdev_region(&g_majorMinor, 0, 1, "dmaer"); 
    4941 +       if (result < 0) 
    4942 +       { 
    4943 +               PRINTK(KERN_ERR "unable to get major device number\n"); 
    4944 +               return result; 
    4945 +       } 
    4946 +       else 
    4947 +               PRINTK(KERN_DEBUG "major device number %d\n", MAJOR(g_majorMinor)); 
    4948 +        
    4949 +       PRINTK(KERN_DEBUG "vma list size %d, page list size %d, page size %ld\n", 
    4950 +               sizeof(struct VmaPageList), sizeof(struct PageList), PAGE_SIZE); 
    4951 + 
    4952 +       //get a dma channel to work with 
    4953 +       result = bcm_dma_chan_alloc(BCM_DMA_FEATURE_FAST, (void **)&g_pDmaChanBase, &g_dmaIrq); 
    4954 + 
    4955 +       //uncomment to force to channel 0 
    4956 +       //result = 0; 
    4957 +       //g_pDmaChanBase = 0xce808000; 
    4958 +        
    4959 +       if (result < 0) 
    4960 +       { 
    4961 +               PRINTK(KERN_ERR "failed to allocate dma channel\n"); 
    4962 +               cdev_del(&g_cDev); 
    4963 +               unregister_chrdev_region(g_majorMinor, 1); 
    4964 +       } 
    4965 +        
    4966 +       //reset the channel 
    4967 +       PRINTK(KERN_DEBUG "allocated dma channel %d (%p), initial state %08x\n", result, g_pDmaChanBase, *g_pDmaChanBase); 
    4968 +       *g_pDmaChanBase = 1 << 31; 
    4969 +       PRINTK(KERN_DEBUG "post-reset %08x\n", *g_pDmaChanBase); 
    4970 +        
    4971 +       g_dmaChan = result; 
    4972 + 
    4973 +       //clear the cache stats 
    4974 +       g_cacheHit = 0; 
    4975 +       g_cacheMiss = 0; 
    4976 + 
    4977 +       //register our device - after this we are go go go 
    4978 +       cdev_init(&g_cDev, &g_fOps); 
    4979 +       g_cDev.owner = THIS_MODULE; 
    4980 +       g_cDev.ops = &g_fOps; 
    4981 +        
    4982 +       result = cdev_add(&g_cDev, g_majorMinor, 1); 
    4983 +       if (result < 0) 
    4984 +       { 
    4985 +               PRINTK(KERN_ERR "failed to add character device\n"); 
    4986 +               unregister_chrdev_region(g_majorMinor, 1); 
    4987 +               bcm_dma_chan_free(g_dmaChan); 
    4988 +               return result; 
    4989 +       } 
    4990 +                
    4991 +       return 0; 
    4992 +} 
    4993 + 
    4994 +static void __exit dmaer_exit(void) 
    4995 +{ 
    4996 +       PRINTK(KERN_INFO "closing dmaer device, cache stats: %d hits %d misses\n", g_cacheHit, g_cacheMiss); 
    4997 +       //unregister the device 
    4998 +       cdev_del(&g_cDev); 
    4999 +       unregister_chrdev_region(g_majorMinor, 1); 
    5000 +       //free the dma channel 
    5001 +       bcm_dma_chan_free(g_dmaChan); 
    5002 +} 
    5003 + 
    5004 +MODULE_LICENSE("Dual BSD/GPL"); 
    5005 +MODULE_AUTHOR("Simon Hall"); 
    5006 +module_init(dmaer_init); 
    5007 +module_exit(dmaer_exit); 
    5008 + 
    50093575--- /dev/null 
    50103576+++ b/arch/arm/mach-bcm2708/include/mach/arm_control.h 
     
    58134379--- /dev/null 
    58144380+++ b/arch/arm/mach-bcm2708/include/mach/irqs.h 
    5815 @@ -0,0 +1,199 @@ 
     4381@@ -0,0 +1,196 @@ 
    58164382+/* 
    58174383+ *  arch/arm/mach-bcm2708/include/mach/irqs.h 
     
    59224488+#define IRQ_PENDING2          (IRQ_ARMCTRL_START + INTERRUPT_PENDING2) 
    59234489+ 
    5924 +#define FIQ_START             HARD_IRQS 
    5925 + 
    59264490+/* 
    59274491+ *  FIQ interrupts definitions are the same as the INT definitions. 
    59284492+ */ 
    5929 +#define FIQ_TIMER0            (FIQ_START+INTERRUPT_TIMER0) 
    5930 +#define FIQ_TIMER1            (FIQ_START+INTERRUPT_TIMER1) 
    5931 +#define FIQ_TIMER2            (FIQ_START+INTERRUPT_TIMER2) 
    5932 +#define FIQ_TIMER3            (FIQ_START+INTERRUPT_TIMER3) 
    5933 +#define FIQ_CODEC0            (FIQ_START+INTERRUPT_CODEC0) 
    5934 +#define FIQ_CODEC1            (FIQ_START+INTERRUPT_CODEC1) 
    5935 +#define FIQ_CODEC2            (FIQ_START+INTERRUPT_CODEC2) 
    5936 +#define FIQ_JPEG              (FIQ_START+INTERRUPT_JPEG) 
    5937 +#define FIQ_ISP               (FIQ_START+INTERRUPT_ISP) 
    5938 +#define FIQ_USB               (FIQ_START+INTERRUPT_USB) 
    5939 +#define FIQ_3D                (FIQ_START+INTERRUPT_3D) 
    5940 +#define FIQ_TRANSPOSER        (FIQ_START+INTERRUPT_TRANSPOSER) 
    5941 +#define FIQ_MULTICORESYNC0    (FIQ_START+INTERRUPT_MULTICORESYNC0) 
    5942 +#define FIQ_MULTICORESYNC1    (FIQ_START+INTERRUPT_MULTICORESYNC1) 
    5943 +#define FIQ_MULTICORESYNC2    (FIQ_START+INTERRUPT_MULTICORESYNC2) 
    5944 +#define FIQ_MULTICORESYNC3    (FIQ_START+INTERRUPT_MULTICORESYNC3) 
    5945 +#define FIQ_DMA0              (FIQ_START+INTERRUPT_DMA0) 
    5946 +#define FIQ_DMA1              (FIQ_START+INTERRUPT_DMA1) 
    5947 +#define FIQ_DMA2              (FIQ_START+INTERRUPT_DMA2) 
    5948 +#define FIQ_DMA3              (FIQ_START+INTERRUPT_DMA3) 
    5949 +#define FIQ_DMA4              (FIQ_START+INTERRUPT_DMA4) 
    5950 +#define FIQ_DMA5              (FIQ_START+INTERRUPT_DMA5) 
    5951 +#define FIQ_DMA6              (FIQ_START+INTERRUPT_DMA6) 
    5952 +#define FIQ_DMA7              (FIQ_START+INTERRUPT_DMA7) 
    5953 +#define FIQ_DMA8              (FIQ_START+INTERRUPT_DMA8) 
    5954 +#define FIQ_DMA9              (FIQ_START+INTERRUPT_DMA9) 
    5955 +#define FIQ_DMA10             (FIQ_START+INTERRUPT_DMA10) 
    5956 +#define FIQ_DMA11             (FIQ_START+INTERRUPT_DMA11) 
    5957 +#define FIQ_DMA12             (FIQ_START+INTERRUPT_DMA12) 
    5958 +#define FIQ_AUX               (FIQ_START+INTERRUPT_AUX) 
    5959 +#define FIQ_ARM               (FIQ_START+INTERRUPT_ARM) 
    5960 +#define FIQ_VPUDMA            (FIQ_START+INTERRUPT_VPUDMA) 
    5961 +#define FIQ_HOSTPORT          (FIQ_START+INTERRUPT_HOSTPORT) 
    5962 +#define FIQ_VIDEOSCALER       (FIQ_START+INTERRUPT_VIDEOSCALER) 
    5963 +#define FIQ_CCP2TX            (FIQ_START+INTERRUPT_CCP2TX) 
    5964 +#define FIQ_SDC               (FIQ_START+INTERRUPT_SDC) 
    5965 +#define FIQ_DSI0              (FIQ_START+INTERRUPT_DSI0) 
    5966 +#define FIQ_AVE               (FIQ_START+INTERRUPT_AVE) 
    5967 +#define FIQ_CAM0              (FIQ_START+INTERRUPT_CAM0) 
    5968 +#define FIQ_CAM1              (FIQ_START+INTERRUPT_CAM1) 
    5969 +#define FIQ_HDMI0             (FIQ_START+INTERRUPT_HDMI0) 
    5970 +#define FIQ_HDMI1             (FIQ_START+INTERRUPT_HDMI1) 
    5971 +#define FIQ_PIXELVALVE1       (FIQ_START+INTERRUPT_PIXELVALVE1) 
    5972 +#define FIQ_I2CSPISLV         (FIQ_START+INTERRUPT_I2CSPISLV) 
    5973 +#define FIQ_DSI1              (FIQ_START+INTERRUPT_DSI1) 
    5974 +#define FIQ_PWA0              (FIQ_START+INTERRUPT_PWA0) 
    5975 +#define FIQ_PWA1              (FIQ_START+INTERRUPT_PWA1) 
    5976 +#define FIQ_CPR               (FIQ_START+INTERRUPT_CPR) 
    5977 +#define FIQ_SMI               (FIQ_START+INTERRUPT_SMI) 
    5978 +#define FIQ_GPIO0             (FIQ_START+INTERRUPT_GPIO0) 
    5979 +#define FIQ_GPIO1             (FIQ_START+INTERRUPT_GPIO1) 
    5980 +#define FIQ_GPIO2             (FIQ_START+INTERRUPT_GPIO2) 
    5981 +#define FIQ_GPIO3             (FIQ_START+INTERRUPT_GPIO3) 
    5982 +#define FIQ_I2C               (FIQ_START+INTERRUPT_I2C) 
    5983 +#define FIQ_SPI               (FIQ_START+INTERRUPT_SPI) 
    5984 +#define FIQ_I2SPCM            (FIQ_START+INTERRUPT_I2SPCM) 
    5985 +#define FIQ_SDIO              (FIQ_START+INTERRUPT_SDIO) 
    5986 +#define FIQ_UART              (FIQ_START+INTERRUPT_UART) 
    5987 +#define FIQ_SLIMBUS           (FIQ_START+INTERRUPT_SLIMBUS) 
    5988 +#define FIQ_VEC               (FIQ_START+INTERRUPT_VEC) 
    5989 +#define FIQ_CPG               (FIQ_START+INTERRUPT_CPG) 
    5990 +#define FIQ_RNG               (FIQ_START+INTERRUPT_RNG) 
    5991 +#define FIQ_ARASANSDIO        (FIQ_START+INTERRUPT_ARASANSDIO) 
    5992 +#define FIQ_AVSPMON           (FIQ_START+INTERRUPT_AVSPMON) 
    5993 + 
    5994 +#define FIQ_ARM_TIMER         (FIQ_START+INTERRUPT_ARM_TIMER) 
    5995 +#define FIQ_ARM_MAILBOX       (FIQ_START+INTERRUPT_ARM_MAILBOX) 
    5996 +#define FIQ_ARM_DOORBELL_0    (FIQ_START+INTERRUPT_ARM_DOORBELL_0) 
    5997 +#define FIQ_ARM_DOORBELL_1    (FIQ_START+INTERRUPT_ARM_DOORBELL_1) 
    5998 +#define FIQ_VPU0_HALTED       (FIQ_START+INTERRUPT_VPU0_HALTED) 
    5999 +#define FIQ_VPU1_HALTED       (FIQ_START+INTERRUPT_VPU1_HALTED) 
    6000 +#define FIQ_ILLEGAL_TYPE0     (FIQ_START+INTERRUPT_ILLEGAL_TYPE0) 
    6001 +#define FIQ_ILLEGAL_TYPE1     (FIQ_START+INTERRUPT_ILLEGAL_TYPE1) 
    6002 +#define FIQ_PENDING1          (FIQ_START+INTERRUPT_PENDING1) 
    6003 +#define FIQ_PENDING2          (FIQ_START+INTERRUPT_PENDING2) 
    6004 + 
    6005 +#define GPIO_IRQ_START       (HARD_IRQS + FIQ_IRQS) 
     4493+#define FIQ_TIMER0            INT_TIMER0 
     4494+#define FIQ_TIMER1            INT_TIMER1 
     4495+#define FIQ_TIMER2            INT_TIMER2 
     4496+#define FIQ_TIMER3            INT_TIMER3 
     4497+#define FIQ_CODEC0            INT_CODEC0 
     4498+#define FIQ_CODEC1            INT_CODEC1 
     4499+#define FIQ_CODEC2            INT_CODEC2 
     4500+#define FIQ_JPEG              INT_JPEG 
     4501+#define FIQ_ISP               INT_ISP 
     4502+#define FIQ_USB               INT_USB 
     4503+#define FIQ_3D                INT_3D 
     4504+#define FIQ_TRANSPOSER        INT_TRANSPOSER 
     4505+#define FIQ_MULTICORESYNC0    INT_MULTICORESYNC0 
     4506+#define FIQ_MULTICORESYNC1    INT_MULTICORESYNC1 
     4507+#define FIQ_MULTICORESYNC2    INT_MULTICORESYNC2 
     4508+#define FIQ_MULTICORESYNC3    INT_MULTICORESYNC3 
     4509+#define FIQ_DMA0              INT_DMA0 
     4510+#define FIQ_DMA1              INT_DMA1 
     4511+#define FIQ_DMA2              INT_DMA2 
     4512+#define FIQ_DMA3              INT_DMA3 
     4513+#define FIQ_DMA4              INT_DMA4 
     4514+#define FIQ_DMA5              INT_DMA5 
     4515+#define FIQ_DMA6              INT_DMA6 
     4516+#define FIQ_DMA7              INT_DMA7 
     4517+#define FIQ_DMA8              INT_DMA8 
     4518+#define FIQ_DMA9              INT_DMA9 
     4519+#define FIQ_DMA10             INT_DMA10 
     4520+#define FIQ_DMA11             INT_DMA11 
     4521+#define FIQ_DMA12             INT_DMA12 
     4522+#define FIQ_AUX               INT_AUX 
     4523+#define FIQ_ARM               INT_ARM 
     4524+#define FIQ_VPUDMA            INT_VPUDMA 
     4525+#define FIQ_HOSTPORT          INT_HOSTPORT 
     4526+#define FIQ_VIDEOSCALER       INT_VIDEOSCALER 
     4527+#define FIQ_CCP2TX            INT_CCP2TX 
     4528+#define FIQ_SDC               INT_SDC 
     4529+#define FIQ_DSI0              INT_DSI0 
     4530+#define FIQ_AVE               INT_AVE 
     4531+#define FIQ_CAM0              INT_CAM0 
     4532+#define FIQ_CAM1              INT_CAM1 
     4533+#define FIQ_HDMI0             INT_HDMI0 
     4534+#define FIQ_HDMI1             INT_HDMI1 
     4535+#define FIQ_PIXELVALVE1       INT_PIXELVALVE1 
     4536+#define FIQ_I2CSPISLV         INT_I2CSPISLV 
     4537+#define FIQ_DSI1              INT_DSI1 
     4538+#define FIQ_PWA0              INT_PWA0 
     4539+#define FIQ_PWA1              INT_PWA1 
     4540+#define FIQ_CPR               INT_CPR 
     4541+#define FIQ_SMI               INT_SMI 
     4542+#define FIQ_GPIO0             INT_GPIO0 
     4543+#define FIQ_GPIO1             INT_GPIO1 
     4544+#define FIQ_GPIO2             INT_GPIO2 
     4545+#define FIQ_GPIO3             INT_GPIO3 
     4546+#define FIQ_I2C               INT_I2C 
     4547+#define FIQ_SPI               INT_SPI 
     4548+#define FIQ_I2SPCM            INT_I2SPCM 
     4549+#define FIQ_SDIO              INT_SDIO 
     4550+#define FIQ_UART              INT_UART 
     4551+#define FIQ_SLIMBUS           INT_SLIMBUS 
     4552+#define FIQ_VEC               INT_VEC 
     4553+#define FIQ_CPG               INT_CPG 
     4554+#define FIQ_RNG               INT_RNG 
     4555+#define FIQ_ARASANSDIO        INT_ARASANSDIO 
     4556+#define FIQ_AVSPMON           INT_AVSPMON 
     4557+ 
     4558+#define FIQ_ARM_TIMER         INT_ARM_TIMER 
     4559+#define FIQ_ARM_MAILBOX       INT_ARM_MAILBOX 
     4560+#define FIQ_ARM_DOORBELL_0    INT_ARM_DOORBELL_0 
     4561+#define FIQ_ARM_DOORBELL_1    INT_ARM_DOORBELL_1 
     4562+#define FIQ_VPU0_HALTED       INT_VPU0_HALTED 
     4563+#define FIQ_VPU1_HALTED       INT_VPU1_HALTED 
     4564+#define FIQ_ILLEGAL_TYPE0     INT_ILLEGAL_TYPE0 
     4565+#define FIQ_ILLEGAL_TYPE1     INT_ILLEGAL_TYPE1 
     4566+#define FIQ_PENDING1          INT_PENDING1 
     4567+#define FIQ_PENDING2          INT_PENDING2 
    60064568+ 
    60074569+#define HARD_IRQS            (64 + 21) 
    6008 +#define FIQ_IRQS              (64 + 21) 
    6009 +#define GPIO_IRQS            (32*5) 
    6010 + 
    6011 +#define NR_IRQS                      HARD_IRQS+FIQ_IRQS+GPIO_IRQS 
     4570+#define GPIO_IRQ_START       HARD_IRQS 
     4571+ 
     4572+#define GPIO_IRQS            32*5 
     4573+ 
     4574+#define NR_IRQS                      HARD_IRQS+GPIO_IRQS 
    60124575+ 
    60134576+ 
     
    60754638--- /dev/null 
    60764639+++ b/arch/arm/mach-bcm2708/include/mach/platform.h 
    6077 @@ -0,0 +1,226 @@ 
     4640@@ -0,0 +1,220 @@ 
    60784641+/* 
    60794642+ * arch/arm/mach-bcm2708/include/mach/platform.h 
     
    61344697+ 
    61354698+#define BCM2708_PERI_BASE        0x20000000 
    6136 +#define IC0_BASE                 (BCM2708_PERI_BASE + 0x2000) 
    61374699+#define ST_BASE                  (BCM2708_PERI_BASE + 0x3000)   /* System Timer */ 
    6138 +#define MPHI_BASE               (BCM2708_PERI_BASE + 0x6000)   /* Message -based Parallel Host Interface */ 
    61394700+#define DMA_BASE                (BCM2708_PERI_BASE + 0x7000)   /* DMA controller */ 
    61404701+#define ARM_BASE                 (BCM2708_PERI_BASE + 0xB000)   /* BCM2708 ARM control block */ 
    61414702+#define PM_BASE                         (BCM2708_PERI_BASE + 0x100000) /* Power Management, Reset controller and Watchdog registers */ 
    6142 +#define RNG_BASE                 (BCM2708_PERI_BASE + 0x104000) /* Hardware RNG */ 
    61434703+#define GPIO_BASE                (BCM2708_PERI_BASE + 0x200000) /* GPIO */ 
    61444704+#define UART0_BASE               (BCM2708_PERI_BASE + 0x201000)        /* Uart 0 */ 
    61454705+#define MMCI0_BASE               (BCM2708_PERI_BASE + 0x202000) /* MMC interface */ 
    6146 +#define SPI0_BASE               (BCM2708_PERI_BASE + 0x204000) /* SPI0 */ 
    6147 +#define BSC0_BASE               (BCM2708_PERI_BASE + 0x205000) /* BSC0 I2C/TWI */ 
    61484706+#define UART1_BASE               (BCM2708_PERI_BASE + 0x215000) /* Uart 1 */ 
    61494707+#define EMMC_BASE                (BCM2708_PERI_BASE + 0x300000) /* eMMC interface */ 
    61504708+#define SMI_BASE                (BCM2708_PERI_BASE + 0x600000) /* SMI */ 
    6151 +#define BSC1_BASE               (BCM2708_PERI_BASE + 0x804000) /* BSC1 I2C/TWI */ 
    61524709+#define USB_BASE                 (BCM2708_PERI_BASE + 0x980000) /* DTC_OTG USB controller */ 
    61534710+#define MCORE_BASE               (BCM2708_PERI_BASE + 0x0000)   /* Fake frame buffer device (actually the multicore sync block*/ 
     
    64855042+ */ 
    64865043+#define arch_decomp_wdog() 
     5044+ 
     5045--- /dev/null 
     5046+++ b/arch/arm/mach-bcm2708/include/mach/vc_mem.h 
     5047@@ -0,0 +1,36 @@ 
     5048+/***************************************************************************** 
     5049+* Copyright 2010 - 2011 Broadcom Corporation.  All rights reserved. 
     5050+* 
     5051+* Unless you and Broadcom execute a separate written software license 
     5052+* agreement governing use of this software, this software is licensed to you 
     5053+* under the terms of the GNU General Public License version 2, available at 
     5054+* http://www.broadcom.com/licenses/GPLv2.php (the "GPL"). 
     5055+* 
     5056+* Notwithstanding the above, under no circumstances may you combine this 
     5057+* software in any way with any other Broadcom software provided under a 
     5058+* license other than the GPL, without Broadcom's express prior written 
     5059+* consent. 
     5060+*****************************************************************************/ 
     5061+ 
     5062+#if !defined( VC_MEM_H ) 
     5063+#define VC_MEM_H 
     5064+ 
     5065+#include <linux/ioctl.h> 
     5066+ 
     5067+#define VC_MEM_IOC_MAGIC  'v' 
     5068+ 
     5069+#define VC_MEM_IOC_MEM_PHYS_ADDR    _IOR( VC_MEM_IOC_MAGIC, 0, unsigned long ) 
     5070+#define VC_MEM_IOC_MEM_SIZE         _IOR( VC_MEM_IOC_MAGIC, 1, unsigned int ) 
     5071+#define VC_MEM_IOC_MEM_BASE         _IOR( VC_MEM_IOC_MAGIC, 2, unsigned int ) 
     5072+#define VC_MEM_IOC_MEM_LOAD         _IOR( VC_MEM_IOC_MAGIC, 3, unsigned int ) 
     5073+ 
     5074+#if defined( __KERNEL__ ) 
     5075+#define VC_MEM_TO_ARM_ADDR_MASK 0x3FFFFFFF 
     5076+ 
     5077+extern unsigned long mm_vc_mem_phys_addr; 
     5078+extern unsigned int  mm_vc_mem_size; 
     5079+extern int vc_mem_get_current_size( void ); 
     5080+#endif 
     5081+ 
     5082+#endif  /* VC_MEM_H */ 
    64875083+ 
    64885084--- /dev/null 
     
    66315227+#endif 
    66325228--- /dev/null 
    6633 +++ b/arch/arm/mach-bcm2708/include/mach/vc_mem.h 
    6634 @@ -0,0 +1,36 @@ 
     5229+++ b/arch/arm/mach-bcm2708/include/mach/vmalloc.h 
     5230@@ -0,0 +1,20 @@ 
     5231+/* 
     5232+ *  arch/arm/mach-bcm2708/include/mach/vmalloc.h 
     5233+ * 
     5234+ *  Copyright (C) 2010 Broadcom 
     5235+ * 
     5236+ * This program is free software; you can redistribute it and/or modify 
     5237+ * it under the terms of the GNU General Public License as published by 
     5238+ * the Free Software Foundation; either version 2 of the License, or 
     5239+ * (at your option) any later version. 
     5240+ * 
     5241+ * This program is distributed in the hope that it will be useful, 
     5242+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
     5243+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     5244+ * GNU General Public License for more details. 
     5245+ * 
     5246+ * You should have received a copy of the GNU General Public License 
     5247+ * along with this program; if not, write to the Free Software 
     5248+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
     5249+ */ 
     5250+#define VMALLOC_END            (0xe8000000) 
     5251--- /dev/null 
     5252+++ b/arch/arm/mach-bcm2708/power.c 
     5253@@ -0,0 +1,194 @@ 
     5254+/* 
     5255+ *      linux/arch/arm/mach-bcm2708/power.c 
     5256+ * 
     5257+ *      Copyright (C) 2010 Broadcom 
     5258+ * 
     5259+ * This program is free software; you can redistribute it and/or modify 
     5260+ * it under the terms of the GNU General Public License version 2 as 
     5261+ * published by the Free Software Foundation. 
     5262+ * 
     5263+ * This device provides a shared mechanism for controlling the power to 
     5264+ * VideoCore subsystems. 
     5265+ */ 
     5266+ 
     5267+#include <linux/module.h> 
     5268+#include <linux/semaphore.h> 
     5269+#include <linux/bug.h> 
     5270+#include <mach/power.h> 
     5271+#include <mach/vcio.h> 
     5272+#include <mach/arm_power.h> 
     5273+ 
     5274+#define DRIVER_NAME "bcm2708_power" 
     5275+ 
     5276+#define BCM_POWER_MAXCLIENTS 4 
     5277+#define BCM_POWER_NOCLIENT (1<<31) 
     5278+ 
     5279+/* Some drivers expect there devices to be permanently powered */ 
     5280+#define BCM_POWER_ALWAYS_ON (BCM_POWER_USB) 
     5281+ 
     5282+#if 1 
     5283+#define DPRINTK printk 
     5284+#else 
     5285+#define DPRINTK if (0) printk 
     5286+#endif 
     5287+ 
     5288+struct state_struct { 
     5289+       uint32_t global_request; 
     5290+       uint32_t client_request[BCM_POWER_MAXCLIENTS]; 
     5291+       struct semaphore client_mutex; 
     5292+       struct semaphore mutex; 
     5293+} g_state; 
     5294+ 
     5295+int bcm_power_open(BCM_POWER_HANDLE_T *handle) 
     5296+{ 
     5297+       BCM_POWER_HANDLE_T i; 
     5298+       int ret = -EBUSY; 
     5299+ 
     5300+       down(&g_state.client_mutex); 
     5301+ 
     5302+       for (i = 0; i < BCM_POWER_MAXCLIENTS; i++) { 
     5303+               if (g_state.client_request[i] == BCM_POWER_NOCLIENT) { 
     5304+                       g_state.client_request[i] = BCM_POWER_NONE; 
     5305+                       *handle = i; 
     5306+                       ret = 0; 
     5307+                       break; 
     5308+               } 
     5309+       } 
     5310+ 
     5311+       up(&g_state.client_mutex); 
     5312+ 
     5313+       DPRINTK("bcm_power_open() -> %d\n", *handle); 
     5314+ 
     5315+       return ret; 
     5316+} 
     5317+EXPORT_SYMBOL_GPL(bcm_power_open); 
     5318+ 
     5319+int bcm_power_request(BCM_POWER_HANDLE_T handle, uint32_t request) 
     5320+{ 
     5321+       int rc = 0; 
     5322+ 
     5323+       DPRINTK("bcm_power_request(%d, %x)\n", handle, request); 
     5324+ 
     5325+       if ((handle < BCM_POWER_MAXCLIENTS) && 
     5326+           (g_state.client_request[handle] != BCM_POWER_NOCLIENT)) { 
     5327+               if (down_interruptible(&g_state.mutex) != 0) { 
     5328+                       DPRINTK("bcm_power_request -> interrupted\n"); 
     5329+                       return -EINTR; 
     5330+               } 
     5331+ 
     5332+               if (request != g_state.client_request[handle]) { 
     5333+                       uint32_t others_request = 0; 
     5334+                       uint32_t global_request; 
     5335+                       BCM_POWER_HANDLE_T i; 
     5336+ 
     5337+                       for (i = 0; i < BCM_POWER_MAXCLIENTS; i++) { 
     5338+                               if (i != handle) 
     5339+                                       others_request |= 
     5340+                                           g_state.client_request[i]; 
     5341+                       } 
     5342+                       others_request &= ~BCM_POWER_NOCLIENT; 
     5343+ 
     5344+                       global_request = request | others_request; 
     5345+                       if (global_request != g_state.global_request) { 
     5346+                               uint32_t actual; 
     5347+ 
     5348+                               /* Send a request to VideoCore */ 
     5349+                               bcm_mailbox_write(MBOX_CHAN_POWER, 
     5350+                                                 global_request << 4); 
     5351+ 
     5352+                               /* Wait for a response during power-up */ 
     5353+                               if (global_request & ~g_state.global_request) { 
     5354+                                       rc = bcm_mailbox_read(MBOX_CHAN_POWER, 
     5355+                                                             &actual); 
     5356+                                       DPRINTK 
     5357+                                           ("bcm_mailbox_read -> %08x, %d\n", 
     5358+                                            actual, rc); 
     5359+                                       actual >>= 4; 
     5360+                               } else { 
     5361+                                       rc = 0; 
     5362+                                       actual = global_request; 
     5363+                               } 
     5364+ 
     5365+                               if (rc == 0) { 
     5366+                                       if (actual != global_request) { 
     5367+                                               printk(KERN_ERR 
     5368+                                                    "%s: prev global %x, new global %x, actual %x, request %x, others_request %x\n", 
     5369+                                                    __func__, 
     5370+                                                    g_state.global_request, 
     5371+                                                    global_request, actual, request, others_request); 
     5372+                                               /* A failure */ 
     5373+                                               BUG_ON((others_request & actual) 
     5374+                                                      != others_request); 
     5375+                                               request &= actual; 
     5376+                                               rc = -EIO; 
     5377+                                       } 
     5378+ 
     5379+                                       g_state.global_request = actual; 
     5380+                                       g_state.client_request[handle] = 
     5381+                                           request; 
     5382+                               } 
     5383+                       } 
     5384+               } 
     5385+               up(&g_state.mutex); 
     5386+       } else { 
     5387+               rc = -EINVAL; 
     5388+       } 
     5389+       DPRINTK("bcm_power_request -> %d\n", rc); 
     5390+       return rc; 
     5391+} 
     5392+EXPORT_SYMBOL_GPL(bcm_power_request); 
     5393+ 
     5394+int bcm_power_close(BCM_POWER_HANDLE_T handle) 
     5395+{ 
     5396+       int rc; 
     5397+ 
     5398+       DPRINTK("bcm_power_close(%d)\n", handle); 
     5399+ 
     5400+       rc = bcm_power_request(handle, BCM_POWER_NONE); 
     5401+       if (rc == 0) 
     5402+               g_state.client_request[handle] = BCM_POWER_NOCLIENT; 
     5403+ 
     5404+       return rc; 
     5405+} 
     5406+EXPORT_SYMBOL_GPL(bcm_power_close); 
     5407+ 
     5408+static int __init bcm_power_init(void) 
     5409+{ 
     5410+#if defined(BCM_POWER_ALWAYS_ON) 
     5411+       BCM_POWER_HANDLE_T always_on_handle; 
     5412+#endif 
     5413+       int rc = 0; 
     5414+       int i; 
     5415+ 
     5416+       printk(KERN_INFO "bcm_power: Broadcom power driver\n"); 
     5417+       bcm_mailbox_write(MBOX_CHAN_POWER, 0); 
     5418+ 
     5419+       for (i = 0; i < BCM_POWER_MAXCLIENTS; i++) 
     5420+               g_state.client_request[i] = BCM_POWER_NOCLIENT; 
     5421+ 
     5422+       sema_init(&g_state.client_mutex, 1); 
     5423+       sema_init(&g_state.mutex, 1); 
     5424+ 
     5425+       g_state.global_request = 0; 
     5426+ 
     5427+#if defined(BCM_POWER_ALWAYS_ON) 
     5428+       if (BCM_POWER_ALWAYS_ON) { 
     5429+               bcm_power_open(&always_on_handle); 
     5430+               bcm_power_request(always_on_handle, BCM_POWER_ALWAYS_ON); 
     5431+       } 
     5432+#endif 
     5433+ 
     5434+       return rc; 
     5435+} 
     5436+ 
     5437+static void __exit bcm_power_exit(void) 
     5438+{ 
     5439+       bcm_mailbox_write(MBOX_CHAN_POWER, 0); 
     5440+} 
     5441+ 
     5442+arch_initcall(bcm_power_init); /* Initialize early */ 
     5443+module_exit(bcm_power_exit); 
     5444+ 
     5445+MODULE_AUTHOR("Phil Elwell"); 
     5446+MODULE_DESCRIPTION("Interface to BCM2708 power management"); 
     5447+MODULE_LICENSE("GPL"); 
     5448--- /dev/null 
     5449+++ b/arch/arm/mach-bcm2708/vc_mem.c 
     5450@@ -0,0 +1,462 @@ 
    66355451+/***************************************************************************** 
    66365452+* Copyright 2010 - 2011 Broadcom Corporation.  All rights reserved. 
     
    66475463+*****************************************************************************/ 
    66485464+ 
    6649 +#if !defined( VC_MEM_H ) 
    6650 +#define VC_MEM_H 
    6651 + 
    6652 +#include <linux/ioctl.h> 
    6653 + 
    6654 +#define VC_MEM_IOC_MAGIC  'v' 
    6655 + 
    6656 +#define VC_MEM_IOC_MEM_PHYS_ADDR    _IOR( VC_MEM_IOC_MAGIC, 0, unsigned long ) 
    6657 +#define VC_MEM_IOC_MEM_SIZE         _IOR( VC_MEM_IOC_MAGIC, 1, unsigned int ) 
    6658 +#define VC_MEM_IOC_MEM_BASE         _IOR( VC_MEM_IOC_MAGIC, 2, unsigned int ) 
    6659 +#define VC_MEM_IOC_MEM_LOAD         _IOR( VC_MEM_IOC_MAGIC, 3, unsigned int ) 
    6660 + 
    6661 +#if defined( __KERNEL__ ) 
    6662 +#define VC_MEM_TO_ARM_ADDR_MASK 0x3FFFFFFF 
    6663 + 
    6664 +extern unsigned long mm_vc_mem_phys_addr; 
    6665 +extern unsigned int  mm_vc_mem_size; 
    6666 +extern int vc_mem_get_current_size( void ); 
     5465+#include <linux/kernel.h> 
     5466+#include <linux/module.h> 
     5467+#include <linux/fs.h> 
     5468+#include <linux/device.h> 
     5469+#include <linux/cdev.h> 
     5470+#include <linux/mm.h> 
     5471+#include <linux/slab.h> 
     5472+#include <linux/proc_fs.h> 
     5473+#include <asm/uaccess.h> 
     5474+#include <linux/dma-mapping.h> 
     5475+ 
     5476+#ifdef CONFIG_ARCH_KONA 
     5477+#include <chal/chal_ipc.h> 
     5478+#elif CONFIG_ARCH_BCM2708 
     5479+#else 
     5480+#include <csp/chal_ipc.h> 
    66675481+#endif 
    66685482+ 
    6669 +#endif  /* VC_MEM_H */ 
    6670 + 
    6671 --- /dev/null 
    6672 +++ b/arch/arm/mach-bcm2708/include/mach/vc_support.h 
    6673 @@ -0,0 +1,69 @@ 
    6674 +#ifndef _VC_SUPPORT_H_ 
    6675 +#define _VC_SUPPORT_H_ 
     5483+#include "mach/vc_mem.h" 
     5484+#include <mach/vcio.h> 
     5485+ 
     5486+#define DRIVER_NAME  "vc-mem" 
     5487+ 
     5488+// Uncomment to enable debug logging 
     5489+// #define ENABLE_DBG 
     5490+ 
     5491+#if defined(ENABLE_DBG) 
     5492+#define LOG_DBG( fmt, ... )  printk( KERN_INFO fmt "\n", ##__VA_ARGS__ ) 
     5493+#else 
     5494+#define LOG_DBG( fmt, ... ) 
     5495+#endif 
     5496+#define LOG_ERR( fmt, ... )  printk( KERN_ERR fmt "\n", ##__VA_ARGS__ ) 
     5497+ 
     5498+// Device (/dev) related variables 
     5499+static dev_t vc_mem_devnum = 0; 
     5500+static struct class *vc_mem_class = NULL; 
     5501+static struct cdev vc_mem_cdev; 
     5502+static int vc_mem_inited = 0; 
     5503+ 
     5504+// Proc entry 
     5505+static struct proc_dir_entry *vc_mem_proc_entry; 
    66765506+ 
    66775507+/* 
    6678 + * vc_support.h 
    6679 + * 
    6680 + *  Created on: 25 Nov 2012 
    6681 + *      Author: Simon 
     5508+ * Videocore memory addresses and size 
     5509+ * 
     5510+ * Drivers that wish to know the videocore memory addresses and sizes should 
     5511+ * use these variables instead of the MM_IO_BASE and MM_ADDR_IO defines in 
     5512+ * headers. This allows the other drivers to not be tied down to a a certain 
     5513+ * address/size at compile time. 
     5514+ * 
     5515+ * In the future, the goal is to have the videocore memory virtual address and 
     5516+ * size be calculated at boot time rather than at compile time. The decision of 
     5517+ * where the videocore memory resides and its size would be in the hands of the 
     5518+ * bootloader (and/or kernel). When that happens, the values of these variables 
     5519+ * would be calculated and assigned in the init function. 
    66825520+ */ 
    6683 + 
    6684 +enum { 
    6685 +/* 
    6686 +      If a MEM_HANDLE_T is discardable, the memory manager may resize it to size 
    6687 +      0 at any time when it is not locked or retained. 
    6688 +   */ 
    6689 +   MEM_FLAG_DISCARDABLE = 1 << 0, 
    6690 + 
    6691 +   /* 
    6692 +      If a MEM_HANDLE_T is allocating (or normal), its block of memory will be 
    6693 +      accessed in an allocating fashion through the cache. 
    6694 +   */ 
    6695 +   MEM_FLAG_NORMAL = 0 << 2, 
    6696 +   MEM_FLAG_ALLOCATING = MEM_FLAG_NORMAL, 
    6697 + 
    6698 +   /* 
    6699 +      If a MEM_HANDLE_T is direct, its block of memory will be accessed 
    6700 +      directly, bypassing the cache. 
    6701 +   */ 
    6702 +   MEM_FLAG_DIRECT = 1 << 2, 
    6703 + 
    6704 +   /* 
    6705 +      If a MEM_HANDLE_T is coherent, its block of memory will be accessed in a 
    6706 +      non-allocating fashion through the cache. 
    6707 +   */ 
    6708 +   MEM_FLAG_COHERENT = 2 << 2, 
    6709 + 
    6710 +   /* 
    6711 +      If a MEM_HANDLE_T is L1-nonallocating, its block of memory will be accessed by 
    6712 +      the VPU in a fashion which is allocating in L2, but only coherent in L1. 
    6713 +   */ 
    6714 +   MEM_FLAG_L1_NONALLOCATING = (MEM_FLAG_DIRECT | MEM_FLAG_COHERENT), 
    6715 + 
    6716 +   /* 
    6717 +      If a MEM_HANDLE_T is zero'd, its contents are set to 0 rather than 
    6718 +      MEM_HANDLE_INVALID on allocation and resize up. 
    6719 +   */ 
    6720 +   MEM_FLAG_ZERO = 1 << 4, 
    6721 + 
    6722 +   /* 
    6723 +      If a MEM_HANDLE_T is uninitialised, it will not be reset to a defined value 
    6724 +      (either zero, or all 1's) on allocation. 
    6725 +    */ 
    6726 +   MEM_FLAG_NO_INIT = 1 << 5, 
    6727 + 
    6728 +   /* 
    6729 +      Hints. 
    6730 +   */ 
    6731 +   MEM_FLAG_HINT_PERMALOCK = 1 << 6, /* Likely to be locked for long periods of time. */ 
    6732 +}; 
    6733 + 
    6734 +unsigned int AllocateVcMemory(unsigned int *pHandle, unsigned int size, unsigned int alignment, unsigned int flags); 
    6735 +unsigned int ReleaseVcMemory(unsigned int handle); 
    6736 +unsigned int LockVcMemory(unsigned int *pBusAddress, unsigned int handle); 
    6737 +unsigned int UnlockVcMemory(unsigned int handle); 
    6738 + 
    6739 +unsigned int ExecuteVcCode(unsigned int code, 
    6740 +               unsigned int r0, unsigned int r1, unsigned int r2, unsigned int r3, unsigned int r4, unsigned int r5); 
    6741 + 
    6742 +#endif 
    6743 --- /dev/null 
    6744 +++ b/arch/arm/mach-bcm2708/include/mach/vmalloc.h 
    6745 @@ -0,0 +1,20 @@ 
    6746 +/* 
    6747 + *  arch/arm/mach-bcm2708/include/mach/vmalloc.h 
    6748 + * 
    6749 + *  Copyright (C) 2010 Broadcom 
    6750 + * 
    6751 + * This program is free software; you can redistribute it and/or modify 
    6752 + * it under the terms of the GNU General Public License as published by 
    6753 + * the Free Software Foundation; either version 2 of the License, or 
    6754 + * (at your option) any later version. 
    6755 + * 
    6756 + * This program is distributed in the hope that it will be useful, 
    6757 + * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    6758 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    6759 + * GNU General Public License for more details. 
    6760 + * 
    6761 + * You should have received a copy of the GNU General Public License 
    6762 + * along with this program; if not, write to the Free Software 
    6763 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
    6764 + */ 
    6765 +#define VMALLOC_END            (0xe8000000) 
    6766 --- /dev/null 
    6767 +++ b/arch/arm/mach-bcm2708/Kconfig 
    6768 @@ -0,0 +1,48 @@ 
    6769 +menu "Broadcom BCM2708 Implementations" 
    6770 +       depends on ARCH_BCM2708 
    6771 + 
    6772 +config MACH_BCM2708 
    6773 +       bool "Broadcom BCM2708 Development Platform" 
    6774 +       select NEED_MACH_MEMORY_H 
    6775 +       select NEED_MACH_IO_H 
    6776 +       select CPU_V6 
    6777 +       help 
    6778 +         Include support for the Broadcom(R) BCM2708 platform. 
    6779 + 
    6780 +config BCM2708_GPIO 
    6781 +       bool "BCM2708 gpio support" 
    6782 +       depends on MACH_BCM2708 
    6783 +       select ARCH_REQUIRE_GPIOLIB 
    6784 +        default y 
    6785 +       help 
    6786 +         Include support for the Broadcom(R) BCM2708 gpio. 
    6787 + 
    6788 +config BCM2708_VCMEM 
    6789 +       bool "Videocore Memory" 
    6790 +       depends on MACH_BCM2708 
    6791 +        default y 
    6792 +        help 
    6793 +          Helper for videocore memory access and total size allocation.            
    6794 + 
    6795 +config BCM2708_NOL2CACHE 
    6796 +       bool "Videocore L2 cache disable" 
    6797 +       depends on MACH_BCM2708 
    6798 +        default n 
    6799 +        help 
    6800 +          Do not allow ARM to use GPU's L2 cache. Requires disable_l2cache in config.txt. 
    6801 + 
    6802 +config BCM2708_DMAER 
    6803 +       tristate "BCM2708 DMA helper" 
    6804 +       depends on MACH_BCM2708 
    6805 +        default n 
    6806 +        help 
    6807 +          Enable DMA helper for accelerating X composition 
    6808 + 
    6809 +config BCM2708_SPIDEV 
    6810 +       bool "Bind spidev to SPI0 master" 
    6811 +       depends on MACH_BCM2708   
    6812 +       depends on SPI 
    6813 +        default y 
    6814 +               help  
    6815 +                       Binds spidev driver to the SPI0 master   
    6816 +endmenu 
    6817 --- /dev/null 
    6818 +++ b/arch/arm/mach-bcm2708/Makefile 
    6819 @@ -0,0 +1,11 @@ 
    6820 +# 
    6821 +# Makefile for the linux kernel. 
    6822 +# 
    6823 + 
    6824 +obj-$(CONFIG_MACH_BCM2708)     += clock.o bcm2708.o armctrl.o vcio.o power.o dma.o 
    6825 +obj-$(CONFIG_BCM2708_GPIO)     += bcm2708_gpio.o 
    6826 +obj-$(CONFIG_BCM2708_VCMEM)    += vc_mem.o 
    6827 + 
    6828 +obj-$(CONFIG_BCM2708_DMAER)    += dmaer_master.o 
    6829 +dmaer_master-objs              := dmaer.o vc_support.o 
    6830 + 
    6831 --- /dev/null 
    6832 +++ b/arch/arm/mach-bcm2708/Makefile.boot 
    6833 @@ -0,0 +1,3 @@ 
    6834 +   zreladdr-y  := 0x00008000 
    6835 +params_phys-y  := 0x00000100 
    6836 +initrd_phys-y  := 0x00800000 
    6837 --- /dev/null 
    6838 +++ b/arch/arm/mach-bcm2708/power.c 
    6839 @@ -0,0 +1,194 @@ 
    6840 +/* 
    6841 + *      linux/arch/arm/mach-bcm2708/power.c 
    6842 + * 
    6843 + *      Copyright (C) 2010 Broadcom 
    6844 + * 
    6845 + * This program is free software; you can redistribute it and/or modify 
    6846 + * it under the terms of the GNU General Public License version 2 as 
    6847 + * published by the Free Software Foundation. 
    6848 + * 
    6849 + * This device provides a shared mechanism for controlling the power to 
    6850 + * VideoCore subsystems. 
    6851 + */ 
    6852 + 
    6853 +#include <linux/module.h> 
    6854 +#include <linux/semaphore.h> 
    6855 +#include <linux/bug.h> 
    6856 +#include <mach/power.h> 
    6857 +#include <mach/vcio.h> 
    6858 +#include <mach/arm_power.h> 
    6859 + 
    6860 +#define DRIVER_NAME "bcm2708_power" 
    6861 + 
    6862 +#define BCM_POWER_MAXCLIENTS 4 
    6863 +#define BCM_POWER_NOCLIENT (1<<31) 
    6864 + 
    6865 +/* Some drivers expect there devices to be permanently powered */ 
    6866 +#define BCM_POWER_ALWAYS_ON (BCM_POWER_USB) 
    6867 + 
    6868 +#if 1 
    6869 +#define DPRINTK printk 
    6870 +#else 
    6871 +#define DPRINTK if (0) printk 
    6872 +#endif 
    6873 + 
    6874 +struct state_struct { 
    6875 +       uint32_t global_request; 
    6876 +       uint32_t client_request[BCM_POWER_MAXCLIENTS]; 
    6877 +       struct semaphore client_mutex; 
    6878 +       struct semaphore mutex; 
    6879 +} g_state; 
    6880 + 
    6881 +int bcm_power_open(BCM_POWER_HANDLE_T *handle) 
    6882 +{ 
    6883 +       BCM_POWER_HANDLE_T i; 
    6884 +       int ret = -EBUSY; 
    6885 + 
    6886 +       down(&g_state.client_mutex); 
    6887 + 
    6888 +       for (i = 0; i < BCM_POWER_MAXCLIENTS; i++) { 
    6889 +               if (g_state.client_request[i] == BCM_POWER_NOCLIENT) { 
    6890 +                       g_state.client_request[i] = BCM_POWER_NONE; 
    6891 +                       *handle = i; 
    6892 +                       ret = 0; 
     5521+// in the 2835 VC in mapped above ARM, but ARM has full access to VC space 
     5522+unsigned long mm_vc_mem_phys_addr = 0x00000000; 
     5523+unsigned int mm_vc_mem_size = 0; 
     5524+unsigned int mm_vc_mem_base = 0; 
     5525+ 
     5526+EXPORT_SYMBOL(mm_vc_mem_phys_addr); 
     5527+EXPORT_SYMBOL(mm_vc_mem_size); 
     5528+EXPORT_SYMBOL(mm_vc_mem_base); 
     5529+ 
     5530+static uint phys_addr = 0; 
     5531+static uint mem_size = 0; 
     5532+static uint mem_base = 0; 
     5533+ 
     5534+ 
     5535+/**************************************************************************** 
     5536+* 
     5537+*   vc_mem_open 
     5538+* 
     5539+***************************************************************************/ 
     5540+ 
     5541+static int 
     5542+vc_mem_open(struct inode *inode, struct file *file) 
     5543+{ 
     5544+       (void) inode; 
     5545+       (void) file; 
     5546+ 
     5547+       LOG_DBG("%s: called file = 0x%p", __func__, file); 
     5548+ 
     5549+       return 0; 
     5550+} 
     5551+ 
     5552+/**************************************************************************** 
     5553+* 
     5554+*   vc_mem_release 
     5555+* 
     5556+***************************************************************************/ 
     5557+ 
     5558+static int 
     5559+vc_mem_release(struct inode *inode, struct file *file) 
     5560+{ 
     5561+       (void) inode; 
     5562+       (void) file; 
     5563+ 
     5564+       LOG_DBG("%s: called file = 0x%p", __func__, file); 
     5565+ 
     5566+       return 0; 
     5567+} 
     5568+ 
     5569+/**************************************************************************** 
     5570+* 
     5571+*   vc_mem_get_size 
     5572+* 
     5573+***************************************************************************/ 
     5574+ 
     5575+static void 
     5576+vc_mem_get_size(void) 
     5577+{ 
     5578+} 
     5579+ 
     5580+/**************************************************************************** 
     5581+* 
     5582+*   vc_mem_get_base 
     5583+* 
     5584+***************************************************************************/ 
     5585+ 
     5586+static void 
     5587+vc_mem_get_base(void) 
     5588+{ 
     5589+} 
     5590+ 
     5591+/**************************************************************************** 
     5592+* 
     5593+*   vc_mem_get_current_size 
     5594+* 
     5595+***************************************************************************/ 
     5596+ 
     5597+int 
     5598+vc_mem_get_current_size(void) 
     5599+{ 
     5600+       return mm_vc_mem_size; 
     5601+} 
     5602+ 
     5603+EXPORT_SYMBOL_GPL(vc_mem_get_current_size); 
     5604+ 
     5605+/**************************************************************************** 
     5606+* 
     5607+*   vc_mem_ioctl 
     5608+* 
     5609+***************************************************************************/ 
     5610+ 
     5611+static long 
     5612+vc_mem_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 
     5613+{ 
     5614+       int rc = 0; 
     5615+ 
     5616+       (void) cmd; 
     5617+       (void) arg; 
     5618+ 
     5619+       LOG_DBG("%s: called file = 0x%p", __func__, file); 
     5620+ 
     5621+       switch (cmd) { 
     5622+       case VC_MEM_IOC_MEM_PHYS_ADDR: 
     5623+               { 
     5624+                       LOG_DBG("%s: VC_MEM_IOC_MEM_PHYS_ADDR=0x%p", 
     5625+                               __func__, (void *) mm_vc_mem_phys_addr); 
     5626+ 
     5627+                       if (copy_to_user((void *) arg, &mm_vc_mem_phys_addr, 
     5628+                                        sizeof (mm_vc_mem_phys_addr)) != 0) { 
     5629+                               rc = -EFAULT; 
     5630+                       } 
    68935631+                       break; 
    68945632+               } 
     5633+       case VC_MEM_IOC_MEM_SIZE: 
     5634+               { 
     5635+                       // Get the videocore memory size first 
     5636+                       vc_mem_get_size(); 
     5637+ 
     5638+                       LOG_DBG("%s: VC_MEM_IOC_MEM_SIZE=%u", __func__, 
     5639+                               mm_vc_mem_size); 
     5640+ 
     5641+                       if (copy_to_user((void *) arg, &mm_vc_mem_size, 
     5642+                                        sizeof (mm_vc_mem_size)) != 0) { 
     5643+                               rc = -EFAULT; 
     5644+                       } 
     5645+                       break; 
     5646+               } 
     5647+       case VC_MEM_IOC_MEM_BASE: 
     5648+               { 
     5649+                       // Get the videocore memory base 
     5650+                       vc_mem_get_base(); 
     5651+ 
     5652+                       LOG_DBG("%s: VC_MEM_IOC_MEM_BASE=%u", __func__, 
     5653+                               mm_vc_mem_base); 
     5654+ 
     5655+                       if (copy_to_user((void *) arg, &mm_vc_mem_base, 
     5656+                                        sizeof (mm_vc_mem_base)) != 0) { 
     5657+                               rc = -EFAULT; 
     5658+                       } 
     5659+                       break; 
     5660+               } 
     5661+       case VC_MEM_IOC_MEM_LOAD: 
     5662+               { 
     5663+                       // Get the videocore memory base 
     5664+                       vc_mem_get_base(); 
     5665+ 
     5666+                       LOG_DBG("%s: VC_MEM_IOC_MEM_LOAD=%u", __func__, 
     5667+                               mm_vc_mem_base); 
     5668+ 
     5669+                       if (copy_to_user((void *) arg, &mm_vc_mem_base, 
     5670+                                        sizeof (mm_vc_mem_base)) != 0) { 
     5671+                               rc = -EFAULT; 
     5672+                       } 
     5673+                       break; 
     5674+               } 
     5675+       default: 
     5676+               { 
     5677+                       return -ENOTTY; 
     5678+               } 
    68955679+       } 
    6896 + 
    6897 +       up(&g_state.client_mutex); 
    6898 + 
    6899 +       DPRINTK("bcm_power_open() -> %d\n", *handle); 
    6900 + 
    6901 +       return ret; 
    6902 +} 
    6903 +EXPORT_SYMBOL_GPL(bcm_power_open); 
    6904 + 
    6905 +int bcm_power_request(BCM_POWER_HANDLE_T handle, uint32_t request) 
     5680+       LOG_DBG("%s: file = 0x%p returning %d", __func__, file, rc); 
     5681+ 
     5682+       return rc; 
     5683+} 
     5684+ 
     5685+/**************************************************************************** 
     5686+* 
     5687+*   vc_mem_mmap 
     5688+* 
     5689+***************************************************************************/ 
     5690+ 
     5691+static int 
     5692+vc_mem_mmap(struct file *filp, struct vm_area_struct *vma) 
    69065693+{ 
    69075694+       int rc = 0; 
    6908 + 
    6909 +       DPRINTK("bcm_power_request(%d, %x)\n", handle, request); 
    6910 + 
    6911 +       if ((handle < BCM_POWER_MAXCLIENTS) && 
    6912 +           (g_state.client_request[handle] != BCM_POWER_NOCLIENT)) { 
    6913 +               if (down_interruptible(&g_state.mutex) != 0) { 
    6914 +                       DPRINTK("bcm_power_request -> interrupted\n"); 
    6915 +                       return -EINTR; 
    6916 +               } 
    6917 + 
    6918 +               if (request != g_state.client_request[handle]) { 
    6919 +                       uint32_t others_request = 0; 
    6920 +                       uint32_t global_request; 
    6921 +                       BCM_POWER_HANDLE_T i; 
    6922 + 
    6923 +                       for (i = 0; i < BCM_POWER_MAXCLIENTS; i++) { 
    6924 +                               if (i != handle) 
    6925 +                                       others_request |= 
    6926 +                                           g_state.client_request[i]; 
    6927 +                       } 
    6928 +                       others_request &= ~BCM_POWER_NOCLIENT; 
    6929 + 
    6930 +                       global_request = request | others_request; 
    6931 +                       if (global_request != g_state.global_request) { 
    6932 +                               uint32_t actual; 
    6933 + 
    6934 +                               /* Send a request to VideoCore */ 
    6935 +                               bcm_mailbox_write(MBOX_CHAN_POWER, 
    6936 +                                                 global_request << 4); 
    6937 + 
    6938 +                               /* Wait for a response during power-up */ 
    6939 +                               if (global_request & ~g_state.global_request) { 
    6940 +                                       rc = bcm_mailbox_read(MBOX_CHAN_POWER, 
    6941 +                                                             &actual); 
    6942 +                                       DPRINTK 
    6943 +                                           ("bcm_mailbox_read -> %08x, %d\n", 
    6944 +                                            actual, rc); 
    6945 +                                       actual >>= 4; 
    6946 +                               } else { 
    6947 +                                       rc = 0; 
    6948 +                                       actual = global_request; 
    6949 +                               } 
    6950 + 
    6951 +                               if (rc == 0) { 
    6952 +                                       if (actual != global_request) { 
    6953 +                                               printk(KERN_ERR 
    6954 +                                                    "%s: prev global %x, new global %x, actual %x, request %x, others_request %x\n", 
    6955 +                                                    __func__, 
    6956 +                                                    g_state.global_request, 
    6957 +                                                    global_request, actual, request, others_request); 
    6958 +                                               /* A failure */ 
    6959 +                                               BUG_ON((others_request & actual) 
    6960 +                                                      != others_request); 
    6961 +                                               request &= actual; 
    6962 +                                               rc = -EIO; 
    6963 +                                       } 
    6964 + 
    6965 +                                       g_state.global_request = actual; 
    6966 +                                       g_state.client_request[handle] = 
    6967 +                                           request; 
    6968 +                               } 
    6969 +                       } 
    6970 +               } 
    6971 +               up(&g_state.mutex); 
    6972 +       } else { 
    6973 +               rc = -EINVAL; 
     5695+       unsigned long length = vma->vm_end - vma->vm_start; 
     5696+       unsigned long offset = vma->vm_pgoff << PAGE_SHIFT; 
     5697+ 
     5698+       LOG_DBG("%s: vm_start = 0x%08lx vm_end = 0x%08lx vm_pgoff = 0x%08lx", 
     5699+               __func__, (long) vma->vm_start, (long) vma->vm_end, 
     5700+               (long) vma->vm_pgoff); 
     5701+ 
     5702+       if (offset + length > mm_vc_mem_size) { 
     5703+               LOG_ERR("%s: length %ld is too big", __func__, length); 
     5704+               return -EINVAL; 
    69745705+       } 
    6975 +       DPRINTK("bcm_power_request -> %d\n", rc); 
     5706+       // Do not cache the memory map 
     5707+       vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 
     5708+ 
     5709+       rc = remap_pfn_range(vma, vma->vm_start, 
     5710+                            (mm_vc_mem_phys_addr >> PAGE_SHIFT) + 
     5711+                            vma->vm_pgoff, length, vma->vm_page_prot); 
     5712+       if (rc != 0) { 
     5713+               LOG_ERR("%s: remap_pfn_range failed (rc=%d)", __func__, rc); 
     5714+       } 
     5715+ 
    69765716+       return rc; 
    69775717+} 
    6978 +EXPORT_SYMBOL_GPL(bcm_power_request); 
    6979 + 
    6980 +int bcm_power_close(BCM_POWER_HANDLE_T handle) 
    6981 +{ 
    6982 +       int rc; 
    6983 + 
    6984 +       DPRINTK("bcm_power_close(%d)\n", handle); 
    6985 + 
    6986 +       rc = bcm_power_request(handle, BCM_POWER_NONE); 
    6987 +       if (rc == 0) 
    6988 +               g_state.client_request[handle] = BCM_POWER_NOCLIENT; 
    6989 + 
     5718+ 
     5719+/**************************************************************************** 
     5720+* 
     5721+*   File Operations for the driver. 
     5722+* 
     5723+***************************************************************************/ 
     5724+ 
     5725+static const struct file_operations vc_mem_fops = { 
     5726+       .owner = THIS_MODULE, 
     5727+       .open = vc_mem_open, 
     5728+       .release = vc_mem_release, 
     5729+       .unlocked_ioctl = vc_mem_ioctl, 
     5730+       .mmap = vc_mem_mmap, 
     5731+}; 
     5732+ 
     5733+/**************************************************************************** 
     5734+* 
     5735+*   vc_mem_proc_read 
     5736+* 
     5737+***************************************************************************/ 
     5738+ 
     5739+static int 
     5740+vc_mem_proc_read(char *buf, char **start, off_t offset, int count, int *eof, 
     5741+                void *data) 
     5742+{ 
     5743+       char *p = buf; 
     5744+ 
     5745+       (void) start; 
     5746+       (void) count; 
     5747+       (void) data; 
     5748+ 
     5749+       if (offset > 0) { 
     5750+               *eof = 1; 
     5751+               return 0; 
     5752+       } 
     5753+       // Get the videocore memory size first 
     5754+       vc_mem_get_size(); 
     5755+ 
     5756+       p += sprintf(p, "Videocore memory:\n"); 
     5757+       if (mm_vc_mem_phys_addr != 0) 
     5758+               p += sprintf(p, "   Physical address: 0x%p\n", 
     5759+                            (void *) mm_vc_mem_phys_addr); 
     5760+       else 
     5761+               p += sprintf(p, "   Physical address: 0x00000000\n"); 
     5762+       p += sprintf(p, "   Length (bytes):   %u\n", mm_vc_mem_size); 
     5763+ 
     5764+       *eof = 1; 
     5765+       return p - buf; 
     5766+} 
     5767+ 
     5768+/**************************************************************************** 
     5769+* 
     5770+*   vc_mem_proc_write 
     5771+* 
     5772+***************************************************************************/ 
     5773+ 
     5774+static int 
     5775+vc_mem_proc_write(struct file *file, const char __user * buffer, 
     5776+                 unsigned long count, void *data) 
     5777+{ 
     5778+       int rc = -EFAULT; 
     5779+       char input_str[10]; 
     5780+ 
     5781+       memset(input_str, 0, sizeof (input_str)); 
     5782+ 
     5783+       if (count > sizeof (input_str)) { 
     5784+               LOG_ERR("%s: input string length too long", __func__); 
     5785+               goto out; 
     5786+       } 
     5787+ 
     5788+       if (copy_from_user(input_str, buffer, count - 1)) { 
     5789+               LOG_ERR("%s: failed to get input string", __func__); 
     5790+               goto out; 
     5791+       } 
     5792+ 
     5793+       if (strncmp(input_str, "connect", strlen("connect")) == 0) { 
     5794+               // Get the videocore memory size from the videocore 
     5795+               vc_mem_get_size(); 
     5796+       } 
     5797+ 
     5798+      out: 
    69905799+       return rc; 
    69915800+} 
    6992 +EXPORT_SYMBOL_GPL(bcm_power_close); 
    6993 + 
    6994 +static int __init bcm_power_init(void) 
    6995 +{ 
    6996 +#if defined(BCM_POWER_ALWAYS_ON) 
    6997 +       BCM_POWER_HANDLE_T always_on_handle; 
     5801+ 
     5802+/**************************************************************************** 
     5803+* 
     5804+*   vc_mem_init 
     5805+* 
     5806+***************************************************************************/ 
     5807+ 
     5808+static int __init 
     5809+vc_mem_init(void) 
     5810+{ 
     5811+       int rc = -EFAULT; 
     5812+       struct device *dev; 
     5813+ 
     5814+       LOG_DBG("%s: called", __func__); 
     5815+ 
     5816+       mm_vc_mem_phys_addr = phys_addr; 
     5817+       mm_vc_mem_size = mem_size; 
     5818+       mm_vc_mem_base = mem_base; 
     5819+ 
     5820+       vc_mem_get_size(); 
     5821+ 
     5822+       printk("vc-mem: phys_addr:0x%08lx mem_base=0x%08x mem_size:0x%08x(%u MiB)\n", 
     5823+               mm_vc_mem_phys_addr, mm_vc_mem_base, mm_vc_mem_size, mm_vc_mem_size / (1024 * 1024)); 
     5824+ 
     5825+       if ((rc = alloc_chrdev_region(&vc_mem_devnum, 0, 1, DRIVER_NAME)) < 0) { 
     5826+               LOG_ERR("%s: alloc_chrdev_region failed (rc=%d)", __func__, rc); 
     5827+               goto out_err; 
     5828+       } 
     5829+ 
     5830+       cdev_init(&vc_mem_cdev, &vc_mem_fops); 
     5831+       if ((rc = cdev_add(&vc_mem_cdev, vc_mem_devnum, 1)) != 0) { 
     5832+               LOG_ERR("%s: cdev_add failed (rc=%d)", __func__, rc); 
     5833+               goto out_unregister; 
     5834+       } 
     5835+ 
     5836+       vc_mem_class = class_create(THIS_MODULE, DRIVER_NAME); 
     5837+       if (IS_ERR(vc_mem_class)) { 
     5838+               rc = PTR_ERR(vc_mem_class); 
     5839+               LOG_ERR("%s: class_create failed (rc=%d)", __func__, rc); 
     5840+               goto out_cdev_del; 
     5841+       } 
     5842+ 
     5843+       dev = device_create(vc_mem_class, NULL, vc_mem_devnum, NULL, 
     5844+                           DRIVER_NAME); 
     5845+       if (IS_ERR(dev)) { 
     5846+               rc = PTR_ERR(dev); 
     5847+               LOG_ERR("%s: device_create failed (rc=%d)", __func__, rc); 
     5848+               goto out_class_destroy; 
     5849+       } 
     5850+ 
     5851+#if 0 
     5852+       vc_mem_proc_entry = create_proc_entry(DRIVER_NAME, 0444, NULL); 
     5853+       if (vc_mem_proc_entry == NULL) { 
     5854+               rc = -EFAULT; 
     5855+               LOG_ERR("%s: create_proc_entry failed", __func__); 
     5856+               goto out_device_destroy; 
     5857+       } 
     5858+       vc_mem_proc_entry->read_proc = vc_mem_proc_read; 
     5859+       vc_mem_proc_entry->write_proc = vc_mem_proc_write; 
    69985860+#endif 
    6999 +       int rc = 0; 
    7000 +       int i; 
    7001 + 
    7002 +       printk(KERN_INFO "bcm_power: Broadcom power driver\n"); 
    7003 +       bcm_mailbox_write(MBOX_CHAN_POWER, 0); 
    7004 + 
    7005 +       for (i = 0; i < BCM_POWER_MAXCLIENTS; i++) 
    7006 +               g_state.client_request[i] = BCM_POWER_NOCLIENT; 
    7007 + 
    7008 +       sema_init(&g_state.client_mutex, 1); 
    7009 +       sema_init(&g_state.mutex, 1); 
    7010 + 
    7011 +       g_state.global_request = 0; 
    7012 + 
    7013 +#if defined(BCM_POWER_ALWAYS_ON) 
    7014 +       if (BCM_POWER_ALWAYS_ON) { 
    7015 +               bcm_power_open(&always_on_handle); 
    7016 +               bcm_power_request(always_on_handle, BCM_POWER_ALWAYS_ON); 
     5861+ 
     5862+       vc_mem_inited = 1; 
     5863+       return 0; 
     5864+ 
     5865+      out_device_destroy: 
     5866+       device_destroy(vc_mem_class, vc_mem_devnum); 
     5867+ 
     5868+      out_class_destroy: 
     5869+       class_destroy(vc_mem_class); 
     5870+       vc_mem_class = NULL; 
     5871+ 
     5872+      out_cdev_del: 
     5873+       cdev_del(&vc_mem_cdev); 
     5874+ 
     5875+      out_unregister: 
     5876+       unregister_chrdev_region(vc_mem_devnum, 1); 
     5877+ 
     5878+      out_err: 
     5879+       return -1; 
     5880+} 
     5881+ 
     5882+/**************************************************************************** 
     5883+* 
     5884+*   vc_mem_exit 
     5885+* 
     5886+***************************************************************************/ 
     5887+ 
     5888+static void __exit 
     5889+vc_mem_exit(void) 
     5890+{ 
     5891+       LOG_DBG("%s: called", __func__); 
     5892+ 
     5893+       if (vc_mem_inited) { 
     5894+#if 0 
     5895+               remove_proc_entry(vc_mem_proc_entry->name, NULL); 
     5896+#endif 
     5897+               device_destroy(vc_mem_class, vc_mem_devnum); 
     5898+               class_destroy(vc_mem_class); 
     5899+               cdev_del(&vc_mem_cdev); 
     5900+               unregister_chrdev_region(vc_mem_devnum, 1); 
    70175901+       } 
    7018 +#endif 
    7019 + 
    7020 +       return rc; 
    7021 +} 
    7022 + 
    7023 +static void __exit bcm_power_exit(void) 
    7024 +{ 
    7025 +       bcm_mailbox_write(MBOX_CHAN_POWER, 0); 
    7026 +} 
    7027 + 
    7028 +arch_initcall(bcm_power_init); /* Initialize early */ 
    7029 +module_exit(bcm_power_exit); 
    7030 + 
    7031 +MODULE_AUTHOR("Phil Elwell"); 
    7032 +MODULE_DESCRIPTION("Interface to BCM2708 power management"); 
     5902+} 
     5903+ 
     5904+module_init(vc_mem_init); 
     5905+module_exit(vc_mem_exit); 
    70335906+MODULE_LICENSE("GPL"); 
     5907+MODULE_AUTHOR("Broadcom Corporation"); 
     5908+ 
     5909+module_param(phys_addr, uint, 0644); 
     5910+module_param(mem_size, uint, 0644); 
     5911+module_param(mem_base, uint, 0644); 
     5912+ 
    70345913--- /dev/null 
    70355914+++ b/arch/arm/mach-bcm2708/vcio.c 
     
    75096388+MODULE_LICENSE("GPL"); 
    75106389+MODULE_ALIAS("platform:bcm-mbox"); 
    7511 --- /dev/null 
    7512 +++ b/arch/arm/mach-bcm2708/vc_mem.c 
    7513 @@ -0,0 +1,462 @@ 
    7514 +/***************************************************************************** 
    7515 +* Copyright 2010 - 2011 Broadcom Corporation.  All rights reserved. 
    7516 +* 
    7517 +* Unless you and Broadcom execute a separate written software license 
    7518 +* agreement governing use of this software, this software is licensed to you 
    7519 +* under the terms of the GNU General Public License version 2, available at 
    7520 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL"). 
    7521 +* 
    7522 +* Notwithstanding the above, under no circumstances may you combine this 
    7523 +* software in any way with any other Broadcom software provided under a 
    7524 +* license other than the GPL, without Broadcom's express prior written 
    7525 +* consent. 
    7526 +*****************************************************************************/ 
    7527 + 
    7528 +#include <linux/kernel.h> 
    7529 +#include <linux/module.h> 
    7530 +#include <linux/fs.h> 
    7531 +#include <linux/device.h> 
    7532 +#include <linux/cdev.h> 
    7533 +#include <linux/mm.h> 
    7534 +#include <linux/slab.h> 
    7535 +#include <linux/proc_fs.h> 
    7536 +#include <asm/uaccess.h> 
    7537 +#include <linux/dma-mapping.h> 
    7538 + 
    7539 +#ifdef CONFIG_ARCH_KONA 
    7540 +#include <chal/chal_ipc.h> 
    7541 +#elif CONFIG_ARCH_BCM2708 
    7542 +#else 
    7543 +#include <csp/chal_ipc.h> 
    7544 +#endif 
    7545 + 
    7546 +#include "mach/vc_mem.h" 
    7547 +#include <mach/vcio.h> 
    7548 + 
    7549 +#define DRIVER_NAME  "vc-mem" 
    7550 + 
    7551 +// Uncomment to enable debug logging 
    7552 +// #define ENABLE_DBG 
    7553 + 
    7554 +#if defined(ENABLE_DBG) 
    7555 +#define LOG_DBG( fmt, ... )  printk( KERN_INFO fmt "\n", ##__VA_ARGS__ ) 
    7556 +#else 
    7557 +#define LOG_DBG( fmt, ... ) 
    7558 +#endif 
    7559 +#define LOG_ERR( fmt, ... )  printk( KERN_ERR fmt "\n", ##__VA_ARGS__ ) 
    7560 + 
    7561 +// Device (/dev) related variables 
    7562 +static dev_t vc_mem_devnum = 0; 
    7563 +static struct class *vc_mem_class = NULL; 
    7564 +static struct cdev vc_mem_cdev; 
    7565 +static int vc_mem_inited = 0; 
    7566 + 
    7567 +// Proc entry 
    7568 +static struct proc_dir_entry *vc_mem_proc_entry; 
    7569 + 
    7570 +/* 
    7571 + * Videocore memory addresses and size 
    7572 + * 
    7573 + * Drivers that wish to know the videocore memory addresses and sizes should 
    7574 + * use these variables instead of the MM_IO_BASE and MM_ADDR_IO defines in 
    7575 + * headers. This allows the other drivers to not be tied down to a a certain 
    7576 + * address/size at compile time. 
    7577 + * 
    7578 + * In the future, the goal is to have the videocore memory virtual address and 
    7579 + * size be calculated at boot time rather than at compile time. The decision of 
    7580 + * where the videocore memory resides and its size would be in the hands of the 
    7581 + * bootloader (and/or kernel). When that happens, the values of these variables 
    7582 + * would be calculated and assigned in the init function. 
    7583 + */ 
    7584 +// in the 2835 VC in mapped above ARM, but ARM has full access to VC space 
    7585 +unsigned long mm_vc_mem_phys_addr = 0x00000000; 
    7586 +unsigned int mm_vc_mem_size = 0; 
    7587 +unsigned int mm_vc_mem_base = 0; 
    7588 + 
    7589 +EXPORT_SYMBOL(mm_vc_mem_phys_addr); 
    7590 +EXPORT_SYMBOL(mm_vc_mem_size); 
    7591 +EXPORT_SYMBOL(mm_vc_mem_base); 
    7592 + 
    7593 +static uint phys_addr = 0; 
    7594 +static uint mem_size = 0; 
    7595 +static uint mem_base = 0; 
    7596 + 
    7597 + 
    7598 +/**************************************************************************** 
    7599 +* 
    7600 +*   vc_mem_open 
    7601 +* 
    7602 +***************************************************************************/ 
    7603 + 
    7604 +static int 
    7605 +vc_mem_open(struct inode *inode, struct file *file) 
    7606 +{ 
    7607 +       (void) inode; 
    7608 +       (void) file; 
    7609 + 
    7610 +       LOG_DBG("%s: called file = 0x%p", __func__, file); 
    7611 + 
    7612 +       return 0; 
    7613 +} 
    7614 + 
    7615 +/**************************************************************************** 
    7616 +* 
    7617 +*   vc_mem_release 
    7618 +* 
    7619 +***************************************************************************/ 
    7620 + 
    7621 +static int 
    7622 +vc_mem_release(struct inode *inode, struct file *file) 
    7623 +{ 
    7624 +       (void) inode; 
    7625 +       (void) file; 
    7626 + 
    7627 +       LOG_DBG("%s: called file = 0x%p", __func__, file); 
    7628 + 
    7629 +       return 0; 
    7630 +} 
    7631 + 
    7632 +/**************************************************************************** 
    7633 +* 
    7634 +*   vc_mem_get_size 
    7635 +* 
    7636 +***************************************************************************/ 
    7637 + 
    7638 +static void 
    7639 +vc_mem_get_size(void) 
    7640 +{ 
    7641 +} 
    7642 + 
    7643 +/**************************************************************************** 
    7644 +* 
    7645 +*   vc_mem_get_base 
    7646 +* 
    7647 +***************************************************************************/ 
    7648 + 
    7649 +static void 
    7650 +vc_mem_get_base(void) 
    7651 +{ 
    7652 +} 
    7653 + 
    7654 +/**************************************************************************** 
    7655 +* 
    7656 +*   vc_mem_get_current_size 
    7657 +* 
    7658 +***************************************************************************/ 
    7659 + 
    7660 +int 
    7661 +vc_mem_get_current_size(void) 
    7662 +{ 
    7663 +       return mm_vc_mem_size; 
    7664 +} 
    7665 + 
    7666 +EXPORT_SYMBOL_GPL(vc_mem_get_current_size); 
    7667 + 
    7668 +/**************************************************************************** 
    7669 +* 
    7670 +*   vc_mem_ioctl 
    7671 +* 
    7672 +***************************************************************************/ 
    7673 + 
    7674 +static long 
    7675 +vc_mem_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 
    7676 +{ 
    7677 +       int rc = 0; 
    7678 + 
    7679 +       (void) cmd; 
    7680 +       (void) arg; 
    7681 + 
    7682 +       LOG_DBG("%s: called file = 0x%p", __func__, file); 
    7683 + 
    7684 +       switch (cmd) { 
    7685 +       case VC_MEM_IOC_MEM_PHYS_ADDR: 
    7686 +               { 
    7687 +                       LOG_DBG("%s: VC_MEM_IOC_MEM_PHYS_ADDR=0x%p", 
    7688 +                               __func__, (void *) mm_vc_mem_phys_addr); 
    7689 + 
    7690 +                       if (copy_to_user((void *) arg, &mm_vc_mem_phys_addr, 
    7691 +                                        sizeof (mm_vc_mem_phys_addr)) != 0) { 
    7692 +                               rc = -EFAULT; 
    7693 +                       } 
    7694 +                       break; 
    7695 +               } 
    7696 +       case VC_MEM_IOC_MEM_SIZE: 
    7697 +               { 
    7698 +                       // Get the videocore memory size first 
    7699 +                       vc_mem_get_size(); 
    7700 + 
    7701 +                       LOG_DBG("%s: VC_MEM_IOC_MEM_SIZE=%u", __func__, 
    7702 +                               mm_vc_mem_size); 
    7703 + 
    7704 +                       if (copy_to_user((void *) arg, &mm_vc_mem_size, 
    7705 +                                        sizeof (mm_vc_mem_size)) != 0) { 
    7706 +                               rc = -EFAULT; 
    7707 +                       } 
    7708 +                       break; 
    7709 +               } 
    7710 +       case VC_MEM_IOC_MEM_BASE: 
    7711 +               { 
    7712 +                       // Get the videocore memory base 
    7713 +                       vc_mem_get_base(); 
    7714 + 
    7715 +                       LOG_DBG("%s: VC_MEM_IOC_MEM_BASE=%u", __func__, 
    7716 +                               mm_vc_mem_base); 
    7717 + 
    7718 +                       if (copy_to_user((void *) arg, &mm_vc_mem_base, 
    7719 +                                        sizeof (mm_vc_mem_base)) != 0) { 
    7720 +                               rc = -EFAULT; 
    7721 +                       } 
    7722 +                       break; 
    7723 +               } 
    7724 +       case VC_MEM_IOC_MEM_LOAD: 
    7725 +               { 
    7726 +                       // Get the videocore memory base 
    7727 +                       vc_mem_get_base(); 
    7728 + 
    7729 +                       LOG_DBG("%s: VC_MEM_IOC_MEM_LOAD=%u", __func__, 
    7730 +                               mm_vc_mem_base); 
    7731 + 
    7732 +                       if (copy_to_user((void *) arg, &mm_vc_mem_base, 
    7733 +                                        sizeof (mm_vc_mem_base)) != 0) { 
    7734 +                               rc = -EFAULT; 
    7735 +                       } 
    7736 +                       break; 
    7737 +               } 
    7738 +       default: 
    7739 +               { 
    7740 +                       return -ENOTTY; 
    7741 +               } 
    7742 +       } 
    7743 +       LOG_DBG("%s: file = 0x%p returning %d", __func__, file, rc); 
    7744 + 
    7745 +       return rc; 
    7746 +} 
    7747 + 
    7748 +/**************************************************************************** 
    7749 +* 
    7750 +*   vc_mem_mmap 
    7751 +* 
    7752 +***************************************************************************/ 
    7753 + 
    7754 +static int 
    7755 +vc_mem_mmap(struct file *filp, struct vm_area_struct *vma) 
    7756 +{ 
    7757 +       int rc = 0; 
    7758 +       unsigned long length = vma->vm_end - vma->vm_start; 
    7759 +       unsigned long offset = vma->vm_pgoff << PAGE_SHIFT; 
    7760 + 
    7761 +       LOG_DBG("%s: vm_start = 0x%08lx vm_end = 0x%08lx vm_pgoff = 0x%08lx", 
    7762 +               __func__, (long) vma->vm_start, (long) vma->vm_end, 
    7763 +               (long) vma->vm_pgoff); 
    7764 + 
    7765 +       if (offset + length > mm_vc_mem_size) { 
    7766 +               LOG_ERR("%s: length %ld is too big", __func__, length); 
    7767 +               return -EINVAL; 
    7768 +       } 
    7769 +       // Do not cache the memory map 
    7770 +       vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 
    7771 + 
    7772 +       rc = remap_pfn_range(vma, vma->vm_start, 
    7773 +                            (mm_vc_mem_phys_addr >> PAGE_SHIFT) + 
    7774 +                            vma->vm_pgoff, length, vma->vm_page_prot); 
    7775 +       if (rc != 0) { 
    7776 +               LOG_ERR("%s: remap_pfn_range failed (rc=%d)", __func__, rc); 
    7777 +       } 
    7778 + 
    7779 +       return rc; 
    7780 +} 
    7781 + 
    7782 +/**************************************************************************** 
    7783 +* 
    7784 +*   File Operations for the driver. 
    7785 +* 
    7786 +***************************************************************************/ 
    7787 + 
    7788 +static const struct file_operations vc_mem_fops = { 
    7789 +       .owner = THIS_MODULE, 
    7790 +       .open = vc_mem_open, 
    7791 +       .release = vc_mem_release, 
    7792 +       .unlocked_ioctl = vc_mem_ioctl, 
    7793 +       .mmap = vc_mem_mmap, 
    7794 +}; 
    7795 + 
    7796 +/**************************************************************************** 
    7797 +* 
    7798 +*   vc_mem_proc_read 
    7799 +* 
    7800 +***************************************************************************/ 
    7801 + 
    7802 +static int 
    7803 +vc_mem_proc_read(char *buf, char **start, off_t offset, int count, int *eof, 
    7804 +                void *data) 
    7805 +{ 
    7806 +       char *p = buf; 
    7807 + 
    7808 +       (void) start; 
    7809 +       (void) count; 
    7810 +       (void) data; 
    7811 + 
    7812 +       if (offset > 0) { 
    7813 +               *eof = 1; 
    7814 +               return 0; 
    7815 +       } 
    7816 +       // Get the videocore memory size first 
    7817 +       vc_mem_get_size(); 
    7818 + 
    7819 +       p += sprintf(p, "Videocore memory:\n"); 
    7820 +       if (mm_vc_mem_phys_addr != 0) 
    7821 +               p += sprintf(p, "   Physical address: 0x%p\n", 
    7822 +                            (void *) mm_vc_mem_phys_addr); 
    7823 +       else 
    7824 +               p += sprintf(p, "   Physical address: 0x00000000\n"); 
    7825 +       p += sprintf(p, "   Length (bytes):   %u\n", mm_vc_mem_size); 
    7826 + 
    7827 +       *eof = 1; 
    7828 +       return p - buf; 
    7829 +} 
    7830 + 
    7831 +/**************************************************************************** 
    7832 +* 
    7833 +*   vc_mem_proc_write 
    7834 +* 
    7835 +***************************************************************************/ 
    7836 + 
    7837 +static int 
    7838 +vc_mem_proc_write(struct file *file, const char __user * buffer, 
    7839 +                 unsigned long count, void *data) 
    7840 +{ 
    7841 +       int rc = -EFAULT; 
    7842 +       char input_str[10]; 
    7843 + 
    7844 +       memset(input_str, 0, sizeof (input_str)); 
    7845 + 
    7846 +       if (count > sizeof (input_str)) { 
    7847 +               LOG_ERR("%s: input string length too long", __func__); 
    7848 +               goto out; 
    7849 +       } 
    7850 + 
    7851 +       if (copy_from_user(input_str, buffer, count - 1)) { 
    7852 +               LOG_ERR("%s: failed to get input string", __func__); 
    7853 +               goto out; 
    7854 +       } 
    7855 + 
    7856 +       if (strncmp(input_str, "connect", strlen("connect")) == 0) { 
    7857 +               // Get the videocore memory size from the videocore 
    7858 +               vc_mem_get_size(); 
    7859 +       } 
    7860 + 
    7861 +      out: 
    7862 +       return rc; 
    7863 +} 
    7864 + 
    7865 +/**************************************************************************** 
    7866 +* 
    7867 +*   vc_mem_init 
    7868 +* 
    7869 +***************************************************************************/ 
    7870 + 
    7871 +static int __init 
    7872 +vc_mem_init(void) 
    7873 +{ 
    7874 +       int rc = -EFAULT; 
    7875 +       struct device *dev; 
    7876 + 
    7877 +       LOG_DBG("%s: called", __func__); 
    7878 + 
    7879 +       mm_vc_mem_phys_addr = phys_addr; 
    7880 +       mm_vc_mem_size = mem_size; 
    7881 +       mm_vc_mem_base = mem_base; 
    7882 + 
    7883 +       vc_mem_get_size(); 
    7884 + 
    7885 +       printk("vc-mem: phys_addr:0x%08lx mem_base=0x%08x mem_size:0x%08x(%u MiB)\n", 
    7886 +               mm_vc_mem_phys_addr, mm_vc_mem_base, mm_vc_mem_size, mm_vc_mem_size / (1024 * 1024)); 
    7887 + 
    7888 +       if ((rc = alloc_chrdev_region(&vc_mem_devnum, 0, 1, DRIVER_NAME)) < 0) { 
    7889 +               LOG_ERR("%s: alloc_chrdev_region failed (rc=%d)", __func__, rc); 
    7890 +               goto out_err; 
    7891 +       } 
    7892 + 
    7893 +       cdev_init(&vc_mem_cdev, &vc_mem_fops); 
    7894 +       if ((rc = cdev_add(&vc_mem_cdev, vc_mem_devnum, 1)) != 0) { 
    7895 +               LOG_ERR("%s: cdev_add failed (rc=%d)", __func__, rc); 
    7896 +               goto out_unregister; 
    7897 +       } 
    7898 + 
    7899 +       vc_mem_class = class_create(THIS_MODULE, DRIVER_NAME); 
    7900 +       if (IS_ERR(vc_mem_class)) { 
    7901 +               rc = PTR_ERR(vc_mem_class); 
    7902 +               LOG_ERR("%s: class_create failed (rc=%d)", __func__, rc); 
    7903 +               goto out_cdev_del; 
    7904 +       } 
    7905 + 
    7906 +       dev = device_create(vc_mem_class, NULL, vc_mem_devnum, NULL, 
    7907 +                           DRIVER_NAME); 
    7908 +       if (IS_ERR(dev)) { 
    7909 +               rc = PTR_ERR(dev); 
    7910 +               LOG_ERR("%s: device_create failed (rc=%d)", __func__, rc); 
    7911 +               goto out_class_destroy; 
    7912 +       } 
    7913 + 
    7914 +#if 0 
    7915 +       vc_mem_proc_entry = create_proc_entry(DRIVER_NAME, 0444, NULL); 
    7916 +       if (vc_mem_proc_entry == NULL) { 
    7917 +               rc = -EFAULT; 
    7918 +               LOG_ERR("%s: create_proc_entry failed", __func__); 
    7919 +               goto out_device_destroy; 
    7920 +       } 
    7921 +       vc_mem_proc_entry->read_proc = vc_mem_proc_read; 
    7922 +       vc_mem_proc_entry->write_proc = vc_mem_proc_write; 
    7923 +#endif 
    7924 + 
    7925 +       vc_mem_inited = 1; 
    7926 +       return 0; 
    7927 + 
    7928 +      out_device_destroy: 
    7929 +       device_destroy(vc_mem_class, vc_mem_devnum); 
    7930 + 
    7931 +      out_class_destroy: 
    7932 +       class_destroy(vc_mem_class); 
    7933 +       vc_mem_class = NULL; 
    7934 + 
    7935 +      out_cdev_del: 
    7936 +       cdev_del(&vc_mem_cdev); 
    7937 + 
    7938 +      out_unregister: 
    7939 +       unregister_chrdev_region(vc_mem_devnum, 1); 
    7940 + 
    7941 +      out_err: 
    7942 +       return -1; 
    7943 +} 
    7944 + 
    7945 +/**************************************************************************** 
    7946 +* 
    7947 +*   vc_mem_exit 
    7948 +* 
    7949 +***************************************************************************/ 
    7950 + 
    7951 +static void __exit 
    7952 +vc_mem_exit(void) 
    7953 +{ 
    7954 +       LOG_DBG("%s: called", __func__); 
    7955 + 
    7956 +       if (vc_mem_inited) { 
    7957 +#if 0 
    7958 +               remove_proc_entry(vc_mem_proc_entry->name, NULL); 
    7959 +#endif 
    7960 +               device_destroy(vc_mem_class, vc_mem_devnum); 
    7961 +               class_destroy(vc_mem_class); 
    7962 +               cdev_del(&vc_mem_cdev); 
    7963 +               unregister_chrdev_region(vc_mem_devnum, 1); 
    7964 +       } 
    7965 +} 
    7966 + 
    7967 +module_init(vc_mem_init); 
    7968 +module_exit(vc_mem_exit); 
    7969 +MODULE_LICENSE("GPL"); 
    7970 +MODULE_AUTHOR("Broadcom Corporation"); 
    7971 + 
    7972 +module_param(phys_addr, uint, 0644); 
    7973 +module_param(mem_size, uint, 0644); 
    7974 +module_param(mem_base, uint, 0644); 
    7975 + 
    7976 --- /dev/null 
    7977 +++ b/arch/arm/mach-bcm2708/vc_support.c 
    7978 @@ -0,0 +1,319 @@ 
    7979 +/* 
    7980 + * vc_support.c 
    7981 + * 
    7982 + *  Created on: 25 Nov 2012 
    7983 + *      Author: Simon 
    7984 + */ 
    7985 + 
    7986 +#include <linux/module.h> 
    7987 +#include <mach/vcio.h> 
    7988 + 
    7989 +#ifdef ECLIPSE_IGNORE 
    7990 + 
    7991 +#define __user 
    7992 +#define __init 
    7993 +#define __exit 
    7994 +#define __iomem 
    7995 +#define KERN_DEBUG 
    7996 +#define KERN_ERR 
    7997 +#define KERN_WARNING 
    7998 +#define KERN_INFO 
    7999 +#define _IOWR(a, b, c) b 
    8000 +#define _IOW(a, b, c) b 
    8001 +#define _IO(a, b) b 
    8002 + 
    8003 +#endif 
    8004 + 
    8005 +/****** VC MAILBOX FUNCTIONALITY ******/ 
    8006 +unsigned int AllocateVcMemory(unsigned int *pHandle, unsigned int size, unsigned int alignment, unsigned int flags) 
    8007 +{ 
    8008 +       struct vc_msg 
    8009 +       { 
    8010 +               unsigned int m_msgSize; 
    8011 +               unsigned int m_response; 
    8012 + 
    8013 +               struct vc_tag 
    8014 +               { 
    8015 +                       unsigned int m_tagId; 
    8016 +                       unsigned int m_sendBufferSize; 
    8017 +                       union { 
    8018 +                               unsigned int m_sendDataSize; 
    8019 +                               unsigned int m_recvDataSize; 
    8020 +                       }; 
    8021 + 
    8022 +                       struct args 
    8023 +                       { 
    8024 +                               union { 
    8025 +                                       unsigned int m_size; 
    8026 +                                       unsigned int m_handle; 
    8027 +                               }; 
    8028 +                               unsigned int m_alignment; 
    8029 +                               unsigned int m_flags; 
    8030 +                       } m_args; 
    8031 +               } m_tag; 
    8032 + 
    8033 +               unsigned int m_endTag; 
    8034 +       } msg; 
    8035 +       int s; 
    8036 + 
    8037 +       msg.m_msgSize = sizeof(msg); 
    8038 +       msg.m_response = 0; 
    8039 +       msg.m_endTag = 0; 
    8040 + 
    8041 +       //fill in the tag for the allocation command 
    8042 +       msg.m_tag.m_tagId = 0x3000c; 
    8043 +       msg.m_tag.m_sendBufferSize = 12; 
    8044 +       msg.m_tag.m_sendDataSize = 12; 
    8045 + 
    8046 +       //fill in our args 
    8047 +       msg.m_tag.m_args.m_size = size; 
    8048 +       msg.m_tag.m_args.m_alignment = alignment; 
    8049 +       msg.m_tag.m_args.m_flags = flags; 
    8050 + 
    8051 +       //run the command 
    8052 +       s = bcm_mailbox_property(&msg, sizeof(msg)); 
    8053 + 
    8054 +       if (s == 0 && msg.m_response == 0x80000000 && msg.m_tag.m_recvDataSize == 0x80000004) 
    8055 +       { 
    8056 +               *pHandle = msg.m_tag.m_args.m_handle; 
    8057 +               return 0; 
    8058 +       } 
    8059 +       else 
    8060 +       { 
    8061 +               printk(KERN_ERR "failed to allocate vc memory: s=%d response=%08x recv data size=%08x\n", 
    8062 +                               s, msg.m_response, msg.m_tag.m_recvDataSize); 
    8063 +               return 1; 
    8064 +       } 
    8065 +} 
    8066 + 
    8067 +unsigned int ReleaseVcMemory(unsigned int handle) 
    8068 +{ 
    8069 +       struct vc_msg 
    8070 +       { 
    8071 +               unsigned int m_msgSize; 
    8072 +               unsigned int m_response; 
    8073 + 
    8074 +               struct vc_tag 
    8075 +               { 
    8076 +                       unsigned int m_tagId; 
    8077 +                       unsigned int m_sendBufferSize; 
    8078 +                       union { 
    8079 +                               unsigned int m_sendDataSize; 
    8080 +                               unsigned int m_recvDataSize; 
    8081 +                       }; 
    8082 + 
    8083 +                       struct args 
    8084 +                       { 
    8085 +                               union { 
    8086 +                                       unsigned int m_handle; 
    8087 +                                       unsigned int m_error; 
    8088 +                               }; 
    8089 +                       } m_args; 
    8090 +               } m_tag; 
    8091 + 
    8092 +               unsigned int m_endTag; 
    8093 +       } msg; 
    8094 +       int s; 
    8095 + 
    8096 +       msg.m_msgSize = sizeof(msg); 
    8097 +       msg.m_response = 0; 
    8098 +       msg.m_endTag = 0; 
    8099 + 
    8100 +       //fill in the tag for the release command 
    8101 +       msg.m_tag.m_tagId = 0x3000f; 
    8102 +       msg.m_tag.m_sendBufferSize = 4; 
    8103 +       msg.m_tag.m_sendDataSize = 4; 
    8104 + 
    8105 +       //pass across the handle 
    8106 +       msg.m_tag.m_args.m_handle = handle; 
    8107 + 
    8108 +       s = bcm_mailbox_property(&msg, sizeof(msg)); 
    8109 + 
    8110 +       if (s == 0 && msg.m_response == 0x80000000 && msg.m_tag.m_recvDataSize == 0x80000004 && msg.m_tag.m_args.m_error == 0) 
    8111 +               return 0; 
    8112 +       else 
    8113 +       { 
    8114 +               printk(KERN_ERR "failed to release vc memory: s=%d response=%08x recv data size=%08x error=%08x\n", 
    8115 +                               s, msg.m_response, msg.m_tag.m_recvDataSize, msg.m_tag.m_args.m_error); 
    8116 +               return 1; 
    8117 +       } 
    8118 +} 
    8119 + 
    8120 +unsigned int LockVcMemory(unsigned int *pBusAddress, unsigned int handle) 
    8121 +{ 
    8122 +       struct vc_msg 
    8123 +       { 
    8124 +               unsigned int m_msgSize; 
    8125 +               unsigned int m_response; 
    8126 + 
    8127 +               struct vc_tag 
    8128 +               { 
    8129 +                       unsigned int m_tagId; 
    8130 +                       unsigned int m_sendBufferSize; 
    8131 +                       union { 
    8132 +                               unsigned int m_sendDataSize; 
    8133 +                               unsigned int m_recvDataSize; 
    8134 +                       }; 
    8135 + 
    8136 +                       struct args 
    8137 +                       { 
    8138 +                               union { 
    8139 +                                       unsigned int m_handle; 
    8140 +                                       unsigned int m_busAddress; 
    8141 +                               }; 
    8142 +                       } m_args; 
    8143 +               } m_tag; 
    8144 + 
    8145 +               unsigned int m_endTag; 
    8146 +       } msg; 
    8147 +       int s; 
    8148 + 
    8149 +       msg.m_msgSize = sizeof(msg); 
    8150 +       msg.m_response = 0; 
    8151 +       msg.m_endTag = 0; 
    8152 + 
    8153 +       //fill in the tag for the lock command 
    8154 +       msg.m_tag.m_tagId = 0x3000d; 
    8155 +       msg.m_tag.m_sendBufferSize = 4; 
    8156 +       msg.m_tag.m_sendDataSize = 4; 
    8157 + 
    8158 +       //pass across the handle 
    8159 +       msg.m_tag.m_args.m_handle = handle; 
    8160 + 
    8161 +       s = bcm_mailbox_property(&msg, sizeof(msg)); 
    8162 + 
    8163 +       if (s == 0 && msg.m_response == 0x80000000 && msg.m_tag.m_recvDataSize == 0x80000004) 
    8164 +       { 
    8165 +               //pick out the bus address 
    8166 +               *pBusAddress = msg.m_tag.m_args.m_busAddress; 
    8167 +               return 0; 
    8168 +       } 
    8169 +       else 
    8170 +       { 
    8171 +               printk(KERN_ERR "failed to lock vc memory: s=%d response=%08x recv data size=%08x\n", 
    8172 +                               s, msg.m_response, msg.m_tag.m_recvDataSize); 
    8173 +               return 1; 
    8174 +       } 
    8175 +} 
    8176 + 
    8177 +unsigned int UnlockVcMemory(unsigned int handle) 
    8178 +{ 
    8179 +       struct vc_msg 
    8180 +       { 
    8181 +               unsigned int m_msgSize; 
    8182 +               unsigned int m_response; 
    8183 + 
    8184 +               struct vc_tag 
    8185 +               { 
    8186 +                       unsigned int m_tagId; 
    8187 +                       unsigned int m_sendBufferSize; 
    8188 +                       union { 
    8189 +                               unsigned int m_sendDataSize; 
    8190 +                               unsigned int m_recvDataSize; 
    8191 +                       }; 
    8192 + 
    8193 +                       struct args 
    8194 +                       { 
    8195 +                               union { 
    8196 +                                       unsigned int m_handle; 
    8197 +                                       unsigned int m_error; 
    8198 +                               }; 
    8199 +                       } m_args; 
    8200 +               } m_tag; 
    8201 + 
    8202 +               unsigned int m_endTag; 
    8203 +       } msg; 
    8204 +       int s; 
    8205 + 
    8206 +       msg.m_msgSize = sizeof(msg); 
    8207 +       msg.m_response = 0; 
    8208 +       msg.m_endTag = 0; 
    8209 + 
    8210 +       //fill in the tag for the unlock command 
    8211 +       msg.m_tag.m_tagId = 0x3000e; 
    8212 +       msg.m_tag.m_sendBufferSize = 4; 
    8213 +       msg.m_tag.m_sendDataSize = 4; 
    8214 + 
    8215 +       //pass across the handle 
    8216 +       msg.m_tag.m_args.m_handle = handle; 
    8217 + 
    8218 +       s = bcm_mailbox_property(&msg, sizeof(msg)); 
    8219 + 
    8220 +       //check the error code too 
    8221 +       if (s == 0 && msg.m_response == 0x80000000 && msg.m_tag.m_recvDataSize == 0x80000004 && msg.m_tag.m_args.m_error == 0) 
    8222 +               return 0; 
    8223 +       else 
    8224 +       { 
    8225 +               printk(KERN_ERR "failed to unlock vc memory: s=%d response=%08x recv data size=%08x error%08x\n", 
    8226 +                               s, msg.m_response, msg.m_tag.m_recvDataSize, msg.m_tag.m_args.m_error); 
    8227 +               return 1; 
    8228 +       } 
    8229 +} 
    8230 + 
    8231 +unsigned int ExecuteVcCode(unsigned int code, 
    8232 +               unsigned int r0, unsigned int r1, unsigned int r2, unsigned int r3, unsigned int r4, unsigned int r5) 
    8233 +{ 
    8234 +       struct vc_msg 
    8235 +       { 
    8236 +               unsigned int m_msgSize; 
    8237 +               unsigned int m_response; 
    8238 + 
    8239 +               struct vc_tag 
    8240 +               { 
    8241 +                       unsigned int m_tagId; 
    8242 +                       unsigned int m_sendBufferSize; 
    8243 +                       union { 
    8244 +                               unsigned int m_sendDataSize; 
    8245 +                               unsigned int m_recvDataSize; 
    8246 +                       }; 
    8247 + 
    8248 +                       struct args 
    8249 +                       { 
    8250 +                               union { 
    8251 +                                       unsigned int m_pCode; 
    8252 +                                       unsigned int m_return; 
    8253 +                               }; 
    8254 +                               unsigned int m_r0; 
    8255 +                               unsigned int m_r1; 
    8256 +                               unsigned int m_r2; 
    8257 +                               unsigned int m_r3; 
    8258 +                               unsigned int m_r4; 
    8259 +                               unsigned int m_r5; 
    8260 +                       } m_args; 
    8261 +               } m_tag; 
    8262 + 
    8263 +               unsigned int m_endTag; 
    8264 +       } msg; 
    8265 +       int s; 
    8266 + 
    8267 +       msg.m_msgSize = sizeof(msg); 
    8268 +       msg.m_response = 0; 
    8269 +       msg.m_endTag = 0; 
    8270 + 
    8271 +       //fill in the tag for the unlock command 
    8272 +       msg.m_tag.m_tagId = 0x30010; 
    8273 +       msg.m_tag.m_sendBufferSize = 28; 
    8274 +       msg.m_tag.m_sendDataSize = 28; 
    8275 + 
    8276 +       //pass across the handle 
    8277 +       msg.m_tag.m_args.m_pCode = code; 
    8278 +       msg.m_tag.m_args.m_r0 = r0; 
    8279 +       msg.m_tag.m_args.m_r1 = r1; 
    8280 +       msg.m_tag.m_args.m_r2 = r2; 
    8281 +       msg.m_tag.m_args.m_r3 = r3; 
    8282 +       msg.m_tag.m_args.m_r4 = r4; 
    8283 +       msg.m_tag.m_args.m_r5 = r5; 
    8284 + 
    8285 +       s = bcm_mailbox_property(&msg, sizeof(msg)); 
    8286 + 
    8287 +       //check the error code too 
    8288 +       if (s == 0 && msg.m_response == 0x80000000 && msg.m_tag.m_recvDataSize == 0x80000004) 
    8289 +               return msg.m_tag.m_args.m_return; 
    8290 +       else 
    8291 +       { 
    8292 +               printk(KERN_ERR "failed to execute: s=%d response=%08x recv data size=%08x\n", 
    8293 +                               s, msg.m_response, msg.m_tag.m_recvDataSize); 
    8294 +               return 1; 
    8295 +       } 
    8296 +} 
    8297 + 
    8298 --- a/arch/arm/Makefile 
    8299 +++ b/arch/arm/Makefile 
    8300 @@ -144,6 +144,7 @@ textofs-$(CONFIG_ARCH_MSM8960) := 0x0020 
    8301  # by CONFIG_* macro name. 
    8302  machine-$(CONFIG_ARCH_AT91)            += at91 
    8303  machine-$(CONFIG_ARCH_BCM)             += bcm 
    8304 +machine-$(CONFIG_ARCH_BCM2708)         += bcm2708 
    8305  machine-$(CONFIG_ARCH_BCM2835)         += bcm2835 
    8306  machine-$(CONFIG_ARCH_CLPS711X)                += clps711x 
    8307  machine-$(CONFIG_ARCH_CNS3XXX)         += cns3xxx 
    83086390--- a/arch/arm/mm/Kconfig 
    83096391+++ b/arch/arm/mm/Kconfig 
     
    83526434 ics_if_voip            MACH_ICS_IF_VOIP        ICS_IF_VOIP             3206 
    83536435 wlf_cragg_6410         MACH_WLF_CRAGG_6410     WLF_CRAGG_6410          3207 
     6436--- a/drivers/mmc/host/Kconfig 
     6437+++ b/drivers/mmc/host/Kconfig 
     6438@@ -249,6 +249,27 @@ config MMC_SDHCI_S3C_DMA 
     6439  
     6440          YMMV. 
     6441  
     6442+config MMC_SDHCI_BCM2708 
     6443+       tristate "SDHCI support on BCM2708" 
     6444+       depends on MMC_SDHCI && MACH_BCM2708 
     6445+       select MMC_SDHCI_IO_ACCESSORS 
     6446+       help 
     6447+         This selects the Secure Digital Host Controller Interface (SDHCI) 
     6448+         often referrered to as the eMMC block. 
     6449+ 
     6450+         If you have a controller with this interface, say Y or M here. 
     6451+ 
     6452+         If unsure, say N. 
     6453+ 
     6454+config MMC_SDHCI_BCM2708_DMA 
     6455+       bool "DMA support on BCM2708 Arasan controller" 
     6456+       depends on MMC_SDHCI_BCM2708 
     6457+       help 
     6458+       Enable DMA support on the Arasan SDHCI controller in Broadcom 2708 
     6459+         based chips. 
     6460+ 
     6461+         If unsure, say N. 
     6462+ 
     6463 config MMC_SDHCI_BCM2835 
     6464        tristate "SDHCI platform support for the BCM2835 SD/MMC Controller" 
     6465        depends on ARCH_BCM2835 
     6466--- a/drivers/mmc/host/Makefile 
     6467+++ b/drivers/mmc/host/Makefile 
     6468@@ -15,6 +15,7 @@ obj-$(CONFIG_MMC_SDHCI_PXAV2) += sdhci-p 
     6469 obj-$(CONFIG_MMC_SDHCI_S3C)    += sdhci-s3c.o 
     6470 obj-$(CONFIG_MMC_SDHCI_SIRF)           += sdhci-sirf.o 
     6471 obj-$(CONFIG_MMC_SDHCI_SPEAR)  += sdhci-spear.o 
     6472+obj-$(CONFIG_MMC_SDHCI_BCM2708)        += sdhci-bcm2708.o 
     6473 obj-$(CONFIG_MMC_WBSD)         += wbsd.o 
     6474 obj-$(CONFIG_MMC_AU1X)         += au1xmmc.o 
     6475 obj-$(CONFIG_MMC_OMAP)         += omap.o 
     6476--- /dev/null 
     6477+++ b/drivers/mmc/host/sdhci-bcm2708.c 
     6478@@ -0,0 +1,1425 @@ 
     6479+/* 
     6480+ * sdhci-bcm2708.c Support for SDHCI device on BCM2708 
     6481+ * Copyright (c) 2010 Broadcom 
     6482+ * 
     6483+ * This program is free software; you can redistribute it and/or modify 
     6484+ * it under the terms of the GNU General Public License version 2 as 
     6485+ * published by the Free Software Foundation. 
     6486+ * 
     6487+ * This program is distributed in the hope that it will be useful, 
     6488+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
     6489+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.         See the 
     6490+ * GNU General Public License for more details. 
     6491+ * 
     6492+ * You should have received a copy of the GNU General Public License 
     6493+ * along with this program; if not, write to the Free Software 
     6494+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
     6495+ */ 
     6496+ 
     6497+/* Supports: 
     6498+ * SDHCI platform device - Arasan SD controller in BCM2708 
     6499+ * 
     6500+ * Inspired by sdhci-pci.c, by Pierre Ossman 
     6501+ */ 
     6502+ 
     6503+#include <linux/delay.h> 
     6504+#include <linux/highmem.h> 
     6505+#include <linux/platform_device.h> 
     6506+#include <linux/module.h> 
     6507+#include <linux/mmc/mmc.h> 
     6508+#include <linux/mmc/host.h> 
     6509+#include <linux/mmc/sd.h> 
     6510+ 
     6511+#include <linux/io.h> 
     6512+#include <linux/dma-mapping.h> 
     6513+#include <mach/dma.h> 
     6514+ 
     6515+#include "sdhci.h" 
     6516+ 
     6517+/*****************************************************************************\ 
     6518+ *                                                                          * 
     6519+ * Configuration                                                            * 
     6520+ *                                                                          * 
     6521+\*****************************************************************************/ 
     6522+ 
     6523+#define DRIVER_NAME "bcm2708_sdhci" 
     6524+ 
     6525+/* for the time being insist on DMA mode - PIO seems not to work */ 
     6526+#ifndef CONFIG_MMC_SDHCI_BCM2708_DMA 
     6527+#warning Non-DMA (PIO) version of this driver currently unavailable 
     6528+#endif 
     6529+#undef CONFIG_MMC_SDHCI_BCM2708_DMA 
     6530+#define CONFIG_MMC_SDHCI_BCM2708_DMA y 
     6531+ 
     6532+#define USE_SYNC_AFTER_DMA 
     6533+#ifdef CONFIG_MMC_SDHCI_BCM2708_DMA 
     6534+/* #define CHECK_DMA_USE */ 
     6535+#endif 
     6536+//#define LOG_REGISTERS 
     6537+ 
     6538+#define USE_SCHED_TIME 
     6539+#define USE_SPACED_WRITES_2CLK 1  /* space consecutive register writes */ 
     6540+#define USE_SOFTWARE_TIMEOUTS 1   /* not hardware timeouts */ 
     6541+#define SOFTWARE_ERASE_TIMEOUT_SEC 30 
     6542+ 
     6543+#define SDHCI_BCM_DMA_CHAN 4   /* this default is normally overriden */ 
     6544+#define SDHCI_BCM_DMA_WAITS 0  /* delays slowing DMA transfers: 0-31 */ 
     6545+/* We are worried that SD card DMA use may be blocking the AXI bus for others */ 
     6546+ 
     6547+/*! TODO: obtain these from the physical address */ 
     6548+#define DMA_SDHCI_BASE  0x7e300000  /* EMMC register block on Videocore */ 
     6549+#define DMA_SDHCI_BUFFER (DMA_SDHCI_BASE + SDHCI_BUFFER) 
     6550+ 
     6551+#define BCM2708_SDHCI_SLEEP_TIMEOUT 1000   /* msecs */ 
     6552+ 
     6553+/* Mhz clock that the EMMC core is running at. Should match the platform clockman settings */ 
     6554+#define BCM2708_EMMC_CLOCK_FREQ 80000000 
     6555+ 
     6556+/*****************************************************************************\ 
     6557+ *                                                                          * 
     6558+ * Debug                                                                    * 
     6559+ *                                                                          * 
     6560+\*****************************************************************************/ 
     6561+ 
     6562+ 
     6563+ 
     6564+#define DBG(f, x...) \ 
     6565+       pr_debug(DRIVER_NAME " [%s()]: " f, __func__,## x) 
     6566+//     printk(KERN_INFO DRIVER_NAME " [%s()]: " f, __func__,## x)//GRAYG 
     6567+ 
     6568+ 
     6569+/*****************************************************************************\ 
     6570+ *                                                                          * 
     6571+ * High Precision Time                                                      * 
     6572+ *                                                                          * 
     6573+\*****************************************************************************/ 
     6574+ 
     6575+#ifdef USE_SCHED_TIME 
     6576+ 
     6577+#include <mach/frc.h> 
     6578+ 
     6579+typedef unsigned long hptime_t; 
     6580+ 
     6581+#define FMT_HPT "lu" 
     6582+ 
     6583+static inline hptime_t hptime(void) 
     6584+{ 
     6585+       return frc_clock_ticks32(); 
     6586+} 
     6587+ 
     6588+#define HPTIME_CLK_NS 1000ul 
     6589+ 
     6590+#else 
     6591+ 
     6592+typedef unsigned long hptime_t; 
     6593+ 
     6594+#define FMT_HPT "lu" 
     6595+ 
     6596+static inline hptime_t hptime(void) 
     6597+{ 
     6598+       return jiffies; 
     6599+} 
     6600+ 
     6601+#define HPTIME_CLK_NS (1000000000ul/HZ) 
     6602+ 
     6603+#endif 
     6604+ 
     6605+static inline unsigned long int since_ns(hptime_t t) 
     6606+{ 
     6607+       return (unsigned long)((hptime() - t) * HPTIME_CLK_NS); 
     6608+} 
     6609+ 
     6610+#if 0 
     6611+static void hptime_test(void) 
     6612+{ 
     6613+       hptime_t now; 
     6614+       hptime_t later; 
     6615+ 
     6616+       now = hptime(); 
     6617+       msleep(10); 
     6618+       later = hptime(); 
     6619+ 
     6620+       printk(KERN_INFO DRIVER_NAME": 10ms = %"FMT_HPT" clks " 
     6621+              "(from %"FMT_HPT" to %"FMT_HPT") = %luns\n", 
     6622+              later-now, now, later, 
     6623+              (unsigned long)(HPTIME_CLK_NS * (later - now))); 
     6624+ 
     6625+       now = hptime(); 
     6626+       msleep(1000); 
     6627+       later = hptime(); 
     6628+ 
     6629+       printk(KERN_INFO DRIVER_NAME": 1s = %"FMT_HPT" clks " 
     6630+              "(from %"FMT_HPT" to %"FMT_HPT") = %luns\n", 
     6631+              later-now, now, later, 
     6632+              (unsigned long)(HPTIME_CLK_NS * (later - now))); 
     6633+} 
     6634+#endif 
     6635+ 
     6636+/*****************************************************************************\ 
     6637+ *                                                                          * 
     6638+ * SDHCI core callbacks                                                             * 
     6639+ *                                                                          * 
     6640+\*****************************************************************************/ 
     6641+ 
     6642+ 
     6643+#ifdef CHECK_DMA_USE 
     6644+/*#define CHECK_DMA_REG_USE*/ 
     6645+#endif 
     6646+ 
     6647+#ifdef CHECK_DMA_REG_USE 
     6648+/* we don't expect anything to be using these registers during a 
     6649+   DMA (except the IRQ status) - so check */ 
     6650+static void check_dma_reg_use(struct sdhci_host *host, int reg); 
     6651+#else 
     6652+#define check_dma_reg_use(host, reg) 
     6653+#endif 
     6654+ 
     6655+ 
     6656+static inline u32 sdhci_bcm2708_raw_readl(struct sdhci_host *host, int reg) 
     6657+{ 
     6658+       return readl(host->ioaddr + reg); 
     6659+} 
     6660+ 
     6661+u32 sdhci_bcm2708_readl(struct sdhci_host *host, int reg) 
     6662+{ 
     6663+       u32 l = sdhci_bcm2708_raw_readl(host, reg); 
     6664+ 
     6665+#ifdef LOG_REGISTERS 
     6666+       printk(KERN_ERR "%s: readl from 0x%02x, value 0x%08x\n", 
     6667+              mmc_hostname(host->mmc), reg, l); 
     6668+#endif 
     6669+       check_dma_reg_use(host, reg); 
     6670+ 
     6671+       return l; 
     6672+} 
     6673+ 
     6674+u16 sdhci_bcm2708_readw(struct sdhci_host *host, int reg) 
     6675+{ 
     6676+       u32 l = sdhci_bcm2708_raw_readl(host, reg & ~3); 
     6677+       u32 w = l >> (reg << 3 & 0x18) & 0xffff; 
     6678+ 
     6679+#ifdef LOG_REGISTERS 
     6680+       printk(KERN_ERR "%s: readw from 0x%02x, value 0x%04x\n", 
     6681+              mmc_hostname(host->mmc), reg, w); 
     6682+#endif 
     6683+       check_dma_reg_use(host, reg); 
     6684+ 
     6685+       return (u16)w; 
     6686+} 
     6687+ 
     6688+u8 sdhci_bcm2708_readb(struct sdhci_host *host, int reg) 
     6689+{ 
     6690+       u32 l = sdhci_bcm2708_raw_readl(host, reg & ~3); 
     6691+       u32 b = l >> (reg << 3 & 0x18) & 0xff; 
     6692+ 
     6693+#ifdef LOG_REGISTERS 
     6694+       printk(KERN_ERR "%s: readb from 0x%02x, value 0x%02x\n", 
     6695+              mmc_hostname(host->mmc), reg, b); 
     6696+#endif 
     6697+       check_dma_reg_use(host, reg); 
     6698+ 
     6699+       return (u8)b; 
     6700+} 
     6701+ 
     6702+ 
     6703+static void sdhci_bcm2708_raw_writel(struct sdhci_host *host, u32 val, int reg) 
     6704+{ 
     6705+       u32 ier; 
     6706+ 
     6707+#if USE_SPACED_WRITES_2CLK 
     6708+       static bool timeout_disabled = false; 
     6709+       unsigned int ns_2clk = 0; 
     6710+         
     6711+       /* The Arasan has a bugette whereby it may lose the content of 
     6712+        * successive writes to registers that are within two SD-card clock 
     6713+        * cycles of each other (a clock domain crossing problem). 
     6714+        * It seems, however, that the data register does not have this problem. 
     6715+        * (Which is just as well - otherwise we'd have to nobble the DMA engine 
     6716+        * too) 
     6717+        */ 
     6718+       if (reg != SDHCI_BUFFER && host->clock != 0) { 
     6719+               /* host->clock is the clock freq in Hz */ 
     6720+               static hptime_t last_write_hpt; 
     6721+               hptime_t now = hptime(); 
     6722+               ns_2clk = 2000000000/host->clock; 
     6723+ 
     6724+               if (now == last_write_hpt || now == last_write_hpt+1) { 
     6725+                        /* we can't guarantee any significant time has 
     6726+                         * passed - we'll have to wait anyway ! */ 
     6727+                       udelay((ns_2clk+1000-1)/1000); 
     6728+               } else 
     6729+               { 
     6730+                       /* we must have waited at least this many ns: */ 
     6731+                       unsigned int ns_wait = HPTIME_CLK_NS * 
     6732+                                              (last_write_hpt - now - 1); 
     6733+                       if (ns_wait < ns_2clk) 
     6734+                               udelay((ns_2clk-ns_wait+500)/1000); 
     6735+               } 
     6736+               last_write_hpt = now; 
     6737+       } 
     6738+#if USE_SOFTWARE_TIMEOUTS 
     6739+       /* The Arasan is clocked for timeouts using the SD clock which is too 
     6740+        * fast for ERASE commands and causes issues. So we disable timeouts 
     6741+        * for ERASE */ 
     6742+       if (host->cmd != NULL && host->cmd->opcode == MMC_ERASE && 
     6743+            reg == (SDHCI_COMMAND & ~3)) { 
     6744+               mod_timer(&host->timer, 
     6745+                          jiffies + SOFTWARE_ERASE_TIMEOUT_SEC * HZ); 
     6746+               ier = readl(host->ioaddr + SDHCI_SIGNAL_ENABLE); 
     6747+               ier &= ~SDHCI_INT_DATA_TIMEOUT; 
     6748+               writel(ier, host->ioaddr + SDHCI_SIGNAL_ENABLE); 
     6749+               timeout_disabled = true; 
     6750+               udelay((ns_2clk+1000-1)/1000); 
     6751+       } else if (timeout_disabled) { 
     6752+               ier = readl(host->ioaddr + SDHCI_SIGNAL_ENABLE); 
     6753+               ier |= SDHCI_INT_DATA_TIMEOUT; 
     6754+               writel(ier, host->ioaddr + SDHCI_SIGNAL_ENABLE); 
     6755+               timeout_disabled = false; 
     6756+               udelay((ns_2clk+1000-1)/1000); 
     6757+       } 
     6758+#endif 
     6759+       writel(val, host->ioaddr + reg); 
     6760+#else