Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * arch/m68k/mvme16x/config.c |
| 3 | * |
| 4 | * Copyright (C) 1995 Richard Hirst [richard@sleepie.demon.co.uk] |
| 5 | * |
| 6 | * Based on: |
| 7 | * |
| 8 | * linux/amiga/config.c |
| 9 | * |
| 10 | * Copyright (C) 1993 Hamish Macdonald |
| 11 | * |
| 12 | * This file is subject to the terms and conditions of the GNU General Public |
| 13 | * License. See the file README.legal in the main directory of this archive |
| 14 | * for more details. |
| 15 | */ |
| 16 | |
| 17 | #include <linux/types.h> |
| 18 | #include <linux/kernel.h> |
| 19 | #include <linux/mm.h> |
Alexey Dobriyan | 813dcf7 | 2008-10-03 22:42:36 +0400 | [diff] [blame] | 20 | #include <linux/seq_file.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 21 | #include <linux/tty.h> |
| 22 | #include <linux/console.h> |
| 23 | #include <linux/linkage.h> |
| 24 | #include <linux/init.h> |
| 25 | #include <linux/major.h> |
| 26 | #include <linux/genhd.h> |
| 27 | #include <linux/rtc.h> |
| 28 | #include <linux/interrupt.h> |
Adrian Bunk | 612e484 | 2008-02-04 22:30:27 -0800 | [diff] [blame] | 29 | #include <linux/module.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | |
| 31 | #include <asm/bootinfo.h> |
Geert Uytterhoeven | 4c3c522 | 2013-10-02 11:37:33 +0200 | [diff] [blame] | 32 | #include <asm/bootinfo-vme.h> |
Geert Uytterhoeven | abe4810 | 2013-10-04 11:41:24 +0200 | [diff] [blame] | 33 | #include <asm/byteorder.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | #include <asm/pgtable.h> |
| 35 | #include <asm/setup.h> |
| 36 | #include <asm/irq.h> |
| 37 | #include <asm/traps.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | #include <asm/machdep.h> |
| 39 | #include <asm/mvme16xhw.h> |
| 40 | |
| 41 | extern t_bdid mvme_bdid; |
| 42 | |
| 43 | static MK48T08ptr_t volatile rtc = (MK48T08ptr_t)MVME_RTC_BASE; |
| 44 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | static void mvme16x_get_model(char *model); |
David Howells | 40220c1 | 2006-10-09 12:19:47 +0100 | [diff] [blame] | 46 | extern void mvme16x_sched_init(irq_handler_t handler); |
Stephen Warren | c8d5ba1 | 2012-11-08 11:34:55 -0700 | [diff] [blame] | 47 | extern u32 mvme16x_gettimeoffset(void); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | extern int mvme16x_hwclk (int, struct rtc_time *); |
| 49 | extern int mvme16x_set_clock_mmss (unsigned long); |
| 50 | extern void mvme16x_reset (void); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 51 | |
| 52 | int bcd2int (unsigned char b); |
| 53 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | |
| 55 | unsigned short mvme16x_config; |
Adrian Bunk | 612e484 | 2008-02-04 22:30:27 -0800 | [diff] [blame] | 56 | EXPORT_SYMBOL(mvme16x_config); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | |
| 58 | |
Geert Uytterhoeven | a4df02a | 2013-06-25 21:15:24 +0200 | [diff] [blame] | 59 | int __init mvme16x_parse_bootinfo(const struct bi_record *bi) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | { |
Geert Uytterhoeven | abe4810 | 2013-10-04 11:41:24 +0200 | [diff] [blame] | 61 | uint16_t tag = be16_to_cpu(bi->tag); |
| 62 | if (tag == BI_VME_TYPE || tag == BI_VME_BRDINFO) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | return 0; |
| 64 | else |
| 65 | return 1; |
| 66 | } |
| 67 | |
| 68 | void mvme16x_reset(void) |
| 69 | { |
Geert Uytterhoeven | 3c8bc6b | 2016-12-06 17:10:23 +0100 | [diff] [blame] | 70 | pr_info("\r\n\nCalled mvme16x_reset\r\n" |
| 71 | "\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | /* The string of returns is to delay the reset until the whole |
| 73 | * message is output. Assert reset bit in GCSR */ |
| 74 | *(volatile char *)0xfff40107 = 0x80; |
| 75 | } |
| 76 | |
| 77 | static void mvme16x_get_model(char *model) |
| 78 | { |
| 79 | p_bdid p = &mvme_bdid; |
| 80 | char suf[4]; |
| 81 | |
| 82 | suf[1] = p->brdsuffix[0]; |
| 83 | suf[2] = p->brdsuffix[1]; |
| 84 | suf[3] = '\0'; |
| 85 | suf[0] = suf[1] ? '-' : '\0'; |
| 86 | |
Geert Uytterhoeven | abe4810 | 2013-10-04 11:41:24 +0200 | [diff] [blame] | 87 | sprintf(model, "Motorola MVME%x%s", be16_to_cpu(p->brdno), suf); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | } |
| 89 | |
| 90 | |
Alexey Dobriyan | 813dcf7 | 2008-10-03 22:42:36 +0400 | [diff] [blame] | 91 | static void mvme16x_get_hardware_list(struct seq_file *m) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 92 | { |
Geert Uytterhoeven | abe4810 | 2013-10-04 11:41:24 +0200 | [diff] [blame] | 93 | uint16_t brdno = be16_to_cpu(mvme_bdid.brdno); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | |
Geert Uytterhoeven | abe4810 | 2013-10-04 11:41:24 +0200 | [diff] [blame] | 95 | if (brdno == 0x0162 || brdno == 0x0172) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | { |
| 97 | unsigned char rev = *(unsigned char *)MVME162_VERSION_REG; |
| 98 | |
Alexey Dobriyan | 813dcf7 | 2008-10-03 22:42:36 +0400 | [diff] [blame] | 99 | seq_printf (m, "VMEchip2 %spresent\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | rev & MVME16x_CONFIG_NO_VMECHIP2 ? "NOT " : ""); |
Alexey Dobriyan | 813dcf7 | 2008-10-03 22:42:36 +0400 | [diff] [blame] | 101 | seq_printf (m, "SCSI interface %spresent\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | rev & MVME16x_CONFIG_NO_SCSICHIP ? "NOT " : ""); |
Alexey Dobriyan | 813dcf7 | 2008-10-03 22:42:36 +0400 | [diff] [blame] | 103 | seq_printf (m, "Ethernet i/f %spresent\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | rev & MVME16x_CONFIG_NO_ETHERNET ? "NOT " : ""); |
| 105 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | } |
| 107 | |
Roman Zippel | 200a3d3 | 2006-06-25 05:47:06 -0700 | [diff] [blame] | 108 | /* |
| 109 | * This function is called during kernel startup to initialize |
| 110 | * the mvme16x IRQ handling routines. Should probably ensure |
| 111 | * that the base vectors for the VMEChip2 and PCCChip2 are valid. |
| 112 | */ |
| 113 | |
Al Viro | 66a3f82 | 2007-07-20 04:33:28 +0100 | [diff] [blame] | 114 | static void __init mvme16x_init_IRQ (void) |
Roman Zippel | 200a3d3 | 2006-06-25 05:47:06 -0700 | [diff] [blame] | 115 | { |
Geert Uytterhoeven | f30a648 | 2011-09-11 11:54:50 +0200 | [diff] [blame] | 116 | m68k_setup_user_interrupt(VEC_USER, 192); |
Roman Zippel | 200a3d3 | 2006-06-25 05:47:06 -0700 | [diff] [blame] | 117 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | |
| 119 | #define pcc2chip ((volatile u_char *)0xfff42000) |
| 120 | #define PccSCCMICR 0x1d |
| 121 | #define PccSCCTICR 0x1e |
| 122 | #define PccSCCRICR 0x1f |
Kars de Jong | f999489 | 2008-11-20 13:47:18 +0100 | [diff] [blame] | 123 | #define PccTPIACKR 0x25 |
| 124 | |
| 125 | #ifdef CONFIG_EARLY_PRINTK |
| 126 | |
| 127 | /**** cd2401 registers ****/ |
| 128 | #define CD2401_ADDR (0xfff45000) |
| 129 | |
| 130 | #define CyGFRCR (0x81) |
| 131 | #define CyCCR (0x13) |
| 132 | #define CyCLR_CHAN (0x40) |
| 133 | #define CyINIT_CHAN (0x20) |
| 134 | #define CyCHIP_RESET (0x10) |
| 135 | #define CyENB_XMTR (0x08) |
| 136 | #define CyDIS_XMTR (0x04) |
| 137 | #define CyENB_RCVR (0x02) |
| 138 | #define CyDIS_RCVR (0x01) |
| 139 | #define CyCAR (0xee) |
| 140 | #define CyIER (0x11) |
| 141 | #define CyMdmCh (0x80) |
| 142 | #define CyRxExc (0x20) |
| 143 | #define CyRxData (0x08) |
| 144 | #define CyTxMpty (0x02) |
| 145 | #define CyTxRdy (0x01) |
| 146 | #define CyLICR (0x26) |
| 147 | #define CyRISR (0x89) |
| 148 | #define CyTIMEOUT (0x80) |
| 149 | #define CySPECHAR (0x70) |
| 150 | #define CyOVERRUN (0x08) |
| 151 | #define CyPARITY (0x04) |
| 152 | #define CyFRAME (0x02) |
| 153 | #define CyBREAK (0x01) |
| 154 | #define CyREOIR (0x84) |
| 155 | #define CyTEOIR (0x85) |
| 156 | #define CyMEOIR (0x86) |
| 157 | #define CyNOTRANS (0x08) |
| 158 | #define CyRFOC (0x30) |
| 159 | #define CyRDR (0xf8) |
| 160 | #define CyTDR (0xf8) |
| 161 | #define CyMISR (0x8b) |
| 162 | #define CyRISR (0x89) |
| 163 | #define CyTISR (0x8a) |
| 164 | #define CyMSVR1 (0xde) |
| 165 | #define CyMSVR2 (0xdf) |
| 166 | #define CyDSR (0x80) |
| 167 | #define CyDCD (0x40) |
| 168 | #define CyCTS (0x20) |
| 169 | #define CyDTR (0x02) |
| 170 | #define CyRTS (0x01) |
| 171 | #define CyRTPRL (0x25) |
| 172 | #define CyRTPRH (0x24) |
| 173 | #define CyCOR1 (0x10) |
| 174 | #define CyPARITY_NONE (0x00) |
| 175 | #define CyPARITY_E (0x40) |
| 176 | #define CyPARITY_O (0xC0) |
| 177 | #define Cy_5_BITS (0x04) |
| 178 | #define Cy_6_BITS (0x05) |
| 179 | #define Cy_7_BITS (0x06) |
| 180 | #define Cy_8_BITS (0x07) |
| 181 | #define CyCOR2 (0x17) |
| 182 | #define CyETC (0x20) |
| 183 | #define CyCtsAE (0x02) |
| 184 | #define CyCOR3 (0x16) |
| 185 | #define Cy_1_STOP (0x02) |
| 186 | #define Cy_2_STOP (0x04) |
| 187 | #define CyCOR4 (0x15) |
| 188 | #define CyREC_FIFO (0x0F) /* Receive FIFO threshold */ |
| 189 | #define CyCOR5 (0x14) |
| 190 | #define CyCOR6 (0x18) |
| 191 | #define CyCOR7 (0x07) |
| 192 | #define CyRBPR (0xcb) |
| 193 | #define CyRCOR (0xc8) |
| 194 | #define CyTBPR (0xc3) |
| 195 | #define CyTCOR (0xc0) |
| 196 | #define CySCHR1 (0x1f) |
| 197 | #define CySCHR2 (0x1e) |
| 198 | #define CyTPR (0xda) |
| 199 | #define CyPILR1 (0xe3) |
| 200 | #define CyPILR2 (0xe0) |
| 201 | #define CyPILR3 (0xe1) |
| 202 | #define CyCMR (0x1b) |
| 203 | #define CyASYNC (0x02) |
| 204 | #define CyLICR (0x26) |
| 205 | #define CyLIVR (0x09) |
| 206 | #define CySCRL (0x23) |
| 207 | #define CySCRH (0x22) |
| 208 | #define CyTFTC (0x80) |
| 209 | |
Finn Thain | c46f46d | 2014-04-12 23:49:30 +1000 | [diff] [blame] | 210 | void mvme16x_cons_write(struct console *co, const char *str, unsigned count) |
Kars de Jong | f999489 | 2008-11-20 13:47:18 +0100 | [diff] [blame] | 211 | { |
| 212 | volatile unsigned char *base_addr = (u_char *)CD2401_ADDR; |
| 213 | volatile u_char sink; |
| 214 | u_char ier; |
| 215 | int port; |
| 216 | u_char do_lf = 0; |
| 217 | int i = 0; |
| 218 | |
| 219 | /* Ensure transmitter is enabled! */ |
| 220 | |
| 221 | port = 0; |
| 222 | base_addr[CyCAR] = (u_char)port; |
| 223 | while (base_addr[CyCCR]) |
| 224 | ; |
| 225 | base_addr[CyCCR] = CyENB_XMTR; |
| 226 | |
| 227 | ier = base_addr[CyIER]; |
| 228 | base_addr[CyIER] = CyTxMpty; |
| 229 | |
| 230 | while (1) { |
| 231 | if (pcc2chip[PccSCCTICR] & 0x20) |
| 232 | { |
| 233 | /* We have a Tx int. Acknowledge it */ |
| 234 | sink = pcc2chip[PccTPIACKR]; |
| 235 | if ((base_addr[CyLICR] >> 2) == port) { |
| 236 | if (i == count) { |
| 237 | /* Last char of string is now output */ |
| 238 | base_addr[CyTEOIR] = CyNOTRANS; |
| 239 | break; |
| 240 | } |
| 241 | if (do_lf) { |
| 242 | base_addr[CyTDR] = '\n'; |
| 243 | str++; |
| 244 | i++; |
| 245 | do_lf = 0; |
| 246 | } |
| 247 | else if (*str == '\n') { |
| 248 | base_addr[CyTDR] = '\r'; |
| 249 | do_lf = 1; |
| 250 | } |
| 251 | else { |
| 252 | base_addr[CyTDR] = *str++; |
| 253 | i++; |
| 254 | } |
| 255 | base_addr[CyTEOIR] = 0; |
| 256 | } |
| 257 | else |
| 258 | base_addr[CyTEOIR] = CyNOTRANS; |
| 259 | } |
| 260 | } |
| 261 | |
| 262 | base_addr[CyIER] = ier; |
| 263 | } |
| 264 | |
Kars de Jong | f999489 | 2008-11-20 13:47:18 +0100 | [diff] [blame] | 265 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 266 | |
| 267 | void __init config_mvme16x(void) |
| 268 | { |
| 269 | p_bdid p = &mvme_bdid; |
| 270 | char id[40]; |
Geert Uytterhoeven | abe4810 | 2013-10-04 11:41:24 +0200 | [diff] [blame] | 271 | uint16_t brdno = be16_to_cpu(p->brdno); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | |
| 273 | mach_max_dma_address = 0xffffffff; |
| 274 | mach_sched_init = mvme16x_sched_init; |
| 275 | mach_init_IRQ = mvme16x_init_IRQ; |
Stephen Warren | c8d5ba1 | 2012-11-08 11:34:55 -0700 | [diff] [blame] | 276 | arch_gettimeoffset = mvme16x_gettimeoffset; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 277 | mach_hwclk = mvme16x_hwclk; |
| 278 | mach_set_clock_mmss = mvme16x_set_clock_mmss; |
| 279 | mach_reset = mvme16x_reset; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 280 | mach_get_model = mvme16x_get_model; |
| 281 | mach_get_hardware_list = mvme16x_get_hardware_list; |
| 282 | |
| 283 | /* Report board revision */ |
| 284 | |
| 285 | if (strncmp("BDID", p->bdid, 4)) |
| 286 | { |
Geert Uytterhoeven | 3c8bc6b | 2016-12-06 17:10:23 +0100 | [diff] [blame] | 287 | pr_crit("Bug call .BRD_ID returned garbage - giving up\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 288 | while (1) |
| 289 | ; |
| 290 | } |
| 291 | /* Board type is only set by newer versions of vmelilo/tftplilo */ |
| 292 | if (vme_brdtype == 0) |
Geert Uytterhoeven | abe4810 | 2013-10-04 11:41:24 +0200 | [diff] [blame] | 293 | vme_brdtype = brdno; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 294 | |
| 295 | mvme16x_get_model(id); |
Geert Uytterhoeven | 3c8bc6b | 2016-12-06 17:10:23 +0100 | [diff] [blame] | 296 | pr_info("BRD_ID: %s BUG %x.%x %02x/%02x/%02x\n", id, p->rev >> 4, |
| 297 | p->rev & 0xf, p->yr, p->mth, p->day); |
Geert Uytterhoeven | abe4810 | 2013-10-04 11:41:24 +0200 | [diff] [blame] | 298 | if (brdno == 0x0162 || brdno == 0x172) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 299 | { |
| 300 | unsigned char rev = *(unsigned char *)MVME162_VERSION_REG; |
| 301 | |
| 302 | mvme16x_config = rev | MVME16x_CONFIG_GOT_SCCA; |
| 303 | |
Geert Uytterhoeven | 3c8bc6b | 2016-12-06 17:10:23 +0100 | [diff] [blame] | 304 | pr_info("MVME%x Hardware status:\n", brdno); |
| 305 | pr_info(" CPU Type 68%s040\n", |
| 306 | rev & MVME16x_CONFIG_GOT_FPU ? "" : "LC"); |
| 307 | pr_info(" CPU clock %dMHz\n", |
| 308 | rev & MVME16x_CONFIG_SPEED_32 ? 32 : 25); |
| 309 | pr_info(" VMEchip2 %spresent\n", |
| 310 | rev & MVME16x_CONFIG_NO_VMECHIP2 ? "NOT " : ""); |
| 311 | pr_info(" SCSI interface %spresent\n", |
| 312 | rev & MVME16x_CONFIG_NO_SCSICHIP ? "NOT " : ""); |
| 313 | pr_info(" Ethernet interface %spresent\n", |
| 314 | rev & MVME16x_CONFIG_NO_ETHERNET ? "NOT " : ""); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 315 | } |
| 316 | else |
| 317 | { |
| 318 | mvme16x_config = MVME16x_CONFIG_GOT_LP | MVME16x_CONFIG_GOT_CD2401; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | } |
| 320 | } |
| 321 | |
Al Viro | 2850bc2 | 2006-10-07 14:16:45 +0100 | [diff] [blame] | 322 | static irqreturn_t mvme16x_abort_int (int irq, void *dev_id) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 323 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 324 | unsigned long *new = (unsigned long *)vectors; |
| 325 | unsigned long *old = (unsigned long *)0xffe00000; |
| 326 | volatile unsigned char uc, *ucp; |
Geert Uytterhoeven | abe4810 | 2013-10-04 11:41:24 +0200 | [diff] [blame] | 327 | uint16_t brdno = be16_to_cpu(mvme_bdid.brdno); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 328 | |
Geert Uytterhoeven | abe4810 | 2013-10-04 11:41:24 +0200 | [diff] [blame] | 329 | if (brdno == 0x0162 || brdno == 0x172) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 330 | { |
| 331 | ucp = (volatile unsigned char *)0xfff42043; |
| 332 | uc = *ucp | 8; |
| 333 | *ucp = uc; |
| 334 | } |
| 335 | else |
| 336 | { |
| 337 | *(volatile unsigned long *)0xfff40074 = 0x40000000; |
| 338 | } |
| 339 | *(new+4) = *(old+4); /* Illegal instruction */ |
| 340 | *(new+9) = *(old+9); /* Trace */ |
| 341 | *(new+47) = *(old+47); /* Trap #15 */ |
| 342 | |
Geert Uytterhoeven | abe4810 | 2013-10-04 11:41:24 +0200 | [diff] [blame] | 343 | if (brdno == 0x0162 || brdno == 0x172) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 344 | *(new+0x5e) = *(old+0x5e); /* ABORT switch */ |
| 345 | else |
| 346 | *(new+0x6e) = *(old+0x6e); /* ABORT switch */ |
| 347 | return IRQ_HANDLED; |
| 348 | } |
| 349 | |
Al Viro | 2850bc2 | 2006-10-07 14:16:45 +0100 | [diff] [blame] | 350 | static irqreturn_t mvme16x_timer_int (int irq, void *dev_id) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | { |
Finn Thain | 4127249 | 2018-12-01 11:53:10 +1100 | [diff] [blame] | 352 | irq_handler_t timer_routine = dev_id; |
| 353 | unsigned long flags; |
| 354 | |
| 355 | local_irq_save(flags); |
| 356 | *(volatile unsigned char *)0xfff4201b |= 8; |
| 357 | timer_routine(0, NULL); |
| 358 | local_irq_restore(flags); |
| 359 | |
| 360 | return IRQ_HANDLED; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 361 | } |
| 362 | |
David Howells | 40220c1 | 2006-10-09 12:19:47 +0100 | [diff] [blame] | 363 | void mvme16x_sched_init (irq_handler_t timer_routine) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 364 | { |
Geert Uytterhoeven | abe4810 | 2013-10-04 11:41:24 +0200 | [diff] [blame] | 365 | uint16_t brdno = be16_to_cpu(mvme_bdid.brdno); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 366 | int irq; |
| 367 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 368 | /* Using PCCchip2 or MC2 chip tick timer 1 */ |
| 369 | *(volatile unsigned long *)0xfff42008 = 0; |
| 370 | *(volatile unsigned long *)0xfff42004 = 10000; /* 10ms */ |
| 371 | *(volatile unsigned char *)0xfff42017 |= 3; |
| 372 | *(volatile unsigned char *)0xfff4201b = 0x16; |
Finn Thain | 4127249 | 2018-12-01 11:53:10 +1100 | [diff] [blame] | 373 | if (request_irq(MVME16x_IRQ_TIMER, mvme16x_timer_int, 0, "timer", |
| 374 | timer_routine)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 375 | panic ("Couldn't register timer int"); |
| 376 | |
Geert Uytterhoeven | abe4810 | 2013-10-04 11:41:24 +0200 | [diff] [blame] | 377 | if (brdno == 0x0162 || brdno == 0x172) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 378 | irq = MVME162_IRQ_ABORT; |
| 379 | else |
| 380 | irq = MVME167_IRQ_ABORT; |
| 381 | if (request_irq(irq, mvme16x_abort_int, 0, |
| 382 | "abort", mvme16x_abort_int)) |
| 383 | panic ("Couldn't register abort int"); |
| 384 | } |
| 385 | |
| 386 | |
| 387 | /* This is always executed with interrupts disabled. */ |
Stephen Warren | c8d5ba1 | 2012-11-08 11:34:55 -0700 | [diff] [blame] | 388 | u32 mvme16x_gettimeoffset(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 389 | { |
Stephen Warren | c8d5ba1 | 2012-11-08 11:34:55 -0700 | [diff] [blame] | 390 | return (*(volatile u32 *)0xfff42008) * 1000; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 391 | } |
| 392 | |
| 393 | int bcd2int (unsigned char b) |
| 394 | { |
| 395 | return ((b>>4)*10 + (b&15)); |
| 396 | } |
| 397 | |
| 398 | int mvme16x_hwclk(int op, struct rtc_time *t) |
| 399 | { |
| 400 | #warning check me! |
| 401 | if (!op) { |
| 402 | rtc->ctrl = RTC_READ; |
| 403 | t->tm_year = bcd2int (rtc->bcd_year); |
| 404 | t->tm_mon = bcd2int (rtc->bcd_mth); |
| 405 | t->tm_mday = bcd2int (rtc->bcd_dom); |
| 406 | t->tm_hour = bcd2int (rtc->bcd_hr); |
| 407 | t->tm_min = bcd2int (rtc->bcd_min); |
| 408 | t->tm_sec = bcd2int (rtc->bcd_sec); |
| 409 | rtc->ctrl = 0; |
| 410 | } |
| 411 | return 0; |
| 412 | } |
| 413 | |
| 414 | int mvme16x_set_clock_mmss (unsigned long nowtime) |
| 415 | { |
| 416 | return 0; |
| 417 | } |
| 418 | |