SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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/kernel.h>
  44 #include <linux/module.h>
  45 #include <asm/errno.h>
  46 #include <asm/io.h>
  47 #include <linux/delay.h>
  48 #include <linux/slab.h>
  49 #include <linux/init.h>
  50 #include <linux/types.h>
  51
  52 #include <linux/mtd/mtd.h>
  53 #include <linux/mtd/nand.h>
  54 #include <linux/mtd/doc2000.h>
  55 #include <linux/mtd/compatmac.h>
  56
  57 /* Where to look for the devices? */
  58 #ifndef CONFIG_MTD_DOCPROBE_ADDRESS
  59 #define CONFIG_MTD_DOCPROBE_ADDRESS 0
  60 #endif
  61
  62
  63 static unsigned long doc_config_location = CONFIG_MTD_DOCPROBE_ADDRESS;
  64 module_param(doc_config_location, ulong, 0);
  65 MODULE_PARM_DESC(doc_config_location, "Physical memory address at which to probe for DiskOnChip");
  66
  67 static unsigned long __initdata doc_locations[] = {
  68 #if defined (__alpha__) || defined(__i386__) || defined(__x86_64__)
  69 #ifdef CONFIG_MTD_DOCPROBE_HIGH
  70         0xfffc8000, 0xfffca000, 0xfffcc000, 0xfffce000,
  71         0xfffd0000, 0xfffd2000, 0xfffd4000, 0xfffd6000,
  72         0xfffd8000, 0xfffda000, 0xfffdc000, 0xfffde000,
  73         0xfffe0000, 0xfffe2000, 0xfffe4000, 0xfffe6000,
  74         0xfffe8000, 0xfffea000, 0xfffec000, 0xfffee000,
  75 #else /*  CONFIG_MTD_DOCPROBE_HIGH */
  76         0xc8000, 0xca000, 0xcc000, 0xce000,
  77         0xd0000, 0xd2000, 0xd4000, 0xd6000,
  78         0xd8000, 0xda000, 0xdc000, 0xde000,
  79         0xe0000, 0xe2000, 0xe4000, 0xe6000,
  80         0xe8000, 0xea000, 0xec000, 0xee000,
  81 #endif /*  CONFIG_MTD_DOCPROBE_HIGH */
  82 #elif defined(__PPC__)
  83         0xe4000000,
  84 #else
  85 #warning Unknown architecture for DiskOnChip. No default probe locations defined
  86 #endif
  87         0xffffffff };
  88
  89 /* doccheck: Probe a given memory window to see if there's a DiskOnChip present */
  90
  91 static inline int __init doccheck(void __iomem *potential, unsigned long physadr)
  92 {
  93         void __iomem *window=potential;
  94         unsigned char tmp, tmpb, tmpc, ChipID;
  95 #ifndef DOC_PASSIVE_PROBE
  96         unsigned char tmp2;
  97 #endif
  98
  99         /* Routine copied from the Linux DOC driver */
 100
 101 #ifdef CONFIG_MTD_DOCPROBE_55AA
 102         /* Check for 0x55 0xAA signature at beginning of window,
 103            this is no longer true once we remove the IPL (for Millennium */
 104         if (ReadDOC(window, Sig1) != 0x55 || ReadDOC(window, Sig2) != 0xaa)
 105                 return 0;
 106 #endif /* CONFIG_MTD_DOCPROBE_55AA */
 107
 108 #ifndef DOC_PASSIVE_PROBE
 109         /* It's not possible to cleanly detect the DiskOnChip - the
 110          * bootup procedure will put the device into reset mode, and
 111          * it's not possible to talk to it without actually writing
 112          * to the DOCControl register. So we store the current contents
 113          * of the DOCControl register's location, in case we later decide
 114          * that it's not a DiskOnChip, and want to put it back how we
 115          * found it.
 116          */
 117         tmp2 = ReadDOC(window, DOCControl);
 118
 119         /* Reset the DiskOnChip ASIC */
 120         WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
 121                  window, DOCControl);
 122         WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
 123                  window, DOCControl);
 124
 125         /* Enable the DiskOnChip ASIC */
 126         WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
 127                  window, DOCControl);
 128         WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
 129                  window, DOCControl);
 130 #endif /* !DOC_PASSIVE_PROBE */
 131
 132         /* We need to read the ChipID register four times. For some
 133            newer DiskOnChip 2000 units, the first three reads will
 134            return the DiskOnChip Millennium ident. Don't ask. */
 135         ChipID = ReadDOC(window, ChipID);
 136
 137         switch (ChipID) {
 138         case DOC_ChipID_Doc2k:
 139                 /* Check the TOGGLE bit in the ECC register */
 140                 tmp  = ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT;
 141                 tmpb = ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT;
 142                 tmpc = ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT;
 143                 if (tmp != tmpb && tmp == tmpc)
 144                                 return ChipID;
 145                 break;
 146
 147         case DOC_ChipID_DocMil:
 148                 /* Check for the new 2000 with Millennium ASIC */
 149                 ReadDOC(window, ChipID);
 150                 ReadDOC(window, ChipID);
 151                 if (ReadDOC(window, ChipID) != DOC_ChipID_DocMil)
 152                         ChipID = DOC_ChipID_Doc2kTSOP;
 153
 154                 /* Check the TOGGLE bit in the ECC register */
 155                 tmp  = ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT;
 156                 tmpb = ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT;
 157                 tmpc = ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT;
 158                 if (tmp != tmpb && tmp == tmpc)
 159                                 return ChipID;
 160                 break;
 161
 162         case DOC_ChipID_DocMilPlus16:
 163         case DOC_ChipID_DocMilPlus32:
 164         case 0:
 165                 /* Possible Millennium+, need to do more checks */
 166 #ifndef DOC_PASSIVE_PROBE
 167                 /* Possibly release from power down mode */
 168                 for (tmp = 0; (tmp < 4); tmp++)
 169                         ReadDOC(window, Mplus_Power);
 170
 171                 /* Reset the DiskOnChip ASIC */
 172                 tmp = DOC_MODE_RESET | DOC_MODE_MDWREN | DOC_MODE_RST_LAT |
 173                         DOC_MODE_BDECT;
 174                 WriteDOC(tmp, window, Mplus_DOCControl);
 175                 WriteDOC(~tmp, window, Mplus_CtrlConfirm);
 176
 177                 mdelay(1);
 178                 /* Enable the DiskOnChip ASIC */
 179                 tmp = DOC_MODE_NORMAL | DOC_MODE_MDWREN | DOC_MODE_RST_LAT |
 180                         DOC_MODE_BDECT;
 181                 WriteDOC(tmp, window, Mplus_DOCControl);
 182                 WriteDOC(~tmp, window, Mplus_CtrlConfirm);
 183                 mdelay(1);
 184 #endif /* !DOC_PASSIVE_PROBE */
 185
 186                 ChipID = ReadDOC(window, ChipID);
 187
 188                 switch (ChipID) {
 189                 case DOC_ChipID_DocMilPlus16:
 190                 case DOC_ChipID_DocMilPlus32:
 191                         /* Check the TOGGLE bit in the toggle register */
 192                         tmp  = ReadDOC(window, Mplus_Toggle) & DOC_TOGGLE_BIT;
 193                         tmpb = ReadDOC(window, Mplus_Toggle) & DOC_TOGGLE_BIT;
 194                         tmpc = ReadDOC(window, Mplus_Toggle) & DOC_TOGGLE_BIT;
 195                         if (tmp != tmpb && tmp == tmpc)
 196                                         return ChipID;
 197                 default:
 198                         break;
 199                 }
 200                 /* FALL TRHU */
 201
 202         default:
 203
 204 #ifdef CONFIG_MTD_DOCPROBE_55AA
 205                 printk(KERN_DEBUG "Possible DiskOnChip with unknown ChipID %2.2X found at 0x%lx\n",
 206                        ChipID, physadr);
 207 #endif
 208 #ifndef DOC_PASSIVE_PROBE
 209                 /* Put back the contents of the DOCControl register, in case it's not
 210                  * actually a DiskOnChip.
 211                  */
 212                 WriteDOC(tmp2, window, DOCControl);
 213 #endif
 214                 return 0;
 215         }
 216
 217         printk(KERN_WARNING "DiskOnChip failed TOGGLE test, dropping.\n");
 218
 219 #ifndef DOC_PASSIVE_PROBE
 220         /* Put back the contents of the DOCControl register: it's not a DiskOnChip */
 221         WriteDOC(tmp2, window, DOCControl);
 222 #endif
 223         return 0;
 224 }
 225
 226 static int docfound;
 227
 228 extern void DoC2k_init(struct mtd_info *);
 229 extern void DoCMil_init(struct mtd_info *);
 230 extern void DoCMilPlus_init(struct mtd_info *);
 231
 232 static void __init DoC_Probe(unsigned long physadr)
 233 {
 234         void __iomem *docptr;
 235         struct DiskOnChip *this;
 236         struct mtd_info *mtd;
 237         int ChipID;
 238         char namebuf[15];
 239         char *name = namebuf;
 240         void (*initroutine)(struct mtd_info *) = NULL;
 241
 242         docptr = ioremap(physadr, DOC_IOREMAP_LEN);
 243
 244         if (!docptr)
 245                 return;
 246
 247         if ((ChipID = doccheck(docptr, physadr))) {
 248                 if (ChipID == DOC_ChipID_Doc2kTSOP) {
 249                         /* Remove this at your own peril. The hardware driver works but nothing prevents you from erasing bad blocks */
 250                         printk(KERN_NOTICE "Refusing to drive DiskOnChip 2000 TSOP until Bad Block Table is correctly supported by INFTL\n");
 251                         iounmap(docptr);
 252                         return;
 253                 }
 254                 docfound = 1;
 255                 mtd = kmalloc(sizeof(struct DiskOnChip) + sizeof(struct mtd_info), GFP_KERNEL);
 256
 257                 if (!mtd) {
 258                         printk(KERN_WARNING "Cannot allocate memory for data structures. Dropping.\n");
 259                         iounmap(docptr);
 260                         return;
 261                 }
 262
 263                 this = (struct DiskOnChip *)(&mtd[1]);
 264
 265                 memset((char *)mtd,0, sizeof(struct mtd_info));
 266                 memset((char *)this, 0, sizeof(struct DiskOnChip));
 267
 268                 mtd->priv = this;
 269                 this->virtadr = docptr;
 270                 this->physadr = physadr;
 271                 this->ChipID = ChipID;
 272                 sprintf(namebuf, "with ChipID %2.2X", ChipID);
 273
 274                 switch(ChipID) {
 275                 case DOC_ChipID_Doc2kTSOP:
 276                         name="2000 TSOP";
 277                         initroutine = symbol_request(DoC2k_init);
 278                         break;
 279
 280                 case DOC_ChipID_Doc2k:
 281                         name="2000";
 282                         initroutine = symbol_request(DoC2k_init);
 283                         break;
 284
 285                 case DOC_ChipID_DocMil:
 286                         name="Millennium";
 287 #ifdef DOC_SINGLE_DRIVER
 288                         initroutine = symbol_request(DoC2k_init);
 289 #else
 290                         initroutine = symbol_request(DoCMil_init);
 291 #endif /* DOC_SINGLE_DRIVER */
 292                         break;
 293
 294                 case DOC_ChipID_DocMilPlus16:
 295                 case DOC_ChipID_DocMilPlus32:
 296                         name="MillenniumPlus";
 297                         initroutine = symbol_request(DoCMilPlus_init);
 298                         break;
 299                 }
 300
 301                 if (initroutine) {
 302                         (*initroutine)(mtd);
 303                         symbol_put_addr(initroutine);
 304                         return;
 305                 }
 306                 printk(KERN_NOTICE "Cannot find driver for DiskOnChip %s at 0x%lX\n", name, physadr);
 307                 kfree(mtd);
 308         }
 309         iounmap(docptr);
 310 }
 311
 312
 313 /****************************************************************************
 314  *
 315  * Module stuff
 316  *
 317  ****************************************************************************/
 318
 319 static int __init init_doc(void)
 320 {
 321         int i;
 322
 323         if (doc_config_location) {
 324                 printk(KERN_INFO "Using configured DiskOnChip probe address 0x%lx\n", doc_config_location);
 325                 DoC_Probe(doc_config_location);
 326         } else {
 327                 for (i=0; (doc_locations[i] != 0xffffffff); i++) {
 328                         DoC_Probe(doc_locations[i]);
 329                 }
 330         }
 331         /* No banner message any more. Print a message if no DiskOnChip
 332            found, so the user knows we at least tried. */
 333         if (!docfound)
 334                 printk(KERN_INFO "No recognised DiskOnChip devices found\n");
 335         return -EAGAIN;
 336 }
 337
 338 module_init(init_doc);
 339
 340 MODULE_LICENSE("GPL");
 341 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
 342 MODULE_DESCRIPTION("Probe code for DiskOnChip 2000 and Millennium devices");
 343