Pull m68knommu updates from Greg Ungerer: "A collection of changes to add elf-fdpic loader support for m68k. Also a collection of various fixes. They include typo corrections, undefined symbol compilation fixes, removal of the ISA_DMA_API support and removal of unused code. Summary: - correctly set up ZERO_PAGE pointer - drop ISA_DMA_API support - fix comment typos - fixes for undefined symbols - remove unused code and variables - elf-fdpic loader support for m68k" * tag 'm68knommu-for-v5.19' of git://git.kernel.org/pub/scm/linux/kernel/git/gerg/m68knommu: m68knommu: fix 68000 CPU link with no platform selected m68k: removed unused "mach_get_ss" m68knommu: fix undefined reference to `mach_get_rtc_pll' m68knommu: fix undefined reference to `_init_sp' m68knommu: allow elf_fdpic loader to be selected m68knommu: add definitions to support elf_fdpic program loader m68knommu: implement minimal regset support m68knommu: use asm-generic/mmu.h for nommu setups m68k: fix typos in comments m68k: coldfire: drop ISA_DMA_API support m68knommu: set ZERO_PAGE() to the allocated zeroed page
Unified · Split
| @@ -56,16 +56,6 @@ config ATARI_ROM_ISA · 55 unmodified lines | |||
| 56 | The only driver currently using this adapter is the EtherNEC | 56 | The only driver currently using this adapter is the EtherNEC |
| 57 | driver for RTL8019AS based NE2000 compatible network cards. | 57 | driver for RTL8019AS based NE2000 compatible network cards. |
| 58 | 58 | ||
| 59 | config GENERIC_ISA_DMA | ||
| 60 | def_bool ISA | ||
| 61 | |||
| 62 | source "drivers/zorro/Kconfig" | 59 | source "drivers/zorro/Kconfig" |
| 63 | 60 | ||
| 64 | endif | 61 | endif |
| 65 | |||
| 66 | if COLDFIRE | ||
| 67 | |||
| 68 | config ISA_DMA_API | ||
| 69 | def_bool !M5272 | ||
| 70 | |||
| 71 | endif | ||
| @@ -37,7 +37,7 @@ endchoice · 36 unmodified lines | |||
| 37 | if M68KCLASSIC | 37 | if M68KCLASSIC |
| 38 | 38 | ||
| 39 | config M68000 | 39 | config M68000 |
| 40 | bool | 40 | def_bool y |
| 41 | depends on !MMU | 41 | depends on !MMU |
| 42 | select CPU_HAS_NO_BITFIELDS | 42 | select CPU_HAS_NO_BITFIELDS |
| 43 | select CPU_HAS_NO_CAS | 43 | select CPU_HAS_NO_CAS |
| @@ -352,6 +352,7 @@ comment "Machine Options" · 351 unmodified lines | |||
| 352 | 352 | ||
| 353 | config UBOOT | 353 | config UBOOT |
| 354 | bool "Support for U-Boot command line parameters" | 354 | bool "Support for U-Boot command line parameters" |
| 355 | depends on COLDFIRE | ||
| 355 | help | 356 | help |
| 356 | If you say Y here kernel will try to collect command | 357 | If you say Y here kernel will try to collect command |
| 357 | line parameters from the initial u-boot stack. | 358 | line parameters from the initial u-boot stack. |
| @@ -15,7 +15,7 @@ · 14 unmodified lines | |||
| 15 | 15 | ||
| 16 | asflags-$(CONFIG_FULLDEBUG) := -DDEBUGGER_COMPATIBLE_CACHE=1 | 16 | asflags-$(CONFIG_FULLDEBUG) := -DDEBUGGER_COMPATIBLE_CACHE=1 |
| 17 | 17 | ||
| 18 | obj-$(CONFIG_COLDFIRE) += cache.o clk.o device.o dma.o entry.o vectors.o | 18 | obj-$(CONFIG_COLDFIRE) += cache.o clk.o device.o entry.o vectors.o |
| 19 | obj-$(CONFIG_M5206) += m5206.o intc.o reset.o | 19 | obj-$(CONFIG_M5206) += m5206.o intc.o reset.o |
| 20 | obj-$(CONFIG_M5206e) += m5206.o intc.o reset.o | 20 | obj-$(CONFIG_M5206e) += m5206.o intc.o reset.o |
| 21 | obj-$(CONFIG_M520x) += m520x.o intc-simr.o reset.o | 21 | obj-$(CONFIG_M520x) += m520x.o intc-simr.o reset.o |
| @@ -1,43 +0,0 @@ | |||
| 1 | // SPDX-License-Identifier: GPL-2.0 | ||
| 2 | /***************************************************************************/ | ||
| 3 | |||
| 4 | /* | ||
| 5 | * dma.c -- Freescale ColdFire DMA support | ||
| 6 | * | ||
| 7 | * Copyright (C) 2007, Greg Ungerer (gerg@snapgear.com) | ||
| 8 | */ | ||
| 9 | |||
| 10 | /***************************************************************************/ | ||
| 11 | |||
| 12 | #include <linux/kernel.h> | ||
| 13 | #include <linux/module.h> | ||
| 14 | #include <asm/dma.h> | ||
| 15 | #include <asm/coldfire.h> | ||
| 16 | #include <asm/mcfsim.h> | ||
| 17 | #include <asm/mcfdma.h> | ||
| 18 | |||
| 19 | /***************************************************************************/ | ||
| 20 | |||
| 21 | /* | ||
| 22 | * DMA channel base address table. | ||
| 23 | */ | ||
| 24 | unsigned int dma_base_addr[MAX_M68K_DMA_CHANNELS] = { | ||
| 25 | #ifdef MCFDMA_BASE0 | ||
| 26 | MCFDMA_BASE0, | ||
| 27 | #endif | ||
| 28 | #ifdef MCFDMA_BASE1 | ||
| 29 | MCFDMA_BASE1, | ||
| 30 | #endif | ||
| 31 | #ifdef MCFDMA_BASE2 | ||
| 32 | MCFDMA_BASE2, | ||
| 33 | #endif | ||
| 34 | #ifdef MCFDMA_BASE3 | ||
| 35 | MCFDMA_BASE3, | ||
| 36 | #endif | ||
| 37 | }; | ||
| 38 | EXPORT_SYMBOL(dma_base_addr); | ||
| 39 | |||
| 40 | unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS]; | ||
| 41 | EXPORT_SYMBOL(dma_device_address); | ||
| 42 | |||
| 43 | /***************************************************************************/ | ||
| @@ -28,7 +28,7 @@ · 27 unmodified lines | |||
| 28 | unsigned char mcf_irq2imr[NR_IRQS]; | 28 | unsigned char mcf_irq2imr[NR_IRQS]; |
| 29 | 29 | ||
| 30 | /* | 30 | /* |
| 31 | * Define the miniumun and maximum external interrupt numbers. | 31 | * Define the minimum and maximum external interrupt numbers. |
| 32 | * This is also used as the "level" interrupt numbers. | 32 | * This is also used as the "level" interrupt numbers. |
| 33 | */ | 33 | */ |
| 34 | #define EIRQ1 25 | 34 | #define EIRQ1 25 |
| @@ -532,7 +532,7 @@ int clock_pll(int fsys, int flags) · 531 unmodified lines | |||
| 532 | writel(readl(MCF_SDRAMC_SDCR) | MCF_SDRAMC_SDCR_CKE, | 532 | writel(readl(MCF_SDRAMC_SDCR) | MCF_SDRAMC_SDCR_CKE, |
| 533 | MCF_SDRAMC_SDCR); | 533 | MCF_SDRAMC_SDCR); |
| 534 | 534 | ||
| 535 | /* Errata - workaround for SDRAM opeartion after exiting LIMP mode */ | 535 | /* Errata - workaround for SDRAM operation after exiting LIMP mode */ |
| 536 | writel(MCF_SDRAMC_REFRESH, MCF_SDRAMC_LIMP_FIX); | 536 | writel(MCF_SDRAMC_REFRESH, MCF_SDRAMC_LIMP_FIX); |
| 537 | 537 | ||
| 538 | /* wait for DQS logic to relock */ | 538 | /* wait for DQS logic to relock */ |
| @@ -31,7 +31,7 @@ static struct pci_bus *rootbus; · 30 unmodified lines | |||
| 31 | static unsigned long iospace; | 31 | static unsigned long iospace; |
| 32 | 32 | ||
| 33 | /* | 33 | /* |
| 34 | * We need to be carefull probing on bus 0 (directly connected to host | 34 | * We need to be careful probing on bus 0 (directly connected to host |
| 35 | * bridge). We should only access the well defined possible devices in | 35 | * bridge). We should only access the well defined possible devices in |
| 36 | * use, ignore aliases and the like. | 36 | * use, ignore aliases and the like. |
| 37 | */ | 37 | */ |
| @@ -240,12 +240,6 @@ static int hp300_hwclk(int op, struct rtc_time *t) · 239 unmodified lines | |||
| 240 | return 0; | 240 | return 0; |
| 241 | } | 241 | } |
| 242 | 242 | ||
| 243 | static unsigned int hp300_get_ss(void) | ||
| 244 | { | ||
| 245 | return hp300_rtc_read(RTC_REG_SEC1) * 10 + | ||
| 246 | hp300_rtc_read(RTC_REG_SEC2); | ||
| 247 | } | ||
| 248 | |||
| 249 | static void __init hp300_init_IRQ(void) | 243 | static void __init hp300_init_IRQ(void) |
| 250 | { | 244 | { |
| 251 | } | 245 | } |
| @@ -256,7 +250,6 @@ void __init config_hp300(void) · 4 unmodified lines | |||
| 256 | mach_init_IRQ = hp300_init_IRQ; | 250 | mach_init_IRQ = hp300_init_IRQ; |
| 257 | mach_get_model = hp300_get_model; | 251 | mach_get_model = hp300_get_model; |
| 258 | mach_hwclk = hp300_hwclk; | 252 | mach_hwclk = hp300_hwclk; |
| 259 | mach_get_ss = hp300_get_ss; | ||
| 260 | mach_reset = hp300_reset; | 253 | mach_reset = hp300_reset; |
| 261 | #ifdef CONFIG_HEARTBEAT | 254 | #ifdef CONFIG_HEARTBEAT |
| 262 | mach_heartbeat = hp300_pulse; | 255 | mach_heartbeat = hp300_pulse; |
| @@ -2,493 +2,10 @@ · 1 unmodified line | |||
| 2 | #ifndef _M68K_DMA_H | 2 | #ifndef _M68K_DMA_H |
| 3 | #define _M68K_DMA_H 1 | 3 | #define _M68K_DMA_H 1 |
| 4 | 4 | ||
| 5 | #ifdef CONFIG_COLDFIRE | ||
| 6 | /* | ||
| 7 | * ColdFire DMA Model: | ||
| 8 | * ColdFire DMA supports two forms of DMA: Single and Dual address. Single | ||
| 9 | * address mode emits a source address, and expects that the device will either | ||
| 10 | * pick up the data (DMA READ) or source data (DMA WRITE). This implies that | ||
| 11 | * the device will place data on the correct byte(s) of the data bus, as the | ||
| 12 | * memory transactions are always 32 bits. This implies that only 32 bit | ||
| 13 | * devices will find single mode transfers useful. Dual address DMA mode | ||
| 14 | * performs two cycles: source read and destination write. ColdFire will | ||
| 15 | * align the data so that the device will always get the correct bytes, thus | ||
| 16 | * is useful for 8 and 16 bit devices. This is the mode that is supported | ||
| 17 | * below. | ||
| 18 | * | ||
| 19 | * AUG/22/2000 : added support for 32-bit Dual-Address-Mode (K) 2000 | ||
| 20 | * Oliver Kamphenkel (O.Kamphenkel@tu-bs.de) | ||
| 21 | * | ||
| 22 | * AUG/25/2000 : added support for 8, 16 and 32-bit Single-Address-Mode (K)2000 | ||
| 23 | * Oliver Kamphenkel (O.Kamphenkel@tu-bs.de) | ||
| 24 | * | ||
| 25 | * APR/18/2002 : added proper support for MCF5272 DMA controller. | ||
| 26 | * Arthur Shipkowski (art@videon-central.com) | ||
| 27 | */ | ||
| 28 | |||
| 29 | #include <asm/coldfire.h> | ||
| 30 | #include <asm/mcfsim.h> | ||
| 31 | #include <asm/mcfdma.h> | ||
| 32 | |||
| 33 | /* | ||
| 34 | * Set number of channels of DMA on ColdFire for different implementations. | ||
| 35 | */ | ||
| 36 | #if defined(CONFIG_M5249) || defined(CONFIG_M5307) || defined(CONFIG_M5407) || \ | ||
| 37 | defined(CONFIG_M523x) || defined(CONFIG_M527x) || \ | ||
| 38 | defined(CONFIG_M528x) || defined(CONFIG_M525x) | ||
| 39 | |||
| 40 | #define MAX_M68K_DMA_CHANNELS 4 | ||
| 41 | #elif defined(CONFIG_M5272) | ||
| 42 | #define MAX_M68K_DMA_CHANNELS 1 | ||
| 43 | #elif defined(CONFIG_M53xx) | ||
| 44 | #define MAX_M68K_DMA_CHANNELS 0 | ||
| 45 | #else | ||
| 46 | #define MAX_M68K_DMA_CHANNELS 2 | ||
| 47 | #endif | ||
| 48 | |||
| 49 | extern unsigned int dma_base_addr[MAX_M68K_DMA_CHANNELS]; | ||
| 50 | extern unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS]; | ||
| 51 | |||
| 52 | #if !defined(CONFIG_M5272) | ||
| 53 | #define DMA_MODE_WRITE_BIT 0x01 /* Memory/IO to IO/Memory select */ | ||
| 54 | #define DMA_MODE_WORD_BIT 0x02 /* 8 or 16 bit transfers */ | ||
| 55 | #define DMA_MODE_LONG_BIT 0x04 /* or 32 bit transfers */ | ||
| 56 | #define DMA_MODE_SINGLE_BIT 0x08 /* single-address-mode */ | ||
| 57 | |||
| 58 | /* I/O to memory, 8 bits, mode */ | ||
| 59 | #define DMA_MODE_READ 0 | ||
| 60 | /* memory to I/O, 8 bits, mode */ | ||
| 61 | #define DMA_MODE_WRITE 1 | ||
| 62 | /* I/O to memory, 16 bits, mode */ | ||
| 63 | #define DMA_MODE_READ_WORD 2 | ||
| 64 | /* memory to I/O, 16 bits, mode */ | ||
| 65 | #define DMA_MODE_WRITE_WORD 3 | ||
| 66 | /* I/O to memory, 32 bits, mode */ | ||
| 67 | #define DMA_MODE_READ_LONG 4 | ||
| 68 | /* memory to I/O, 32 bits, mode */ | ||
| 69 | #define DMA_MODE_WRITE_LONG 5 | ||
| 70 | /* I/O to memory, 8 bits, single-address-mode */ | ||
| 71 | #define DMA_MODE_READ_SINGLE 8 | ||
| 72 | /* memory to I/O, 8 bits, single-address-mode */ | ||
| 73 | #define DMA_MODE_WRITE_SINGLE 9 | ||
| 74 | /* I/O to memory, 16 bits, single-address-mode */ | ||
| 75 | #define DMA_MODE_READ_WORD_SINGLE 10 | ||
| 76 | /* memory to I/O, 16 bits, single-address-mode */ | ||
| 77 | #define DMA_MODE_WRITE_WORD_SINGLE 11 | ||
| 78 | /* I/O to memory, 32 bits, single-address-mode */ | ||
| 79 | #define DMA_MODE_READ_LONG_SINGLE 12 | ||
| 80 | /* memory to I/O, 32 bits, single-address-mode */ | ||
| 81 | #define DMA_MODE_WRITE_LONG_SINGLE 13 | ||
| 82 | |||
| 83 | #else /* CONFIG_M5272 is defined */ | ||
| 84 | |||
| 85 | /* Source static-address mode */ | ||
| 86 | #define DMA_MODE_SRC_SA_BIT 0x01 | ||
| 87 | /* Two bits to select between all four modes */ | ||
| 88 | #define DMA_MODE_SSIZE_MASK 0x06 | ||
| 89 | /* Offset to shift bits in */ | ||
| 90 | #define DMA_MODE_SSIZE_OFF 0x01 | ||
| 91 | /* Destination static-address mode */ | ||
| 92 | #define DMA_MODE_DES_SA_BIT 0x10 | ||
| 93 | /* Two bits to select between all four modes */ | ||
| 94 | #define DMA_MODE_DSIZE_MASK 0x60 | ||
| 95 | /* Offset to shift bits in */ | ||
| 96 | #define DMA_MODE_DSIZE_OFF 0x05 | ||
| 97 | /* Size modifiers */ | ||
| 98 | #define DMA_MODE_SIZE_LONG 0x00 | ||
| 99 | #define DMA_MODE_SIZE_BYTE 0x01 | ||
| 100 | #define DMA_MODE_SIZE_WORD 0x02 | ||
| 101 | #define DMA_MODE_SIZE_LINE 0x03 | ||
| 102 | |||
| 103 | /* | ||
| 104 | * Aliases to help speed quick ports; these may be suboptimal, however. They | ||
| 105 | * do not include the SINGLE mode modifiers since the MCF5272 does not have a | ||
| 106 | * mode where the device is in control of its addressing. | ||
| 107 | */ | ||
| 108 | |||
| 109 | /* I/O to memory, 8 bits, mode */ | ||
| 110 | #define DMA_MODE_READ ((DMA_MODE_SIZE_BYTE << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_BYTE << DMA_MODE_SSIZE_OFF) | DMA_SRC_SA_BIT) | ||
| 111 | /* memory to I/O, 8 bits, mode */ | ||
| 112 | #define DMA_MODE_WRITE ((DMA_MODE_SIZE_BYTE << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_BYTE << DMA_MODE_SSIZE_OFF) | DMA_DES_SA_BIT) | ||
| 113 | /* I/O to memory, 16 bits, mode */ | ||
| 114 | #define DMA_MODE_READ_WORD ((DMA_MODE_SIZE_WORD << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_WORD << DMA_MODE_SSIZE_OFF) | DMA_SRC_SA_BIT) | ||
| 115 | /* memory to I/O, 16 bits, mode */ | ||
| 116 | #define DMA_MODE_WRITE_WORD ((DMA_MODE_SIZE_WORD << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_WORD << DMA_MODE_SSIZE_OFF) | DMA_DES_SA_BIT) | ||
| 117 | /* I/O to memory, 32 bits, mode */ | ||
| 118 | #define DMA_MODE_READ_LONG ((DMA_MODE_SIZE_LONG << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_LONG << DMA_MODE_SSIZE_OFF) | DMA_SRC_SA_BIT) | ||
| 119 | /* memory to I/O, 32 bits, mode */ | ||
| 120 | #define DMA_MODE_WRITE_LONG ((DMA_MODE_SIZE_LONG << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_LONG << DMA_MODE_SSIZE_OFF) | DMA_DES_SA_BIT) | ||
| 121 | |||
| 122 | #endif /* !defined(CONFIG_M5272) */ | ||
| 123 | |||
| 124 | #if !defined(CONFIG_M5272) | ||
| 125 | /* enable/disable a specific DMA channel */ | ||
| 126 | static __inline__ void enable_dma(unsigned int dmanr) | ||
| 127 | { | ||
| 128 | volatile unsigned short *dmawp; | ||
| 129 | |||
| 130 | #ifdef DMA_DEBUG | ||
| 131 | printk("enable_dma(dmanr=%d)\n", dmanr); | ||
| 132 | #endif | ||
| 133 | |||
| 134 | dmawp = (unsigned short *) dma_base_addr[dmanr]; | ||
| 135 | dmawp[MCFDMA_DCR] |= MCFDMA_DCR_EEXT; | ||
| 136 | } | ||
| 137 | |||
| 138 | static __inline__ void disable_dma(unsigned int dmanr) | ||
| 139 | { | ||
| 140 | volatile unsigned short *dmawp; | ||
| 141 | volatile unsigned char *dmapb; | ||
| 142 | |||
| 143 | #ifdef DMA_DEBUG | ||
| 144 | printk("disable_dma(dmanr=%d)\n", dmanr); | ||
| 145 | #endif | ||
| 146 | |||
| 147 | dmawp = (unsigned short *) dma_base_addr[dmanr]; | ||
| 148 | dmapb = (unsigned char *) dma_base_addr[dmanr]; | ||
| 149 | |||
| 150 | /* Turn off external requests, and stop any DMA in progress */ | ||
| 151 | dmawp[MCFDMA_DCR] &= ~MCFDMA_DCR_EEXT; | ||
| 152 | dmapb[MCFDMA_DSR] = MCFDMA_DSR_DONE; | ||
| 153 | } | ||
| 154 | |||
| 155 | /* | ||
| 156 | * Clear the 'DMA Pointer Flip Flop'. | ||
| 157 | * Write 0 for LSB/MSB, 1 for MSB/LSB access. | ||
| 158 | * Use this once to initialize the FF to a known state. | ||
| 159 | * After that, keep track of it. :-) | ||
| 160 | * --- In order to do that, the DMA routines below should --- | ||
| 161 | * --- only be used while interrupts are disabled! --- | ||
| 162 | * | ||
| 163 | * This is a NOP for ColdFire. Provide a stub for compatibility. | ||
| 164 | */ | ||
| 165 | static __inline__ void clear_dma_ff(unsigned int dmanr) | ||
| 166 | { | ||
| 167 | } | ||
| 168 | |||
| 169 | /* set mode (above) for a specific DMA channel */ | ||
| 170 | static __inline__ void set_dma_mode(unsigned int dmanr, char mode) | ||
| 171 | { | ||
| 172 | |||
| 173 | volatile unsigned char *dmabp; | ||
| 174 | volatile unsigned short *dmawp; | ||
| 175 | |||
| 176 | #ifdef DMA_DEBUG | ||
| 177 | printk("set_dma_mode(dmanr=%d,mode=%d)\n", dmanr, mode); | ||
| 178 | #endif | ||
| 179 | |||
| 180 | dmabp = (unsigned char *) dma_base_addr[dmanr]; | ||
| 181 | dmawp = (unsigned short *) dma_base_addr[dmanr]; | ||
| 182 | |||
| 183 | /* Clear config errors */ | ||
| 184 | dmabp[MCFDMA_DSR] = MCFDMA_DSR_DONE; | ||
| 185 | |||
| 186 | /* Set command register */ | ||
| 187 | dmawp[MCFDMA_DCR] = | ||
| 188 | MCFDMA_DCR_INT | /* Enable completion irq */ | ||
| 189 | MCFDMA_DCR_CS | /* Force one xfer per request */ | ||
| 190 | MCFDMA_DCR_AA | /* Enable auto alignment */ | ||
| 191 | /* single-address-mode */ | ||
| 192 | ((mode & DMA_MODE_SINGLE_BIT) ? MCFDMA_DCR_SAA : 0) | | ||
| 193 | /* sets s_rw (-> r/w) high if Memory to I/0 */ | ||
| 194 | ((mode & DMA_MODE_WRITE_BIT) ? MCFDMA_DCR_S_RW : 0) | | ||
| 195 | /* Memory to I/O or I/O to Memory */ | ||
| 196 | ((mode & DMA_MODE_WRITE_BIT) ? MCFDMA_DCR_SINC : MCFDMA_DCR_DINC) | | ||
| 197 | /* 32 bit, 16 bit or 8 bit transfers */ | ||
| 198 | ((mode & DMA_MODE_WORD_BIT) ? MCFDMA_DCR_SSIZE_WORD : | ||
| 199 | ((mode & DMA_MODE_LONG_BIT) ? MCFDMA_DCR_SSIZE_LONG : | ||
| 200 | MCFDMA_DCR_SSIZE_BYTE)) | | ||
| 201 | ((mode & DMA_MODE_WORD_BIT) ? MCFDMA_DCR_DSIZE_WORD : | ||
| 202 | ((mode & DMA_MODE_LONG_BIT) ? MCFDMA_DCR_DSIZE_LONG : | ||
| 203 | MCFDMA_DCR_DSIZE_BYTE)); | ||
| 204 | |||
| 205 | #ifdef DEBUG_DMA | ||
| 206 | printk("%s(%d): dmanr=%d DSR[%x]=%x DCR[%x]=%x\n", __FILE__, __LINE__, | ||
| 207 | dmanr, (int) &dmabp[MCFDMA_DSR], dmabp[MCFDMA_DSR], | ||
| 208 | (int) &dmawp[MCFDMA_DCR], dmawp[MCFDMA_DCR]); | ||
| 209 | #endif | ||
| 210 | } | ||
| 211 | |||
| 212 | /* Set transfer address for specific DMA channel */ | ||
| 213 | static __inline__ void set_dma_addr(unsigned int dmanr, unsigned int a) | ||
| 214 | { | ||
| 215 | volatile unsigned short *dmawp; | ||
| 216 | volatile unsigned int *dmalp; | ||
| 217 | |||
| 218 | #ifdef DMA_DEBUG | ||
| 219 | printk("set_dma_addr(dmanr=%d,a=%x)\n", dmanr, a); | ||
| 220 | #endif | ||
| 221 | |||
| 222 | dmawp = (unsigned short *) dma_base_addr[dmanr]; | ||
| 223 | dmalp = (unsigned int *) dma_base_addr[dmanr]; | ||
| 224 | |||
| 225 | /* Determine which address registers are used for memory/device accesses */ | ||
| 226 | if (dmawp[MCFDMA_DCR] & MCFDMA_DCR_SINC) { | ||
| 227 | /* Source incrementing, must be memory */ | ||
| 228 | dmalp[MCFDMA_SAR] = a; | ||
| 229 | /* Set dest address, must be device */ | ||
| 230 | dmalp[MCFDMA_DAR] = dma_device_address[dmanr]; | ||
| 231 | } else { | ||
| 232 | /* Destination incrementing, must be memory */ | ||
| 233 | dmalp[MCFDMA_DAR] = a; | ||
| 234 | /* Set source address, must be device */ | ||
| 235 | dmalp[MCFDMA_SAR] = dma_device_address[dmanr]; | ||
| 236 | } | ||
| 237 | |||
| 238 | #ifdef DEBUG_DMA | ||
| 239 | printk("%s(%d): dmanr=%d DCR[%x]=%x SAR[%x]=%08x DAR[%x]=%08x\n", | ||
| 240 | __FILE__, __LINE__, dmanr, (int) &dmawp[MCFDMA_DCR], dmawp[MCFDMA_DCR], | ||
| 241 | (int) &dmalp[MCFDMA_SAR], dmalp[MCFDMA_SAR], | ||
| 242 | (int) &dmalp[MCFDMA_DAR], dmalp[MCFDMA_DAR]); | ||
| 243 | #endif | ||
| 244 | } | ||
| 245 | |||
| 246 | /* | ||
| 247 | * Specific for Coldfire - sets device address. | ||
| 248 | * Should be called after the mode set call, and before set DMA address. | ||
| 249 | */ | ||
| 250 | static __inline__ void set_dma_device_addr(unsigned int dmanr, unsigned int a) | ||
| 251 | { | ||
| 252 | #ifdef DMA_DEBUG | ||
| 253 | printk("set_dma_device_addr(dmanr=%d,a=%x)\n", dmanr, a); | ||
| 254 | #endif | ||
| 255 | |||
| 256 | dma_device_address[dmanr] = a; | ||
| 257 | } | ||
| 258 | |||
| 259 | /* | ||
| 260 | * NOTE 2: "count" represents _bytes_. | ||
| 261 | */ | ||
| 262 | static __inline__ void set_dma_count(unsigned int dmanr, unsigned int count) | ||
| 263 | { | ||
| 264 | volatile unsigned short *dmawp; | ||
| 265 | |||
| 266 | #ifdef DMA_DEBUG | ||
| 267 | printk("set_dma_count(dmanr=%d,count=%d)\n", dmanr, count); | ||
| 268 | #endif | ||
| 269 | |||
| 270 | dmawp = (unsigned short *) dma_base_addr[dmanr]; | ||
| 271 | dmawp[MCFDMA_BCR] = (unsigned short)count; | ||
| 272 | } | ||
| 273 | |||
| 274 | /* | ||
| 275 | * Get DMA residue count. After a DMA transfer, this | ||
| 276 | * should return zero. Reading this while a DMA transfer is | ||
| 277 | * still in progress will return unpredictable results. | ||
| 278 | * Otherwise, it returns the number of _bytes_ left to transfer. | ||
| 279 | */ | ||
| 280 | static __inline__ int get_dma_residue(unsigned int dmanr) | ||
| 281 | { | ||
| 282 | volatile unsigned short *dmawp; | ||
| 283 | unsigned short count; | ||
| 284 | |||
| 285 | #ifdef DMA_DEBUG | ||
| 286 | printk("get_dma_residue(dmanr=%d)\n", dmanr); | ||
| 287 | #endif | ||
| 288 | |||
| 289 | dmawp = (unsigned short *) dma_base_addr[dmanr]; | ||
| 290 | count = dmawp[MCFDMA_BCR]; | ||
| 291 | return((int) count); | ||
| 292 | } | ||
| 293 | #else /* CONFIG_M5272 is defined */ | ||
| 294 | |||
| 295 | /* | ||
| 296 | * The MCF5272 DMA controller is very different than the controller defined above | ||
| 297 | * in terms of register mapping. For instance, with the exception of the 16-bit | ||
| 298 | * interrupt register (IRQ#85, for reference), all of the registers are 32-bit. | ||
| 299 | * | ||
| 300 | * The big difference, however, is the lack of device-requested DMA. All modes | ||
| 301 | * are dual address transfer, and there is no 'device' setup or direction bit. | ||
| 302 | * You can DMA between a device and memory, between memory and memory, or even between | ||
| 303 | * two devices directly, with any combination of incrementing and non-incrementing | ||
| 304 | * addresses you choose. This puts a crimp in distinguishing between the 'device | ||
| 305 | * address' set up by set_dma_device_addr. | ||
| 306 | * | ||
| 307 | * Therefore, there are two options. One is to use set_dma_addr and set_dma_device_addr, | ||
| 308 | * which will act exactly as above in -- it will look to see if the source is set to | ||
| 309 | * autoincrement, and if so it will make the source use the set_dma_addr value and the | ||
| 310 | * destination the set_dma_device_addr value. Otherwise the source will be set to the | ||
| 311 | * set_dma_device_addr value and the destination will get the set_dma_addr value. | ||
| 312 | * | ||
| 313 | * The other is to use the provided set_dma_src_addr and set_dma_dest_addr functions | ||
| 314 | * and make it explicit. Depending on what you're doing, one of these two should work | ||
| 315 | * for you, but don't mix them in the same transfer setup. | ||
| 316 | */ | ||
| 317 | |||
| 318 | /* enable/disable a specific DMA channel */ | ||
| 319 | static __inline__ void enable_dma(unsigned int dmanr) | ||
| 320 | { | ||
| 321 | volatile unsigned int *dmalp; | ||
| 322 | |||
| 323 | #ifdef DMA_DEBUG | ||
| 324 | printk("enable_dma(dmanr=%d)\n", dmanr); | ||
| 325 | #endif | ||
| 326 | |||
| 327 | dmalp = (unsigned int *) dma_base_addr[dmanr]; | ||
| 328 | dmalp[MCFDMA_DMR] |= MCFDMA_DMR_EN; | ||
| 329 | } | ||
| 330 | |||
| 331 | static __inline__ void disable_dma(unsigned int dmanr) | ||
| 332 | { | ||
| 333 | volatile unsigned int *dmalp; | ||
| 334 | |||
| 335 | #ifdef DMA_DEBUG | ||
| 336 | printk("disable_dma(dmanr=%d)\n", dmanr); | ||
| 337 | #endif | ||
| 338 | |||
| 339 | dmalp = (unsigned int *) dma_base_addr[dmanr]; | ||
| 340 | |||
| 341 | /* Turn off external requests, and stop any DMA in progress */ | ||
| 342 | dmalp[MCFDMA_DMR] &= ~MCFDMA_DMR_EN; | ||
| 343 | dmalp[MCFDMA_DMR] |= MCFDMA_DMR_RESET; | ||
| 344 | } | ||
| 345 | |||
| 346 | /* | ||
| 347 | * Clear the 'DMA Pointer Flip Flop'. | ||
| 348 | * Write 0 for LSB/MSB, 1 for MSB/LSB access. | ||
| 349 | * Use this once to initialize the FF to a known state. | ||
| 350 | * After that, keep track of it. :-) | ||
| 351 | * --- In order to do that, the DMA routines below should --- | ||
| 352 | * --- only be used while interrupts are disabled! --- | ||
| 353 | * | ||
| 354 | * This is a NOP for ColdFire. Provide a stub for compatibility. | ||
| 355 | */ | ||
| 356 | static __inline__ void clear_dma_ff(unsigned int dmanr) | ||
| 357 | { | ||
| 358 | } | ||
| 359 | |||
| 360 | /* set mode (above) for a specific DMA channel */ | ||
| 361 | static __inline__ void set_dma_mode(unsigned int dmanr, char mode) | ||
| 362 | { | ||
| 363 | |||
| 364 | volatile unsigned int *dmalp; | ||
| 365 | volatile unsigned short *dmawp; | ||
| 366 | |||
| 367 | #ifdef DMA_DEBUG | ||
| 368 | printk("set_dma_mode(dmanr=%d,mode=%d)\n", dmanr, mode); | ||
| 369 | #endif | ||
| 370 | dmalp = (unsigned int *) dma_base_addr[dmanr]; | ||
| 371 | dmawp = (unsigned short *) dma_base_addr[dmanr]; | ||
| 372 | |||
| 373 | /* Clear config errors */ | ||
| 374 | dmalp[MCFDMA_DMR] |= MCFDMA_DMR_RESET; | ||
| 375 | |||
| 376 | /* Set command register */ | ||
| 377 | dmalp[MCFDMA_DMR] = | ||
| 378 | MCFDMA_DMR_RQM_DUAL | /* Mandatory Request Mode setting */ | ||
| 379 | MCFDMA_DMR_DSTT_SD | /* Set up addressing types; set to supervisor-data. */ | ||
| 380 | MCFDMA_DMR_SRCT_SD | /* Set up addressing types; set to supervisor-data. */ | ||
| 381 | /* source static-address-mode */ | ||
| 382 | ((mode & DMA_MODE_SRC_SA_BIT) ? MCFDMA_DMR_SRCM_SA : MCFDMA_DMR_SRCM_IA) | | ||
| 383 | /* dest static-address-mode */ | ||
| 384 | ((mode & DMA_MODE_DES_SA_BIT) ? MCFDMA_DMR_DSTM_SA : MCFDMA_DMR_DSTM_IA) | | ||
| 385 | /* burst, 32 bit, 16 bit or 8 bit transfers are separately configurable on the MCF5272 */ | ||
| 386 | (((mode & DMA_MODE_SSIZE_MASK) >> DMA_MODE_SSIZE_OFF) << MCFDMA_DMR_DSTS_OFF) | | ||
| 387 | (((mode & DMA_MODE_SSIZE_MASK) >> DMA_MODE_SSIZE_OFF) << MCFDMA_DMR_SRCS_OFF); | ||
| 388 | |||
| 389 | dmawp[MCFDMA_DIR] |= MCFDMA_DIR_ASCEN; /* Enable completion interrupts */ | ||
| 390 | |||
| 391 | #ifdef DEBUG_DMA | ||
| 392 | printk("%s(%d): dmanr=%d DMR[%x]=%x DIR[%x]=%x\n", __FILE__, __LINE__, | ||
| 393 | dmanr, (int) &dmalp[MCFDMA_DMR], dmalp[MCFDMA_DMR], | ||
| 394 | (int) &dmawp[MCFDMA_DIR], dmawp[MCFDMA_DIR]); | ||
| 395 | #endif | ||
| 396 | } | ||
| 397 | |||
| 398 | /* Set transfer address for specific DMA channel */ | ||
| 399 | static __inline__ void set_dma_addr(unsigned int dmanr, unsigned int a) | ||
| 400 | { | ||
| 401 | volatile unsigned int *dmalp; | ||
| 402 | |||
| 403 | #ifdef DMA_DEBUG | ||
| 404 | printk("set_dma_addr(dmanr=%d,a=%x)\n", dmanr, a); | ||
| 405 | #endif | ||
| 406 | |||
| 407 | dmalp = (unsigned int *) dma_base_addr[dmanr]; | ||
| 408 | |||
| 409 | /* Determine which address registers are used for memory/device accesses */ | ||
| 410 | if (dmalp[MCFDMA_DMR] & MCFDMA_DMR_SRCM) { | ||
| 411 | /* Source incrementing, must be memory */ | ||
| 412 | dmalp[MCFDMA_DSAR] = a; | ||
| 413 | /* Set dest address, must be device */ | ||
| 414 | dmalp[MCFDMA_DDAR] = dma_device_address[dmanr]; | ||
| 415 | } else { | ||
| 416 | /* Destination incrementing, must be memory */ | ||
| 417 | dmalp[MCFDMA_DDAR] = a; | ||
| 418 | /* Set source address, must be device */ | ||
| 419 | dmalp[MCFDMA_DSAR] = dma_device_address[dmanr]; | ||
| 420 | } | ||
| 421 | |||
| 422 | #ifdef DEBUG_DMA | ||
| 423 | printk("%s(%d): dmanr=%d DMR[%x]=%x SAR[%x]=%08x DAR[%x]=%08x\n", | ||
| 424 | __FILE__, __LINE__, dmanr, (int) &dmalp[MCFDMA_DMR], dmalp[MCFDMA_DMR], | ||
| 425 | (int) &dmalp[MCFDMA_DSAR], dmalp[MCFDMA_DSAR], | ||
| 426 | (int) &dmalp[MCFDMA_DDAR], dmalp[MCFDMA_DDAR]); | ||
| 427 | #endif | ||
| 428 | } | ||
| 429 | |||
| 430 | /* | ||
| 431 | * Specific for Coldfire - sets device address. | ||
| 432 | * Should be called after the mode set call, and before set DMA address. | ||
| 433 | */ | ||
| 434 | static __inline__ void set_dma_device_addr(unsigned int dmanr, unsigned int a) | ||
| 435 | { | ||
| 436 | #ifdef DMA_DEBUG | ||
| 437 | printk("set_dma_device_addr(dmanr=%d,a=%x)\n", dmanr, a); | ||
| 438 | #endif | ||
| 439 | |||
| 440 | dma_device_address[dmanr] = a; | ||
| 441 | } | ||
| 442 | |||
| 443 | /* | ||
| 444 | * NOTE 2: "count" represents _bytes_. | ||
| 445 | * | ||
| 446 | * NOTE 3: While a 32-bit register, "count" is only a maximum 24-bit value. | ||
| 447 | */ | ||
| 448 | static __inline__ void set_dma_count(unsigned int dmanr, unsigned int count) | ||
| 449 | { | ||
| 450 | volatile unsigned int *dmalp; | ||
| 451 | |||
| 452 | #ifdef DMA_DEBUG | ||
| 453 | printk("set_dma_count(dmanr=%d,count=%d)\n", dmanr, count); | ||
| 454 | #endif | ||
| 455 | |||
| 456 | dmalp = (unsigned int *) dma_base_addr[dmanr]; | ||
| 457 | dmalp[MCFDMA_DBCR] = count; | ||
| 458 | } | ||
| 459 | |||
| 460 | /* | ||
| 461 | * Get DMA residue count. After a DMA transfer, this | ||
| 462 | * should return zero. Reading this while a DMA transfer is | ||
| 463 | * still in progress will return unpredictable results. | ||
| 464 | * Otherwise, it returns the number of _bytes_ left to transfer. | ||
| 465 | */ | ||
| 466 | static __inline__ int get_dma_residue(unsigned int dmanr) | ||
| 467 | { | ||
| 468 | volatile unsigned int *dmalp; | ||
| 469 | unsigned int count; | ||
| 470 | |||
| 471 | #ifdef DMA_DEBUG | ||
| 472 | printk("get_dma_residue(dmanr=%d)\n", dmanr); | ||
| 473 | #endif | ||
| 474 | |||
| 475 | dmalp = (unsigned int *) dma_base_addr[dmanr]; | ||
| 476 | count = dmalp[MCFDMA_DBCR]; | ||
| 477 | return(count); | ||
| 478 | } | ||
| 479 | |||
| 480 | #endif /* !defined(CONFIG_M5272) */ | ||
| 481 | #endif /* CONFIG_COLDFIRE */ | ||
| 482 | |||
| 483 | /* it's useless on the m68k, but unfortunately needed by the new | 5 | /* it's useless on the m68k, but unfortunately needed by the new |
| 484 | bootmem allocator (but this should do it for this) */ | 6 | bootmem allocator (but this should do it for this) */ |
| 485 | #define MAX_DMA_ADDRESS PAGE_OFFSET | 7 | #define MAX_DMA_ADDRESS PAGE_OFFSET |
| 486 | 8 | ||
| 487 | #define MAX_DMA_CHANNELS 8 | ||
| 488 | |||
| 489 | extern int request_dma(unsigned int dmanr, const char * device_id); /* reserve a DMA channel */ | ||
| 490 | extern void free_dma(unsigned int dmanr); /* release it again */ | ||
| 491 | |||
| 492 | #ifdef CONFIG_PCI | 9 | #ifdef CONFIG_PCI |
| 493 | extern int isa_dma_bridge_buggy; | 10 | extern int isa_dma_bridge_buggy; |
| 494 | #else | 11 | #else |
| @@ -60,6 +60,13 @@ typedef struct user_m68kfp_struct elf_fpregset_t; · 59 unmodified lines | |||
| 60 | is actually used on ASV. */ | 60 | is actually used on ASV. */ |
| 61 | #define ELF_PLAT_INIT(_r, load_addr) _r->a1 = 0 | 61 | #define ELF_PLAT_INIT(_r, load_addr) _r->a1 = 0 |
| 62 | 62 | ||
| 63 | #define ELF_FDPIC_PLAT_INIT(_r, _exec_map_addr, _interp_map_addr, dynamic_addr) \ | ||
| 64 | do { \ | ||
| 65 | (_r)->d3 = _exec_map_addr; \ | ||
| 66 | (_r)->d4 = _interp_map_addr; \ | ||
| 67 | (_r)->d5 = dynamic_addr; \ | ||
| 68 | } while(0) | ||
| 69 | |||
| 63 | #if defined(CONFIG_SUN3) || defined(CONFIG_COLDFIRE) | 70 | #if defined(CONFIG_SUN3) || defined(CONFIG_COLDFIRE) |
| 64 | #define ELF_EXEC_PAGESIZE 8192 | 71 | #define ELF_EXEC_PAGESIZE 8192 |
| 65 | #else | 72 | #else |
| @@ -114,4 +121,6 @@ typedef struct user_m68kfp_struct elf_fpregset_t; · 48 unmodified lines | |||
| 114 | 121 | ||
| 115 | #define ELF_PLATFORM (NULL) | 122 | #define ELF_PLATFORM (NULL) |
| 116 | 123 | ||
| 124 | #define ELF_FDPIC_CORE_EFLAGS 0 | ||
| 125 | |||
| 117 | #endif | 126 | #endif |
| @@ -19,7 +19,6 @@ extern void (*mach_get_model) (char *model); · 18 unmodified lines | |||
| 19 | extern void (*mach_get_hardware_list) (struct seq_file *m); | 19 | extern void (*mach_get_hardware_list) (struct seq_file *m); |
| 20 | /* machine dependent timer functions */ | 20 | /* machine dependent timer functions */ |
| 21 | extern int (*mach_hwclk)(int, struct rtc_time*); | 21 | extern int (*mach_hwclk)(int, struct rtc_time*); |
| 22 | extern unsigned int (*mach_get_ss)(void); | ||
| 23 | extern int (*mach_get_rtc_pll)(struct rtc_pll_info *); | 22 | extern int (*mach_get_rtc_pll)(struct rtc_pll_info *); |
| 24 | extern int (*mach_set_rtc_pll)(struct rtc_pll_info *); | 23 | extern int (*mach_set_rtc_pll)(struct rtc_pll_info *); |
| 25 | extern void (*mach_reset)( void ); | 24 | extern void (*mach_reset)( void ); |
| @@ -6,9 +6,7 @@ · 5 unmodified lines | |||
| 6 | /* Default "unsigned long" context */ | 6 | /* Default "unsigned long" context */ |
| 7 | typedef unsigned long mm_context_t; | 7 | typedef unsigned long mm_context_t; |
| 8 | #else | 8 | #else |
| 9 | typedef struct { | 9 | #include <asm-generic/mmu.h> |
| 10 | unsigned long end_brk; | ||
| 11 | } mm_context_t; | ||
| 12 | #endif | 10 | #endif |
| 13 | 11 | ||
| 14 | #endif | 12 | #endif |
| @@ -42,7 +42,8 @@ extern void paging_init(void); · 41 unmodified lines | |||
| 42 | * ZERO_PAGE is a global shared page that is always zero: used | 42 | * ZERO_PAGE is a global shared page that is always zero: used |
| 43 | * for zero-mapped memory areas etc.. | 43 | * for zero-mapped memory areas etc.. |
| 44 | */ | 44 | */ |
| 45 | #define ZERO_PAGE(vaddr) (virt_to_page(0)) | 45 | extern void *empty_zero_page; |
| 46 | #define ZERO_PAGE(vaddr) (virt_to_page(empty_zero_page)) | ||
| 46 | 47 | ||
| 47 | /* | 48 | /* |
| 48 | * All 32bit addresses are effectively valid for vmalloc... | 49 | * All 32bit addresses are effectively valid for vmalloc... |
| @@ -74,7 +74,12 @@ struct switch_stack { · 73 unmodified lines | |||
| 74 | 74 | ||
| 75 | #define PTRACE_GET_THREAD_AREA 25 | 75 | #define PTRACE_GET_THREAD_AREA 25 |
| 76 | 76 | ||
| 77 | #define PTRACE_GETFDPIC 31 | ||
| 78 | |||
| 77 | #define PTRACE_SINGLEBLOCK 33 /* resume execution until next branch */ | 79 | #define PTRACE_SINGLEBLOCK 33 /* resume execution until next branch */ |
| 78 | 80 | ||
| 81 | #define PTRACE_GETFDPIC_EXEC 0 | ||
| 82 | #define PTRACE_GETFDPIC_INTERP 1 | ||
| 83 | |||
| 79 | #endif /* __ASSEMBLY__ */ | 84 | #endif /* __ASSEMBLY__ */ |
| 80 | #endif /* _UAPI_M68K_PTRACE_H */ | 85 | #endif /* _UAPI_M68K_PTRACE_H */ |
| @@ -19,6 +19,8 @@ · 18 unmodified lines | |||
| 19 | #include <linux/ptrace.h> | 19 | #include <linux/ptrace.h> |
| 20 | #include <linux/user.h> | 20 | #include <linux/user.h> |
| 21 | #include <linux/signal.h> | 21 | #include <linux/signal.h> |
| 22 | #include <linux/regset.h> | ||
| 23 | #include <linux/elf.h> | ||
| 22 | 24 | ||
| 23 | #include <linux/uaccess.h> | 25 | #include <linux/uaccess.h> |
| 24 | #include <asm/page.h> | 26 | #include <asm/page.h> |
| @@ -284,3 +286,59 @@ asmlinkage void syscall_trace_leave(void) · 259 unmodified lines | |||
| 284 | if (test_thread_flag(TIF_SYSCALL_TRACE)) | 286 | if (test_thread_flag(TIF_SYSCALL_TRACE)) |
| 285 | ptrace_report_syscall_exit(task_pt_regs(current), 0); | 287 | ptrace_report_syscall_exit(task_pt_regs(current), 0); |
| 286 | } | 288 | } |
| 289 | |||
| 290 | #if defined(CONFIG_BINFMT_ELF_FDPIC) && defined(CONFIG_ELF_CORE) | ||
| 291 | /* | ||
| 292 | * Currently the only thing that needs to use regsets for m68k is the | ||
| 293 | * coredump support of the elf_fdpic loader. Implement the minimum | ||
| 294 | * definitions required for that. | ||
| 295 | */ | ||
| 296 | static int m68k_regset_get(struct task_struct *target, | ||
| 297 | const struct user_regset *regset, | ||
| 298 | struct membuf to) | ||
| 299 | { | ||
| 300 | struct pt_regs *ptregs = task_pt_regs(target); | ||
| 301 | u32 uregs[ELF_NGREG]; | ||
| 302 | |||
| 303 | ELF_CORE_COPY_REGS(uregs, ptregs); | ||
| 304 | return membuf_write(&to, uregs, sizeof(uregs)); | ||
| 305 | } | ||
| 306 | |||
| 307 | enum m68k_regset { | ||
| 308 | REGSET_GPR, | ||
| 309 | #ifdef CONFIG_FPU | ||
| 310 | REGSET_FPU, | ||
| 311 | #endif | ||
| 312 | }; | ||
| 313 | |||
| 314 | static const struct user_regset m68k_user_regsets[] = { | ||
| 315 | [REGSET_GPR] = { | ||
| 316 | .core_note_type = NT_PRSTATUS, | ||
| 317 | .n = ELF_NGREG, | ||
| 318 | .size = sizeof(u32), | ||
| 319 | .align = sizeof(u16), | ||
| 320 | .regset_get = m68k_regset_get, | ||
| 321 | }, | ||
| 322 | #ifdef CONFIG_FPU | ||
| 323 | [REGSET_FPU] = { | ||
| 324 | .core_note_type = NT_PRFPREG, | ||
| 325 | .n = sizeof(struct user_m68kfp_struct) / sizeof(u32), | ||
| 326 | .size = sizeof(u32), | ||
| 327 | .align = sizeof(u32), | ||
| 328 | } | ||
| 329 | #endif /* CONFIG_FPU */ | ||
| 330 | }; | ||
| 331 | |||
| 332 | static const struct user_regset_view user_m68k_view = { | ||
| 333 | .name = "m68k", | ||
| 334 | .e_machine = EM_68K, | ||
| 335 | .ei_osabi = ELF_OSABI, | ||
| 336 | .regsets = m68k_user_regsets, | ||
| 337 | .n = ARRAY_SIZE(m68k_user_regsets) | ||
| 338 | }; | ||
| 339 | |||
| 340 | const struct user_regset_view *task_user_regset_view(struct task_struct *task) | ||
| 341 | { | ||
| 342 | return &user_m68k_view; | ||
| 343 | } | ||
| 344 | #endif /* CONFIG_BINFMT_ELF_FDPIC && CONFIG_ELF_CORE */ | ||
| @@ -87,15 +87,6 @@ void (*mach_sched_init) (void) __initdata = NULL; · 86 unmodified lines | |||
| 87 | void (*mach_init_IRQ) (void) __initdata = NULL; | 87 | void (*mach_init_IRQ) (void) __initdata = NULL; |
| 88 | void (*mach_get_model) (char *model); | 88 | void (*mach_get_model) (char *model); |
| 89 | void (*mach_get_hardware_list) (struct seq_file *m); | 89 | void (*mach_get_hardware_list) (struct seq_file *m); |
| 90 | /* machine dependent timer functions */ | ||
| 91 | int (*mach_hwclk) (int, struct rtc_time*); | ||
| 92 | EXPORT_SYMBOL(mach_hwclk); | ||
| 93 | unsigned int (*mach_get_ss)(void); | ||
| 94 | int (*mach_get_rtc_pll)(struct rtc_pll_info *); | ||
| 95 | int (*mach_set_rtc_pll)(struct rtc_pll_info *); | ||
| 96 | EXPORT_SYMBOL(mach_get_ss); | ||
| 97 | EXPORT_SYMBOL(mach_get_rtc_pll); | ||
| 98 | EXPORT_SYMBOL(mach_set_rtc_pll); | ||
| 99 | void (*mach_reset)( void ); | 90 | void (*mach_reset)( void ); |
| 100 | void (*mach_halt)( void ); | 91 | void (*mach_halt)( void ); |
| 101 | void (*mach_power_off)( void ); | 92 | void (*mach_power_off)( void ); |
| @@ -50,7 +50,6 @@ char __initdata command_line[COMMAND_LINE_SIZE]; · 49 unmodified lines | |||
| 50 | 50 | ||
| 51 | /* machine dependent timer functions */ | 51 | /* machine dependent timer functions */ |
| 52 | void (*mach_sched_init)(void) __initdata = NULL; | 52 | void (*mach_sched_init)(void) __initdata = NULL; |
| 53 | int (*mach_hwclk) (int, struct rtc_time*); | ||
| 54 | 53 | ||
| 55 | /* machine dependent reboot functions */ | 54 | /* machine dependent reboot functions */ |
| 56 | void (*mach_reset)(void); | 55 | void (*mach_reset)(void); |
| @@ -63,6 +63,15 @@ void timer_heartbeat(void) · 62 unmodified lines | |||
| 63 | #endif /* CONFIG_HEARTBEAT */ | 63 | #endif /* CONFIG_HEARTBEAT */ |
| 64 | 64 | ||
| 65 | #ifdef CONFIG_M68KCLASSIC | 65 | #ifdef CONFIG_M68KCLASSIC |
| 66 | /* machine dependent timer functions */ | ||
| 67 | int (*mach_hwclk) (int, struct rtc_time*); | ||
| 68 | EXPORT_SYMBOL(mach_hwclk); | ||
| 69 | |||
| 70 | int (*mach_get_rtc_pll)(struct rtc_pll_info *); | ||
| 71 | int (*mach_set_rtc_pll)(struct rtc_pll_info *); | ||
| 72 | EXPORT_SYMBOL(mach_get_rtc_pll); | ||
| 73 | EXPORT_SYMBOL(mach_set_rtc_pll); | ||
| 74 | |||
| 66 | #if !IS_BUILTIN(CONFIG_RTC_DRV_GENERIC) | 75 | #if !IS_BUILTIN(CONFIG_RTC_DRV_GENERIC) |
| 67 | void read_persistent_clock64(struct timespec64 *ts) | 76 | void read_persistent_clock64(struct timespec64 *ts) |
| 68 | { | 77 | { |
| @@ -27,7 +27,6 @@ · 26 unmodified lines | |||
| 27 | #include <asm/pgalloc.h> | 27 | #include <asm/pgalloc.h> |
| 28 | #include <asm/machdep.h> | 28 | #include <asm/machdep.h> |
| 29 | #include <asm/io.h> | 29 | #include <asm/io.h> |
| 30 | #include <asm/dma.h> | ||
| 31 | #ifdef CONFIG_ATARI | 30 | #ifdef CONFIG_ATARI |
| 32 | #include <asm/atari_stram.h> | 31 | #include <asm/atari_stram.h> |
| 33 | #endif | 32 | #endif |
| @@ -41,7 +41,6 @@ static void q40_get_model(char *model); · 40 unmodified lines | |||
| 41 | extern void q40_sched_init(void); | 41 | extern void q40_sched_init(void); |
| 42 | 42 | ||
| 43 | static int q40_hwclk(int, struct rtc_time *); | 43 | static int q40_hwclk(int, struct rtc_time *); |
| 44 | static unsigned int q40_get_ss(void); | ||
| 45 | static int q40_get_rtc_pll(struct rtc_pll_info *pll); | 44 | static int q40_get_rtc_pll(struct rtc_pll_info *pll); |
| 46 | static int q40_set_rtc_pll(struct rtc_pll_info *pll); | 45 | static int q40_set_rtc_pll(struct rtc_pll_info *pll); |
| 47 | 46 | ||
| @@ -169,7 +168,6 @@ void __init config_q40(void) · 121 unmodified lines | |||
| 169 | 168 | ||
| 170 | mach_init_IRQ = q40_init_IRQ; | 169 | mach_init_IRQ = q40_init_IRQ; |
| 171 | mach_hwclk = q40_hwclk; | 170 | mach_hwclk = q40_hwclk; |
| 172 | mach_get_ss = q40_get_ss; | ||
| 173 | mach_get_rtc_pll = q40_get_rtc_pll; | 171 | mach_get_rtc_pll = q40_get_rtc_pll; |
| 174 | mach_set_rtc_pll = q40_set_rtc_pll; | 172 | mach_set_rtc_pll = q40_set_rtc_pll; |
| 175 | 173 | ||
| @@ -246,11 +244,6 @@ static int q40_hwclk(int op, struct rtc_time *t) · 70 unmodified lines | |||
| 246 | return 0; | 244 | return 0; |
| 247 | } | 245 | } |
| 248 | 246 | ||
| 249 | static unsigned int q40_get_ss(void) | ||
| 250 | { | ||
| 251 | return bcd2bin(Q40_RTC_SECS); | ||
| 252 | } | ||
| 253 | |||
| 254 | /* get and set PLL calibration of RTC clock */ | 247 | /* get and set PLL calibration of RTC clock */ |
| 255 | #define Q40_RTC_PLL_MASK ((1<<5)-1) | 248 | #define Q40_RTC_PLL_MASK ((1<<5)-1) |
| 256 | #define Q40_RTC_PLL_SIGN (1<<5) | 249 | #define Q40_RTC_PLL_SIGN (1<<5) |
| @@ -508,7 +508,7 @@ config MMC_OMAP_HS · 507 unmodified lines | |||
| 508 | 508 | ||
| 509 | config MMC_WBSD | 509 | config MMC_WBSD |
| 510 | tristate "Winbond W83L51xD SD/MMC Card Interface support" | 510 | tristate "Winbond W83L51xD SD/MMC Card Interface support" |
| 511 | depends on ISA_DMA_API && !M68K | 511 | depends on ISA_DMA_API |
| 512 | help | 512 | help |
| 513 | This selects the Winbond(R) W83L51xD Secure digital and | 513 | This selects the Winbond(R) W83L51xD Secure digital and |
| 514 | Multimedia card Interface. | 514 | Multimedia card Interface. |
| @@ -58,7 +58,7 @@ config ARCH_USE_GNU_PROPERTY · 57 unmodified lines | |||
| 58 | config BINFMT_ELF_FDPIC | 58 | config BINFMT_ELF_FDPIC |
| 59 | bool "Kernel support for FDPIC ELF binaries" | 59 | bool "Kernel support for FDPIC ELF binaries" |
| 60 | default y if !BINFMT_ELF | 60 | default y if !BINFMT_ELF |
| 61 | depends on (ARM || (SUPERH && !MMU)) | 61 | depends on ARM || ((M68K || SUPERH) && !MMU) |
| 62 | select ELFCORE | 62 | select ELFCORE |
| 63 | help | 63 | help |
| 64 | ELF FDPIC binaries are based on ELF, but allow the individual load | 64 | ELF FDPIC binaries are based on ELF, but allow the individual load |
| @@ -9,9 +9,7 @@ ifneq ($(CONFIG_SND_PROC_FS),) · 8 unmodified lines | |||
| 9 | snd-y += info.o | 9 | snd-y += info.o |
| 10 | snd-$(CONFIG_SND_OSSEMUL) += info_oss.o | 10 | snd-$(CONFIG_SND_OSSEMUL) += info_oss.o |
| 11 | endif | 11 | endif |
| 12 | ifneq ($(CONFIG_M68K),y) | ||
| 13 | snd-$(CONFIG_ISA_DMA_API) += isadma.o | 12 | snd-$(CONFIG_ISA_DMA_API) += isadma.o |
| 14 | endif | ||
| 15 | snd-$(CONFIG_SND_OSSEMUL) += sound_oss.o | 13 | snd-$(CONFIG_SND_OSSEMUL) += sound_oss.o |
| 16 | snd-$(CONFIG_SND_VMASTER) += vmaster.o | 14 | snd-$(CONFIG_SND_VMASTER) += vmaster.o |
| 17 | snd-$(CONFIG_SND_JACK) += ctljack.o jack.o | 15 | snd-$(CONFIG_SND_JACK) += ctljack.o jack.o |
| @@ -22,7 +22,7 @@ config SND_SB16_DSP · 21 unmodified lines | |||
| 22 | menuconfig SND_ISA | 22 | menuconfig SND_ISA |
| 23 | bool "ISA sound devices" | 23 | bool "ISA sound devices" |
| 24 | depends on ISA || COMPILE_TEST | 24 | depends on ISA || COMPILE_TEST |
| 25 | depends on ISA_DMA_API && !M68K | 25 | depends on ISA_DMA_API |
| 26 | default y | 26 | default y |
| 27 | help | 27 | help |
| 28 | Support for sound devices connected via the ISA bus. | 28 | Support for sound devices connected via the ISA bus. |