blob: 593bb033a3fafac6b40cc5b5369b7299264900ae [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001
2/* Linux driver for Disk-On-Chip devices */
3/* Probe routines common to all DoC devices */
4/* (C) 1999 Machine Vision Holdings, Inc. */
5/* (C) 1999-2003 David Woodhouse <dwmw2@infradead.org> */
6
Thomas Gleixnere5580fb2005-11-07 11:15:40 +00007/* $Id: docprobe.c,v 1.46 2005/11/07 11:14:25 gleixner Exp $ */
Linus Torvalds1da177e2005-04-16 15:20:36 -07008
9
10
11/* DOC_PASSIVE_PROBE:
Thomas Gleixnere5580fb2005-11-07 11:15:40 +000012 In order to ensure that the BIOS checksum is correct at boot time, and
13 hence that the onboard BIOS extension gets executed, the DiskOnChip
14 goes into reset mode when it is read sequentially: all registers
15 return 0xff until the chip is woken up again by writing to the
16 DOCControl register.
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
Thomas Gleixnere5580fb2005-11-07 11:15:40 +000018 Unfortunately, this means that the probe for the DiskOnChip is unsafe,
19 because one of the first things it does is write to where it thinks
20 the DOCControl register should be - which may well be shared memory
21 for another device. I've had machines which lock up when this is
22 attempted. Hence the possibility to do a passive probe, which will fail
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 to detect a chip in reset mode, but is at least guaranteed not to lock
24 the machine.
25
26 If you have this problem, uncomment the following line:
27#define DOC_PASSIVE_PROBE
28*/
29
30
31/* DOC_SINGLE_DRIVER:
32 Millennium driver has been merged into DOC2000 driver.
33
34 The old Millennium-only driver has been retained just in case there
35 are problems with the new code. If the combined driver doesn't work
Thomas Gleixnere5580fb2005-11-07 11:15:40 +000036 for you, you can try the old one by undefining DOC_SINGLE_DRIVER
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 below and also enabling it in your configuration. If this fixes the
Thomas Gleixnere5580fb2005-11-07 11:15:40 +000038 problems, please send a report to the MTD mailing list at
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 <linux-mtd@lists.infradead.org>.
40*/
41#define DOC_SINGLE_DRIVER
42
43#include <linux/config.h>
44#include <linux/kernel.h>
45#include <linux/module.h>
46#include <asm/errno.h>
47#include <asm/io.h>
48#include <linux/delay.h>
49#include <linux/slab.h>
50#include <linux/init.h>
51#include <linux/types.h>
52
53#include <linux/mtd/mtd.h>
54#include <linux/mtd/nand.h>
55#include <linux/mtd/doc2000.h>
56#include <linux/mtd/compatmac.h>
57
58/* Where to look for the devices? */
59#ifndef CONFIG_MTD_DOCPROBE_ADDRESS
60#define CONFIG_MTD_DOCPROBE_ADDRESS 0
61#endif
62
63
64static unsigned long doc_config_location = CONFIG_MTD_DOCPROBE_ADDRESS;
65module_param(doc_config_location, ulong, 0);
66MODULE_PARM_DESC(doc_config_location, "Physical memory address at which to probe for DiskOnChip");
67
68static unsigned long __initdata doc_locations[] = {
69#if defined (__alpha__) || defined(__i386__) || defined(__x86_64__)
70#ifdef CONFIG_MTD_DOCPROBE_HIGH
Thomas Gleixnere5580fb2005-11-07 11:15:40 +000071 0xfffc8000, 0xfffca000, 0xfffcc000, 0xfffce000,
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 0xfffd0000, 0xfffd2000, 0xfffd4000, 0xfffd6000,
Thomas Gleixnere5580fb2005-11-07 11:15:40 +000073 0xfffd8000, 0xfffda000, 0xfffdc000, 0xfffde000,
74 0xfffe0000, 0xfffe2000, 0xfffe4000, 0xfffe6000,
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 0xfffe8000, 0xfffea000, 0xfffec000, 0xfffee000,
76#else /* CONFIG_MTD_DOCPROBE_HIGH */
Thomas Gleixnere5580fb2005-11-07 11:15:40 +000077 0xc8000, 0xca000, 0xcc000, 0xce000,
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 0xd0000, 0xd2000, 0xd4000, 0xd6000,
Thomas Gleixnere5580fb2005-11-07 11:15:40 +000079 0xd8000, 0xda000, 0xdc000, 0xde000,
80 0xe0000, 0xe2000, 0xe4000, 0xe6000,
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 0xe8000, 0xea000, 0xec000, 0xee000,
82#endif /* CONFIG_MTD_DOCPROBE_HIGH */
83#elif defined(__PPC__)
84 0xe4000000,
85#elif defined(CONFIG_MOMENCO_OCELOT)
86 0x2f000000,
87 0xff000000,
88#elif defined(CONFIG_MOMENCO_OCELOT_G) || defined (CONFIG_MOMENCO_OCELOT_C)
89 0xff000000,
90##else
91#warning Unknown architecture for DiskOnChip. No default probe locations defined
92#endif
93 0xffffffff };
94
95/* doccheck: Probe a given memory window to see if there's a DiskOnChip present */
96
97static inline int __init doccheck(void __iomem *potential, unsigned long physadr)
98{
99 void __iomem *window=potential;
100 unsigned char tmp, tmpb, tmpc, ChipID;
101#ifndef DOC_PASSIVE_PROBE
102 unsigned char tmp2;
103#endif
104
105 /* Routine copied from the Linux DOC driver */
106
107#ifdef CONFIG_MTD_DOCPROBE_55AA
108 /* Check for 0x55 0xAA signature at beginning of window,
109 this is no longer true once we remove the IPL (for Millennium */
110 if (ReadDOC(window, Sig1) != 0x55 || ReadDOC(window, Sig2) != 0xaa)
111 return 0;
112#endif /* CONFIG_MTD_DOCPROBE_55AA */
113
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000114#ifndef DOC_PASSIVE_PROBE
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 /* It's not possible to cleanly detect the DiskOnChip - the
116 * bootup procedure will put the device into reset mode, and
117 * it's not possible to talk to it without actually writing
118 * to the DOCControl register. So we store the current contents
119 * of the DOCControl register's location, in case we later decide
120 * that it's not a DiskOnChip, and want to put it back how we
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000121 * found it.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 */
123 tmp2 = ReadDOC(window, DOCControl);
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000124
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 /* Reset the DiskOnChip ASIC */
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000126 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 window, DOCControl);
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000128 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 window, DOCControl);
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000130
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 /* Enable the DiskOnChip ASIC */
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000132 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 window, DOCControl);
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000134 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 window, DOCControl);
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000136#endif /* !DOC_PASSIVE_PROBE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
138 /* We need to read the ChipID register four times. For some
139 newer DiskOnChip 2000 units, the first three reads will
140 return the DiskOnChip Millennium ident. Don't ask. */
141 ChipID = ReadDOC(window, ChipID);
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000142
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 switch (ChipID) {
144 case DOC_ChipID_Doc2k:
145 /* Check the TOGGLE bit in the ECC register */
146 tmp = ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT;
147 tmpb = ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT;
148 tmpc = ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT;
149 if (tmp != tmpb && tmp == tmpc)
150 return ChipID;
151 break;
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 case DOC_ChipID_DocMil:
154 /* Check for the new 2000 with Millennium ASIC */
155 ReadDOC(window, ChipID);
156 ReadDOC(window, ChipID);
157 if (ReadDOC(window, ChipID) != DOC_ChipID_DocMil)
158 ChipID = DOC_ChipID_Doc2kTSOP;
159
160 /* Check the TOGGLE bit in the ECC register */
161 tmp = ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT;
162 tmpb = ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT;
163 tmpc = ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT;
164 if (tmp != tmpb && tmp == tmpc)
165 return ChipID;
166 break;
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000167
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 case DOC_ChipID_DocMilPlus16:
169 case DOC_ChipID_DocMilPlus32:
170 case 0:
171 /* Possible Millennium+, need to do more checks */
172#ifndef DOC_PASSIVE_PROBE
173 /* Possibly release from power down mode */
174 for (tmp = 0; (tmp < 4); tmp++)
175 ReadDOC(window, Mplus_Power);
176
177 /* Reset the DiskOnChip ASIC */
178 tmp = DOC_MODE_RESET | DOC_MODE_MDWREN | DOC_MODE_RST_LAT |
179 DOC_MODE_BDECT;
180 WriteDOC(tmp, window, Mplus_DOCControl);
181 WriteDOC(~tmp, window, Mplus_CtrlConfirm);
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000182
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 mdelay(1);
184 /* Enable the DiskOnChip ASIC */
185 tmp = DOC_MODE_NORMAL | DOC_MODE_MDWREN | DOC_MODE_RST_LAT |
186 DOC_MODE_BDECT;
187 WriteDOC(tmp, window, Mplus_DOCControl);
188 WriteDOC(~tmp, window, Mplus_CtrlConfirm);
189 mdelay(1);
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000190#endif /* !DOC_PASSIVE_PROBE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
192 ChipID = ReadDOC(window, ChipID);
193
194 switch (ChipID) {
195 case DOC_ChipID_DocMilPlus16:
196 case DOC_ChipID_DocMilPlus32:
197 /* Check the TOGGLE bit in the toggle register */
198 tmp = ReadDOC(window, Mplus_Toggle) & DOC_TOGGLE_BIT;
199 tmpb = ReadDOC(window, Mplus_Toggle) & DOC_TOGGLE_BIT;
200 tmpc = ReadDOC(window, Mplus_Toggle) & DOC_TOGGLE_BIT;
201 if (tmp != tmpb && tmp == tmpc)
202 return ChipID;
203 default:
204 break;
205 }
206 /* FALL TRHU */
207
208 default:
209
210#ifdef CONFIG_MTD_DOCPROBE_55AA
211 printk(KERN_DEBUG "Possible DiskOnChip with unknown ChipID %2.2X found at 0x%lx\n",
212 ChipID, physadr);
213#endif
214#ifndef DOC_PASSIVE_PROBE
215 /* Put back the contents of the DOCControl register, in case it's not
216 * actually a DiskOnChip.
217 */
218 WriteDOC(tmp2, window, DOCControl);
219#endif
220 return 0;
221 }
222
223 printk(KERN_WARNING "DiskOnChip failed TOGGLE test, dropping.\n");
224
225#ifndef DOC_PASSIVE_PROBE
226 /* Put back the contents of the DOCControl register: it's not a DiskOnChip */
227 WriteDOC(tmp2, window, DOCControl);
228#endif
229 return 0;
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000230}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
232static int docfound;
233
David Woodhouse396674e2006-05-08 17:10:11 +0100234extern void DoC2k_init(struct mtd_info *);
David Woodhouse396674e2006-05-08 17:10:11 +0100235extern void DoCMil_init(struct mtd_info *);
David Woodhouse396674e2006-05-08 17:10:11 +0100236extern void DoCMilPlus_init(struct mtd_info *);
David Woodhouse396674e2006-05-08 17:10:11 +0100237
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238static void __init DoC_Probe(unsigned long physadr)
239{
240 void __iomem *docptr;
241 struct DiskOnChip *this;
242 struct mtd_info *mtd;
243 int ChipID;
244 char namebuf[15];
245 char *name = namebuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 void (*initroutine)(struct mtd_info *) = NULL;
247
248 docptr = ioremap(physadr, DOC_IOREMAP_LEN);
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000249
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 if (!docptr)
251 return;
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000252
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 if ((ChipID = doccheck(docptr, physadr))) {
254 if (ChipID == DOC_ChipID_Doc2kTSOP) {
255 /* Remove this at your own peril. The hardware driver works but nothing prevents you from erasing bad blocks */
256 printk(KERN_NOTICE "Refusing to drive DiskOnChip 2000 TSOP until Bad Block Table is correctly supported by INFTL\n");
257 iounmap(docptr);
258 return;
259 }
260 docfound = 1;
261 mtd = kmalloc(sizeof(struct DiskOnChip) + sizeof(struct mtd_info), GFP_KERNEL);
262
263 if (!mtd) {
264 printk(KERN_WARNING "Cannot allocate memory for data structures. Dropping.\n");
265 iounmap(docptr);
266 return;
267 }
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 this = (struct DiskOnChip *)(&mtd[1]);
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000270
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 memset((char *)mtd,0, sizeof(struct mtd_info));
272 memset((char *)this, 0, sizeof(struct DiskOnChip));
273
274 mtd->priv = this;
275 this->virtadr = docptr;
276 this->physadr = physadr;
277 this->ChipID = ChipID;
278 sprintf(namebuf, "with ChipID %2.2X", ChipID);
279
280 switch(ChipID) {
281 case DOC_ChipID_Doc2kTSOP:
282 name="2000 TSOP";
David Woodhouseecde2632006-05-21 18:38:51 +0100283 initroutine = symbol_request(DoC2k_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 break;
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000285
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 case DOC_ChipID_Doc2k:
287 name="2000";
David Woodhouseecde2632006-05-21 18:38:51 +0100288 initroutine = symbol_request(DoC2k_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 break;
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 case DOC_ChipID_DocMil:
292 name="Millennium";
293#ifdef DOC_SINGLE_DRIVER
David Woodhouseecde2632006-05-21 18:38:51 +0100294 initroutine = symbol_request(DoC2k_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295#else
David Woodhouseecde2632006-05-21 18:38:51 +0100296 initroutine = symbol_request(DoCMil_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297#endif /* DOC_SINGLE_DRIVER */
298 break;
299
300 case DOC_ChipID_DocMilPlus16:
301 case DOC_ChipID_DocMilPlus32:
302 name="MillenniumPlus";
David Woodhouseecde2632006-05-21 18:38:51 +0100303 initroutine = symbol_request(DoCMilPlus_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 break;
305 }
306
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 if (initroutine) {
308 (*initroutine)(mtd);
David Woodhouse5e535422006-05-08 14:05:05 +0100309 symbol_put_addr(initroutine);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 return;
311 }
312 printk(KERN_NOTICE "Cannot find driver for DiskOnChip %s at 0x%lX\n", name, physadr);
313 kfree(mtd);
314 }
315 iounmap(docptr);
316}
317
318
319/****************************************************************************
320 *
321 * Module stuff
322 *
323 ****************************************************************************/
324
325static int __init init_doc(void)
326{
327 int i;
Thomas Gleixnere5580fb2005-11-07 11:15:40 +0000328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 if (doc_config_location) {
330 printk(KERN_INFO "Using configured DiskOnChip probe address 0x%lx\n", doc_config_location);
331 DoC_Probe(doc_config_location);
332 } else {
333 for (i=0; (doc_locations[i] != 0xffffffff); i++) {
334 DoC_Probe(doc_locations[i]);
335 }
336 }
337 /* No banner message any more. Print a message if no DiskOnChip
338 found, so the user knows we at least tried. */
339 if (!docfound)
340 printk(KERN_INFO "No recognised DiskOnChip devices found\n");
341 return -EAGAIN;
342}
343
344module_init(init_doc);
345
346MODULE_LICENSE("GPL");
347MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
348MODULE_DESCRIPTION("Probe code for DiskOnChip 2000 and Millennium devices");
349