git-mtd: symbol_get() fix
[linux-2.6.git] / drivers / mtd / devices / docprobe.c
1
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
7 /* $Id: docprobe.c,v 1.46 2005/11/07 11:14:25 gleixner Exp $    */
8
9
10
11 /* DOC_PASSIVE_PROBE:
12    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.
17
18    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
23    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
36    for you, you can try the old one by undefining DOC_SINGLE_DRIVER
37    below and also enabling it in your configuration. If this fixes the
38    problems, please send a report to the MTD mailing list at
39    <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
64 static unsigned long doc_config_location = CONFIG_MTD_DOCPROBE_ADDRESS;
65 module_param(doc_config_location, ulong, 0);
66 MODULE_PARM_DESC(doc_config_location, "Physical memory address at which to probe for DiskOnChip");
67
68 static unsigned long __initdata doc_locations[] = {
69 #if defined (__alpha__) || defined(__i386__) || defined(__x86_64__)
70 #ifdef CONFIG_MTD_DOCPROBE_HIGH
71         0xfffc8000, 0xfffca000, 0xfffcc000, 0xfffce000,
72         0xfffd0000, 0xfffd2000, 0xfffd4000, 0xfffd6000,
73         0xfffd8000, 0xfffda000, 0xfffdc000, 0xfffde000,
74         0xfffe0000, 0xfffe2000, 0xfffe4000, 0xfffe6000,
75         0xfffe8000, 0xfffea000, 0xfffec000, 0xfffee000,
76 #else /*  CONFIG_MTD_DOCPROBE_HIGH */
77         0xc8000, 0xca000, 0xcc000, 0xce000,
78         0xd0000, 0xd2000, 0xd4000, 0xd6000,
79         0xd8000, 0xda000, 0xdc000, 0xde000,
80         0xe0000, 0xe2000, 0xe4000, 0xe6000,
81         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
97 static 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
114 #ifndef DOC_PASSIVE_PROBE
115         /* 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
121          * found it.
122          */
123         tmp2 = ReadDOC(window, DOCControl);
124
125         /* Reset the DiskOnChip ASIC */
126         WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
127                  window, DOCControl);
128         WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
129                  window, DOCControl);
130
131         /* Enable the DiskOnChip ASIC */
132         WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
133                  window, DOCControl);
134         WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
135                  window, DOCControl);
136 #endif /* !DOC_PASSIVE_PROBE */
137
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);
142
143         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;
152
153         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;
167
168         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);
182
183                 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);
190 #endif /* !DOC_PASSIVE_PROBE */
191
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;
230 }
231
232 static int docfound;
233
234 #ifdef CONFIG_MTD_DOC2000
235 extern void DoC2k_init(struct mtd_info *);
236 #define doc2k_initfunc (&DoC2k_init)
237 #else 
238 #define doc2k_initfunc NULL
239 #endif
240
241 #ifdef CONFIG_MTD_DOC2001
242 extern void DoCMil_init(struct mtd_info *);
243 #define docmil_initfunc (&DoCMil_init)
244 #else 
245 #define docmil_initfunc NULL
246 #endif
247
248 #ifdef CONFIG_MTD_DOC2001PLUS
249 extern void DoCMilPlus_init(struct mtd_info *);
250 #define docmplus_initfunc (&DoCMilPlus_init)
251 #else 
252 #define docmplus_initfunc NULL
253 #endif
254
255 static void __init DoC_Probe(unsigned long physadr)
256 {
257         void __iomem *docptr;
258         struct DiskOnChip *this;
259         struct mtd_info *mtd;
260         int ChipID;
261         char namebuf[15];
262         char *name = namebuf;
263         char *im_funcname = NULL;
264         char *im_modname = NULL;
265         void (*initroutine)(struct mtd_info *) = NULL;
266
267         docptr = ioremap(physadr, DOC_IOREMAP_LEN);
268
269         if (!docptr)
270                 return;
271
272         if ((ChipID = doccheck(docptr, physadr))) {
273                 if (ChipID == DOC_ChipID_Doc2kTSOP) {
274                         /* Remove this at your own peril. The hardware driver works but nothing prevents you from erasing bad blocks */
275                         printk(KERN_NOTICE "Refusing to drive DiskOnChip 2000 TSOP until Bad Block Table is correctly supported by INFTL\n");
276                         iounmap(docptr);
277                         return;
278                 }
279                 docfound = 1;
280                 mtd = kmalloc(sizeof(struct DiskOnChip) + sizeof(struct mtd_info), GFP_KERNEL);
281
282                 if (!mtd) {
283                         printk(KERN_WARNING "Cannot allocate memory for data structures. Dropping.\n");
284                         iounmap(docptr);
285                         return;
286                 }
287
288                 this = (struct DiskOnChip *)(&mtd[1]);
289
290                 memset((char *)mtd,0, sizeof(struct mtd_info));
291                 memset((char *)this, 0, sizeof(struct DiskOnChip));
292
293                 mtd->priv = this;
294                 this->virtadr = docptr;
295                 this->physadr = physadr;
296                 this->ChipID = ChipID;
297                 sprintf(namebuf, "with ChipID %2.2X", ChipID);
298
299                 switch(ChipID) {
300                 case DOC_ChipID_Doc2kTSOP:
301                         name="2000 TSOP";
302                         im_funcname = "DoC2k_init";
303                         im_modname = "doc2000";
304                         initroutine = doc2k_initfunc;
305                         break;
306
307                 case DOC_ChipID_Doc2k:
308                         name="2000";
309                         im_funcname = "DoC2k_init";
310                         im_modname = "doc2000";
311                         initroutine = doc2k_initfunc;
312                         break;
313
314                 case DOC_ChipID_DocMil:
315                         name="Millennium";
316 #ifdef DOC_SINGLE_DRIVER
317                         im_funcname = "DoC2k_init";
318                         im_modname = "doc2000";
319                         initroutine = doc2k_initfunc;
320 #else
321                         im_funcname = "DoCMil_init";
322                         im_modname = "doc2001";
323                         initroutine = docmil_initfunc;
324 #endif /* DOC_SINGLE_DRIVER */
325                         break;
326
327                 case DOC_ChipID_DocMilPlus16:
328                 case DOC_ChipID_DocMilPlus32:
329                         name="MillenniumPlus";
330                         im_funcname = "DoCMilPlus_init";
331                         im_modname = "doc2001plus";
332                         initroutine = docmplus_initfunc;
333                         break;
334                 }
335
336 #ifdef CONFIG_MODULES
337                 if (im_funcname && !initroutine)
338                         initroutine = __symbol_get(im_funcname);
339                 if (im_funcname && !initroutine) {
340                         request_module(im_modname);
341                         initroutine = __symbol_get(im_funcname);
342                 }
343 #endif
344                 if (initroutine) {
345                         (*initroutine)(mtd);
346                         symbol_put_addr(initroutine);
347                         return;
348                 }
349                 printk(KERN_NOTICE "Cannot find driver for DiskOnChip %s at 0x%lX\n", name, physadr);
350                 kfree(mtd);
351         }
352         iounmap(docptr);
353 }
354
355
356 /****************************************************************************
357  *
358  * Module stuff
359  *
360  ****************************************************************************/
361
362 static int __init init_doc(void)
363 {
364         int i;
365
366         if (doc_config_location) {
367                 printk(KERN_INFO "Using configured DiskOnChip probe address 0x%lx\n", doc_config_location);
368                 DoC_Probe(doc_config_location);
369         } else {
370                 for (i=0; (doc_locations[i] != 0xffffffff); i++) {
371                         DoC_Probe(doc_locations[i]);
372                 }
373         }
374         /* No banner message any more. Print a message if no DiskOnChip
375            found, so the user knows we at least tried. */
376         if (!docfound)
377                 printk(KERN_INFO "No recognised DiskOnChip devices found\n");
378         return -EAGAIN;
379 }
380
381 module_init(init_doc);
382
383 MODULE_LICENSE("GPL");
384 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
385 MODULE_DESCRIPTION("Probe code for DiskOnChip 2000 and Millennium devices");
386