diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /arch/m68k/mvme16x |
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'arch/m68k/mvme16x')
-rw-r--r-- | arch/m68k/mvme16x/16xints.c | 149 | ||||
-rw-r--r-- | arch/m68k/mvme16x/Makefile | 5 | ||||
-rw-r--r-- | arch/m68k/mvme16x/config.c | 286 | ||||
-rw-r--r-- | arch/m68k/mvme16x/mvme16x_ksyms.c | 6 | ||||
-rw-r--r-- | arch/m68k/mvme16x/rtc.c | 172 |
5 files changed, 618 insertions, 0 deletions
diff --git a/arch/m68k/mvme16x/16xints.c b/arch/m68k/mvme16x/16xints.c new file mode 100644 index 000000000000..793ef735b59c --- /dev/null +++ b/arch/m68k/mvme16x/16xints.c | |||
@@ -0,0 +1,149 @@ | |||
1 | /* | ||
2 | * arch/m68k/mvme16x/16xints.c | ||
3 | * | ||
4 | * Copyright (C) 1995 Richard Hirst [richard@sleepie.demon.co.uk] | ||
5 | * | ||
6 | * based on amiints.c -- Amiga Linux interrupt handling code | ||
7 | * | ||
8 | * This file is subject to the terms and conditions of the GNU General Public | ||
9 | * License. See the file README.legal in the main directory of this archive | ||
10 | * for more details. | ||
11 | * | ||
12 | */ | ||
13 | |||
14 | #include <linux/types.h> | ||
15 | #include <linux/kernel.h> | ||
16 | #include <linux/errno.h> | ||
17 | #include <linux/seq_file.h> | ||
18 | |||
19 | #include <asm/system.h> | ||
20 | #include <asm/ptrace.h> | ||
21 | #include <asm/irq.h> | ||
22 | |||
23 | static irqreturn_t mvme16x_defhand (int irq, void *dev_id, struct pt_regs *fp); | ||
24 | |||
25 | /* | ||
26 | * This should ideally be 4 elements only, for speed. | ||
27 | */ | ||
28 | |||
29 | static struct { | ||
30 | irqreturn_t (*handler)(int, void *, struct pt_regs *); | ||
31 | unsigned long flags; | ||
32 | void *dev_id; | ||
33 | const char *devname; | ||
34 | unsigned count; | ||
35 | } irq_tab[192]; | ||
36 | |||
37 | /* | ||
38 | * void mvme16x_init_IRQ (void) | ||
39 | * | ||
40 | * Parameters: None | ||
41 | * | ||
42 | * Returns: Nothing | ||
43 | * | ||
44 | * This function is called during kernel startup to initialize | ||
45 | * the mvme16x IRQ handling routines. Should probably ensure | ||
46 | * that the base vectors for the VMEChip2 and PCCChip2 are valid. | ||
47 | */ | ||
48 | |||
49 | void mvme16x_init_IRQ (void) | ||
50 | { | ||
51 | int i; | ||
52 | |||
53 | for (i = 0; i < 192; i++) { | ||
54 | irq_tab[i].handler = mvme16x_defhand; | ||
55 | irq_tab[i].flags = IRQ_FLG_STD; | ||
56 | irq_tab[i].dev_id = NULL; | ||
57 | irq_tab[i].devname = NULL; | ||
58 | irq_tab[i].count = 0; | ||
59 | } | ||
60 | } | ||
61 | |||
62 | int mvme16x_request_irq(unsigned int irq, | ||
63 | irqreturn_t (*handler)(int, void *, struct pt_regs *), | ||
64 | unsigned long flags, const char *devname, void *dev_id) | ||
65 | { | ||
66 | if (irq < 64 || irq > 255) { | ||
67 | printk("%s: Incorrect IRQ %d from %s\n", __FUNCTION__, irq, devname); | ||
68 | return -ENXIO; | ||
69 | } | ||
70 | |||
71 | if (!(irq_tab[irq-64].flags & IRQ_FLG_STD)) { | ||
72 | if (irq_tab[irq-64].flags & IRQ_FLG_LOCK) { | ||
73 | printk("%s: IRQ %d from %s is not replaceable\n", | ||
74 | __FUNCTION__, irq, irq_tab[irq-64].devname); | ||
75 | return -EBUSY; | ||
76 | } | ||
77 | if (flags & IRQ_FLG_REPLACE) { | ||
78 | printk("%s: %s can't replace IRQ %d from %s\n", | ||
79 | __FUNCTION__, devname, irq, irq_tab[irq-64].devname); | ||
80 | return -EBUSY; | ||
81 | } | ||
82 | } | ||
83 | irq_tab[irq-64].handler = handler; | ||
84 | irq_tab[irq-64].flags = flags; | ||
85 | irq_tab[irq-64].dev_id = dev_id; | ||
86 | irq_tab[irq-64].devname = devname; | ||
87 | return 0; | ||
88 | } | ||
89 | |||
90 | void mvme16x_free_irq(unsigned int irq, void *dev_id) | ||
91 | { | ||
92 | if (irq < 64 || irq > 255) { | ||
93 | printk("%s: Incorrect IRQ %d\n", __FUNCTION__, irq); | ||
94 | return; | ||
95 | } | ||
96 | |||
97 | if (irq_tab[irq-64].dev_id != dev_id) | ||
98 | printk("%s: Removing probably wrong IRQ %d from %s\n", | ||
99 | __FUNCTION__, irq, irq_tab[irq-64].devname); | ||
100 | |||
101 | irq_tab[irq-64].handler = mvme16x_defhand; | ||
102 | irq_tab[irq-64].flags = IRQ_FLG_STD; | ||
103 | irq_tab[irq-64].dev_id = NULL; | ||
104 | irq_tab[irq-64].devname = NULL; | ||
105 | } | ||
106 | |||
107 | irqreturn_t mvme16x_process_int (unsigned long vec, struct pt_regs *fp) | ||
108 | { | ||
109 | if (vec < 64 || vec > 255) { | ||
110 | printk ("mvme16x_process_int: Illegal vector %ld", vec); | ||
111 | return IRQ_NONE; | ||
112 | } else { | ||
113 | irq_tab[vec-64].count++; | ||
114 | irq_tab[vec-64].handler(vec, irq_tab[vec-64].dev_id, fp); | ||
115 | return IRQ_HANDLED; | ||
116 | } | ||
117 | } | ||
118 | |||
119 | int show_mvme16x_interrupts (struct seq_file *p, void *v) | ||
120 | { | ||
121 | int i; | ||
122 | |||
123 | for (i = 0; i < 192; i++) { | ||
124 | if (irq_tab[i].count) | ||
125 | seq_printf(p, "Vec 0x%02x: %8d %s\n", | ||
126 | i+64, irq_tab[i].count, | ||
127 | irq_tab[i].devname ? irq_tab[i].devname : "free"); | ||
128 | } | ||
129 | return 0; | ||
130 | } | ||
131 | |||
132 | |||
133 | static irqreturn_t mvme16x_defhand (int irq, void *dev_id, struct pt_regs *fp) | ||
134 | { | ||
135 | printk ("Unknown interrupt 0x%02x\n", irq); | ||
136 | return IRQ_NONE; | ||
137 | } | ||
138 | |||
139 | |||
140 | void mvme16x_enable_irq (unsigned int irq) | ||
141 | { | ||
142 | } | ||
143 | |||
144 | |||
145 | void mvme16x_disable_irq (unsigned int irq) | ||
146 | { | ||
147 | } | ||
148 | |||
149 | |||
diff --git a/arch/m68k/mvme16x/Makefile b/arch/m68k/mvme16x/Makefile new file mode 100644 index 000000000000..5129f56b64a3 --- /dev/null +++ b/arch/m68k/mvme16x/Makefile | |||
@@ -0,0 +1,5 @@ | |||
1 | # | ||
2 | # Makefile for Linux arch/m68k/mvme16x source directory | ||
3 | # | ||
4 | |||
5 | obj-y := config.o 16xints.o rtc.o mvme16x_ksyms.o | ||
diff --git a/arch/m68k/mvme16x/config.c b/arch/m68k/mvme16x/config.c new file mode 100644 index 000000000000..26ce81c1337d --- /dev/null +++ b/arch/m68k/mvme16x/config.c | |||
@@ -0,0 +1,286 @@ | |||
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> | ||
20 | #include <linux/tty.h> | ||
21 | #include <linux/console.h> | ||
22 | #include <linux/linkage.h> | ||
23 | #include <linux/init.h> | ||
24 | #include <linux/major.h> | ||
25 | #include <linux/genhd.h> | ||
26 | #include <linux/rtc.h> | ||
27 | #include <linux/interrupt.h> | ||
28 | |||
29 | #include <asm/bootinfo.h> | ||
30 | #include <asm/system.h> | ||
31 | #include <asm/pgtable.h> | ||
32 | #include <asm/setup.h> | ||
33 | #include <asm/irq.h> | ||
34 | #include <asm/traps.h> | ||
35 | #include <asm/rtc.h> | ||
36 | #include <asm/machdep.h> | ||
37 | #include <asm/mvme16xhw.h> | ||
38 | |||
39 | extern t_bdid mvme_bdid; | ||
40 | |||
41 | static MK48T08ptr_t volatile rtc = (MK48T08ptr_t)MVME_RTC_BASE; | ||
42 | |||
43 | extern irqreturn_t mvme16x_process_int (int level, struct pt_regs *regs); | ||
44 | extern void mvme16x_init_IRQ (void); | ||
45 | extern void mvme16x_free_irq (unsigned int, void *); | ||
46 | extern int show_mvme16x_interrupts (struct seq_file *, void *); | ||
47 | extern void mvme16x_enable_irq (unsigned int); | ||
48 | extern void mvme16x_disable_irq (unsigned int); | ||
49 | static void mvme16x_get_model(char *model); | ||
50 | static int mvme16x_get_hardware_list(char *buffer); | ||
51 | extern int mvme16x_request_irq(unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *), unsigned long flags, const char *devname, void *dev_id); | ||
52 | extern void mvme16x_sched_init(irqreturn_t (*handler)(int, void *, struct pt_regs *)); | ||
53 | extern unsigned long mvme16x_gettimeoffset (void); | ||
54 | extern int mvme16x_hwclk (int, struct rtc_time *); | ||
55 | extern int mvme16x_set_clock_mmss (unsigned long); | ||
56 | extern void mvme16x_reset (void); | ||
57 | extern void mvme16x_waitbut(void); | ||
58 | |||
59 | int bcd2int (unsigned char b); | ||
60 | |||
61 | /* Save tick handler routine pointer, will point to do_timer() in | ||
62 | * kernel/sched.c, called via mvme16x_process_int() */ | ||
63 | |||
64 | static irqreturn_t (*tick_handler)(int, void *, struct pt_regs *); | ||
65 | |||
66 | |||
67 | unsigned short mvme16x_config; | ||
68 | |||
69 | |||
70 | int mvme16x_parse_bootinfo(const struct bi_record *bi) | ||
71 | { | ||
72 | if (bi->tag == BI_VME_TYPE || bi->tag == BI_VME_BRDINFO) | ||
73 | return 0; | ||
74 | else | ||
75 | return 1; | ||
76 | } | ||
77 | |||
78 | void mvme16x_reset(void) | ||
79 | { | ||
80 | printk ("\r\n\nCalled mvme16x_reset\r\n" | ||
81 | "\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r"); | ||
82 | /* The string of returns is to delay the reset until the whole | ||
83 | * message is output. Assert reset bit in GCSR */ | ||
84 | *(volatile char *)0xfff40107 = 0x80; | ||
85 | } | ||
86 | |||
87 | static void mvme16x_get_model(char *model) | ||
88 | { | ||
89 | p_bdid p = &mvme_bdid; | ||
90 | char suf[4]; | ||
91 | |||
92 | suf[1] = p->brdsuffix[0]; | ||
93 | suf[2] = p->brdsuffix[1]; | ||
94 | suf[3] = '\0'; | ||
95 | suf[0] = suf[1] ? '-' : '\0'; | ||
96 | |||
97 | sprintf(model, "Motorola MVME%x%s", p->brdno, suf); | ||
98 | } | ||
99 | |||
100 | |||
101 | static int mvme16x_get_hardware_list(char *buffer) | ||
102 | { | ||
103 | p_bdid p = &mvme_bdid; | ||
104 | int len = 0; | ||
105 | |||
106 | if (p->brdno == 0x0162 || p->brdno == 0x0172) | ||
107 | { | ||
108 | unsigned char rev = *(unsigned char *)MVME162_VERSION_REG; | ||
109 | |||
110 | len += sprintf (buffer+len, "VMEchip2 %spresent\n", | ||
111 | rev & MVME16x_CONFIG_NO_VMECHIP2 ? "NOT " : ""); | ||
112 | len += sprintf (buffer+len, "SCSI interface %spresent\n", | ||
113 | rev & MVME16x_CONFIG_NO_SCSICHIP ? "NOT " : ""); | ||
114 | len += sprintf (buffer+len, "Ethernet i/f %spresent\n", | ||
115 | rev & MVME16x_CONFIG_NO_ETHERNET ? "NOT " : ""); | ||
116 | } | ||
117 | else | ||
118 | *buffer = '\0'; | ||
119 | |||
120 | return (len); | ||
121 | } | ||
122 | |||
123 | |||
124 | #define pcc2chip ((volatile u_char *)0xfff42000) | ||
125 | #define PccSCCMICR 0x1d | ||
126 | #define PccSCCTICR 0x1e | ||
127 | #define PccSCCRICR 0x1f | ||
128 | |||
129 | void __init config_mvme16x(void) | ||
130 | { | ||
131 | p_bdid p = &mvme_bdid; | ||
132 | char id[40]; | ||
133 | |||
134 | mach_max_dma_address = 0xffffffff; | ||
135 | mach_sched_init = mvme16x_sched_init; | ||
136 | mach_init_IRQ = mvme16x_init_IRQ; | ||
137 | mach_gettimeoffset = mvme16x_gettimeoffset; | ||
138 | mach_hwclk = mvme16x_hwclk; | ||
139 | mach_set_clock_mmss = mvme16x_set_clock_mmss; | ||
140 | mach_reset = mvme16x_reset; | ||
141 | mach_free_irq = mvme16x_free_irq; | ||
142 | mach_process_int = mvme16x_process_int; | ||
143 | mach_get_irq_list = show_mvme16x_interrupts; | ||
144 | mach_request_irq = mvme16x_request_irq; | ||
145 | enable_irq = mvme16x_enable_irq; | ||
146 | disable_irq = mvme16x_disable_irq; | ||
147 | mach_get_model = mvme16x_get_model; | ||
148 | mach_get_hardware_list = mvme16x_get_hardware_list; | ||
149 | |||
150 | /* Report board revision */ | ||
151 | |||
152 | if (strncmp("BDID", p->bdid, 4)) | ||
153 | { | ||
154 | printk ("\n\nBug call .BRD_ID returned garbage - giving up\n\n"); | ||
155 | while (1) | ||
156 | ; | ||
157 | } | ||
158 | /* Board type is only set by newer versions of vmelilo/tftplilo */ | ||
159 | if (vme_brdtype == 0) | ||
160 | vme_brdtype = p->brdno; | ||
161 | |||
162 | mvme16x_get_model(id); | ||
163 | printk ("\nBRD_ID: %s BUG %x.%x %02x/%02x/%02x\n", id, p->rev>>4, | ||
164 | p->rev&0xf, p->yr, p->mth, p->day); | ||
165 | if (p->brdno == 0x0162 || p->brdno == 0x172) | ||
166 | { | ||
167 | unsigned char rev = *(unsigned char *)MVME162_VERSION_REG; | ||
168 | |||
169 | mvme16x_config = rev | MVME16x_CONFIG_GOT_SCCA; | ||
170 | |||
171 | printk ("MVME%x Hardware status:\n", p->brdno); | ||
172 | printk (" CPU Type 68%s040\n", | ||
173 | rev & MVME16x_CONFIG_GOT_FPU ? "" : "LC"); | ||
174 | printk (" CPU clock %dMHz\n", | ||
175 | rev & MVME16x_CONFIG_SPEED_32 ? 32 : 25); | ||
176 | printk (" VMEchip2 %spresent\n", | ||
177 | rev & MVME16x_CONFIG_NO_VMECHIP2 ? "NOT " : ""); | ||
178 | printk (" SCSI interface %spresent\n", | ||
179 | rev & MVME16x_CONFIG_NO_SCSICHIP ? "NOT " : ""); | ||
180 | printk (" Ethernet interface %spresent\n", | ||
181 | rev & MVME16x_CONFIG_NO_ETHERNET ? "NOT " : ""); | ||
182 | } | ||
183 | else | ||
184 | { | ||
185 | mvme16x_config = MVME16x_CONFIG_GOT_LP | MVME16x_CONFIG_GOT_CD2401; | ||
186 | |||
187 | /* Dont allow any interrupts from the CD2401 until the interrupt */ | ||
188 | /* handlers are installed */ | ||
189 | |||
190 | pcc2chip[PccSCCMICR] = 0x10; | ||
191 | pcc2chip[PccSCCTICR] = 0x10; | ||
192 | pcc2chip[PccSCCRICR] = 0x10; | ||
193 | } | ||
194 | } | ||
195 | |||
196 | static irqreturn_t mvme16x_abort_int (int irq, void *dev_id, struct pt_regs *fp) | ||
197 | { | ||
198 | p_bdid p = &mvme_bdid; | ||
199 | unsigned long *new = (unsigned long *)vectors; | ||
200 | unsigned long *old = (unsigned long *)0xffe00000; | ||
201 | volatile unsigned char uc, *ucp; | ||
202 | |||
203 | if (p->brdno == 0x0162 || p->brdno == 0x172) | ||
204 | { | ||
205 | ucp = (volatile unsigned char *)0xfff42043; | ||
206 | uc = *ucp | 8; | ||
207 | *ucp = uc; | ||
208 | } | ||
209 | else | ||
210 | { | ||
211 | *(volatile unsigned long *)0xfff40074 = 0x40000000; | ||
212 | } | ||
213 | *(new+4) = *(old+4); /* Illegal instruction */ | ||
214 | *(new+9) = *(old+9); /* Trace */ | ||
215 | *(new+47) = *(old+47); /* Trap #15 */ | ||
216 | |||
217 | if (p->brdno == 0x0162 || p->brdno == 0x172) | ||
218 | *(new+0x5e) = *(old+0x5e); /* ABORT switch */ | ||
219 | else | ||
220 | *(new+0x6e) = *(old+0x6e); /* ABORT switch */ | ||
221 | return IRQ_HANDLED; | ||
222 | } | ||
223 | |||
224 | static irqreturn_t mvme16x_timer_int (int irq, void *dev_id, struct pt_regs *fp) | ||
225 | { | ||
226 | *(volatile unsigned char *)0xfff4201b |= 8; | ||
227 | return tick_handler(irq, dev_id, fp); | ||
228 | } | ||
229 | |||
230 | void mvme16x_sched_init (irqreturn_t (*timer_routine)(int, void *, struct pt_regs *)) | ||
231 | { | ||
232 | p_bdid p = &mvme_bdid; | ||
233 | int irq; | ||
234 | |||
235 | tick_handler = timer_routine; | ||
236 | /* Using PCCchip2 or MC2 chip tick timer 1 */ | ||
237 | *(volatile unsigned long *)0xfff42008 = 0; | ||
238 | *(volatile unsigned long *)0xfff42004 = 10000; /* 10ms */ | ||
239 | *(volatile unsigned char *)0xfff42017 |= 3; | ||
240 | *(volatile unsigned char *)0xfff4201b = 0x16; | ||
241 | if (request_irq(MVME16x_IRQ_TIMER, mvme16x_timer_int, 0, | ||
242 | "timer", mvme16x_timer_int)) | ||
243 | panic ("Couldn't register timer int"); | ||
244 | |||
245 | if (p->brdno == 0x0162 || p->brdno == 0x172) | ||
246 | irq = MVME162_IRQ_ABORT; | ||
247 | else | ||
248 | irq = MVME167_IRQ_ABORT; | ||
249 | if (request_irq(irq, mvme16x_abort_int, 0, | ||
250 | "abort", mvme16x_abort_int)) | ||
251 | panic ("Couldn't register abort int"); | ||
252 | } | ||
253 | |||
254 | |||
255 | /* This is always executed with interrupts disabled. */ | ||
256 | unsigned long mvme16x_gettimeoffset (void) | ||
257 | { | ||
258 | return (*(volatile unsigned long *)0xfff42008); | ||
259 | } | ||
260 | |||
261 | int bcd2int (unsigned char b) | ||
262 | { | ||
263 | return ((b>>4)*10 + (b&15)); | ||
264 | } | ||
265 | |||
266 | int mvme16x_hwclk(int op, struct rtc_time *t) | ||
267 | { | ||
268 | #warning check me! | ||
269 | if (!op) { | ||
270 | rtc->ctrl = RTC_READ; | ||
271 | t->tm_year = bcd2int (rtc->bcd_year); | ||
272 | t->tm_mon = bcd2int (rtc->bcd_mth); | ||
273 | t->tm_mday = bcd2int (rtc->bcd_dom); | ||
274 | t->tm_hour = bcd2int (rtc->bcd_hr); | ||
275 | t->tm_min = bcd2int (rtc->bcd_min); | ||
276 | t->tm_sec = bcd2int (rtc->bcd_sec); | ||
277 | rtc->ctrl = 0; | ||
278 | } | ||
279 | return 0; | ||
280 | } | ||
281 | |||
282 | int mvme16x_set_clock_mmss (unsigned long nowtime) | ||
283 | { | ||
284 | return 0; | ||
285 | } | ||
286 | |||
diff --git a/arch/m68k/mvme16x/mvme16x_ksyms.c b/arch/m68k/mvme16x/mvme16x_ksyms.c new file mode 100644 index 000000000000..4a8a3634bb47 --- /dev/null +++ b/arch/m68k/mvme16x/mvme16x_ksyms.c | |||
@@ -0,0 +1,6 @@ | |||
1 | #include <linux/module.h> | ||
2 | #include <linux/types.h> | ||
3 | #include <asm/ptrace.h> | ||
4 | #include <asm/mvme16xhw.h> | ||
5 | |||
6 | EXPORT_SYMBOL(mvme16x_config); | ||
diff --git a/arch/m68k/mvme16x/rtc.c b/arch/m68k/mvme16x/rtc.c new file mode 100644 index 000000000000..8a2425069088 --- /dev/null +++ b/arch/m68k/mvme16x/rtc.c | |||
@@ -0,0 +1,172 @@ | |||
1 | /* | ||
2 | * Real Time Clock interface for Linux on the MVME16x | ||
3 | * | ||
4 | * Based on the PC driver by Paul Gortmaker. | ||
5 | */ | ||
6 | |||
7 | #define RTC_VERSION "1.00" | ||
8 | |||
9 | #include <linux/types.h> | ||
10 | #include <linux/errno.h> | ||
11 | #include <linux/miscdevice.h> | ||
12 | #include <linux/slab.h> | ||
13 | #include <linux/ioport.h> | ||
14 | #include <linux/fcntl.h> | ||
15 | #include <linux/init.h> | ||
16 | #include <linux/poll.h> | ||
17 | #include <linux/mc146818rtc.h> /* For struct rtc_time and ioctls, etc */ | ||
18 | #include <linux/smp_lock.h> | ||
19 | #include <asm/mvme16xhw.h> | ||
20 | |||
21 | #include <asm/io.h> | ||
22 | #include <asm/uaccess.h> | ||
23 | #include <asm/system.h> | ||
24 | #include <asm/setup.h> | ||
25 | |||
26 | /* | ||
27 | * We sponge a minor off of the misc major. No need slurping | ||
28 | * up another valuable major dev number for this. If you add | ||
29 | * an ioctl, make sure you don't conflict with SPARC's RTC | ||
30 | * ioctls. | ||
31 | */ | ||
32 | |||
33 | #define BCD2BIN(val) (((val)&15) + ((val)>>4)*10) | ||
34 | #define BIN2BCD(val) ((((val)/10)<<4) + (val)%10) | ||
35 | |||
36 | static const unsigned char days_in_mo[] = | ||
37 | {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; | ||
38 | |||
39 | static atomic_t rtc_ready = ATOMIC_INIT(1); | ||
40 | |||
41 | static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd, | ||
42 | unsigned long arg) | ||
43 | { | ||
44 | volatile MK48T08ptr_t rtc = (MK48T08ptr_t)MVME_RTC_BASE; | ||
45 | unsigned long flags; | ||
46 | struct rtc_time wtime; | ||
47 | |||
48 | switch (cmd) { | ||
49 | case RTC_RD_TIME: /* Read the time/date from RTC */ | ||
50 | { | ||
51 | local_irq_save(flags); | ||
52 | /* Ensure clock and real-time-mode-register are accessible */ | ||
53 | rtc->ctrl = RTC_READ; | ||
54 | memset(&wtime, 0, sizeof(struct rtc_time)); | ||
55 | wtime.tm_sec = BCD2BIN(rtc->bcd_sec); | ||
56 | wtime.tm_min = BCD2BIN(rtc->bcd_min); | ||
57 | wtime.tm_hour = BCD2BIN(rtc->bcd_hr); | ||
58 | wtime.tm_mday = BCD2BIN(rtc->bcd_dom); | ||
59 | wtime.tm_mon = BCD2BIN(rtc->bcd_mth)-1; | ||
60 | wtime.tm_year = BCD2BIN(rtc->bcd_year); | ||
61 | if (wtime.tm_year < 70) | ||
62 | wtime.tm_year += 100; | ||
63 | wtime.tm_wday = BCD2BIN(rtc->bcd_dow)-1; | ||
64 | rtc->ctrl = 0; | ||
65 | local_irq_restore(flags); | ||
66 | return copy_to_user((void *)arg, &wtime, sizeof wtime) ? | ||
67 | -EFAULT : 0; | ||
68 | } | ||
69 | case RTC_SET_TIME: /* Set the RTC */ | ||
70 | { | ||
71 | struct rtc_time rtc_tm; | ||
72 | unsigned char mon, day, hrs, min, sec, leap_yr; | ||
73 | unsigned int yrs; | ||
74 | |||
75 | if (!capable(CAP_SYS_ADMIN)) | ||
76 | return -EACCES; | ||
77 | |||
78 | if (copy_from_user(&rtc_tm, (struct rtc_time*)arg, | ||
79 | sizeof(struct rtc_time))) | ||
80 | return -EFAULT; | ||
81 | |||
82 | yrs = rtc_tm.tm_year; | ||
83 | if (yrs < 1900) | ||
84 | yrs += 1900; | ||
85 | mon = rtc_tm.tm_mon + 1; /* tm_mon starts at zero */ | ||
86 | day = rtc_tm.tm_mday; | ||
87 | hrs = rtc_tm.tm_hour; | ||
88 | min = rtc_tm.tm_min; | ||
89 | sec = rtc_tm.tm_sec; | ||
90 | |||
91 | leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400)); | ||
92 | |||
93 | if ((mon > 12) || (day == 0)) | ||
94 | return -EINVAL; | ||
95 | |||
96 | if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr))) | ||
97 | return -EINVAL; | ||
98 | |||
99 | if ((hrs >= 24) || (min >= 60) || (sec >= 60)) | ||
100 | return -EINVAL; | ||
101 | |||
102 | if (yrs >= 2070) | ||
103 | return -EINVAL; | ||
104 | |||
105 | local_irq_save(flags); | ||
106 | rtc->ctrl = RTC_WRITE; | ||
107 | |||
108 | rtc->bcd_sec = BIN2BCD(sec); | ||
109 | rtc->bcd_min = BIN2BCD(min); | ||
110 | rtc->bcd_hr = BIN2BCD(hrs); | ||
111 | rtc->bcd_dom = BIN2BCD(day); | ||
112 | rtc->bcd_mth = BIN2BCD(mon); | ||
113 | rtc->bcd_year = BIN2BCD(yrs%100); | ||
114 | |||
115 | rtc->ctrl = 0; | ||
116 | local_irq_restore(flags); | ||
117 | return 0; | ||
118 | } | ||
119 | default: | ||
120 | return -EINVAL; | ||
121 | } | ||
122 | } | ||
123 | |||
124 | /* | ||
125 | * We enforce only one user at a time here with the open/close. | ||
126 | * Also clear the previous interrupt data on an open, and clean | ||
127 | * up things on a close. | ||
128 | */ | ||
129 | |||
130 | static int rtc_open(struct inode *inode, struct file *file) | ||
131 | { | ||
132 | if( !atomic_dec_and_test(&rtc_ready) ) | ||
133 | { | ||
134 | atomic_inc( &rtc_ready ); | ||
135 | return -EBUSY; | ||
136 | } | ||
137 | |||
138 | return 0; | ||
139 | } | ||
140 | |||
141 | static int rtc_release(struct inode *inode, struct file *file) | ||
142 | { | ||
143 | atomic_inc( &rtc_ready ); | ||
144 | return 0; | ||
145 | } | ||
146 | |||
147 | /* | ||
148 | * The various file operations we support. | ||
149 | */ | ||
150 | |||
151 | static struct file_operations rtc_fops = { | ||
152 | .ioctl = rtc_ioctl, | ||
153 | .open = rtc_open, | ||
154 | .release = rtc_release, | ||
155 | }; | ||
156 | |||
157 | static struct miscdevice rtc_dev= | ||
158 | { | ||
159 | .minor = RTC_MINOR, | ||
160 | .name = "rtc", | ||
161 | .fops = &rtc_fops | ||
162 | }; | ||
163 | |||
164 | int __init rtc_MK48T08_init(void) | ||
165 | { | ||
166 | if (!MACH_IS_MVME16x) | ||
167 | return -ENODEV; | ||
168 | |||
169 | printk(KERN_INFO "MK48T08 Real Time Clock Driver v%s\n", RTC_VERSION); | ||
170 | return misc_register(&rtc_dev); | ||
171 | } | ||
172 | |||