Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * Written by Martin Kolinek, February 1996 |
| 3 | * |
| 4 | * Changes: |
| 5 | * |
| 6 | * Chris Beauregard July 28th, 1996 |
| 7 | * - Fixed up integrated SCSI detection |
| 8 | * |
| 9 | * Chris Beauregard August 3rd, 1996 |
| 10 | * - Made mca_info local |
| 11 | * - Made integrated registers accessible through standard function calls |
| 12 | * - Added name field |
| 13 | * - More sanity checking |
| 14 | * |
| 15 | * Chris Beauregard August 9th, 1996 |
| 16 | * - Rewrote /proc/mca |
| 17 | * |
| 18 | * Chris Beauregard January 7th, 1997 |
| 19 | * - Added basic NMI-processing |
| 20 | * - Added more information to mca_info structure |
| 21 | * |
| 22 | * David Weinehall October 12th, 1998 |
| 23 | * - Made a lot of cleaning up in the source |
| 24 | * - Added use of save_flags / restore_flags |
| 25 | * - Added the 'driver_loaded' flag in MCA_adapter |
| 26 | * - Added an alternative implemention of ZP Gu's mca_find_unused_adapter |
| 27 | * |
| 28 | * David Weinehall March 24th, 1999 |
| 29 | * - Fixed the output of 'Driver Installed' in /proc/mca/pos |
| 30 | * - Made the Integrated Video & SCSI show up even if they have id 0000 |
| 31 | * |
| 32 | * Alexander Viro November 9th, 1999 |
| 33 | * - Switched to regular procfs methods |
| 34 | * |
| 35 | * Alfred Arnold & David Weinehall August 23rd, 2000 |
| 36 | * - Added support for Planar POS-registers |
| 37 | */ |
| 38 | |
| 39 | #include <linux/module.h> |
| 40 | #include <linux/types.h> |
| 41 | #include <linux/errno.h> |
| 42 | #include <linux/kernel.h> |
| 43 | #include <linux/mca.h> |
Fernando Luis Vázquez Cao | 6f6b1e0 | 2006-09-26 10:52:36 +0200 | [diff] [blame] | 44 | #include <linux/kprobes.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | #include <asm/system.h> |
| 46 | #include <asm/io.h> |
| 47 | #include <linux/proc_fs.h> |
| 48 | #include <linux/mman.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 49 | #include <linux/mm.h> |
| 50 | #include <linux/pagemap.h> |
| 51 | #include <linux/ioport.h> |
| 52 | #include <asm/uaccess.h> |
| 53 | #include <linux/init.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 55 | static unsigned char which_scsi; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 56 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 57 | int MCA_bus; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | EXPORT_SYMBOL(MCA_bus); |
| 59 | |
| 60 | /* |
| 61 | * Motherboard register spinlock. Untested on SMP at the moment, but |
| 62 | * are there any MCA SMP boxes? |
| 63 | * |
| 64 | * Yes - Alan |
| 65 | */ |
| 66 | static DEFINE_SPINLOCK(mca_lock); |
| 67 | |
| 68 | /* Build the status info for the adapter */ |
| 69 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 70 | static void mca_configure_adapter_status(struct mca_device *mca_dev) |
| 71 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | mca_dev->status = MCA_ADAPTER_NONE; |
| 73 | |
| 74 | mca_dev->pos_id = mca_dev->pos[0] |
| 75 | + (mca_dev->pos[1] << 8); |
| 76 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 77 | if (!mca_dev->pos_id && mca_dev->slot < MCA_MAX_SLOT_NR) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 79 | /* |
| 80 | * id = 0x0000 usually indicates hardware failure, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | * however, ZP Gu (zpg@castle.net> reports that his 9556 |
| 82 | * has 0x0000 as id and everything still works. There |
| 83 | * also seem to be an adapter with id = 0x0000; the |
| 84 | * NCR Parallel Bus Memory Card. Until this is confirmed, |
| 85 | * however, this code will stay. |
| 86 | */ |
| 87 | |
| 88 | mca_dev->status = MCA_ADAPTER_ERROR; |
| 89 | |
| 90 | return; |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 91 | } else if (mca_dev->pos_id != 0xffff) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 92 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 93 | /* |
| 94 | * 0xffff usually indicates that there's no adapter, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | * however, some integrated adapters may have 0xffff as |
| 96 | * their id and still be valid. Examples are on-board |
| 97 | * VGA of the 55sx, the integrated SCSI of the 56 & 57, |
| 98 | * and possibly also the 95 ULTIMEDIA. |
| 99 | */ |
| 100 | |
| 101 | mca_dev->status = MCA_ADAPTER_NORMAL; |
| 102 | } |
| 103 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 104 | if ((mca_dev->pos_id == 0xffff || |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | mca_dev->pos_id == 0x0000) && mca_dev->slot >= MCA_MAX_SLOT_NR) { |
| 106 | int j; |
| 107 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 108 | for (j = 2; j < 8; j++) { |
| 109 | if (mca_dev->pos[j] != 0xff) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 110 | mca_dev->status = MCA_ADAPTER_NORMAL; |
| 111 | break; |
| 112 | } |
| 113 | } |
| 114 | } |
| 115 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 116 | if (!(mca_dev->pos[2] & MCA_ENABLED)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | |
| 118 | /* enabled bit is in POS 2 */ |
| 119 | |
| 120 | mca_dev->status = MCA_ADAPTER_DISABLED; |
| 121 | } |
| 122 | } /* mca_configure_adapter_status */ |
| 123 | |
| 124 | /*--------------------------------------------------------------------*/ |
| 125 | |
| 126 | static struct resource mca_standard_resources[] = { |
| 127 | { .start = 0x60, .end = 0x60, .name = "system control port B (MCA)" }, |
| 128 | { .start = 0x90, .end = 0x90, .name = "arbitration (MCA)" }, |
| 129 | { .start = 0x91, .end = 0x91, .name = "card Select Feedback (MCA)" }, |
| 130 | { .start = 0x92, .end = 0x92, .name = "system Control port A (MCA)" }, |
| 131 | { .start = 0x94, .end = 0x94, .name = "system board setup (MCA)" }, |
| 132 | { .start = 0x96, .end = 0x97, .name = "POS (MCA)" }, |
| 133 | { .start = 0x100, .end = 0x107, .name = "POS (MCA)" } |
| 134 | }; |
| 135 | |
Tobias Klauser | 38e548e | 2005-11-07 00:58:31 -0800 | [diff] [blame] | 136 | #define MCA_STANDARD_RESOURCES ARRAY_SIZE(mca_standard_resources) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 137 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 138 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 139 | * mca_read_and_store_pos - read the POS registers into a memory buffer |
| 140 | * @pos: a char pointer to 8 bytes, contains the POS register value on |
| 141 | * successful return |
| 142 | * |
| 143 | * Returns 1 if a card actually exists (i.e. the pos isn't |
| 144 | * all 0xff) or 0 otherwise |
| 145 | */ |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 146 | static int mca_read_and_store_pos(unsigned char *pos) |
| 147 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | int j; |
| 149 | int found = 0; |
| 150 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 151 | for (j = 0; j < 8; j++) { |
| 152 | pos[j] = inb_p(MCA_POS_REG(j)); |
| 153 | if (pos[j] != 0xff) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | /* 0xff all across means no device. 0x00 means |
| 155 | * something's broken, but a device is |
| 156 | * probably there. However, if you get 0x00 |
| 157 | * from a motherboard register it won't matter |
| 158 | * what we find. For the record, on the |
| 159 | * 57SLC, the integrated SCSI adapter has |
| 160 | * 0xffff for the adapter ID, but nonzero for |
| 161 | * other registers. */ |
| 162 | |
| 163 | found = 1; |
| 164 | } |
| 165 | } |
| 166 | return found; |
| 167 | } |
| 168 | |
| 169 | static unsigned char mca_pc_read_pos(struct mca_device *mca_dev, int reg) |
| 170 | { |
| 171 | unsigned char byte; |
| 172 | unsigned long flags; |
| 173 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 174 | if (reg < 0 || reg >= 8) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | return 0; |
| 176 | |
| 177 | spin_lock_irqsave(&mca_lock, flags); |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 178 | if (mca_dev->pos_register) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | /* Disable adapter setup, enable motherboard setup */ |
| 180 | |
| 181 | outb_p(0, MCA_ADAPTER_SETUP_REG); |
| 182 | outb_p(mca_dev->pos_register, MCA_MOTHERBOARD_SETUP_REG); |
| 183 | |
| 184 | byte = inb_p(MCA_POS_REG(reg)); |
| 185 | outb_p(0xff, MCA_MOTHERBOARD_SETUP_REG); |
| 186 | } else { |
| 187 | |
| 188 | /* Make sure motherboard setup is off */ |
| 189 | |
| 190 | outb_p(0xff, MCA_MOTHERBOARD_SETUP_REG); |
| 191 | |
| 192 | /* Read the appropriate register */ |
| 193 | |
| 194 | outb_p(0x8|(mca_dev->slot & 0xf), MCA_ADAPTER_SETUP_REG); |
| 195 | byte = inb_p(MCA_POS_REG(reg)); |
| 196 | outb_p(0, MCA_ADAPTER_SETUP_REG); |
| 197 | } |
| 198 | spin_unlock_irqrestore(&mca_lock, flags); |
| 199 | |
| 200 | mca_dev->pos[reg] = byte; |
| 201 | |
| 202 | return byte; |
| 203 | } |
| 204 | |
| 205 | static void mca_pc_write_pos(struct mca_device *mca_dev, int reg, |
| 206 | unsigned char byte) |
| 207 | { |
| 208 | unsigned long flags; |
| 209 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 210 | if (reg < 0 || reg >= 8) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | return; |
| 212 | |
| 213 | spin_lock_irqsave(&mca_lock, flags); |
| 214 | |
| 215 | /* Make sure motherboard setup is off */ |
| 216 | |
| 217 | outb_p(0xff, MCA_MOTHERBOARD_SETUP_REG); |
| 218 | |
| 219 | /* Read in the appropriate register */ |
| 220 | |
| 221 | outb_p(0x8|(mca_dev->slot&0xf), MCA_ADAPTER_SETUP_REG); |
| 222 | outb_p(byte, MCA_POS_REG(reg)); |
| 223 | outb_p(0, MCA_ADAPTER_SETUP_REG); |
| 224 | |
| 225 | spin_unlock_irqrestore(&mca_lock, flags); |
| 226 | |
| 227 | /* Update the global register list, while we have the byte */ |
| 228 | |
| 229 | mca_dev->pos[reg] = byte; |
| 230 | |
| 231 | } |
| 232 | |
| 233 | /* for the primary MCA bus, we have identity transforms */ |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 234 | static int mca_dummy_transform_irq(struct mca_device *mca_dev, int irq) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 235 | { |
| 236 | return irq; |
| 237 | } |
| 238 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 239 | static int mca_dummy_transform_ioport(struct mca_device *mca_dev, int port) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 240 | { |
| 241 | return port; |
| 242 | } |
| 243 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 244 | static void *mca_dummy_transform_memory(struct mca_device *mca_dev, void *mem) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 245 | { |
| 246 | return mem; |
| 247 | } |
| 248 | |
| 249 | |
| 250 | static int __init mca_init(void) |
| 251 | { |
| 252 | unsigned int i, j; |
| 253 | struct mca_device *mca_dev; |
| 254 | unsigned char pos[8]; |
| 255 | short mca_builtin_scsi_ports[] = {0xf7, 0xfd, 0x00}; |
| 256 | struct mca_bus *bus; |
| 257 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 258 | /* |
| 259 | * WARNING: Be careful when making changes here. Putting an adapter |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | * and the motherboard simultaneously into setup mode may result in |
| 261 | * damage to chips (according to The Indispensible PC Hardware Book |
| 262 | * by Hans-Peter Messmer). Also, we disable system interrupts (so |
| 263 | * that we are not disturbed in the middle of this). |
| 264 | */ |
| 265 | |
| 266 | /* Make sure the MCA bus is present */ |
| 267 | |
| 268 | if (mca_system_init()) { |
| 269 | printk(KERN_ERR "MCA bus system initialisation failed\n"); |
| 270 | return -ENODEV; |
| 271 | } |
| 272 | |
| 273 | if (!MCA_bus) |
| 274 | return -ENODEV; |
| 275 | |
| 276 | printk(KERN_INFO "Micro Channel bus detected.\n"); |
| 277 | |
| 278 | /* All MCA systems have at least a primary bus */ |
| 279 | bus = mca_attach_bus(MCA_PRIMARY_BUS); |
| 280 | if (!bus) |
| 281 | goto out_nomem; |
| 282 | bus->default_dma_mask = 0xffffffffLL; |
| 283 | bus->f.mca_write_pos = mca_pc_write_pos; |
| 284 | bus->f.mca_read_pos = mca_pc_read_pos; |
| 285 | bus->f.mca_transform_irq = mca_dummy_transform_irq; |
| 286 | bus->f.mca_transform_ioport = mca_dummy_transform_ioport; |
| 287 | bus->f.mca_transform_memory = mca_dummy_transform_memory; |
| 288 | |
| 289 | /* get the motherboard device */ |
Burman Yan | 116780f | 2006-12-07 02:14:19 +0100 | [diff] [blame] | 290 | mca_dev = kzalloc(sizeof(struct mca_device), GFP_KERNEL); |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 291 | if (unlikely(!mca_dev)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | goto out_nomem; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 293 | |
| 294 | /* |
| 295 | * We do not expect many MCA interrupts during initialization, |
| 296 | * but let us be safe: |
| 297 | */ |
| 298 | spin_lock_irq(&mca_lock); |
| 299 | |
| 300 | /* Make sure adapter setup is off */ |
| 301 | |
| 302 | outb_p(0, MCA_ADAPTER_SETUP_REG); |
| 303 | |
| 304 | /* Read motherboard POS registers */ |
| 305 | |
| 306 | mca_dev->pos_register = 0x7f; |
| 307 | outb_p(mca_dev->pos_register, MCA_MOTHERBOARD_SETUP_REG); |
| 308 | mca_dev->name[0] = 0; |
| 309 | mca_read_and_store_pos(mca_dev->pos); |
| 310 | mca_configure_adapter_status(mca_dev); |
| 311 | /* fake POS and slot for a motherboard */ |
| 312 | mca_dev->pos_id = MCA_MOTHERBOARD_POS; |
| 313 | mca_dev->slot = MCA_MOTHERBOARD; |
| 314 | mca_register_device(MCA_PRIMARY_BUS, mca_dev); |
| 315 | |
Burman Yan | 116780f | 2006-12-07 02:14:19 +0100 | [diff] [blame] | 316 | mca_dev = kzalloc(sizeof(struct mca_device), GFP_ATOMIC); |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 317 | if (unlikely(!mca_dev)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 318 | goto out_unlock_nomem; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | |
| 320 | /* Put motherboard into video setup mode, read integrated video |
| 321 | * POS registers, and turn motherboard setup off. |
| 322 | */ |
| 323 | |
| 324 | mca_dev->pos_register = 0xdf; |
| 325 | outb_p(mca_dev->pos_register, MCA_MOTHERBOARD_SETUP_REG); |
| 326 | mca_dev->name[0] = 0; |
| 327 | mca_read_and_store_pos(mca_dev->pos); |
| 328 | mca_configure_adapter_status(mca_dev); |
| 329 | /* fake POS and slot for the integrated video */ |
| 330 | mca_dev->pos_id = MCA_INTEGVIDEO_POS; |
| 331 | mca_dev->slot = MCA_INTEGVIDEO; |
| 332 | mca_register_device(MCA_PRIMARY_BUS, mca_dev); |
| 333 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 334 | /* |
| 335 | * Put motherboard into scsi setup mode, read integrated scsi |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 336 | * POS registers, and turn motherboard setup off. |
| 337 | * |
| 338 | * It seems there are two possible SCSI registers. Martin says that |
| 339 | * for the 56,57, 0xf7 is the one, but fails on the 76. |
| 340 | * Alfredo (apena@vnet.ibm.com) says |
| 341 | * 0xfd works on his machine. We'll try both of them. I figure it's |
| 342 | * a good bet that only one could be valid at a time. This could |
| 343 | * screw up though if one is used for something else on the other |
| 344 | * machine. |
| 345 | */ |
| 346 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 347 | for (i = 0; (which_scsi = mca_builtin_scsi_ports[i]) != 0; i++) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | outb_p(which_scsi, MCA_MOTHERBOARD_SETUP_REG); |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 349 | if (mca_read_and_store_pos(pos)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 350 | break; |
| 351 | } |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 352 | if (which_scsi) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 353 | /* found a scsi card */ |
Burman Yan | 116780f | 2006-12-07 02:14:19 +0100 | [diff] [blame] | 354 | mca_dev = kzalloc(sizeof(struct mca_device), GFP_ATOMIC); |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 355 | if (unlikely(!mca_dev)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 356 | goto out_unlock_nomem; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 357 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 358 | for (j = 0; j < 8; j++) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 359 | mca_dev->pos[j] = pos[j]; |
| 360 | |
| 361 | mca_configure_adapter_status(mca_dev); |
| 362 | /* fake POS and slot for integrated SCSI controller */ |
| 363 | mca_dev->pos_id = MCA_INTEGSCSI_POS; |
| 364 | mca_dev->slot = MCA_INTEGSCSI; |
| 365 | mca_dev->pos_register = which_scsi; |
| 366 | mca_register_device(MCA_PRIMARY_BUS, mca_dev); |
| 367 | } |
| 368 | |
| 369 | /* Turn off motherboard setup */ |
| 370 | |
| 371 | outb_p(0xff, MCA_MOTHERBOARD_SETUP_REG); |
| 372 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 373 | /* |
| 374 | * Now loop over MCA slots: put each adapter into setup mode, and |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 375 | * read its POS registers. Then put adapter setup off. |
| 376 | */ |
| 377 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 378 | for (i = 0; i < MCA_MAX_SLOT_NR; i++) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 379 | outb_p(0x8|(i&0xf), MCA_ADAPTER_SETUP_REG); |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 380 | if (!mca_read_and_store_pos(pos)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 381 | continue; |
| 382 | |
Burman Yan | 116780f | 2006-12-07 02:14:19 +0100 | [diff] [blame] | 383 | mca_dev = kzalloc(sizeof(struct mca_device), GFP_ATOMIC); |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 384 | if (unlikely(!mca_dev)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 385 | goto out_unlock_nomem; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 386 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 387 | for (j = 0; j < 8; j++) |
| 388 | mca_dev->pos[j] = pos[j]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 389 | |
| 390 | mca_dev->driver_loaded = 0; |
| 391 | mca_dev->slot = i; |
| 392 | mca_dev->pos_register = 0; |
| 393 | mca_configure_adapter_status(mca_dev); |
| 394 | mca_register_device(MCA_PRIMARY_BUS, mca_dev); |
| 395 | } |
| 396 | outb_p(0, MCA_ADAPTER_SETUP_REG); |
| 397 | |
| 398 | /* Enable interrupts and return memory start */ |
| 399 | spin_unlock_irq(&mca_lock); |
| 400 | |
| 401 | for (i = 0; i < MCA_STANDARD_RESOURCES; i++) |
| 402 | request_resource(&ioport_resource, mca_standard_resources + i); |
| 403 | |
| 404 | mca_do_proc_init(); |
| 405 | |
| 406 | return 0; |
| 407 | |
| 408 | out_unlock_nomem: |
| 409 | spin_unlock_irq(&mca_lock); |
| 410 | out_nomem: |
| 411 | printk(KERN_EMERG "Failed memory allocation in MCA setup!\n"); |
| 412 | return -ENOMEM; |
| 413 | } |
| 414 | |
| 415 | subsys_initcall(mca_init); |
| 416 | |
| 417 | /*--------------------------------------------------------------------*/ |
| 418 | |
Fernando Luis Vázquez Cao | 6f6b1e0 | 2006-09-26 10:52:36 +0200 | [diff] [blame] | 419 | static __kprobes void |
| 420 | mca_handle_nmi_device(struct mca_device *mca_dev, int check_flag) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 421 | { |
| 422 | int slot = mca_dev->slot; |
| 423 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 424 | if (slot == MCA_INTEGSCSI) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 425 | printk(KERN_CRIT "NMI: caused by MCA integrated SCSI adapter (%s)\n", |
| 426 | mca_dev->name); |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 427 | } else if (slot == MCA_INTEGVIDEO) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 428 | printk(KERN_CRIT "NMI: caused by MCA integrated video adapter (%s)\n", |
| 429 | mca_dev->name); |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 430 | } else if (slot == MCA_MOTHERBOARD) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 431 | printk(KERN_CRIT "NMI: caused by motherboard (%s)\n", |
| 432 | mca_dev->name); |
| 433 | } |
| 434 | |
| 435 | /* More info available in POS 6 and 7? */ |
| 436 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 437 | if (check_flag) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 438 | unsigned char pos6, pos7; |
| 439 | |
| 440 | pos6 = mca_device_read_pos(mca_dev, 6); |
| 441 | pos7 = mca_device_read_pos(mca_dev, 7); |
| 442 | |
| 443 | printk(KERN_CRIT "NMI: POS 6 = 0x%x, POS 7 = 0x%x\n", pos6, pos7); |
| 444 | } |
| 445 | |
| 446 | } /* mca_handle_nmi_slot */ |
| 447 | |
| 448 | /*--------------------------------------------------------------------*/ |
| 449 | |
Fernando Luis Vázquez Cao | 6f6b1e0 | 2006-09-26 10:52:36 +0200 | [diff] [blame] | 450 | static int __kprobes mca_handle_nmi_callback(struct device *dev, void *data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 451 | { |
| 452 | struct mca_device *mca_dev = to_mca_device(dev); |
| 453 | unsigned char pos5; |
| 454 | |
| 455 | pos5 = mca_device_read_pos(mca_dev, 5); |
| 456 | |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 457 | if (!(pos5 & 0x80)) { |
| 458 | /* |
| 459 | * Bit 7 of POS 5 is reset when this adapter has a hardware |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 460 | * error. Bit 7 it reset if there's error information |
| 461 | * available in POS 6 and 7. |
| 462 | */ |
| 463 | mca_handle_nmi_device(mca_dev, !(pos5 & 0x40)); |
| 464 | return 1; |
| 465 | } |
| 466 | return 0; |
| 467 | } |
| 468 | |
Fernando Luis Vázquez Cao | 6f6b1e0 | 2006-09-26 10:52:36 +0200 | [diff] [blame] | 469 | void __kprobes mca_handle_nmi(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 470 | { |
Paolo Ciarrocchi | 0067cc9 | 2008-02-22 23:10:06 +0100 | [diff] [blame] | 471 | /* |
| 472 | * First try - scan the various adapters and see if a specific |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 473 | * adapter was responsible for the error. |
| 474 | */ |
| 475 | bus_for_each_dev(&mca_bus_type, NULL, NULL, mca_handle_nmi_callback); |
Ingo Molnar | d85a881 | 2009-02-23 00:29:45 +0100 | [diff] [blame] | 476 | } |